From de8e96f91c9f9279492c2412bd7985592c78a9b1 Mon Sep 17 00:00:00 2001
From: Kevin Malakoff <kmalakoff@gmail.com>
Date: Wed, 9 Sep 2015 10:08:50 -0700
Subject: [PATCH] Update Knockback to 1.0.0 and simplified.

---
 examples/knockback/.gitignore                 |   23 +-
 examples/knockback/index.html                 |   34 +-
 .../js/lib/knockout-extended-bindings.js      |   30 -
 examples/knockback/js/models/todo.js          |   26 -
 .../knockback/js/models/todo_collection.js    |   39 +-
 examples/knockback/js/viewmodels/app.js       |  225 +-
 examples/knockback/js/viewmodels/todo.js      |  128 +-
 .../node_modules/backbone/backbone.js         | 1148 ++--
 .../node_modules/jquery/dist/jquery.js        |   13 +-
 .../node_modules/knockback/knockback.js       | 4977 +++++++++--------
 .../node_modules/backbone/backbone.js         | 1608 ------
 .../node_modules/underscore/underscore.js     | 1415 -----
 .../build/output/knockout-latest.debug.js     |  612 +-
 .../node_modules/todomvc-app-css/index.css    |  102 +-
 .../node_modules/todomvc-common/base.js       |    9 +-
 examples/knockback/package.json               |   13 +-
 .../src/lib/knockout-extended-bindings.coffee |   15 -
 examples/knockback/src/models/todo.coffee     |    5 -
 .../src/models/todo_collection.coffee         |   11 -
 examples/knockback/src/viewmodels/app.coffee  |  100 +-
 examples/knockback/src/viewmodels/todo.coffee |   45 +-
 21 files changed, 3968 insertions(+), 6610 deletions(-)
 delete mode 100644 examples/knockback/js/lib/knockout-extended-bindings.js
 delete mode 100644 examples/knockback/js/models/todo.js
 delete mode 100644 examples/knockback/node_modules/knockback/node_modules/backbone/backbone.js
 delete mode 100644 examples/knockback/node_modules/knockback/node_modules/underscore/underscore.js
 rename examples/knockback/node_modules/{knockback/node_modules => }/knockout/build/output/knockout-latest.debug.js (92%)
 delete mode 100644 examples/knockback/src/lib/knockout-extended-bindings.coffee
 delete mode 100644 examples/knockback/src/models/todo.coffee
diff --git a/examples/knockback/.gitignore b/examples/knockback/.gitignore
index 5a1e3a5299..edc511ad89 100644
--- a/examples/knockback/.gitignore
+++ b/examples/knockback/.gitignore
@@ -2,18 +2,21 @@ node_modules/knockback/*
 !node_modules/knockback/knockback.js
 !node_modules/knockback/node_modules
 
-node_modules/knockback/node_modules/backbone/*
-!node_modules/knockback/node_modules/backbone/backbone.js
+node_modules/backbone/*
+!node_modules/backbone/backbone.js
 
-node_modules/knockback/node_modules/underscore/*
-!node_modules/knockback/node_modules/underscore/underscore.js
+node_modules/backbone.localStorage/*
+!node_modules/backbone.localStorage/backbone.localStorage.js
 
-node_modules/knockback/node_modules/knockout/*
-!node_modules/knockback/node_modules/knockout/build
-node_modules/knockback/node_modules/knockout/build/*
-!node_modules/knockback/node_modules/knockout/build/output
-node_modules/knockback/node_modules/knockout/build/output/*
-!node_modules/knockback/node_modules/knockout/build/output/knockout-latest.debug.js
+node_modules/underscore/*
+!node_modules/underscore.js
+
+node_modules/knockout/*
+!node_modules/knockout/build
+node_modules/knockout/build/*
+!node_modules/knockout/build/output
+node_modules/knockout/build/output/*
+!node_modules/knockout/build/output/knockout-latest.debug.js
 
 node_modules/jquery/*
 !node_modules/jquery/dist
diff --git a/examples/knockback/index.html b/examples/knockback/index.html
index f23f2a3ecb..ae1ced4136 100644
--- a/examples/knockback/index.html
+++ b/examples/knockback/index.html
@@ -7,28 +7,28 @@
 		<link rel="stylesheet" href="node_modules/todomvc-app-css/index.css">
 	</head>
 	<body>
-		<section id="todoapp" kb-inject="AppViewModel">
-			<header id="header">
+		<section class="todoapp" kb-inject="AppViewModel">
+			<header class="header">
 				<h1>todos</h1>
-				<input id="new-todo" type="text" data-bind="value: title, valueUpdate: 'afterkeydown', event: {keyup: onAddTodo}" placeholder="What needs to be done?" autofocus>
+				<input class="new-todo" type="text" data-bind="value: title, valueUpdate: 'afterkeydown', event: {keyup: onAddTodo}" placeholder="What needs to be done?" autofocus>
 			</header>
-			<section id="main" data-bind="block: tasks_exist">
-				<input id="toggle-all" type="checkbox" data-bind="checked: all_completed">
+			<section class="main" data-bind="visible: tasks_exist">
+				<input class="toggle-all" type="checkbox" data-bind="checked: all_completed">
 				<label for="toggle-all">Mark all as complete</label>
-				<ul id="todo-list" data-bind="foreach: todos">
+				<ul class="todo-list" data-bind="foreach: todos">
 					<li data-bind="css: {completed: completed, editing: editing}">
 						<div class="view" data-bind="event: {dblclick: onCheckEditBegin}">
 							<input class="toggle" type="checkbox" data-bind="checked: completed" checked>
 							<label data-bind="text: title"></label>
-							<button class="destroy" data-bind="click: onDestroyTodo"></button>
+							<button class="destroy" data-bind="click: onDestroy"></button>
 						</div>
-						<input class="edit" type="text" data-bind="value: title, selectAndFocus: editing, event: {blur: onCheckEditEnd, keyup: onCheckEditEnd}">
+						<input class="edit" type="text" data-bind="value: edit_title, event: {blur: onCheckEditEnd, keyup: onCheckEditEnd}">
 					</li>
 				</ul>
 			</section>
-			<footer id="footer" data-bind="block: tasks_exist">
-				<span id="todo-count" data-bind="html: loc.remaining_message"></span>
-				<ul id="filters">
+			<footer class="footer" data-bind="visible: tasks_exist">
+				<span class="todo-count" data-bind="html: loc.remaining_message"></span>
+				<ul class="filters">
 					<li>
 						<a href="#/" data-bind="css: {selected: list_filter_mode()==''}">All</a>
 					</li>
@@ -39,10 +39,10 @@ <h1>todos</h1>
 						<a href="#/completed" data-bind="css: {selected: list_filter_mode()=='completed'}">Completed</a>
 					</li>
 				</ul>
-				<button id="clear-completed" data-bind="text: loc.clear_message, block: loc.clear_message, click: onDestroyCompleted"></button>
+				<button class="clear-completed" data-bind="text: loc.clear_message, visible: loc.clear_message, click: onClearCompleted"></button>
 			</footer>
 		</section>
-		<footer id="info">
+		<footer class="info">
 			<p>Double-click to edit a todo</p>
 			<p>Created by <a href="https://github.com/kmalakoff">Kevin Malakoff</a>. <br/>
 			Please try out the <a href="http://kmalakoff.github.com/knockback-todos-app/">enhanced version</a> <br/>
@@ -54,15 +54,13 @@ <h1>todos</h1>
 		<!-- App Dependencies -->
 		<script src="node_modules/todomvc-common/base.js"></script>
 		<script src="node_modules/jquery/dist/jquery.js"></script>
-		<script src="node_modules/knockback/node_modules/underscore/underscore.js"></script>
-		<script src="node_modules/knockback/node_modules/backbone/backbone.js"></script>
-		<script src="node_modules/knockback/node_modules/knockout/build/output/knockout-latest.debug.js"></script>
+		<script src="node_modules/underscore/underscore.js"></script>
+		<script src="node_modules/backbone/backbone.js"></script>
+		<script src="node_modules/knockout/build/output/knockout-latest.debug.js"></script>
 		<script src="node_modules/knockback/knockback.js"></script>
 		<script src="node_modules/backbone.localStorage/backbone.localStorage.js"></script>
 
 		<!-- App and Components -->
-		<script src="js/lib/knockout-extended-bindings.js"></script>
-		<script src="js/models/todo.js"></script>
 		<script src="js/models/todo_collection.js"></script>
 		<script src="js/viewmodels/todo.js"></script>
 		<script src="js/viewmodels/app.js"></script>
diff --git a/examples/knockback/js/lib/knockout-extended-bindings.js b/examples/knockback/js/lib/knockout-extended-bindings.js
deleted file mode 100644
index d00963ccad..0000000000
--- a/examples/knockback/js/lib/knockout-extended-bindings.js
+++ /dev/null
@@ -1,30 +0,0 @@
-// Generated by CoffeeScript 1.8.0
-(function() {
-  ko.bindingHandlers.dblclick = {
-    init: function(element, value_accessor) {
-      return $(element).dblclick(ko.utils.unwrapObservable(value_accessor()));
-    }
-  };
-
-  ko.bindingHandlers.block = {
-    update: function(element, value_accessor) {
-      return element.style.display = ko.utils.unwrapObservable(value_accessor()) ? 'block' : 'none';
-    }
-  };
-
-  ko.bindingHandlers.selectAndFocus = {
-    init: function(element, value_accessor, all_bindings_accessor) {
-      ko.bindingHandlers.hasfocus.init(element, value_accessor, all_bindings_accessor);
-      return ko.utils.registerEventHandler(element, 'focus', function() {
-        return element.select();
-      });
-    },
-    update: function(element, value_accessor) {
-      ko.utils.unwrapObservable(value_accessor());
-      return _.defer(function() {
-        return ko.bindingHandlers.hasfocus.update(element, value_accessor);
-      });
-    }
-  };
-
-}).call(this);
diff --git a/examples/knockback/js/models/todo.js b/examples/knockback/js/models/todo.js
deleted file mode 100644
index 87686d003f..0000000000
--- a/examples/knockback/js/models/todo.js
+++ /dev/null
@@ -1,26 +0,0 @@
-// Generated by CoffeeScript 1.8.0
-(function() {
-  var __hasProp = {}.hasOwnProperty,
-    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
-
-  window.Todo = (function(_super) {
-    __extends(Todo, _super);
-
-    function Todo() {
-      return Todo.__super__.constructor.apply(this, arguments);
-    }
-
-    Todo.prototype.completed = function(completed) {
-      if (arguments.length === 0) {
-        return !!this.get('completed');
-      }
-      return this.save({
-        completed: completed ? new Date() : null
-      });
-    };
-
-    return Todo;
-
-  })(Backbone.Model);
-
-}).call(this);
diff --git a/examples/knockback/js/models/todo_collection.js b/examples/knockback/js/models/todo_collection.js
index 778dd0aa1b..63ddfc8aa7 100644
--- a/examples/knockback/js/models/todo_collection.js
+++ b/examples/knockback/js/models/todo_collection.js
@@ -1,10 +1,10 @@
-// Generated by CoffeeScript 1.8.0
+// Generated by CoffeeScript 1.10.0
 (function() {
-  var __hasProp = {}.hasOwnProperty,
-    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+  var extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
 
-  window.TodoCollection = (function(_super) {
-    __extends(TodoCollection, _super);
+  window.TodoCollection = (function(superClass) {
+    extend(TodoCollection, superClass);
 
     function TodoCollection() {
       return TodoCollection.__super__.constructor.apply(this, arguments);
@@ -12,35 +12,6 @@
 
     TodoCollection.prototype.localStorage = new Store('todos-knockback');
 
-    TodoCollection.prototype.model = Todo;
-
-    TodoCollection.prototype.completedCount = function() {
-      return this.models.reduce((function(prev, cur) {
-        return prev + (cur.completed() ? 1 : 0);
-      }), 0);
-    };
-
-    TodoCollection.prototype.remainingCount = function() {
-      return this.models.length - this.completedCount();
-    };
-
-    TodoCollection.prototype.completeAll = function(completed) {
-      return this.each(function(todo) {
-        return todo.completed(completed);
-      });
-    };
-
-    TodoCollection.prototype.destroyCompleted = function() {
-      var completed_tasks, model, _i, _len;
-      completed_tasks = this.filter(function(todo) {
-        return todo.completed();
-      });
-      for (_i = 0, _len = completed_tasks.length; _i < _len; _i++) {
-        model = completed_tasks[_i];
-        model.destroy();
-      }
-    };
-
     return TodoCollection;
 
   })(Backbone.Collection);
diff --git a/examples/knockback/js/viewmodels/app.js b/examples/knockback/js/viewmodels/app.js
index 7b6db6f544..c953c99c63 100644
--- a/examples/knockback/js/viewmodels/app.js
+++ b/examples/knockback/js/viewmodels/app.js
@@ -1,120 +1,133 @@
-// Generated by CoffeeScript 1.8.0
+// Generated by CoffeeScript 1.10.0
 (function() {
-  var ENTER_KEY;
+  var ENTER_KEY,
+    bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
 
   ENTER_KEY = 13;
 
-  window.AppViewModel = function() {
-    var filter_fn, router;
-    this.collections = {
-      todos: new TodoCollection()
-    };
-    this.collections.todos.fetch();
-    this.list_filter_mode = ko.observable('');
-    filter_fn = ko.computed((function(_this) {
-      return function() {
-        switch (_this.list_filter_mode()) {
-          case 'active':
-            return function(model) {
-              return !model.completed();
-            };
-          case 'completed':
-            return function(model) {
-              return model.completed();
-            };
-          default:
-            return function() {
-              return true;
-            };
-        }
-      };
-    })(this));
-    this.todos = kb.collectionObservable(this.collections.todos, {
-      view_model: TodoViewModel,
-      filters: filter_fn
-    });
-    this.todos_changed = kb.triggeredObservable(this.collections.todos, 'change add remove');
-    this.tasks_exist = ko.computed((function(_this) {
-      return function() {
-        _this.todos_changed();
-        return !!_this.collections.todos.length;
-      };
-    })(this));
-    this.title = ko.observable('');
-    this.onAddTodo = (function(_this) {
-      return function(view_model, event) {
-        if (!$.trim(_this.title()) || (event.keyCode !== ENTER_KEY)) {
-          return true;
-        }
-        _this.collections.todos.create({
-          title: $.trim(_this.title())
-        });
-        return _this.title('');
-      };
-    })(this);
-    this.remaining_count = ko.computed((function(_this) {
-      return function() {
-        _this.todos_changed();
-        return _this.collections.todos.remainingCount();
-      };
-    })(this));
-    this.completed_count = ko.computed((function(_this) {
-      return function() {
-        _this.todos_changed();
-        return _this.collections.todos.completedCount();
-      };
-    })(this));
-    this.all_completed = ko.computed({
-      read: (function(_this) {
+  window.AppViewModel = (function() {
+    function AppViewModel() {
+      this.onClearCompleted = bind(this.onClearCompleted, this);
+      this.onAddTodo = bind(this.onAddTodo, this);
+      var filter_fn, fn, i, len, ref, route, router;
+      this.list_filter_mode = ko.observable('');
+      filter_fn = ko.computed((function(_this) {
         return function() {
-          return !_this.remaining_count();
+          switch (_this.list_filter_mode()) {
+            case 'active':
+              return (function(model) {
+                return !model.get('completed');
+              });
+            case 'completed':
+              return (function(model) {
+                return model.get('completed');
+              });
+            default:
+              return (function() {
+                return true;
+              });
+          }
         };
-      })(this),
-      write: (function(_this) {
-        return function(completed) {
-          return _this.collections.todos.completeAll(completed);
+      })(this));
+      this.todos = kb.collectionObservable(new TodoCollection(), TodoViewModel, {
+        filters: filter_fn
+      });
+      this.todos.collection().fetch();
+      this._todos_changed = kb.triggeredObservable(this.todos.collection(), 'change add remove');
+      this.tasks_exist = ko.computed((function(_this) {
+        return function() {
+          _this._todos_changed();
+          return !!_this.todos.collection().models.length;
         };
-      })(this)
-    });
-    this.onDestroyCompleted = (function(_this) {
-      return function() {
-        return _this.collections.todos.destroyCompleted();
-      };
-    })(this);
-    this.loc = {
-      remaining_message: ko.computed((function(_this) {
+      })(this));
+      this.title = ko.observable('');
+      this.completed_count = ko.computed((function(_this) {
         return function() {
-          return "<strong>" + (_this.remaining_count()) + "</strong> " + (_this.remaining_count() === 1 ? 'item' : 'items') + " left";
+          _this._todos_changed();
+          return _this.todos.collection().filter(function(model) {
+            return model.get('completed');
+          }).length;
         };
-      })(this)),
-      clear_message: ko.computed((function(_this) {
+      })(this));
+      this.remaining_count = ko.computed((function(_this) {
         return function() {
-          var count;
-          if ((count = _this.completed_count())) {
-            return "Clear completed";
-          } else {
-            return '';
-          }
+          _this._todos_changed();
+          return _this.todos.collection().length - _this.completed_count();
         };
-      })(this))
-    };
-    router = new Backbone.Router;
-    router.route('', null, (function(_this) {
-      return function() {
-        return _this.list_filter_mode('');
-      };
-    })(this));
-    router.route('active', null, (function(_this) {
-      return function() {
-        return _this.list_filter_mode('active');
-      };
-    })(this));
-    router.route('completed', null, (function(_this) {
-      return function() {
-        return _this.list_filter_mode('completed');
+      })(this));
+      this.all_completed = ko.computed({
+        read: (function(_this) {
+          return function() {
+            return !_this.remaining_count();
+          };
+        })(this),
+        write: (function(_this) {
+          return function(completed) {
+            return _this.todos.collection().each(function(model) {
+              return model.save({
+                completed: completed
+              });
+            });
+          };
+        })(this)
+      });
+      this.loc = {
+        remaining_message: ko.computed((function(_this) {
+          return function() {
+            return "<strong>" + (_this.remaining_count()) + "</strong> " + (_this.remaining_count() === 1 ? 'item' : 'items') + " left";
+          };
+        })(this)),
+        clear_message: ko.computed((function(_this) {
+          return function() {
+            if (_this.completed_count()) {
+              return 'Clear completed';
+            } else {
+              return '';
+            }
+          };
+        })(this))
       };
-    })(this));
-    Backbone.history.start();
-  };
+      router = new Backbone.Router;
+      ref = ['', 'active', 'completed'];
+      fn = (function(_this) {
+        return function(route) {
+          return router.route(route, null, function() {
+            return _this.list_filter_mode(route);
+          });
+        };
+      })(this);
+      for (i = 0, len = ref.length; i < len; i++) {
+        route = ref[i];
+        fn(route);
+      }
+      Backbone.history.start();
+    }
+
+    AppViewModel.prototype.onAddTodo = function(vm, event) {
+      if (!$.trim(this.title()) || (event.keyCode !== ENTER_KEY)) {
+        return;
+      }
+      this.todos.collection().create({
+        title: $.trim(this.title())
+      });
+      return this.title('');
+    };
+
+    AppViewModel.prototype.onClearCompleted = function() {
+      var i, len, model, ref, results;
+      ref = this.todos.collection().filter(function(model) {
+        return model.get('completed');
+      });
+      results = [];
+      for (i = 0, len = ref.length; i < len; i++) {
+        model = ref[i];
+        results.push(model.destroy());
+      }
+      return results;
+    };
+
+    return AppViewModel;
+
+  })();
 
 }).call(this);
diff --git a/examples/knockback/js/viewmodels/todo.js b/examples/knockback/js/viewmodels/todo.js
index 40de8d5e5b..3e41a03ce6 100644
--- a/examples/knockback/js/viewmodels/todo.js
+++ b/examples/knockback/js/viewmodels/todo.js
@@ -1,60 +1,78 @@
-// Generated by CoffeeScript 1.8.0
+// Generated by CoffeeScript 1.10.0
 (function() {
-  window.TodoViewModel = function(model) {
-    var ENTER_KEY, ESCAPE_KEY;
-    ENTER_KEY = 13;
-    ESCAPE_KEY = 27;
-    this.editing = ko.observable(false);
-    this.completed = kb.observable(model, {
-      key: 'completed',
-      read: (function() {
-        return model.completed();
-      }),
-      write: (function(completed) {
-        return model.completed(completed);
-      })
-    }, this);
-    this.title = kb.observable(model, {
-      key: 'title',
-      write: ((function(_this) {
-        return function(title) {
-          if ($.trim(title)) {
-            model.save({
-              title: $.trim(title)
-            });
-          } else {
-            _.defer(function() {
-              return model.destroy();
-            });
-          }
-          return _this.editing(false);
+  var ENTER_KEY, ESCAPE_KEY,
+    bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
+    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+    hasProp = {}.hasOwnProperty;
+
+  ENTER_KEY = 13;
+
+  ESCAPE_KEY = 27;
+
+  window.TodoViewModel = (function(superClass) {
+    extend(TodoViewModel, superClass);
+
+    function TodoViewModel(model, options) {
+      this.onCheckEditEnd = bind(this.onCheckEditEnd, this);
+      this.onCheckEditBegin = bind(this.onCheckEditBegin, this);
+      this.onDestroy = bind(this.onDestroy, this);
+      TodoViewModel.__super__.constructor.call(this, model, {
+        requires: ['title', 'completed']
+      }, options);
+      this.completed.subscribe((function(_this) {
+        return function(completed) {
+          return _this.model().save({
+            completed: completed
+          });
         };
-      })(this))
-    }, this);
-    this.onDestroyTodo = (function(_this) {
-      return function() {
-        return model.destroy();
-      };
-    })(this);
-    this.onCheckEditBegin = (function(_this) {
-      return function() {
-        if (!_this.editing()) {
-          _this.editing(true);
-          return $('.todo-input').focus();
-        }
-      };
-    })(this);
-    this.onCheckEditEnd = (function(_this) {
-      return function(view_model, event) {
-        if (event.keyCode === ESCAPE_KEY) {
-          _this.editing(false);
-        }
-        if ((event.keyCode === ENTER_KEY) || (event.type === 'blur')) {
-          $('.todo-input').blur();
-          return _this.editing(false);
+      })(this));
+      this.edit_title = ko.observable();
+      this.editing = ko.observable(false);
+    }
+
+    TodoViewModel.prototype.onDestroy = function() {
+      return this.model().destroy();
+    };
+
+    TodoViewModel.prototype.onCheckEditBegin = function() {
+      if (this.editing()) {
+        return;
+      }
+      this.edit_title(this.title());
+      this.editing(true);
+      return $('.todo-input').focus();
+    };
+
+    TodoViewModel.prototype.onCheckEditEnd = function(vm, event) {
+      var title;
+      if (!this.editing()) {
+        return;
+      }
+      if (event.keyCode === ESCAPE_KEY) {
+        this.editing(false);
+      }
+      if ((event.keyCode === ENTER_KEY) || (event.type === 'blur')) {
+        $('.todo-input').blur();
+        title = this.edit_title();
+        if ($.trim(title)) {
+          this.model().set({
+            title: title
+          }).save({
+            title: $.trim(title)
+          });
+        } else {
+          _.defer((function(_this) {
+            return function() {
+              return _this.model().destroy();
+            };
+          })(this));
         }
-      };
-    })(this);
-  };
+        return this.editing(false);
+      }
+    };
+
+    return TodoViewModel;
+
+  })(kb.ViewModel);
 
 }).call(this);
diff --git a/examples/knockback/node_modules/backbone/backbone.js b/examples/knockback/node_modules/backbone/backbone.js
index 24a550a0ad..c924965621 100644
--- a/examples/knockback/node_modules/backbone/backbone.js
+++ b/examples/knockback/node_modules/backbone/backbone.js
@@ -1,11 +1,16 @@
-//     Backbone.js 1.1.2
+//     Backbone.js 1.2.3
 
-//     (c) 2010-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+//     (c) 2010-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
 //     Backbone may be freely distributed under the MIT license.
 //     For all details and documentation:
 //     http://backbonejs.org
 
-(function(root, factory) {
+(function(factory) {
+
+  // Establish the root object, `window` (`self`) in the browser, or `global` on the server.
+  // We use `self` instead of `window` for `WebWorker` support.
+  var root = (typeof self == 'object' && self.self == self && self) ||
+            (typeof global == 'object' && global.global == global && global);
 
   // Set up Backbone appropriately for the environment. Start with AMD.
   if (typeof define === 'function' && define.amd) {
@@ -17,15 +22,16 @@
 
   // Next for Node.js or CommonJS. jQuery may not be needed as a module.
   } else if (typeof exports !== 'undefined') {
-    var _ = require('underscore');
-    factory(root, exports, _);
+    var _ = require('underscore'), $;
+    try { $ = require('jquery'); } catch(e) {}
+    factory(root, exports, _, $);
 
   // Finally, as a browser global.
   } else {
     root.Backbone = factory(root, {}, root._, (root.jQuery || root.Zepto || root.ender || root.$));
   }
 
-}(this, function(root, Backbone, _, $) {
+}(function(root, Backbone, _, $) {
 
   // Initial Setup
   // -------------
@@ -34,14 +40,11 @@
   // restored later on, if `noConflict` is used.
   var previousBackbone = root.Backbone;
 
-  // Create local references to array methods we'll want to use later.
-  var array = [];
-  var push = array.push;
-  var slice = array.slice;
-  var splice = array.splice;
+  // Create a local reference to a common array method we'll want to use later.
+  var slice = Array.prototype.slice;
 
   // Current version of the library. Keep in sync with `package.json`.
-  Backbone.VERSION = '1.1.2';
+  Backbone.VERSION = '1.2.3';
 
   // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns
   // the `$` variable.
@@ -60,17 +63,65 @@
   Backbone.emulateHTTP = false;
 
   // Turn on `emulateJSON` to support legacy servers that can't deal with direct
-  // `application/json` requests ... will encode the body as
+  // `application/json` requests ... this will encode the body as
   // `application/x-www-form-urlencoded` instead and will send the model in a
   // form param named `model`.
   Backbone.emulateJSON = false;
 
+  // Proxy Backbone class methods to Underscore functions, wrapping the model's
+  // `attributes` object or collection's `models` array behind the scenes.
+  //
+  // collection.filter(function(model) { return model.get('age') > 10 });
+  // collection.each(this.addView);
+  //
+  // `Function#apply` can be slow so we use the method's arg count, if we know it.
+  var addMethod = function(length, method, attribute) {
+    switch (length) {
+      case 1: return function() {
+        return _[method](this[attribute]);
+      };
+      case 2: return function(value) {
+        return _[method](this[attribute], value);
+      };
+      case 3: return function(iteratee, context) {
+        return _[method](this[attribute], cb(iteratee, this), context);
+      };
+      case 4: return function(iteratee, defaultVal, context) {
+        return _[method](this[attribute], cb(iteratee, this), defaultVal, context);
+      };
+      default: return function() {
+        var args = slice.call(arguments);
+        args.unshift(this[attribute]);
+        return _[method].apply(_, args);
+      };
+    }
+  };
+  var addUnderscoreMethods = function(Class, methods, attribute) {
+    _.each(methods, function(length, method) {
+      if (_[method]) Class.prototype[method] = addMethod(length, method, attribute);
+    });
+  };
+
+  // Support `collection.sortBy('attr')` and `collection.findWhere({id: 1})`.
+  var cb = function(iteratee, instance) {
+    if (_.isFunction(iteratee)) return iteratee;
+    if (_.isObject(iteratee) && !instance._isModel(iteratee)) return modelMatcher(iteratee);
+    if (_.isString(iteratee)) return function(model) { return model.get(iteratee); };
+    return iteratee;
+  };
+  var modelMatcher = function(attrs) {
+    var matcher = _.matches(attrs);
+    return function(model) {
+      return matcher(model.attributes);
+    };
+  };
+
   // Backbone.Events
   // ---------------
 
   // A module that can be mixed in to *any object* in order to provide it with
-  // custom events. You may bind with `on` or remove with `off` callback
-  // functions to an event; `trigger`-ing an event fires all callbacks in
+  // a custom event channel. You may bind a callback to an event with `on` or
+  // remove with `off`; `trigger`-ing an event fires all callbacks in
   // succession.
   //
   //     var object = {};
@@ -78,123 +129,234 @@
   //     object.on('expand', function(){ alert('expanded'); });
   //     object.trigger('expand');
   //
-  var Events = Backbone.Events = {
-
-    // Bind an event to a `callback` function. Passing `"all"` will bind
-    // the callback to all events fired.
-    on: function(name, callback, context) {
-      if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;
-      this._events || (this._events = {});
-      var events = this._events[name] || (this._events[name] = []);
-      events.push({callback: callback, context: context, ctx: context || this});
-      return this;
-    },
+  var Events = Backbone.Events = {};
 
-    // Bind an event to only be triggered a single time. After the first time
-    // the callback is invoked, it will be removed.
-    once: function(name, callback, context) {
-      if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this;
-      var self = this;
-      var once = _.once(function() {
-        self.off(name, once);
-        callback.apply(this, arguments);
-      });
-      once._callback = callback;
-      return this.on(name, once, context);
-    },
-
-    // Remove one or many callbacks. If `context` is null, removes all
-    // callbacks with that function. If `callback` is null, removes all
-    // callbacks for the event. If `name` is null, removes all bound
-    // callbacks for all events.
-    off: function(name, callback, context) {
-      var retain, ev, events, names, i, l, j, k;
-      if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;
-      if (!name && !callback && !context) {
-        this._events = void 0;
-        return this;
+  // Regular expression used to split event strings.
+  var eventSplitter = /\s+/;
+
+  // Iterates over the standard `event, callback` (as well as the fancy multiple
+  // space-separated events `"change blur", callback` and jQuery-style event
+  // maps `{event: callback}`).
+  var eventsApi = function(iteratee, events, name, callback, opts) {
+    var i = 0, names;
+    if (name && typeof name === 'object') {
+      // Handle event maps.
+      if (callback !== void 0 && 'context' in opts && opts.context === void 0) opts.context = callback;
+      for (names = _.keys(name); i < names.length ; i++) {
+        events = eventsApi(iteratee, events, names[i], name[names[i]], opts);
       }
-      names = name ? [name] : _.keys(this._events);
-      for (i = 0, l = names.length; i < l; i++) {
-        name = names[i];
-        if (events = this._events[name]) {
-          this._events[name] = retain = [];
-          if (callback || context) {
-            for (j = 0, k = events.length; j < k; j++) {
-              ev = events[j];
-              if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||
-                  (context && context !== ev.context)) {
-                retain.push(ev);
-              }
-            }
-          }
-          if (!retain.length) delete this._events[name];
-        }
+    } else if (name && eventSplitter.test(name)) {
+      // Handle space separated event names by delegating them individually.
+      for (names = name.split(eventSplitter); i < names.length; i++) {
+        events = iteratee(events, names[i], callback, opts);
       }
+    } else {
+      // Finally, standard events.
+      events = iteratee(events, name, callback, opts);
+    }
+    return events;
+  };
 
-      return this;
-    },
+  // Bind an event to a `callback` function. Passing `"all"` will bind
+  // the callback to all events fired.
+  Events.on = function(name, callback, context) {
+    return internalOn(this, name, callback, context);
+  };
 
-    // Trigger one or many events, firing all bound callbacks. Callbacks are
-    // passed the same arguments as `trigger` is, apart from the event name
-    // (unless you're listening on `"all"`, which will cause your callback to
-    // receive the true name of the event as the first argument).
-    trigger: function(name) {
-      if (!this._events) return this;
-      var args = slice.call(arguments, 1);
-      if (!eventsApi(this, 'trigger', name, args)) return this;
-      var events = this._events[name];
-      var allEvents = this._events.all;
-      if (events) triggerEvents(events, args);
-      if (allEvents) triggerEvents(allEvents, arguments);
-      return this;
-    },
+  // Guard the `listening` argument from the public API.
+  var internalOn = function(obj, name, callback, context, listening) {
+    obj._events = eventsApi(onApi, obj._events || {}, name, callback, {
+        context: context,
+        ctx: obj,
+        listening: listening
+    });
 
-    // Tell this object to stop listening to either specific events ... or
-    // to every object it's currently listening to.
-    stopListening: function(obj, name, callback) {
-      var listeningTo = this._listeningTo;
-      if (!listeningTo) return this;
-      var remove = !name && !callback;
-      if (!callback && typeof name === 'object') callback = this;
-      if (obj) (listeningTo = {})[obj._listenId] = obj;
-      for (var id in listeningTo) {
-        obj = listeningTo[id];
-        obj.off(name, callback, this);
-        if (remove || _.isEmpty(obj._events)) delete this._listeningTo[id];
-      }
-      return this;
+    if (listening) {
+      var listeners = obj._listeners || (obj._listeners = {});
+      listeners[listening.id] = listening;
     }
 
+    return obj;
   };
 
-  // Regular expression used to split event strings.
-  var eventSplitter = /\s+/;
+  // Inversion-of-control versions of `on`. Tell *this* object to listen to
+  // an event in another object... keeping track of what it's listening to
+  // for easier unbinding later.
+  Events.listenTo =  function(obj, name, callback) {
+    if (!obj) return this;
+    var id = obj._listenId || (obj._listenId = _.uniqueId('l'));
+    var listeningTo = this._listeningTo || (this._listeningTo = {});
+    var listening = listeningTo[id];
+
+    // This object is not listening to any other events on `obj` yet.
+    // Setup the necessary references to track the listening callbacks.
+    if (!listening) {
+      var thisId = this._listenId || (this._listenId = _.uniqueId('l'));
+      listening = listeningTo[id] = {obj: obj, objId: id, id: thisId, listeningTo: listeningTo, count: 0};
+    }
+
+    // Bind callbacks on obj, and keep track of them on listening.
+    internalOn(obj, name, callback, this, listening);
+    return this;
+  };
+
+  // The reducing API that adds a callback to the `events` object.
+  var onApi = function(events, name, callback, options) {
+    if (callback) {
+      var handlers = events[name] || (events[name] = []);
+      var context = options.context, ctx = options.ctx, listening = options.listening;
+      if (listening) listening.count++;
+
+      handlers.push({ callback: callback, context: context, ctx: context || ctx, listening: listening });
+    }
+    return events;
+  };
+
+  // Remove one or many callbacks. If `context` is null, removes all
+  // callbacks with that function. If `callback` is null, removes all
+  // callbacks for the event. If `name` is null, removes all bound
+  // callbacks for all events.
+  Events.off =  function(name, callback, context) {
+    if (!this._events) return this;
+    this._events = eventsApi(offApi, this._events, name, callback, {
+        context: context,
+        listeners: this._listeners
+    });
+    return this;
+  };
+
+  // Tell this object to stop listening to either specific events ... or
+  // to every object it's currently listening to.
+  Events.stopListening =  function(obj, name, callback) {
+    var listeningTo = this._listeningTo;
+    if (!listeningTo) return this;
+
+    var ids = obj ? [obj._listenId] : _.keys(listeningTo);
+
+    for (var i = 0; i < ids.length; i++) {
+      var listening = listeningTo[ids[i]];
+
+      // If listening doesn't exist, this object is not currently
+      // listening to obj. Break out early.
+      if (!listening) break;
+
+      listening.obj.off(name, callback, this);
+    }
+    if (_.isEmpty(listeningTo)) this._listeningTo = void 0;
+
+    return this;
+  };
 
-  // Implement fancy features of the Events API such as multiple event
-  // names `"change blur"` and jQuery-style event maps `{change: action}`
-  // in terms of the existing API.
-  var eventsApi = function(obj, action, name, rest) {
-    if (!name) return true;
+  // The reducing API that removes a callback from the `events` object.
+  var offApi = function(events, name, callback, options) {
+    if (!events) return;
 
-    // Handle event maps.
-    if (typeof name === 'object') {
-      for (var key in name) {
-        obj[action].apply(obj, [key, name[key]].concat(rest));
+    var i = 0, listening;
+    var context = options.context, listeners = options.listeners;
+
+    // Delete all events listeners and "drop" events.
+    if (!name && !callback && !context) {
+      var ids = _.keys(listeners);
+      for (; i < ids.length; i++) {
+        listening = listeners[ids[i]];
+        delete listeners[listening.id];
+        delete listening.listeningTo[listening.objId];
       }
-      return false;
+      return;
     }
 
-    // Handle space separated event names.
-    if (eventSplitter.test(name)) {
-      var names = name.split(eventSplitter);
-      for (var i = 0, l = names.length; i < l; i++) {
-        obj[action].apply(obj, [names[i]].concat(rest));
+    var names = name ? [name] : _.keys(events);
+    for (; i < names.length; i++) {
+      name = names[i];
+      var handlers = events[name];
+
+      // Bail out if there are no events stored.
+      if (!handlers) break;
+
+      // Replace events if there are any remaining.  Otherwise, clean up.
+      var remaining = [];
+      for (var j = 0; j < handlers.length; j++) {
+        var handler = handlers[j];
+        if (
+          callback && callback !== handler.callback &&
+            callback !== handler.callback._callback ||
+              context && context !== handler.context
+        ) {
+          remaining.push(handler);
+        } else {
+          listening = handler.listening;
+          if (listening && --listening.count === 0) {
+            delete listeners[listening.id];
+            delete listening.listeningTo[listening.objId];
+          }
+        }
+      }
+
+      // Update tail event if the list has any events.  Otherwise, clean up.
+      if (remaining.length) {
+        events[name] = remaining;
+      } else {
+        delete events[name];
       }
-      return false;
     }
+    if (_.size(events)) return events;
+  };
+
+  // Bind an event to only be triggered a single time. After the first time
+  // the callback is invoked, its listener will be removed. If multiple events
+  // are passed in using the space-separated syntax, the handler will fire
+  // once for each event, not once for a combination of all events.
+  Events.once =  function(name, callback, context) {
+    // Map the event into a `{event: once}` object.
+    var events = eventsApi(onceMap, {}, name, callback, _.bind(this.off, this));
+    return this.on(events, void 0, context);
+  };
 
-    return true;
+  // Inversion-of-control versions of `once`.
+  Events.listenToOnce =  function(obj, name, callback) {
+    // Map the event into a `{event: once}` object.
+    var events = eventsApi(onceMap, {}, name, callback, _.bind(this.stopListening, this, obj));
+    return this.listenTo(obj, events);
+  };
+
+  // Reduces the event callbacks into a map of `{event: onceWrapper}`.
+  // `offer` unbinds the `onceWrapper` after it has been called.
+  var onceMap = function(map, name, callback, offer) {
+    if (callback) {
+      var once = map[name] = _.once(function() {
+        offer(name, once);
+        callback.apply(this, arguments);
+      });
+      once._callback = callback;
+    }
+    return map;
+  };
+
+  // Trigger one or many events, firing all bound callbacks. Callbacks are
+  // passed the same arguments as `trigger` is, apart from the event name
+  // (unless you're listening on `"all"`, which will cause your callback to
+  // receive the true name of the event as the first argument).
+  Events.trigger =  function(name) {
+    if (!this._events) return this;
+
+    var length = Math.max(0, arguments.length - 1);
+    var args = Array(length);
+    for (var i = 0; i < length; i++) args[i] = arguments[i + 1];
+
+    eventsApi(triggerApi, this._events, name, void 0, args);
+    return this;
+  };
+
+  // Handles triggering the appropriate event callbacks.
+  var triggerApi = function(objEvents, name, cb, args) {
+    if (objEvents) {
+      var events = objEvents[name];
+      var allEvents = objEvents.all;
+      if (events && allEvents) allEvents = allEvents.slice();
+      if (events) triggerEvents(events, args);
+      if (allEvents) triggerEvents(allEvents, [name].concat(args));
+    }
+    return objEvents;
   };
 
   // A difficult-to-believe, but optimized internal dispatch function for
@@ -211,22 +373,6 @@
     }
   };
 
-  var listenMethods = {listenTo: 'on', listenToOnce: 'once'};
-
-  // Inversion-of-control versions of `on` and `once`. Tell *this* object to
-  // listen to an event in another object ... keeping track of what it's
-  // listening to.
-  _.each(listenMethods, function(implementation, method) {
-    Events[method] = function(obj, name, callback) {
-      var listeningTo = this._listeningTo || (this._listeningTo = {});
-      var id = obj._listenId || (obj._listenId = _.uniqueId('l'));
-      listeningTo[id] = obj;
-      if (!callback && typeof name === 'object') callback = this;
-      obj[implementation](name, callback, this);
-      return this;
-    };
-  });
-
   // Aliases for backwards compatibility.
   Events.bind   = Events.on;
   Events.unbind = Events.off;
@@ -248,7 +394,7 @@
   var Model = Backbone.Model = function(attributes, options) {
     var attrs = attributes || {};
     options || (options = {});
-    this.cid = _.uniqueId('c');
+    this.cid = _.uniqueId(this.cidPrefix);
     this.attributes = {};
     if (options.collection) this.collection = options.collection;
     if (options.parse) attrs = this.parse(attrs, options) || {};
@@ -271,6 +417,10 @@
     // CouchDB users may want to set this to `"_id"`.
     idAttribute: 'id',
 
+    // The prefix is used to create the client id which is used to identify models locally.
+    // You may want to override this if you're experiencing name clashes with model ids.
+    cidPrefix: 'c',
+
     // Initialize is an empty function by default. Override it with your own
     // initialization logic.
     initialize: function(){},
@@ -302,14 +452,19 @@
       return this.get(attr) != null;
     },
 
+    // Special-cased proxy to underscore's `_.matches` method.
+    matches: function(attrs) {
+      return !!_.iteratee(attrs, this)(this.attributes);
+    },
+
     // Set a hash of model attributes on the object, firing `"change"`. This is
     // the core primitive operation of a model, updating the data and notifying
     // anyone who needs to know about the change in state. The heart of the beast.
     set: function(key, val, options) {
-      var attr, attrs, unset, changes, silent, changing, prev, current;
       if (key == null) return this;
 
       // Handle both `"key", value` and `{key: value}` -style arguments.
+      var attrs;
       if (typeof key === 'object') {
         attrs = key;
         options = val;
@@ -323,37 +478,40 @@
       if (!this._validate(attrs, options)) return false;
 
       // Extract attributes and options.
-      unset           = options.unset;
-      silent          = options.silent;
-      changes         = [];
-      changing        = this._changing;
-      this._changing  = true;
+      var unset      = options.unset;
+      var silent     = options.silent;
+      var changes    = [];
+      var changing   = this._changing;
+      this._changing = true;
 
       if (!changing) {
         this._previousAttributes = _.clone(this.attributes);
         this.changed = {};
       }
-      current = this.attributes, prev = this._previousAttributes;
 
-      // Check for changes of `id`.
-      if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];
+      var current = this.attributes;
+      var changed = this.changed;
+      var prev    = this._previousAttributes;
 
       // For each `set` attribute, update or delete the current value.
-      for (attr in attrs) {
+      for (var attr in attrs) {
         val = attrs[attr];
         if (!_.isEqual(current[attr], val)) changes.push(attr);
         if (!_.isEqual(prev[attr], val)) {
-          this.changed[attr] = val;
+          changed[attr] = val;
         } else {
-          delete this.changed[attr];
+          delete changed[attr];
         }
         unset ? delete current[attr] : current[attr] = val;
       }
 
+      // Update the `id`.
+      this.id = this.get(this.idAttribute);
+
       // Trigger all relevant attribute changes.
       if (!silent) {
         if (changes.length) this._pending = options;
-        for (var i = 0, l = changes.length; i < l; i++) {
+        for (var i = 0; i < changes.length; i++) {
           this.trigger('change:' + changes[i], this, current[changes[i]], options);
         }
       }
@@ -401,13 +559,14 @@
     // determining if there *would be* a change.
     changedAttributes: function(diff) {
       if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;
-      var val, changed = false;
       var old = this._changing ? this._previousAttributes : this.attributes;
+      var changed = {};
       for (var attr in diff) {
-        if (_.isEqual(old[attr], (val = diff[attr]))) continue;
-        (changed || (changed = {}))[attr] = val;
+        var val = diff[attr];
+        if (_.isEqual(old[attr], val)) continue;
+        changed[attr] = val;
       }
-      return changed;
+      return _.size(changed) ? changed : false;
     },
 
     // Get the previous value of an attribute, recorded at the time the last
@@ -423,17 +582,16 @@
       return _.clone(this._previousAttributes);
     },
 
-    // Fetch the model from the server. If the server's representation of the
-    // model differs from its current attributes, they will be overridden,
-    // triggering a `"change"` event.
+    // Fetch the model from the server, merging the response with the model's
+    // local attributes. Any changed attributes will trigger a "change" event.
     fetch: function(options) {
-      options = options ? _.clone(options) : {};
-      if (options.parse === void 0) options.parse = true;
+      options = _.extend({parse: true}, options);
       var model = this;
       var success = options.success;
       options.success = function(resp) {
-        if (!model.set(model.parse(resp, options), options)) return false;
-        if (success) success(model, resp, options);
+        var serverAttrs = options.parse ? model.parse(resp, options) : resp;
+        if (!model.set(serverAttrs, options)) return false;
+        if (success) success.call(options.context, model, resp, options);
         model.trigger('sync', model, resp, options);
       };
       wrapError(this, options);
@@ -444,9 +602,8 @@
     // If the server returns an attributes hash that differs, the model's
     // state will be `set` again.
     save: function(key, val, options) {
-      var attrs, method, xhr, attributes = this.attributes;
-
       // Handle both `"key", value` and `{key: value}` -style arguments.
+      var attrs;
       if (key == null || typeof key === 'object') {
         attrs = key;
         options = val;
@@ -454,46 +611,43 @@
         (attrs = {})[key] = val;
       }
 
-      options = _.extend({validate: true}, options);
+      options = _.extend({validate: true, parse: true}, options);
+      var wait = options.wait;
 
       // If we're not waiting and attributes exist, save acts as
       // `set(attr).save(null, opts)` with validation. Otherwise, check if
       // the model will be valid when the attributes, if any, are set.
-      if (attrs && !options.wait) {
+      if (attrs && !wait) {
         if (!this.set(attrs, options)) return false;
       } else {
         if (!this._validate(attrs, options)) return false;
       }
 
-      // Set temporary attributes if `{wait: true}`.
-      if (attrs && options.wait) {
-        this.attributes = _.extend({}, attributes, attrs);
-      }
-
       // After a successful server-side save, the client is (optionally)
       // updated with the server-side state.
-      if (options.parse === void 0) options.parse = true;
       var model = this;
       var success = options.success;
+      var attributes = this.attributes;
       options.success = function(resp) {
         // Ensure attributes are restored during synchronous saves.
         model.attributes = attributes;
-        var serverAttrs = model.parse(resp, options);
-        if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs);
-        if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) {
-          return false;
-        }
-        if (success) success(model, resp, options);
+        var serverAttrs = options.parse ? model.parse(resp, options) : resp;
+        if (wait) serverAttrs = _.extend({}, attrs, serverAttrs);
+        if (serverAttrs && !model.set(serverAttrs, options)) return false;
+        if (success) success.call(options.context, model, resp, options);
         model.trigger('sync', model, resp, options);
       };
       wrapError(this, options);
 
-      method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');
-      if (method === 'patch') options.attrs = attrs;
-      xhr = this.sync(method, this, options);
+      // Set temporary attributes if `{wait: true}` to properly find new ids.
+      if (attrs && wait) this.attributes = _.extend({}, attributes, attrs);
+
+      var method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');
+      if (method === 'patch' && !options.attrs) options.attrs = attrs;
+      var xhr = this.sync(method, this, options);
 
       // Restore attributes.
-      if (attrs && options.wait) this.attributes = attributes;
+      this.attributes = attributes;
 
       return xhr;
     },
@@ -505,25 +659,27 @@
       options = options ? _.clone(options) : {};
       var model = this;
       var success = options.success;
+      var wait = options.wait;
 
       var destroy = function() {
+        model.stopListening();
         model.trigger('destroy', model, model.collection, options);
       };
 
       options.success = function(resp) {
-        if (options.wait || model.isNew()) destroy();
-        if (success) success(model, resp, options);
+        if (wait) destroy();
+        if (success) success.call(options.context, model, resp, options);
         if (!model.isNew()) model.trigger('sync', model, resp, options);
       };
 
+      var xhr = false;
       if (this.isNew()) {
-        options.success();
-        return false;
+        _.defer(options.success);
+      } else {
+        wrapError(this, options);
+        xhr = this.sync('delete', this, options);
       }
-      wrapError(this, options);
-
-      var xhr = this.sync('delete', this, options);
-      if (!options.wait) destroy();
+      if (!wait) destroy();
       return xhr;
     },
 
@@ -536,7 +692,8 @@
         _.result(this.collection, 'url') ||
         urlError();
       if (this.isNew()) return base;
-      return base.replace(/([^\/])$/, '$1/') + encodeURIComponent(this.id);
+      var id = this.get(this.idAttribute);
+      return base.replace(/[^\/]$/, '$&/') + encodeURIComponent(id);
     },
 
     // **parse** converts a response into the hash of attributes to be `set` on
@@ -557,7 +714,7 @@
 
     // Check if the model is currently in a valid state.
     isValid: function(options) {
-      return this._validate({}, _.extend(options || {}, { validate: true }));
+      return this._validate({}, _.defaults({validate: true}, options));
     },
 
     // Run validation against the next complete set of model attributes,
@@ -573,23 +730,19 @@
 
   });
 
-  // Underscore methods that we want to implement on the Model.
-  var modelMethods = ['keys', 'values', 'pairs', 'invert', 'pick', 'omit'];
+  // Underscore methods that we want to implement on the Model, mapped to the
+  // number of arguments they take.
+  var modelMethods = { keys: 1, values: 1, pairs: 1, invert: 1, pick: 0,
+      omit: 0, chain: 1, isEmpty: 1 };
 
   // Mix in each Underscore method as a proxy to `Model#attributes`.
-  _.each(modelMethods, function(method) {
-    Model.prototype[method] = function() {
-      var args = slice.call(arguments);
-      args.unshift(this.attributes);
-      return _[method].apply(_, args);
-    };
-  });
+  addUnderscoreMethods(Model, modelMethods, 'attributes');
 
   // Backbone.Collection
   // -------------------
 
   // If models tend to represent a single row of data, a Backbone Collection is
-  // more analagous to a table full of data ... or a small slice or page of that
+  // more analogous to a table full of data ... or a small slice or page of that
   // table, or a collection of rows that belong together for a particular reason
   // -- all of the messages in this particular folder, all of the documents
   // belonging to this particular author, and so on. Collections maintain
@@ -611,6 +764,16 @@
   var setOptions = {add: true, remove: true, merge: true};
   var addOptions = {add: true, remove: false};
 
+  // Splices `insert` into `array` at index `at`.
+  var splice = function(array, insert, at) {
+    at = Math.min(Math.max(at, 0), array.length);
+    var tail = Array(array.length - at);
+    var length = insert.length;
+    for (var i = 0; i < tail.length; i++) tail[i] = array[i + at];
+    for (i = 0; i < length; i++) array[i + at] = insert[i];
+    for (i = 0; i < tail.length; i++) array[i + length + at] = tail[i];
+  };
+
   // Define the Collection's inheritable methods.
   _.extend(Collection.prototype, Events, {
 
@@ -625,7 +788,7 @@
     // The JSON representation of a Collection is an array of the
     // models' attributes.
     toJSON: function(options) {
-      return this.map(function(model){ return model.toJSON(options); });
+      return this.map(function(model) { return model.toJSON(options); });
     },
 
     // Proxy `Backbone.sync` by default.
@@ -633,32 +796,21 @@
       return Backbone.sync.apply(this, arguments);
     },
 
-    // Add a model, or list of models to the set.
+    // Add a model, or list of models to the set. `models` may be Backbone
+    // Models or raw JavaScript objects to be converted to Models, or any
+    // combination of the two.
     add: function(models, options) {
       return this.set(models, _.extend({merge: false}, options, addOptions));
     },
 
     // Remove a model, or a list of models from the set.
     remove: function(models, options) {
+      options = _.extend({}, options);
       var singular = !_.isArray(models);
       models = singular ? [models] : _.clone(models);
-      options || (options = {});
-      var i, l, index, model;
-      for (i = 0, l = models.length; i < l; i++) {
-        model = models[i] = this.get(models[i]);
-        if (!model) continue;
-        delete this._byId[model.id];
-        delete this._byId[model.cid];
-        index = this.indexOf(model);
-        this.models.splice(index, 1);
-        this.length--;
-        if (!options.silent) {
-          options.index = index;
-          model.trigger('remove', model, this, options);
-        }
-        this._removeReference(model, options);
-      }
-      return singular ? models[0] : models;
+      var removed = this._removeModels(models, options);
+      if (!options.silent && removed) this.trigger('update', this, options);
+      return singular ? removed[0] : removed;
     },
 
     // Update a collection by `set`-ing a new list of models, adding new ones,
@@ -666,78 +818,88 @@
     // already exist in the collection, as necessary. Similar to **Model#set**,
     // the core operation for updating the data contained by the collection.
     set: function(models, options) {
+      if (models == null) return;
+
       options = _.defaults({}, options, setOptions);
-      if (options.parse) models = this.parse(models, options);
+      if (options.parse && !this._isModel(models)) models = this.parse(models, options);
+
       var singular = !_.isArray(models);
-      models = singular ? (models ? [models] : []) : _.clone(models);
-      var i, l, id, model, attrs, existing, sort;
+      models = singular ? [models] : models.slice();
+
       var at = options.at;
-      var targetModel = this.model;
+      if (at != null) at = +at;
+      if (at < 0) at += this.length + 1;
+
+      var set = [];
+      var toAdd = [];
+      var toRemove = [];
+      var modelMap = {};
+
+      var add = options.add;
+      var merge = options.merge;
+      var remove = options.remove;
+
+      var sort = false;
       var sortable = this.comparator && (at == null) && options.sort !== false;
       var sortAttr = _.isString(this.comparator) ? this.comparator : null;
-      var toAdd = [], toRemove = [], modelMap = {};
-      var add = options.add, merge = options.merge, remove = options.remove;
-      var order = !sortable && add && remove ? [] : false;
 
       // Turn bare objects into model references, and prevent invalid models
       // from being added.
-      for (i = 0, l = models.length; i < l; i++) {
-        attrs = models[i] || {};
-        if (attrs instanceof Model) {
-          id = model = attrs;
-        } else {
-          id = attrs[targetModel.prototype.idAttribute || 'id'];
-        }
+      var model;
+      for (var i = 0; i < models.length; i++) {
+        model = models[i];
 
         // If a duplicate is found, prevent it from being added and
         // optionally merge it into the existing model.
-        if (existing = this.get(id)) {
-          if (remove) modelMap[existing.cid] = true;
-          if (merge) {
-            attrs = attrs === model ? model.attributes : attrs;
+        var existing = this.get(model);
+        if (existing) {
+          if (merge && model !== existing) {
+            var attrs = this._isModel(model) ? model.attributes : model;
             if (options.parse) attrs = existing.parse(attrs, options);
             existing.set(attrs, options);
-            if (sortable && !sort && existing.hasChanged(sortAttr)) sort = true;
+            if (sortable && !sort) sort = existing.hasChanged(sortAttr);
+          }
+          if (!modelMap[existing.cid]) {
+            modelMap[existing.cid] = true;
+            set.push(existing);
           }
           models[i] = existing;
 
         // If this is a new, valid model, push it to the `toAdd` list.
         } else if (add) {
-          model = models[i] = this._prepareModel(attrs, options);
-          if (!model) continue;
-          toAdd.push(model);
-          this._addReference(model, options);
+          model = models[i] = this._prepareModel(model, options);
+          if (model) {
+            toAdd.push(model);
+            this._addReference(model, options);
+            modelMap[model.cid] = true;
+            set.push(model);
+          }
         }
-
-        // Do not add multiple models with the same `id`.
-        model = existing || model;
-        if (order && (model.isNew() || !modelMap[model.id])) order.push(model);
-        modelMap[model.id] = true;
       }
 
-      // Remove nonexistent models if appropriate.
+      // Remove stale models.
       if (remove) {
-        for (i = 0, l = this.length; i < l; ++i) {
-          if (!modelMap[(model = this.models[i]).cid]) toRemove.push(model);
+        for (i = 0; i < this.length; i++) {
+          model = this.models[i];
+          if (!modelMap[model.cid]) toRemove.push(model);
         }
-        if (toRemove.length) this.remove(toRemove, options);
+        if (toRemove.length) this._removeModels(toRemove, options);
       }
 
       // See if sorting is needed, update `length` and splice in new models.
-      if (toAdd.length || (order && order.length)) {
+      var orderChanged = false;
+      var replace = !sortable && add && remove;
+      if (set.length && replace) {
+        orderChanged = this.length != set.length || _.some(this.models, function(model, index) {
+          return model !== set[index];
+        });
+        this.models.length = 0;
+        splice(this.models, set, 0);
+        this.length = this.models.length;
+      } else if (toAdd.length) {
         if (sortable) sort = true;
-        this.length += toAdd.length;
-        if (at != null) {
-          for (i = 0, l = toAdd.length; i < l; i++) {
-            this.models.splice(at + i, 0, toAdd[i]);
-          }
-        } else {
-          if (order) this.models.length = 0;
-          var orderedModels = order || toAdd;
-          for (i = 0, l = orderedModels.length; i < l; i++) {
-            this.models.push(orderedModels[i]);
-          }
-        }
+        splice(this.models, toAdd, at == null ? this.length : at);
+        this.length = this.models.length;
       }
 
       // Silently sort the collection if appropriate.
@@ -745,10 +907,13 @@
 
       // Unless silenced, it's time to fire all appropriate add/sort events.
       if (!options.silent) {
-        for (i = 0, l = toAdd.length; i < l; i++) {
-          (model = toAdd[i]).trigger('add', model, this, options);
+        for (i = 0; i < toAdd.length; i++) {
+          if (at != null) options.index = at + i;
+          model = toAdd[i];
+          model.trigger('add', model, this, options);
         }
-        if (sort || (order && order.length)) this.trigger('sort', this, options);
+        if (sort || orderChanged) this.trigger('sort', this, options);
+        if (toAdd.length || toRemove.length) this.trigger('update', this, options);
       }
 
       // Return the added (or merged) model (or models).
@@ -760,8 +925,8 @@
     // any granular `add` or `remove` events. Fires `reset` when finished.
     // Useful for bulk operations and optimizations.
     reset: function(models, options) {
-      options || (options = {});
-      for (var i = 0, l = this.models.length; i < l; i++) {
+      options = options ? _.clone(options) : {};
+      for (var i = 0; i < this.models.length; i++) {
         this._removeReference(this.models[i], options);
       }
       options.previousModels = this.models;
@@ -779,8 +944,7 @@
     // Remove a model from the end of the collection.
     pop: function(options) {
       var model = this.at(this.length - 1);
-      this.remove(model, options);
-      return model;
+      return this.remove(model, options);
     },
 
     // Add a model to the beginning of the collection.
@@ -791,8 +955,7 @@
     // Remove a model from the beginning of the collection.
     shift: function(options) {
       var model = this.at(0);
-      this.remove(model, options);
-      return model;
+      return this.remove(model, options);
     },
 
     // Slice out a sub-array of models from the collection.
@@ -803,24 +966,20 @@
     // Get a model from the set by id.
     get: function(obj) {
       if (obj == null) return void 0;
-      return this._byId[obj] || this._byId[obj.id] || this._byId[obj.cid];
+      var id = this.modelId(this._isModel(obj) ? obj.attributes : obj);
+      return this._byId[obj] || this._byId[id] || this._byId[obj.cid];
     },
 
     // Get the model at the given index.
     at: function(index) {
+      if (index < 0) index += this.length;
       return this.models[index];
     },
 
     // Return models with matching attributes. Useful for simple cases of
     // `filter`.
     where: function(attrs, first) {
-      if (_.isEmpty(attrs)) return first ? void 0 : [];
-      return this[first ? 'find' : 'filter'](function(model) {
-        for (var key in attrs) {
-          if (attrs[key] !== model.get(key)) return false;
-        }
-        return true;
-      });
+      return this[first ? 'find' : 'filter'](attrs);
     },
 
     // Return the first model with matching attributes. Useful for simple cases
@@ -833,16 +992,19 @@
     // normal circumstances, as the set will maintain sort order as each item
     // is added.
     sort: function(options) {
-      if (!this.comparator) throw new Error('Cannot sort a set without a comparator');
+      var comparator = this.comparator;
+      if (!comparator) throw new Error('Cannot sort a set without a comparator');
       options || (options = {});
 
+      var length = comparator.length;
+      if (_.isFunction(comparator)) comparator = _.bind(comparator, this);
+
       // Run sort based on type of `comparator`.
-      if (_.isString(this.comparator) || this.comparator.length === 1) {
-        this.models = this.sortBy(this.comparator, this);
+      if (length === 1 || _.isString(comparator)) {
+        this.models = this.sortBy(comparator);
       } else {
-        this.models.sort(_.bind(this.comparator, this));
+        this.models.sort(comparator);
       }
-
       if (!options.silent) this.trigger('sort', this, options);
       return this;
     },
@@ -856,14 +1018,13 @@
     // collection when they arrive. If `reset: true` is passed, the response
     // data will be passed through the `reset` method instead of `set`.
     fetch: function(options) {
-      options = options ? _.clone(options) : {};
-      if (options.parse === void 0) options.parse = true;
+      options = _.extend({parse: true}, options);
       var success = options.success;
       var collection = this;
       options.success = function(resp) {
         var method = options.reset ? 'reset' : 'set';
         collection[method](resp, options);
-        if (success) success(collection, resp, options);
+        if (success) success.call(options.context, collection, resp, options);
         collection.trigger('sync', collection, resp, options);
       };
       wrapError(this, options);
@@ -875,13 +1036,15 @@
     // wait for the server to agree.
     create: function(model, options) {
       options = options ? _.clone(options) : {};
-      if (!(model = this._prepareModel(model, options))) return false;
-      if (!options.wait) this.add(model, options);
+      var wait = options.wait;
+      model = this._prepareModel(model, options);
+      if (!model) return false;
+      if (!wait) this.add(model, options);
       var collection = this;
       var success = options.success;
-      options.success = function(model, resp) {
-        if (options.wait) collection.add(model, options);
-        if (success) success(model, resp, options);
+      options.success = function(model, resp, callbackOpts) {
+        if (wait) collection.add(model, callbackOpts);
+        if (success) success.call(callbackOpts.context, model, resp, callbackOpts);
       };
       model.save(null, options);
       return model;
@@ -895,7 +1058,15 @@
 
     // Create a new collection with an identical list of models as this one.
     clone: function() {
-      return new this.constructor(this.models);
+      return new this.constructor(this.models, {
+        model: this.model,
+        comparator: this.comparator
+      });
+    },
+
+    // Define how to uniquely identify models in the collection.
+    modelId: function (attrs) {
+      return attrs[this.model.prototype.idAttribute || 'id'];
     },
 
     // Private method to reset all internal state. Called when the collection
@@ -909,7 +1080,10 @@
     // Prepare a hash of attributes (or other model) to be added to this
     // collection.
     _prepareModel: function(attrs, options) {
-      if (attrs instanceof Model) return attrs;
+      if (this._isModel(attrs)) {
+        if (!attrs.collection) attrs.collection = this;
+        return attrs;
+      }
       options = options ? _.clone(options) : {};
       options.collection = this;
       var model = new this.model(attrs, options);
@@ -918,16 +1092,47 @@
       return false;
     },
 
+    // Internal method called by both remove and set.
+    _removeModels: function(models, options) {
+      var removed = [];
+      for (var i = 0; i < models.length; i++) {
+        var model = this.get(models[i]);
+        if (!model) continue;
+
+        var index = this.indexOf(model);
+        this.models.splice(index, 1);
+        this.length--;
+
+        if (!options.silent) {
+          options.index = index;
+          model.trigger('remove', model, this, options);
+        }
+
+        removed.push(model);
+        this._removeReference(model, options);
+      }
+      return removed.length ? removed : false;
+    },
+
+    // Method for checking whether an object should be considered a model for
+    // the purposes of adding to the collection.
+    _isModel: function (model) {
+      return model instanceof Model;
+    },
+
     // Internal method to create a model's ties to a collection.
     _addReference: function(model, options) {
       this._byId[model.cid] = model;
-      if (model.id != null) this._byId[model.id] = model;
-      if (!model.collection) model.collection = this;
+      var id = this.modelId(model.attributes);
+      if (id != null) this._byId[id] = model;
       model.on('all', this._onModelEvent, this);
     },
 
     // Internal method to sever a model's ties to a collection.
     _removeReference: function(model, options) {
+      delete this._byId[model.cid];
+      var id = this.modelId(model.attributes);
+      if (id != null) delete this._byId[id];
       if (this === model.collection) delete model.collection;
       model.off('all', this._onModelEvent, this);
     },
@@ -939,9 +1144,13 @@
     _onModelEvent: function(event, model, collection, options) {
       if ((event === 'add' || event === 'remove') && collection !== this) return;
       if (event === 'destroy') this.remove(model, options);
-      if (model && event === 'change:' + model.idAttribute) {
-        delete this._byId[model.previous(model.idAttribute)];
-        if (model.id != null) this._byId[model.id] = model;
+      if (event === 'change') {
+        var prevId = this.modelId(model.previousAttributes());
+        var id = this.modelId(model.attributes);
+        if (prevId !== id) {
+          if (prevId != null) delete this._byId[prevId];
+          if (id != null) this._byId[id] = model;
+        }
       }
       this.trigger.apply(this, arguments);
     }
@@ -951,34 +1160,17 @@
   // Underscore methods that we want to implement on the Collection.
   // 90% of the core usefulness of Backbone Collections is actually implemented
   // right here:
-  var methods = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',
-    'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select',
-    'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke',
-    'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',
-    'tail', 'drop', 'last', 'without', 'difference', 'indexOf', 'shuffle',
-    'lastIndexOf', 'isEmpty', 'chain', 'sample'];
+  var collectionMethods = { forEach: 3, each: 3, map: 3, collect: 3, reduce: 4,
+      foldl: 4, inject: 4, reduceRight: 4, foldr: 4, find: 3, detect: 3, filter: 3,
+      select: 3, reject: 3, every: 3, all: 3, some: 3, any: 3, include: 3, includes: 3,
+      contains: 3, invoke: 0, max: 3, min: 3, toArray: 1, size: 1, first: 3,
+      head: 3, take: 3, initial: 3, rest: 3, tail: 3, drop: 3, last: 3,
+      without: 0, difference: 0, indexOf: 3, shuffle: 1, lastIndexOf: 3,
+      isEmpty: 1, chain: 1, sample: 3, partition: 3, groupBy: 3, countBy: 3,
+      sortBy: 3, indexBy: 3};
 
   // Mix in each Underscore method as a proxy to `Collection#models`.
-  _.each(methods, function(method) {
-    Collection.prototype[method] = function() {
-      var args = slice.call(arguments);
-      args.unshift(this.models);
-      return _[method].apply(_, args);
-    };
-  });
-
-  // Underscore methods that take a property name as an argument.
-  var attributeMethods = ['groupBy', 'countBy', 'sortBy', 'indexBy'];
-
-  // Use attributes instead of properties.
-  _.each(attributeMethods, function(method) {
-    Collection.prototype[method] = function(value, context) {
-      var iterator = _.isFunction(value) ? value : function(model) {
-        return model.get(value);
-      };
-      return _[method](this.models, iterator, context);
-    };
-  });
+  addUnderscoreMethods(Collection, collectionMethods, 'models');
 
   // Backbone.View
   // -------------
@@ -995,17 +1187,15 @@
   // if an existing element is not provided...
   var View = Backbone.View = function(options) {
     this.cid = _.uniqueId('view');
-    options || (options = {});
     _.extend(this, _.pick(options, viewOptions));
     this._ensureElement();
     this.initialize.apply(this, arguments);
-    this.delegateEvents();
   };
 
   // Cached regex to split keys for `delegate`.
   var delegateEventSplitter = /^(\S+)\s*(.*)$/;
 
-  // List of view options to be merged as properties.
+  // List of view options to be set as properties.
   var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];
 
   // Set up all inheritable **Backbone.View** properties and methods.
@@ -1034,21 +1224,37 @@
     // Remove this view by taking the element out of the DOM, and removing any
     // applicable Backbone.Events listeners.
     remove: function() {
-      this.$el.remove();
+      this._removeElement();
       this.stopListening();
       return this;
     },
 
-    // Change the view's element (`this.el` property), including event
-    // re-delegation.
-    setElement: function(element, delegate) {
-      if (this.$el) this.undelegateEvents();
-      this.$el = element instanceof Backbone.$ ? element : Backbone.$(element);
-      this.el = this.$el[0];
-      if (delegate !== false) this.delegateEvents();
+    // Remove this view's element from the document and all event listeners
+    // attached to it. Exposed for subclasses using an alternative DOM
+    // manipulation API.
+    _removeElement: function() {
+      this.$el.remove();
+    },
+
+    // Change the view's element (`this.el` property) and re-delegate the
+    // view's events on the new element.
+    setElement: function(element) {
+      this.undelegateEvents();
+      this._setElement(element);
+      this.delegateEvents();
       return this;
     },
 
+    // Creates the `this.el` and `this.$el` references for this view using the
+    // given `el`. `el` can be a CSS selector or an HTML string, a jQuery
+    // context or an element. Subclasses can override this to utilize an
+    // alternative DOM manipulation API and are only required to set the
+    // `this.el` property.
+    _setElement: function(el) {
+      this.$el = el instanceof Backbone.$ ? el : Backbone.$(el);
+      this.el = this.$el[0];
+    },
+
     // Set callbacks, where `this.events` is a hash of
     //
     // *{"event selector": "callback"}*
@@ -1062,37 +1268,49 @@
     // pairs. Callbacks will be bound to the view, with `this` set properly.
     // Uses event delegation for efficiency.
     // Omitting the selector binds the event to `this.el`.
-    // This only works for delegate-able events: not `focus`, `blur`, and
-    // not `change`, `submit`, and `reset` in Internet Explorer.
     delegateEvents: function(events) {
-      if (!(events || (events = _.result(this, 'events')))) return this;
+      events || (events = _.result(this, 'events'));
+      if (!events) return this;
       this.undelegateEvents();
       for (var key in events) {
         var method = events[key];
-        if (!_.isFunction(method)) method = this[events[key]];
+        if (!_.isFunction(method)) method = this[method];
         if (!method) continue;
-
         var match = key.match(delegateEventSplitter);
-        var eventName = match[1], selector = match[2];
-        method = _.bind(method, this);
-        eventName += '.delegateEvents' + this.cid;
-        if (selector === '') {
-          this.$el.on(eventName, method);
-        } else {
-          this.$el.on(eventName, selector, method);
-        }
+        this.delegate(match[1], match[2], _.bind(method, this));
       }
       return this;
     },
 
-    // Clears all callbacks previously bound to the view with `delegateEvents`.
+    // Add a single event listener to the view's element (or a child element
+    // using `selector`). This only works for delegate-able events: not `focus`,
+    // `blur`, and not `change`, `submit`, and `reset` in Internet Explorer.
+    delegate: function(eventName, selector, listener) {
+      this.$el.on(eventName + '.delegateEvents' + this.cid, selector, listener);
+      return this;
+    },
+
+    // Clears all callbacks previously bound to the view by `delegateEvents`.
     // You usually don't need to use this, but may wish to if you have multiple
     // Backbone views attached to the same DOM element.
     undelegateEvents: function() {
-      this.$el.off('.delegateEvents' + this.cid);
+      if (this.$el) this.$el.off('.delegateEvents' + this.cid);
+      return this;
+    },
+
+    // A finer-grained `undelegateEvents` for removing a single delegated event.
+    // `selector` and `listener` are both optional.
+    undelegate: function(eventName, selector, listener) {
+      this.$el.off(eventName + '.delegateEvents' + this.cid, selector, listener);
       return this;
     },
 
+    // Produces a DOM element to be assigned to your view. Exposed for
+    // subclasses using an alternative DOM manipulation API.
+    _createElement: function(tagName) {
+      return document.createElement(tagName);
+    },
+
     // Ensure that the View has a DOM element to render into.
     // If `this.el` is a string, pass it through `$()`, take the first
     // matching element, and re-assign it to `el`. Otherwise, create
@@ -1102,11 +1320,17 @@
         var attrs = _.extend({}, _.result(this, 'attributes'));
         if (this.id) attrs.id = _.result(this, 'id');
         if (this.className) attrs['class'] = _.result(this, 'className');
-        var $el = Backbone.$('<' + _.result(this, 'tagName') + '>').attr(attrs);
-        this.setElement($el, false);
+        this.setElement(this._createElement(_.result(this, 'tagName')));
+        this._setAttributes(attrs);
       } else {
-        this.setElement(_.result(this, 'el'), false);
+        this.setElement(_.result(this, 'el'));
       }
+    },
+
+    // Set attributes from a hash on this view's element.  Exposed for
+    // subclasses using an alternative DOM manipulation API.
+    _setAttributes: function(attributes) {
+      this.$el.attr(attributes);
     }
 
   });
@@ -1175,14 +1399,13 @@
       params.processData = false;
     }
 
-    // If we're sending a `PATCH` request, and we're in an old Internet Explorer
-    // that still has ActiveX enabled by default, override jQuery to use that
-    // for XHR instead. Remove this line when jQuery supports `PATCH` on IE8.
-    if (params.type === 'PATCH' && noXhrPatch) {
-      params.xhr = function() {
-        return new ActiveXObject("Microsoft.XMLHTTP");
-      };
-    }
+    // Pass along `textStatus` and `errorThrown` from jQuery.
+    var error = options.error;
+    options.error = function(xhr, textStatus, errorThrown) {
+      options.textStatus = textStatus;
+      options.errorThrown = errorThrown;
+      if (error) error.call(options.context, xhr, textStatus, errorThrown);
+    };
 
     // Make the request, allowing the user to override any Ajax options.
     var xhr = options.xhr = Backbone.ajax(_.extend(params, options));
@@ -1190,10 +1413,6 @@
     return xhr;
   };
 
-  var noXhrPatch =
-    typeof window !== 'undefined' && !!window.ActiveXObject &&
-      !(window.XMLHttpRequest && (new XMLHttpRequest).dispatchEvent);
-
   // Map from CRUD to HTTP for our default `Backbone.sync` implementation.
   var methodMap = {
     'create': 'POST',
@@ -1251,17 +1470,18 @@
       var router = this;
       Backbone.history.route(route, function(fragment) {
         var args = router._extractParameters(route, fragment);
-        router.execute(callback, args);
-        router.trigger.apply(router, ['route:' + name].concat(args));
-        router.trigger('route', name, args);
-        Backbone.history.trigger('route', router, name, args);
+        if (router.execute(callback, args, name) !== false) {
+          router.trigger.apply(router, ['route:' + name].concat(args));
+          router.trigger('route', name, args);
+          Backbone.history.trigger('route', router, name, args);
+        }
       });
       return this;
     },
 
     // Execute a route handler with the provided parameters.  This is an
     // excellent place to do pre-route setup or post-route cleanup.
-    execute: function(callback, args) {
+    execute: function(callback, args, name) {
       if (callback) callback.apply(this, args);
     },
 
@@ -1319,7 +1539,7 @@
   // falls back to polling.
   var History = Backbone.History = function() {
     this.handlers = [];
-    _.bindAll(this, 'checkUrl');
+    this.checkUrl = _.bind(this.checkUrl, this);
 
     // Ensure that `History` can be used outside of the browser.
     if (typeof window !== 'undefined') {
@@ -1334,12 +1554,6 @@
   // Cached regex for stripping leading and trailing slashes.
   var rootStripper = /^\/+|\/+$/g;
 
-  // Cached regex for detecting MSIE.
-  var isExplorer = /msie [\w.]+/;
-
-  // Cached regex for removing a trailing slash.
-  var trailingSlash = /\/$/;
-
   // Cached regex for stripping urls of hash.
   var pathStripper = /#.*$/;
 
@@ -1355,7 +1569,29 @@
 
     // Are we at the app root?
     atRoot: function() {
-      return this.location.pathname.replace(/[^\/]$/, '$&/') === this.root;
+      var path = this.location.pathname.replace(/[^\/]$/, '$&/');
+      return path === this.root && !this.getSearch();
+    },
+
+    // Does the pathname match the root?
+    matchRoot: function() {
+      var path = this.decodeFragment(this.location.pathname);
+      var root = path.slice(0, this.root.length - 1) + '/';
+      return root === this.root;
+    },
+
+    // Unicode characters in `location.pathname` are percent encoded so they're
+    // decoded for comparison. `%25` should not be decoded since it may be part
+    // of an encoded parameter.
+    decodeFragment: function(fragment) {
+      return decodeURI(fragment.replace(/%25/g, '%2525'));
+    },
+
+    // In IE6, the hash fragment and search params are incorrect if the
+    // fragment contains `?`.
+    getSearch: function() {
+      var match = this.location.href.replace(/#.*/, '').match(/\?.+/);
+      return match ? match[0] : '';
     },
 
     // Gets the true hash value. Cannot use location.hash directly due to bug
@@ -1365,14 +1601,19 @@
       return match ? match[1] : '';
     },
 
-    // Get the cross-browser normalized URL fragment, either from the URL,
-    // the hash, or the override.
-    getFragment: function(fragment, forcePushState) {
+    // Get the pathname and search params, without the root.
+    getPath: function() {
+      var path = this.decodeFragment(
+        this.location.pathname + this.getSearch()
+      ).slice(this.root.length - 1);
+      return path.charAt(0) === '/' ? path.slice(1) : path;
+    },
+
+    // Get the cross-browser normalized URL fragment from the path or hash.
+    getFragment: function(fragment) {
       if (fragment == null) {
-        if (this._hasPushState || !this._wantsHashChange || forcePushState) {
-          fragment = decodeURI(this.location.pathname + this.location.search);
-          var root = this.root.replace(trailingSlash, '');
-          if (!fragment.indexOf(root)) fragment = fragment.slice(root.length);
+        if (this._usePushState || !this._wantsHashChange) {
+          fragment = this.getPath();
         } else {
           fragment = this.getHash();
         }
@@ -1383,7 +1624,7 @@
     // Start the hash change handling, returning `true` if the current URL matches
     // an existing route, and `false` otherwise.
     start: function(options) {
-      if (History.started) throw new Error("Backbone.history has already been started");
+      if (History.started) throw new Error('Backbone.history has already been started');
       History.started = true;
 
       // Figure out the initial configuration. Do we need an iframe?
@@ -1391,36 +1632,16 @@
       this.options          = _.extend({root: '/'}, this.options, options);
       this.root             = this.options.root;
       this._wantsHashChange = this.options.hashChange !== false;
+      this._hasHashChange   = 'onhashchange' in window && (document.documentMode === void 0 || document.documentMode > 7);
+      this._useHashChange   = this._wantsHashChange && this._hasHashChange;
       this._wantsPushState  = !!this.options.pushState;
-      this._hasPushState    = !!(this.options.pushState && this.history && this.history.pushState);
-      var fragment          = this.getFragment();
-      var docMode           = document.documentMode;
-      var oldIE             = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7));
+      this._hasPushState    = !!(this.history && this.history.pushState);
+      this._usePushState    = this._wantsPushState && this._hasPushState;
+      this.fragment         = this.getFragment();
 
       // Normalize root to always include a leading and trailing slash.
       this.root = ('/' + this.root + '/').replace(rootStripper, '/');
 
-      if (oldIE && this._wantsHashChange) {
-        var frame = Backbone.$('<iframe src="javascript:0" tabindex="-1">');
-        this.iframe = frame.hide().appendTo('body')[0].contentWindow;
-        this.navigate(fragment);
-      }
-
-      // Depending on whether we're using pushState or hashes, and whether
-      // 'onhashchange' is supported, determine how we check the URL state.
-      if (this._hasPushState) {
-        Backbone.$(window).on('popstate', this.checkUrl);
-      } else if (this._wantsHashChange && ('onhashchange' in window) && !oldIE) {
-        Backbone.$(window).on('hashchange', this.checkUrl);
-      } else if (this._wantsHashChange) {
-        this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
-      }
-
-      // Determine if we need to change the base url, for a pushState link
-      // opened by a non-pushState browser.
-      this.fragment = fragment;
-      var loc = this.location;
-
       // Transition from hashChange to pushState or vice versa if both are
       // requested.
       if (this._wantsHashChange && this._wantsPushState) {
@@ -1428,27 +1649,75 @@
         // If we've started off with a route from a `pushState`-enabled
         // browser, but we're currently in a browser that doesn't support it...
         if (!this._hasPushState && !this.atRoot()) {
-          this.fragment = this.getFragment(null, true);
-          this.location.replace(this.root + '#' + this.fragment);
+          var root = this.root.slice(0, -1) || '/';
+          this.location.replace(root + '#' + this.getPath());
           // Return immediately as browser will do redirect to new url
           return true;
 
         // Or if we've started out with a hash-based route, but we're currently
         // in a browser where it could be `pushState`-based instead...
-        } else if (this._hasPushState && this.atRoot() && loc.hash) {
-          this.fragment = this.getHash().replace(routeStripper, '');
-          this.history.replaceState({}, document.title, this.root + this.fragment);
+        } else if (this._hasPushState && this.atRoot()) {
+          this.navigate(this.getHash(), {replace: true});
         }
 
       }
 
+      // Proxy an iframe to handle location events if the browser doesn't
+      // support the `hashchange` event, HTML5 history, or the user wants
+      // `hashChange` but not `pushState`.
+      if (!this._hasHashChange && this._wantsHashChange && !this._usePushState) {
+        this.iframe = document.createElement('iframe');
+        this.iframe.src = 'javascript:0';
+        this.iframe.style.display = 'none';
+        this.iframe.tabIndex = -1;
+        var body = document.body;
+        // Using `appendChild` will throw on IE < 9 if the document is not ready.
+        var iWindow = body.insertBefore(this.iframe, body.firstChild).contentWindow;
+        iWindow.document.open();
+        iWindow.document.close();
+        iWindow.location.hash = '#' + this.fragment;
+      }
+
+      // Add a cross-platform `addEventListener` shim for older browsers.
+      var addEventListener = window.addEventListener || function (eventName, listener) {
+        return attachEvent('on' + eventName, listener);
+      };
+
+      // Depending on whether we're using pushState or hashes, and whether
+      // 'onhashchange' is supported, determine how we check the URL state.
+      if (this._usePushState) {
+        addEventListener('popstate', this.checkUrl, false);
+      } else if (this._useHashChange && !this.iframe) {
+        addEventListener('hashchange', this.checkUrl, false);
+      } else if (this._wantsHashChange) {
+        this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
+      }
+
       if (!this.options.silent) return this.loadUrl();
     },
 
     // Disable Backbone.history, perhaps temporarily. Not useful in a real app,
     // but possibly useful for unit testing Routers.
     stop: function() {
-      Backbone.$(window).off('popstate', this.checkUrl).off('hashchange', this.checkUrl);
+      // Add a cross-platform `removeEventListener` shim for older browsers.
+      var removeEventListener = window.removeEventListener || function (eventName, listener) {
+        return detachEvent('on' + eventName, listener);
+      };
+
+      // Remove window listeners.
+      if (this._usePushState) {
+        removeEventListener('popstate', this.checkUrl, false);
+      } else if (this._useHashChange && !this.iframe) {
+        removeEventListener('hashchange', this.checkUrl, false);
+      }
+
+      // Clean up the iframe if necessary.
+      if (this.iframe) {
+        document.body.removeChild(this.iframe);
+        this.iframe = null;
+      }
+
+      // Some environments will throw when clearing an undefined interval.
       if (this._checkUrlInterval) clearInterval(this._checkUrlInterval);
       History.started = false;
     },
@@ -1463,9 +1732,13 @@
     // calls `loadUrl`, normalizing across the hidden iframe.
     checkUrl: function(e) {
       var current = this.getFragment();
+
+      // If the user pressed the back button, the iframe's hash will have
+      // changed and we should use that for comparison.
       if (current === this.fragment && this.iframe) {
-        current = this.getFragment(this.getHash(this.iframe));
+        current = this.getHash(this.iframe.contentWindow);
       }
+
       if (current === this.fragment) return false;
       if (this.iframe) this.navigate(current);
       this.loadUrl();
@@ -1475,8 +1748,10 @@
     // match, returns `true`. If no defined routes matches the fragment,
     // returns `false`.
     loadUrl: function(fragment) {
+      // If the root doesn't match, no routes can match either.
+      if (!this.matchRoot()) return false;
       fragment = this.fragment = this.getFragment(fragment);
-      return _.any(this.handlers, function(handler) {
+      return _.some(this.handlers, function(handler) {
         if (handler.route.test(fragment)) {
           handler.callback(fragment);
           return true;
@@ -1495,31 +1770,42 @@
       if (!History.started) return false;
       if (!options || options === true) options = {trigger: !!options};
 
-      var url = this.root + (fragment = this.getFragment(fragment || ''));
+      // Normalize the fragment.
+      fragment = this.getFragment(fragment || '');
 
-      // Strip the hash for matching.
-      fragment = fragment.replace(pathStripper, '');
+      // Don't include a trailing slash on the root.
+      var root = this.root;
+      if (fragment === '' || fragment.charAt(0) === '?') {
+        root = root.slice(0, -1) || '/';
+      }
+      var url = root + fragment;
+
+      // Strip the hash and decode for matching.
+      fragment = this.decodeFragment(fragment.replace(pathStripper, ''));
 
       if (this.fragment === fragment) return;
       this.fragment = fragment;
 
-      // Don't include a trailing slash on the root.
-      if (fragment === '' && url !== '/') url = url.slice(0, -1);
-
       // If pushState is available, we use it to set the fragment as a real URL.
-      if (this._hasPushState) {
+      if (this._usePushState) {
         this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);
 
       // If hash changes haven't been explicitly disabled, update the hash
       // fragment to store history.
       } else if (this._wantsHashChange) {
         this._updateHash(this.location, fragment, options.replace);
-        if (this.iframe && (fragment !== this.getFragment(this.getHash(this.iframe)))) {
+        if (this.iframe && (fragment !== this.getHash(this.iframe.contentWindow))) {
+          var iWindow = this.iframe.contentWindow;
+
           // Opening and closing the iframe tricks IE7 and earlier to push a
           // history entry on hash-tag change.  When replace is true, we don't
           // want this.
-          if(!options.replace) this.iframe.document.open().close();
-          this._updateHash(this.iframe.location, fragment, options.replace);
+          if (!options.replace) {
+            iWindow.document.open();
+            iWindow.document.close();
+          }
+
+          this._updateHash(iWindow.location, fragment, options.replace);
         }
 
       // If you've told us that you explicitly don't want fallback hashchange-
@@ -1550,7 +1836,7 @@
   // Helpers
   // -------
 
-  // Helper function to correctly set up the prototype chain, for subclasses.
+  // Helper function to correctly set up the prototype chain for subclasses.
   // Similar to `goog.inherits`, but uses a hash of prototype properties and
   // class properties to be extended.
   var extend = function(protoProps, staticProps) {
@@ -1559,7 +1845,7 @@
 
     // The constructor function for the new subclass is either defined by you
     // (the "constructor" property in your `extend` definition), or defaulted
-    // by us to simply call the parent's constructor.
+    // by us to simply call the parent constructor.
     if (protoProps && _.has(protoProps, 'constructor')) {
       child = protoProps.constructor;
     } else {
@@ -1570,7 +1856,7 @@
     _.extend(child, parent, staticProps);
 
     // Set the prototype chain to inherit from `parent`, without calling
-    // `parent`'s constructor function.
+    // `parent` constructor function.
     var Surrogate = function(){ this.constructor = child; };
     Surrogate.prototype = parent.prototype;
     child.prototype = new Surrogate;
@@ -1598,7 +1884,7 @@
   var wrapError = function(model, options) {
     var error = options.error;
     options.error = function(resp) {
-      if (error) error(model, resp, options);
+      if (error) error.call(options.context, model, resp, options);
       model.trigger('error', model, resp, options);
     };
   };
diff --git a/examples/knockback/node_modules/jquery/dist/jquery.js b/examples/knockback/node_modules/jquery/dist/jquery.js
index 79d631ff46..eed17778c6 100644
--- a/examples/knockback/node_modules/jquery/dist/jquery.js
+++ b/examples/knockback/node_modules/jquery/dist/jquery.js
@@ -1,5 +1,5 @@
 /*!
- * jQuery JavaScript Library v2.1.3
+ * jQuery JavaScript Library v2.1.4
  * http://jquery.com/
  *
  * Includes Sizzle.js
@@ -9,7 +9,7 @@
  * Released under the MIT license
  * http://jquery.org/license
  *
- * Date: 2014-12-18T15:11Z
+ * Date: 2015-04-28T16:01Z
  */
 
 (function( global, factory ) {
@@ -67,7 +67,7 @@ var
 	// Use the correct document accordingly with window argument (sandbox)
 	document = window.document,
 
-	version = "2.1.3",
+	version = "2.1.4",
 
 	// Define a local copy of jQuery
 	jQuery = function( selector, context ) {
@@ -531,7 +531,12 @@ jQuery.each("Boolean Number String Function Array Date RegExp Object Error".spli
 });
 
 function isArraylike( obj ) {
-	var length = obj.length,
+
+	// Support: iOS 8.2 (not reproducible in simulator)
+	// `in` check used to prevent JIT error (gh-2145)
+	// hasOwn isn't used here due to false negatives
+	// regarding Nodelist length in IE
+	var length = "length" in obj && obj.length,
 		type = jQuery.type( obj );
 
 	if ( type === "function" || jQuery.isWindow( obj ) ) {
diff --git a/examples/knockback/node_modules/knockback/knockback.js b/examples/knockback/node_modules/knockback/knockback.js
index a3560c0148..1d537f1abb 100644
--- a/examples/knockback/node_modules/knockback/knockback.js
+++ b/examples/knockback/node_modules/knockback/knockback.js
@@ -1,6 +1,6 @@
 /*
-  knockback.js 0.20.5
-  Copyright (c)  2011-2014 Kevin Malakoff.
+  knockback.js 1.0.0
+  Copyright (c)  2011-2015 Kevin Malakoff.
   License: MIT (http://www.opensource.org/licenses/mit-license.php)
   Source: https://github.com/kmalakoff/knockback
   Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
@@ -10,52 +10,52 @@
 	if(typeof exports === 'object' && typeof module === 'object')
 		module.exports = factory(require("knockout"), require("backbone"), require("underscore"), (function webpackLoadOptionalExternalModule() { try { return require("jquery"); } catch(e) {} }()));
 	else if(typeof define === 'function' && define.amd)
-		define(["knockout", "backbone", "underscore"], function webpackLoadOptionalExternalModuleAmd(__WEBPACK_EXTERNAL_MODULE_20__, __WEBPACK_EXTERNAL_MODULE_21__, __WEBPACK_EXTERNAL_MODULE_22__) {
-			return factory(__WEBPACK_EXTERNAL_MODULE_20__, __WEBPACK_EXTERNAL_MODULE_21__, __WEBPACK_EXTERNAL_MODULE_22__, root["jQuery"]);
+		define(["knockout", "backbone", "underscore"], function webpackLoadOptionalExternalModuleAmd(__WEBPACK_EXTERNAL_MODULE_3__, __WEBPACK_EXTERNAL_MODULE_5__, __WEBPACK_EXTERNAL_MODULE_6__) {
+			return factory(__WEBPACK_EXTERNAL_MODULE_3__, __WEBPACK_EXTERNAL_MODULE_5__, __WEBPACK_EXTERNAL_MODULE_6__, root["jQuery"]);
 		});
 	else if(typeof exports === 'object')
 		exports["kb"] = factory(require("knockout"), require("backbone"), require("underscore"), (function webpackLoadOptionalExternalModule() { try { return require("jquery"); } catch(e) {} }()));
 	else
 		root["kb"] = factory(root["ko"], root["Backbone"], root["_"], root["jQuery"]);
-})(this, function(__WEBPACK_EXTERNAL_MODULE_20__, __WEBPACK_EXTERNAL_MODULE_21__, __WEBPACK_EXTERNAL_MODULE_22__, __WEBPACK_EXTERNAL_MODULE_23__) {
+})(this, function(__WEBPACK_EXTERNAL_MODULE_3__, __WEBPACK_EXTERNAL_MODULE_5__, __WEBPACK_EXTERNAL_MODULE_6__, __WEBPACK_EXTERNAL_MODULE_7__) {
 return /******/ (function(modules) { // webpackBootstrap
 /******/ 	// The module cache
 /******/ 	var installedModules = {};
-/******/
+
 /******/ 	// The require function
 /******/ 	function __webpack_require__(moduleId) {
-/******/
+
 /******/ 		// Check if module is in cache
 /******/ 		if(installedModules[moduleId])
 /******/ 			return installedModules[moduleId].exports;
-/******/
+
 /******/ 		// Create a new module (and put it into the cache)
 /******/ 		var module = installedModules[moduleId] = {
 /******/ 			exports: {},
 /******/ 			id: moduleId,
 /******/ 			loaded: false
 /******/ 		};
-/******/
+
 /******/ 		// Execute the module function
 /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
-/******/
+
 /******/ 		// Flag the module as loaded
 /******/ 		module.loaded = true;
-/******/
+
 /******/ 		// Return the exports of the module
 /******/ 		return module.exports;
 /******/ 	}
-/******/
-/******/
+
+
 /******/ 	// expose the modules object (__webpack_modules__)
 /******/ 	__webpack_require__.m = modules;
-/******/
+
 /******/ 	// expose the module cache
 /******/ 	__webpack_require__.c = installedModules;
-/******/
+
 /******/ 	// __webpack_public_path__
 /******/ 	__webpack_require__.p = "";
-/******/
+
 /******/ 	// Load entry module and return exports
 /******/ 	return __webpack_require__(0);
 /******/ })
@@ -65,24 +65,24 @@ return /******/ (function(modules) { // webpackBootstrap
 /***/ function(module, exports, __webpack_require__) {
 
 	__webpack_require__(1);
-	__webpack_require__(2);
-	__webpack_require__(3);
-	__webpack_require__(4);
-	__webpack_require__(5);
-	__webpack_require__(6);
-	__webpack_require__(7);
 	__webpack_require__(8);
-	__webpack_require__(9);
-	__webpack_require__(10);
-	__webpack_require__(11);
 	__webpack_require__(12);
 	__webpack_require__(13);
+	__webpack_require__(14);
+	__webpack_require__(2);
 	__webpack_require__(15);
 	__webpack_require__(16);
-	__webpack_require__(17);
 	__webpack_require__(18);
 	__webpack_require__(19);
-	module.exports = __webpack_require__(14);
+	__webpack_require__(17);
+	__webpack_require__(20);
+	__webpack_require__(24);
+	__webpack_require__(25);
+	__webpack_require__(27);
+	__webpack_require__(28);
+	__webpack_require__(29);
+	__webpack_require__(30);
+	module.exports = __webpack_require__(32);
 
 
 /***/ },
@@ -91,18 +91,18 @@ return /******/ (function(modules) { // webpackBootstrap
 
 	
 	/*
-	  knockback.js 0.20.5
+	  knockback.js 1.0.0
 	  Copyright (c)  2011-2014 Kevin Malakoff.
 	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
 	  Source: https://github.com/kmalakoff/knockback
 	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
 	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
 	 */
-	var COMPARE_ASCENDING, COMPARE_DESCENDING, COMPARE_EQUAL, KEYS_PUBLISH, kb, ko, _, _ref,
-	  __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
-	  __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+	var COMPARE_ASCENDING, COMPARE_DESCENDING, COMPARE_EQUAL, KEYS_PUBLISH, _, kb, ko, ref,
+	  bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
+	  indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
 
-	_ref = kb = __webpack_require__(6), _ = _ref._, ko = _ref.ko;
+	ref = kb = __webpack_require__(2), _ = ref._, ko = ref.ko;
 
 	COMPARE_EQUAL = 0;
 
@@ -134,12 +134,12 @@ return /******/ (function(modules) { // webpackBootstrap
 	  CollectionObservable.extend = kb.extend;
 
 	  function CollectionObservable(collection, view_model, options) {
-	    this._onCollectionChange = __bind(this._onCollectionChange, this);
+	    this._onCollectionChange = bind(this._onCollectionChange, this);
 	    var args;
 	    args = Array.prototype.slice.call(_.isArguments(collection) ? collection : arguments);
 	    return kb.ignore((function(_this) {
 	      return function() {
-	        var arg, create_options, observable, _i, _len;
+	        var arg, create_options, i, len, observable;
 	        collection = args[0] instanceof kb.Collection ? args.shift() : (_.isArray(args[0]) ? new kb.Collection(args.shift()) : new kb.Collection());
 	        if (_.isFunction(args[0])) {
 	          args[0] = {
@@ -147,8 +147,8 @@ return /******/ (function(modules) { // webpackBootstrap
 	          };
 	        }
 	        options = {};
-	        for (_i = 0, _len = args.length; _i < _len; _i++) {
-	          arg = args[_i];
+	        for (i = 0, len = args.length; i < len; i++) {
+	          arg = args[i];
 	          _.extend(options, arg);
 	        }
 	        observable = kb.utils.wrappedObservable(_this, ko.observableArray([]));
@@ -207,12 +207,12 @@ return /******/ (function(modules) { // webpackBootstrap
 	          collection.bind('all', _this._onCollectionChange);
 	        }
 	        _this._mapper = ko.computed(function() {
-	          var comparator, current_collection, filter, filters, models, previous_view_models, view_models, _j, _len1;
+	          var comparator, current_collection, filter, filters, j, len1, models, previous_view_models, view_models;
 	          comparator = _this._comparator();
 	          filters = _this._filters();
 	          if (filters) {
-	            for (_j = 0, _len1 = filters.length; _j < _len1; _j++) {
-	              filter = filters[_j];
+	            for (j = 0, len1 = filters.length; j < len1; j++) {
+	              filter = filters[j];
 	              ko.utils.unwrapObservable(filter);
 	            }
 	          }
@@ -313,8 +313,8 @@ return /******/ (function(modules) { // webpackBootstrap
 	    }
 	    id_attribute = model.hasOwnProperty(model.idAttribute) ? model.idAttribute : 'cid';
 	    return _.find(kb.peek(kb.utils.wrappedObservable(this)), function(test) {
-	      var _ref1;
-	      if (test != null ? (_ref1 = test.__kb) != null ? _ref1.object : void 0 : void 0) {
+	      var ref1;
+	      if (test != null ? (ref1 = test.__kb) != null ? ref1.object : void 0 : void 0) {
 	        return test.__kb.object[id_attribute] === model[id_attribute];
 	      } else {
 	        return false;
@@ -459,7 +459,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	  CollectionObservable.prototype._onObservableArrayChange = function(models_or_view_models) {
 	    return kb.ignore((function(_this) {
 	      return function() {
-	        var collection, current_view_model, has_filters, model, models, observable, view_model, view_models, _i, _len;
+	        var collection, current_view_model, has_filters, i, len, model, models, observable, view_model, view_models;
 	        if (_this.in_edit) {
 	          return;
 	        }
@@ -478,8 +478,8 @@ return /******/ (function(modules) { // webpackBootstrap
 	        } else {
 	          !has_filters || (view_models = []);
 	          models = [];
-	          for (_i = 0, _len = models_or_view_models.length; _i < _len; _i++) {
-	            view_model = models_or_view_models[_i];
+	          for (i = 0, len = models_or_view_models.length; i < len; i++) {
+	            view_model = models_or_view_models[i];
 	            model = kb.utils.wrappedObject(view_model);
 	            if (has_filters) {
 	              if (!_this._selectModel(model)) {
@@ -522,17 +522,17 @@ return /******/ (function(modules) { // webpackBootstrap
 	  };
 
 	  CollectionObservable.prototype._selectModel = function(model) {
-	    var filter, filters, _i, _len, _ref1;
+	    var filter, filters, i, len, ref1;
 	    filters = kb.peek(this._filters);
-	    for (_i = 0, _len = filters.length; _i < _len; _i++) {
-	      filter = filters[_i];
+	    for (i = 0, len = filters.length; i < len; i++) {
+	      filter = filters[i];
 	      filter = kb.peek(filter);
 	      if (_.isFunction(filter)) {
 	        if (!filter(model)) {
 	          return false;
 	        }
 	      } else if (_.isArray(filter)) {
-	        if (_ref1 = model.id, __indexOf.call(filter, _ref1) < 0) {
+	        if (ref1 = model.id, indexOf.call(filter, ref1) < 0) {
 	          return false;
 	        }
 	      } else {
@@ -552,1449 +552,1343 @@ return /******/ (function(modules) { // webpackBootstrap
 	  return new kb.CollectionObservable(arguments);
 	};
 
+	kb.observableCollection = kb.collectionObservable;
+
 
 /***/ },
 /* 2 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var ALL_ORMS, kb, key, ko, value, _, _ref;
+	/* WEBPACK VAR INJECTION */(function(global) {
+	/*
+	  knockback.js 1.0.0
+	  Copyright (c)  2011-2014 Kevin Malakoff.
+	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
+	  Source: https://github.com/kmalakoff/knockback
+	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
+	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
+	 */
+	var Backbone, LIFECYCLE_METHODS, _, kb, ko, window;
 
-	_ref = kb = __webpack_require__(6), _ = _ref._, ko = _ref.ko;
+	window = window != null ? window : global;
 
-	ALL_ORMS = {
-	  "default": null,
-	  'backbone-orm': null,
-	  'backbone-associations': __webpack_require__(26),
-	  'backbone-relational': __webpack_require__(27),
-	  supermodel: __webpack_require__(28)
-	};
+	ko = __webpack_require__(3);
 
-	kb.orm = ALL_ORMS["default"];
+	LIFECYCLE_METHODS = ['release', 'destroy', 'dispose'];
 
-	for (key in ALL_ORMS) {
-	  value = ALL_ORMS[key];
-	  if (value && value.isAvailable()) {
-	    kb.orm = value;
-	    break;
-	  }
-	}
+	module.exports = kb = (function() {
+	  var ref;
 
-	module.exports = function(options) {
-	  var orm;
-	  if (options == null) {
-	    options = {};
-	  }
-	  for (key in options) {
-	    value = options[key];
-	    switch (key) {
-	      case 'orm':
-	        if (_.isString(value)) {
-	          if (!ALL_ORMS.hasOwnProperty(value)) {
-	            console.log("Knockback configure: could not find orm: " + value + ". Available: " + (_.keys(ALL_ORMS).join(', ')));
-	            continue;
-	          }
-	          if ((orm = ALL_ORMS[value]) && !orm.isAvailable()) {
-	            console.log("Knockback configure: could not enable orm " + value + ". Make sure it is included before Knockback");
-	            continue;
-	          }
-	          kb.orm = orm;
-	          continue;
-	        } else {
-	          kb.orm = value;
-	        }
-	        break;
-	      default:
-	        kb[key] = value;
-	    }
-	  }
-	};
+	  function kb() {}
 
+	  kb.VERSION = '1.0.0';
 
-/***/ },
-/* 3 */
-/***/ function(module, exports, __webpack_require__) {
+	  kb.TYPE_UNKNOWN = 0;
 
-	
-	/*
-	  knockback.js 0.20.5
-	  Copyright (c)  2011-2014 Kevin Malakoff.
-	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
-	  Source: https://github.com/kmalakoff/knockback
-	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
-	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
-	 */
-	var kb, ko, _, _ref,
-	  __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+	  kb.TYPE_SIMPLE = 1;
 
-	_ref = kb = __webpack_require__(6), _ = _ref._, ko = _ref.ko;
+	  kb.TYPE_ARRAY = 2;
 
-	kb.EventWatcher = (function() {
-	  EventWatcher.useOptionsOrCreate = function(options, emitter, obj, callback_options) {
-	    if (options.event_watcher) {
-	      if (!(options.event_watcher.emitter() === emitter || (options.event_watcher.model_ref === emitter))) {
-	        kb._throwUnexpected(this, 'emitter not matching');
-	      }
-	      return kb.utils.wrappedEventWatcher(obj, options.event_watcher).registerCallbacks(obj, callback_options);
-	    } else {
-	      kb.utils.wrappedEventWatcherIsOwned(obj, true);
-	      return kb.utils.wrappedEventWatcher(obj, new kb.EventWatcher(emitter)).registerCallbacks(obj, callback_options);
-	    }
-	  };
+	  kb.TYPE_MODEL = 3;
 
-	  function EventWatcher(emitter, obj, callback_options) {
-	    this._unbindCallbacks = __bind(this._unbindCallbacks, this);
-	    this._onModelUnloaded = __bind(this._onModelUnloaded, this);
-	    this._onModelLoaded = __bind(this._onModelLoaded, this);
-	    this.__kb || (this.__kb = {});
-	    this.__kb.callbacks = {};
-	    this.ee = null;
-	    if (callback_options) {
-	      this.registerCallbacks(obj, callback_options);
-	    }
-	    if (emitter) {
-	      this.emitter(emitter);
-	    }
-	  }
+	  kb.TYPE_COLLECTION = 4;
 
-	  EventWatcher.prototype.destroy = function() {
-	    this.emitter(null);
-	    this.__kb.callbacks = null;
-	    return kb.utils.wrappedDestroy(this);
+	  kb.wasReleased = function(obj) {
+	    return !obj || obj.__kb_released;
 	  };
 
-	  EventWatcher.prototype.emitter = function(new_emitter) {
-	    if ((arguments.length === 0) || (this.ee === new_emitter)) {
-	      return this.ee;
+	  kb.isReleaseable = function(obj, depth) {
+	    var i, key, len, method, value;
+	    if (depth == null) {
+	      depth = 0;
 	    }
-	    if (this.model_ref) {
-	      this.model_ref.unbind('loaded', this._onModelLoaded);
-	      this.model_ref.unbind('unloaded', this._onModelUnloaded);
-	      this.model_ref.release();
-	      this.model_ref = null;
+	    if ((!obj || (obj !== Object(obj))) || obj.__kb_released) {
+	      return false;
 	    }
-	    if (kb.Backbone && kb.Backbone.ModelRef && (new_emitter instanceof kb.Backbone.ModelRef)) {
-	      this.model_ref = new_emitter;
-	      this.model_ref.retain();
-	      this.model_ref.bind('loaded', this._onModelLoaded);
-	      this.model_ref.bind('unloaded', this._onModelUnloaded);
-	      new_emitter = this.model_ref.model() || null;
-	    } else {
-	      delete this.model_ref;
+	    if (ko.isObservable(obj) || (obj instanceof kb.ViewModel)) {
+	      return true;
 	    }
-	    if (this.ee !== new_emitter) {
-	      if (new_emitter) {
-	        this._onModelLoaded(new_emitter);
-	      } else {
-	        this._onModelUnloaded(this.ee);
+	    if ((typeof obj === 'function') || kb.isModel(obj) || kb.isCollection(obj)) {
+	      return false;
+	    }
+	    for (i = 0, len = LIFECYCLE_METHODS.length; i < len; i++) {
+	      method = LIFECYCLE_METHODS[i];
+	      if (typeof obj[method] === 'function') {
+	        return true;
 	      }
 	    }
-	    return new_emitter;
-	  };
-
-	  EventWatcher.prototype.registerCallbacks = function(obj, callback_info) {
-	    var event_name, event_names, model, _fn, _i, _len;
-	    obj || kb._throwMissing(this, 'obj');
-	    callback_info || kb._throwMissing(this, 'callback_info');
-	    event_names = callback_info.event_selector ? callback_info.event_selector.split(' ') : ['change'];
-	    model = this.ee;
-	    _fn = (function(_this) {
-	      return function(event_name) {
-	        var callbacks, info;
-	        if (!(callbacks = _this.__kb.callbacks[event_name])) {
-	          callbacks = _this.__kb.callbacks[event_name] = {
-	            model: null,
-	            list: [],
-	            fn: function(model) {
-	              var info, _j, _len1, _ref1;
-	              _ref1 = callbacks.list;
-	              for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
-	                info = _ref1[_j];
-	                if (!info.update) {
-	                  continue;
-	                }
-	                if (model && info.key && (model.hasChanged && !model.hasChanged(ko.utils.unwrapObservable(info.key)))) {
-	                  continue;
-	                }
-	                !kb.statistics || kb.statistics.addModelEvent({
-	                  name: event_name,
-	                  model: model,
-	                  key: info.key,
-	                  path: info.path
-	                });
-	                info.update();
-	              }
-	              return null;
-	            }
-	          };
-	        }
-	        callbacks.list.push(info = _.defaults({
-	          obj: obj
-	        }, callback_info));
-	        if (model) {
-	          return _this._onModelLoaded(model);
-	        }
-	      };
-	    })(this);
-	    for (_i = 0, _len = event_names.length; _i < _len; _i++) {
-	      event_name = event_names[_i];
-	      if (!event_name) {
-	        continue;
+	    if (depth > 0) {
+	      return false;
+	    }
+	    for (key in obj) {
+	      value = obj[key];
+	      if ((key !== '__kb') && kb.isReleaseable(value, depth + 1)) {
+	        return true;
 	      }
-	      _fn(event_name);
 	    }
-	    return this;
+	    return false;
 	  };
 
-	  EventWatcher.prototype.releaseCallbacks = function(obj) {
-	    var callbacks, event_name, _ref1;
-	    this.ee = null;
-	    _ref1 = this.__kb.callbacks;
-	    for (event_name in _ref1) {
-	      callbacks = _ref1[event_name];
-	      this._unbindCallbacks(event_name, callbacks, kb.wasReleased(obj));
+	  kb.release = function(obj) {
+	    var array, i, index, len, method, value;
+	    if (!kb.isReleaseable(obj)) {
+	      return;
 	    }
-	    return delete this.__kb.callbacks;
-	  };
-
-	  EventWatcher.prototype._onModelLoaded = function(model) {
-	    var callbacks, event_name, info, _i, _len, _ref1, _ref2, _ref3;
-	    this.ee = model;
-	    _ref1 = this.__kb.callbacks;
-	    for (event_name in _ref1) {
-	      callbacks = _ref1[event_name];
-	      if (callbacks.model && (callbacks.model !== model)) {
-	        this._unbindCallbacks(event_name, callbacks, true);
+	    obj.__kb_released = true;
+	    if (_.isArray(obj)) {
+	      for (index in obj) {
+	        value = obj[index];
+	        if (kb.isReleaseable(value)) {
+	          obj[index] = null;
+	          kb.release(value);
+	        }
 	      }
-	      if (!callbacks.model) {
-	        callbacks.model = model;
-	        model.bind(event_name, callbacks.fn);
+	      return;
+	    }
+	    if (ko.isObservable(obj) && _.isArray(array = kb.peek(obj))) {
+	      if (obj.__kb_is_co || (obj.__kb_is_o && (obj.valueType() === kb.TYPE_COLLECTION))) {
+	        return typeof obj.destroy === "function" ? obj.destroy() : void 0;
 	      }
-	      _ref2 = callbacks.list;
-	      for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
-	        info = _ref2[_i];
-	        info.unbind_fn || (info.unbind_fn = (_ref3 = kb.orm) != null ? _ref3.bind(model, info.key, info.update, info.path) : void 0);
-	        if (info.emitter) {
-	          info.emitter(model);
+	      for (index in array) {
+	        value = array[index];
+	        if (kb.isReleaseable(value)) {
+	          array[index] = null;
+	          kb.release(value);
 	        }
 	      }
-	    }
-	  };
-
-	  EventWatcher.prototype._onModelUnloaded = function(model) {
-	    var callbacks, event_name, _ref1;
-	    if (this.ee !== model) {
+	      if (typeof obj.dispose === 'function') {
+	        obj.dispose();
+	      }
 	      return;
 	    }
-	    this.ee = null;
-	    _ref1 = this.__kb.callbacks;
-	    for (event_name in _ref1) {
-	      callbacks = _ref1[event_name];
-	      this._unbindCallbacks(event_name, callbacks);
+	    for (i = 0, len = LIFECYCLE_METHODS.length; i < len; i++) {
+	      method = LIFECYCLE_METHODS[i];
+	      if (typeof obj[method] === 'function') {
+	        return obj[method].call(obj);
+	      }
+	    }
+	    if (!ko.isObservable(obj)) {
+	      return this.releaseKeys(obj);
 	    }
 	  };
 
-	  EventWatcher.prototype._unbindCallbacks = function(event_name, callbacks, skip_emitter) {
-	    var info, _i, _len, _ref1;
-	    if (callbacks.model) {
-	      callbacks.model.unbind(event_name, callbacks.fn);
-	      callbacks.model = null;
-	    }
-	    _ref1 = callbacks.list;
-	    for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
-	      info = _ref1[_i];
-	      if (info.unbind_fn) {
-	        info.unbind_fn();
-	        info.unbind_fn = null;
-	      }
-	      if (info.emitter && !skip_emitter && !kb.wasReleased(info.obj)) {
-	        info.emitter(null);
+	  kb.releaseKeys = function(obj) {
+	    var key, value;
+	    for (key in obj) {
+	      value = obj[key];
+	      if (key !== '__kb' && kb.isReleaseable(value)) {
+	        obj[key] = null;
+	        kb.release(value);
 	      }
 	    }
 	  };
 
-	  return EventWatcher;
-
-	})();
-
-	kb.emitterObservable = function(emitter, observable) {
-	  return new kb.EventWatcher(emitter, observable);
-	};
-
-
-/***/ },
-/* 4 */
-/***/ function(module, exports, __webpack_require__) {
+	  kb.releaseOnNodeRemove = function(view_model, node) {
+	    view_model || kb._throwUnexpected(this, 'missing view model');
+	    node || kb._throwUnexpected(this, 'missing node');
+	    return ko.utils.domNodeDisposal.addDisposeCallback(node, function() {
+	      return kb.release(view_model);
+	    });
+	  };
 
-	
-	/*
-	  knockback.js 0.20.5
-	  Copyright (c)  2011-2014 Kevin Malakoff.
-	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
-	  Source: https://github.com/kmalakoff/knockback
-	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
-	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
-	 */
-	var kb, _;
+	  kb.renderTemplate = function(template, view_model, options) {
+	    var document, el, observable;
+	    if (options == null) {
+	      options = {};
+	    }
+	    if (!(document = window != null ? window.document : void 0)) {
+	      return typeof console !== "undefined" && console !== null ? console.log('renderTemplate: document is undefined') : void 0;
+	    }
+	    el = document.createElement('div');
+	    observable = ko.renderTemplate(template, view_model, options, el, 'replaceChildren');
+	    if (el.childNodes.length === 1) {
+	      el = el.childNodes[0];
+	    } else if (el.childNodes.length) {
+	      ko.storedBindingContextForNode(el, ko.contextFor(el.childNodes[0]));
+	    }
+	    kb.releaseOnNodeRemove(view_model, el);
+	    observable.dispose();
+	    if (view_model.afterRender && !options.afterRender) {
+	      view_model.afterRender(el);
+	    }
+	    return el;
+	  };
 
-	_ = (kb = __webpack_require__(6))._;
+	  kb.applyBindings = function(view_model, node) {
+	    var child, children, i, len, ref;
+	    if (node.length) {
+	      ref = [document.createElement('div'), node], node = ref[0], children = ref[1];
+	      for (i = 0, len = children.length; i < len; i++) {
+	        child = children[i];
+	        node.appendChild(child);
+	      }
+	    }
+	    ko.applyBindings(view_model, node);
+	    kb.releaseOnNodeRemove(view_model, node);
+	    return node;
+	  };
 
-	kb.Factory = (function() {
-	  Factory.useOptionsOrCreate = function(options, obj, owner_path) {
-	    var factory;
-	    if (options.factory && (!options.factories || (options.factories && options.factory.hasPathMappings(options.factories, owner_path)))) {
-	      return kb.utils.wrappedFactory(obj, options.factory);
+	  kb.getValue = function(model, key, args) {
+	    var ref;
+	    if (!model) {
+	      return;
 	    }
-	    factory = kb.utils.wrappedFactory(obj, new kb.Factory(options.factory));
-	    if (options.factories) {
-	      factory.addPathMappings(options.factories, owner_path);
+	    if (_.isFunction(model[key]) && ((ref = kb.orm) != null ? ref.useFunction(model, key) : void 0)) {
+	      return model[key]();
 	    }
-	    return factory;
+	    if (!args) {
+	      return model.get(key);
+	    }
+	    return model.get.apply(model, _.map([key].concat(args), function(value) {
+	      return kb.peek(value);
+	    }));
 	  };
 
-	  function Factory(parent_factory) {
-	    this.paths = {};
-	    if (parent_factory) {
-	      this.parent_factory = parent_factory;
+	  kb.setValue = function(model, key, value) {
+	    var attributes, ref;
+	    if (!model) {
+	      return;
 	    }
-	  }
+	    if (_.isFunction(model[key]) && ((ref = kb.orm) != null ? ref.useFunction(model, key) : void 0)) {
+	      return model[key](value);
+	    }
+	    (attributes = {})[key] = value;
+	    return model.set(attributes);
+	  };
 
-	  Factory.prototype.hasPath = function(path) {
-	    var _ref;
-	    return this.paths.hasOwnProperty(path) || ((_ref = this.parent_factory) != null ? _ref.hasPath(path) : void 0);
+	  kb.ignore = ((ref = ko.dependencyDetection) != null ? ref.ignore : void 0) || function(callback, callbackTarget, callbackArgs) {
+	    var value;
+	    value = null;
+	    ko.computed(function() {
+	      return value = callback.apply(callbackTarget, callbackArgs || []);
+	    }).dispose();
+	    return value;
 	  };
 
-	  Factory.prototype.addPathMapping = function(path, create_info) {
-	    return this.paths[path] = create_info;
+	  kb.extend = __webpack_require__(4);
+
+	  kb._throwMissing = function(instance, message) {
+	    throw (_.isString(instance) ? instance : instance.constructor.name) + ": " + message + " is missing";
 	  };
 
-	  Factory.prototype.addPathMappings = function(factories, owner_path) {
-	    var create_info, path;
-	    for (path in factories) {
-	      create_info = factories[path];
-	      this.paths[kb.utils.pathJoin(owner_path, path)] = create_info;
-	    }
+	  kb._throwUnexpected = function(instance, message) {
+	    throw (_.isString(instance) ? instance : instance.constructor.name) + ": " + message + " is unexpected";
 	  };
 
-	  Factory.prototype.hasPathMappings = function(factories, owner_path) {
-	    var all_exist, creator, existing_creator, path;
-	    all_exist = true;
-	    for (path in factories) {
-	      creator = factories[path];
-	      all_exist &= (existing_creator = this.creatorForPath(null, kb.utils.pathJoin(owner_path, path))) && (creator === existing_creator);
+	  kb.publishMethods = function(observable, instance, methods) {
+	    var fn, i, len;
+	    for (i = 0, len = methods.length; i < len; i++) {
+	      fn = methods[i];
+	      observable[fn] = kb._.bind(instance[fn], instance);
 	    }
-	    return all_exist;
 	  };
 
-	  Factory.prototype.creatorForPath = function(obj, path) {
-	    var creator, _ref;
-	    if (creator = this.paths[path]) {
-	      return (creator.view_model ? creator.view_model : creator);
+	  kb.peek = function(obs) {
+	    if (!ko.isObservable(obs)) {
+	      return obs;
 	    }
-	    if (creator = (_ref = this.parent_factory) != null ? _ref.creatorForPath(obj, path) : void 0) {
-	      return creator;
+	    if (obs.peek) {
+	      return obs.peek();
 	    }
-	    return null;
+	    return kb.ignore(function() {
+	      return obs();
+	    });
 	  };
 
-	  return Factory;
+	  kb.isModel = function(obj) {
+	    return obj && ((obj instanceof kb.Model) || ((typeof obj.get === 'function') && (typeof obj.bind === 'function')));
+	  };
+
+	  kb.isCollection = function(obj) {
+	    return obj && (obj instanceof kb.Collection);
+	  };
+
+	  return kb;
 
 	})();
 
+	if (window.Parse) {
+	  Backbone = kb.Parse = window.Parse;
+	  _ = kb._ = window.Parse._;
+	} else {
+	  Backbone = kb.Backbone = __webpack_require__(5);
+	  _ = kb._ = __webpack_require__(6);
+	}
+
+	kb.ko = ko;
+
+	kb.Collection = Backbone.Collection;
+
+	kb.Model = Backbone.Object || Backbone.Model;
+
+	kb.Events = Backbone.Events;
+
+	kb.$ = window.jQuery || window.$;
+
+	try {
+	  kb.$ || (kb.$ = __webpack_require__(7));
+	} catch (undefined) {}
+
+	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
 
 /***/ },
-/* 5 */
-/***/ function(module, exports, __webpack_require__) {
+/* 3 */
+/***/ function(module, exports) {
 
-	/* WEBPACK VAR INJECTION */(function(global) {
+	module.exports = __WEBPACK_EXTERNAL_MODULE_3__;
+
+/***/ },
+/* 4 */
+/***/ function(module, exports) {
+
+	
 	/*
-	  knockback.js 0.20.5
+	  knockback.js 1.0.0
 	  Copyright (c)  2011-2014 Kevin Malakoff.
 	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
 	  Source: https://github.com/kmalakoff/knockback
 	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
 	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
 	 */
-	var $, kb, ko, onReady, window, _, _ko_applyBindings, _ref;
+	var copyProps;
 
-	window = window != null ? window : global;
+	copyProps = function(dest, source) {
+	  var key, value;
+	  for (key in source) {
+	    value = source[key];
+	    dest[key] = value;
+	  }
+	  return dest;
+	};
 
-	_ref = kb = __webpack_require__(6), _ = _ref._, ko = _ref.ko, $ = _ref.$;
+	// Shared empty constructor function to aid in prototype-chain creation.
+	var ctor = function(){};
 
-	kb.RECUSIVE_AUTO_INJECT = true;
+	// Helper function to correctly set up the prototype chain, for subclasses.
+	// Similar to 'goog.inherits', but uses a hash of prototype properties and
+	// class properties to be extended.
+	var inherits = function(parent, protoProps, staticProps) {
+	  var child;
 
-	ko.bindingHandlers['inject'] = {
-	  'init': function(element, value_accessor, all_bindings_accessor, view_model) {
-	    return kb.Inject.inject(ko.utils.unwrapObservable(value_accessor()), view_model, element, value_accessor, all_bindings_accessor);
+	  // The constructor function for the new subclass is either defined by you
+	  // (the "constructor" property in your extend definition), or defaulted
+	  // by us to simply call the parent's constructor.
+	  if (protoProps && protoProps.hasOwnProperty('constructor')) {
+	    child = protoProps.constructor;
+	  } else {
+	    child = function(){ parent.apply(this, arguments); };
 	  }
+
+	  // Inherit class (static) properties from parent.
+	  copyProps(child, parent);
+
+	  // Set the prototype chain to inherit from parent, without calling
+	  // parent's constructor function.
+	  ctor.prototype = parent.prototype;
+	  child.prototype = new ctor();
+
+	  // Add prototype properties (instance properties) to the subclass,
+	  // if supplied.
+	  if (protoProps) copyProps(child.prototype, protoProps);
+
+	  // Add static properties to the constructor function, if supplied.
+	  if (staticProps) copyProps(child, staticProps);
+
+	  // Correctly set child's 'prototype.constructor'.
+	  child.prototype.constructor = child;
+
+	  // Set a convenience property in case the parent's prototype is needed later.
+	  child.__super__ = parent.prototype;
+
+	  return child;
 	};
 
-	kb.Inject = (function() {
-	  function Inject() {}
+	// The self-propagating extend function that BacLCone classes use.
+	var extend = function (protoProps, classProps) {
+	  var child = inherits(this, protoProps, classProps);
+	  child.extend = this.extend;
+	  return child;
+	};
+	;
 
-	  Inject.inject = function(data, view_model, element, value_accessor, all_bindings_accessor, nested) {
-	    var inject;
-	    inject = function(data) {
-	      var key, target, value;
-	      if (_.isFunction(data)) {
-	        view_model = new data(view_model, element, value_accessor, all_bindings_accessor);
-	        kb.releaseOnNodeRemove(view_model, element);
-	      } else {
-	        if (data.view_model) {
-	          view_model = new data.view_model(view_model, element, value_accessor, all_bindings_accessor);
-	          kb.releaseOnNodeRemove(view_model, element);
-	        }
-	        for (key in data) {
-	          value = data[key];
-	          if (key === 'view_model') {
-	            continue;
-	          }
-	          if (key === 'create') {
-	            value(view_model, element, value_accessor, all_bindings_accessor);
-	          } else if (_.isObject(value) && !_.isFunction(value)) {
-	            target = nested || (value && value.create) ? {} : view_model;
-	            view_model[key] = kb.Inject.inject(value, target, element, value_accessor, all_bindings_accessor, true);
-	          } else {
-	            view_model[key] = value;
-	          }
-	        }
-	      }
-	      return view_model;
-	    };
-	    if (nested) {
-	      return inject(data);
-	    } else {
-	      return kb.ignore(function() {
-	        return inject(data);
-	      });
-	    }
-	  };
+	module.exports = extend;
 
-	  Inject.injectViewModels = function(root) {
-	    var afterBinding, app, beforeBinding, data, expression, findElements, options, results, _i, _len;
-	    results = [];
-	    findElements = function(el) {
-	      var attr, child_el, _i, _len, _ref1;
-	      if (!el.__kb_injected) {
-	        if (el.attributes && (attr = _.find(el.attributes, function(attr) {
-	          return attr.name === 'kb-inject';
-	        }))) {
-	          el.__kb_injected = true;
-	          results.push({
-	            el: el,
-	            view_model: {},
-	            binding: attr.value
-	          });
-	        }
-	      }
-	      _ref1 = el.childNodes;
-	      for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
-	        child_el = _ref1[_i];
-	        findElements(child_el);
-	      }
-	    };
-	    if (!root && (window != null ? window.document : void 0)) {
-	      root = window.document;
-	    }
-	    findElements(root);
-	    for (_i = 0, _len = results.length; _i < _len; _i++) {
-	      app = results[_i];
-	      if (expression = app.binding) {
-	        (expression.search(/[:]/) < 0) || (expression = "{" + expression + "}");
-	        data = (new Function("", "return ( " + expression + " )"))();
-	        data || (data = {});
-	        (!data.options) || (options = data.options, delete data.options);
-	        options || (options = {});
-	        app.view_model = kb.Inject.inject(data, app.view_model, app.el, null, null, true);
-	        afterBinding = app.view_model.afterBinding || options.afterBinding;
-	        beforeBinding = app.view_model.beforeBinding || options.beforeBinding;
-	      }
-	      if (beforeBinding) {
-	        beforeBinding.call(app.view_model, app.view_model, app.el, options);
-	      }
-	      kb.applyBindings(app.view_model, app.el, options);
-	      if (afterBinding) {
-	        afterBinding.call(app.view_model, app.view_model, app.el, options);
-	      }
-	    }
-	    return results;
-	  };
 
-	  return Inject;
+/***/ },
+/* 5 */
+/***/ function(module, exports) {
 
-	})();
+	module.exports = __WEBPACK_EXTERNAL_MODULE_5__;
 
-	_ko_applyBindings = ko.applyBindings;
+/***/ },
+/* 6 */
+/***/ function(module, exports) {
 
-	ko.applyBindings = function(context, element) {
-	  var results;
-	  results = kb.RECUSIVE_AUTO_INJECT ? kb.injectViewModels(element) : [];
-	  if (!results.length) {
-	    return _ko_applyBindings.apply(this, arguments);
-	  }
+	module.exports = __WEBPACK_EXTERNAL_MODULE_6__;
+
+/***/ },
+/* 7 */
+/***/ function(module, exports) {
+
+	if(typeof __WEBPACK_EXTERNAL_MODULE_7__ === 'undefined') {var e = new Error("Cannot find module \"undefined\""); e.code = 'MODULE_NOT_FOUND'; throw e;}
+	module.exports = __WEBPACK_EXTERNAL_MODULE_7__;
+
+/***/ },
+/* 8 */
+/***/ function(module, exports, __webpack_require__) {
+
+	var ALL_ORMS, _, kb, key, ko, ref, value;
+
+	ref = kb = __webpack_require__(2), _ = ref._, ko = ref.ko;
+
+	ALL_ORMS = {
+	  "default": null,
+	  'backbone-orm': null,
+	  'backbone-associations': __webpack_require__(9),
+	  'backbone-relational': __webpack_require__(10),
+	  supermodel: __webpack_require__(11)
 	};
 
-	kb.injectViewModels = kb.Inject.injectViewModels;
+	kb.orm = ALL_ORMS["default"];
 
-	if (typeof document !== "undefined" && document !== null) {
-	  if ($) {
-	    $(function() {
-	      return kb.injectViewModels();
-	    });
-	  } else {
-	    (onReady = function() {
-	      if (document.readyState !== 'complete') {
-	        return setTimeout(onReady, 0);
-	      }
-	      return kb.injectViewModels();
-	    })();
+	for (key in ALL_ORMS) {
+	  value = ALL_ORMS[key];
+	  if (value && value.isAvailable()) {
+	    kb.orm = value;
+	    break;
 	  }
 	}
-	
-	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
+
+	module.exports = function(options) {
+	  var orm;
+	  if (options == null) {
+	    options = {};
+	  }
+	  for (key in options) {
+	    value = options[key];
+	    switch (key) {
+	      case 'orm':
+	        if (_.isString(value)) {
+	          if (!ALL_ORMS.hasOwnProperty(value)) {
+	            console.log("Knockback configure: could not find orm: " + value + ". Available: " + (_.keys(ALL_ORMS).join(', ')));
+	            continue;
+	          }
+	          if ((orm = ALL_ORMS[value]) && !orm.isAvailable()) {
+	            console.log("Knockback configure: could not enable orm " + value + ". Make sure it is included before Knockback");
+	            continue;
+	          }
+	          kb.orm = orm;
+	          continue;
+	        } else {
+	          kb.orm = value;
+	        }
+	        break;
+	      default:
+	        kb[key] = value;
+	    }
+	  }
+	};
+
 
 /***/ },
-/* 6 */
+/* 9 */
 /***/ function(module, exports, __webpack_require__) {
 
-	/* WEBPACK VAR INJECTION */(function(global) {
+	
 	/*
-	  knockback.js 0.20.5
+	  knockback.js 1.0.0
 	  Copyright (c)  2011-2014 Kevin Malakoff.
 	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
 	  Source: https://github.com/kmalakoff/knockback
 	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
 	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
 	 */
-	var Backbone, LIFECYCLE_METHODS, kb, ko, window, _;
+	var AssociatedModel, Backbone, BackboneAssociations, _, kb, ref;
 
-	window = window != null ? window : global;
+	ref = kb = __webpack_require__(2), _ = ref._, Backbone = ref.Backbone;
 
-	ko = __webpack_require__(20);
+	AssociatedModel = null;
 
-	LIFECYCLE_METHODS = ['release', 'destroy', 'dispose'];
+	module.exports = BackboneAssociations = (function() {
+	  function BackboneAssociations() {}
 
-	module.exports = kb = (function() {
-	  var _ref;
+	  BackboneAssociations.isAvailable = function() {
+	    return !!(AssociatedModel = Backbone != null ? Backbone.AssociatedModel : void 0);
+	  };
 
-	  function kb() {}
+	  BackboneAssociations.keys = function(model) {
+	    if (!(model instanceof AssociatedModel)) {
+	      return null;
+	    }
+	    return _.map(model.relations, function(test) {
+	      return test.key;
+	    });
+	  };
 
-	  kb.VERSION = '0.20.5';
+	  BackboneAssociations.relationType = function(model, key) {
+	    var relation;
+	    if (!(model instanceof AssociatedModel)) {
+	      return null;
+	    }
+	    if (!(relation = _.find(model.relations, function(test) {
+	      return test.key === key;
+	    }))) {
+	      return null;
+	    }
+	    if (relation.type === 'Many') {
+	      return kb.TYPE_COLLECTION;
+	    } else {
+	      return kb.TYPE_MODEL;
+	    }
+	  };
 
-	  kb.TYPE_UNKNOWN = 0;
+	  BackboneAssociations.useFunction = function() {
+	    return false;
+	  };
 
-	  kb.TYPE_SIMPLE = 1;
+	  return BackboneAssociations;
 
-	  kb.TYPE_ARRAY = 2;
+	})();
 
-	  kb.TYPE_MODEL = 3;
 
-	  kb.TYPE_COLLECTION = 4;
+/***/ },
+/* 10 */
+/***/ function(module, exports, __webpack_require__) {
 
-	  kb.wasReleased = function(obj) {
-	    return !obj || obj.__kb_released;
+	
+	/*
+	  knockback.js 1.0.0
+	  Copyright (c)  2011-2014 Kevin Malakoff.
+	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
+	  Source: https://github.com/kmalakoff/knockback
+	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
+	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
+	 */
+	var Backbone, BackboneRelational, RelationalModel, _, kb, ref;
+
+	ref = kb = __webpack_require__(2), _ = ref._, Backbone = ref.Backbone;
+
+	RelationalModel = null;
+
+	module.exports = BackboneRelational = (function() {
+	  function BackboneRelational() {}
+
+	  BackboneRelational.isAvailable = function() {
+	    return !!(RelationalModel = Backbone != null ? Backbone.RelationalModel : void 0);
 	  };
 
-	  kb.isReleaseable = function(obj, depth) {
-	    var key, method, value, _i, _len;
-	    if (depth == null) {
-	      depth = 0;
+	  BackboneRelational.relationType = function(model, key) {
+	    var relation;
+	    if (!(model instanceof RelationalModel)) {
+	      return null;
 	    }
-	    if ((!obj || (obj !== Object(obj))) || obj.__kb_released) {
-	      return false;
+	    if (!(relation = _.find(model.getRelations(), function(test) {
+	      return test.key === key;
+	    }))) {
+	      return null;
 	    }
-	    if (ko.isObservable(obj) || (obj instanceof kb.ViewModel)) {
-	      return true;
+	    if (relation.collectionType || _.isArray(relation.keyContents)) {
+	      return kb.TYPE_COLLECTION;
+	    } else {
+	      return kb.TYPE_MODEL;
 	    }
-	    if ((typeof obj === 'function') || kb.isModel(obj) || kb.isCollection(obj)) {
-	      return false;
+	  };
+
+	  BackboneRelational.bind = function(model, key, update, path) {
+	    var event, events, i, len, rel_fn, type;
+	    if (!(type = this.relationType(model, key))) {
+	      return null;
 	    }
-	    for (_i = 0, _len = LIFECYCLE_METHODS.length; _i < _len; _i++) {
-	      method = LIFECYCLE_METHODS[_i];
-	      if (typeof obj[method] === 'function') {
-	        return true;
+	    rel_fn = function(model) {
+	      !kb.statistics || kb.statistics.addModelEvent({
+	        name: 'update (relational)',
+	        model: model,
+	        key: key,
+	        path: path
+	      });
+	      return update();
+	    };
+	    events = kb.Backbone.Relation.prototype.sanitizeOptions ? ['update', 'add', 'remove'] : ['change', 'add', 'remove'];
+	    if (type === kb.TYPE_COLLECTION) {
+	      for (i = 0, len = events.length; i < len; i++) {
+	        event = events[i];
+	        model.bind(event + ":" + key, rel_fn);
 	      }
+	    } else {
+	      model.bind(events[0] + ":" + key, rel_fn);
 	    }
-	    if (depth > 0) {
-	      return false;
-	    }
-	    for (key in obj) {
-	      value = obj[key];
-	      if ((key !== '__kb') && kb.isReleaseable(value, depth + 1)) {
-	        return true;
-	      }
-	    }
-	    return false;
-	  };
-
-	  kb.release = function(obj) {
-	    var array, index, method, value, _i, _len;
-	    if (!kb.isReleaseable(obj)) {
-	      return;
-	    }
-	    obj.__kb_released = true;
-	    if (_.isArray(obj)) {
-	      for (index in obj) {
-	        value = obj[index];
-	        if (kb.isReleaseable(value)) {
-	          obj[index] = null;
-	          kb.release(value);
-	        }
-	      }
-	      return;
-	    }
-	    if (ko.isObservable(obj) && _.isArray(array = kb.peek(obj))) {
-	      if (obj.__kb_is_co || (obj.__kb_is_o && (obj.valueType() === kb.TYPE_COLLECTION))) {
-	        return typeof obj.destroy === "function" ? obj.destroy() : void 0;
-	      }
-	      for (index in array) {
-	        value = array[index];
-	        if (kb.isReleaseable(value)) {
-	          array[index] = null;
-	          kb.release(value);
+	    return function() {
+	      var j, len1;
+	      if (type === kb.TYPE_COLLECTION) {
+	        for (j = 0, len1 = events.length; j < len1; j++) {
+	          event = events[j];
+	          model.unbind(event + ":" + key, rel_fn);
 	        }
+	      } else {
+	        model.unbind(events[0] + ":" + key, rel_fn);
 	      }
-	      if (typeof obj.dispose === 'function') {
-	        obj.dispose();
-	      }
-	      return;
-	    }
-	    for (_i = 0, _len = LIFECYCLE_METHODS.length; _i < _len; _i++) {
-	      method = LIFECYCLE_METHODS[_i];
-	      if (typeof obj[method] === 'function') {
-	        return obj[method].call(obj);
-	      }
-	    }
-	    if (!ko.isObservable(obj)) {
-	      return this.releaseKeys(obj);
-	    }
+	    };
 	  };
 
-	  kb.releaseKeys = function(obj) {
-	    var key, value;
-	    for (key in obj) {
-	      value = obj[key];
-	      if (key !== '__kb' && kb.isReleaseable(value)) {
-	        obj[key] = null;
-	        kb.release(value);
-	      }
-	    }
+	  BackboneRelational.useFunction = function() {
+	    return false;
 	  };
 
-	  kb.releaseOnNodeRemove = function(view_model, node) {
-	    view_model || kb._throwUnexpected(this, 'missing view model');
-	    node || kb._throwUnexpected(this, 'missing node');
-	    return ko.utils.domNodeDisposal.addDisposeCallback(node, function() {
-	      return kb.release(view_model);
-	    });
-	  };
+	  return BackboneRelational;
 
-	  kb.renderTemplate = function(template, view_model, options) {
-	    var document, el, observable;
-	    if (options == null) {
-	      options = {};
-	    }
-	    if (!(document = window != null ? window.document : void 0)) {
-	      return typeof console !== "undefined" && console !== null ? console.log('renderTemplate: document is undefined') : void 0;
-	    }
-	    el = document.createElement('div');
-	    observable = ko.renderTemplate(template, view_model, options, el, 'replaceChildren');
-	    if (el.childNodes.length === 1) {
-	      el = el.childNodes[0];
-	    } else if (el.childNodes.length) {
-	      ko.storedBindingContextForNode(el, ko.contextFor(el.childNodes[0]));
-	    }
-	    kb.releaseOnNodeRemove(view_model, el);
-	    observable.dispose();
-	    if (view_model.afterRender && !options.afterRender) {
-	      view_model.afterRender(el);
-	    }
-	    return el;
-	  };
+	})();
 
-	  kb.applyBindings = function(view_model, node) {
-	    var child, children, _i, _len, _ref;
-	    if (node.length) {
-	      _ref = [document.createElement('div'), node], node = _ref[0], children = _ref[1];
-	      for (_i = 0, _len = children.length; _i < _len; _i++) {
-	        child = children[_i];
-	        node.appendChild(child);
-	      }
-	    }
-	    ko.applyBindings(view_model, node);
-	    kb.releaseOnNodeRemove(view_model, node);
-	    return node;
-	  };
 
-	  kb.getValue = function(model, key, args) {
-	    var _ref;
-	    if (!model) {
-	      return;
-	    }
-	    if (_.isFunction(model[key]) && ((_ref = kb.orm) != null ? _ref.useFunction(model, key) : void 0)) {
-	      return model[key]();
-	    }
-	    if (!args) {
-	      return model.get(key);
-	    }
-	    return model.get.apply(model, _.map([key].concat(args), function(value) {
-	      return kb.peek(value);
-	    }));
-	  };
+/***/ },
+/* 11 */
+/***/ function(module, exports, __webpack_require__) {
 
-	  kb.setValue = function(model, key, value) {
-	    var attributes, _ref;
-	    if (!model) {
-	      return;
-	    }
-	    if (_.isFunction(model[key]) && ((_ref = kb.orm) != null ? _ref.useFunction(model, key) : void 0)) {
-	      return model[key](value);
-	    }
-	    (attributes = {})[key] = value;
-	    return model.set(attributes);
-	  };
+	/* WEBPACK VAR INJECTION */(function(global) {
+	/*
+	  knockback.js 1.0.0
+	  Copyright (c)  2011-2014 Kevin Malakoff.
+	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
+	  Source: https://github.com/kmalakoff/knockback
+	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
+	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
+	 */
+	var Supermodel, _, kb, root;
 
-	  kb.ignore = ((_ref = ko.dependencyDetection) != null ? _ref.ignore : void 0) || function(callback, callbackTarget, callbackArgs) {
-	    var value;
-	    value = null;
-	    ko.computed(function() {
-	      return value = callback.apply(callbackTarget, callbackArgs || []);
-	    }).dispose();
-	    return value;
-	  };
+	root = typeof window !== "undefined" && window !== null ? window : global;
 
-	  kb.extend = __webpack_require__(29);
+	_ = (kb = __webpack_require__(2))._;
 
-	  kb._throwMissing = function(instance, message) {
-	    throw "" + (_.isString(instance) ? instance : instance.constructor.name) + ": " + message + " is missing";
-	  };
+	Supermodel = null;
 
-	  kb._throwUnexpected = function(instance, message) {
-	    throw "" + (_.isString(instance) ? instance : instance.constructor.name) + ": " + message + " is unexpected";
+	module.exports = Supermodel = (function() {
+	  function Supermodel() {}
+
+	  Supermodel.isAvailable = function() {
+	    return !!(Supermodel = root.Supermodel);
 	  };
 
-	  kb.publishMethods = function(observable, instance, methods) {
-	    var fn, _i, _len;
-	    for (_i = 0, _len = methods.length; _i < _len; _i++) {
-	      fn = methods[_i];
-	      observable[fn] = kb._.bind(instance[fn], instance);
+	  Supermodel.keys = function(model) {
+	    if (!(model instanceof Supermodel.Model)) {
+	      return null;
 	    }
+	    return _.keys(model.constructor.associations());
 	  };
 
-	  kb.peek = function(obs) {
-	    if (!ko.isObservable(obs)) {
-	      return obs;
+	  Supermodel.relationType = function(model, key) {
+	    var relation;
+	    if (!(model instanceof Supermodel.Model)) {
+	      return null;
 	    }
-	    if (obs.peek) {
-	      return obs.peek();
+	    if (!(relation = model.constructor.associations()[key])) {
+	      return null;
+	    }
+	    if (relation.add) {
+	      return kb.TYPE_COLLECTION;
+	    } else {
+	      return kb.TYPE_MODEL;
 	    }
-	    return kb.ignore(function() {
-	      return obs();
-	    });
 	  };
 
-	  kb.isModel = function(obj) {
-	    return obj && ((obj instanceof kb.Model) || ((typeof obj.get === 'function') && (typeof obj.bind === 'function')));
+	  Supermodel.bind = function(model, key, update, path) {
+	    var rel_fn, type;
+	    if (!(type = this.relationType(model, key))) {
+	      return null;
+	    }
+	    rel_fn = function(model, other) {
+	      var previous, relation;
+	      !kb.statistics || kb.statistics.addModelEvent({
+	        name: 'update (supermodel)',
+	        model: model,
+	        key: key,
+	        path: path
+	      });
+	      relation = model.constructor.associations()[key];
+	      previous = model[relation.store];
+	      model[relation.store] = other;
+	      update(other);
+	      return model[relation.store] = previous;
+	    };
+	    if (type === kb.TYPE_MODEL) {
+	      model.bind("associate:" + key, rel_fn);
+	      return function() {
+	        return model.unbind("associate:" + key, rel_fn);
+	      };
+	    }
 	  };
 
-	  kb.isCollection = function(obj) {
-	    return obj && (obj instanceof kb.Collection);
+	  Supermodel.useFunction = function(model, key) {
+	    return !!this.relationType(model, key);
 	  };
 
-	  return kb;
+	  return Supermodel;
 
 	})();
 
-	if (window.Parse) {
-	  Backbone = kb.Parse = window.Parse;
-	  _ = kb._ = window.Parse._;
-	} else {
-	  Backbone = kb.Backbone = __webpack_require__(21);
-	  _ = kb._ = __webpack_require__(22);
-	}
-
-	kb.ko = ko;
-
-	kb.Collection = Backbone.Collection;
-
-	kb.Model = Backbone.Object || Backbone.Model;
-
-	kb.Events = Backbone.Events;
-
-	kb.$ = window.jQuery || window.$;
-
-	try {
-	  kb.$ || (kb.$ = __webpack_require__(23));
-	} catch (_error) {}
-	
 	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
 
 /***/ },
-/* 7 */
+/* 12 */
 /***/ function(module, exports, __webpack_require__) {
 
 	
 	/*
-	  knockback.js 0.20.5
+	  knockback.js 1.0.0
 	  Copyright (c)  2011-2014 Kevin Malakoff.
 	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
 	  Source: https://github.com/kmalakoff/knockback
 	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
 	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
 	 */
-	var kb, ko, _extend, _ref, _ref1;
+	var _, kb, ko, ref,
+	  bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
 
-	ko = (kb = __webpack_require__(6)).ko;
+	ref = kb = __webpack_require__(2), _ = ref._, ko = ref.ko;
 
-	if ((_ref = ko.subscribable) != null ? (_ref1 = _ref.fn) != null ? _ref1.extend : void 0 : void 0) {
-	  _extend = ko.subscribable.fn.extend;
-	  ko.subscribable.fn.extend = function() {
-	    var target, _dispose;
-	    target = _extend.apply(this, arguments);
-	    if (target !== this && kb.isReleaseable(this)) {
-	      _dispose = target.dispose;
-	      target.dispose = (function(_this) {
-	        return function() {
-	          if (_dispose != null) {
-	            _dispose.apply(target, arguments);
-	          }
-	          return kb.release(_this);
-	        };
-	      })(this);
+	kb.EventWatcher = (function() {
+	  EventWatcher.useOptionsOrCreate = function(options, emitter, obj, callback_options) {
+	    if (options.event_watcher) {
+	      if (!(options.event_watcher.emitter() === emitter || (options.event_watcher.model_ref === emitter))) {
+	        kb._throwUnexpected(this, 'emitter not matching');
+	      }
+	      return kb.utils.wrappedEventWatcher(obj, options.event_watcher).registerCallbacks(obj, callback_options);
+	    } else {
+	      kb.utils.wrappedEventWatcherIsOwned(obj, true);
+	      return kb.utils.wrappedEventWatcher(obj, new kb.EventWatcher(emitter)).registerCallbacks(obj, callback_options);
 	    }
-	    return target;
 	  };
-	}
 
+	  function EventWatcher(emitter, obj, callback_options) {
+	    this._unbindCallbacks = bind(this._unbindCallbacks, this);
+	    this._onModelUnloaded = bind(this._onModelUnloaded, this);
+	    this._onModelLoaded = bind(this._onModelLoaded, this);
+	    this.__kb || (this.__kb = {});
+	    this.__kb.callbacks = {};
+	    this.ee = null;
+	    if (callback_options) {
+	      this.registerCallbacks(obj, callback_options);
+	    }
+	    if (emitter) {
+	      this.emitter(emitter);
+	    }
+	  }
 
-/***/ },
-/* 8 */
-/***/ function(module, exports, __webpack_require__) {
-
-	
-	/*
-	  knockback.js 0.20.5
-	  Copyright (c)  2011-2014 Kevin Malakoff.
-	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
-	  Source: https://github.com/kmalakoff/knockback
-	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
-	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
-	 */
-	var KEYS_INFO, KEYS_PUBLISH, TypedValue, kb, ko, _, _ref;
-
-	_ref = kb = __webpack_require__(6), _ = _ref._, ko = _ref.ko;
-
-	TypedValue = __webpack_require__(11);
-
-	KEYS_PUBLISH = ['value', 'valueType', 'destroy'];
+	  EventWatcher.prototype.destroy = function() {
+	    this.emitter(null);
+	    this.__kb.callbacks = null;
+	    return kb.utils.wrappedDestroy(this);
+	  };
 
-	KEYS_INFO = ['args', 'read', 'write'];
+	  EventWatcher.prototype.emitter = function(new_emitter) {
+	    if ((arguments.length === 0) || (this.ee === new_emitter)) {
+	      return this.ee;
+	    }
+	    if (this.model_ref) {
+	      this.model_ref.unbind('loaded', this._onModelLoaded);
+	      this.model_ref.unbind('unloaded', this._onModelUnloaded);
+	      this.model_ref.release();
+	      this.model_ref = null;
+	    }
+	    if (kb.Backbone && kb.Backbone.ModelRef && (new_emitter instanceof kb.Backbone.ModelRef)) {
+	      this.model_ref = new_emitter;
+	      this.model_ref.retain();
+	      this.model_ref.bind('loaded', this._onModelLoaded);
+	      this.model_ref.bind('unloaded', this._onModelUnloaded);
+	      new_emitter = this.model_ref.model() || null;
+	    } else {
+	      delete this.model_ref;
+	    }
+	    if (this.ee !== new_emitter) {
+	      if (new_emitter) {
+	        this._onModelLoaded(new_emitter);
+	      } else {
+	        this._onModelUnloaded(this.ee);
+	      }
+	    }
+	    return new_emitter;
+	  };
 
-	kb.Observable = (function() {
-	  function Observable(model, key_or_info, options, _vm) {
-	    this._vm = _vm != null ? _vm : {};
-	    return kb.ignore((function(_this) {
-	      return function() {
-	        var create_options, event_watcher, key, observable, _i, _len;
-	        key_or_info || kb._throwMissing(_this, 'key_or_info');
-	        _this.key = key_or_info.key || key_or_info;
-	        for (_i = 0, _len = KEYS_INFO.length; _i < _len; _i++) {
-	          key = KEYS_INFO[_i];
-	          if (key_or_info[key]) {
-	            _this[key] = key_or_info[key];
-	          }
-	        }
-	        create_options = kb.utils.collapseOptions(options);
-	        event_watcher = create_options.event_watcher;
-	        delete create_options.event_watcher;
-	        _this._value = new TypedValue(create_options);
-	        _this._model = ko.observable();
-	        observable = kb.utils.wrappedObservable(_this, ko.computed({
-	          read: function() {
-	            var arg, args, _j, _len1, _model, _ref1, _ref2;
-	            _model = _this._model();
-	            _ref1 = args = [_this.key].concat(_this.args || []);
-	            for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
-	              arg = _ref1[_j];
-	              ko.utils.unwrapObservable(arg);
-	            }
-	            if ((_ref2 = kb.utils.wrappedEventWatcher(_this)) != null) {
-	              _ref2.emitter(_model || null);
-	            }
-	            if (_this.read) {
-	              _this.update(_this.read.apply(_this._vm, args));
-	            } else if (!_.isUndefined(_model)) {
-	              kb.ignore(function() {
-	                return _this.update(kb.getValue(_model, kb.peek(_this.key), _this.args));
-	              });
-	            }
-	            return _this._value.value();
-	          },
-	          write: function(new_value) {
-	            return kb.ignore(function() {
-	              var unwrapped_new_value, _model;
-	              unwrapped_new_value = kb.utils.unwrapModels(new_value);
-	              _model = kb.peek(_this._model);
-	              if (_this.write) {
-	                _this.write.call(_this._vm, unwrapped_new_value);
-	                new_value = kb.getValue(_model, kb.peek(_this.key), _this.args);
-	              } else if (_model) {
-	                kb.setValue(_model, kb.peek(_this.key), unwrapped_new_value);
-	              }
-	              return _this.update(new_value);
-	            });
-	          },
-	          owner: _this._vm
-	        }));
-	        observable.__kb_is_o = true;
-	        create_options.store = kb.utils.wrappedStore(observable, create_options.store);
-	        create_options.path = kb.utils.pathJoin(create_options.path, _this.key);
-	        if (create_options.factories && ((typeof create_options.factories === 'function') || create_options.factories.create)) {
-	          create_options.factory = kb.utils.wrappedFactory(observable, new kb.Factory(create_options.factory));
-	          create_options.factory.addPathMapping(create_options.path, create_options.factories);
-	        } else {
-	          create_options.factory = kb.Factory.useOptionsOrCreate(create_options, observable, create_options.path);
-	        }
-	        delete create_options.factories;
-	        kb.publishMethods(observable, _this, KEYS_PUBLISH);
-	        observable.model = _this.model = ko.computed({
-	          read: function() {
-	            return ko.utils.unwrapObservable(_this._model);
-	          },
-	          write: function(new_model) {
-	            return kb.ignore(function() {
-	              var new_value;
-	              if (_this.__kb_released || (kb.peek(_this._model) === new_model)) {
-	                return;
-	              }
-	              new_value = kb.getValue(new_model, kb.peek(_this.key), _this.args);
-	              _this._model(new_model);
-	              if (!new_model) {
-	                return _this.update(null);
-	              } else if (!_.isUndefined(new_value)) {
-	                return _this.update(new_value);
+	  EventWatcher.prototype.registerCallbacks = function(obj, callback_info) {
+	    var event_name, event_names, fn, i, len, model;
+	    obj || kb._throwMissing(this, 'obj');
+	    callback_info || kb._throwMissing(this, 'callback_info');
+	    event_names = callback_info.event_selector ? callback_info.event_selector.split(' ') : ['change'];
+	    model = this.ee;
+	    fn = (function(_this) {
+	      return function(event_name) {
+	        var callbacks, info;
+	        if (!(callbacks = _this.__kb.callbacks[event_name])) {
+	          callbacks = _this.__kb.callbacks[event_name] = {
+	            model: null,
+	            list: [],
+	            fn: function(model) {
+	              var info, j, len1, ref1;
+	              ref1 = callbacks.list;
+	              for (j = 0, len1 = ref1.length; j < len1; j++) {
+	                info = ref1[j];
+	                if (!info.update) {
+	                  continue;
+	                }
+	                if (model && info.key && (model.hasChanged && !model.hasChanged(ko.utils.unwrapObservable(info.key)))) {
+	                  continue;
+	                }
+	                !kb.statistics || kb.statistics.addModelEvent({
+	                  name: event_name,
+	                  model: model,
+	                  key: info.key,
+	                  path: info.path
+	                });
+	                info.update();
 	              }
-	            });
-	          }
-	        });
-	        kb.EventWatcher.useOptionsOrCreate({
-	          event_watcher: event_watcher
-	        }, model || null, _this, {
-	          emitter: _this.model,
-	          update: (function() {
-	            return kb.ignore(function() {
-	              return _this.update();
-	            });
-	          }),
-	          key: _this.key,
-	          path: create_options.path
-	        });
-	        _this._value.rawValue() || _this._value.update();
-	        if (kb.LocalizedObservable && key_or_info.localizer) {
-	          observable = new key_or_info.localizer(observable);
+	              return null;
+	            }
+	          };
 	        }
-	        if (kb.DefaultObservable && key_or_info.hasOwnProperty('default')) {
-	          observable = kb.defaultObservable(observable, key_or_info["default"]);
+	        callbacks.list.push(info = _.defaults({
+	          obj: obj
+	        }, callback_info));
+	        if (model) {
+	          return _this._onModelLoaded(model);
 	        }
-	        return observable;
 	      };
-	    })(this));
-	  }
-
-	  Observable.prototype.destroy = function() {
-	    var observable;
-	    observable = kb.utils.wrappedObservable(this);
-	    this.__kb_released = true;
-	    this._value.destroy();
-	    this._value = null;
-	    this.model.dispose();
-	    this.model = observable.model = null;
-	    return kb.utils.wrappedDestroy(this);
+	    })(this);
+	    for (i = 0, len = event_names.length; i < len; i++) {
+	      event_name = event_names[i];
+	      if (!event_name) {
+	        continue;
+	      }
+	      fn(event_name);
+	    }
+	    return this;
 	  };
 
-	  Observable.prototype.value = function() {
-	    return this._value.rawValue();
+	  EventWatcher.prototype.releaseCallbacks = function(obj) {
+	    var callbacks, event_name, ref1;
+	    this.ee = null;
+	    ref1 = this.__kb.callbacks;
+	    for (event_name in ref1) {
+	      callbacks = ref1[event_name];
+	      this._unbindCallbacks(event_name, callbacks, kb.wasReleased(obj));
+	    }
+	    return delete this.__kb.callbacks;
 	  };
 
-	  Observable.prototype.valueType = function() {
-	    return this._value.valueType(kb.peek(this._model), kb.peek(this.key));
+	  EventWatcher.prototype._onModelLoaded = function(model) {
+	    var callbacks, event_name, i, info, len, ref1, ref2, ref3;
+	    this.ee = model;
+	    ref1 = this.__kb.callbacks;
+	    for (event_name in ref1) {
+	      callbacks = ref1[event_name];
+	      if (callbacks.model && (callbacks.model !== model)) {
+	        this._unbindCallbacks(event_name, callbacks, true);
+	      }
+	      if (!callbacks.model) {
+	        callbacks.model = model;
+	        model.bind(event_name, callbacks.fn);
+	      }
+	      ref2 = callbacks.list;
+	      for (i = 0, len = ref2.length; i < len; i++) {
+	        info = ref2[i];
+	        info.unbind_fn || (info.unbind_fn = (ref3 = kb.orm) != null ? ref3.bind(model, info.key, info.update, info.path) : void 0);
+	        if (info.emitter) {
+	          info.emitter(model);
+	        }
+	      }
+	    }
 	  };
 
-	  Observable.prototype.update = function(new_value) {
-	    if (this.__kb_released) {
+	  EventWatcher.prototype._onModelUnloaded = function(model) {
+	    var callbacks, event_name, ref1;
+	    if (this.ee !== model) {
 	      return;
 	    }
-	    if (!arguments.length) {
-	      new_value = kb.getValue(kb.peek(this._model), kb.peek(this.key));
+	    this.ee = null;
+	    ref1 = this.__kb.callbacks;
+	    for (event_name in ref1) {
+	      callbacks = ref1[event_name];
+	      this._unbindCallbacks(event_name, callbacks);
 	    }
-	    return this._value.update(new_value);
 	  };
 
-	  return Observable;
+	  EventWatcher.prototype._unbindCallbacks = function(event_name, callbacks, skip_emitter) {
+	    var i, info, len, ref1;
+	    if (callbacks.model) {
+	      callbacks.model.unbind(event_name, callbacks.fn);
+	      callbacks.model = null;
+	    }
+	    ref1 = callbacks.list;
+	    for (i = 0, len = ref1.length; i < len; i++) {
+	      info = ref1[i];
+	      if (info.unbind_fn) {
+	        info.unbind_fn();
+	        info.unbind_fn = null;
+	      }
+	      if (info.emitter && !skip_emitter && !kb.wasReleased(info.obj)) {
+	        info.emitter(null);
+	      }
+	    }
+	  };
+
+	  return EventWatcher;
 
 	})();
 
-	kb.observable = function(model, key, options, view_model) {
-	  return new kb.Observable(model, key, options, view_model);
+	kb.emitterObservable = function(emitter, observable) {
+	  return new kb.EventWatcher(emitter, observable);
 	};
 
 
 /***/ },
-/* 9 */
+/* 13 */
 /***/ function(module, exports, __webpack_require__) {
 
 	
 	/*
-	  knockback.js 0.20.5
+	  knockback.js 1.0.0
 	  Copyright (c)  2011-2014 Kevin Malakoff.
 	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
 	  Source: https://github.com/kmalakoff/knockback
 	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
 	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
 	 */
-	var kb, _;
+	var _, kb;
 
-	_ = (kb = __webpack_require__(6))._;
+	_ = (kb = __webpack_require__(2))._;
 
-	module.exports = kb.Statistics = (function() {
-	  function Statistics() {
-	    this.model_events_tracker = [];
-	    this.registered_tracker = {};
+	kb.Factory = (function() {
+	  Factory.useOptionsOrCreate = function(options, obj, owner_path) {
+	    var factory;
+	    if (options.factory && (!options.factories || (options.factories && options.factory.hasPathMappings(options.factories, owner_path)))) {
+	      return kb.utils.wrappedFactory(obj, options.factory);
+	    }
+	    factory = kb.utils.wrappedFactory(obj, new kb.Factory(options.factory));
+	    if (options.factories) {
+	      factory.addPathMappings(options.factories, owner_path);
+	    }
+	    return factory;
+	  };
+
+	  function Factory(parent_factory) {
+	    this.paths = {};
+	    if (parent_factory) {
+	      this.parent_factory = parent_factory;
+	    }
 	  }
 
-	  Statistics.prototype.clear = function() {
-	    return this.model_events_tracker = [];
+	  Factory.prototype.hasPath = function(path) {
+	    var ref;
+	    return this.paths.hasOwnProperty(path) || ((ref = this.parent_factory) != null ? ref.hasPath(path) : void 0);
 	  };
 
-	  Statistics.prototype.addModelEvent = function(event) {
-	    return this.model_events_tracker.push(event);
+	  Factory.prototype.addPathMapping = function(path, create_info) {
+	    return this.paths[path] = create_info;
 	  };
 
-	  Statistics.prototype.modelEventsStatsString = function() {
-	    var event_groups, key, stats_string, value;
-	    stats_string = '';
-	    stats_string += "Total Count: " + this.model_events_tracker.length;
-	    event_groups = _.groupBy(this.model_events_tracker, function(test) {
-	      return "event name: '" + test.name + "', attribute name: '" + test.key + "'";
-	    });
-	    for (key in event_groups) {
-	      value = event_groups[key];
-	      stats_string += "\n " + key + ", count: " + value.length;
+	  Factory.prototype.addPathMappings = function(factories, owner_path) {
+	    var create_info, path;
+	    for (path in factories) {
+	      create_info = factories[path];
+	      this.paths[kb.utils.pathJoin(owner_path, path)] = create_info;
 	    }
-	    return stats_string;
 	  };
 
-	  Statistics.prototype.register = function(key, obj) {
-	    return this.registeredTracker(key).push(obj);
-	  };
-
-	  Statistics.prototype.unregister = function(key, obj) {
-	    var index, type_tracker;
-	    type_tracker = this.registeredTracker(key);
-	    if ((index = _.indexOf(type_tracker, obj)) < 0) {
-	      return typeof console !== "undefined" && console !== null ? console.log("kb.Statistics: failed to unregister type: " + key) : void 0;
+	  Factory.prototype.hasPathMappings = function(factories, owner_path) {
+	    var all_exist, creator, existing_creator, path;
+	    all_exist = true;
+	    for (path in factories) {
+	      creator = factories[path];
+	      all_exist &= (existing_creator = this.creatorForPath(null, kb.utils.pathJoin(owner_path, path))) && (creator === existing_creator);
 	    }
-	    return type_tracker.splice(index, 1);
+	    return all_exist;
 	  };
 
-	  Statistics.prototype.registeredCount = function(type) {
-	    var count, type_tracker, _ref;
-	    if (type) {
-	      return this.registeredTracker(type).length;
+	  Factory.prototype.creatorForPath = function(obj, path) {
+	    var creator, ref;
+	    if (creator = this.paths[path]) {
+	      return (creator.view_model ? creator.view_model : creator);
 	    }
-	    count = 0;
-	    _ref = this.registered_tracker[type];
-	    for (type in _ref) {
-	      type_tracker = _ref[type];
-	      count += type_tracker.length;
+	    if (creator = (ref = this.parent_factory) != null ? ref.creatorForPath(obj, path) : void 0) {
+	      return creator;
 	    }
-	    return count;
+	    return null;
 	  };
 
-	  Statistics.prototype.registeredStatsString = function(success_message) {
-	    var stats_string, type, type_tracker, written, _ref;
-	    stats_string = '';
-	    _ref = this.registered_tracker;
-	    for (type in _ref) {
-	      type_tracker = _ref[type];
-	      if (!type_tracker.length) {
-	        continue;
-	      }
-	      if (written) {
-	        stats_string += '\n ';
+	  return Factory;
+
+	})();
+
+
+/***/ },
+/* 14 */
+/***/ function(module, exports, __webpack_require__) {
+
+	/* WEBPACK VAR INJECTION */(function(global) {
+	/*
+	  knockback.js 1.0.0
+	  Copyright (c)  2011-2014 Kevin Malakoff.
+	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
+	  Source: https://github.com/kmalakoff/knockback
+	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
+	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
+	 */
+	var $, _, _ko_applyBindings, kb, ko, onReady, ref, window;
+
+	window = window != null ? window : global;
+
+	ref = kb = __webpack_require__(2), _ = ref._, ko = ref.ko, $ = ref.$;
+
+	kb.RECUSIVE_AUTO_INJECT = true;
+
+	ko.bindingHandlers['inject'] = {
+	  'init': function(element, value_accessor, all_bindings_accessor, view_model) {
+	    return kb.Inject.inject(ko.utils.unwrapObservable(value_accessor()), view_model, element, value_accessor, all_bindings_accessor);
+	  }
+	};
+
+	kb.Inject = (function() {
+	  function Inject() {}
+
+	  Inject.inject = function(data, view_model, element, value_accessor, all_bindings_accessor, nested) {
+	    var inject;
+	    inject = function(data) {
+	      var key, target, value;
+	      if (_.isFunction(data)) {
+	        view_model = new data(view_model, element, value_accessor, all_bindings_accessor);
+	        kb.releaseOnNodeRemove(view_model, element);
+	      } else {
+	        if (data.view_model) {
+	          view_model = new data.view_model(view_model, element, value_accessor, all_bindings_accessor);
+	          kb.releaseOnNodeRemove(view_model, element);
+	        }
+	        for (key in data) {
+	          value = data[key];
+	          if (key === 'view_model') {
+	            continue;
+	          }
+	          if (key === 'create') {
+	            value(view_model, element, value_accessor, all_bindings_accessor);
+	          } else if (_.isObject(value) && !_.isFunction(value)) {
+	            target = nested || (value && value.create) ? {} : view_model;
+	            view_model[key] = kb.Inject.inject(value, target, element, value_accessor, all_bindings_accessor, true);
+	          } else {
+	            view_model[key] = value;
+	          }
+	        }
 	      }
-	      stats_string += "" + (type ? type : 'No Name') + ": " + type_tracker.length;
-	      written = true;
-	    }
-	    if (stats_string) {
-	      return stats_string;
+	      return view_model;
+	    };
+	    if (nested) {
+	      return inject(data);
 	    } else {
-	      return success_message;
+	      return kb.ignore(function() {
+	        return inject(data);
+	      });
 	    }
 	  };
 
-	  Statistics.prototype.registeredTracker = function(key) {
-	    var type_tracker;
-	    if (this.registered_tracker.hasOwnProperty(key)) {
-	      return this.registered_tracker[key];
-	    }
-	    type_tracker = [];
-	    this.registered_tracker[key] = type_tracker;
-	    return type_tracker;
-	  };
-
-	  Statistics.eventsStats = function(obj, key) {
-	    var events, node, stats, tail, _i, _len, _ref;
-	    stats = {
-	      count: 0
+	  Inject.injectViewModels = function(root) {
+	    var afterBinding, app, beforeBinding, data, expression, findElements, i, len, options, results;
+	    results = [];
+	    findElements = function(el) {
+	      var attr, child_el, i, len, ref1;
+	      if (!el.__kb_injected) {
+	        if (el.attributes && (attr = _.find(el.attributes, function(attr) {
+	          return attr.name === 'kb-inject';
+	        }))) {
+	          el.__kb_injected = true;
+	          results.push({
+	            el: el,
+	            view_model: {},
+	            binding: attr.value
+	          });
+	        }
+	      }
+	      ref1 = el.childNodes;
+	      for (i = 0, len = ref1.length; i < len; i++) {
+	        child_el = ref1[i];
+	        findElements(child_el);
+	      }
 	    };
-	    events = obj._events || obj._callbacks || {};
-	    _ref = (key ? [key] : _.keys(events));
-	    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-	      key = _ref[_i];
-	      if (!(node = events[key])) {
-	        continue;
+	    if (!root && (window != null ? window.document : void 0)) {
+	      root = window.document;
+	    }
+	    findElements(root);
+	    for (i = 0, len = results.length; i < len; i++) {
+	      app = results[i];
+	      if (expression = app.binding) {
+	        (expression.search(/[:]/) < 0) || (expression = "{" + expression + "}");
+	        data = (new Function("", "return ( " + expression + " )"))();
+	        data || (data = {});
+	        (!data.options) || (options = data.options, delete data.options);
+	        options || (options = {});
+	        app.view_model = kb.Inject.inject(data, app.view_model, app.el, null, null, true);
+	        afterBinding = app.view_model.afterBinding || options.afterBinding;
+	        beforeBinding = app.view_model.beforeBinding || options.beforeBinding;
 	      }
-	      if (_.isArray(node)) {
-	        stats[key] = _.compact(node).length;
-	      } else {
-	        stats[key] = 0;
-	        tail = node.tail;
-	        while ((node = node.next) !== tail) {
-	          stats[key]++;
-	        }
+	      if (beforeBinding) {
+	        beforeBinding.call(app.view_model, app.view_model, app.el, options);
+	      }
+	      kb.applyBindings(app.view_model, app.el, options);
+	      if (afterBinding) {
+	        afterBinding.call(app.view_model, app.view_model, app.el, options);
 	      }
-	      stats.count += stats[key];
 	    }
-	    return stats;
+	    return results;
 	  };
 
-	  return Statistics;
+	  return Inject;
 
 	})();
 
+	_ko_applyBindings = ko.applyBindings;
+
+	ko.applyBindings = function(context, element) {
+	  var results;
+	  results = kb.RECUSIVE_AUTO_INJECT ? kb.injectViewModels(element) : [];
+	  if (!results.length) {
+	    return _ko_applyBindings.apply(this, arguments);
+	  }
+	};
+
+	kb.injectViewModels = kb.Inject.injectViewModels;
+
+	if (typeof document !== "undefined" && document !== null) {
+	  if ($) {
+	    $(function() {
+	      return kb.injectViewModels();
+	    });
+	  } else {
+	    (onReady = function() {
+	      if (document.readyState !== 'complete') {
+	        return setTimeout(onReady, 0);
+	      }
+	      return kb.injectViewModels();
+	    })();
+	  }
+	}
+
+	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
 
 /***/ },
-/* 10 */
+/* 15 */
 /***/ function(module, exports, __webpack_require__) {
 
 	
 	/*
-	  knockback.js 0.20.5
+	  knockback.js 1.0.0
 	  Copyright (c)  2011-2014 Kevin Malakoff.
 	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
 	  Source: https://github.com/kmalakoff/knockback
 	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
 	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
 	 */
-	var kb, ko, _, _ref;
-
-	_ref = kb = __webpack_require__(6), _ = _ref._, ko = _ref.ko;
-
-	module.exports = kb.Store = (function() {
-	  Store.instances = [];
-
-	  Store.useOptionsOrCreate = function(options, obj, observable) {
-	    var store;
-	    if (!options.store) {
-	      kb.utils.wrappedStoreIsOwned(observable, true);
-	    }
-	    store = kb.utils.wrappedStore(observable, options.store || new kb.Store());
-	    store.retain(observable, obj, options.creator);
-	    return store;
-	  };
-
-	  function Store() {
-	    this.observable_records = {};
-	    this.replaced_observables = [];
-	    kb.Store.instances.push(this);
-	  }
-
-	  Store.prototype.destroy = function() {
-	    var index;
-	    this.__kb_released = true;
-	    this.clear();
-	    if ((index = _.indexOf(kb.Store.instances, this)) >= 0) {
-	      return kb.Store.instances.splice(index, 1);
-	    }
-	  };
-
-	  Store.prototype.clear = function() {
-	    var cid, creator_id, observable, observable_records, records, replaced_observables, _i, _len, _ref1, _ref2;
-	    _ref1 = [this.observable_records, {}], observable_records = _ref1[0], this.observable_records = _ref1[1];
-	    for (creator_id in observable_records) {
-	      records = observable_records[creator_id];
-	      for (cid in records) {
-	        observable = records[cid];
-	        this.release(observable, true);
-	      }
-	    }
-	    _ref2 = [this.replaced_observables, []], replaced_observables = _ref2[0], this.replaced_observables = _ref2[1];
-	    for (_i = 0, _len = replaced_observables.length; _i < _len; _i++) {
-	      observable = replaced_observables[_i];
-	      if (!observable.__kb_released) {
-	        this.release(observable, true);
-	      }
-	    }
-	  };
-
-	  Store.prototype.compact = function() {
-	    var cid, creator_id, observable, records, _ref1;
-	    _ref1 = this.observable_records;
-	    for (creator_id in _ref1) {
-	      records = _ref1[creator_id];
-	      for (cid in records) {
-	        observable = records[cid];
-	        if (observable.__kb_released) {
-	          delete records[cid];
-	        }
-	      }
-	    }
-	  };
+	var _extend, kb, ko, ref, ref1;
 
-	  Store.prototype.retain = function(observable, obj, creator) {
-	    var current_observable;
-	    if (!this._canRegister(observable)) {
-	      return;
-	    }
-	    creator || (creator = observable.constructor);
-	    if (current_observable = this.find(obj, creator)) {
-	      if (current_observable === observable) {
-	        this._getOrCreateStoreReferences(observable).ref_count++;
-	        return observable;
-	      }
-	      this._retire(current_observable);
-	    }
-	    this._add(observable, obj, creator);
-	    this._getOrCreateStoreReferences(observable).ref_count++;
-	    return observable;
-	  };
+	ko = (kb = __webpack_require__(2)).ko;
 
-	  Store.prototype.retainOrCreate = function(obj, options) {
-	    var creator, observable;
-	    if (!(creator = this._creator(obj, options))) {
-	      return kb.utils.createFromDefaultCreator(obj, options);
-	    }
-	    if (creator.models_only) {
-	      return obj;
-	    }
-	    if (observable = this.find(obj, creator)) {
-	      return observable;
-	    }
-	    if (!_.isFunction(creator.create || creator)) {
-	      throw new Error("Invalid factory for \"" + options.path + "\"");
+	if ((ref = ko.subscribable) != null ? (ref1 = ref.fn) != null ? ref1.extend : void 0 : void 0) {
+	  _extend = ko.subscribable.fn.extend;
+	  ko.subscribable.fn.extend = function() {
+	    var _dispose, target;
+	    target = _extend.apply(this, arguments);
+	    if (target !== this && kb.isReleaseable(this)) {
+	      _dispose = target.dispose;
+	      target.dispose = (function(_this) {
+	        return function() {
+	          if (_dispose != null) {
+	            _dispose.apply(target, arguments);
+	          }
+	          return kb.release(_this);
+	        };
+	      })(this);
 	    }
-	    observable = kb.ignore((function(_this) {
-	      return function() {
-	        options = _.defaults({
-	          store: _this,
-	          creator: creator
-	        }, options);
-	        observable = creator.create ? creator.create(obj, options) : new creator(obj, options);
-	        return observable || ko.observable(null);
-	      };
-	    })(this));
-	    this.retain(observable, obj, creator);
-	    return observable;
+	    return target;
 	  };
+	}
 
-	  Store.prototype.reuse = function(observable, obj) {
-	    var creator, current_obj, current_observable;
-	    if ((current_obj = kb.utils.wrappedObject(observable)) === obj) {
-	      return;
-	    }
-	    if (!this._canRegister(observable)) {
-	      throw new Error('Cannot reuse a simple observable');
-	    }
-	    if (this._refCount(observable) !== 1) {
-	      throw new Error("Trying to change a shared view model. Ref count: " + (this._refCount(observable)));
-	    }
-	    creator = kb.utils.wrappedCreator(observable) || observable.constructor;
-	    if (!_.isUndefined(current_obj)) {
-	      current_observable = this.find(current_obj, creator);
-	    }
-	    this.retain(observable, obj, creator);
-	    if (current_observable) {
-	      this.release(current_observable);
-	    }
-	  };
 
-	  Store.prototype.release = function(observable, force) {
-	    var store_references;
-	    if (!this._canRegister(observable)) {
-	      return kb.release(observable);
-	    }
-	    if (store_references = this._storeReferences(observable)) {
-	      if (!force && --store_references.ref_count > 0) {
-	        return;
-	      }
-	      this._clearStoreReferences(observable);
-	    }
-	    this._remove(observable);
-	    if (observable.__kb_released) {
-	      return;
-	    }
-	    if (force || this._refCount(observable) <= 1) {
-	      return kb.release(observable);
-	    }
-	  };
+/***/ },
+/* 16 */
+/***/ function(module, exports, __webpack_require__) {
 
-	  Store.prototype.find = function(obj, creator) {
-	    var observable, records, _ref1;
-	    if (!(records = this.observable_records[this._creatorId(creator)])) {
-	      return null;
-	    }
-	    if ((_ref1 = (observable = records[this._cid(obj)])) != null ? _ref1.__kb_released : void 0) {
-	      delete records[this._cid(obj)];
-	      return null;
-	    }
-	    return observable;
-	  };
+	
+	/*
+	  knockback.js 1.0.0
+	  Copyright (c)  2011-2014 Kevin Malakoff.
+	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
+	  Source: https://github.com/kmalakoff/knockback
+	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
+	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
+	 */
+	var KEYS_INFO, KEYS_PUBLISH, TypedValue, _, kb, ko, ref;
 
-	  Store.prototype._refCount = function(observable) {
-	    var stores_references;
-	    if (observable.__kb_released) {
-	      if (typeof console !== "undefined" && console !== null) {
-	        console.log('Observable already released');
-	      }
-	      return 0;
-	    }
-	    if (!(stores_references = kb.utils.get(observable, 'stores_references'))) {
-	      return 1;
-	    }
-	    return _.reduce(stores_references, (function(memo, store_references) {
-	      return memo + store_references.ref_count;
-	    }), 0);
-	  };
+	ref = kb = __webpack_require__(2), _ = ref._, ko = ref.ko;
 
-	  Store.prototype._canRegister = function(observable) {
-	    return observable && !ko.isObservable(observable) && !observable.__kb_is_co;
-	  };
+	TypedValue = __webpack_require__(17);
 
-	  Store.prototype._cid = function(obj) {
-	    var cid;
-	    return cid = obj ? obj.cid || (obj.cid = _.uniqueId('c')) : 'null';
-	  };
+	KEYS_PUBLISH = ['value', 'valueType', 'destroy'];
 
-	  Store.prototype._creatorId = function(creator) {
-	    var create, item, _i, _len, _ref1;
-	    create = creator.create || creator;
-	    create.__kb_cids || (create.__kb_cids = []);
-	    _ref1 = create.__kb_cids;
-	    for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
-	      item = _ref1[_i];
-	      if (item.create === create) {
-	        return item.cid;
-	      }
-	    }
-	    create.__kb_cids.push(item = {
-	      create: create,
-	      cid: _.uniqueId('kb')
-	    });
-	    return item.cid;
-	  };
+	KEYS_INFO = ['args', 'read', 'write'];
 
-	  Store.prototype._storeReferences = function(observable) {
-	    var stores_references;
-	    if (!(stores_references = kb.utils.get(observable, 'stores_references'))) {
-	      return;
-	    }
-	    return _.find(stores_references, (function(_this) {
-	      return function(store_references) {
-	        return store_references.store === _this;
+	kb.Observable = (function() {
+	  function Observable(model, key_or_info, options, _vm) {
+	    this._vm = _vm != null ? _vm : {};
+	    return kb.ignore((function(_this) {
+	      return function() {
+	        var create_options, event_watcher, i, key, len, observable;
+	        key_or_info || kb._throwMissing(_this, 'key_or_info');
+	        _this.key = key_or_info.key || key_or_info;
+	        for (i = 0, len = KEYS_INFO.length; i < len; i++) {
+	          key = KEYS_INFO[i];
+	          if (key_or_info[key]) {
+	            _this[key] = key_or_info[key];
+	          }
+	        }
+	        create_options = kb.utils.collapseOptions(options);
+	        event_watcher = create_options.event_watcher;
+	        delete create_options.event_watcher;
+	        _this._value = new TypedValue(create_options);
+	        _this._model = ko.observable();
+	        observable = kb.utils.wrappedObservable(_this, ko.computed({
+	          read: function() {
+	            var _model, arg, args, j, len1, ref1, ref2;
+	            _model = _this._model();
+	            ref1 = args = [_this.key].concat(_this.args || []);
+	            for (j = 0, len1 = ref1.length; j < len1; j++) {
+	              arg = ref1[j];
+	              ko.utils.unwrapObservable(arg);
+	            }
+	            if ((ref2 = kb.utils.wrappedEventWatcher(_this)) != null) {
+	              ref2.emitter(_model || null);
+	            }
+	            if (_this.read) {
+	              _this.update(_this.read.apply(_this._vm, args));
+	            } else if (!_.isUndefined(_model)) {
+	              kb.ignore(function() {
+	                return _this.update(kb.getValue(_model, kb.peek(_this.key), _this.args));
+	              });
+	            }
+	            return _this._value.value();
+	          },
+	          write: function(new_value) {
+	            return kb.ignore(function() {
+	              var _model, unwrapped_new_value;
+	              unwrapped_new_value = kb.utils.unwrapModels(new_value);
+	              _model = kb.peek(_this._model);
+	              if (_this.write) {
+	                _this.write.call(_this._vm, unwrapped_new_value);
+	                new_value = kb.getValue(_model, kb.peek(_this.key), _this.args);
+	              } else if (_model) {
+	                kb.setValue(_model, kb.peek(_this.key), unwrapped_new_value);
+	              }
+	              return _this.update(new_value);
+	            });
+	          },
+	          owner: _this._vm
+	        }));
+	        observable.__kb_is_o = true;
+	        create_options.store = kb.utils.wrappedStore(observable, create_options.store);
+	        create_options.path = kb.utils.pathJoin(create_options.path, _this.key);
+	        if (create_options.factories && ((typeof create_options.factories === 'function') || create_options.factories.create)) {
+	          create_options.factory = kb.utils.wrappedFactory(observable, new kb.Factory(create_options.factory));
+	          create_options.factory.addPathMapping(create_options.path, create_options.factories);
+	        } else {
+	          create_options.factory = kb.Factory.useOptionsOrCreate(create_options, observable, create_options.path);
+	        }
+	        delete create_options.factories;
+	        kb.publishMethods(observable, _this, KEYS_PUBLISH);
+	        observable.model = _this.model = ko.computed({
+	          read: function() {
+	            return ko.utils.unwrapObservable(_this._model);
+	          },
+	          write: function(new_model) {
+	            return kb.ignore(function() {
+	              var new_value;
+	              if (_this.__kb_released || (kb.peek(_this._model) === new_model)) {
+	                return;
+	              }
+	              new_value = kb.getValue(new_model, kb.peek(_this.key), _this.args);
+	              _this._model(new_model);
+	              if (!new_model) {
+	                return _this.update(null);
+	              } else if (!_.isUndefined(new_value)) {
+	                return _this.update(new_value);
+	              }
+	            });
+	          }
+	        });
+	        kb.EventWatcher.useOptionsOrCreate({
+	          event_watcher: event_watcher
+	        }, model || null, _this, {
+	          emitter: _this.model,
+	          update: (function() {
+	            return kb.ignore(function() {
+	              return _this.update();
+	            });
+	          }),
+	          key: _this.key,
+	          path: create_options.path
+	        });
+	        _this._value.rawValue() || _this._value.update();
+	        if (kb.LocalizedObservable && key_or_info.localizer) {
+	          observable = new key_or_info.localizer(observable);
+	        }
+	        if (kb.DefaultObservable && key_or_info.hasOwnProperty('default')) {
+	          observable = kb.defaultObservable(observable, key_or_info["default"]);
+	        }
+	        return observable;
 	      };
 	    })(this));
-	  };
-
-	  Store.prototype._getOrCreateStoreReferences = function(observable) {
-	    var store_references, stores_references;
-	    stores_references = kb.utils.orSet(observable, 'stores_references', []);
-	    if (!(store_references = _.find(stores_references, (function(_this) {
-	      return function(store_references) {
-	        return store_references.store === _this;
-	      };
-	    })(this)))) {
-	      stores_references.push(store_references = {
-	        store: this,
-	        ref_count: 0,
-	        release: (function(_this) {
-	          return function() {
-	            return _this.release(observable);
-	          };
-	        })(this)
-	      });
-	    }
-	    return store_references;
-	  };
-
-	  Store.prototype._clearStoreReferences = function(observable) {
-	    var index, store_references, stores_references, _ref1;
-	    if (stores_references = kb.utils.get(observable, 'stores_references')) {
-	      _ref1 = observable.__kb.stores_references;
-	      for (index in _ref1) {
-	        store_references = _ref1[index];
-	        if (store_references.store === this) {
-	          observable.__kb.stores_references.splice(index, 1);
-	          break;
-	        }
-	      }
-	    }
-	  };
+	  }
 
-	  Store.prototype._retire = function(observable) {
-	    this._clearStoreReferences(observable);
-	    this.replaced_observables.push(observable);
-	    return this._remove(observable);
+	  Observable.prototype.destroy = function() {
+	    var observable;
+	    observable = kb.utils.wrappedObservable(this);
+	    this.__kb_released = true;
+	    this._value.destroy();
+	    this._value = null;
+	    this.model.dispose();
+	    this.model = observable.model = null;
+	    return kb.utils.wrappedDestroy(this);
 	  };
 
-	  Store.prototype._add = function(observable, obj, creator) {
-	    var _base, _name;
-	    creator || (creator = observable.constructor);
-	    kb.utils.wrappedObject(observable, obj);
-	    kb.utils.wrappedCreator(observable, creator);
-	    return ((_base = this.observable_records)[_name = this._creatorId(creator)] || (_base[_name] = {}))[this._cid(obj)] = observable;
+	  Observable.prototype.value = function() {
+	    return this._value.rawValue();
 	  };
 
-	  Store.prototype._remove = function(observable) {
-	    var creator, current_observable, obj;
-	    creator = kb.utils.wrappedCreator(observable) || observable.constructor;
-	    if (current_observable = this.find(obj = kb.utils.wrappedObject(observable), creator)) {
-	      if (current_observable === observable) {
-	        delete this.observable_records[this._creatorId(creator)][this._cid(obj)];
-	      }
-	    }
-	    kb.utils.wrappedObject(observable, null);
-	    return kb.utils.wrappedCreator(observable, null);
+	  Observable.prototype.valueType = function() {
+	    return this._value.valueType(kb.peek(this._model), kb.peek(this.key));
 	  };
 
-	  Store.prototype._creator = function(obj, options) {
-	    var creator;
-	    if (options.creator) {
-	      return options.creator;
-	    }
-	    if (creator = kb.utils.inferCreator(obj, options.factory, options.path)) {
-	      return creator;
+	  Observable.prototype.update = function(new_value) {
+	    if (this.__kb_released) {
+	      return;
 	    }
-	    if (kb.isModel(obj)) {
-	      return kb.ViewModel;
+	    if (!arguments.length) {
+	      new_value = kb.getValue(kb.peek(this._model), kb.peek(this.key));
 	    }
+	    return this._value.update(new_value);
 	  };
 
-	  return Store;
+	  return Observable;
 
 	})();
 
+	kb.observable = function(model, key, options, view_model) {
+	  return new kb.Observable(model, key, options, view_model);
+	};
+
 
 /***/ },
-/* 11 */
+/* 17 */
 /***/ function(module, exports, __webpack_require__) {
 
-	var TypedValue, kb, ko, _, _ref;
+	var TypedValue, _, kb, ko, ref;
 
-	_ref = kb = __webpack_require__(6), _ = _ref._, ko = _ref.ko;
+	ref = kb = __webpack_require__(2), _ = ref._, ko = ref.ko;
 
 	module.exports = TypedValue = (function() {
-	  function TypedValue(create_options) {
-	    this.create_options = create_options;
+	  function TypedValue(create_options1) {
+	    this.create_options = create_options1;
 	    this._vo = ko.observable(null);
 	  }
 
@@ -2028,13 +1922,13 @@ return /******/ (function(modules) { // webpackBootstrap
 	  };
 
 	  TypedValue.prototype.update = function(new_value) {
-	    var new_type, value, _ref1;
+	    var new_type, ref1, value;
 	    if (this.__kb_released) {
 	      return;
 	    }
 	    (new_value !== void 0) || (new_value = null);
 	    new_type = kb.utils.valueType(new_value);
-	    if ((_ref1 = this.__kb_value) != null ? _ref1.__kb_released : void 0) {
+	    if ((ref1 = this.__kb_value) != null ? ref1.__kb_released : void 0) {
 	      this.__kb_value = this.value_type = void 0;
 	    }
 	    value = this.__kb_value;
@@ -2078,7 +1972,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	  };
 
 	  TypedValue.prototype._updateValueObservable = function(new_value, new_observable) {
-	    var create_options, creator, previous_value, value, value_type, _ref1;
+	    var create_options, creator, previous_value, ref1, value, value_type;
 	    create_options = this.create_options;
 	    creator = kb.utils.inferCreator(new_value, create_options.factory, create_options.path);
 	    if ((new_value === null) && !creator) {
@@ -2090,7 +1984,7 @@ return /******/ (function(modules) { // webpackBootstrap
 	    }
 	    create_options.creator = creator;
 	    value_type = kb.TYPE_UNKNOWN;
-	    _ref1 = [this.__kb_value, void 0], previous_value = _ref1[0], this.__kb_value = _ref1[1];
+	    ref1 = [this.__kb_value, void 0], previous_value = ref1[0], this.__kb_value = ref1[1];
 	    if (new_observable) {
 	      value = new_observable;
 	      if (create_options.store) {
@@ -2129,1560 +2023,1663 @@ return /******/ (function(modules) { // webpackBootstrap
 	        this.value_type = kb.TYPE_SIMPLE;
 	      }
 	    }
-	    if (previous_value) {
-	      if (this.create_options.store) {
-	        this.create_options.store.release(previous_value);
+	    if (previous_value) {
+	      if (this.create_options.store) {
+	        this.create_options.store.release(previous_value);
+	      } else {
+	        kb.release(previous_value);
+	      }
+	    }
+	    this.__kb_value = value;
+	    return this._vo(value);
+	  };
+
+	  TypedValue.prototype._inferType = function(value) {};
+
+	  return TypedValue;
+
+	})();
+
+
+/***/ },
+/* 18 */
+/***/ function(module, exports, __webpack_require__) {
+
+	
+	/*
+	  knockback.js 1.0.0
+	  Copyright (c)  2011-2014 Kevin Malakoff.
+	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
+	  Source: https://github.com/kmalakoff/knockback
+	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
+	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
+	 */
+	var _, kb;
+
+	_ = (kb = __webpack_require__(2))._;
+
+	module.exports = kb.Statistics = (function() {
+	  function Statistics() {
+	    this.model_events_tracker = [];
+	    this.registered_tracker = {};
+	  }
+
+	  Statistics.prototype.clear = function() {
+	    return this.model_events_tracker = [];
+	  };
+
+	  Statistics.prototype.addModelEvent = function(event) {
+	    return this.model_events_tracker.push(event);
+	  };
+
+	  Statistics.prototype.modelEventsStatsString = function() {
+	    var event_groups, key, stats_string, value;
+	    stats_string = '';
+	    stats_string += "Total Count: " + this.model_events_tracker.length;
+	    event_groups = _.groupBy(this.model_events_tracker, function(test) {
+	      return "event name: '" + test.name + "', attribute name: '" + test.key + "'";
+	    });
+	    for (key in event_groups) {
+	      value = event_groups[key];
+	      stats_string += "\n " + key + ", count: " + value.length;
+	    }
+	    return stats_string;
+	  };
+
+	  Statistics.prototype.register = function(key, obj) {
+	    return this.registeredTracker(key).push(obj);
+	  };
+
+	  Statistics.prototype.unregister = function(key, obj) {
+	    var index, type_tracker;
+	    type_tracker = this.registeredTracker(key);
+	    if ((index = _.indexOf(type_tracker, obj)) < 0) {
+	      return typeof console !== "undefined" && console !== null ? console.log("kb.Statistics: failed to unregister type: " + key) : void 0;
+	    }
+	    return type_tracker.splice(index, 1);
+	  };
+
+	  Statistics.prototype.registeredCount = function(type) {
+	    var count, ref, type_tracker;
+	    if (type) {
+	      return this.registeredTracker(type).length;
+	    }
+	    count = 0;
+	    ref = this.registered_tracker[type];
+	    for (type in ref) {
+	      type_tracker = ref[type];
+	      count += type_tracker.length;
+	    }
+	    return count;
+	  };
+
+	  Statistics.prototype.registeredStatsString = function(success_message) {
+	    var ref, stats_string, type, type_tracker, written;
+	    stats_string = '';
+	    ref = this.registered_tracker;
+	    for (type in ref) {
+	      type_tracker = ref[type];
+	      if (!type_tracker.length) {
+	        continue;
+	      }
+	      if (written) {
+	        stats_string += '\n ';
+	      }
+	      stats_string += (type ? type : 'No Name') + ": " + type_tracker.length;
+	      written = true;
+	    }
+	    if (stats_string) {
+	      return stats_string;
+	    } else {
+	      return success_message;
+	    }
+	  };
+
+	  Statistics.prototype.registeredTracker = function(key) {
+	    var type_tracker;
+	    if (this.registered_tracker.hasOwnProperty(key)) {
+	      return this.registered_tracker[key];
+	    }
+	    type_tracker = [];
+	    this.registered_tracker[key] = type_tracker;
+	    return type_tracker;
+	  };
+
+	  Statistics.eventsStats = function(obj, key) {
+	    var events, i, len, node, ref, stats, tail;
+	    stats = {
+	      count: 0
+	    };
+	    events = obj._events || obj._callbacks || {};
+	    ref = (key ? [key] : _.keys(events));
+	    for (i = 0, len = ref.length; i < len; i++) {
+	      key = ref[i];
+	      if (!(node = events[key])) {
+	        continue;
+	      }
+	      if (_.isArray(node)) {
+	        stats[key] = _.compact(node).length;
 	      } else {
-	        kb.release(previous_value);
+	        stats[key] = 0;
+	        tail = node.tail;
+	        while ((node = node.next) !== tail) {
+	          stats[key]++;
+	        }
 	      }
+	      stats.count += stats[key];
 	    }
-	    this.__kb_value = value;
-	    return this._vo(value);
+	    return stats;
 	  };
 
-	  TypedValue.prototype._inferType = function(value) {};
-
-	  return TypedValue;
+	  return Statistics;
 
 	})();
 
 
 /***/ },
-/* 12 */
+/* 19 */
 /***/ function(module, exports, __webpack_require__) {
 
 	
 	/*
-	  knockback.js 0.20.5
+	  knockback.js 1.0.0
 	  Copyright (c)  2011-2014 Kevin Malakoff.
 	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
 	  Source: https://github.com/kmalakoff/knockback
 	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
 	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
 	 */
-	var kb, ko, _, _ref;
-
-	_ref = kb = __webpack_require__(6), _ = _ref._, ko = _ref.ko;
-
-	kb.utils = (function() {
-	  function utils() {}
+	var _, kb, ko, ref;
 
-	  utils.get = function(obj, key, default_value) {
-	    if (!obj.__kb || !obj.__kb.hasOwnProperty(key)) {
-	      return default_value;
-	    } else {
-	      return obj.__kb[key];
-	    }
-	  };
+	ref = kb = __webpack_require__(2), _ = ref._, ko = ref.ko;
 
-	  utils.set = function(obj, key, value) {
-	    return (obj.__kb || (obj.__kb = {}))[key] = value;
-	  };
+	module.exports = kb.Store = (function() {
+	  Store.instances = [];
 
-	  utils.orSet = function(obj, key, value) {
-	    if (!(obj.__kb || (obj.__kb = {})).hasOwnProperty(key)) {
-	      obj.__kb[key] = value;
+	  Store.useOptionsOrCreate = function(options, obj, observable) {
+	    var store;
+	    if (!options.store) {
+	      kb.utils.wrappedStoreIsOwned(observable, true);
 	    }
-	    return obj.__kb[key];
+	    store = kb.utils.wrappedStore(observable, options.store || new kb.Store());
+	    store.retain(observable, obj, options.creator);
+	    return store;
 	  };
 
-	  utils.has = function(obj, key) {
-	    return obj.__kb && obj.__kb.hasOwnProperty(key);
-	  };
+	  function Store() {
+	    this.observable_records = {};
+	    this.replaced_observables = [];
+	    kb.Store.instances.push(this);
+	  }
 
-	  utils.wrappedObservable = function(obj, value) {
-	    if (arguments.length === 1) {
-	      return kb.utils.get(obj, 'observable');
-	    } else {
-	      return kb.utils.set(obj, 'observable', value);
+	  Store.prototype.destroy = function() {
+	    var index;
+	    this.__kb_released = true;
+	    this.clear();
+	    if ((index = _.indexOf(kb.Store.instances, this)) >= 0) {
+	      return kb.Store.instances.splice(index, 1);
 	    }
 	  };
 
-	  utils.wrappedObject = function(obj, value) {
-	    if (arguments.length === 1) {
-	      return kb.utils.get(obj, 'object');
-	    } else {
-	      return kb.utils.set(obj, 'object', value);
+	  Store.prototype.clear = function() {
+	    var cid, creator_id, i, len, observable, observable_records, records, ref1, ref2, replaced_observables;
+	    ref1 = [this.observable_records, {}], observable_records = ref1[0], this.observable_records = ref1[1];
+	    for (creator_id in observable_records) {
+	      records = observable_records[creator_id];
+	      for (cid in records) {
+	        observable = records[cid];
+	        this.release(observable, true);
+	      }
 	    }
-	  };
-
-	  utils.wrappedCreator = function(obj, value) {
-	    if (arguments.length === 1) {
-	      return kb.utils.get(obj, 'creator');
-	    } else {
-	      return kb.utils.set(obj, 'creator', value);
+	    ref2 = [this.replaced_observables, []], replaced_observables = ref2[0], this.replaced_observables = ref2[1];
+	    for (i = 0, len = replaced_observables.length; i < len; i++) {
+	      observable = replaced_observables[i];
+	      if (!observable.__kb_released) {
+	        this.release(observable, true);
+	      }
 	    }
 	  };
 
-	  utils.wrappedModel = function(obj, value) {
-	    if (arguments.length === 1) {
-	      if (_.isUndefined(value = kb.utils.get(obj, 'object'))) {
-	        return obj;
-	      } else {
-	        return value;
+	  Store.prototype.compact = function() {
+	    var cid, creator_id, observable, records, ref1;
+	    ref1 = this.observable_records;
+	    for (creator_id in ref1) {
+	      records = ref1[creator_id];
+	      for (cid in records) {
+	        observable = records[cid];
+	        if (observable.__kb_released) {
+	          delete records[cid];
+	        }
 	      }
-	    } else {
-	      return kb.utils.set(obj, 'object', value);
 	    }
 	  };
 
-	  utils.wrappedStore = function(obj, value) {
-	    if (arguments.length === 1) {
-	      return kb.utils.get(obj, 'store');
-	    } else {
-	      return kb.utils.set(obj, 'store', value);
+	  Store.prototype.retain = function(observable, obj, creator) {
+	    var current_observable;
+	    if (!this._canRegister(observable)) {
+	      return;
 	    }
-	  };
-
-	  utils.wrappedStoreIsOwned = function(obj, value) {
-	    if (arguments.length === 1) {
-	      return kb.utils.get(obj, 'store_is_owned');
-	    } else {
-	      return kb.utils.set(obj, 'store_is_owned', value);
+	    creator || (creator = observable.constructor);
+	    if (current_observable = this.find(obj, creator)) {
+	      if (current_observable === observable) {
+	        this._getOrCreateStoreReferences(observable).ref_count++;
+	        return observable;
+	      }
+	      this._retire(current_observable);
 	    }
+	    this._add(observable, obj, creator);
+	    this._getOrCreateStoreReferences(observable).ref_count++;
+	    return observable;
 	  };
 
-	  utils.wrappedFactory = function(obj, value) {
-	    if (arguments.length === 1) {
-	      return kb.utils.get(obj, 'factory');
-	    } else {
-	      return kb.utils.set(obj, 'factory', value);
+	  Store.prototype.retainOrCreate = function(obj, options) {
+	    var creator, observable;
+	    if (!(creator = this._creator(obj, options))) {
+	      return kb.utils.createFromDefaultCreator(obj, options);
 	    }
-	  };
-
-	  utils.wrappedEventWatcher = function(obj, value) {
-	    if (arguments.length === 1) {
-	      return kb.utils.get(obj, 'event_watcher');
-	    } else {
-	      return kb.utils.set(obj, 'event_watcher', value);
+	    if (creator.models_only) {
+	      return obj;
 	    }
-	  };
-
-	  utils.wrappedEventWatcherIsOwned = function(obj, value) {
-	    if (arguments.length === 1) {
-	      return kb.utils.get(obj, 'event_watcher_is_owned');
-	    } else {
-	      return kb.utils.set(obj, 'event_watcher_is_owned', value);
+	    if (observable = this.find(obj, creator)) {
+	      return observable;
+	    }
+	    if (!_.isFunction(creator.create || creator)) {
+	      throw new Error("Invalid factory for \"" + options.path + "\"");
 	    }
+	    observable = kb.ignore((function(_this) {
+	      return function() {
+	        options = _.defaults({
+	          store: _this,
+	          creator: creator
+	        }, options);
+	        observable = creator.create ? creator.create(obj, options) : new creator(obj, options);
+	        return observable || ko.observable(null);
+	      };
+	    })(this));
+	    this.retain(observable, obj, creator);
+	    return observable;
 	  };
 
-	  utils.wrappedDestroy = __webpack_require__(30);
-
-	  utils.valueType = function(observable) {
-	    if (!observable) {
-	      return kb.TYPE_UNKNOWN;
+	  Store.prototype.reuse = function(observable, obj) {
+	    var creator, current_obj, current_observable;
+	    if ((current_obj = kb.utils.wrappedObject(observable)) === obj) {
+	      return;
 	    }
-	    if (observable.__kb_is_o) {
-	      return observable.valueType();
+	    if (!this._canRegister(observable)) {
+	      throw new Error('Cannot reuse a simple observable');
 	    }
-	    if (observable.__kb_is_co || (observable instanceof kb.Collection)) {
-	      return kb.TYPE_COLLECTION;
+	    if (this._refCount(observable) !== 1) {
+	      throw new Error("Trying to change a shared view model. Ref count: " + (this._refCount(observable)));
 	    }
-	    if ((observable instanceof kb.ViewModel) || (observable instanceof kb.Model)) {
-	      return kb.TYPE_MODEL;
+	    creator = kb.utils.wrappedCreator(observable) || observable.constructor;
+	    if (!_.isUndefined(current_obj)) {
+	      current_observable = this.find(current_obj, creator);
 	    }
-	    if (_.isArray(observable)) {
-	      return kb.TYPE_ARRAY;
+	    this.retain(observable, obj, creator);
+	    if (current_observable) {
+	      this.release(current_observable);
 	    }
-	    return kb.TYPE_SIMPLE;
-	  };
-
-	  utils.pathJoin = function(path1, path2) {
-	    return (path1 ? (path1[path1.length - 1] !== '.' ? "" + path1 + "." : path1) : '') + path2;
-	  };
-
-	  utils.optionsPathJoin = function(options, path) {
-	    return _.defaults({
-	      path: this.pathJoin(options.path, path)
-	    }, options);
 	  };
 
-	  utils.inferCreator = function(value, factory, path) {
-	    var creator;
-	    if (factory && (creator = factory.creatorForPath(value, path))) {
-	      return creator;
+	  Store.prototype.release = function(observable, force) {
+	    var store_references;
+	    if (!this._canRegister(observable)) {
+	      return kb.release(observable);
 	    }
-	    if (!value) {
-	      return null;
+	    if (store_references = this._storeReferences(observable)) {
+	      if (!force && --store_references.ref_count > 0) {
+	        return;
+	      }
+	      this._clearStoreReferences(observable);
 	    }
-	    if (value instanceof kb.Model) {
-	      return kb.ViewModel;
+	    this._remove(observable);
+	    if (observable.__kb_released) {
+	      return;
 	    }
-	    if (value instanceof kb.Collection) {
-	      return kb.CollectionObservable;
+	    if (force || this._refCount(observable) <= 1) {
+	      return kb.release(observable);
 	    }
-	    return null;
 	  };
 
-	  utils.createFromDefaultCreator = function(obj, options) {
-	    if (kb.isModel(obj)) {
-	      return kb.viewModel(obj, options);
-	    }
-	    if (kb.isCollection(obj)) {
-	      return kb.collectionObservable(obj, options);
+	  Store.prototype.find = function(obj, creator) {
+	    var observable, records, ref1;
+	    if (!(records = this.observable_records[this._creatorId(creator)])) {
+	      return null;
 	    }
-	    if (_.isArray(obj)) {
-	      return ko.observableArray(obj);
+	    if ((ref1 = (observable = records[this._cid(obj)])) != null ? ref1.__kb_released : void 0) {
+	      delete records[this._cid(obj)];
+	      return null;
 	    }
-	    return ko.observable(obj);
+	    return observable;
 	  };
 
-	  utils.collapseOptions = __webpack_require__(31);
-
-	  utils.unwrapModels = __webpack_require__(32);
-
-	  utils.resolveModel = function(model) {
-	    if (model && kb.Backbone && kb.Backbone.ModelRef && model instanceof kb.Backbone.ModelRef) {
-	      return model.model();
-	    } else {
-	      return model;
+	  Store.prototype._refCount = function(observable) {
+	    var stores_references;
+	    if (observable.__kb_released) {
+	      if (typeof console !== "undefined" && console !== null) {
+	        console.log('Observable already released');
+	      }
+	      return 0;
+	    }
+	    if (!(stores_references = kb.utils.get(observable, 'stores_references'))) {
+	      return 1;
 	    }
+	    return _.reduce(stores_references, (function(memo, store_references) {
+	      return memo + store_references.ref_count;
+	    }), 0);
 	  };
 
-	  return utils;
-
-	})();
-
-
-/***/ },
-/* 13 */
-/***/ function(module, exports, __webpack_require__) {
-
-	
-	/*
-	  knockback.js 0.20.5
-	  Copyright (c)  2011-2014 Kevin Malakoff.
-	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
-	  Source: https://github.com/kmalakoff/knockback
-	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
-	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
-	 */
-	var KEYS_OPTIONS, assignViewModelKey, createObservable, createStaticObservables, kb, ko, _, _ref;
-
-	_ref = kb = __webpack_require__(6), _ = _ref._, ko = _ref.ko;
-
-	assignViewModelKey = function(vm, key) {
-	  var vm_key;
-	  vm_key = vm.__kb.internals && _.contains(vm.__kb.internals, key) ? "_" + key : key;
-	  if (vm.__kb.view_model.hasOwnProperty(vm_key)) {
-	    return;
-	  }
-	  vm.__kb.view_model[vm_key] = null;
-	  return vm_key;
-	};
+	  Store.prototype._canRegister = function(observable) {
+	    return observable && !ko.isObservable(observable) && !observable.__kb_is_co;
+	  };
 
-	createObservable = function(vm, model, key, create_options) {
-	  var vm_key;
-	  if (vm.__kb.excludes && _.contains(vm.__kb.excludes, key)) {
-	    return;
-	  }
-	  if (vm.__kb.statics && _.contains(vm.__kb.statics, key)) {
-	    return;
-	  }
-	  if (!(vm_key = assignViewModelKey(vm, key))) {
-	    return;
-	  }
-	  return vm[vm_key] = vm.__kb.view_model[vm_key] = kb.observable(model, key, create_options, vm);
-	};
+	  Store.prototype._cid = function(obj) {
+	    var cid;
+	    return cid = obj ? obj.cid || (obj.cid = _.uniqueId('c')) : 'null';
+	  };
 
-	createStaticObservables = function(vm, model) {
-	  var key, vm_key, _i, _len, _ref1;
-	  _ref1 = vm.__kb.statics;
-	  for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
-	    key = _ref1[_i];
-	    if (vm_key = assignViewModelKey(vm, key)) {
-	      if (model.has(vm_key)) {
-	        vm[vm_key] = vm.__kb.view_model[vm_key] = model.get(vm_key);
-	      } else if (vm.__kb.static_defaults && vm_key in vm.__kb.static_defaults) {
-	        vm[vm_key] = vm.__kb.view_model[vm_key] = vm.__kb.static_defaults[vm_key];
-	      } else {
-	        delete vm.__kb.view_model[vm_key];
+	  Store.prototype._creatorId = function(creator) {
+	    var create, i, item, len, ref1;
+	    create = creator.create || creator;
+	    create.__kb_cids || (create.__kb_cids = []);
+	    ref1 = create.__kb_cids;
+	    for (i = 0, len = ref1.length; i < len; i++) {
+	      item = ref1[i];
+	      if (item.create === create) {
+	        return item.cid;
 	      }
 	    }
-	  }
-	};
-
-	KEYS_OPTIONS = ['keys', 'internals', 'excludes', 'statics', 'static_defaults'];
-
-	kb.ViewModel = (function() {
-	  ViewModel.extend = kb.extend;
+	    create.__kb_cids.push(item = {
+	      create: create,
+	      cid: _.uniqueId('kb')
+	    });
+	    return item.cid;
+	  };
 
-	  function ViewModel(model, options, view_model) {
-	    var args;
-	    if (options == null) {
-	      options = {};
+	  Store.prototype._storeReferences = function(observable) {
+	    var stores_references;
+	    if (!(stores_references = kb.utils.get(observable, 'stores_references'))) {
+	      return;
 	    }
-	    args = Array.prototype.slice.call(_.isArguments(model) ? model : arguments);
-	    return kb.ignore((function(_this) {
-	      return function() {
-	        var arg, event_watcher, key, _i, _j, _len, _len1, _model;
-	        !(model = args.shift()) || kb.isModel(model) || kb._throwUnexpected(_this, 'not a model');
-	        if (_.isArray(args[0])) {
-	          args[0] = {
-	            keys: args[0]
-	          };
-	        }
-	        _this.__kb || (_this.__kb = {});
-	        _this.__kb.view_model = (args.length > 1 ? args.pop() : _this);
-	        options = {};
-	        for (_i = 0, _len = args.length; _i < _len; _i++) {
-	          arg = args[_i];
-	          _.extend(options, arg);
-	        }
-	        options = kb.utils.collapseOptions(options);
-	        for (_j = 0, _len1 = KEYS_OPTIONS.length; _j < _len1; _j++) {
-	          key = KEYS_OPTIONS[_j];
-	          if (options.hasOwnProperty(key)) {
-	            _this.__kb[key] = options[key];
-	          }
-	        }
-	        kb.Store.useOptionsOrCreate(options, model, _this);
-	        _this.__kb.path = options.path;
-	        kb.Factory.useOptionsOrCreate(options, _this, options.path);
-	        _model = kb.utils.set(_this, '_model', ko.observable());
-	        _this.model = ko.computed({
-	          read: function() {
-	            return ko.utils.unwrapObservable(_model);
-	          },
-	          write: function(new_model) {
-	            return kb.ignore(function() {
-	              if ((kb.utils.wrappedObject(_this) === new_model) || kb.wasReleased(_this) || !event_watcher) {
-	                return;
-	              }
-	              _this.__kb.store.reuse(_this, kb.utils.resolveModel(new_model));
-	              event_watcher.emitter(new_model);
-	              _model(event_watcher.ee);
-	              return !event_watcher.ee || _this.createObservables(event_watcher.ee);
-	            });
-	          }
-	        });
-	        event_watcher = kb.utils.wrappedEventWatcher(_this, new kb.EventWatcher(model, _this, {
-	          emitter: _this._model,
-	          update: (function() {
-	            return kb.ignore(function() {
-	              return !(event_watcher != null ? event_watcher.ee : void 0) || _this.createObservables(event_watcher != null ? event_watcher.ee : void 0);
-	            });
-	          })
-	        }));
-	        kb.utils.wrappedObject(_this, model = event_watcher.ee);
-	        _model(event_watcher.ee);
-	        _this.__kb.create_options = {
-	          store: kb.utils.wrappedStore(_this),
-	          factory: kb.utils.wrappedFactory(_this),
-	          path: _this.__kb.path,
-	          event_watcher: kb.utils.wrappedEventWatcher(_this)
-	        };
-	        !options.requires || _this.createObservables(model, options.requires);
-	        !_this.__kb.internals || _this.createObservables(model, _this.__kb.internals);
-	        !options.mappings || _this.createObservables(model, options.mappings);
-	        !_this.__kb.statics || createStaticObservables(_this, model);
-	        _this.createObservables(model, _this.__kb.keys);
-	        !kb.statistics || kb.statistics.register('ViewModel', _this);
-	        return _this;
+	    return _.find(stores_references, (function(_this) {
+	      return function(store_references) {
+	        return store_references.store === _this;
 	      };
 	    })(this));
-	  }
+	  };
 
-	  ViewModel.prototype.destroy = function() {
-	    var vm_key;
-	    this.__kb_released = true;
-	    if (this.__kb.view_model !== this) {
-	      for (vm_key in this.__kb.vm_keys) {
-	        this.__kb.view_model[vm_key] = null;
+	  Store.prototype._getOrCreateStoreReferences = function(observable) {
+	    var store_references, stores_references;
+	    stores_references = kb.utils.orSet(observable, 'stores_references', []);
+	    if (!(store_references = _.find(stores_references, (function(_this) {
+	      return function(store_references) {
+	        return store_references.store === _this;
+	      };
+	    })(this)))) {
+	      stores_references.push(store_references = {
+	        store: this,
+	        ref_count: 0,
+	        release: (function(_this) {
+	          return function() {
+	            return _this.release(observable);
+	          };
+	        })(this)
+	      });
+	    }
+	    return store_references;
+	  };
+
+	  Store.prototype._clearStoreReferences = function(observable) {
+	    var index, ref1, store_references, stores_references;
+	    if (stores_references = kb.utils.get(observable, 'stores_references')) {
+	      ref1 = observable.__kb.stores_references;
+	      for (index in ref1) {
+	        store_references = ref1[index];
+	        if (store_references.store === this) {
+	          observable.__kb.stores_references.splice(index, 1);
+	          break;
+	        }
 	      }
 	    }
-	    this.__kb.view_model = this.__kb.create_options = null;
-	    kb.releaseKeys(this);
-	    kb.utils.wrappedDestroy(this);
-	    return !kb.statistics || kb.statistics.unregister('ViewModel', this);
 	  };
 
-	  ViewModel.prototype.shareOptions = function() {
-	    return {
-	      store: kb.utils.wrappedStore(this),
-	      factory: kb.utils.wrappedFactory(this)
-	    };
+	  Store.prototype._retire = function(observable) {
+	    this._clearStoreReferences(observable);
+	    this.replaced_observables.push(observable);
+	    return this._remove(observable);
 	  };
 
-	  ViewModel.prototype.createObservables = function(model, keys) {
-	    var key, mapping_info, rel_keys, vm_key, _i, _j, _len, _len1, _ref1;
-	    if (!keys) {
-	      if (this.__kb.keys || !model) {
-	        return;
-	      }
-	      for (key in model.attributes) {
-	        createObservable(this, model, key, this.__kb.create_options);
-	      }
-	      if (rel_keys = (_ref1 = kb.orm) != null ? typeof _ref1.keys === "function" ? _ref1.keys(model) : void 0 : void 0) {
-	        for (_i = 0, _len = rel_keys.length; _i < _len; _i++) {
-	          key = rel_keys[_i];
-	          createObservable(this, model, key, this.__kb.create_options);
-	        }
-	      }
-	    } else if (_.isArray(keys)) {
-	      for (_j = 0, _len1 = keys.length; _j < _len1; _j++) {
-	        key = keys[_j];
-	        createObservable(this, model, key, this.__kb.create_options);
-	      }
-	    } else {
-	      for (key in keys) {
-	        mapping_info = keys[key];
-	        if (!(vm_key = assignViewModelKey(this, key))) {
-	          continue;
-	        }
-	        if (!_.isString(mapping_info)) {
-	          mapping_info.key || (mapping_info.key = vm_key);
-	        }
-	        this[vm_key] = this.__kb.view_model[vm_key] = kb.observable(model, mapping_info, this.__kb.create_options, this);
+	  Store.prototype._add = function(observable, obj, creator) {
+	    var base, name;
+	    creator || (creator = observable.constructor);
+	    kb.utils.wrappedObject(observable, obj);
+	    kb.utils.wrappedCreator(observable, creator);
+	    return ((base = this.observable_records)[name = this._creatorId(creator)] || (base[name] = {}))[this._cid(obj)] = observable;
+	  };
+
+	  Store.prototype._remove = function(observable) {
+	    var creator, current_observable, obj;
+	    creator = kb.utils.wrappedCreator(observable) || observable.constructor;
+	    if (current_observable = this.find(obj = kb.utils.wrappedObject(observable), creator)) {
+	      if (current_observable === observable) {
+	        delete this.observable_records[this._creatorId(creator)][this._cid(obj)];
 	      }
 	    }
+	    kb.utils.wrappedObject(observable, null);
+	    return kb.utils.wrappedCreator(observable, null);
+	  };
+
+	  Store.prototype._creator = function(obj, options) {
+	    var creator;
+	    if (options.creator) {
+	      return options.creator;
+	    }
+	    if (creator = kb.utils.inferCreator(obj, options.factory, options.path)) {
+	      return creator;
+	    }
+	    if (kb.isModel(obj)) {
+	      return kb.ViewModel;
+	    }
 	  };
 
-	  return ViewModel;
+	  return Store;
 
 	})();
 
-	kb.viewModel = function(model, options, view_model) {
-	  return new kb.ViewModel(arguments);
-	};
-
 
 /***/ },
-/* 14 */
+/* 20 */
 /***/ function(module, exports, __webpack_require__) {
 
 	
 	/*
-	  knockback.js 0.20.5
+	  knockback.js 1.0.0
 	  Copyright (c)  2011-2014 Kevin Malakoff.
 	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
 	  Source: https://github.com/kmalakoff/knockback
 	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
 	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
 	 */
-	var kb, key, _i, _len, _ref;
+	var _, kb, ko, ref;
 
-	module.exports = kb = __webpack_require__(6);
+	ref = kb = __webpack_require__(2), _ = ref._, ko = ref.ko;
 
-	kb.configure = __webpack_require__(2);
-
-	kb.modules = {
-	  underscore: kb._,
-	  backbone: kb.Parse || kb.Backbone,
-	  knockout: kb.ko
-	};
+	kb.utils = (function() {
+	  function utils() {}
 
-	if (typeof window !== "undefined" && window !== null) {
-	  _ref = ['_', 'Backbone', 'Parse', 'ko', '$'];
-	  for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-	    key = _ref[_i];
-	    if (kb[key] && !Object.prototype.hasOwnProperty.call(window, key)) {
-	      window[key] = kb[key];
+	  utils.get = function(obj, key, default_value) {
+	    if (!obj.__kb || !obj.__kb.hasOwnProperty(key)) {
+	      return default_value;
+	    } else {
+	      return obj.__kb[key];
 	    }
-	  }
-	}
+	  };
 
+	  utils.set = function(obj, key, value) {
+	    return (obj.__kb || (obj.__kb = {}))[key] = value;
+	  };
 
-/***/ },
-/* 15 */
-/***/ function(module, exports, __webpack_require__) {
+	  utils.orSet = function(obj, key, value) {
+	    if (!(obj.__kb || (obj.__kb = {})).hasOwnProperty(key)) {
+	      obj.__kb[key] = value;
+	    }
+	    return obj.__kb[key];
+	  };
 
-	
-	/*
-	  knockback.js 0.20.5
-	  Copyright (c)  2011-2014 Kevin Malakoff.
-	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
-	  Source: https://github.com/kmalakoff/knockback
-	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
-	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
-	 */
-	var KEYS_PUBLISH, kb, ko, _, _ref;
+	  utils.has = function(obj, key) {
+	    return obj.__kb && obj.__kb.hasOwnProperty(key);
+	  };
 
-	_ref = kb = __webpack_require__(6), _ = _ref._, ko = _ref.ko;
+	  utils.wrappedObservable = function(obj, value) {
+	    if (arguments.length === 1) {
+	      return kb.utils.get(obj, 'observable');
+	    } else {
+	      return kb.utils.set(obj, 'observable', value);
+	    }
+	  };
 
-	__webpack_require__(24);
+	  utils.wrappedObject = function(obj, value) {
+	    if (arguments.length === 1) {
+	      return kb.utils.get(obj, 'object');
+	    } else {
+	      return kb.utils.set(obj, 'object', value);
+	    }
+	  };
 
-	KEYS_PUBLISH = ['destroy', 'setToDefault'];
+	  utils.wrappedCreator = function(obj, value) {
+	    if (arguments.length === 1) {
+	      return kb.utils.get(obj, 'creator');
+	    } else {
+	      return kb.utils.set(obj, 'creator', value);
+	    }
+	  };
 
-	module.exports = kb.DefaultObservable = (function() {
-	  function DefaultObservable(target_observable, dv) {
-	    var observable;
-	    this.dv = dv;
-	    observable = kb.utils.wrappedObservable(this, ko.computed({
-	      read: (function(_this) {
-	        return function() {
-	          var current_target;
-	          current_target = ko.utils.unwrapObservable(target_observable());
-	          if (_.isNull(current_target) || _.isUndefined(current_target)) {
-	            return ko.utils.unwrapObservable(_this.dv);
-	          } else {
-	            return current_target;
-	          }
-	        };
-	      })(this),
-	      write: function(value) {
-	        return target_observable(value);
+	  utils.wrappedModel = function(obj, value) {
+	    if (arguments.length === 1) {
+	      if (_.isUndefined(value = kb.utils.get(obj, 'object'))) {
+	        return obj;
+	      } else {
+	        return value;
 	      }
-	    }));
-	    kb.publishMethods(observable, this, KEYS_PUBLISH);
-	    return observable;
-	  }
-
-	  DefaultObservable.prototype.destroy = function() {
-	    return kb.utils.wrappedDestroy(this);
+	    } else {
+	      return kb.utils.set(obj, 'object', value);
+	    }
 	  };
 
-	  DefaultObservable.prototype.setToDefault = function() {
-	    return kb.utils.wrappedObservable(this)(this.dv);
+	  utils.wrappedStore = function(obj, value) {
+	    if (arguments.length === 1) {
+	      return kb.utils.get(obj, 'store');
+	    } else {
+	      return kb.utils.set(obj, 'store', value);
+	    }
 	  };
 
-	  return DefaultObservable;
+	  utils.wrappedStoreIsOwned = function(obj, value) {
+	    if (arguments.length === 1) {
+	      return kb.utils.get(obj, 'store_is_owned');
+	    } else {
+	      return kb.utils.set(obj, 'store_is_owned', value);
+	    }
+	  };
 
-	})();
+	  utils.wrappedFactory = function(obj, value) {
+	    if (arguments.length === 1) {
+	      return kb.utils.get(obj, 'factory');
+	    } else {
+	      return kb.utils.set(obj, 'factory', value);
+	    }
+	  };
 
-	kb.defaultObservable = function(target, default_value) {
-	  return new kb.DefaultObservable(target, default_value);
-	};
+	  utils.wrappedEventWatcher = function(obj, value) {
+	    if (arguments.length === 1) {
+	      return kb.utils.get(obj, 'event_watcher');
+	    } else {
+	      return kb.utils.set(obj, 'event_watcher', value);
+	    }
+	  };
 
+	  utils.wrappedEventWatcherIsOwned = function(obj, value) {
+	    if (arguments.length === 1) {
+	      return kb.utils.get(obj, 'event_watcher_is_owned');
+	    } else {
+	      return kb.utils.set(obj, 'event_watcher_is_owned', value);
+	    }
+	  };
 
-/***/ },
-/* 16 */
-/***/ function(module, exports, __webpack_require__) {
+	  utils.wrappedDestroy = __webpack_require__(21);
 
-	
-	/*
-	  knockback.js 0.20.5
-	  Copyright (c)  2011-2014 Kevin Malakoff.
-	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
-	  Source: https://github.com/kmalakoff/knockback
-	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
-	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
-	 */
-	var arraySlice, kb, ko, _, _ref;
+	  utils.valueType = function(observable) {
+	    if (!observable) {
+	      return kb.TYPE_UNKNOWN;
+	    }
+	    if (observable.__kb_is_o) {
+	      return observable.valueType();
+	    }
+	    if (observable.__kb_is_co || (observable instanceof kb.Collection)) {
+	      return kb.TYPE_COLLECTION;
+	    }
+	    if ((observable instanceof kb.ViewModel) || (observable instanceof kb.Model)) {
+	      return kb.TYPE_MODEL;
+	    }
+	    if (_.isArray(observable)) {
+	      return kb.TYPE_ARRAY;
+	    }
+	    return kb.TYPE_SIMPLE;
+	  };
 
-	_ref = kb = __webpack_require__(6), _ = _ref._, ko = _ref.ko;
+	  utils.pathJoin = function(path1, path2) {
+	    return (path1 ? (path1[path1.length - 1] !== '.' ? path1 + "." : path1) : '') + path2;
+	  };
 
-	arraySlice = Array.prototype.slice;
+	  utils.optionsPathJoin = function(options, path) {
+	    return _.defaults({
+	      path: this.pathJoin(options.path, path)
+	    }, options);
+	  };
 
-	kb.toFormattedString = function(format) {
-	  var arg, args, index, parameter_index, result, value;
-	  result = format.slice();
-	  args = arraySlice.call(arguments, 1);
-	  for (index in args) {
-	    arg = args[index];
-	    value = ko.utils.unwrapObservable(arg);
-	    if (_.isUndefined(value) || _.isNull(value)) {
-	      value = '';
+	  utils.inferCreator = function(value, factory, path) {
+	    var creator;
+	    if (factory && (creator = factory.creatorForPath(value, path))) {
+	      return creator;
 	    }
-	    parameter_index = format.indexOf("\{" + index + "\}");
-	    while (parameter_index >= 0) {
-	      result = result.replace("{" + index + "}", value);
-	      parameter_index = format.indexOf("\{" + index + "\}", parameter_index + 1);
+	    if (!value) {
+	      return null;
 	    }
-	  }
-	  return result;
-	};
-
-	kb.parseFormattedString = function(string, format) {
-	  var count, format_indices_to_matched_indices, index, match_index, matches, parameter_count, parameter_index, positions, regex, regex_string, result, results, sorted_positions;
-	  regex_string = format.slice();
-	  index = 0;
-	  parameter_count = 0;
-	  positions = {};
-	  while (regex_string.search("\\{" + index + "\\}") >= 0) {
-	    parameter_index = format.indexOf("\{" + index + "\}");
-	    while (parameter_index >= 0) {
-	      regex_string = regex_string.replace("\{" + index + "\}", '(.*)');
-	      positions[parameter_index] = index;
-	      parameter_count++;
-	      parameter_index = format.indexOf("\{" + index + "\}", parameter_index + 1);
+	    if (value instanceof kb.Model) {
+	      return kb.ViewModel;
 	    }
-	    index++;
-	  }
-	  count = index;
-	  regex = new RegExp(regex_string);
-	  matches = regex.exec(string);
-	  if (matches) {
-	    matches.shift();
-	  }
-	  if (!matches || (matches.length !== parameter_count)) {
-	    result = [];
-	    while (count-- > 0) {
-	      result.push('');
+	    if (value instanceof kb.Collection) {
+	      return kb.CollectionObservable;
+	    }
+	    return null;
+	  };
+
+	  utils.createFromDefaultCreator = function(obj, options) {
+	    if (kb.isModel(obj)) {
+	      return kb.viewModel(obj, options);
 	    }
-	    return result;
-	  }
-	  sorted_positions = _.sortBy(_.keys(positions), function(parameter_index, format_index) {
-	    return parseInt(parameter_index, 10);
-	  });
-	  format_indices_to_matched_indices = {};
-	  for (match_index in sorted_positions) {
-	    parameter_index = sorted_positions[match_index];
-	    index = positions[parameter_index];
-	    if (format_indices_to_matched_indices.hasOwnProperty(index)) {
-	      continue;
+	    if (kb.isCollection(obj)) {
+	      return kb.collectionObservable(obj, options);
 	    }
-	    format_indices_to_matched_indices[index] = match_index;
-	  }
-	  results = [];
-	  index = 0;
-	  while (index < count) {
-	    results.push(matches[format_indices_to_matched_indices[index]]);
-	    index++;
-	  }
-	  return results;
-	};
+	    if (_.isArray(obj)) {
+	      return ko.observableArray(obj);
+	    }
+	    return ko.observable(obj);
+	  };
 
-	module.exports = kb.FormattedObservable = (function() {
-	  function FormattedObservable(format, args) {
-	    var observable, observable_args;
-	    if (_.isArray(args)) {
-	      format = format;
-	      observable_args = args;
+	  utils.collapseOptions = __webpack_require__(22);
+
+	  utils.unwrapModels = __webpack_require__(23);
+
+	  utils.resolveModel = function(model) {
+	    if (model && kb.Backbone && kb.Backbone.ModelRef && model instanceof kb.Backbone.ModelRef) {
+	      return model.model();
 	    } else {
-	      observable_args = arraySlice.call(arguments, 1);
+	      return model;
 	    }
-	    observable = kb.utils.wrappedObservable(this, ko.computed({
-	      read: function() {
-	        var arg, _i, _len;
-	        args = [ko.utils.unwrapObservable(format)];
-	        for (_i = 0, _len = observable_args.length; _i < _len; _i++) {
-	          arg = observable_args[_i];
-	          args.push(ko.utils.unwrapObservable(arg));
-	        }
-	        return kb.toFormattedString.apply(null, args);
-	      },
-	      write: function(value) {
-	        var index, matches, max_count;
-	        matches = kb.parseFormattedString(value, ko.utils.unwrapObservable(format));
-	        max_count = Math.min(observable_args.length, matches.length);
-	        index = 0;
-	        while (index < max_count) {
-	          observable_args[index](matches[index]);
-	          index++;
-	        }
-	      }
-	    }));
-	    return observable;
-	  }
-
-	  FormattedObservable.prototype.destroy = function() {
-	    return kb.utils.wrappedDestroy(this);
 	  };
 
-	  return FormattedObservable;
+	  return utils;
 
 	})();
 
-	kb.formattedObservable = function(format, args) {
-	  return new kb.FormattedObservable(format, arraySlice.call(arguments, 1));
-	};
-
 
 /***/ },
-/* 17 */
+/* 21 */
 /***/ function(module, exports, __webpack_require__) {
 
 	
 	/*
-	  knockback.js 0.20.5
+	  knockback.js 1.0.0
 	  Copyright (c)  2011-2014 Kevin Malakoff.
 	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
 	  Source: https://github.com/kmalakoff/knockback
 	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
 	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
 	 */
-	var KEYS_PUBLISH, kb, ko, _, _ref;
+	var _, wrappedDestroy;
 
-	_ref = kb = __webpack_require__(6), _ = _ref._, ko = _ref.ko;
+	_ = __webpack_require__(2)._;
 
-	KEYS_PUBLISH = ['destroy', 'observedValue', 'resetToCurrent'];
+	module.exports = wrappedDestroy = function(obj) {
+	  var __kb, store_references;
+	  if (!obj.__kb) {
+	    return;
+	  }
+	  if (obj.__kb.event_watcher) {
+	    obj.__kb.event_watcher.releaseCallbacks(obj);
+	  }
+	  __kb = obj.__kb;
+	  obj.__kb = null;
+	  if (__kb.observable) {
+	    __kb.observable.destroy = __kb.observable.release = null;
+	    wrappedDestroy(__kb.observable);
+	    __kb.observable = null;
+	  }
+	  __kb.factory = null;
+	  if (__kb.event_watcher_is_owned) {
+	    __kb.event_watcher.destroy();
+	  }
+	  __kb.event_watcher = null;
+	  if (__kb.store_is_owned) {
+	    __kb.store.destroy();
+	  }
+	  __kb.store = null;
+	  if (__kb.stores_references) {
+	    while (store_references = __kb.stores_references.pop()) {
+	      if (!store_references.store.__kb_released) {
+	        store_references.store.release(obj);
+	      }
+	    }
+	  }
+	};
 
-	kb.locale_manager || (kb.locale_manager = void 0);
 
-	module.exports = kb.LocalizedObservable = (function() {
-	  LocalizedObservable.extend = kb.extend;
+/***/ },
+/* 22 */
+/***/ function(module, exports, __webpack_require__) {
 
-	  function LocalizedObservable(value, options, vm) {
-	    var observable;
-	    this.value = value;
-	    this.vm = vm;
-	    options || (options = {});
-	    this.vm || (this.vm = {});
-	    this.read || kb._throwMissing(this, 'read');
-	    kb.locale_manager || kb._throwMissing(this, 'kb.locale_manager');
-	    this.__kb || (this.__kb = {});
-	    this.__kb._onLocaleChange = _.bind(this._onLocaleChange, this);
-	    this.__kb._onChange = options.onChange;
-	    if (this.value) {
-	      value = ko.utils.unwrapObservable(this.value);
-	    }
-	    this.vo = ko.observable(!value ? null : this.read(value, null));
-	    observable = kb.utils.wrappedObservable(this, ko.computed({
-	      read: (function(_this) {
-	        return function() {
-	          if (_this.value) {
-	            ko.utils.unwrapObservable(_this.value);
-	          }
-	          _this.vo();
-	          return _this.read(ko.utils.unwrapObservable(_this.value));
-	        };
-	      })(this),
-	      write: (function(_this) {
-	        return function(value) {
-	          _this.write || kb._throwUnexpected(_this, 'writing to read-only');
-	          _this.write(value, ko.utils.unwrapObservable(_this.value));
-	          _this.vo(value);
-	          if (_this.__kb._onChange) {
-	            return _this.__kb._onChange(value);
-	          }
-	        };
-	      })(this),
-	      owner: this.vm
-	    }));
-	    kb.publishMethods(observable, this, KEYS_PUBLISH);
-	    kb.locale_manager.bind('change', this.__kb._onLocaleChange);
-	    if (options.hasOwnProperty('default')) {
-	      observable = kb.DefaultObservable && ko.defaultObservable(observable, options["default"]);
-	    }
-	    return observable;
-	  }
+	
+	/*
+	  knockback.js 1.0.0
+	  Copyright (c)  2011-2014 Kevin Malakoff.
+	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
+	  Source: https://github.com/kmalakoff/knockback
+	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
+	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
+	 */
+	var _, _keyArrayToObject, _mergeArray, _mergeObject, _mergeOptions;
 
-	  LocalizedObservable.prototype.destroy = function() {
-	    kb.locale_manager.unbind('change', this.__kb._onLocaleChange);
-	    this.vm = null;
-	    return kb.utils.wrappedDestroy(this);
-	  };
+	_ = __webpack_require__(2)._;
 
-	  LocalizedObservable.prototype.resetToCurrent = function() {
-	    var current_value, observable;
-	    observable = kb.utils.wrappedObservable(this);
-	    current_value = this.value ? this.read(ko.utils.unwrapObservable(this.value)) : null;
-	    if (observable() === current_value) {
-	      return;
-	    }
-	    return observable(current_value);
-	  };
+	_mergeArray = function(result, key, value) {
+	  result[key] || (result[key] = []);
+	  if (!_.isArray(value)) {
+	    value = [value];
+	  }
+	  result[key] = result[key].length ? _.union(result[key], value) : value;
+	  return result;
+	};
 
-	  LocalizedObservable.prototype.observedValue = function(value) {
-	    if (arguments.length === 0) {
-	      return this.value;
-	    }
-	    this.value = value;
-	    this._onLocaleChange();
-	  };
+	_mergeObject = function(result, key, value) {
+	  result[key] || (result[key] = {});
+	  return _.extend(result[key], value);
+	};
 
-	  LocalizedObservable.prototype._onLocaleChange = function() {
-	    var value;
-	    value = this.read(ko.utils.unwrapObservable(this.value));
-	    this.vo(value);
-	    if (this.__kb._onChange) {
-	      return this.__kb._onChange(value);
+	_keyArrayToObject = function(value) {
+	  var i, item, len, result;
+	  result = {};
+	  for (i = 0, len = value.length; i < len; i++) {
+	    item = value[i];
+	    result[item] = {
+	      key: item
+	    };
+	  }
+	  return result;
+	};
+
+	_mergeOptions = function(result, options) {
+	  var key, value;
+	  if (!options) {
+	    return result;
+	  }
+	  for (key in options) {
+	    value = options[key];
+	    switch (key) {
+	      case 'internals':
+	      case 'requires':
+	      case 'excludes':
+	      case 'statics':
+	        _mergeArray(result, key, value);
+	        break;
+	      case 'keys':
+	        if ((_.isObject(value) && !_.isArray(value)) || (_.isObject(result[key]) && !_.isArray(result[key]))) {
+	          if (!_.isObject(value)) {
+	            value = [value];
+	          }
+	          if (_.isArray(value)) {
+	            value = _keyArrayToObject(value);
+	          }
+	          if (_.isArray(result[key])) {
+	            result[key] = _keyArrayToObject(result[key]);
+	          }
+	          _mergeObject(result, key, value);
+	        } else {
+	          _mergeArray(result, key, value);
+	        }
+	        break;
+	      case 'factories':
+	        if (_.isFunction(value)) {
+	          result[key] = value;
+	        } else {
+	          _mergeObject(result, key, value);
+	        }
+	        break;
+	      case 'static_defaults':
+	        _mergeObject(result, key, value);
+	        break;
+	      case 'options':
+	        break;
+	      default:
+	        result[key] = value;
 	    }
-	  };
-
-	  return LocalizedObservable;
-
-	})();
+	  }
+	  return _mergeOptions(result, options.options);
+	};
 
-	kb.localizedObservable = function(value, options, view_model) {
-	  return new kb.LocalizedObservable(value, options, view_model);
+	module.exports = function(options) {
+	  return _mergeOptions({}, options);
 	};
 
 
 /***/ },
-/* 18 */
+/* 23 */
 /***/ function(module, exports, __webpack_require__) {
 
 	
 	/*
-	  knockback.js 0.20.5
+	  knockback.js 1.0.0
 	  Copyright (c)  2011-2014 Kevin Malakoff.
 	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
 	  Source: https://github.com/kmalakoff/knockback
 	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
 	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
 	 */
-	var KEYS_PUBLISH, kb, ko, _, _ref;
+	var _, unwrapModels;
 
-	_ref = kb = __webpack_require__(6), _ = _ref._, ko = _ref.ko;
-
-	KEYS_PUBLISH = ['destroy'];
+	_ = __webpack_require__(2)._;
 
-	module.exports = kb.TriggeredObservable = (function() {
-	  function TriggeredObservable(emitter, event_selector) {
-	    var observable;
-	    this.event_selector = event_selector;
-	    emitter || kb._throwMissing(this, 'emitter');
-	    this.event_selector || kb._throwMissing(this, 'event_selector');
-	    this.vo = ko.observable();
-	    observable = kb.utils.wrappedObservable(this, ko.computed((function(_this) {
-	      return function() {
-	        return _this.vo();
-	      };
-	    })(this)));
-	    kb.publishMethods(observable, this, KEYS_PUBLISH);
-	    kb.utils.wrappedEventWatcher(this, new kb.EventWatcher(emitter, this, {
-	      emitter: _.bind(this.emitter, this),
-	      update: _.bind(this.update, this),
-	      event_selector: this.event_selector
-	    }));
-	    return observable;
+	module.exports = unwrapModels = function(obj) {
+	  var key, result, value;
+	  if (!obj) {
+	    return obj;
 	  }
-
-	  TriggeredObservable.prototype.destroy = function() {
-	    return kb.utils.wrappedDestroy(this);
-	  };
-
-	  TriggeredObservable.prototype.emitter = function(new_emitter) {
-	    if ((arguments.length === 0) || (this.ee === new_emitter)) {
-	      return this.ee;
-	    }
-	    if ((this.ee = new_emitter)) {
-	      return this.update();
-	    }
-	  };
-
-	  TriggeredObservable.prototype.update = function() {
-	    if (!this.ee) {
-	      return;
-	    }
-	    if (this.vo() !== this.ee) {
-	      return this.vo(this.ee);
-	    } else {
-	      return this.vo.valueHasMutated();
+	  if (obj.__kb) {
+	    return (obj.__kb.hasOwnProperty('object') ? obj.__kb.object : obj);
+	  }
+	  if (_.isArray(obj)) {
+	    return _.map(obj, function(test) {
+	      return unwrapModels(test);
+	    });
+	  }
+	  if (_.isObject(obj) && (obj.constructor === {}.constructor)) {
+	    result = {};
+	    for (key in obj) {
+	      value = obj[key];
+	      result[key] = unwrapModels(value);
 	    }
-	  };
-
-	  return TriggeredObservable;
-
-	})();
-
-	kb.triggeredObservable = function(emitter, event_selector) {
-	  return new kb.TriggeredObservable(emitter, event_selector);
+	    return result;
+	  }
+	  return obj;
 	};
 
 
 /***/ },
-/* 19 */
+/* 24 */
 /***/ function(module, exports, __webpack_require__) {
 
 	
 	/*
-	  knockback.js 0.20.5
+	  knockback.js 1.0.0
 	  Copyright (c)  2011-2014 Kevin Malakoff.
 	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
 	  Source: https://github.com/kmalakoff/knockback
 	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
 	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
 	 */
-	var $, callOrGet, kb, ko, _, _ref;
-
-	_ref = kb = __webpack_require__(6), _ = _ref._, ko = _ref.ko, $ = _ref.$;
-
-	__webpack_require__(25);
-
-	callOrGet = function(value) {
-	  value = ko.utils.unwrapObservable(value);
-	  if (typeof value === 'function') {
-	    return value.apply(null, Array.prototype.slice.call(arguments, 1));
-	  } else {
-	    return value;
-	  }
-	};
-
-	module.exports = kb.Validation = (function() {
-	  function Validation() {}
+	var KEYS_OPTIONS, _, assignViewModelKey, createObservable, createStaticObservables, kb, ko, ref;
 
-	  return Validation;
-
-	})();
+	ref = kb = __webpack_require__(2), _ = ref._, ko = ref.ko;
 
-	kb.valueValidator = function(value, bindings, validation_options) {
-	  if (validation_options == null) {
-	    validation_options = {};
+	assignViewModelKey = function(vm, key) {
+	  var vm_key;
+	  vm_key = vm.__kb.internals && _.contains(vm.__kb.internals, key) ? "_" + key : key;
+	  if (vm.__kb.view_model.hasOwnProperty(vm_key)) {
+	    return;
 	  }
-	  (validation_options && !(typeof validation_options === 'function')) || (validation_options = {});
-	  return ko.computed(function() {
-	    var active_index, current_value, disabled, identifier, identifier_index, priorities, results, validator;
-	    results = {
-	      $error_count: 0
-	    };
-	    current_value = ko.utils.unwrapObservable(value);
-	    !('disable' in validation_options) || (disabled = callOrGet(validation_options.disable));
-	    !('enable' in validation_options) || (disabled = !callOrGet(validation_options.enable));
-	    priorities = validation_options.priorities || [];
-	    _.isArray(priorities) || (priorities = [priorities]);
-	    active_index = priorities.length + 1;
-	    for (identifier in bindings) {
-	      validator = bindings[identifier];
-	      results[identifier] = !disabled && callOrGet(validator, current_value);
-	      if (results[identifier]) {
-	        results.$error_count++;
-	        (identifier_index = _.indexOf(priorities, identifier) >= 0) || (identifier_index = priorities.length);
-	        if (results.$active_error && identifier_index < active_index) {
-	          results.$active_error = identifier;
-	          active_index = identifier_index;
-	        } else {
-	          results.$active_error || (results.$active_error = identifier, active_index = identifier_index);
-	        }
-	      }
-	    }
-	    results.$enabled = !disabled;
-	    results.$disable = !!disabled;
-	    results.$valid = results.$error_count === 0;
-	    return results;
-	  });
+	  vm.__kb.view_model[vm_key] = null;
+	  return vm_key;
 	};
 
-	kb.inputValidator = function(view_model, el, validation_options) {
-	  var $input_el, bindings, identifier, input_name, options, result, type, validator, validators, _ref1;
-	  if (validation_options == null) {
-	    validation_options = {};
-	  }
-	  (validation_options && !(typeof validation_options === 'function')) || (validation_options = {});
-	  validators = kb.valid;
-	  $input_el = $(el);
-	  if ((input_name = $input_el.attr('name')) && !_.isString(input_name)) {
-	    input_name = null;
-	  }
-	  if (!(bindings = $input_el.attr('data-bind'))) {
-	    return null;
+	createObservable = function(vm, model, key, create_options) {
+	  var vm_key;
+	  if (vm.__kb.excludes && _.contains(vm.__kb.excludes, key)) {
+	    return;
 	  }
-	  options = (new Function("sc", "with(sc[0]) { return { " + bindings + " } }"))([view_model]);
-	  if (!(options && options.value)) {
-	    return null;
+	  if (vm.__kb.statics && _.contains(vm.__kb.statics, key)) {
+	    return;
 	  }
-	  (!options.validation_options) || (_.defaults(options.validation_options, validation_options), validation_options = options.validation_options);
-	  bindings = {};
-	  (!validators[type = $input_el.attr('type')]) || (bindings[type] = validators[type]);
-	  (!$input_el.attr('required')) || (bindings.required = validators.required);
-	  if (options.validations) {
-	    _ref1 = options.validations;
-	    for (identifier in _ref1) {
-	      validator = _ref1[identifier];
-	      bindings[identifier] = validator;
-	    }
+	  if (!(vm_key = assignViewModelKey(vm, key))) {
+	    return;
 	  }
-	  result = kb.valueValidator(options.value, bindings, validation_options);
-	  (!input_name && !validation_options.no_attach) || (view_model["$" + input_name] = result);
-	  return result;
+	  return vm[vm_key] = vm.__kb.view_model[vm_key] = kb.observable(model, key, create_options, vm);
 	};
 
-	kb.formValidator = function(view_model, el) {
-	  var $root_el, bindings, form_name, input_el, name, options, results, validation_options, validator, validators, _i, _len, _ref1;
-	  results = {};
-	  validators = [];
-	  $root_el = $(el);
-	  if ((form_name = $root_el.attr('name')) && !_.isString(form_name)) {
-	    form_name = null;
-	  }
-	  if ((bindings = $root_el.attr('data-bind'))) {
-	    options = (new Function("sc", "with(sc[0]) { return { " + bindings + " } }"))([view_model]);
-	    validation_options = options.validation_options;
-	  }
-	  validation_options || (validation_options = {});
-	  validation_options.no_attach = !!form_name;
-	  _ref1 = $root_el.find('input');
-	  for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
-	    input_el = _ref1[_i];
-	    if (!(name = $(input_el).attr('name'))) {
-	      continue;
+	createStaticObservables = function(vm, model) {
+	  var i, key, len, ref1, vm_key;
+	  ref1 = vm.__kb.statics;
+	  for (i = 0, len = ref1.length; i < len; i++) {
+	    key = ref1[i];
+	    if (vm_key = assignViewModelKey(vm, key)) {
+	      if (model.has(vm_key)) {
+	        vm[vm_key] = vm.__kb.view_model[vm_key] = model.get(vm_key);
+	      } else if (vm.__kb.static_defaults && vm_key in vm.__kb.static_defaults) {
+	        vm[vm_key] = vm.__kb.view_model[vm_key] = vm.__kb.static_defaults[vm_key];
+	      } else {
+	        delete vm.__kb.view_model[vm_key];
+	      }
 	    }
-	    validator = kb.inputValidator(view_model, input_el, validation_options);
-	    !validator || validators.push(results[name] = validator);
 	  }
-	  results.$error_count = ko.computed(function() {
-	    var error_count, _j, _len1;
-	    error_count = 0;
-	    for (_j = 0, _len1 = validators.length; _j < _len1; _j++) {
-	      validator = validators[_j];
-	      error_count += validator().$error_count;
-	    }
-	    return error_count;
-	  });
-	  results.$valid = ko.computed(function() {
-	    return results.$error_count() === 0;
-	  });
-	  results.$enabled = ko.computed(function() {
-	    var enabled, _j, _len1;
-	    enabled = true;
-	    for (_j = 0, _len1 = validators.length; _j < _len1; _j++) {
-	      validator = validators[_j];
-	      enabled &= validator().$enabled;
+	};
+
+	KEYS_OPTIONS = ['keys', 'internals', 'excludes', 'statics', 'static_defaults'];
+
+	kb.ViewModel = (function() {
+	  ViewModel.extend = kb.extend;
+
+	  function ViewModel(model, options, view_model) {
+	    var args;
+	    if (options == null) {
+	      options = {};
 	    }
-	    return enabled;
-	  });
-	  results.$disabled = ko.computed(function() {
-	    return !results.$enabled();
-	  });
-	  if (form_name) {
-	    view_model["$" + form_name] = results;
+	    args = Array.prototype.slice.call(_.isArguments(model) ? model : arguments);
+	    return kb.ignore((function(_this) {
+	      return function() {
+	        var _model, arg, event_watcher, i, j, key, len, len1;
+	        !(model = args.shift()) || kb.isModel(model) || kb._throwUnexpected(_this, 'not a model');
+	        if (_.isArray(args[0])) {
+	          args[0] = {
+	            keys: args[0]
+	          };
+	        }
+	        _this.__kb || (_this.__kb = {});
+	        _this.__kb.view_model = (args.length > 1 ? args.pop() : _this);
+	        options = {};
+	        for (i = 0, len = args.length; i < len; i++) {
+	          arg = args[i];
+	          _.extend(options, arg);
+	        }
+	        options = kb.utils.collapseOptions(options);
+	        for (j = 0, len1 = KEYS_OPTIONS.length; j < len1; j++) {
+	          key = KEYS_OPTIONS[j];
+	          if (options.hasOwnProperty(key)) {
+	            _this.__kb[key] = options[key];
+	          }
+	        }
+	        kb.Store.useOptionsOrCreate(options, model, _this);
+	        _this.__kb.path = options.path;
+	        kb.Factory.useOptionsOrCreate(options, _this, options.path);
+	        _model = kb.utils.set(_this, '_model', ko.observable());
+	        _this.model = ko.computed({
+	          read: function() {
+	            return ko.utils.unwrapObservable(_model);
+	          },
+	          write: function(new_model) {
+	            return kb.ignore(function() {
+	              if ((kb.utils.wrappedObject(_this) === new_model) || kb.wasReleased(_this) || !event_watcher) {
+	                return;
+	              }
+	              _this.__kb.store.reuse(_this, kb.utils.resolveModel(new_model));
+	              event_watcher.emitter(new_model);
+	              _model(event_watcher.ee);
+	              return !event_watcher.ee || _this.createObservables(event_watcher.ee);
+	            });
+	          }
+	        });
+	        event_watcher = kb.utils.wrappedEventWatcher(_this, new kb.EventWatcher(model, _this, {
+	          emitter: _this._model,
+	          update: (function() {
+	            return kb.ignore(function() {
+	              return !(event_watcher != null ? event_watcher.ee : void 0) || _this.createObservables(event_watcher != null ? event_watcher.ee : void 0);
+	            });
+	          })
+	        }));
+	        kb.utils.wrappedObject(_this, model = event_watcher.ee);
+	        _model(event_watcher.ee);
+	        _this.__kb.create_options = {
+	          store: kb.utils.wrappedStore(_this),
+	          factory: kb.utils.wrappedFactory(_this),
+	          path: _this.__kb.path,
+	          event_watcher: kb.utils.wrappedEventWatcher(_this)
+	        };
+	        !options.requires || _this.createObservables(model, options.requires);
+	        !_this.__kb.internals || _this.createObservables(model, _this.__kb.internals);
+	        !options.mappings || _this.createObservables(model, options.mappings);
+	        !_this.__kb.statics || createStaticObservables(_this, model);
+	        _this.createObservables(model, _this.__kb.keys);
+	        !kb.statistics || kb.statistics.register('ViewModel', _this);
+	        return _this;
+	      };
+	    })(this));
 	  }
-	  return results;
-	};
-
-
-/***/ },
-/* 20 */
-/***/ function(module, exports, __webpack_require__) {
 
-	module.exports = __WEBPACK_EXTERNAL_MODULE_20__;
+	  ViewModel.prototype.destroy = function() {
+	    var vm_key;
+	    this.__kb_released = true;
+	    if (this.__kb.view_model !== this) {
+	      for (vm_key in this.__kb.vm_keys) {
+	        this.__kb.view_model[vm_key] = null;
+	      }
+	    }
+	    this.__kb.view_model = this.__kb.create_options = null;
+	    kb.releaseKeys(this);
+	    kb.utils.wrappedDestroy(this);
+	    return !kb.statistics || kb.statistics.unregister('ViewModel', this);
+	  };
 
-/***/ },
-/* 21 */
-/***/ function(module, exports, __webpack_require__) {
+	  ViewModel.prototype.shareOptions = function() {
+	    return {
+	      store: kb.utils.wrappedStore(this),
+	      factory: kb.utils.wrappedFactory(this)
+	    };
+	  };
 
-	module.exports = __WEBPACK_EXTERNAL_MODULE_21__;
+	  ViewModel.prototype.createObservables = function(model, keys) {
+	    var i, j, key, len, len1, mapping_info, ref1, rel_keys, vm_key;
+	    if (!keys) {
+	      if (this.__kb.keys || !model) {
+	        return;
+	      }
+	      for (key in model.attributes) {
+	        createObservable(this, model, key, this.__kb.create_options);
+	      }
+	      if (rel_keys = (ref1 = kb.orm) != null ? typeof ref1.keys === "function" ? ref1.keys(model) : void 0 : void 0) {
+	        for (i = 0, len = rel_keys.length; i < len; i++) {
+	          key = rel_keys[i];
+	          createObservable(this, model, key, this.__kb.create_options);
+	        }
+	      }
+	    } else if (_.isArray(keys)) {
+	      for (j = 0, len1 = keys.length; j < len1; j++) {
+	        key = keys[j];
+	        createObservable(this, model, key, this.__kb.create_options);
+	      }
+	    } else {
+	      for (key in keys) {
+	        mapping_info = keys[key];
+	        if (!(vm_key = assignViewModelKey(this, key))) {
+	          continue;
+	        }
+	        if (!_.isString(mapping_info)) {
+	          mapping_info.key || (mapping_info.key = vm_key);
+	        }
+	        this[vm_key] = this.__kb.view_model[vm_key] = kb.observable(model, mapping_info, this.__kb.create_options, this);
+	      }
+	    }
+	  };
 
-/***/ },
-/* 22 */
-/***/ function(module, exports, __webpack_require__) {
+	  return ViewModel;
 
-	module.exports = __WEBPACK_EXTERNAL_MODULE_22__;
+	})();
 
-/***/ },
-/* 23 */
-/***/ function(module, exports, __webpack_require__) {
+	kb.viewModel = function(model, options, view_model) {
+	  return new kb.ViewModel(arguments);
+	};
 
-	if(typeof __WEBPACK_EXTERNAL_MODULE_23__ === 'undefined') {var e = new Error("Cannot find module \"undefined\""); e.code = 'MODULE_NOT_FOUND'; throw e;}
-	module.exports = __WEBPACK_EXTERNAL_MODULE_23__;
 
 /***/ },
-/* 24 */
+/* 25 */
 /***/ function(module, exports, __webpack_require__) {
 
 	
 	/*
-	  knockback.js 0.20.5
+	  knockback.js 1.0.0
 	  Copyright (c)  2011-2014 Kevin Malakoff.
 	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
 	  Source: https://github.com/kmalakoff/knockback
 	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
 	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
 	 */
-	var kb, ko, _, _ref;
+	var KEYS_PUBLISH, _, kb, ko, ref;
 
-	_ref = kb = __webpack_require__(6), _ = _ref._, ko = _ref.ko;
+	ref = kb = __webpack_require__(2), _ = ref._, ko = ref.ko;
 
-	kb.Observable.prototype.setToDefault = function() {
-	  var _ref1;
-	  if ((_ref1 = this.__kb_value) != null) {
-	    if (typeof _ref1.setToDefault === "function") {
-	      _ref1.setToDefault();
-	    }
-	  }
-	};
+	__webpack_require__(26);
 
-	kb.ViewModel.prototype.setToDefault = function() {
-	  var vm_key, _ref1;
-	  for (vm_key in this.__kb.vm_keys) {
-	    if ((_ref1 = this[vm_key]) != null) {
-	      if (typeof _ref1.setToDefault === "function") {
-	        _ref1.setToDefault();
-	      }
-	    }
-	  }
-	};
+	KEYS_PUBLISH = ['destroy', 'setToDefault'];
 
-	kb.utils.setToDefault = function(obj) {
-	  var key, value;
-	  if (!obj) {
-	    return;
-	  }
-	  if (ko.isObservable(obj)) {
-	    if (typeof obj.setToDefault === "function") {
-	      obj.setToDefault();
-	    }
-	  } else if (_.isObject(obj)) {
-	    for (key in obj) {
-	      value = obj[key];
-	      if (value && (ko.isObservable(value) || (typeof value !== 'function')) && ((key[0] !== '_') || key.search('__kb'))) {
-	        this.setToDefault(value);
+	module.exports = kb.DefaultObservable = (function() {
+	  function DefaultObservable(target_observable, dv) {
+	    var observable;
+	    this.dv = dv;
+	    observable = kb.utils.wrappedObservable(this, ko.computed({
+	      read: (function(_this) {
+	        return function() {
+	          var current_target;
+	          current_target = ko.utils.unwrapObservable(target_observable());
+	          if (_.isNull(current_target) || _.isUndefined(current_target)) {
+	            return ko.utils.unwrapObservable(_this.dv);
+	          } else {
+	            return current_target;
+	          }
+	        };
+	      })(this),
+	      write: function(value) {
+	        return target_observable(value);
 	      }
-	    }
+	    }));
+	    kb.publishMethods(observable, this, KEYS_PUBLISH);
+	    return observable;
 	  }
-	  return obj;
+
+	  DefaultObservable.prototype.destroy = function() {
+	    return kb.utils.wrappedDestroy(this);
+	  };
+
+	  DefaultObservable.prototype.setToDefault = function() {
+	    return kb.utils.wrappedObservable(this)(this.dv);
+	  };
+
+	  return DefaultObservable;
+
+	})();
+
+	kb.defaultObservable = function(target, default_value) {
+	  return new kb.DefaultObservable(target, default_value);
 	};
 
+	kb.observableDefault = kb.defaultObservable;
+
 
 /***/ },
-/* 25 */
+/* 26 */
 /***/ function(module, exports, __webpack_require__) {
 
 	
 	/*
-	  knockback.js 0.20.5
+	  knockback.js 1.0.0
 	  Copyright (c)  2011-2014 Kevin Malakoff.
 	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
 	  Source: https://github.com/kmalakoff/knockback
 	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
 	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
 	 */
-	var $, EMAIL_REGEXP, NUMBER_REGEXP, URL_REGEXP, kb, ko, _, _ref;
-
-	_ref = kb = __webpack_require__(6), _ = _ref._, ko = _ref.ko, $ = _ref.$;
-
-	URL_REGEXP = /^(ftp|http|https):\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?$/;
-
-	EMAIL_REGEXP = /^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,4}$/;
-
-	NUMBER_REGEXP = /^\s*(\-|\+)?(\d+|(\d*(\.\d*)))\s*$/;
-
-	kb.valid = {
-	  required: function(value) {
-	    return !value;
-	  },
-	  url: function(value) {
-	    return !URL_REGEXP.test(value);
-	  },
-	  email: function(value) {
-	    return !EMAIL_REGEXP.test(value);
-	  },
-	  number: function(value) {
-	    return !NUMBER_REGEXP.test(value);
-	  }
-	};
-
-	kb.hasChangedFn = function(model) {
-	  var attributes, m;
-	  m = null;
-	  attributes = null;
-	  return function() {
-	    var current_model;
-	    if (m !== (current_model = ko.utils.unwrapObservable(model))) {
-	      m = current_model;
-	      attributes = (m ? m.toJSON() : null);
-	      return false;
-	    }
-	    if (!(m && attributes)) {
-	      return false;
-	    }
-	    return !_.isEqual(m.toJSON(), attributes);
-	  };
-	};
+	var _, kb, ko, ref;
 
-	kb.minLengthFn = function(length) {
-	  return function(value) {
-	    return !value || value.length < length;
-	  };
-	};
+	ref = kb = __webpack_require__(2), _ = ref._, ko = ref.ko;
 
-	kb.uniqueValueFn = function(model, key, collection) {
-	  return function(value) {
-	    var c, k, m;
-	    m = ko.utils.unwrapObservable(model);
-	    k = ko.utils.unwrapObservable(key);
-	    c = ko.utils.unwrapObservable(collection);
-	    if (!(m && k && c)) {
-	      return false;
+	kb.Observable.prototype.setToDefault = function() {
+	  var ref1;
+	  if ((ref1 = this.__kb_value) != null) {
+	    if (typeof ref1.setToDefault === "function") {
+	      ref1.setToDefault();
 	    }
-	    return !!_.find(c.models, (function(_this) {
-	      return function(test) {
-	        return (test !== m) && test.get(k) === value;
-	      };
-	    })(this));
-	  };
+	  }
 	};
 
-	kb.untilTrueFn = function(stand_in, fn, model) {
-	  var was_true;
-	  was_true = false;
-	  if (model && ko.isObservable(model)) {
-	    model.subscribe(function() {
-	      return was_true = false;
-	    });
-	  }
-	  return function(value) {
-	    var f, result;
-	    if (!(f = ko.utils.unwrapObservable(fn))) {
-	      return ko.utils.unwrapObservable(stand_in);
-	    }
-	    was_true |= !!(result = f(ko.utils.unwrapObservable(value)));
-	    return (was_true ? result : ko.utils.unwrapObservable(stand_in));
-	  };
+	kb.ViewModel.prototype.setToDefault = function() {
+	  var ref1, vm_key;
+	  for (vm_key in this.__kb.vm_keys) {
+	    if ((ref1 = this[vm_key]) != null) {
+	      if (typeof ref1.setToDefault === "function") {
+	        ref1.setToDefault();
+	      }
+	    }
+	  }
 	};
 
-	kb.untilFalseFn = function(stand_in, fn, model) {
-	  var was_false;
-	  was_false = false;
-	  if (model && ko.isObservable(model)) {
-	    model.subscribe(function() {
-	      return was_false = false;
-	    });
+	kb.utils.setToDefault = function(obj) {
+	  var key, value;
+	  if (!obj) {
+	    return;
 	  }
-	  return function(value) {
-	    var f, result;
-	    if (!(f = ko.utils.unwrapObservable(fn))) {
-	      return ko.utils.unwrapObservable(stand_in);
+	  if (ko.isObservable(obj)) {
+	    if (typeof obj.setToDefault === "function") {
+	      obj.setToDefault();
 	    }
-	    was_false |= !(result = f(ko.utils.unwrapObservable(value)));
-	    return (was_false ? result : ko.utils.unwrapObservable(stand_in));
-	  };
+	  } else if (_.isObject(obj)) {
+	    for (key in obj) {
+	      value = obj[key];
+	      if (value && (ko.isObservable(value) || (typeof value !== 'function')) && ((key[0] !== '_') || key.search('__kb'))) {
+	        this.setToDefault(value);
+	      }
+	    }
+	  }
+	  return obj;
 	};
 
 
 /***/ },
-/* 26 */
+/* 27 */
 /***/ function(module, exports, __webpack_require__) {
 
 	
 	/*
-	  knockback.js 0.20.5
+	  knockback.js 1.0.0
 	  Copyright (c)  2011-2014 Kevin Malakoff.
 	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
 	  Source: https://github.com/kmalakoff/knockback
 	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
 	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
 	 */
-	var AssociatedModel, Backbone, BackboneAssociations, kb, _, _ref;
-
-	_ref = kb = __webpack_require__(6), _ = _ref._, Backbone = _ref.Backbone;
+	var _, arraySlice, kb, ko, ref;
 
-	AssociatedModel = null;
-
-	module.exports = BackboneAssociations = (function() {
-	  function BackboneAssociations() {}
+	ref = kb = __webpack_require__(2), _ = ref._, ko = ref.ko;
 
-	  BackboneAssociations.isAvailable = function() {
-	    return !!(AssociatedModel = Backbone != null ? Backbone.AssociatedModel : void 0);
-	  };
+	arraySlice = Array.prototype.slice;
 
-	  BackboneAssociations.keys = function(model) {
-	    if (!(model instanceof AssociatedModel)) {
-	      return null;
+	kb.toFormattedString = function(format) {
+	  var arg, args, index, parameter_index, result, value;
+	  result = format.slice();
+	  args = arraySlice.call(arguments, 1);
+	  for (index in args) {
+	    arg = args[index];
+	    value = ko.utils.unwrapObservable(arg);
+	    if (_.isUndefined(value) || _.isNull(value)) {
+	      value = '';
 	    }
-	    return _.map(model.relations, function(test) {
-	      return test.key;
-	    });
-	  };
+	    parameter_index = format.indexOf("\{" + index + "\}");
+	    while (parameter_index >= 0) {
+	      result = result.replace("{" + index + "}", value);
+	      parameter_index = format.indexOf("\{" + index + "\}", parameter_index + 1);
+	    }
+	  }
+	  return result;
+	};
 
-	  BackboneAssociations.relationType = function(model, key) {
-	    var relation;
-	    if (!(model instanceof AssociatedModel)) {
-	      return null;
+	kb.parseFormattedString = function(string, format) {
+	  var count, format_indices_to_matched_indices, index, match_index, matches, parameter_count, parameter_index, positions, regex, regex_string, result, results, sorted_positions;
+	  regex_string = format.slice();
+	  index = 0;
+	  parameter_count = 0;
+	  positions = {};
+	  while (regex_string.search("\\{" + index + "\\}") >= 0) {
+	    parameter_index = format.indexOf("\{" + index + "\}");
+	    while (parameter_index >= 0) {
+	      regex_string = regex_string.replace("\{" + index + "\}", '(.*)');
+	      positions[parameter_index] = index;
+	      parameter_count++;
+	      parameter_index = format.indexOf("\{" + index + "\}", parameter_index + 1);
 	    }
-	    if (!(relation = _.find(model.relations, function(test) {
-	      return test.key === key;
-	    }))) {
-	      return null;
+	    index++;
+	  }
+	  count = index;
+	  regex = new RegExp(regex_string);
+	  matches = regex.exec(string);
+	  if (matches) {
+	    matches.shift();
+	  }
+	  if (!matches || (matches.length !== parameter_count)) {
+	    result = [];
+	    while (count-- > 0) {
+	      result.push('');
 	    }
-	    if (relation.type === 'Many') {
-	      return kb.TYPE_COLLECTION;
+	    return result;
+	  }
+	  sorted_positions = _.sortBy(_.keys(positions), function(parameter_index, format_index) {
+	    return parseInt(parameter_index, 10);
+	  });
+	  format_indices_to_matched_indices = {};
+	  for (match_index in sorted_positions) {
+	    parameter_index = sorted_positions[match_index];
+	    index = positions[parameter_index];
+	    if (format_indices_to_matched_indices.hasOwnProperty(index)) {
+	      continue;
+	    }
+	    format_indices_to_matched_indices[index] = match_index;
+	  }
+	  results = [];
+	  index = 0;
+	  while (index < count) {
+	    results.push(matches[format_indices_to_matched_indices[index]]);
+	    index++;
+	  }
+	  return results;
+	};
+
+	module.exports = kb.FormattedObservable = (function() {
+	  function FormattedObservable(format, args) {
+	    var observable, observable_args;
+	    if (_.isArray(args)) {
+	      format = format;
+	      observable_args = args;
 	    } else {
-	      return kb.TYPE_MODEL;
+	      observable_args = arraySlice.call(arguments, 1);
 	    }
-	  };
+	    observable = kb.utils.wrappedObservable(this, ko.computed({
+	      read: function() {
+	        var arg, i, len;
+	        args = [ko.utils.unwrapObservable(format)];
+	        for (i = 0, len = observable_args.length; i < len; i++) {
+	          arg = observable_args[i];
+	          args.push(ko.utils.unwrapObservable(arg));
+	        }
+	        return kb.toFormattedString.apply(null, args);
+	      },
+	      write: function(value) {
+	        var index, matches, max_count;
+	        matches = kb.parseFormattedString(value, ko.utils.unwrapObservable(format));
+	        max_count = Math.min(observable_args.length, matches.length);
+	        index = 0;
+	        while (index < max_count) {
+	          observable_args[index](matches[index]);
+	          index++;
+	        }
+	      }
+	    }));
+	    return observable;
+	  }
 
-	  BackboneAssociations.useFunction = function() {
-	    return false;
+	  FormattedObservable.prototype.destroy = function() {
+	    return kb.utils.wrappedDestroy(this);
 	  };
 
-	  return BackboneAssociations;
+	  return FormattedObservable;
 
 	})();
 
+	kb.formattedObservable = function(format, args) {
+	  return new kb.FormattedObservable(format, arraySlice.call(arguments, 1));
+	};
+
+	kb.observableFormatted = kb.formattedObservable;
+
 
 /***/ },
-/* 27 */
+/* 28 */
 /***/ function(module, exports, __webpack_require__) {
 
 	
 	/*
-	  knockback.js 0.20.5
+	  knockback.js 1.0.0
 	  Copyright (c)  2011-2014 Kevin Malakoff.
 	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
 	  Source: https://github.com/kmalakoff/knockback
 	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
 	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
 	 */
-	var Backbone, BackboneRelational, RelationalModel, kb, _, _ref;
+	var KEYS_PUBLISH, _, kb, ko, ref;
 
-	_ref = kb = __webpack_require__(6), _ = _ref._, Backbone = _ref.Backbone;
+	ref = kb = __webpack_require__(2), _ = ref._, ko = ref.ko;
 
-	RelationalModel = null;
+	KEYS_PUBLISH = ['destroy', 'observedValue', 'resetToCurrent'];
 
-	module.exports = BackboneRelational = (function() {
-	  function BackboneRelational() {}
+	kb.locale_manager || (kb.locale_manager = void 0);
 
-	  BackboneRelational.isAvailable = function() {
-	    return !!(RelationalModel = Backbone != null ? Backbone.RelationalModel : void 0);
-	  };
+	module.exports = kb.LocalizedObservable = (function() {
+	  LocalizedObservable.extend = kb.extend;
 
-	  BackboneRelational.relationType = function(model, key) {
-	    var relation;
-	    if (!(model instanceof RelationalModel)) {
-	      return null;
-	    }
-	    if (!(relation = _.find(model.getRelations(), function(test) {
-	      return test.key === key;
-	    }))) {
-	      return null;
+	  function LocalizedObservable(value1, options, vm) {
+	    var observable, value;
+	    this.value = value1;
+	    this.vm = vm;
+	    options || (options = {});
+	    this.vm || (this.vm = {});
+	    this.read || kb._throwMissing(this, 'read');
+	    kb.locale_manager || kb._throwMissing(this, 'kb.locale_manager');
+	    this.__kb || (this.__kb = {});
+	    this.__kb._onLocaleChange = _.bind(this._onLocaleChange, this);
+	    this.__kb._onChange = options.onChange;
+	    if (this.value) {
+	      value = ko.utils.unwrapObservable(this.value);
 	    }
-	    if (relation.collectionType || _.isArray(relation.keyContents)) {
-	      return kb.TYPE_COLLECTION;
-	    } else {
-	      return kb.TYPE_MODEL;
+	    this.vo = ko.observable(!value ? null : this.read(value, null));
+	    observable = kb.utils.wrappedObservable(this, ko.computed({
+	      read: (function(_this) {
+	        return function() {
+	          if (_this.value) {
+	            ko.utils.unwrapObservable(_this.value);
+	          }
+	          _this.vo();
+	          return _this.read(ko.utils.unwrapObservable(_this.value));
+	        };
+	      })(this),
+	      write: (function(_this) {
+	        return function(value) {
+	          _this.write || kb._throwUnexpected(_this, 'writing to read-only');
+	          _this.write(value, ko.utils.unwrapObservable(_this.value));
+	          _this.vo(value);
+	          if (_this.__kb._onChange) {
+	            return _this.__kb._onChange(value);
+	          }
+	        };
+	      })(this),
+	      owner: this.vm
+	    }));
+	    kb.publishMethods(observable, this, KEYS_PUBLISH);
+	    kb.locale_manager.bind('change', this.__kb._onLocaleChange);
+	    if (options.hasOwnProperty('default')) {
+	      observable = kb.DefaultObservable && ko.defaultObservable(observable, options["default"]);
 	    }
+	    return observable;
+	  }
+
+	  LocalizedObservable.prototype.destroy = function() {
+	    kb.locale_manager.unbind('change', this.__kb._onLocaleChange);
+	    this.vm = null;
+	    return kb.utils.wrappedDestroy(this);
 	  };
 
-	  BackboneRelational.bind = function(model, key, update, path) {
-	    var event, events, rel_fn, type, _i, _len;
-	    if (!(type = this.relationType(model, key))) {
-	      return null;
-	    }
-	    rel_fn = function(model) {
-	      !kb.statistics || kb.statistics.addModelEvent({
-	        name: 'update (relational)',
-	        model: model,
-	        key: key,
-	        path: path
-	      });
-	      return update();
-	    };
-	    events = kb.Backbone.Relation.prototype.sanitizeOptions ? ['update', 'add', 'remove'] : ['change', 'add', 'remove'];
-	    if (type === kb.TYPE_COLLECTION) {
-	      for (_i = 0, _len = events.length; _i < _len; _i++) {
-	        event = events[_i];
-	        model.bind("" + event + ":" + key, rel_fn);
-	      }
-	    } else {
-	      model.bind("" + events[0] + ":" + key, rel_fn);
+	  LocalizedObservable.prototype.resetToCurrent = function() {
+	    var current_value, observable;
+	    observable = kb.utils.wrappedObservable(this);
+	    current_value = this.value ? this.read(ko.utils.unwrapObservable(this.value)) : null;
+	    if (observable() === current_value) {
+	      return;
 	    }
-	    return function() {
-	      var _j, _len1;
-	      if (type === kb.TYPE_COLLECTION) {
-	        for (_j = 0, _len1 = events.length; _j < _len1; _j++) {
-	          event = events[_j];
-	          model.unbind("" + event + ":" + key, rel_fn);
-	        }
-	      } else {
-	        model.unbind("" + events[0] + ":" + key, rel_fn);
-	      }
-	    };
+	    return observable(current_value);
 	  };
 
-	  BackboneRelational.useFunction = function() {
-	    return false;
+	  LocalizedObservable.prototype.observedValue = function(value) {
+	    if (arguments.length === 0) {
+	      return this.value;
+	    }
+	    this.value = value;
+	    this._onLocaleChange();
 	  };
 
-	  return BackboneRelational;
+	  LocalizedObservable.prototype._onLocaleChange = function() {
+	    var value;
+	    value = this.read(ko.utils.unwrapObservable(this.value));
+	    this.vo(value);
+	    if (this.__kb._onChange) {
+	      return this.__kb._onChange(value);
+	    }
+	  };
+
+	  return LocalizedObservable;
 
 	})();
 
+	kb.localizedObservable = function(value, options, view_model) {
+	  return new kb.LocalizedObservable(value, options, view_model);
+	};
+
+	kb.observableLocalized = kb.localizedObservable;
+
 
 /***/ },
-/* 28 */
+/* 29 */
 /***/ function(module, exports, __webpack_require__) {
 
-	/* WEBPACK VAR INJECTION */(function(global) {
+	
 	/*
-	  knockback.js 0.20.5
+	  knockback.js 1.0.0
 	  Copyright (c)  2011-2014 Kevin Malakoff.
 	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
 	  Source: https://github.com/kmalakoff/knockback
 	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
 	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
 	 */
-	var Supermodel, kb, root, _;
-
-	root = typeof window !== "undefined" && window !== null ? window : global;
+	var KEYS_PUBLISH, _, kb, ko, ref;
 
-	_ = (kb = __webpack_require__(6))._;
+	ref = kb = __webpack_require__(2), _ = ref._, ko = ref.ko;
 
-	Supermodel = null;
+	KEYS_PUBLISH = ['destroy'];
 
-	module.exports = Supermodel = (function() {
-	  function Supermodel() {}
+	module.exports = kb.TriggeredObservable = (function() {
+	  function TriggeredObservable(emitter, event_selector1) {
+	    var observable;
+	    this.event_selector = event_selector1;
+	    emitter || kb._throwMissing(this, 'emitter');
+	    this.event_selector || kb._throwMissing(this, 'event_selector');
+	    this.vo = ko.observable();
+	    observable = kb.utils.wrappedObservable(this, ko.computed((function(_this) {
+	      return function() {
+	        return _this.vo();
+	      };
+	    })(this)));
+	    kb.publishMethods(observable, this, KEYS_PUBLISH);
+	    kb.utils.wrappedEventWatcher(this, new kb.EventWatcher(emitter, this, {
+	      emitter: _.bind(this.emitter, this),
+	      update: _.bind(this.update, this),
+	      event_selector: this.event_selector
+	    }));
+	    return observable;
+	  }
 
-	  Supermodel.isAvailable = function() {
-	    return !!(Supermodel = root.Supermodel);
+	  TriggeredObservable.prototype.destroy = function() {
+	    return kb.utils.wrappedDestroy(this);
 	  };
 
-	  Supermodel.keys = function(model) {
-	    if (!(model instanceof Supermodel.Model)) {
-	      return null;
+	  TriggeredObservable.prototype.emitter = function(new_emitter) {
+	    if ((arguments.length === 0) || (this.ee === new_emitter)) {
+	      return this.ee;
+	    }
+	    if ((this.ee = new_emitter)) {
+	      return this.update();
 	    }
-	    return _.keys(model.constructor.associations());
 	  };
 
-	  Supermodel.relationType = function(model, key) {
-	    var relation;
-	    if (!(model instanceof Supermodel.Model)) {
-	      return null;
-	    }
-	    if (!(relation = model.constructor.associations()[key])) {
-	      return null;
+	  TriggeredObservable.prototype.update = function() {
+	    if (!this.ee) {
+	      return;
 	    }
-	    if (relation.add) {
-	      return kb.TYPE_COLLECTION;
+	    if (this.vo() !== this.ee) {
+	      return this.vo(this.ee);
 	    } else {
-	      return kb.TYPE_MODEL;
+	      return this.vo.valueHasMutated();
 	    }
 	  };
 
-	  Supermodel.bind = function(model, key, update, path) {
-	    var rel_fn, type;
-	    if (!(type = this.relationType(model, key))) {
-	      return null;
-	    }
-	    rel_fn = function(model, other) {
-	      var previous, relation;
-	      !kb.statistics || kb.statistics.addModelEvent({
-	        name: 'update (supermodel)',
-	        model: model,
-	        key: key,
-	        path: path
-	      });
-	      relation = model.constructor.associations()[key];
-	      previous = model[relation.store];
-	      model[relation.store] = other;
-	      update(other);
-	      return model[relation.store] = previous;
-	    };
-	    if (type === kb.TYPE_MODEL) {
-	      model.bind("associate:" + key, rel_fn);
-	      return function() {
-	        return model.unbind("associate:" + key, rel_fn);
-	      };
-	    }
-	  };
+	  return TriggeredObservable;
 
-	  Supermodel.useFunction = function(model, key) {
-	    return !!this.relationType(model, key);
-	  };
+	})();
 
-	  return Supermodel;
+	kb.triggeredObservable = function(emitter, event_selector) {
+	  return new kb.TriggeredObservable(emitter, event_selector);
+	};
+
+	kb.observableTriggered = kb.triggeredObservable;
 
-	})();
-	
-	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
 
 /***/ },
-/* 29 */
+/* 30 */
 /***/ function(module, exports, __webpack_require__) {
 
 	
 	/*
-	  knockback.js 0.20.5
+	  knockback.js 1.0.0
 	  Copyright (c)  2011-2014 Kevin Malakoff.
 	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
 	  Source: https://github.com/kmalakoff/knockback
 	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
 	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
 	 */
-	var copyProps;
-
-	copyProps = function(dest, source) {
-	  var key, value;
-	  for (key in source) {
-	    value = source[key];
-	    dest[key] = value;
-	  }
-	  return dest;
-	};
+	var $, _, callOrGet, kb, ko, ref;
 
-	// Shared empty constructor function to aid in prototype-chain creation.
-	var ctor = function(){};
+	ref = kb = __webpack_require__(2), _ = ref._, ko = ref.ko, $ = ref.$;
 
-	// Helper function to correctly set up the prototype chain, for subclasses.
-	// Similar to 'goog.inherits', but uses a hash of prototype properties and
-	// class properties to be extended.
-	var inherits = function(parent, protoProps, staticProps) {
-	  var child;
+	__webpack_require__(31);
 
-	  // The constructor function for the new subclass is either defined by you
-	  // (the "constructor" property in your extend definition), or defaulted
-	  // by us to simply call the parent's constructor.
-	  if (protoProps && protoProps.hasOwnProperty('constructor')) {
-	    child = protoProps.constructor;
+	callOrGet = function(value) {
+	  value = ko.utils.unwrapObservable(value);
+	  if (typeof value === 'function') {
+	    return value.apply(null, Array.prototype.slice.call(arguments, 1));
 	  } else {
-	    child = function(){ parent.apply(this, arguments); };
+	    return value;
 	  }
-
-	  // Inherit class (static) properties from parent.
-	  copyProps(child, parent);
-
-	  // Set the prototype chain to inherit from parent, without calling
-	  // parent's constructor function.
-	  ctor.prototype = parent.prototype;
-	  child.prototype = new ctor();
-
-	  // Add prototype properties (instance properties) to the subclass,
-	  // if supplied.
-	  if (protoProps) copyProps(child.prototype, protoProps);
-
-	  // Add static properties to the constructor function, if supplied.
-	  if (staticProps) copyProps(child, staticProps);
-
-	  // Correctly set child's 'prototype.constructor'.
-	  child.prototype.constructor = child;
-
-	  // Set a convenience property in case the parent's prototype is needed later.
-	  child.__super__ = parent.prototype;
-
-	  return child;
-	};
-
-	// The self-propagating extend function that BacLCone classes use.
-	var extend = function (protoProps, classProps) {
-	  var child = inherits(this, protoProps, classProps);
-	  child.extend = this.extend;
-	  return child;
 	};
-	;
-
-	module.exports = extend;
 
+	module.exports = kb.Validation = (function() {
+	  function Validation() {}
 
-/***/ },
-/* 30 */
-/***/ function(module, exports, __webpack_require__) {
+	  return Validation;
 
-	
-	/*
-	  knockback.js 0.20.5
-	  Copyright (c)  2011-2014 Kevin Malakoff.
-	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
-	  Source: https://github.com/kmalakoff/knockback
-	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
-	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
-	 */
-	var wrappedDestroy, _;
+	})();
 
-	_ = __webpack_require__(6)._;
+	kb.valueValidator = function(value, bindings, validation_options) {
+	  if (validation_options == null) {
+	    validation_options = {};
+	  }
+	  (validation_options && !(typeof validation_options === 'function')) || (validation_options = {});
+	  return ko.computed(function() {
+	    var active_index, current_value, disabled, identifier, identifier_index, priorities, results, validator;
+	    results = {
+	      $error_count: 0
+	    };
+	    current_value = ko.utils.unwrapObservable(value);
+	    !('disable' in validation_options) || (disabled = callOrGet(validation_options.disable));
+	    !('enable' in validation_options) || (disabled = !callOrGet(validation_options.enable));
+	    priorities = validation_options.priorities || [];
+	    _.isArray(priorities) || (priorities = [priorities]);
+	    active_index = priorities.length + 1;
+	    for (identifier in bindings) {
+	      validator = bindings[identifier];
+	      results[identifier] = !disabled && callOrGet(validator, current_value);
+	      if (results[identifier]) {
+	        results.$error_count++;
+	        (identifier_index = _.indexOf(priorities, identifier) >= 0) || (identifier_index = priorities.length);
+	        if (results.$active_error && identifier_index < active_index) {
+	          results.$active_error = identifier;
+	          active_index = identifier_index;
+	        } else {
+	          results.$active_error || (results.$active_error = identifier, active_index = identifier_index);
+	        }
+	      }
+	    }
+	    results.$enabled = !disabled;
+	    results.$disable = !!disabled;
+	    results.$valid = results.$error_count === 0;
+	    return results;
+	  });
+	};
 
-	module.exports = wrappedDestroy = function(obj) {
-	  var store_references, __kb;
-	  if (!obj.__kb) {
-	    return;
+	kb.inputValidator = function(view_model, el, validation_options) {
+	  var $input_el, bindings, identifier, input_name, options, ref1, result, type, validator, validators;
+	  if (validation_options == null) {
+	    validation_options = {};
+	  }
+	  (validation_options && !(typeof validation_options === 'function')) || (validation_options = {});
+	  validators = kb.valid;
+	  $input_el = $(el);
+	  if ((input_name = $input_el.attr('name')) && !_.isString(input_name)) {
+	    input_name = null;
 	  }
-	  if (obj.__kb.event_watcher) {
-	    obj.__kb.event_watcher.releaseCallbacks(obj);
+	  if (!(bindings = $input_el.attr('data-bind'))) {
+	    return null;
 	  }
-	  __kb = obj.__kb;
-	  obj.__kb = null;
-	  if (__kb.observable) {
-	    __kb.observable.destroy = __kb.observable.release = null;
-	    wrappedDestroy(__kb.observable);
-	    __kb.observable = null;
+	  options = (new Function("sc", "with(sc[0]) { return { " + bindings + " } }"))([view_model]);
+	  if (!(options && options.value)) {
+	    return null;
 	  }
-	  __kb.factory = null;
-	  if (__kb.event_watcher_is_owned) {
-	    __kb.event_watcher.destroy();
+	  (!options.validation_options) || (_.defaults(options.validation_options, validation_options), validation_options = options.validation_options);
+	  bindings = {};
+	  (!validators[type = $input_el.attr('type')]) || (bindings[type] = validators[type]);
+	  (!$input_el.attr('required')) || (bindings.required = validators.required);
+	  if (options.validations) {
+	    ref1 = options.validations;
+	    for (identifier in ref1) {
+	      validator = ref1[identifier];
+	      bindings[identifier] = validator;
+	    }
 	  }
-	  __kb.event_watcher = null;
-	  if (__kb.store_is_owned) {
-	    __kb.store.destroy();
+	  result = kb.valueValidator(options.value, bindings, validation_options);
+	  (!input_name && !validation_options.no_attach) || (view_model["$" + input_name] = result);
+	  return result;
+	};
+
+	kb.formValidator = function(view_model, el) {
+	  var $root_el, bindings, form_name, i, input_el, len, name, options, ref1, results, validation_options, validator, validators;
+	  results = {};
+	  validators = [];
+	  $root_el = $(el);
+	  if ((form_name = $root_el.attr('name')) && !_.isString(form_name)) {
+	    form_name = null;
 	  }
-	  __kb.store = null;
-	  if (__kb.stores_references) {
-	    while (store_references = __kb.stores_references.pop()) {
-	      if (!store_references.store.__kb_released) {
-	        store_references.store.release(obj);
-	      }
+	  if ((bindings = $root_el.attr('data-bind'))) {
+	    options = (new Function("sc", "with(sc[0]) { return { " + bindings + " } }"))([view_model]);
+	    validation_options = options.validation_options;
+	  }
+	  validation_options || (validation_options = {});
+	  validation_options.no_attach = !!form_name;
+	  ref1 = $root_el.find('input');
+	  for (i = 0, len = ref1.length; i < len; i++) {
+	    input_el = ref1[i];
+	    if (!(name = $(input_el).attr('name'))) {
+	      continue;
+	    }
+	    validator = kb.inputValidator(view_model, input_el, validation_options);
+	    !validator || validators.push(results[name] = validator);
+	  }
+	  results.$error_count = ko.computed(function() {
+	    var error_count, j, len1;
+	    error_count = 0;
+	    for (j = 0, len1 = validators.length; j < len1; j++) {
+	      validator = validators[j];
+	      error_count += validator().$error_count;
+	    }
+	    return error_count;
+	  });
+	  results.$valid = ko.computed(function() {
+	    return results.$error_count() === 0;
+	  });
+	  results.$enabled = ko.computed(function() {
+	    var enabled, j, len1;
+	    enabled = true;
+	    for (j = 0, len1 = validators.length; j < len1; j++) {
+	      validator = validators[j];
+	      enabled &= validator().$enabled;
 	    }
+	    return enabled;
+	  });
+	  results.$disabled = ko.computed(function() {
+	    return !results.$enabled();
+	  });
+	  if (form_name) {
+	    view_model["$" + form_name] = results;
 	  }
+	  return results;
 	};
 
 
@@ -3692,94 +3689,113 @@ return /******/ (function(modules) { // webpackBootstrap
 
 	
 	/*
-	  knockback.js 0.20.5
+	  knockback.js 1.0.0
 	  Copyright (c)  2011-2014 Kevin Malakoff.
 	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
 	  Source: https://github.com/kmalakoff/knockback
 	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
 	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
 	 */
-	var _, _keyArrayToObject, _mergeArray, _mergeObject, _mergeOptions;
+	var $, EMAIL_REGEXP, NUMBER_REGEXP, URL_REGEXP, _, kb, ko, ref;
 
-	_ = __webpack_require__(6)._;
+	ref = kb = __webpack_require__(2), _ = ref._, ko = ref.ko, $ = ref.$;
 
-	_mergeArray = function(result, key, value) {
-	  result[key] || (result[key] = []);
-	  if (!_.isArray(value)) {
-	    value = [value];
+	URL_REGEXP = /^(ftp|http|https):\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?$/;
+
+	EMAIL_REGEXP = /^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,4}$/;
+
+	NUMBER_REGEXP = /^\s*(\-|\+)?(\d+|(\d*(\.\d*)))\s*$/;
+
+	kb.valid = {
+	  required: function(value) {
+	    return !value;
+	  },
+	  url: function(value) {
+	    return !URL_REGEXP.test(value);
+	  },
+	  email: function(value) {
+	    return !EMAIL_REGEXP.test(value);
+	  },
+	  number: function(value) {
+	    return !NUMBER_REGEXP.test(value);
 	  }
-	  result[key] = result[key].length ? _.union(result[key], value) : value;
-	  return result;
 	};
 
-	_mergeObject = function(result, key, value) {
-	  result[key] || (result[key] = {});
-	  return _.extend(result[key], value);
+	kb.hasChangedFn = function(model) {
+	  var attributes, m;
+	  m = null;
+	  attributes = null;
+	  return function() {
+	    var current_model;
+	    if (m !== (current_model = ko.utils.unwrapObservable(model))) {
+	      m = current_model;
+	      attributes = (m ? m.toJSON() : null);
+	      return false;
+	    }
+	    if (!(m && attributes)) {
+	      return false;
+	    }
+	    return !_.isEqual(m.toJSON(), attributes);
+	  };
 	};
 
-	_keyArrayToObject = function(value) {
-	  var item, result, _i, _len;
-	  result = {};
-	  for (_i = 0, _len = value.length; _i < _len; _i++) {
-	    item = value[_i];
-	    result[item] = {
-	      key: item
-	    };
-	  }
-	  return result;
+	kb.minLengthFn = function(length) {
+	  return function(value) {
+	    return !value || value.length < length;
+	  };
 	};
 
-	_mergeOptions = function(result, options) {
-	  var key, value;
-	  if (!options) {
-	    return result;
-	  }
-	  for (key in options) {
-	    value = options[key];
-	    switch (key) {
-	      case 'internals':
-	      case 'requires':
-	      case 'excludes':
-	      case 'statics':
-	        _mergeArray(result, key, value);
-	        break;
-	      case 'keys':
-	        if ((_.isObject(value) && !_.isArray(value)) || (_.isObject(result[key]) && !_.isArray(result[key]))) {
-	          if (!_.isObject(value)) {
-	            value = [value];
-	          }
-	          if (_.isArray(value)) {
-	            value = _keyArrayToObject(value);
-	          }
-	          if (_.isArray(result[key])) {
-	            result[key] = _keyArrayToObject(result[key]);
-	          }
-	          _mergeObject(result, key, value);
-	        } else {
-	          _mergeArray(result, key, value);
-	        }
-	        break;
-	      case 'factories':
-	        if (_.isFunction(value)) {
-	          result[key] = value;
-	        } else {
-	          _mergeObject(result, key, value);
-	        }
-	        break;
-	      case 'static_defaults':
-	        _mergeObject(result, key, value);
-	        break;
-	      case 'options':
-	        break;
-	      default:
-	        result[key] = value;
+	kb.uniqueValueFn = function(model, key, collection) {
+	  return function(value) {
+	    var c, k, m;
+	    m = ko.utils.unwrapObservable(model);
+	    k = ko.utils.unwrapObservable(key);
+	    c = ko.utils.unwrapObservable(collection);
+	    if (!(m && k && c)) {
+	      return false;
 	    }
+	    return !!_.find(c.models, (function(_this) {
+	      return function(test) {
+	        return (test !== m) && test.get(k) === value;
+	      };
+	    })(this));
+	  };
+	};
+
+	kb.untilTrueFn = function(stand_in, fn, model) {
+	  var was_true;
+	  was_true = false;
+	  if (model && ko.isObservable(model)) {
+	    model.subscribe(function() {
+	      return was_true = false;
+	    });
 	  }
-	  return _mergeOptions(result, options.options);
+	  return function(value) {
+	    var f, result;
+	    if (!(f = ko.utils.unwrapObservable(fn))) {
+	      return ko.utils.unwrapObservable(stand_in);
+	    }
+	    was_true |= !!(result = f(ko.utils.unwrapObservable(value)));
+	    return (was_true ? result : ko.utils.unwrapObservable(stand_in));
+	  };
 	};
 
-	module.exports = function(options) {
-	  return _mergeOptions({}, options);
+	kb.untilFalseFn = function(stand_in, fn, model) {
+	  var was_false;
+	  was_false = false;
+	  if (model && ko.isObservable(model)) {
+	    model.subscribe(function() {
+	      return was_false = false;
+	    });
+	  }
+	  return function(value) {
+	    var f, result;
+	    if (!(f = ko.utils.unwrapObservable(fn))) {
+	      return ko.utils.unwrapObservable(stand_in);
+	    }
+	    was_false |= !(result = f(ko.utils.unwrapObservable(value)));
+	    return (was_false ? result : ko.utils.unwrapObservable(stand_in));
+	  };
 	};
 
 
@@ -3789,42 +3805,37 @@ return /******/ (function(modules) { // webpackBootstrap
 
 	
 	/*
-	  knockback.js 0.20.5
+	  knockback.js 1.0.0
 	  Copyright (c)  2011-2014 Kevin Malakoff.
 	  License: MIT (http://www.opensource.org/licenses/mit-license.php)
 	  Source: https://github.com/kmalakoff/knockback
 	  Dependencies: Knockout.js, Backbone.js, and Underscore.js (or LoDash.js).
 	  Optional dependencies: Backbone.ModelRef.js and BackboneORM.
 	 */
-	var unwrapModels, _;
+	var i, kb, key, len, ref;
 
-	_ = __webpack_require__(6)._;
+	module.exports = kb = __webpack_require__(2);
 
-	module.exports = unwrapModels = function(obj) {
-	  var key, result, value;
-	  if (!obj) {
-	    return obj;
-	  }
-	  if (obj.__kb) {
-	    return (obj.__kb.hasOwnProperty('object') ? obj.__kb.object : obj);
-	  }
-	  if (_.isArray(obj)) {
-	    return _.map(obj, function(test) {
-	      return unwrapModels(test);
-	    });
-	  }
-	  if (_.isObject(obj) && (obj.constructor === {}.constructor)) {
-	    result = {};
-	    for (key in obj) {
-	      value = obj[key];
-	      result[key] = unwrapModels(value);
+	kb.configure = __webpack_require__(8);
+
+	kb.modules = {
+	  underscore: kb._,
+	  backbone: kb.Parse || kb.Backbone,
+	  knockout: kb.ko
+	};
+
+	if (typeof window !== "undefined" && window !== null) {
+	  ref = ['_', 'Backbone', 'Parse', 'ko', '$'];
+	  for (i = 0, len = ref.length; i < len; i++) {
+	    key = ref[i];
+	    if (kb[key] && !Object.prototype.hasOwnProperty.call(window, key)) {
+	      window[key] = kb[key];
 	    }
-	    return result;
 	  }
-	  return obj;
-	};
+	}
 
 
 /***/ }
 /******/ ])
 });
+;
\ No newline at end of file
diff --git a/examples/knockback/node_modules/knockback/node_modules/backbone/backbone.js b/examples/knockback/node_modules/knockback/node_modules/backbone/backbone.js
deleted file mode 100644
index 24a550a0ad..0000000000
--- a/examples/knockback/node_modules/knockback/node_modules/backbone/backbone.js
+++ /dev/null
@@ -1,1608 +0,0 @@
-//     Backbone.js 1.1.2
-
-//     (c) 2010-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
-//     Backbone may be freely distributed under the MIT license.
-//     For all details and documentation:
-//     http://backbonejs.org
-
-(function(root, factory) {
-
-  // Set up Backbone appropriately for the environment. Start with AMD.
-  if (typeof define === 'function' && define.amd) {
-    define(['underscore', 'jquery', 'exports'], function(_, $, exports) {
-      // Export global even in AMD case in case this script is loaded with
-      // others that may still expect a global Backbone.
-      root.Backbone = factory(root, exports, _, $);
-    });
-
-  // Next for Node.js or CommonJS. jQuery may not be needed as a module.
-  } else if (typeof exports !== 'undefined') {
-    var _ = require('underscore');
-    factory(root, exports, _);
-
-  // Finally, as a browser global.
-  } else {
-    root.Backbone = factory(root, {}, root._, (root.jQuery || root.Zepto || root.ender || root.$));
-  }
-
-}(this, function(root, Backbone, _, $) {
-
-  // Initial Setup
-  // -------------
-
-  // Save the previous value of the `Backbone` variable, so that it can be
-  // restored later on, if `noConflict` is used.
-  var previousBackbone = root.Backbone;
-
-  // Create local references to array methods we'll want to use later.
-  var array = [];
-  var push = array.push;
-  var slice = array.slice;
-  var splice = array.splice;
-
-  // Current version of the library. Keep in sync with `package.json`.
-  Backbone.VERSION = '1.1.2';
-
-  // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns
-  // the `$` variable.
-  Backbone.$ = $;
-
-  // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable
-  // to its previous owner. Returns a reference to this Backbone object.
-  Backbone.noConflict = function() {
-    root.Backbone = previousBackbone;
-    return this;
-  };
-
-  // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option
-  // will fake `"PATCH"`, `"PUT"` and `"DELETE"` requests via the `_method` parameter and
-  // set a `X-Http-Method-Override` header.
-  Backbone.emulateHTTP = false;
-
-  // Turn on `emulateJSON` to support legacy servers that can't deal with direct
-  // `application/json` requests ... will encode the body as
-  // `application/x-www-form-urlencoded` instead and will send the model in a
-  // form param named `model`.
-  Backbone.emulateJSON = false;
-
-  // Backbone.Events
-  // ---------------
-
-  // A module that can be mixed in to *any object* in order to provide it with
-  // custom events. You may bind with `on` or remove with `off` callback
-  // functions to an event; `trigger`-ing an event fires all callbacks in
-  // succession.
-  //
-  //     var object = {};
-  //     _.extend(object, Backbone.Events);
-  //     object.on('expand', function(){ alert('expanded'); });
-  //     object.trigger('expand');
-  //
-  var Events = Backbone.Events = {
-
-    // Bind an event to a `callback` function. Passing `"all"` will bind
-    // the callback to all events fired.
-    on: function(name, callback, context) {
-      if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;
-      this._events || (this._events = {});
-      var events = this._events[name] || (this._events[name] = []);
-      events.push({callback: callback, context: context, ctx: context || this});
-      return this;
-    },
-
-    // Bind an event to only be triggered a single time. After the first time
-    // the callback is invoked, it will be removed.
-    once: function(name, callback, context) {
-      if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this;
-      var self = this;
-      var once = _.once(function() {
-        self.off(name, once);
-        callback.apply(this, arguments);
-      });
-      once._callback = callback;
-      return this.on(name, once, context);
-    },
-
-    // Remove one or many callbacks. If `context` is null, removes all
-    // callbacks with that function. If `callback` is null, removes all
-    // callbacks for the event. If `name` is null, removes all bound
-    // callbacks for all events.
-    off: function(name, callback, context) {
-      var retain, ev, events, names, i, l, j, k;
-      if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;
-      if (!name && !callback && !context) {
-        this._events = void 0;
-        return this;
-      }
-      names = name ? [name] : _.keys(this._events);
-      for (i = 0, l = names.length; i < l; i++) {
-        name = names[i];
-        if (events = this._events[name]) {
-          this._events[name] = retain = [];
-          if (callback || context) {
-            for (j = 0, k = events.length; j < k; j++) {
-              ev = events[j];
-              if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||
-                  (context && context !== ev.context)) {
-                retain.push(ev);
-              }
-            }
-          }
-          if (!retain.length) delete this._events[name];
-        }
-      }
-
-      return this;
-    },
-
-    // Trigger one or many events, firing all bound callbacks. Callbacks are
-    // passed the same arguments as `trigger` is, apart from the event name
-    // (unless you're listening on `"all"`, which will cause your callback to
-    // receive the true name of the event as the first argument).
-    trigger: function(name) {
-      if (!this._events) return this;
-      var args = slice.call(arguments, 1);
-      if (!eventsApi(this, 'trigger', name, args)) return this;
-      var events = this._events[name];
-      var allEvents = this._events.all;
-      if (events) triggerEvents(events, args);
-      if (allEvents) triggerEvents(allEvents, arguments);
-      return this;
-    },
-
-    // Tell this object to stop listening to either specific events ... or
-    // to every object it's currently listening to.
-    stopListening: function(obj, name, callback) {
-      var listeningTo = this._listeningTo;
-      if (!listeningTo) return this;
-      var remove = !name && !callback;
-      if (!callback && typeof name === 'object') callback = this;
-      if (obj) (listeningTo = {})[obj._listenId] = obj;
-      for (var id in listeningTo) {
-        obj = listeningTo[id];
-        obj.off(name, callback, this);
-        if (remove || _.isEmpty(obj._events)) delete this._listeningTo[id];
-      }
-      return this;
-    }
-
-  };
-
-  // Regular expression used to split event strings.
-  var eventSplitter = /\s+/;
-
-  // Implement fancy features of the Events API such as multiple event
-  // names `"change blur"` and jQuery-style event maps `{change: action}`
-  // in terms of the existing API.
-  var eventsApi = function(obj, action, name, rest) {
-    if (!name) return true;
-
-    // Handle event maps.
-    if (typeof name === 'object') {
-      for (var key in name) {
-        obj[action].apply(obj, [key, name[key]].concat(rest));
-      }
-      return false;
-    }
-
-    // Handle space separated event names.
-    if (eventSplitter.test(name)) {
-      var names = name.split(eventSplitter);
-      for (var i = 0, l = names.length; i < l; i++) {
-        obj[action].apply(obj, [names[i]].concat(rest));
-      }
-      return false;
-    }
-
-    return true;
-  };
-
-  // A difficult-to-believe, but optimized internal dispatch function for
-  // triggering events. Tries to keep the usual cases speedy (most internal
-  // Backbone events have 3 arguments).
-  var triggerEvents = function(events, args) {
-    var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];
-    switch (args.length) {
-      case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;
-      case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;
-      case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;
-      case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;
-      default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); return;
-    }
-  };
-
-  var listenMethods = {listenTo: 'on', listenToOnce: 'once'};
-
-  // Inversion-of-control versions of `on` and `once`. Tell *this* object to
-  // listen to an event in another object ... keeping track of what it's
-  // listening to.
-  _.each(listenMethods, function(implementation, method) {
-    Events[method] = function(obj, name, callback) {
-      var listeningTo = this._listeningTo || (this._listeningTo = {});
-      var id = obj._listenId || (obj._listenId = _.uniqueId('l'));
-      listeningTo[id] = obj;
-      if (!callback && typeof name === 'object') callback = this;
-      obj[implementation](name, callback, this);
-      return this;
-    };
-  });
-
-  // Aliases for backwards compatibility.
-  Events.bind   = Events.on;
-  Events.unbind = Events.off;
-
-  // Allow the `Backbone` object to serve as a global event bus, for folks who
-  // want global "pubsub" in a convenient place.
-  _.extend(Backbone, Events);
-
-  // Backbone.Model
-  // --------------
-
-  // Backbone **Models** are the basic data object in the framework --
-  // frequently representing a row in a table in a database on your server.
-  // A discrete chunk of data and a bunch of useful, related methods for
-  // performing computations and transformations on that data.
-
-  // Create a new model with the specified attributes. A client id (`cid`)
-  // is automatically generated and assigned for you.
-  var Model = Backbone.Model = function(attributes, options) {
-    var attrs = attributes || {};
-    options || (options = {});
-    this.cid = _.uniqueId('c');
-    this.attributes = {};
-    if (options.collection) this.collection = options.collection;
-    if (options.parse) attrs = this.parse(attrs, options) || {};
-    attrs = _.defaults({}, attrs, _.result(this, 'defaults'));
-    this.set(attrs, options);
-    this.changed = {};
-    this.initialize.apply(this, arguments);
-  };
-
-  // Attach all inheritable methods to the Model prototype.
-  _.extend(Model.prototype, Events, {
-
-    // A hash of attributes whose current and previous value differ.
-    changed: null,
-
-    // The value returned during the last failed validation.
-    validationError: null,
-
-    // The default name for the JSON `id` attribute is `"id"`. MongoDB and
-    // CouchDB users may want to set this to `"_id"`.
-    idAttribute: 'id',
-
-    // Initialize is an empty function by default. Override it with your own
-    // initialization logic.
-    initialize: function(){},
-
-    // Return a copy of the model's `attributes` object.
-    toJSON: function(options) {
-      return _.clone(this.attributes);
-    },
-
-    // Proxy `Backbone.sync` by default -- but override this if you need
-    // custom syncing semantics for *this* particular model.
-    sync: function() {
-      return Backbone.sync.apply(this, arguments);
-    },
-
-    // Get the value of an attribute.
-    get: function(attr) {
-      return this.attributes[attr];
-    },
-
-    // Get the HTML-escaped value of an attribute.
-    escape: function(attr) {
-      return _.escape(this.get(attr));
-    },
-
-    // Returns `true` if the attribute contains a value that is not null
-    // or undefined.
-    has: function(attr) {
-      return this.get(attr) != null;
-    },
-
-    // Set a hash of model attributes on the object, firing `"change"`. This is
-    // the core primitive operation of a model, updating the data and notifying
-    // anyone who needs to know about the change in state. The heart of the beast.
-    set: function(key, val, options) {
-      var attr, attrs, unset, changes, silent, changing, prev, current;
-      if (key == null) return this;
-
-      // Handle both `"key", value` and `{key: value}` -style arguments.
-      if (typeof key === 'object') {
-        attrs = key;
-        options = val;
-      } else {
-        (attrs = {})[key] = val;
-      }
-
-      options || (options = {});
-
-      // Run validation.
-      if (!this._validate(attrs, options)) return false;
-
-      // Extract attributes and options.
-      unset           = options.unset;
-      silent          = options.silent;
-      changes         = [];
-      changing        = this._changing;
-      this._changing  = true;
-
-      if (!changing) {
-        this._previousAttributes = _.clone(this.attributes);
-        this.changed = {};
-      }
-      current = this.attributes, prev = this._previousAttributes;
-
-      // Check for changes of `id`.
-      if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];
-
-      // For each `set` attribute, update or delete the current value.
-      for (attr in attrs) {
-        val = attrs[attr];
-        if (!_.isEqual(current[attr], val)) changes.push(attr);
-        if (!_.isEqual(prev[attr], val)) {
-          this.changed[attr] = val;
-        } else {
-          delete this.changed[attr];
-        }
-        unset ? delete current[attr] : current[attr] = val;
-      }
-
-      // Trigger all relevant attribute changes.
-      if (!silent) {
-        if (changes.length) this._pending = options;
-        for (var i = 0, l = changes.length; i < l; i++) {
-          this.trigger('change:' + changes[i], this, current[changes[i]], options);
-        }
-      }
-
-      // You might be wondering why there's a `while` loop here. Changes can
-      // be recursively nested within `"change"` events.
-      if (changing) return this;
-      if (!silent) {
-        while (this._pending) {
-          options = this._pending;
-          this._pending = false;
-          this.trigger('change', this, options);
-        }
-      }
-      this._pending = false;
-      this._changing = false;
-      return this;
-    },
-
-    // Remove an attribute from the model, firing `"change"`. `unset` is a noop
-    // if the attribute doesn't exist.
-    unset: function(attr, options) {
-      return this.set(attr, void 0, _.extend({}, options, {unset: true}));
-    },
-
-    // Clear all attributes on the model, firing `"change"`.
-    clear: function(options) {
-      var attrs = {};
-      for (var key in this.attributes) attrs[key] = void 0;
-      return this.set(attrs, _.extend({}, options, {unset: true}));
-    },
-
-    // Determine if the model has changed since the last `"change"` event.
-    // If you specify an attribute name, determine if that attribute has changed.
-    hasChanged: function(attr) {
-      if (attr == null) return !_.isEmpty(this.changed);
-      return _.has(this.changed, attr);
-    },
-
-    // Return an object containing all the attributes that have changed, or
-    // false if there are no changed attributes. Useful for determining what
-    // parts of a view need to be updated and/or what attributes need to be
-    // persisted to the server. Unset attributes will be set to undefined.
-    // You can also pass an attributes object to diff against the model,
-    // determining if there *would be* a change.
-    changedAttributes: function(diff) {
-      if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;
-      var val, changed = false;
-      var old = this._changing ? this._previousAttributes : this.attributes;
-      for (var attr in diff) {
-        if (_.isEqual(old[attr], (val = diff[attr]))) continue;
-        (changed || (changed = {}))[attr] = val;
-      }
-      return changed;
-    },
-
-    // Get the previous value of an attribute, recorded at the time the last
-    // `"change"` event was fired.
-    previous: function(attr) {
-      if (attr == null || !this._previousAttributes) return null;
-      return this._previousAttributes[attr];
-    },
-
-    // Get all of the attributes of the model at the time of the previous
-    // `"change"` event.
-    previousAttributes: function() {
-      return _.clone(this._previousAttributes);
-    },
-
-    // Fetch the model from the server. If the server's representation of the
-    // model differs from its current attributes, they will be overridden,
-    // triggering a `"change"` event.
-    fetch: function(options) {
-      options = options ? _.clone(options) : {};
-      if (options.parse === void 0) options.parse = true;
-      var model = this;
-      var success = options.success;
-      options.success = function(resp) {
-        if (!model.set(model.parse(resp, options), options)) return false;
-        if (success) success(model, resp, options);
-        model.trigger('sync', model, resp, options);
-      };
-      wrapError(this, options);
-      return this.sync('read', this, options);
-    },
-
-    // Set a hash of model attributes, and sync the model to the server.
-    // If the server returns an attributes hash that differs, the model's
-    // state will be `set` again.
-    save: function(key, val, options) {
-      var attrs, method, xhr, attributes = this.attributes;
-
-      // Handle both `"key", value` and `{key: value}` -style arguments.
-      if (key == null || typeof key === 'object') {
-        attrs = key;
-        options = val;
-      } else {
-        (attrs = {})[key] = val;
-      }
-
-      options = _.extend({validate: true}, options);
-
-      // If we're not waiting and attributes exist, save acts as
-      // `set(attr).save(null, opts)` with validation. Otherwise, check if
-      // the model will be valid when the attributes, if any, are set.
-      if (attrs && !options.wait) {
-        if (!this.set(attrs, options)) return false;
-      } else {
-        if (!this._validate(attrs, options)) return false;
-      }
-
-      // Set temporary attributes if `{wait: true}`.
-      if (attrs && options.wait) {
-        this.attributes = _.extend({}, attributes, attrs);
-      }
-
-      // After a successful server-side save, the client is (optionally)
-      // updated with the server-side state.
-      if (options.parse === void 0) options.parse = true;
-      var model = this;
-      var success = options.success;
-      options.success = function(resp) {
-        // Ensure attributes are restored during synchronous saves.
-        model.attributes = attributes;
-        var serverAttrs = model.parse(resp, options);
-        if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs);
-        if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) {
-          return false;
-        }
-        if (success) success(model, resp, options);
-        model.trigger('sync', model, resp, options);
-      };
-      wrapError(this, options);
-
-      method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');
-      if (method === 'patch') options.attrs = attrs;
-      xhr = this.sync(method, this, options);
-
-      // Restore attributes.
-      if (attrs && options.wait) this.attributes = attributes;
-
-      return xhr;
-    },
-
-    // Destroy this model on the server if it was already persisted.
-    // Optimistically removes the model from its collection, if it has one.
-    // If `wait: true` is passed, waits for the server to respond before removal.
-    destroy: function(options) {
-      options = options ? _.clone(options) : {};
-      var model = this;
-      var success = options.success;
-
-      var destroy = function() {
-        model.trigger('destroy', model, model.collection, options);
-      };
-
-      options.success = function(resp) {
-        if (options.wait || model.isNew()) destroy();
-        if (success) success(model, resp, options);
-        if (!model.isNew()) model.trigger('sync', model, resp, options);
-      };
-
-      if (this.isNew()) {
-        options.success();
-        return false;
-      }
-      wrapError(this, options);
-
-      var xhr = this.sync('delete', this, options);
-      if (!options.wait) destroy();
-      return xhr;
-    },
-
-    // Default URL for the model's representation on the server -- if you're
-    // using Backbone's restful methods, override this to change the endpoint
-    // that will be called.
-    url: function() {
-      var base =
-        _.result(this, 'urlRoot') ||
-        _.result(this.collection, 'url') ||
-        urlError();
-      if (this.isNew()) return base;
-      return base.replace(/([^\/])$/, '$1/') + encodeURIComponent(this.id);
-    },
-
-    // **parse** converts a response into the hash of attributes to be `set` on
-    // the model. The default implementation is just to pass the response along.
-    parse: function(resp, options) {
-      return resp;
-    },
-
-    // Create a new model with identical attributes to this one.
-    clone: function() {
-      return new this.constructor(this.attributes);
-    },
-
-    // A model is new if it has never been saved to the server, and lacks an id.
-    isNew: function() {
-      return !this.has(this.idAttribute);
-    },
-
-    // Check if the model is currently in a valid state.
-    isValid: function(options) {
-      return this._validate({}, _.extend(options || {}, { validate: true }));
-    },
-
-    // Run validation against the next complete set of model attributes,
-    // returning `true` if all is well. Otherwise, fire an `"invalid"` event.
-    _validate: function(attrs, options) {
-      if (!options.validate || !this.validate) return true;
-      attrs = _.extend({}, this.attributes, attrs);
-      var error = this.validationError = this.validate(attrs, options) || null;
-      if (!error) return true;
-      this.trigger('invalid', this, error, _.extend(options, {validationError: error}));
-      return false;
-    }
-
-  });
-
-  // Underscore methods that we want to implement on the Model.
-  var modelMethods = ['keys', 'values', 'pairs', 'invert', 'pick', 'omit'];
-
-  // Mix in each Underscore method as a proxy to `Model#attributes`.
-  _.each(modelMethods, function(method) {
-    Model.prototype[method] = function() {
-      var args = slice.call(arguments);
-      args.unshift(this.attributes);
-      return _[method].apply(_, args);
-    };
-  });
-
-  // Backbone.Collection
-  // -------------------
-
-  // If models tend to represent a single row of data, a Backbone Collection is
-  // more analagous to a table full of data ... or a small slice or page of that
-  // table, or a collection of rows that belong together for a particular reason
-  // -- all of the messages in this particular folder, all of the documents
-  // belonging to this particular author, and so on. Collections maintain
-  // indexes of their models, both in order, and for lookup by `id`.
-
-  // Create a new **Collection**, perhaps to contain a specific type of `model`.
-  // If a `comparator` is specified, the Collection will maintain
-  // its models in sort order, as they're added and removed.
-  var Collection = Backbone.Collection = function(models, options) {
-    options || (options = {});
-    if (options.model) this.model = options.model;
-    if (options.comparator !== void 0) this.comparator = options.comparator;
-    this._reset();
-    this.initialize.apply(this, arguments);
-    if (models) this.reset(models, _.extend({silent: true}, options));
-  };
-
-  // Default options for `Collection#set`.
-  var setOptions = {add: true, remove: true, merge: true};
-  var addOptions = {add: true, remove: false};
-
-  // Define the Collection's inheritable methods.
-  _.extend(Collection.prototype, Events, {
-
-    // The default model for a collection is just a **Backbone.Model**.
-    // This should be overridden in most cases.
-    model: Model,
-
-    // Initialize is an empty function by default. Override it with your own
-    // initialization logic.
-    initialize: function(){},
-
-    // The JSON representation of a Collection is an array of the
-    // models' attributes.
-    toJSON: function(options) {
-      return this.map(function(model){ return model.toJSON(options); });
-    },
-
-    // Proxy `Backbone.sync` by default.
-    sync: function() {
-      return Backbone.sync.apply(this, arguments);
-    },
-
-    // Add a model, or list of models to the set.
-    add: function(models, options) {
-      return this.set(models, _.extend({merge: false}, options, addOptions));
-    },
-
-    // Remove a model, or a list of models from the set.
-    remove: function(models, options) {
-      var singular = !_.isArray(models);
-      models = singular ? [models] : _.clone(models);
-      options || (options = {});
-      var i, l, index, model;
-      for (i = 0, l = models.length; i < l; i++) {
-        model = models[i] = this.get(models[i]);
-        if (!model) continue;
-        delete this._byId[model.id];
-        delete this._byId[model.cid];
-        index = this.indexOf(model);
-        this.models.splice(index, 1);
-        this.length--;
-        if (!options.silent) {
-          options.index = index;
-          model.trigger('remove', model, this, options);
-        }
-        this._removeReference(model, options);
-      }
-      return singular ? models[0] : models;
-    },
-
-    // Update a collection by `set`-ing a new list of models, adding new ones,
-    // removing models that are no longer present, and merging models that
-    // already exist in the collection, as necessary. Similar to **Model#set**,
-    // the core operation for updating the data contained by the collection.
-    set: function(models, options) {
-      options = _.defaults({}, options, setOptions);
-      if (options.parse) models = this.parse(models, options);
-      var singular = !_.isArray(models);
-      models = singular ? (models ? [models] : []) : _.clone(models);
-      var i, l, id, model, attrs, existing, sort;
-      var at = options.at;
-      var targetModel = this.model;
-      var sortable = this.comparator && (at == null) && options.sort !== false;
-      var sortAttr = _.isString(this.comparator) ? this.comparator : null;
-      var toAdd = [], toRemove = [], modelMap = {};
-      var add = options.add, merge = options.merge, remove = options.remove;
-      var order = !sortable && add && remove ? [] : false;
-
-      // Turn bare objects into model references, and prevent invalid models
-      // from being added.
-      for (i = 0, l = models.length; i < l; i++) {
-        attrs = models[i] || {};
-        if (attrs instanceof Model) {
-          id = model = attrs;
-        } else {
-          id = attrs[targetModel.prototype.idAttribute || 'id'];
-        }
-
-        // If a duplicate is found, prevent it from being added and
-        // optionally merge it into the existing model.
-        if (existing = this.get(id)) {
-          if (remove) modelMap[existing.cid] = true;
-          if (merge) {
-            attrs = attrs === model ? model.attributes : attrs;
-            if (options.parse) attrs = existing.parse(attrs, options);
-            existing.set(attrs, options);
-            if (sortable && !sort && existing.hasChanged(sortAttr)) sort = true;
-          }
-          models[i] = existing;
-
-        // If this is a new, valid model, push it to the `toAdd` list.
-        } else if (add) {
-          model = models[i] = this._prepareModel(attrs, options);
-          if (!model) continue;
-          toAdd.push(model);
-          this._addReference(model, options);
-        }
-
-        // Do not add multiple models with the same `id`.
-        model = existing || model;
-        if (order && (model.isNew() || !modelMap[model.id])) order.push(model);
-        modelMap[model.id] = true;
-      }
-
-      // Remove nonexistent models if appropriate.
-      if (remove) {
-        for (i = 0, l = this.length; i < l; ++i) {
-          if (!modelMap[(model = this.models[i]).cid]) toRemove.push(model);
-        }
-        if (toRemove.length) this.remove(toRemove, options);
-      }
-
-      // See if sorting is needed, update `length` and splice in new models.
-      if (toAdd.length || (order && order.length)) {
-        if (sortable) sort = true;
-        this.length += toAdd.length;
-        if (at != null) {
-          for (i = 0, l = toAdd.length; i < l; i++) {
-            this.models.splice(at + i, 0, toAdd[i]);
-          }
-        } else {
-          if (order) this.models.length = 0;
-          var orderedModels = order || toAdd;
-          for (i = 0, l = orderedModels.length; i < l; i++) {
-            this.models.push(orderedModels[i]);
-          }
-        }
-      }
-
-      // Silently sort the collection if appropriate.
-      if (sort) this.sort({silent: true});
-
-      // Unless silenced, it's time to fire all appropriate add/sort events.
-      if (!options.silent) {
-        for (i = 0, l = toAdd.length; i < l; i++) {
-          (model = toAdd[i]).trigger('add', model, this, options);
-        }
-        if (sort || (order && order.length)) this.trigger('sort', this, options);
-      }
-
-      // Return the added (or merged) model (or models).
-      return singular ? models[0] : models;
-    },
-
-    // When you have more items than you want to add or remove individually,
-    // you can reset the entire set with a new list of models, without firing
-    // any granular `add` or `remove` events. Fires `reset` when finished.
-    // Useful for bulk operations and optimizations.
-    reset: function(models, options) {
-      options || (options = {});
-      for (var i = 0, l = this.models.length; i < l; i++) {
-        this._removeReference(this.models[i], options);
-      }
-      options.previousModels = this.models;
-      this._reset();
-      models = this.add(models, _.extend({silent: true}, options));
-      if (!options.silent) this.trigger('reset', this, options);
-      return models;
-    },
-
-    // Add a model to the end of the collection.
-    push: function(model, options) {
-      return this.add(model, _.extend({at: this.length}, options));
-    },
-
-    // Remove a model from the end of the collection.
-    pop: function(options) {
-      var model = this.at(this.length - 1);
-      this.remove(model, options);
-      return model;
-    },
-
-    // Add a model to the beginning of the collection.
-    unshift: function(model, options) {
-      return this.add(model, _.extend({at: 0}, options));
-    },
-
-    // Remove a model from the beginning of the collection.
-    shift: function(options) {
-      var model = this.at(0);
-      this.remove(model, options);
-      return model;
-    },
-
-    // Slice out a sub-array of models from the collection.
-    slice: function() {
-      return slice.apply(this.models, arguments);
-    },
-
-    // Get a model from the set by id.
-    get: function(obj) {
-      if (obj == null) return void 0;
-      return this._byId[obj] || this._byId[obj.id] || this._byId[obj.cid];
-    },
-
-    // Get the model at the given index.
-    at: function(index) {
-      return this.models[index];
-    },
-
-    // Return models with matching attributes. Useful for simple cases of
-    // `filter`.
-    where: function(attrs, first) {
-      if (_.isEmpty(attrs)) return first ? void 0 : [];
-      return this[first ? 'find' : 'filter'](function(model) {
-        for (var key in attrs) {
-          if (attrs[key] !== model.get(key)) return false;
-        }
-        return true;
-      });
-    },
-
-    // Return the first model with matching attributes. Useful for simple cases
-    // of `find`.
-    findWhere: function(attrs) {
-      return this.where(attrs, true);
-    },
-
-    // Force the collection to re-sort itself. You don't need to call this under
-    // normal circumstances, as the set will maintain sort order as each item
-    // is added.
-    sort: function(options) {
-      if (!this.comparator) throw new Error('Cannot sort a set without a comparator');
-      options || (options = {});
-
-      // Run sort based on type of `comparator`.
-      if (_.isString(this.comparator) || this.comparator.length === 1) {
-        this.models = this.sortBy(this.comparator, this);
-      } else {
-        this.models.sort(_.bind(this.comparator, this));
-      }
-
-      if (!options.silent) this.trigger('sort', this, options);
-      return this;
-    },
-
-    // Pluck an attribute from each model in the collection.
-    pluck: function(attr) {
-      return _.invoke(this.models, 'get', attr);
-    },
-
-    // Fetch the default set of models for this collection, resetting the
-    // collection when they arrive. If `reset: true` is passed, the response
-    // data will be passed through the `reset` method instead of `set`.
-    fetch: function(options) {
-      options = options ? _.clone(options) : {};
-      if (options.parse === void 0) options.parse = true;
-      var success = options.success;
-      var collection = this;
-      options.success = function(resp) {
-        var method = options.reset ? 'reset' : 'set';
-        collection[method](resp, options);
-        if (success) success(collection, resp, options);
-        collection.trigger('sync', collection, resp, options);
-      };
-      wrapError(this, options);
-      return this.sync('read', this, options);
-    },
-
-    // Create a new instance of a model in this collection. Add the model to the
-    // collection immediately, unless `wait: true` is passed, in which case we
-    // wait for the server to agree.
-    create: function(model, options) {
-      options = options ? _.clone(options) : {};
-      if (!(model = this._prepareModel(model, options))) return false;
-      if (!options.wait) this.add(model, options);
-      var collection = this;
-      var success = options.success;
-      options.success = function(model, resp) {
-        if (options.wait) collection.add(model, options);
-        if (success) success(model, resp, options);
-      };
-      model.save(null, options);
-      return model;
-    },
-
-    // **parse** converts a response into a list of models to be added to the
-    // collection. The default implementation is just to pass it through.
-    parse: function(resp, options) {
-      return resp;
-    },
-
-    // Create a new collection with an identical list of models as this one.
-    clone: function() {
-      return new this.constructor(this.models);
-    },
-
-    // Private method to reset all internal state. Called when the collection
-    // is first initialized or reset.
-    _reset: function() {
-      this.length = 0;
-      this.models = [];
-      this._byId  = {};
-    },
-
-    // Prepare a hash of attributes (or other model) to be added to this
-    // collection.
-    _prepareModel: function(attrs, options) {
-      if (attrs instanceof Model) return attrs;
-      options = options ? _.clone(options) : {};
-      options.collection = this;
-      var model = new this.model(attrs, options);
-      if (!model.validationError) return model;
-      this.trigger('invalid', this, model.validationError, options);
-      return false;
-    },
-
-    // Internal method to create a model's ties to a collection.
-    _addReference: function(model, options) {
-      this._byId[model.cid] = model;
-      if (model.id != null) this._byId[model.id] = model;
-      if (!model.collection) model.collection = this;
-      model.on('all', this._onModelEvent, this);
-    },
-
-    // Internal method to sever a model's ties to a collection.
-    _removeReference: function(model, options) {
-      if (this === model.collection) delete model.collection;
-      model.off('all', this._onModelEvent, this);
-    },
-
-    // Internal method called every time a model in the set fires an event.
-    // Sets need to update their indexes when models change ids. All other
-    // events simply proxy through. "add" and "remove" events that originate
-    // in other collections are ignored.
-    _onModelEvent: function(event, model, collection, options) {
-      if ((event === 'add' || event === 'remove') && collection !== this) return;
-      if (event === 'destroy') this.remove(model, options);
-      if (model && event === 'change:' + model.idAttribute) {
-        delete this._byId[model.previous(model.idAttribute)];
-        if (model.id != null) this._byId[model.id] = model;
-      }
-      this.trigger.apply(this, arguments);
-    }
-
-  });
-
-  // Underscore methods that we want to implement on the Collection.
-  // 90% of the core usefulness of Backbone Collections is actually implemented
-  // right here:
-  var methods = ['forEach', 'each', 'map', 'collect', 'reduce', 'foldl',
-    'inject', 'reduceRight', 'foldr', 'find', 'detect', 'filter', 'select',
-    'reject', 'every', 'all', 'some', 'any', 'include', 'contains', 'invoke',
-    'max', 'min', 'toArray', 'size', 'first', 'head', 'take', 'initial', 'rest',
-    'tail', 'drop', 'last', 'without', 'difference', 'indexOf', 'shuffle',
-    'lastIndexOf', 'isEmpty', 'chain', 'sample'];
-
-  // Mix in each Underscore method as a proxy to `Collection#models`.
-  _.each(methods, function(method) {
-    Collection.prototype[method] = function() {
-      var args = slice.call(arguments);
-      args.unshift(this.models);
-      return _[method].apply(_, args);
-    };
-  });
-
-  // Underscore methods that take a property name as an argument.
-  var attributeMethods = ['groupBy', 'countBy', 'sortBy', 'indexBy'];
-
-  // Use attributes instead of properties.
-  _.each(attributeMethods, function(method) {
-    Collection.prototype[method] = function(value, context) {
-      var iterator = _.isFunction(value) ? value : function(model) {
-        return model.get(value);
-      };
-      return _[method](this.models, iterator, context);
-    };
-  });
-
-  // Backbone.View
-  // -------------
-
-  // Backbone Views are almost more convention than they are actual code. A View
-  // is simply a JavaScript object that represents a logical chunk of UI in the
-  // DOM. This might be a single item, an entire list, a sidebar or panel, or
-  // even the surrounding frame which wraps your whole app. Defining a chunk of
-  // UI as a **View** allows you to define your DOM events declaratively, without
-  // having to worry about render order ... and makes it easy for the view to
-  // react to specific changes in the state of your models.
-
-  // Creating a Backbone.View creates its initial element outside of the DOM,
-  // if an existing element is not provided...
-  var View = Backbone.View = function(options) {
-    this.cid = _.uniqueId('view');
-    options || (options = {});
-    _.extend(this, _.pick(options, viewOptions));
-    this._ensureElement();
-    this.initialize.apply(this, arguments);
-    this.delegateEvents();
-  };
-
-  // Cached regex to split keys for `delegate`.
-  var delegateEventSplitter = /^(\S+)\s*(.*)$/;
-
-  // List of view options to be merged as properties.
-  var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];
-
-  // Set up all inheritable **Backbone.View** properties and methods.
-  _.extend(View.prototype, Events, {
-
-    // The default `tagName` of a View's element is `"div"`.
-    tagName: 'div',
-
-    // jQuery delegate for element lookup, scoped to DOM elements within the
-    // current view. This should be preferred to global lookups where possible.
-    $: function(selector) {
-      return this.$el.find(selector);
-    },
-
-    // Initialize is an empty function by default. Override it with your own
-    // initialization logic.
-    initialize: function(){},
-
-    // **render** is the core function that your view should override, in order
-    // to populate its element (`this.el`), with the appropriate HTML. The
-    // convention is for **render** to always return `this`.
-    render: function() {
-      return this;
-    },
-
-    // Remove this view by taking the element out of the DOM, and removing any
-    // applicable Backbone.Events listeners.
-    remove: function() {
-      this.$el.remove();
-      this.stopListening();
-      return this;
-    },
-
-    // Change the view's element (`this.el` property), including event
-    // re-delegation.
-    setElement: function(element, delegate) {
-      if (this.$el) this.undelegateEvents();
-      this.$el = element instanceof Backbone.$ ? element : Backbone.$(element);
-      this.el = this.$el[0];
-      if (delegate !== false) this.delegateEvents();
-      return this;
-    },
-
-    // Set callbacks, where `this.events` is a hash of
-    //
-    // *{"event selector": "callback"}*
-    //
-    //     {
-    //       'mousedown .title':  'edit',
-    //       'click .button':     'save',
-    //       'click .open':       function(e) { ... }
-    //     }
-    //
-    // pairs. Callbacks will be bound to the view, with `this` set properly.
-    // Uses event delegation for efficiency.
-    // Omitting the selector binds the event to `this.el`.
-    // This only works for delegate-able events: not `focus`, `blur`, and
-    // not `change`, `submit`, and `reset` in Internet Explorer.
-    delegateEvents: function(events) {
-      if (!(events || (events = _.result(this, 'events')))) return this;
-      this.undelegateEvents();
-      for (var key in events) {
-        var method = events[key];
-        if (!_.isFunction(method)) method = this[events[key]];
-        if (!method) continue;
-
-        var match = key.match(delegateEventSplitter);
-        var eventName = match[1], selector = match[2];
-        method = _.bind(method, this);
-        eventName += '.delegateEvents' + this.cid;
-        if (selector === '') {
-          this.$el.on(eventName, method);
-        } else {
-          this.$el.on(eventName, selector, method);
-        }
-      }
-      return this;
-    },
-
-    // Clears all callbacks previously bound to the view with `delegateEvents`.
-    // You usually don't need to use this, but may wish to if you have multiple
-    // Backbone views attached to the same DOM element.
-    undelegateEvents: function() {
-      this.$el.off('.delegateEvents' + this.cid);
-      return this;
-    },
-
-    // Ensure that the View has a DOM element to render into.
-    // If `this.el` is a string, pass it through `$()`, take the first
-    // matching element, and re-assign it to `el`. Otherwise, create
-    // an element from the `id`, `className` and `tagName` properties.
-    _ensureElement: function() {
-      if (!this.el) {
-        var attrs = _.extend({}, _.result(this, 'attributes'));
-        if (this.id) attrs.id = _.result(this, 'id');
-        if (this.className) attrs['class'] = _.result(this, 'className');
-        var $el = Backbone.$('<' + _.result(this, 'tagName') + '>').attr(attrs);
-        this.setElement($el, false);
-      } else {
-        this.setElement(_.result(this, 'el'), false);
-      }
-    }
-
-  });
-
-  // Backbone.sync
-  // -------------
-
-  // Override this function to change the manner in which Backbone persists
-  // models to the server. You will be passed the type of request, and the
-  // model in question. By default, makes a RESTful Ajax request
-  // to the model's `url()`. Some possible customizations could be:
-  //
-  // * Use `setTimeout` to batch rapid-fire updates into a single request.
-  // * Send up the models as XML instead of JSON.
-  // * Persist models via WebSockets instead of Ajax.
-  //
-  // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests
-  // as `POST`, with a `_method` parameter containing the true HTTP method,
-  // as well as all requests with the body as `application/x-www-form-urlencoded`
-  // instead of `application/json` with the model in a param named `model`.
-  // Useful when interfacing with server-side languages like **PHP** that make
-  // it difficult to read the body of `PUT` requests.
-  Backbone.sync = function(method, model, options) {
-    var type = methodMap[method];
-
-    // Default options, unless specified.
-    _.defaults(options || (options = {}), {
-      emulateHTTP: Backbone.emulateHTTP,
-      emulateJSON: Backbone.emulateJSON
-    });
-
-    // Default JSON-request options.
-    var params = {type: type, dataType: 'json'};
-
-    // Ensure that we have a URL.
-    if (!options.url) {
-      params.url = _.result(model, 'url') || urlError();
-    }
-
-    // Ensure that we have the appropriate request data.
-    if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {
-      params.contentType = 'application/json';
-      params.data = JSON.stringify(options.attrs || model.toJSON(options));
-    }
-
-    // For older servers, emulate JSON by encoding the request into an HTML-form.
-    if (options.emulateJSON) {
-      params.contentType = 'application/x-www-form-urlencoded';
-      params.data = params.data ? {model: params.data} : {};
-    }
-
-    // For older servers, emulate HTTP by mimicking the HTTP method with `_method`
-    // And an `X-HTTP-Method-Override` header.
-    if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {
-      params.type = 'POST';
-      if (options.emulateJSON) params.data._method = type;
-      var beforeSend = options.beforeSend;
-      options.beforeSend = function(xhr) {
-        xhr.setRequestHeader('X-HTTP-Method-Override', type);
-        if (beforeSend) return beforeSend.apply(this, arguments);
-      };
-    }
-
-    // Don't process data on a non-GET request.
-    if (params.type !== 'GET' && !options.emulateJSON) {
-      params.processData = false;
-    }
-
-    // If we're sending a `PATCH` request, and we're in an old Internet Explorer
-    // that still has ActiveX enabled by default, override jQuery to use that
-    // for XHR instead. Remove this line when jQuery supports `PATCH` on IE8.
-    if (params.type === 'PATCH' && noXhrPatch) {
-      params.xhr = function() {
-        return new ActiveXObject("Microsoft.XMLHTTP");
-      };
-    }
-
-    // Make the request, allowing the user to override any Ajax options.
-    var xhr = options.xhr = Backbone.ajax(_.extend(params, options));
-    model.trigger('request', model, xhr, options);
-    return xhr;
-  };
-
-  var noXhrPatch =
-    typeof window !== 'undefined' && !!window.ActiveXObject &&
-      !(window.XMLHttpRequest && (new XMLHttpRequest).dispatchEvent);
-
-  // Map from CRUD to HTTP for our default `Backbone.sync` implementation.
-  var methodMap = {
-    'create': 'POST',
-    'update': 'PUT',
-    'patch':  'PATCH',
-    'delete': 'DELETE',
-    'read':   'GET'
-  };
-
-  // Set the default implementation of `Backbone.ajax` to proxy through to `$`.
-  // Override this if you'd like to use a different library.
-  Backbone.ajax = function() {
-    return Backbone.$.ajax.apply(Backbone.$, arguments);
-  };
-
-  // Backbone.Router
-  // ---------------
-
-  // Routers map faux-URLs to actions, and fire events when routes are
-  // matched. Creating a new one sets its `routes` hash, if not set statically.
-  var Router = Backbone.Router = function(options) {
-    options || (options = {});
-    if (options.routes) this.routes = options.routes;
-    this._bindRoutes();
-    this.initialize.apply(this, arguments);
-  };
-
-  // Cached regular expressions for matching named param parts and splatted
-  // parts of route strings.
-  var optionalParam = /\((.*?)\)/g;
-  var namedParam    = /(\(\?)?:\w+/g;
-  var splatParam    = /\*\w+/g;
-  var escapeRegExp  = /[\-{}\[\]+?.,\\\^$|#\s]/g;
-
-  // Set up all inheritable **Backbone.Router** properties and methods.
-  _.extend(Router.prototype, Events, {
-
-    // Initialize is an empty function by default. Override it with your own
-    // initialization logic.
-    initialize: function(){},
-
-    // Manually bind a single named route to a callback. For example:
-    //
-    //     this.route('search/:query/p:num', 'search', function(query, num) {
-    //       ...
-    //     });
-    //
-    route: function(route, name, callback) {
-      if (!_.isRegExp(route)) route = this._routeToRegExp(route);
-      if (_.isFunction(name)) {
-        callback = name;
-        name = '';
-      }
-      if (!callback) callback = this[name];
-      var router = this;
-      Backbone.history.route(route, function(fragment) {
-        var args = router._extractParameters(route, fragment);
-        router.execute(callback, args);
-        router.trigger.apply(router, ['route:' + name].concat(args));
-        router.trigger('route', name, args);
-        Backbone.history.trigger('route', router, name, args);
-      });
-      return this;
-    },
-
-    // Execute a route handler with the provided parameters.  This is an
-    // excellent place to do pre-route setup or post-route cleanup.
-    execute: function(callback, args) {
-      if (callback) callback.apply(this, args);
-    },
-
-    // Simple proxy to `Backbone.history` to save a fragment into the history.
-    navigate: function(fragment, options) {
-      Backbone.history.navigate(fragment, options);
-      return this;
-    },
-
-    // Bind all defined routes to `Backbone.history`. We have to reverse the
-    // order of the routes here to support behavior where the most general
-    // routes can be defined at the bottom of the route map.
-    _bindRoutes: function() {
-      if (!this.routes) return;
-      this.routes = _.result(this, 'routes');
-      var route, routes = _.keys(this.routes);
-      while ((route = routes.pop()) != null) {
-        this.route(route, this.routes[route]);
-      }
-    },
-
-    // Convert a route string into a regular expression, suitable for matching
-    // against the current location hash.
-    _routeToRegExp: function(route) {
-      route = route.replace(escapeRegExp, '\\$&')
-                   .replace(optionalParam, '(?:$1)?')
-                   .replace(namedParam, function(match, optional) {
-                     return optional ? match : '([^/?]+)';
-                   })
-                   .replace(splatParam, '([^?]*?)');
-      return new RegExp('^' + route + '(?:\\?([\\s\\S]*))?$');
-    },
-
-    // Given a route, and a URL fragment that it matches, return the array of
-    // extracted decoded parameters. Empty or unmatched parameters will be
-    // treated as `null` to normalize cross-browser behavior.
-    _extractParameters: function(route, fragment) {
-      var params = route.exec(fragment).slice(1);
-      return _.map(params, function(param, i) {
-        // Don't decode the search params.
-        if (i === params.length - 1) return param || null;
-        return param ? decodeURIComponent(param) : null;
-      });
-    }
-
-  });
-
-  // Backbone.History
-  // ----------------
-
-  // Handles cross-browser history management, based on either
-  // [pushState](http://diveintohtml5.info/history.html) and real URLs, or
-  // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)
-  // and URL fragments. If the browser supports neither (old IE, natch),
-  // falls back to polling.
-  var History = Backbone.History = function() {
-    this.handlers = [];
-    _.bindAll(this, 'checkUrl');
-
-    // Ensure that `History` can be used outside of the browser.
-    if (typeof window !== 'undefined') {
-      this.location = window.location;
-      this.history = window.history;
-    }
-  };
-
-  // Cached regex for stripping a leading hash/slash and trailing space.
-  var routeStripper = /^[#\/]|\s+$/g;
-
-  // Cached regex for stripping leading and trailing slashes.
-  var rootStripper = /^\/+|\/+$/g;
-
-  // Cached regex for detecting MSIE.
-  var isExplorer = /msie [\w.]+/;
-
-  // Cached regex for removing a trailing slash.
-  var trailingSlash = /\/$/;
-
-  // Cached regex for stripping urls of hash.
-  var pathStripper = /#.*$/;
-
-  // Has the history handling already been started?
-  History.started = false;
-
-  // Set up all inheritable **Backbone.History** properties and methods.
-  _.extend(History.prototype, Events, {
-
-    // The default interval to poll for hash changes, if necessary, is
-    // twenty times a second.
-    interval: 50,
-
-    // Are we at the app root?
-    atRoot: function() {
-      return this.location.pathname.replace(/[^\/]$/, '$&/') === this.root;
-    },
-
-    // Gets the true hash value. Cannot use location.hash directly due to bug
-    // in Firefox where location.hash will always be decoded.
-    getHash: function(window) {
-      var match = (window || this).location.href.match(/#(.*)$/);
-      return match ? match[1] : '';
-    },
-
-    // Get the cross-browser normalized URL fragment, either from the URL,
-    // the hash, or the override.
-    getFragment: function(fragment, forcePushState) {
-      if (fragment == null) {
-        if (this._hasPushState || !this._wantsHashChange || forcePushState) {
-          fragment = decodeURI(this.location.pathname + this.location.search);
-          var root = this.root.replace(trailingSlash, '');
-          if (!fragment.indexOf(root)) fragment = fragment.slice(root.length);
-        } else {
-          fragment = this.getHash();
-        }
-      }
-      return fragment.replace(routeStripper, '');
-    },
-
-    // Start the hash change handling, returning `true` if the current URL matches
-    // an existing route, and `false` otherwise.
-    start: function(options) {
-      if (History.started) throw new Error("Backbone.history has already been started");
-      History.started = true;
-
-      // Figure out the initial configuration. Do we need an iframe?
-      // Is pushState desired ... is it available?
-      this.options          = _.extend({root: '/'}, this.options, options);
-      this.root             = this.options.root;
-      this._wantsHashChange = this.options.hashChange !== false;
-      this._wantsPushState  = !!this.options.pushState;
-      this._hasPushState    = !!(this.options.pushState && this.history && this.history.pushState);
-      var fragment          = this.getFragment();
-      var docMode           = document.documentMode;
-      var oldIE             = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7));
-
-      // Normalize root to always include a leading and trailing slash.
-      this.root = ('/' + this.root + '/').replace(rootStripper, '/');
-
-      if (oldIE && this._wantsHashChange) {
-        var frame = Backbone.$('<iframe src="javascript:0" tabindex="-1">');
-        this.iframe = frame.hide().appendTo('body')[0].contentWindow;
-        this.navigate(fragment);
-      }
-
-      // Depending on whether we're using pushState or hashes, and whether
-      // 'onhashchange' is supported, determine how we check the URL state.
-      if (this._hasPushState) {
-        Backbone.$(window).on('popstate', this.checkUrl);
-      } else if (this._wantsHashChange && ('onhashchange' in window) && !oldIE) {
-        Backbone.$(window).on('hashchange', this.checkUrl);
-      } else if (this._wantsHashChange) {
-        this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
-      }
-
-      // Determine if we need to change the base url, for a pushState link
-      // opened by a non-pushState browser.
-      this.fragment = fragment;
-      var loc = this.location;
-
-      // Transition from hashChange to pushState or vice versa if both are
-      // requested.
-      if (this._wantsHashChange && this._wantsPushState) {
-
-        // If we've started off with a route from a `pushState`-enabled
-        // browser, but we're currently in a browser that doesn't support it...
-        if (!this._hasPushState && !this.atRoot()) {
-          this.fragment = this.getFragment(null, true);
-          this.location.replace(this.root + '#' + this.fragment);
-          // Return immediately as browser will do redirect to new url
-          return true;
-
-        // Or if we've started out with a hash-based route, but we're currently
-        // in a browser where it could be `pushState`-based instead...
-        } else if (this._hasPushState && this.atRoot() && loc.hash) {
-          this.fragment = this.getHash().replace(routeStripper, '');
-          this.history.replaceState({}, document.title, this.root + this.fragment);
-        }
-
-      }
-
-      if (!this.options.silent) return this.loadUrl();
-    },
-
-    // Disable Backbone.history, perhaps temporarily. Not useful in a real app,
-    // but possibly useful for unit testing Routers.
-    stop: function() {
-      Backbone.$(window).off('popstate', this.checkUrl).off('hashchange', this.checkUrl);
-      if (this._checkUrlInterval) clearInterval(this._checkUrlInterval);
-      History.started = false;
-    },
-
-    // Add a route to be tested when the fragment changes. Routes added later
-    // may override previous routes.
-    route: function(route, callback) {
-      this.handlers.unshift({route: route, callback: callback});
-    },
-
-    // Checks the current URL to see if it has changed, and if it has,
-    // calls `loadUrl`, normalizing across the hidden iframe.
-    checkUrl: function(e) {
-      var current = this.getFragment();
-      if (current === this.fragment && this.iframe) {
-        current = this.getFragment(this.getHash(this.iframe));
-      }
-      if (current === this.fragment) return false;
-      if (this.iframe) this.navigate(current);
-      this.loadUrl();
-    },
-
-    // Attempt to load the current URL fragment. If a route succeeds with a
-    // match, returns `true`. If no defined routes matches the fragment,
-    // returns `false`.
-    loadUrl: function(fragment) {
-      fragment = this.fragment = this.getFragment(fragment);
-      return _.any(this.handlers, function(handler) {
-        if (handler.route.test(fragment)) {
-          handler.callback(fragment);
-          return true;
-        }
-      });
-    },
-
-    // Save a fragment into the hash history, or replace the URL state if the
-    // 'replace' option is passed. You are responsible for properly URL-encoding
-    // the fragment in advance.
-    //
-    // The options object can contain `trigger: true` if you wish to have the
-    // route callback be fired (not usually desirable), or `replace: true`, if
-    // you wish to modify the current URL without adding an entry to the history.
-    navigate: function(fragment, options) {
-      if (!History.started) return false;
-      if (!options || options === true) options = {trigger: !!options};
-
-      var url = this.root + (fragment = this.getFragment(fragment || ''));
-
-      // Strip the hash for matching.
-      fragment = fragment.replace(pathStripper, '');
-
-      if (this.fragment === fragment) return;
-      this.fragment = fragment;
-
-      // Don't include a trailing slash on the root.
-      if (fragment === '' && url !== '/') url = url.slice(0, -1);
-
-      // If pushState is available, we use it to set the fragment as a real URL.
-      if (this._hasPushState) {
-        this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);
-
-      // If hash changes haven't been explicitly disabled, update the hash
-      // fragment to store history.
-      } else if (this._wantsHashChange) {
-        this._updateHash(this.location, fragment, options.replace);
-        if (this.iframe && (fragment !== this.getFragment(this.getHash(this.iframe)))) {
-          // Opening and closing the iframe tricks IE7 and earlier to push a
-          // history entry on hash-tag change.  When replace is true, we don't
-          // want this.
-          if(!options.replace) this.iframe.document.open().close();
-          this._updateHash(this.iframe.location, fragment, options.replace);
-        }
-
-      // If you've told us that you explicitly don't want fallback hashchange-
-      // based history, then `navigate` becomes a page refresh.
-      } else {
-        return this.location.assign(url);
-      }
-      if (options.trigger) return this.loadUrl(fragment);
-    },
-
-    // Update the hash location, either replacing the current entry, or adding
-    // a new one to the browser history.
-    _updateHash: function(location, fragment, replace) {
-      if (replace) {
-        var href = location.href.replace(/(javascript:|#).*$/, '');
-        location.replace(href + '#' + fragment);
-      } else {
-        // Some browsers require that `hash` contains a leading #.
-        location.hash = '#' + fragment;
-      }
-    }
-
-  });
-
-  // Create the default Backbone.history.
-  Backbone.history = new History;
-
-  // Helpers
-  // -------
-
-  // Helper function to correctly set up the prototype chain, for subclasses.
-  // Similar to `goog.inherits`, but uses a hash of prototype properties and
-  // class properties to be extended.
-  var extend = function(protoProps, staticProps) {
-    var parent = this;
-    var child;
-
-    // The constructor function for the new subclass is either defined by you
-    // (the "constructor" property in your `extend` definition), or defaulted
-    // by us to simply call the parent's constructor.
-    if (protoProps && _.has(protoProps, 'constructor')) {
-      child = protoProps.constructor;
-    } else {
-      child = function(){ return parent.apply(this, arguments); };
-    }
-
-    // Add static properties to the constructor function, if supplied.
-    _.extend(child, parent, staticProps);
-
-    // Set the prototype chain to inherit from `parent`, without calling
-    // `parent`'s constructor function.
-    var Surrogate = function(){ this.constructor = child; };
-    Surrogate.prototype = parent.prototype;
-    child.prototype = new Surrogate;
-
-    // Add prototype properties (instance properties) to the subclass,
-    // if supplied.
-    if (protoProps) _.extend(child.prototype, protoProps);
-
-    // Set a convenience property in case the parent's prototype is needed
-    // later.
-    child.__super__ = parent.prototype;
-
-    return child;
-  };
-
-  // Set up inheritance for the model, collection, router, view and history.
-  Model.extend = Collection.extend = Router.extend = View.extend = History.extend = extend;
-
-  // Throw an error when a URL is needed, and none is supplied.
-  var urlError = function() {
-    throw new Error('A "url" property or function must be specified');
-  };
-
-  // Wrap an optional error callback with a fallback error event.
-  var wrapError = function(model, options) {
-    var error = options.error;
-    options.error = function(resp) {
-      if (error) error(model, resp, options);
-      model.trigger('error', model, resp, options);
-    };
-  };
-
-  return Backbone;
-
-}));
diff --git a/examples/knockback/node_modules/knockback/node_modules/underscore/underscore.js b/examples/knockback/node_modules/knockback/node_modules/underscore/underscore.js
deleted file mode 100644
index b4f49a0204..0000000000
--- a/examples/knockback/node_modules/knockback/node_modules/underscore/underscore.js
+++ /dev/null
@@ -1,1415 +0,0 @@
-//     Underscore.js 1.7.0
-//     http://underscorejs.org
-//     (c) 2009-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
-//     Underscore may be freely distributed under the MIT license.
-
-(function() {
-
-  // Baseline setup
-  // --------------
-
-  // Establish the root object, `window` in the browser, or `exports` on the server.
-  var root = this;
-
-  // Save the previous value of the `_` variable.
-  var previousUnderscore = root._;
-
-  // Save bytes in the minified (but not gzipped) version:
-  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
-
-  // Create quick reference variables for speed access to core prototypes.
-  var
-    push             = ArrayProto.push,
-    slice            = ArrayProto.slice,
-    concat           = ArrayProto.concat,
-    toString         = ObjProto.toString,
-    hasOwnProperty   = ObjProto.hasOwnProperty;
-
-  // All **ECMAScript 5** native function implementations that we hope to use
-  // are declared here.
-  var
-    nativeIsArray      = Array.isArray,
-    nativeKeys         = Object.keys,
-    nativeBind         = FuncProto.bind;
-
-  // Create a safe reference to the Underscore object for use below.
-  var _ = function(obj) {
-    if (obj instanceof _) return obj;
-    if (!(this instanceof _)) return new _(obj);
-    this._wrapped = obj;
-  };
-
-  // Export the Underscore object for **Node.js**, with
-  // backwards-compatibility for the old `require()` API. If we're in
-  // the browser, add `_` as a global object.
-  if (typeof exports !== 'undefined') {
-    if (typeof module !== 'undefined' && module.exports) {
-      exports = module.exports = _;
-    }
-    exports._ = _;
-  } else {
-    root._ = _;
-  }
-
-  // Current version.
-  _.VERSION = '1.7.0';
-
-  // Internal function that returns an efficient (for current engines) version
-  // of the passed-in callback, to be repeatedly applied in other Underscore
-  // functions.
-  var createCallback = function(func, context, argCount) {
-    if (context === void 0) return func;
-    switch (argCount == null ? 3 : argCount) {
-      case 1: return function(value) {
-        return func.call(context, value);
-      };
-      case 2: return function(value, other) {
-        return func.call(context, value, other);
-      };
-      case 3: return function(value, index, collection) {
-        return func.call(context, value, index, collection);
-      };
-      case 4: return function(accumulator, value, index, collection) {
-        return func.call(context, accumulator, value, index, collection);
-      };
-    }
-    return function() {
-      return func.apply(context, arguments);
-    };
-  };
-
-  // A mostly-internal function to generate callbacks that can be applied
-  // to each element in a collection, returning the desired result — either
-  // identity, an arbitrary callback, a property matcher, or a property accessor.
-  _.iteratee = function(value, context, argCount) {
-    if (value == null) return _.identity;
-    if (_.isFunction(value)) return createCallback(value, context, argCount);
-    if (_.isObject(value)) return _.matches(value);
-    return _.property(value);
-  };
-
-  // Collection Functions
-  // --------------------
-
-  // The cornerstone, an `each` implementation, aka `forEach`.
-  // Handles raw objects in addition to array-likes. Treats all
-  // sparse array-likes as if they were dense.
-  _.each = _.forEach = function(obj, iteratee, context) {
-    if (obj == null) return obj;
-    iteratee = createCallback(iteratee, context);
-    var i, length = obj.length;
-    if (length === +length) {
-      for (i = 0; i < length; i++) {
-        iteratee(obj[i], i, obj);
-      }
-    } else {
-      var keys = _.keys(obj);
-      for (i = 0, length = keys.length; i < length; i++) {
-        iteratee(obj[keys[i]], keys[i], obj);
-      }
-    }
-    return obj;
-  };
-
-  // Return the results of applying the iteratee to each element.
-  _.map = _.collect = function(obj, iteratee, context) {
-    if (obj == null) return [];
-    iteratee = _.iteratee(iteratee, context);
-    var keys = obj.length !== +obj.length && _.keys(obj),
-        length = (keys || obj).length,
-        results = Array(length),
-        currentKey;
-    for (var index = 0; index < length; index++) {
-      currentKey = keys ? keys[index] : index;
-      results[index] = iteratee(obj[currentKey], currentKey, obj);
-    }
-    return results;
-  };
-
-  var reduceError = 'Reduce of empty array with no initial value';
-
-  // **Reduce** builds up a single result from a list of values, aka `inject`,
-  // or `foldl`.
-  _.reduce = _.foldl = _.inject = function(obj, iteratee, memo, context) {
-    if (obj == null) obj = [];
-    iteratee = createCallback(iteratee, context, 4);
-    var keys = obj.length !== +obj.length && _.keys(obj),
-        length = (keys || obj).length,
-        index = 0, currentKey;
-    if (arguments.length < 3) {
-      if (!length) throw new TypeError(reduceError);
-      memo = obj[keys ? keys[index++] : index++];
-    }
-    for (; index < length; index++) {
-      currentKey = keys ? keys[index] : index;
-      memo = iteratee(memo, obj[currentKey], currentKey, obj);
-    }
-    return memo;
-  };
-
-  // The right-associative version of reduce, also known as `foldr`.
-  _.reduceRight = _.foldr = function(obj, iteratee, memo, context) {
-    if (obj == null) obj = [];
-    iteratee = createCallback(iteratee, context, 4);
-    var keys = obj.length !== + obj.length && _.keys(obj),
-        index = (keys || obj).length,
-        currentKey;
-    if (arguments.length < 3) {
-      if (!index) throw new TypeError(reduceError);
-      memo = obj[keys ? keys[--index] : --index];
-    }
-    while (index--) {
-      currentKey = keys ? keys[index] : index;
-      memo = iteratee(memo, obj[currentKey], currentKey, obj);
-    }
-    return memo;
-  };
-
-  // Return the first value which passes a truth test. Aliased as `detect`.
-  _.find = _.detect = function(obj, predicate, context) {
-    var result;
-    predicate = _.iteratee(predicate, context);
-    _.some(obj, function(value, index, list) {
-      if (predicate(value, index, list)) {
-        result = value;
-        return true;
-      }
-    });
-    return result;
-  };
-
-  // Return all the elements that pass a truth test.
-  // Aliased as `select`.
-  _.filter = _.select = function(obj, predicate, context) {
-    var results = [];
-    if (obj == null) return results;
-    predicate = _.iteratee(predicate, context);
-    _.each(obj, function(value, index, list) {
-      if (predicate(value, index, list)) results.push(value);
-    });
-    return results;
-  };
-
-  // Return all the elements for which a truth test fails.
-  _.reject = function(obj, predicate, context) {
-    return _.filter(obj, _.negate(_.iteratee(predicate)), context);
-  };
-
-  // Determine whether all of the elements match a truth test.
-  // Aliased as `all`.
-  _.every = _.all = function(obj, predicate, context) {
-    if (obj == null) return true;
-    predicate = _.iteratee(predicate, context);
-    var keys = obj.length !== +obj.length && _.keys(obj),
-        length = (keys || obj).length,
-        index, currentKey;
-    for (index = 0; index < length; index++) {
-      currentKey = keys ? keys[index] : index;
-      if (!predicate(obj[currentKey], currentKey, obj)) return false;
-    }
-    return true;
-  };
-
-  // Determine if at least one element in the object matches a truth test.
-  // Aliased as `any`.
-  _.some = _.any = function(obj, predicate, context) {
-    if (obj == null) return false;
-    predicate = _.iteratee(predicate, context);
-    var keys = obj.length !== +obj.length && _.keys(obj),
-        length = (keys || obj).length,
-        index, currentKey;
-    for (index = 0; index < length; index++) {
-      currentKey = keys ? keys[index] : index;
-      if (predicate(obj[currentKey], currentKey, obj)) return true;
-    }
-    return false;
-  };
-
-  // Determine if the array or object contains a given value (using `===`).
-  // Aliased as `include`.
-  _.contains = _.include = function(obj, target) {
-    if (obj == null) return false;
-    if (obj.length !== +obj.length) obj = _.values(obj);
-    return _.indexOf(obj, target) >= 0;
-  };
-
-  // Invoke a method (with arguments) on every item in a collection.
-  _.invoke = function(obj, method) {
-    var args = slice.call(arguments, 2);
-    var isFunc = _.isFunction(method);
-    return _.map(obj, function(value) {
-      return (isFunc ? method : value[method]).apply(value, args);
-    });
-  };
-
-  // Convenience version of a common use case of `map`: fetching a property.
-  _.pluck = function(obj, key) {
-    return _.map(obj, _.property(key));
-  };
-
-  // Convenience version of a common use case of `filter`: selecting only objects
-  // containing specific `key:value` pairs.
-  _.where = function(obj, attrs) {
-    return _.filter(obj, _.matches(attrs));
-  };
-
-  // Convenience version of a common use case of `find`: getting the first object
-  // containing specific `key:value` pairs.
-  _.findWhere = function(obj, attrs) {
-    return _.find(obj, _.matches(attrs));
-  };
-
-  // Return the maximum element (or element-based computation).
-  _.max = function(obj, iteratee, context) {
-    var result = -Infinity, lastComputed = -Infinity,
-        value, computed;
-    if (iteratee == null && obj != null) {
-      obj = obj.length === +obj.length ? obj : _.values(obj);
-      for (var i = 0, length = obj.length; i < length; i++) {
-        value = obj[i];
-        if (value > result) {
-          result = value;
-        }
-      }
-    } else {
-      iteratee = _.iteratee(iteratee, context);
-      _.each(obj, function(value, index, list) {
-        computed = iteratee(value, index, list);
-        if (computed > lastComputed || computed === -Infinity && result === -Infinity) {
-          result = value;
-          lastComputed = computed;
-        }
-      });
-    }
-    return result;
-  };
-
-  // Return the minimum element (or element-based computation).
-  _.min = function(obj, iteratee, context) {
-    var result = Infinity, lastComputed = Infinity,
-        value, computed;
-    if (iteratee == null && obj != null) {
-      obj = obj.length === +obj.length ? obj : _.values(obj);
-      for (var i = 0, length = obj.length; i < length; i++) {
-        value = obj[i];
-        if (value < result) {
-          result = value;
-        }
-      }
-    } else {
-      iteratee = _.iteratee(iteratee, context);
-      _.each(obj, function(value, index, list) {
-        computed = iteratee(value, index, list);
-        if (computed < lastComputed || computed === Infinity && result === Infinity) {
-          result = value;
-          lastComputed = computed;
-        }
-      });
-    }
-    return result;
-  };
-
-  // Shuffle a collection, using the modern version of the
-  // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).
-  _.shuffle = function(obj) {
-    var set = obj && obj.length === +obj.length ? obj : _.values(obj);
-    var length = set.length;
-    var shuffled = Array(length);
-    for (var index = 0, rand; index < length; index++) {
-      rand = _.random(0, index);
-      if (rand !== index) shuffled[index] = shuffled[rand];
-      shuffled[rand] = set[index];
-    }
-    return shuffled;
-  };
-
-  // Sample **n** random values from a collection.
-  // If **n** is not specified, returns a single random element.
-  // The internal `guard` argument allows it to work with `map`.
-  _.sample = function(obj, n, guard) {
-    if (n == null || guard) {
-      if (obj.length !== +obj.length) obj = _.values(obj);
-      return obj[_.random(obj.length - 1)];
-    }
-    return _.shuffle(obj).slice(0, Math.max(0, n));
-  };
-
-  // Sort the object's values by a criterion produced by an iteratee.
-  _.sortBy = function(obj, iteratee, context) {
-    iteratee = _.iteratee(iteratee, context);
-    return _.pluck(_.map(obj, function(value, index, list) {
-      return {
-        value: value,
-        index: index,
-        criteria: iteratee(value, index, list)
-      };
-    }).sort(function(left, right) {
-      var a = left.criteria;
-      var b = right.criteria;
-      if (a !== b) {
-        if (a > b || a === void 0) return 1;
-        if (a < b || b === void 0) return -1;
-      }
-      return left.index - right.index;
-    }), 'value');
-  };
-
-  // An internal function used for aggregate "group by" operations.
-  var group = function(behavior) {
-    return function(obj, iteratee, context) {
-      var result = {};
-      iteratee = _.iteratee(iteratee, context);
-      _.each(obj, function(value, index) {
-        var key = iteratee(value, index, obj);
-        behavior(result, value, key);
-      });
-      return result;
-    };
-  };
-
-  // Groups the object's values by a criterion. Pass either a string attribute
-  // to group by, or a function that returns the criterion.
-  _.groupBy = group(function(result, value, key) {
-    if (_.has(result, key)) result[key].push(value); else result[key] = [value];
-  });
-
-  // Indexes the object's values by a criterion, similar to `groupBy`, but for
-  // when you know that your index values will be unique.
-  _.indexBy = group(function(result, value, key) {
-    result[key] = value;
-  });
-
-  // Counts instances of an object that group by a certain criterion. Pass
-  // either a string attribute to count by, or a function that returns the
-  // criterion.
-  _.countBy = group(function(result, value, key) {
-    if (_.has(result, key)) result[key]++; else result[key] = 1;
-  });
-
-  // Use a comparator function to figure out the smallest index at which
-  // an object should be inserted so as to maintain order. Uses binary search.
-  _.sortedIndex = function(array, obj, iteratee, context) {
-    iteratee = _.iteratee(iteratee, context, 1);
-    var value = iteratee(obj);
-    var low = 0, high = array.length;
-    while (low < high) {
-      var mid = low + high >>> 1;
-      if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;
-    }
-    return low;
-  };
-
-  // Safely create a real, live array from anything iterable.
-  _.toArray = function(obj) {
-    if (!obj) return [];
-    if (_.isArray(obj)) return slice.call(obj);
-    if (obj.length === +obj.length) return _.map(obj, _.identity);
-    return _.values(obj);
-  };
-
-  // Return the number of elements in an object.
-  _.size = function(obj) {
-    if (obj == null) return 0;
-    return obj.length === +obj.length ? obj.length : _.keys(obj).length;
-  };
-
-  // Split a collection into two arrays: one whose elements all satisfy the given
-  // predicate, and one whose elements all do not satisfy the predicate.
-  _.partition = function(obj, predicate, context) {
-    predicate = _.iteratee(predicate, context);
-    var pass = [], fail = [];
-    _.each(obj, function(value, key, obj) {
-      (predicate(value, key, obj) ? pass : fail).push(value);
-    });
-    return [pass, fail];
-  };
-
-  // Array Functions
-  // ---------------
-
-  // Get the first element of an array. Passing **n** will return the first N
-  // values in the array. Aliased as `head` and `take`. The **guard** check
-  // allows it to work with `_.map`.
-  _.first = _.head = _.take = function(array, n, guard) {
-    if (array == null) return void 0;
-    if (n == null || guard) return array[0];
-    if (n < 0) return [];
-    return slice.call(array, 0, n);
-  };
-
-  // Returns everything but the last entry of the array. Especially useful on
-  // the arguments object. Passing **n** will return all the values in
-  // the array, excluding the last N. The **guard** check allows it to work with
-  // `_.map`.
-  _.initial = function(array, n, guard) {
-    return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));
-  };
-
-  // Get the last element of an array. Passing **n** will return the last N
-  // values in the array. The **guard** check allows it to work with `_.map`.
-  _.last = function(array, n, guard) {
-    if (array == null) return void 0;
-    if (n == null || guard) return array[array.length - 1];
-    return slice.call(array, Math.max(array.length - n, 0));
-  };
-
-  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
-  // Especially useful on the arguments object. Passing an **n** will return
-  // the rest N values in the array. The **guard**
-  // check allows it to work with `_.map`.
-  _.rest = _.tail = _.drop = function(array, n, guard) {
-    return slice.call(array, n == null || guard ? 1 : n);
-  };
-
-  // Trim out all falsy values from an array.
-  _.compact = function(array) {
-    return _.filter(array, _.identity);
-  };
-
-  // Internal implementation of a recursive `flatten` function.
-  var flatten = function(input, shallow, strict, output) {
-    if (shallow && _.every(input, _.isArray)) {
-      return concat.apply(output, input);
-    }
-    for (var i = 0, length = input.length; i < length; i++) {
-      var value = input[i];
-      if (!_.isArray(value) && !_.isArguments(value)) {
-        if (!strict) output.push(value);
-      } else if (shallow) {
-        push.apply(output, value);
-      } else {
-        flatten(value, shallow, strict, output);
-      }
-    }
-    return output;
-  };
-
-  // Flatten out an array, either recursively (by default), or just one level.
-  _.flatten = function(array, shallow) {
-    return flatten(array, shallow, false, []);
-  };
-
-  // Return a version of the array that does not contain the specified value(s).
-  _.without = function(array) {
-    return _.difference(array, slice.call(arguments, 1));
-  };
-
-  // Produce a duplicate-free version of the array. If the array has already
-  // been sorted, you have the option of using a faster algorithm.
-  // Aliased as `unique`.
-  _.uniq = _.unique = function(array, isSorted, iteratee, context) {
-    if (array == null) return [];
-    if (!_.isBoolean(isSorted)) {
-      context = iteratee;
-      iteratee = isSorted;
-      isSorted = false;
-    }
-    if (iteratee != null) iteratee = _.iteratee(iteratee, context);
-    var result = [];
-    var seen = [];
-    for (var i = 0, length = array.length; i < length; i++) {
-      var value = array[i];
-      if (isSorted) {
-        if (!i || seen !== value) result.push(value);
-        seen = value;
-      } else if (iteratee) {
-        var computed = iteratee(value, i, array);
-        if (_.indexOf(seen, computed) < 0) {
-          seen.push(computed);
-          result.push(value);
-        }
-      } else if (_.indexOf(result, value) < 0) {
-        result.push(value);
-      }
-    }
-    return result;
-  };
-
-  // Produce an array that contains the union: each distinct element from all of
-  // the passed-in arrays.
-  _.union = function() {
-    return _.uniq(flatten(arguments, true, true, []));
-  };
-
-  // Produce an array that contains every item shared between all the
-  // passed-in arrays.
-  _.intersection = function(array) {
-    if (array == null) return [];
-    var result = [];
-    var argsLength = arguments.length;
-    for (var i = 0, length = array.length; i < length; i++) {
-      var item = array[i];
-      if (_.contains(result, item)) continue;
-      for (var j = 1; j < argsLength; j++) {
-        if (!_.contains(arguments[j], item)) break;
-      }
-      if (j === argsLength) result.push(item);
-    }
-    return result;
-  };
-
-  // Take the difference between one array and a number of other arrays.
-  // Only the elements present in just the first array will remain.
-  _.difference = function(array) {
-    var rest = flatten(slice.call(arguments, 1), true, true, []);
-    return _.filter(array, function(value){
-      return !_.contains(rest, value);
-    });
-  };
-
-  // Zip together multiple lists into a single array -- elements that share
-  // an index go together.
-  _.zip = function(array) {
-    if (array == null) return [];
-    var length = _.max(arguments, 'length').length;
-    var results = Array(length);
-    for (var i = 0; i < length; i++) {
-      results[i] = _.pluck(arguments, i);
-    }
-    return results;
-  };
-
-  // Converts lists into objects. Pass either a single array of `[key, value]`
-  // pairs, or two parallel arrays of the same length -- one of keys, and one of
-  // the corresponding values.
-  _.object = function(list, values) {
-    if (list == null) return {};
-    var result = {};
-    for (var i = 0, length = list.length; i < length; i++) {
-      if (values) {
-        result[list[i]] = values[i];
-      } else {
-        result[list[i][0]] = list[i][1];
-      }
-    }
-    return result;
-  };
-
-  // Return the position of the first occurrence of an item in an array,
-  // or -1 if the item is not included in the array.
-  // If the array is large and already in sort order, pass `true`
-  // for **isSorted** to use binary search.
-  _.indexOf = function(array, item, isSorted) {
-    if (array == null) return -1;
-    var i = 0, length = array.length;
-    if (isSorted) {
-      if (typeof isSorted == 'number') {
-        i = isSorted < 0 ? Math.max(0, length + isSorted) : isSorted;
-      } else {
-        i = _.sortedIndex(array, item);
-        return array[i] === item ? i : -1;
-      }
-    }
-    for (; i < length; i++) if (array[i] === item) return i;
-    return -1;
-  };
-
-  _.lastIndexOf = function(array, item, from) {
-    if (array == null) return -1;
-    var idx = array.length;
-    if (typeof from == 'number') {
-      idx = from < 0 ? idx + from + 1 : Math.min(idx, from + 1);
-    }
-    while (--idx >= 0) if (array[idx] === item) return idx;
-    return -1;
-  };
-
-  // Generate an integer Array containing an arithmetic progression. A port of
-  // the native Python `range()` function. See
-  // [the Python documentation](http://docs.python.org/library/functions.html#range).
-  _.range = function(start, stop, step) {
-    if (arguments.length <= 1) {
-      stop = start || 0;
-      start = 0;
-    }
-    step = step || 1;
-
-    var length = Math.max(Math.ceil((stop - start) / step), 0);
-    var range = Array(length);
-
-    for (var idx = 0; idx < length; idx++, start += step) {
-      range[idx] = start;
-    }
-
-    return range;
-  };
-
-  // Function (ahem) Functions
-  // ------------------
-
-  // Reusable constructor function for prototype setting.
-  var Ctor = function(){};
-
-  // Create a function bound to a given object (assigning `this`, and arguments,
-  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
-  // available.
-  _.bind = function(func, context) {
-    var args, bound;
-    if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
-    if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');
-    args = slice.call(arguments, 2);
-    bound = function() {
-      if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
-      Ctor.prototype = func.prototype;
-      var self = new Ctor;
-      Ctor.prototype = null;
-      var result = func.apply(self, args.concat(slice.call(arguments)));
-      if (_.isObject(result)) return result;
-      return self;
-    };
-    return bound;
-  };
-
-  // Partially apply a function by creating a version that has had some of its
-  // arguments pre-filled, without changing its dynamic `this` context. _ acts
-  // as a placeholder, allowing any combination of arguments to be pre-filled.
-  _.partial = function(func) {
-    var boundArgs = slice.call(arguments, 1);
-    return function() {
-      var position = 0;
-      var args = boundArgs.slice();
-      for (var i = 0, length = args.length; i < length; i++) {
-        if (args[i] === _) args[i] = arguments[position++];
-      }
-      while (position < arguments.length) args.push(arguments[position++]);
-      return func.apply(this, args);
-    };
-  };
-
-  // Bind a number of an object's methods to that object. Remaining arguments
-  // are the method names to be bound. Useful for ensuring that all callbacks
-  // defined on an object belong to it.
-  _.bindAll = function(obj) {
-    var i, length = arguments.length, key;
-    if (length <= 1) throw new Error('bindAll must be passed function names');
-    for (i = 1; i < length; i++) {
-      key = arguments[i];
-      obj[key] = _.bind(obj[key], obj);
-    }
-    return obj;
-  };
-
-  // Memoize an expensive function by storing its results.
-  _.memoize = function(func, hasher) {
-    var memoize = function(key) {
-      var cache = memoize.cache;
-      var address = hasher ? hasher.apply(this, arguments) : key;
-      if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);
-      return cache[address];
-    };
-    memoize.cache = {};
-    return memoize;
-  };
-
-  // Delays a function for the given number of milliseconds, and then calls
-  // it with the arguments supplied.
-  _.delay = function(func, wait) {
-    var args = slice.call(arguments, 2);
-    return setTimeout(function(){
-      return func.apply(null, args);
-    }, wait);
-  };
-
-  // Defers a function, scheduling it to run after the current call stack has
-  // cleared.
-  _.defer = function(func) {
-    return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
-  };
-
-  // Returns a function, that, when invoked, will only be triggered at most once
-  // during a given window of time. Normally, the throttled function will run
-  // as much as it can, without ever going more than once per `wait` duration;
-  // but if you'd like to disable the execution on the leading edge, pass
-  // `{leading: false}`. To disable execution on the trailing edge, ditto.
-  _.throttle = function(func, wait, options) {
-    var context, args, result;
-    var timeout = null;
-    var previous = 0;
-    if (!options) options = {};
-    var later = function() {
-      previous = options.leading === false ? 0 : _.now();
-      timeout = null;
-      result = func.apply(context, args);
-      if (!timeout) context = args = null;
-    };
-    return function() {
-      var now = _.now();
-      if (!previous && options.leading === false) previous = now;
-      var remaining = wait - (now - previous);
-      context = this;
-      args = arguments;
-      if (remaining <= 0 || remaining > wait) {
-        clearTimeout(timeout);
-        timeout = null;
-        previous = now;
-        result = func.apply(context, args);
-        if (!timeout) context = args = null;
-      } else if (!timeout && options.trailing !== false) {
-        timeout = setTimeout(later, remaining);
-      }
-      return result;
-    };
-  };
-
-  // Returns a function, that, as long as it continues to be invoked, will not
-  // be triggered. The function will be called after it stops being called for
-  // N milliseconds. If `immediate` is passed, trigger the function on the
-  // leading edge, instead of the trailing.
-  _.debounce = function(func, wait, immediate) {
-    var timeout, args, context, timestamp, result;
-
-    var later = function() {
-      var last = _.now() - timestamp;
-
-      if (last < wait && last > 0) {
-        timeout = setTimeout(later, wait - last);
-      } else {
-        timeout = null;
-        if (!immediate) {
-          result = func.apply(context, args);
-          if (!timeout) context = args = null;
-        }
-      }
-    };
-
-    return function() {
-      context = this;
-      args = arguments;
-      timestamp = _.now();
-      var callNow = immediate && !timeout;
-      if (!timeout) timeout = setTimeout(later, wait);
-      if (callNow) {
-        result = func.apply(context, args);
-        context = args = null;
-      }
-
-      return result;
-    };
-  };
-
-  // Returns the first function passed as an argument to the second,
-  // allowing you to adjust arguments, run code before and after, and
-  // conditionally execute the original function.
-  _.wrap = function(func, wrapper) {
-    return _.partial(wrapper, func);
-  };
-
-  // Returns a negated version of the passed-in predicate.
-  _.negate = function(predicate) {
-    return function() {
-      return !predicate.apply(this, arguments);
-    };
-  };
-
-  // Returns a function that is the composition of a list of functions, each
-  // consuming the return value of the function that follows.
-  _.compose = function() {
-    var args = arguments;
-    var start = args.length - 1;
-    return function() {
-      var i = start;
-      var result = args[start].apply(this, arguments);
-      while (i--) result = args[i].call(this, result);
-      return result;
-    };
-  };
-
-  // Returns a function that will only be executed after being called N times.
-  _.after = function(times, func) {
-    return function() {
-      if (--times < 1) {
-        return func.apply(this, arguments);
-      }
-    };
-  };
-
-  // Returns a function that will only be executed before being called N times.
-  _.before = function(times, func) {
-    var memo;
-    return function() {
-      if (--times > 0) {
-        memo = func.apply(this, arguments);
-      } else {
-        func = null;
-      }
-      return memo;
-    };
-  };
-
-  // Returns a function that will be executed at most one time, no matter how
-  // often you call it. Useful for lazy initialization.
-  _.once = _.partial(_.before, 2);
-
-  // Object Functions
-  // ----------------
-
-  // Retrieve the names of an object's properties.
-  // Delegates to **ECMAScript 5**'s native `Object.keys`
-  _.keys = function(obj) {
-    if (!_.isObject(obj)) return [];
-    if (nativeKeys) return nativeKeys(obj);
-    var keys = [];
-    for (var key in obj) if (_.has(obj, key)) keys.push(key);
-    return keys;
-  };
-
-  // Retrieve the values of an object's properties.
-  _.values = function(obj) {
-    var keys = _.keys(obj);
-    var length = keys.length;
-    var values = Array(length);
-    for (var i = 0; i < length; i++) {
-      values[i] = obj[keys[i]];
-    }
-    return values;
-  };
-
-  // Convert an object into a list of `[key, value]` pairs.
-  _.pairs = function(obj) {
-    var keys = _.keys(obj);
-    var length = keys.length;
-    var pairs = Array(length);
-    for (var i = 0; i < length; i++) {
-      pairs[i] = [keys[i], obj[keys[i]]];
-    }
-    return pairs;
-  };
-
-  // Invert the keys and values of an object. The values must be serializable.
-  _.invert = function(obj) {
-    var result = {};
-    var keys = _.keys(obj);
-    for (var i = 0, length = keys.length; i < length; i++) {
-      result[obj[keys[i]]] = keys[i];
-    }
-    return result;
-  };
-
-  // Return a sorted list of the function names available on the object.
-  // Aliased as `methods`
-  _.functions = _.methods = function(obj) {
-    var names = [];
-    for (var key in obj) {
-      if (_.isFunction(obj[key])) names.push(key);
-    }
-    return names.sort();
-  };
-
-  // Extend a given object with all the properties in passed-in object(s).
-  _.extend = function(obj) {
-    if (!_.isObject(obj)) return obj;
-    var source, prop;
-    for (var i = 1, length = arguments.length; i < length; i++) {
-      source = arguments[i];
-      for (prop in source) {
-        if (hasOwnProperty.call(source, prop)) {
-            obj[prop] = source[prop];
-        }
-      }
-    }
-    return obj;
-  };
-
-  // Return a copy of the object only containing the whitelisted properties.
-  _.pick = function(obj, iteratee, context) {
-    var result = {}, key;
-    if (obj == null) return result;
-    if (_.isFunction(iteratee)) {
-      iteratee = createCallback(iteratee, context);
-      for (key in obj) {
-        var value = obj[key];
-        if (iteratee(value, key, obj)) result[key] = value;
-      }
-    } else {
-      var keys = concat.apply([], slice.call(arguments, 1));
-      obj = new Object(obj);
-      for (var i = 0, length = keys.length; i < length; i++) {
-        key = keys[i];
-        if (key in obj) result[key] = obj[key];
-      }
-    }
-    return result;
-  };
-
-   // Return a copy of the object without the blacklisted properties.
-  _.omit = function(obj, iteratee, context) {
-    if (_.isFunction(iteratee)) {
-      iteratee = _.negate(iteratee);
-    } else {
-      var keys = _.map(concat.apply([], slice.call(arguments, 1)), String);
-      iteratee = function(value, key) {
-        return !_.contains(keys, key);
-      };
-    }
-    return _.pick(obj, iteratee, context);
-  };
-
-  // Fill in a given object with default properties.
-  _.defaults = function(obj) {
-    if (!_.isObject(obj)) return obj;
-    for (var i = 1, length = arguments.length; i < length; i++) {
-      var source = arguments[i];
-      for (var prop in source) {
-        if (obj[prop] === void 0) obj[prop] = source[prop];
-      }
-    }
-    return obj;
-  };
-
-  // Create a (shallow-cloned) duplicate of an object.
-  _.clone = function(obj) {
-    if (!_.isObject(obj)) return obj;
-    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
-  };
-
-  // Invokes interceptor with the obj, and then returns obj.
-  // The primary purpose of this method is to "tap into" a method chain, in
-  // order to perform operations on intermediate results within the chain.
-  _.tap = function(obj, interceptor) {
-    interceptor(obj);
-    return obj;
-  };
-
-  // Internal recursive comparison function for `isEqual`.
-  var eq = function(a, b, aStack, bStack) {
-    // Identical objects are equal. `0 === -0`, but they aren't identical.
-    // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
-    if (a === b) return a !== 0 || 1 / a === 1 / b;
-    // A strict comparison is necessary because `null == undefined`.
-    if (a == null || b == null) return a === b;
-    // Unwrap any wrapped objects.
-    if (a instanceof _) a = a._wrapped;
-    if (b instanceof _) b = b._wrapped;
-    // Compare `[[Class]]` names.
-    var className = toString.call(a);
-    if (className !== toString.call(b)) return false;
-    switch (className) {
-      // Strings, numbers, regular expressions, dates, and booleans are compared by value.
-      case '[object RegExp]':
-      // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')
-      case '[object String]':
-        // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
-        // equivalent to `new String("5")`.
-        return '' + a === '' + b;
-      case '[object Number]':
-        // `NaN`s are equivalent, but non-reflexive.
-        // Object(NaN) is equivalent to NaN
-        if (+a !== +a) return +b !== +b;
-        // An `egal` comparison is performed for other numeric values.
-        return +a === 0 ? 1 / +a === 1 / b : +a === +b;
-      case '[object Date]':
-      case '[object Boolean]':
-        // Coerce dates and booleans to numeric primitive values. Dates are compared by their
-        // millisecond representations. Note that invalid dates with millisecond representations
-        // of `NaN` are not equivalent.
-        return +a === +b;
-    }
-    if (typeof a != 'object' || typeof b != 'object') return false;
-    // Assume equality for cyclic structures. The algorithm for detecting cyclic
-    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
-    var length = aStack.length;
-    while (length--) {
-      // Linear search. Performance is inversely proportional to the number of
-      // unique nested structures.
-      if (aStack[length] === a) return bStack[length] === b;
-    }
-    // Objects with different constructors are not equivalent, but `Object`s
-    // from different frames are.
-    var aCtor = a.constructor, bCtor = b.constructor;
-    if (
-      aCtor !== bCtor &&
-      // Handle Object.create(x) cases
-      'constructor' in a && 'constructor' in b &&
-      !(_.isFunction(aCtor) && aCtor instanceof aCtor &&
-        _.isFunction(bCtor) && bCtor instanceof bCtor)
-    ) {
-      return false;
-    }
-    // Add the first object to the stack of traversed objects.
-    aStack.push(a);
-    bStack.push(b);
-    var size, result;
-    // Recursively compare objects and arrays.
-    if (className === '[object Array]') {
-      // Compare array lengths to determine if a deep comparison is necessary.
-      size = a.length;
-      result = size === b.length;
-      if (result) {
-        // Deep compare the contents, ignoring non-numeric properties.
-        while (size--) {
-          if (!(result = eq(a[size], b[size], aStack, bStack))) break;
-        }
-      }
-    } else {
-      // Deep compare objects.
-      var keys = _.keys(a), key;
-      size = keys.length;
-      // Ensure that both objects contain the same number of properties before comparing deep equality.
-      result = _.keys(b).length === size;
-      if (result) {
-        while (size--) {
-          // Deep compare each member
-          key = keys[size];
-          if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;
-        }
-      }
-    }
-    // Remove the first object from the stack of traversed objects.
-    aStack.pop();
-    bStack.pop();
-    return result;
-  };
-
-  // Perform a deep comparison to check if two objects are equal.
-  _.isEqual = function(a, b) {
-    return eq(a, b, [], []);
-  };
-
-  // Is a given array, string, or object empty?
-  // An "empty" object has no enumerable own-properties.
-  _.isEmpty = function(obj) {
-    if (obj == null) return true;
-    if (_.isArray(obj) || _.isString(obj) || _.isArguments(obj)) return obj.length === 0;
-    for (var key in obj) if (_.has(obj, key)) return false;
-    return true;
-  };
-
-  // Is a given value a DOM element?
-  _.isElement = function(obj) {
-    return !!(obj && obj.nodeType === 1);
-  };
-
-  // Is a given value an array?
-  // Delegates to ECMA5's native Array.isArray
-  _.isArray = nativeIsArray || function(obj) {
-    return toString.call(obj) === '[object Array]';
-  };
-
-  // Is a given variable an object?
-  _.isObject = function(obj) {
-    var type = typeof obj;
-    return type === 'function' || type === 'object' && !!obj;
-  };
-
-  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
-  _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
-    _['is' + name] = function(obj) {
-      return toString.call(obj) === '[object ' + name + ']';
-    };
-  });
-
-  // Define a fallback version of the method in browsers (ahem, IE), where
-  // there isn't any inspectable "Arguments" type.
-  if (!_.isArguments(arguments)) {
-    _.isArguments = function(obj) {
-      return _.has(obj, 'callee');
-    };
-  }
-
-  // Optimize `isFunction` if appropriate. Work around an IE 11 bug.
-  if (typeof /./ !== 'function') {
-    _.isFunction = function(obj) {
-      return typeof obj == 'function' || false;
-    };
-  }
-
-  // Is a given object a finite number?
-  _.isFinite = function(obj) {
-    return isFinite(obj) && !isNaN(parseFloat(obj));
-  };
-
-  // Is the given value `NaN`? (NaN is the only number which does not equal itself).
-  _.isNaN = function(obj) {
-    return _.isNumber(obj) && obj !== +obj;
-  };
-
-  // Is a given value a boolean?
-  _.isBoolean = function(obj) {
-    return obj === true || obj === false || toString.call(obj) === '[object Boolean]';
-  };
-
-  // Is a given value equal to null?
-  _.isNull = function(obj) {
-    return obj === null;
-  };
-
-  // Is a given variable undefined?
-  _.isUndefined = function(obj) {
-    return obj === void 0;
-  };
-
-  // Shortcut function for checking if an object has a given property directly
-  // on itself (in other words, not on a prototype).
-  _.has = function(obj, key) {
-    return obj != null && hasOwnProperty.call(obj, key);
-  };
-
-  // Utility Functions
-  // -----------------
-
-  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
-  // previous owner. Returns a reference to the Underscore object.
-  _.noConflict = function() {
-    root._ = previousUnderscore;
-    return this;
-  };
-
-  // Keep the identity function around for default iteratees.
-  _.identity = function(value) {
-    return value;
-  };
-
-  _.constant = function(value) {
-    return function() {
-      return value;
-    };
-  };
-
-  _.noop = function(){};
-
-  _.property = function(key) {
-    return function(obj) {
-      return obj[key];
-    };
-  };
-
-  // Returns a predicate for checking whether an object has a given set of `key:value` pairs.
-  _.matches = function(attrs) {
-    var pairs = _.pairs(attrs), length = pairs.length;
-    return function(obj) {
-      if (obj == null) return !length;
-      obj = new Object(obj);
-      for (var i = 0; i < length; i++) {
-        var pair = pairs[i], key = pair[0];
-        if (pair[1] !== obj[key] || !(key in obj)) return false;
-      }
-      return true;
-    };
-  };
-
-  // Run a function **n** times.
-  _.times = function(n, iteratee, context) {
-    var accum = Array(Math.max(0, n));
-    iteratee = createCallback(iteratee, context, 1);
-    for (var i = 0; i < n; i++) accum[i] = iteratee(i);
-    return accum;
-  };
-
-  // Return a random integer between min and max (inclusive).
-  _.random = function(min, max) {
-    if (max == null) {
-      max = min;
-      min = 0;
-    }
-    return min + Math.floor(Math.random() * (max - min + 1));
-  };
-
-  // A (possibly faster) way to get the current timestamp as an integer.
-  _.now = Date.now || function() {
-    return new Date().getTime();
-  };
-
-   // List of HTML entities for escaping.
-  var escapeMap = {
-    '&': '&amp;',
-    '<': '&lt;',
-    '>': '&gt;',
-    '"': '&quot;',
-    "'": '&#x27;',
-    '`': '&#x60;'
-  };
-  var unescapeMap = _.invert(escapeMap);
-
-  // Functions for escaping and unescaping strings to/from HTML interpolation.
-  var createEscaper = function(map) {
-    var escaper = function(match) {
-      return map[match];
-    };
-    // Regexes for identifying a key that needs to be escaped
-    var source = '(?:' + _.keys(map).join('|') + ')';
-    var testRegexp = RegExp(source);
-    var replaceRegexp = RegExp(source, 'g');
-    return function(string) {
-      string = string == null ? '' : '' + string;
-      return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;
-    };
-  };
-  _.escape = createEscaper(escapeMap);
-  _.unescape = createEscaper(unescapeMap);
-
-  // If the value of the named `property` is a function then invoke it with the
-  // `object` as context; otherwise, return it.
-  _.result = function(object, property) {
-    if (object == null) return void 0;
-    var value = object[property];
-    return _.isFunction(value) ? object[property]() : value;
-  };
-
-  // Generate a unique integer id (unique within the entire client session).
-  // Useful for temporary DOM ids.
-  var idCounter = 0;
-  _.uniqueId = function(prefix) {
-    var id = ++idCounter + '';
-    return prefix ? prefix + id : id;
-  };
-
-  // By default, Underscore uses ERB-style template delimiters, change the
-  // following template settings to use alternative delimiters.
-  _.templateSettings = {
-    evaluate    : /<%([\s\S]+?)%>/g,
-    interpolate : /<%=([\s\S]+?)%>/g,
-    escape      : /<%-([\s\S]+?)%>/g
-  };
-
-  // When customizing `templateSettings`, if you don't want to define an
-  // interpolation, evaluation or escaping regex, we need one that is
-  // guaranteed not to match.
-  var noMatch = /(.)^/;
-
-  // Certain characters need to be escaped so that they can be put into a
-  // string literal.
-  var escapes = {
-    "'":      "'",
-    '\\':     '\\',
-    '\r':     'r',
-    '\n':     'n',
-    '\u2028': 'u2028',
-    '\u2029': 'u2029'
-  };
-
-  var escaper = /\\|'|\r|\n|\u2028|\u2029/g;
-
-  var escapeChar = function(match) {
-    return '\\' + escapes[match];
-  };
-
-  // JavaScript micro-templating, similar to John Resig's implementation.
-  // Underscore templating handles arbitrary delimiters, preserves whitespace,
-  // and correctly escapes quotes within interpolated code.
-  // NB: `oldSettings` only exists for backwards compatibility.
-  _.template = function(text, settings, oldSettings) {
-    if (!settings && oldSettings) settings = oldSettings;
-    settings = _.defaults({}, settings, _.templateSettings);
-
-    // Combine delimiters into one regular expression via alternation.
-    var matcher = RegExp([
-      (settings.escape || noMatch).source,
-      (settings.interpolate || noMatch).source,
-      (settings.evaluate || noMatch).source
-    ].join('|') + '|$', 'g');
-
-    // Compile the template source, escaping string literals appropriately.
-    var index = 0;
-    var source = "__p+='";
-    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
-      source += text.slice(index, offset).replace(escaper, escapeChar);
-      index = offset + match.length;
-
-      if (escape) {
-        source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
-      } else if (interpolate) {
-        source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
-      } else if (evaluate) {
-        source += "';\n" + evaluate + "\n__p+='";
-      }
-
-      // Adobe VMs need the match returned to produce the correct offest.
-      return match;
-    });
-    source += "';\n";
-
-    // If a variable is not specified, place data values in local scope.
-    if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
-
-    source = "var __t,__p='',__j=Array.prototype.join," +
-      "print=function(){__p+=__j.call(arguments,'');};\n" +
-      source + 'return __p;\n';
-
-    try {
-      var render = new Function(settings.variable || 'obj', '_', source);
-    } catch (e) {
-      e.source = source;
-      throw e;
-    }
-
-    var template = function(data) {
-      return render.call(this, data, _);
-    };
-
-    // Provide the compiled source as a convenience for precompilation.
-    var argument = settings.variable || 'obj';
-    template.source = 'function(' + argument + '){\n' + source + '}';
-
-    return template;
-  };
-
-  // Add a "chain" function. Start chaining a wrapped Underscore object.
-  _.chain = function(obj) {
-    var instance = _(obj);
-    instance._chain = true;
-    return instance;
-  };
-
-  // OOP
-  // ---------------
-  // If Underscore is called as a function, it returns a wrapped object that
-  // can be used OO-style. This wrapper holds altered versions of all the
-  // underscore functions. Wrapped objects may be chained.
-
-  // Helper function to continue chaining intermediate results.
-  var result = function(obj) {
-    return this._chain ? _(obj).chain() : obj;
-  };
-
-  // Add your own custom functions to the Underscore object.
-  _.mixin = function(obj) {
-    _.each(_.functions(obj), function(name) {
-      var func = _[name] = obj[name];
-      _.prototype[name] = function() {
-        var args = [this._wrapped];
-        push.apply(args, arguments);
-        return result.call(this, func.apply(_, args));
-      };
-    });
-  };
-
-  // Add all of the Underscore functions to the wrapper object.
-  _.mixin(_);
-
-  // Add all mutator Array functions to the wrapper.
-  _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
-    var method = ArrayProto[name];
-    _.prototype[name] = function() {
-      var obj = this._wrapped;
-      method.apply(obj, arguments);
-      if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];
-      return result.call(this, obj);
-    };
-  });
-
-  // Add all accessor Array functions to the wrapper.
-  _.each(['concat', 'join', 'slice'], function(name) {
-    var method = ArrayProto[name];
-    _.prototype[name] = function() {
-      return result.call(this, method.apply(this._wrapped, arguments));
-    };
-  });
-
-  // Extracts the result from a wrapped and chained object.
-  _.prototype.value = function() {
-    return this._wrapped;
-  };
-
-  // AMD registration happens at the end for compatibility with AMD loaders
-  // that may not enforce next-turn semantics on modules. Even though general
-  // practice for AMD registration is to be anonymous, underscore registers
-  // as a named module because, like jQuery, it is a base library that is
-  // popular enough to be bundled in a third party lib, but not be part of
-  // an AMD load request. Those cases could generate an error when an
-  // anonymous define() is called outside of a loader request.
-  if (typeof define === 'function' && define.amd) {
-    define('underscore', [], function() {
-      return _;
-    });
-  }
-}.call(this));
diff --git a/examples/knockback/node_modules/knockback/node_modules/knockout/build/output/knockout-latest.debug.js b/examples/knockback/node_modules/knockout/build/output/knockout-latest.debug.js
similarity index 92%
rename from examples/knockback/node_modules/knockback/node_modules/knockout/build/output/knockout-latest.debug.js
rename to examples/knockback/node_modules/knockout/build/output/knockout-latest.debug.js
index e192f33f0f..d83744ee33 100644
--- a/examples/knockback/node_modules/knockback/node_modules/knockout/build/output/knockout-latest.debug.js
+++ b/examples/knockback/node_modules/knockout/build/output/knockout-latest.debug.js
@@ -1,5 +1,5 @@
 /*!
- * Knockout JavaScript library v3.2.0
+ * Knockout JavaScript library v3.3.0
  * (c) Steven Sanderson - http://knockoutjs.com/
  * License: MIT (http://www.opensource.org/licenses/mit-license.php)
  */
@@ -16,18 +16,17 @@ var DEBUG=true;
         JSON = window["JSON"];
 (function(factory) {
     // Support three module loading scenarios
-    if (typeof require === 'function' && typeof exports === 'object' && typeof module === 'object') {
-        // [1] CommonJS/Node.js
-        var target = module['exports'] || exports; // module.exports is for Node.js
-        factory(target, require);
-    } else if (typeof define === 'function' && define['amd']) {
-        // [2] AMD anonymous module
+    if (typeof define === 'function' && define['amd']) {
+        // [1] AMD anonymous module
         define(['exports', 'require'], factory);
+    } else if (typeof require === 'function' && typeof exports === 'object' && typeof module === 'object') {
+        // [2] CommonJS/Node.js
+        factory(module['exports'] || exports);  // module.exports is for Node.js
     } else {
         // [3] No module loader (plain <script> tag) - put directly in global namespace
         factory(window['ko'] = {});
     }
-}(function(koExports, require){
+}(function(koExports, amdRequire){
 // Internally, all KO objects are attached to koExports (even the non-exported ones whose names will be minified by the closure compiler).
 // In the future, the following "ko" variable may be made distinct from "koExports" so that private objects are not externally reachable.
 var ko = typeof koExports !== 'undefined' ? koExports : {};
@@ -46,7 +45,7 @@ ko.exportSymbol = function(koPath, object) {
 ko.exportProperty = function(owner, publicName, object) {
     owner[publicName] = object;
 };
-ko.version = "3.2.0";
+ko.version = "3.3.0";
 
 ko.exportSymbol('version', ko.version);
 ko.utils = (function () {
@@ -113,6 +112,37 @@ ko.utils = (function () {
         return (inputType == "checkbox") || (inputType == "radio");
     }
 
+    // For details on the pattern for changing node classes
+    // see: https://github.com/knockout/knockout/issues/1597
+    var cssClassNameRegex = /\S+/g;
+
+    function toggleDomNodeCssClass(node, classNames, shouldHaveClass) {
+        var addOrRemoveFn;
+        if (classNames) {
+            if (typeof node.classList === 'object') {
+                addOrRemoveFn = node.classList[shouldHaveClass ? 'add' : 'remove'];
+                ko.utils.arrayForEach(classNames.match(cssClassNameRegex), function(className) {
+                    addOrRemoveFn.call(node.classList, className);
+                });
+            } else if (typeof node.className['baseVal'] === 'string') {
+                // SVG tag .classNames is an SVGAnimatedString instance
+                toggleObjectClassPropertyString(node.className, 'baseVal', classNames, shouldHaveClass);
+            } else {
+                // node.className ought to be a string.
+                toggleObjectClassPropertyString(node, 'className', classNames, shouldHaveClass);
+            }
+        }
+    }
+
+    function toggleObjectClassPropertyString(obj, prop, classNames, shouldHaveClass) {
+        // obj/prop is either a node/'className' or a SVGAnimatedString/'baseVal'.
+        var currentClassNames = obj[prop].match(cssClassNameRegex) || [];
+        ko.utils.arrayForEach(classNames.match(cssClassNameRegex), function(className) {
+            ko.utils.addOrRemoveItem(currentClassNames, className, shouldHaveClass);
+        });
+        obj[prop] = currentClassNames.join(" ");
+    }
+
     return {
         fieldsIncludedWithJsonPost: ['authenticity_token', /^__RequestVerificationToken(_.*)?$/],
 
@@ -226,8 +256,9 @@ ko.utils = (function () {
             // Ensure it's a real array, as we're about to reparent the nodes and
             // we don't want the underlying collection to change while we're doing that.
             var nodesArray = ko.utils.makeArray(nodes);
+            var templateDocument = (nodesArray[0] && nodesArray[0].ownerDocument) || document;
 
-            var container = document.createElement('div');
+            var container = templateDocument.createElement('div');
             for (var i = 0, j = nodesArray.length; i < j; i++) {
                 container.appendChild(ko.cleanNode(nodesArray[i]));
             }
@@ -283,7 +314,7 @@ ko.utils = (function () {
 
                 // Rule [A]
                 while (continuousNodeArray.length && continuousNodeArray[0].parentNode !== parentNode)
-                    continuousNodeArray.shift();
+                    continuousNodeArray.splice(0, 1);
 
                 // Rule [B]
                 if (continuousNodeArray.length > 1) {
@@ -412,16 +443,7 @@ ko.utils = (function () {
             return ko.isObservable(value) ? value.peek() : value;
         },
 
-        toggleDomNodeCssClass: function (node, classNames, shouldHaveClass) {
-            if (classNames) {
-                var cssClassNameRegex = /\S+/g,
-                    currentClassNames = node.className.match(cssClassNameRegex) || [];
-                ko.utils.arrayForEach(classNames.match(cssClassNameRegex), function(className) {
-                    ko.utils.addOrRemoveItem(currentClassNames, className, shouldHaveClass);
-                });
-                node.className = currentClassNames.join(" ");
-            }
-        },
+        toggleDomNodeCssClass: toggleDomNodeCssClass,
 
         setTextContent: function(element, textContent) {
             var value = ko.utils.unwrapObservable(textContent);
@@ -595,16 +617,26 @@ ko.exportSymbol('utils.triggerEvent', ko.utils.triggerEvent);
 ko.exportSymbol('utils.unwrapObservable', ko.utils.unwrapObservable);
 ko.exportSymbol('utils.objectForEach', ko.utils.objectForEach);
 ko.exportSymbol('utils.addOrRemoveItem', ko.utils.addOrRemoveItem);
+ko.exportSymbol('utils.setTextContent', ko.utils.setTextContent);
 ko.exportSymbol('unwrap', ko.utils.unwrapObservable); // Convenient shorthand, because this is used so commonly
 
 if (!Function.prototype['bind']) {
     // Function.prototype.bind is a standard part of ECMAScript 5th Edition (December 2009, http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf)
     // In case the browser doesn't implement it natively, provide a JavaScript implementation. This implementation is based on the one in prototype.js
     Function.prototype['bind'] = function (object) {
-        var originalFunction = this, args = Array.prototype.slice.call(arguments), object = args.shift();
-        return function () {
-            return originalFunction.apply(object, args.concat(Array.prototype.slice.call(arguments)));
-        };
+        var originalFunction = this;
+        if (arguments.length === 1) {
+            return function () {
+                return originalFunction.apply(object, arguments);
+            };
+        } else {
+            var partialArgs = Array.prototype.slice.call(arguments, 1);
+            return function () {
+                var args = partialArgs.slice(0);
+                args.push.apply(args, arguments);
+                return originalFunction.apply(object, args);
+            };
+        }
     };
 }
 
@@ -751,7 +783,7 @@ ko.utils.domNodeDisposal = new (function () {
             if (jQueryInstance && (typeof jQueryInstance['cleanData'] == "function"))
                 jQueryInstance['cleanData']([node]);
         }
-    }
+    };
 })();
 ko.cleanNode = ko.utils.domNodeDisposal.cleanNode; // Shorthand name for convenience
 ko.removeNode = ko.utils.domNodeDisposal.removeNode; // Shorthand name for convenience
@@ -763,7 +795,10 @@ ko.exportSymbol('utils.domNodeDisposal.removeDisposeCallback', ko.utils.domNodeD
 (function () {
     var leadingCommentRegex = /^(\s*)<!--(.*?)-->/;
 
-    function simpleHtmlParse(html) {
+    function simpleHtmlParse(html, documentContext) {
+        documentContext || (documentContext = document);
+        var windowContext = documentContext['parentWindow'] || documentContext['defaultView'] || window;
+
         // Based on jQuery's "clean" function, but only accounting for table-related elements.
         // If you have referenced jQuery, this won't be used anyway - KO will use jQuery's "clean" function directly
 
@@ -773,7 +808,7 @@ ko.exportSymbol('utils.domNodeDisposal.removeDisposeCallback', ko.utils.domNodeD
         // (possibly a text node) in front of the comment. So, KO does not attempt to workaround this IE issue automatically at present.
 
         // Trim whitespace, otherwise indexOf won't work as expected
-        var tags = ko.utils.stringTrim(html).toLowerCase(), div = document.createElement("div");
+        var tags = ko.utils.stringTrim(html).toLowerCase(), div = documentContext.createElement("div");
 
         // Finds the first match from the left column, and returns the corresponding "wrap" data from the right column
         var wrap = tags.match(/^<(thead|tbody|tfoot)/)              && [1, "<table>", "</table>"] ||
@@ -784,8 +819,8 @@ ko.exportSymbol('utils.domNodeDisposal.removeDisposeCallback', ko.utils.domNodeD
         // Go to html and back, then peel off extra wrappers
         // Note that we always prefix with some dummy text, because otherwise, IE<9 will strip out leading comment nodes in descendants. Total madness.
         var markup = "ignored<div>" + wrap[1] + html + wrap[2] + "</div>";
-        if (typeof window['innerShiv'] == "function") {
-            div.appendChild(window['innerShiv'](markup));
+        if (typeof windowContext['innerShiv'] == "function") {
+            div.appendChild(windowContext['innerShiv'](markup));
         } else {
             div.innerHTML = markup;
         }
@@ -797,13 +832,13 @@ ko.exportSymbol('utils.domNodeDisposal.removeDisposeCallback', ko.utils.domNodeD
         return ko.utils.makeArray(div.lastChild.childNodes);
     }
 
-    function jQueryHtmlParse(html) {
+    function jQueryHtmlParse(html, documentContext) {
         // jQuery's "parseHTML" function was introduced in jQuery 1.8.0 and is a documented public API.
         if (jQueryInstance['parseHTML']) {
-            return jQueryInstance['parseHTML'](html) || []; // Ensure we always return an array and never null
+            return jQueryInstance['parseHTML'](html, documentContext) || []; // Ensure we always return an array and never null
         } else {
             // For jQuery < 1.8.0, we fall back on the undocumented internal "clean" function.
-            var elems = jQueryInstance['clean']([html]);
+            var elems = jQueryInstance['clean']([html], documentContext);
 
             // As of jQuery 1.7.1, jQuery parses the HTML by appending it to some dummy parent nodes held in an in-memory document fragment.
             // Unfortunately, it never clears the dummy parent nodes from the document fragment, so it leaks memory over time.
@@ -822,9 +857,9 @@ ko.exportSymbol('utils.domNodeDisposal.removeDisposeCallback', ko.utils.domNodeD
         }
     }
 
-    ko.utils.parseHtmlFragment = function(html) {
-        return jQueryInstance ? jQueryHtmlParse(html)   // As below, benefit from jQuery's optimisations where possible
-                              : simpleHtmlParse(html);  // ... otherwise, this simple logic will do in most common cases.
+    ko.utils.parseHtmlFragment = function(html, documentContext) {
+        return jQueryInstance ? jQueryHtmlParse(html, documentContext)   // As below, benefit from jQuery's optimisations where possible
+                              : simpleHtmlParse(html, documentContext);  // ... otherwise, this simple logic will do in most common cases.
     };
 
     ko.utils.setHtml = function(node, html) {
@@ -844,7 +879,7 @@ ko.exportSymbol('utils.domNodeDisposal.removeDisposeCallback', ko.utils.domNodeD
                 jQueryInstance(node)['html'](html);
             } else {
                 // ... otherwise, use KO's own parsing logic.
-                var parsedNodes = ko.utils.parseHtmlFragment(html);
+                var parsedNodes = ko.utils.parseHtmlFragment(html, node.ownerDocument);
                 for (var i = 0; i < parsedNodes.length; i++)
                     node.appendChild(parsedNodes[i]);
             }
@@ -1011,7 +1046,7 @@ function applyExtenders(requestedExtenders) {
 ko.exportSymbol('extenders', ko.extenders);
 
 ko.subscription = function (target, callback, disposeCallback) {
-    this.target = target;
+    this._target = target;
     this.callback = callback;
     this.disposeCallback = disposeCallback;
     this.isDisposed = false;
@@ -1025,6 +1060,7 @@ ko.subscription.prototype.dispose = function () {
 ko.subscribable = function () {
     ko.utils.setPrototypeOfOrExtend(this, ko.subscribable['fn']);
     this._subscriptions = {};
+    this._versionNumber = 1;
 }
 
 var defaultEvent = "change";
@@ -1054,6 +1090,9 @@ var ko_subscribable_fn = {
 
     "notifySubscribers": function (valueToNotify, event) {
         event = event || defaultEvent;
+        if (event === defaultEvent) {
+            this.updateVersion();
+        }
         if (this.hasSubscriptionsForEvent(event)) {
             try {
                 ko.dependencyDetection.begin(); // Begin suppressing dependency detection (by setting the top frame to undefined)
@@ -1069,6 +1108,18 @@ var ko_subscribable_fn = {
         }
     },
 
+    getVersion: function () {
+        return this._versionNumber;
+    },
+
+    hasChanged: function (versionToCheck) {
+        return this.getVersion() !== versionToCheck;
+    },
+
+    updateVersion: function () {
+        ++this._versionNumber;
+    },
+
     limit: function(limitFunction) {
         var self = this, selfIsObservable = ko.isObservable(self),
             isPending, previousValue, pendingValue, beforeChange = 'beforeChange';
@@ -1115,12 +1166,16 @@ var ko_subscribable_fn = {
         return this._subscriptions[event] && this._subscriptions[event].length;
     },
 
-    getSubscriptionsCount: function () {
-        var total = 0;
-        ko.utils.objectForEach(this._subscriptions, function(eventName, subscriptions) {
-            total += subscriptions.length;
-        });
-        return total;
+    getSubscriptionsCount: function (event) {
+        if (event) {
+            return this._subscriptions[event] && this._subscriptions[event].length || 0;
+        } else {
+            var total = 0;
+            ko.utils.objectForEach(this._subscriptions, function(eventName, subscriptions) {
+                total += subscriptions.length;
+            });
+            return total;
+        }
     },
 
     isDifferent: function(oldValue, newValue) {
@@ -1213,6 +1268,8 @@ ko.exportSymbol('computedContext', ko.computedContext);
 ko.exportSymbol('computedContext.getDependenciesCount', ko.computedContext.getDependenciesCount);
 ko.exportSymbol('computedContext.isInitial', ko.computedContext.isInitial);
 ko.exportSymbol('computedContext.isSleeping', ko.computedContext.isSleeping);
+
+ko.exportSymbol('ignoreDependencies', ko.ignoreDependencies = ko.dependencyDetection.ignore);
 ko.observable = function (initialValue) {
     var _latestValue = initialValue;
 
@@ -1418,15 +1475,27 @@ ko.extenders['trackArrayChanges'] = function(target) {
     }
     var trackingChanges = false,
         cachedDiff = null,
+        arrayChangeSubscription,
         pendingNotifications = 0,
-        underlyingSubscribeFunction = target.subscribe;
+        underlyingBeforeSubscriptionAddFunction = target.beforeSubscriptionAdd,
+        underlyingAfterSubscriptionRemoveFunction = target.afterSubscriptionRemove;
 
-    // Intercept "subscribe" calls, and for array change events, ensure change tracking is enabled
-    target.subscribe = target['subscribe'] = function(callback, callbackTarget, event) {
+    // Watch "subscribe" calls, and for array change events, ensure change tracking is enabled
+    target.beforeSubscriptionAdd = function (event) {
+        if (underlyingBeforeSubscriptionAddFunction)
+            underlyingBeforeSubscriptionAddFunction.call(target, event);
         if (event === arrayChangeEventName) {
             trackChanges();
         }
-        return underlyingSubscribeFunction.apply(this, arguments);
+    };
+    // Watch "dispose" calls, and for array change events, ensure change tracking is disabled when all are disposed
+    target.afterSubscriptionRemove = function (event) {
+        if (underlyingAfterSubscriptionRemoveFunction)
+            underlyingAfterSubscriptionRemoveFunction.call(target, event);
+        if (event === arrayChangeEventName && !target.hasSubscriptionsForEvent(arrayChangeEventName)) {
+            arrayChangeSubscription.dispose();
+            trackingChanges = false;
+        }
     };
 
     function trackChanges() {
@@ -1450,22 +1519,23 @@ ko.extenders['trackArrayChanges'] = function(target) {
         // change it's possible to produce a diff
         var previousContents = [].concat(target.peek() || []);
         cachedDiff = null;
-        target.subscribe(function(currentContents) {
+        arrayChangeSubscription = target.subscribe(function(currentContents) {
             // Make a copy of the current contents and ensure it's an array
             currentContents = [].concat(currentContents || []);
 
             // Compute the diff and issue notifications, but only if someone is listening
             if (target.hasSubscriptionsForEvent(arrayChangeEventName)) {
                 var changes = getChanges(previousContents, currentContents);
-                if (changes.length) {
-                    target['notifySubscribers'](changes, arrayChangeEventName);
-                }
             }
 
             // Eliminate references to the old, removed items, so they can be GCed
             previousContents = currentContents;
             cachedDiff = null;
             pendingNotifications = 0;
+
+            if (changes && changes.length) {
+                target['notifySubscribers'](changes, arrayChangeEventName);
+            }
         });
     }
 
@@ -1558,44 +1628,58 @@ ko.computed = ko.dependentObservable = function (evaluatorFunctionOrOptions, eva
     if (typeof readFunction != "function")
         throw new Error("Pass a function that returns the value of the ko.computed");
 
-    function addSubscriptionToDependency(subscribable, id) {
-        if (!_subscriptionsToDependencies[id]) {
-            _subscriptionsToDependencies[id] = subscribable.subscribe(evaluatePossiblyAsync);
-            ++_dependenciesCount;
+    function addDependencyTracking(id, target, trackingObj) {
+        if (pure && target === dependentObservable) {
+            throw Error("A 'pure' computed must not be called recursively");
         }
+
+        dependencyTracking[id] = trackingObj;
+        trackingObj._order = _dependenciesCount++;
+        trackingObj._version = target.getVersion();
     }
 
-    function disposeAllSubscriptionsToDependencies() {
-        ko.utils.objectForEach(_subscriptionsToDependencies, function (id, subscription) {
-            subscription.dispose();
-        });
-        _subscriptionsToDependencies = {};
+    function haveDependenciesChanged() {
+        var id, dependency;
+        for (id in dependencyTracking) {
+            if (dependencyTracking.hasOwnProperty(id)) {
+                dependency = dependencyTracking[id];
+                if (dependency._target.hasChanged(dependency._version)) {
+                    return true;
+                }
+            }
+        }
     }
 
     function disposeComputed() {
-        disposeAllSubscriptionsToDependencies();
+        if (!isSleeping && dependencyTracking) {
+            ko.utils.objectForEach(dependencyTracking, function (id, dependency) {
+                if (dependency.dispose)
+                    dependency.dispose();
+            });
+        }
+        dependencyTracking = null;
         _dependenciesCount = 0;
         _isDisposed = true;
         _needsEvaluation = false;
+        isSleeping = false;
     }
 
     function evaluatePossiblyAsync() {
         var throttleEvaluationTimeout = dependentObservable['throttleEvaluation'];
         if (throttleEvaluationTimeout && throttleEvaluationTimeout >= 0) {
             clearTimeout(evaluationTimeoutInstance);
-            evaluationTimeoutInstance = setTimeout(evaluateImmediate, throttleEvaluationTimeout);
+            evaluationTimeoutInstance = setTimeout(function () {
+                evaluateImmediate(true /*notifyChange*/);
+            }, throttleEvaluationTimeout);
         } else if (dependentObservable._evalRateLimited) {
             dependentObservable._evalRateLimited();
         } else {
-            evaluateImmediate();
+            evaluateImmediate(true /*notifyChange*/);
         }
     }
 
-    function evaluateImmediate(suppressChangeNotification) {
+    function evaluateImmediate(notifyChange) {
         if (_isBeingEvaluated) {
-            if (pure) {
-                throw Error("A 'pure' computed must not be called recursively");
-            }
             // If the evaluation of a ko.computed causes side effects, it's possible that it will trigger its own re-evaluation.
             // This is not desirable (it's hard for a developer to realise a chain of dependencies might cause this, and they almost
             // certainly didn't intend infinite re-evaluations). So, for predictability, we simply prevent ko.computeds from causing
@@ -1621,82 +1705,71 @@ ko.computed = ko.dependentObservable = function (evaluatorFunctionOrOptions, eva
 
         _isBeingEvaluated = true;
 
-        // When sleeping, recalculate the value and return.
-        if (isSleeping) {
-            try {
-                var dependencyTracking = {};
-                ko.dependencyDetection.begin({
-                    callback: function (subscribable, id) {
-                        if (!dependencyTracking[id]) {
-                            dependencyTracking[id] = 1;
-                            ++_dependenciesCount;
+        try {
+            // Initially, we assume that none of the subscriptions are still being used (i.e., all are candidates for disposal).
+            // Then, during evaluation, we cross off any that are in fact still being used.
+            var disposalCandidates = dependencyTracking,
+                disposalCount = _dependenciesCount,
+                isInitial = pure ? undefined : !_dependenciesCount;   // If we're evaluating when there are no previous dependencies, it must be the first time
+
+            ko.dependencyDetection.begin({
+                callback: function(subscribable, id) {
+                    if (!_isDisposed) {
+                        if (disposalCount && disposalCandidates[id]) {
+                            // Don't want to dispose this subscription, as it's still being used
+                            addDependencyTracking(id, subscribable, disposalCandidates[id]);
+                            delete disposalCandidates[id];
+                            --disposalCount;
+                        } else if (!dependencyTracking[id]) {
+                            // Brand new subscription - add it
+                            addDependencyTracking(id, subscribable, isSleeping ? { _target: subscribable } : subscribable.subscribe(evaluatePossiblyAsync));
                         }
-                    },
-                    computed: dependentObservable,
-                    isInitial: undefined
-                });
-                _dependenciesCount = 0;
-                _latestValue = readFunction.call(evaluatorFunctionTarget);
-            } finally {
-                ko.dependencyDetection.end();
-                _isBeingEvaluated = false;
-            }
-        } else {
-            try {
-                // Initially, we assume that none of the subscriptions are still being used (i.e., all are candidates for disposal).
-                // Then, during evaluation, we cross off any that are in fact still being used.
-                var disposalCandidates = _subscriptionsToDependencies, disposalCount = _dependenciesCount;
-                ko.dependencyDetection.begin({
-                    callback: function(subscribable, id) {
-                        if (!_isDisposed) {
-                            if (disposalCount && disposalCandidates[id]) {
-                                // Don't want to dispose this subscription, as it's still being used
-                                _subscriptionsToDependencies[id] = disposalCandidates[id];
-                                ++_dependenciesCount;
-                                delete disposalCandidates[id];
-                                --disposalCount;
-                            } else {
-                                // Brand new subscription - add it
-                                addSubscriptionToDependency(subscribable, id);
-                            }
-                        }
-                    },
-                    computed: dependentObservable,
-                    isInitial: pure ? undefined : !_dependenciesCount        // If we're evaluating when there are no previous dependencies, it must be the first time
-                });
+                    }
+                },
+                computed: dependentObservable,
+                isInitial: isInitial
+            });
 
-                _subscriptionsToDependencies = {};
-                _dependenciesCount = 0;
+            dependencyTracking = {};
+            _dependenciesCount = 0;
 
-                try {
-                    var newValue = evaluatorFunctionTarget ? readFunction.call(evaluatorFunctionTarget) : readFunction();
+            try {
+                var newValue = evaluatorFunctionTarget ? readFunction.call(evaluatorFunctionTarget) : readFunction();
 
-                } finally {
-                    ko.dependencyDetection.end();
+            } finally {
+                ko.dependencyDetection.end();
 
-                    // For each subscription no longer being used, remove it from the active subscriptions list and dispose it
-                    if (disposalCount) {
-                        ko.utils.objectForEach(disposalCandidates, function(id, toDispose) {
+                // For each subscription no longer being used, remove it from the active subscriptions list and dispose it
+                if (disposalCount && !isSleeping) {
+                    ko.utils.objectForEach(disposalCandidates, function(id, toDispose) {
+                        if (toDispose.dispose)
                             toDispose.dispose();
-                        });
-                    }
-
-                    _needsEvaluation = false;
+                    });
                 }
 
-                if (dependentObservable.isDifferent(_latestValue, newValue)) {
-                    dependentObservable["notifySubscribers"](_latestValue, "beforeChange");
+                _needsEvaluation = false;
+            }
 
-                    _latestValue = newValue;
-                    if (DEBUG) dependentObservable._latestValue = _latestValue;
+            if (dependentObservable.isDifferent(_latestValue, newValue)) {
+                if (!isSleeping) {
+                    notify(_latestValue, "beforeChange");
+                }
 
-                    if (suppressChangeNotification !== true) {  // Check for strict true value since setTimeout in Firefox passes a numeric value to the function
-                        dependentObservable["notifySubscribers"](_latestValue);
-                    }
+                _latestValue = newValue;
+                if (DEBUG) dependentObservable._latestValue = _latestValue;
+
+                if (isSleeping) {
+                    dependentObservable.updateVersion();
+                } else if (notifyChange) {
+                    notify(_latestValue);
                 }
-            } finally {
-                _isBeingEvaluated = false;
             }
+
+            if (isInitial) {
+                notify(_latestValue, "awake");
+            }
+        } finally {
+            _isBeingEvaluated = false;
         }
 
         if (!_dependenciesCount)
@@ -1715,17 +1788,18 @@ ko.computed = ko.dependentObservable = function (evaluatorFunctionOrOptions, eva
         } else {
             // Reading the value
             ko.dependencyDetection.registerDependency(dependentObservable);
-            if (_needsEvaluation)
-                evaluateImmediate(true /* suppressChangeNotification */);
+            if (_needsEvaluation || (isSleeping && haveDependenciesChanged())) {
+                evaluateImmediate();
+            }
             return _latestValue;
         }
     }
 
     function peek() {
-        // Peek won't re-evaluate, except to get the initial value when "deferEvaluation" is set, or while the computed is sleeping.
-        // Those are the only times that both of these conditions will be satisfied.
-        if (_needsEvaluation && !_dependenciesCount)
-            evaluateImmediate(true /* suppressChangeNotification */);
+        // Peek won't re-evaluate, except while the computed is sleeping or to get the initial value when "deferEvaluation" is set.
+        if ((_needsEvaluation && !_dependenciesCount) || (isSleeping && haveDependenciesChanged())) {
+            evaluateImmediate();
+        }
         return _latestValue;
     }
 
@@ -1733,13 +1807,17 @@ ko.computed = ko.dependentObservable = function (evaluatorFunctionOrOptions, eva
         return _needsEvaluation || _dependenciesCount > 0;
     }
 
+    function notify(value, event) {
+        dependentObservable["notifySubscribers"](value, event);
+    }
+
     // By here, "options" is always non-null
     var writeFunction = options["write"],
         disposeWhenNodeIsRemoved = options["disposeWhenNodeIsRemoved"] || options.disposeWhenNodeIsRemoved || null,
         disposeWhenOption = options["disposeWhen"] || options.disposeWhen,
         disposeWhen = disposeWhenOption,
         dispose = disposeComputed,
-        _subscriptionsToDependencies = {},
+        dependencyTracking = {},
         _dependenciesCount = 0,
         evaluationTimeoutInstance = null;
 
@@ -1751,7 +1829,7 @@ ko.computed = ko.dependentObservable = function (evaluatorFunctionOrOptions, eva
 
     dependentObservable.peek = peek;
     dependentObservable.getDependenciesCount = function () { return _dependenciesCount; };
-    dependentObservable.hasWriteFunction = typeof options["write"] === "function";
+    dependentObservable.hasWriteFunction = typeof writeFunction === "function";
     dependentObservable.dispose = function () { dispose(); };
     dependentObservable.isActive = isActive;
 
@@ -1773,24 +1851,69 @@ ko.computed = ko.dependentObservable = function (evaluatorFunctionOrOptions, eva
     if (options['pure']) {
         pure = true;
         isSleeping = true;     // Starts off sleeping; will awake on the first subscription
-        dependentObservable.beforeSubscriptionAdd = function () {
-            // If asleep, wake up the computed and evaluate to register any dependencies.
-            if (isSleeping) {
+        dependentObservable.beforeSubscriptionAdd = function (event) {
+            // If asleep, wake up the computed by subscribing to any dependencies.
+            if (!_isDisposed && isSleeping && event == 'change') {
                 isSleeping = false;
-                evaluateImmediate(true /* suppressChangeNotification */);
+                if (_needsEvaluation || haveDependenciesChanged()) {
+                    dependencyTracking = null;
+                    _dependenciesCount = 0;
+                    _needsEvaluation = true;
+                    evaluateImmediate();
+                } else {
+                    // First put the dependencies in order
+                    var dependeciesOrder = [];
+                    ko.utils.objectForEach(dependencyTracking, function (id, dependency) {
+                        dependeciesOrder[dependency._order] = id;
+                    });
+                    // Next, subscribe to each one
+                    ko.utils.arrayForEach(dependeciesOrder, function(id, order) {
+                        var dependency = dependencyTracking[id],
+                            subscription = dependency._target.subscribe(evaluatePossiblyAsync);
+                        subscription._order = order;
+                        subscription._version = dependency._version;
+                        dependencyTracking[id] = subscription;
+                    });
+                }
+                if (!_isDisposed) {     // test since evaluating could trigger disposal
+                    notify(_latestValue, "awake");
+                }
             }
-        }
-        dependentObservable.afterSubscriptionRemove = function () {
-            if (!dependentObservable.getSubscriptionsCount()) {
-                disposeAllSubscriptionsToDependencies();
-                isSleeping = _needsEvaluation = true;
+        };
+
+        dependentObservable.afterSubscriptionRemove = function (event) {
+            if (!_isDisposed && event == 'change' && !dependentObservable.hasSubscriptionsForEvent('change')) {
+                ko.utils.objectForEach(dependencyTracking, function (id, dependency) {
+                    if (dependency.dispose) {
+                        dependencyTracking[id] = {
+                            _target: dependency._target,
+                            _order: dependency._order,
+                            _version: dependency._version
+                        };
+                        dependency.dispose();
+                    }
+                });
+                isSleeping = true;
+                notify(undefined, "asleep");
             }
-        }
+        };
+
+        // Because a pure computed is not automatically updated while it is sleeping, we can't
+        // simply return the version number. Instead, we check if any of the dependencies have
+        // changed and conditionally re-evaluate the computed observable.
+        dependentObservable._originalGetVersion = dependentObservable.getVersion;
+        dependentObservable.getVersion = function () {
+            if (isSleeping && (_needsEvaluation || haveDependenciesChanged())) {
+                evaluateImmediate();
+            }
+            return dependentObservable._originalGetVersion();
+        };
     } else if (options['deferEvaluation']) {
         // This will force a computed with deferEvaluation to evaluate when the first subscriptions is registered.
-        dependentObservable.beforeSubscriptionAdd = function () {
-            peek();
-            delete dependentObservable.beforeSubscriptionAdd;
+        dependentObservable.beforeSubscriptionAdd = function (event) {
+            if (event == 'change' || event == 'beforeChange') {
+                peek();
+            }
         }
     }
 
@@ -2085,7 +2208,7 @@ ko.expressionRewriting = (function () {
         if (str.charCodeAt(0) === 123) str = str.slice(1, -1);
 
         // Split into tokens
-        var result = [], toks = str.match(bindingToken), key, values, depth = 0;
+        var result = [], toks = str.match(bindingToken), key, values = [], depth = 0;
 
         if (toks) {
             // Append a comma so that we don't need a separate code block to deal with the last item
@@ -2096,15 +2219,17 @@ ko.expressionRewriting = (function () {
                 // A comma signals the end of a key/value pair if depth is zero
                 if (c === 44) { // ","
                     if (depth <= 0) {
-                        if (key)
-                            result.push(values ? {key: key, value: values.join('')} : {'unknown': key});
-                        key = values = depth = 0;
+                        result.push((key && values.length) ? {key: key, value: values.join('')} : {'unknown': key || values.join('')});
+                        key = depth = 0;
+                        values = [];
                         continue;
                     }
                 // Simply skip the colon that separates the name and value
                 } else if (c === 58) { // ":"
-                    if (!values)
+                    if (!depth && !key && values.length === 1) {
+                        key = values.pop();
                         continue;
+                    }
                 // A set of slashes is initially matched as a regular expression, but could be division
                 } else if (c === 47 && i && tok.length > 1) {  // "/"
                     // Look at the end of the previous token to determine if the slash is actually division
@@ -2123,15 +2248,11 @@ ko.expressionRewriting = (function () {
                     ++depth;
                 } else if (c === 41 || c === 125 || c === 93) { // ')', '}', ']'
                     --depth;
-                // The key must be a single token; if it's a string, trim the quotes
-                } else if (!key && !values) {
-                    key = (c === 34 || c === 39) /* '"', "'" */ ? tok.slice(1, -1) : tok;
-                    continue;
+                // The key will be the first token; if it's a string, trim the quotes
+                } else if (!key && !values.length && (c === 34 || c === 39)) { // '"', "'"
+                    tok = tok.slice(1, -1);
                 }
-                if (values)
-                    values.push(tok);
-                else
-                    values = [tok];
+                values.push(tok);
             }
         }
         return result;
@@ -2512,9 +2633,10 @@ ko.exportSymbol('bindingProvider', ko.bindingProvider);
     // may consider adding <template> to this list, because such elements' contents are always
     // intended to be bound in a different context from where they appear in the document.
     var bindingDoesNotRecurseIntoElementTypes = {
-        // Don't want bindings that operate on text nodes to mutate <script> contents,
+        // Don't want bindings that operate on text nodes to mutate <script> and <textarea> contents,
         // because it's unexpected and a potential XSS issue
-        'script': true
+        'script': true,
+        'textarea': true
     };
 
     // Use an overridable method for retrieving binding handlers so that a plugins may support dynamically created handlers
@@ -2978,8 +3100,15 @@ ko.exportSymbol('bindingProvider', ko.bindingProvider);
             var cachedDefinition = getObjectOwnProperty(loadedDefinitionsCache, componentName);
             if (cachedDefinition) {
                 // It's already loaded and cached. Reuse the same definition object.
-                // Note that for API consistency, even cache hits complete asynchronously.
-                setTimeout(function() { callback(cachedDefinition) }, 0);
+                // Note that for API consistency, even cache hits complete asynchronously by default.
+                // You can bypass this by putting synchronous:true on your component config.
+                if (cachedDefinition.isSynchronousComponent) {
+                    ko.dependencyDetection.ignore(function() { // See comment in loaderRegistryBehaviors.js for reasoning
+                        callback(cachedDefinition.definition);
+                    });
+                } else {
+                    setTimeout(function() { callback(cachedDefinition.definition); }, 0);
+                }
             } else {
                 // Join the loading process that is already underway, or start a new one.
                 loadComponentAndNotify(componentName, callback);
@@ -3003,14 +3132,22 @@ ko.exportSymbol('bindingProvider', ko.bindingProvider);
         if (!subscribable) {
             // It's not started loading yet. Start loading, and when it's done, move it to loadedDefinitionsCache.
             subscribable = loadingSubscribablesCache[componentName] = new ko.subscribable();
-            beginLoadingComponent(componentName, function(definition) {
-                loadedDefinitionsCache[componentName] = definition;
+            subscribable.subscribe(callback);
+
+            beginLoadingComponent(componentName, function(definition, config) {
+                var isSynchronousComponent = !!(config && config['synchronous']);
+                loadedDefinitionsCache[componentName] = { definition: definition, isSynchronousComponent: isSynchronousComponent };
                 delete loadingSubscribablesCache[componentName];
 
                 // For API consistency, all loads complete asynchronously. However we want to avoid
                 // adding an extra setTimeout if it's unnecessary (i.e., the completion is already
                 // async) since setTimeout(..., 0) still takes about 16ms or more on most browsers.
-                if (completedAsync) {
+                //
+                // You can bypass the 'always synchronous' feature by putting the synchronous:true
+                // flag on your component configuration when you register it.
+                if (completedAsync || isSynchronousComponent) {
+                    // Note that notifySubscribers ignores any dependencies read within the callback.
+                    // See comment in loaderRegistryBehaviors.js for reasoning
                     subscribable['notifySubscribers'](definition);
                 } else {
                     setTimeout(function() {
@@ -3019,8 +3156,9 @@ ko.exportSymbol('bindingProvider', ko.bindingProvider);
                 }
             });
             completedAsync = true;
+        } else {
+            subscribable.subscribe(callback);
         }
-        subscribable.subscribe(callback);
     }
 
     function beginLoadingComponent(componentName, callback) {
@@ -3028,14 +3166,14 @@ ko.exportSymbol('bindingProvider', ko.bindingProvider);
             if (config) {
                 // We have a config, so now load its definition
                 getFirstResultFromLoaders('loadComponent', [componentName, config], function(definition) {
-                    callback(definition);
+                    callback(definition, config);
                 });
             } else {
                 // The component has no config - it's unknown to all the loaders.
                 // Note that this is not an error (e.g., a module loading error) - that would abort the
                 // process and this callback would not run. For this callback to run, all loaders must
                 // have confirmed they don't know about this component.
-                callback(null);
+                callback(null, null);
             }
         });
     }
@@ -3291,8 +3429,8 @@ ko.exportSymbol('bindingProvider', ko.bindingProvider);
     function possiblyGetConfigFromAmd(errorCallback, config, callback) {
         if (typeof config['require'] === 'string') {
             // The config is the value of an AMD module
-            if (require || window['require']) {
-                (require || window['require'])([config['require']], callback);
+            if (amdRequire || window['require']) {
+                (amdRequire || window['require'])([config['require']], callback);
             } else {
                 errorCallback('Uses require, but no AMD loader is present');
             }
@@ -3364,18 +3502,26 @@ ko.exportSymbol('bindingProvider', ko.bindingProvider);
                     return ko.computed(paramValue, null, { disposeWhenNodeIsRemoved: elem });
                 }),
                 result = ko.utils.objectMap(rawParamComputedValues, function(paramValueComputed, paramName) {
+                    var paramValue = paramValueComputed.peek();
                     // Does the evaluation of the parameter value unwrap any observables?
                     if (!paramValueComputed.isActive()) {
                         // No it doesn't, so there's no need for any computed wrapper. Just pass through the supplied value directly.
                         // Example: "someVal: firstName, age: 123" (whether or not firstName is an observable/computed)
-                        return paramValueComputed.peek();
+                        return paramValue;
                     } else {
                         // Yes it does. Supply a computed property that unwraps both the outer (binding expression)
                         // level of observability, and any inner (resulting model value) level of observability.
-                        // This means the component doesn't have to worry about multiple unwrapping.
-                        return ko.computed(function() {
-                            return ko.utils.unwrapObservable(paramValueComputed());
-                        }, null, { disposeWhenNodeIsRemoved: elem });
+                        // This means the component doesn't have to worry about multiple unwrapping. If the value is a
+                        // writable observable, the computed will also be writable and pass the value on to the observable.
+                        return ko.computed({
+                            'read': function() {
+                                return ko.utils.unwrapObservable(paramValueComputed());
+                            },
+                            'write': ko.isWriteableObservable(paramValue) && function(value) {
+                                paramValueComputed()(value);
+                            },
+                            disposeWhenNodeIsRemoved: elem
+                        });
                     }
                 });
 
@@ -3438,7 +3584,8 @@ ko.exportSymbol('bindingProvider', ko.bindingProvider);
 
                     // Any in-flight loading operation is no longer relevant, so make sure we ignore its completion
                     currentLoadingOperationId = null;
-                };
+                },
+                originalChildNodes = ko.utils.makeArray(ko.virtualElements.childNodes(element));
 
             ko.utils.domNodeDisposal.addDisposeCallback(element, disposeAssociatedComponentViewModel);
 
@@ -3472,8 +3619,11 @@ ko.exportSymbol('bindingProvider', ko.bindingProvider);
                         throw new Error('Unknown component \'' + componentName + '\'');
                     }
                     cloneTemplateIntoElement(componentName, componentDefinition, element);
-                    var componentViewModel = createViewModel(componentDefinition, element, componentParams),
-                        childBindingContext = bindingContext['createChildContext'](componentViewModel);
+                    var componentViewModel = createViewModel(componentDefinition, element, originalChildNodes, componentParams),
+                        childBindingContext = bindingContext['createChildContext'](componentViewModel, /* dataItemAlias */ undefined, function(ctx) {
+                            ctx['$component'] = componentViewModel;
+                            ctx['$componentTemplateNodes'] = originalChildNodes;
+                        });
                     currentViewModel = componentViewModel;
                     ko.applyBindingsToDescendants(childBindingContext, element);
                 });
@@ -3495,10 +3645,10 @@ ko.exportSymbol('bindingProvider', ko.bindingProvider);
         ko.virtualElements.setDomNodeChildren(element, clonedNodesArray);
     }
 
-    function createViewModel(componentDefinition, element, componentParams) {
+    function createViewModel(componentDefinition, element, originalChildNodes, componentParams) {
         var componentViewModelFactory = componentDefinition['createViewModel'];
         return componentViewModelFactory
-            ? componentViewModelFactory.call(componentDefinition, componentParams, { element: element })
+            ? componentViewModelFactory.call(componentDefinition, componentParams, { 'element': element, 'templateNodes': originalChildNodes })
             : componentParams; // Template-only component
     }
 
@@ -3651,7 +3801,7 @@ ko.bindingHandlers['checkedValue'] = {
 ko.bindingHandlers['css'] = {
     'update': function (element, valueAccessor) {
         var value = ko.utils.unwrapObservable(valueAccessor());
-        if (typeof value == "object") {
+        if (value !== null && typeof value == "object") {
             ko.utils.objectForEach(value, function(className, shouldHaveClass) {
                 shouldHaveClass = ko.utils.unwrapObservable(shouldHaveClass);
                 ko.utils.toggleDomNodeCssClass(element, className, shouldHaveClass);
@@ -3893,19 +4043,23 @@ ko.bindingHandlers['options'] = {
             return ko.utils.arrayFilter(element.options, function (node) { return node.selected; });
         }
 
-        var selectWasPreviouslyEmpty = element.length == 0;
-        var previousScrollTop = (!selectWasPreviouslyEmpty && element.multiple) ? element.scrollTop : null;
-        var unwrappedArray = ko.utils.unwrapObservable(valueAccessor());
-        var includeDestroyed = allBindings.get('optionsIncludeDestroyed');
-        var arrayToDomNodeChildrenOptions = {};
-        var captionValue;
-        var filteredArray;
-        var previousSelectedValues;
-
-        if (element.multiple) {
-            previousSelectedValues = ko.utils.arrayMap(selectedOptions(), ko.selectExtensions.readValue);
-        } else {
-            previousSelectedValues = element.selectedIndex >= 0 ? [ ko.selectExtensions.readValue(element.options[element.selectedIndex]) ] : [];
+        var selectWasPreviouslyEmpty = element.length == 0,
+            multiple = element.multiple,
+            previousScrollTop = (!selectWasPreviouslyEmpty && multiple) ? element.scrollTop : null,
+            unwrappedArray = ko.utils.unwrapObservable(valueAccessor()),
+            valueAllowUnset = allBindings.get('valueAllowUnset') && allBindings['has']('value'),
+            includeDestroyed = allBindings.get('optionsIncludeDestroyed'),
+            arrayToDomNodeChildrenOptions = {},
+            captionValue,
+            filteredArray,
+            previousSelectedValues = [];
+
+        if (!valueAllowUnset) {
+            if (multiple) {
+                previousSelectedValues = ko.utils.arrayMap(selectedOptions(), ko.selectExtensions.readValue);
+            } else if (element.selectedIndex >= 0) {
+                previousSelectedValues.push(ko.selectExtensions.readValue(element.options[element.selectedIndex]));
+            }
         }
 
         if (unwrappedArray) {
@@ -3946,7 +4100,7 @@ ko.bindingHandlers['options'] = {
         var itemUpdate = false;
         function optionForArrayItem(arrayEntry, index, oldOptions) {
             if (oldOptions.length) {
-                previousSelectedValues = oldOptions[0].selected ? [ ko.selectExtensions.readValue(oldOptions[0]) ] : [];
+                previousSelectedValues = !valueAllowUnset && oldOptions[0].selected ? [ ko.selectExtensions.readValue(oldOptions[0]) ] : [];
                 itemUpdate = true;
             }
             var option = element.ownerDocument.createElement("option");
@@ -3973,20 +4127,25 @@ ko.bindingHandlers['options'] = {
             };
 
         function setSelectionCallback(arrayEntry, newOptions) {
-            // IE6 doesn't like us to assign selection to OPTION nodes before they're added to the document.
-            // That's why we first added them without selection. Now it's time to set the selection.
-            if (previousSelectedValues.length) {
+            if (itemUpdate && valueAllowUnset) {
+                // The model value is authoritative, so make sure its value is the one selected
+                // There is no need to use dependencyDetection.ignore since setDomNodeChildrenFromArrayMapping does so already.
+                ko.selectExtensions.writeValue(element, ko.utils.unwrapObservable(allBindings.get('value')), true /* allowUnset */);
+            } else if (previousSelectedValues.length) {
+                // IE6 doesn't like us to assign selection to OPTION nodes before they're added to the document.
+                // That's why we first added them without selection. Now it's time to set the selection.
                 var isSelected = ko.utils.arrayIndexOf(previousSelectedValues, ko.selectExtensions.readValue(newOptions[0])) >= 0;
                 ko.utils.setOptionNodeSelectionState(newOptions[0], isSelected);
 
                 // If this option was changed from being selected during a single-item update, notify the change
-                if (itemUpdate && !isSelected)
+                if (itemUpdate && !isSelected) {
                     ko.dependencyDetection.ignore(ko.utils.triggerEvent, null, [element, "change"]);
+                }
             }
         }
 
         var callback = setSelectionCallback;
-        if (allBindings['has']('optionsAfterRender')) {
+        if (allBindings['has']('optionsAfterRender') && typeof allBindings.get('optionsAfterRender') == "function") {
             callback = function(arrayEntry, newOptions) {
                 setSelectionCallback(arrayEntry, newOptions);
                 ko.dependencyDetection.ignore(allBindings.get('optionsAfterRender'), null, [newOptions[0], arrayEntry !== captionPlaceholder ? arrayEntry : undefined]);
@@ -3996,13 +4155,13 @@ ko.bindingHandlers['options'] = {
         ko.utils.setDomNodeChildrenFromArrayMapping(element, filteredArray, optionForArrayItem, arrayToDomNodeChildrenOptions, callback);
 
         ko.dependencyDetection.ignore(function () {
-            if (allBindings.get('valueAllowUnset') && allBindings['has']('value')) {
+            if (valueAllowUnset) {
                 // The model value is authoritative, so make sure its value is the one selected
                 ko.selectExtensions.writeValue(element, ko.utils.unwrapObservable(allBindings.get('value')), true /* allowUnset */);
             } else {
                 // Determine if the selection has changed as a result of updating the options list
                 var selectionChanged;
-                if (element.multiple) {
+                if (multiple) {
                     // For a multiple-select box, compare the new selection count to the previous one
                     // But if nothing was selected before, the selection can't have changed
                     selectionChanged = previousSelectedValues.length && selectedOptions().length < previousSelectedValues.length;
@@ -4417,6 +4576,7 @@ makeEventHandlerShortcut('click');
 //            //   - you might also want to make bindingContext.$parent, bindingContext.$parents,
 //            //     and bindingContext.$root available in the template too
 //            // - options gives you access to any other properties set on "data-bind: { template: options }"
+//            // - templateDocument is the document object of the template
 //            //
 //            // Return value: an array of DOM nodes
 //        }
@@ -4434,7 +4594,7 @@ makeEventHandlerShortcut('click');
 
 ko.templateEngine = function () { };
 
-ko.templateEngine.prototype['renderTemplateSource'] = function (templateSource, bindingContext, options) {
+ko.templateEngine.prototype['renderTemplateSource'] = function (templateSource, bindingContext, options, templateDocument) {
     throw new Error("Override renderTemplateSource");
 };
 
@@ -4459,7 +4619,7 @@ ko.templateEngine.prototype['makeTemplateSource'] = function(template, templateD
 
 ko.templateEngine.prototype['renderTemplate'] = function (template, bindingContext, options, templateDocument) {
     var templateSource = this['makeTemplateSource'](template, templateDocument);
-    return this['renderTemplateSource'](templateSource, bindingContext, options);
+    return this['renderTemplateSource'](templateSource, bindingContext, options, templateDocument);
 };
 
 ko.templateEngine.prototype['isTemplateRewritten'] = function (template, templateDocument) {
@@ -4479,7 +4639,7 @@ ko.templateEngine.prototype['rewriteTemplate'] = function (template, rewriterCal
 ko.exportSymbol('templateEngine', ko.templateEngine);
 
 ko.templateRewriting = (function () {
-    var memoizeDataBindingAttributeSyntaxRegex = /(<([a-z]+\d*)(?:\s+(?!data-bind\s*=\s*)[a-z0-9\-]+(?:=(?:\"[^\"]*\"|\'[^\']*\'))?)*\s+)data-bind\s*=\s*(["'])([\s\S]*?)\3/gi;
+    var memoizeDataBindingAttributeSyntaxRegex = /(<([a-z]+\d*)(?:\s+(?!data-bind\s*=\s*)[a-z0-9\-]+(?:=(?:\"[^\"]*\"|\'[^\']*\'|[^>]*))?)*\s+)data-bind\s*=\s*(["'])([\s\S]*?)\3/gi;
     var memoizeVirtualContainerBindingSyntaxRegex = /<!--\s*ko\b\s*([\s\S]*?)\s*-->/g;
 
     function validateDataBindValuesForRewriting(keyValueArray) {
@@ -4720,7 +4880,7 @@ ko.exportSymbol('__tr_ambtns', ko.templateRewriting.applyMemoizedBindingsToNextS
     function executeTemplate(targetNodeOrNodeArray, renderMode, template, bindingContext, options) {
         options = options || {};
         var firstTargetNode = targetNodeOrNodeArray && getFirstNodeFromPossibleArray(targetNodeOrNodeArray);
-        var templateDocument = firstTargetNode && firstTargetNode.ownerDocument;
+        var templateDocument = (firstTargetNode || template || {}).ownerDocument;
         var templateEngineToUse = (options['templateEngine'] || _templateEngine);
         ko.templateRewriting.ensureTemplateIsRewritten(template, templateEngineToUse, templateDocument);
         var renderedNodesArray = templateEngineToUse['renderTemplate'](template, bindingContext, options, templateDocument);
@@ -4826,6 +4986,10 @@ ko.exportSymbol('__tr_ambtns', ko.templateRewriting.applyMemoizedBindingsToNextS
             activateBindingsOnContinuousNodeArray(addedNodesArray, arrayItemContext);
             if (options['afterRender'])
                 options['afterRender'](addedNodesArray, arrayValue);
+
+            // release the "cache" variable, so that it can be collected by
+            // the GC when its value isn't used from within the bindings anymore.
+            arrayItemContext = null;
         };
 
         return ko.dependentObservable(function () {
@@ -4860,6 +5024,17 @@ ko.exportSymbol('__tr_ambtns', ko.templateRewriting.applyMemoizedBindingsToNextS
             if (typeof bindingValue == "string" || bindingValue['name']) {
                 // It's a named template - clear the element
                 ko.virtualElements.emptyNode(element);
+            } else if ('nodes' in bindingValue) {
+                // We've been given an array of DOM nodes. Save them as the template source.
+                // There is no known use case for the node array being an observable array (if the output
+                // varies, put that behavior *into* your template - that's what templates are for), and
+                // the implementation would be a mess, so assert that it's not observable.
+                var nodes = bindingValue['nodes'] || [];
+                if (ko.isObservable(nodes)) {
+                    throw new Error('The "nodes" option must be a plain, non-observable array.');
+                }
+                var container = ko.utils.moveCleanedNodesToContainerElement(nodes); // This also removes the nodes from their current parent
+                new ko.templateSources.anonymousTemplate(element)['nodes'](container);
             } else {
                 // It's an anonymous template - store the element contents, then clear the element
                 var templateNodes = ko.virtualElements.childNodes(element),
@@ -5194,7 +5369,7 @@ ko.nativeTemplateEngine = function () {
 
 ko.nativeTemplateEngine.prototype = new ko.templateEngine();
 ko.nativeTemplateEngine.prototype.constructor = ko.nativeTemplateEngine;
-ko.nativeTemplateEngine.prototype['renderTemplateSource'] = function (templateSource, bindingContext, options) {
+ko.nativeTemplateEngine.prototype['renderTemplateSource'] = function (templateSource, bindingContext, options, templateDocument) {
     var useNodesIfAvailable = !(ko.utils.ieVersion < 9), // IE<9 cloneNode doesn't work properly
         templateNodesFunc = useNodesIfAvailable ? templateSource['nodes'] : null,
         templateNodes = templateNodesFunc ? templateSource['nodes']() : null;
@@ -5203,7 +5378,7 @@ ko.nativeTemplateEngine.prototype['renderTemplateSource'] = function (templateSo
         return ko.utils.makeArray(templateNodes.cloneNode(true).childNodes);
     } else {
         var templateText = templateSource['text']();
-        return ko.utils.parseHtmlFragment(templateText);
+        return ko.utils.parseHtmlFragment(templateText, templateDocument);
     }
 };
 
@@ -5240,7 +5415,8 @@ ko.exportSymbol('nativeTemplateEngine', ko.nativeTemplateEngine);
             return jQueryInstance['tmpl'](compiledTemplate, data, jQueryTemplateOptions);
         }
 
-        this['renderTemplateSource'] = function(templateSource, bindingContext, options) {
+        this['renderTemplateSource'] = function(templateSource, bindingContext, options, templateDocument) {
+            templateDocument = templateDocument || document;
             options = options || {};
             ensureHasReferencedJQueryTemplates();
 
@@ -5259,7 +5435,7 @@ ko.exportSymbol('nativeTemplateEngine', ko.nativeTemplateEngine);
             var jQueryTemplateOptions = jQueryInstance['extend']({ 'koBindingContext': bindingContext }, options['templateOptions']);
 
             var resultNodes = executeTemplate(precompiled, data, jQueryTemplateOptions);
-            resultNodes['appendTo'](document.createElement("div")); // Using "appendTo" forces jQuery/jQuery.tmpl to perform necessary cleanup work
+            resultNodes['appendTo'](templateDocument.createElement("div")); // Using "appendTo" forces jQuery/jQuery.tmpl to perform necessary cleanup work
 
             jQueryInstance['fragments'] = {}; // Clear jQuery's fragment cache to avoid a memory leak after a large number of template renders
             return resultNodes;
diff --git a/examples/knockback/node_modules/todomvc-app-css/index.css b/examples/knockback/node_modules/todomvc-app-css/index.css
index 54d89abda7..ba79a58df3 100644
--- a/examples/knockback/node_modules/todomvc-app-css/index.css
+++ b/examples/knockback/node_modules/todomvc-app-css/index.css
@@ -44,7 +44,7 @@ input[type="checkbox"] {
 	display: none;
 }
 
-#todoapp {
+.todoapp {
 	background: #fff;
 	margin: 130px 0 40px 0;
 	position: relative;
@@ -52,25 +52,25 @@ input[type="checkbox"] {
 	            0 25px 50px 0 rgba(0, 0, 0, 0.1);
 }
 
-#todoapp input::-webkit-input-placeholder {
+.todoapp input::-webkit-input-placeholder {
 	font-style: italic;
 	font-weight: 300;
 	color: #e6e6e6;
 }
 
-#todoapp input::-moz-placeholder {
+.todoapp input::-moz-placeholder {
 	font-style: italic;
 	font-weight: 300;
 	color: #e6e6e6;
 }
 
-#todoapp input::input-placeholder {
+.todoapp input::input-placeholder {
 	font-style: italic;
 	font-weight: 300;
 	color: #e6e6e6;
 }
 
-#todoapp h1 {
+.todoapp h1 {
 	position: absolute;
 	top: -155px;
 	width: 100%;
@@ -83,7 +83,7 @@ input[type="checkbox"] {
 	text-rendering: optimizeLegibility;
 }
 
-#new-todo,
+.new-todo,
 .edit {
 	position: relative;
 	margin: 0;
@@ -104,14 +104,14 @@ input[type="checkbox"] {
 	font-smoothing: antialiased;
 }
 
-#new-todo {
+.new-todo {
 	padding: 16px 16px 16px 60px;
 	border: none;
 	background: rgba(0, 0, 0, 0.003);
 	box-shadow: inset 0 -2px 1px rgba(0,0,0,0.03);
 }
 
-#main {
+.main {
 	position: relative;
 	z-index: 2;
 	border-top: 1px solid #e6e6e6;
@@ -121,7 +121,7 @@ label[for='toggle-all'] {
 	display: none;
 }
 
-#toggle-all {
+.toggle-all {
 	position: absolute;
 	top: -55px;
 	left: -12px;
@@ -131,50 +131,50 @@ label[for='toggle-all'] {
 	border: none; /* Mobile Safari */
 }
 
-#toggle-all:before {
+.toggle-all:before {
 	content: '❯';
 	font-size: 22px;
 	color: #e6e6e6;
 	padding: 10px 27px 10px 27px;
 }
 
-#toggle-all:checked:before {
+.toggle-all:checked:before {
 	color: #737373;
 }
 
-#todo-list {
+.todo-list {
 	margin: 0;
 	padding: 0;
 	list-style: none;
 }
 
-#todo-list li {
+.todo-list li {
 	position: relative;
 	font-size: 24px;
 	border-bottom: 1px solid #ededed;
 }
 
-#todo-list li:last-child {
+.todo-list li:last-child {
 	border-bottom: none;
 }
 
-#todo-list li.editing {
+.todo-list li.editing {
 	border-bottom: none;
 	padding: 0;
 }
 
-#todo-list li.editing .edit {
+.todo-list li.editing .edit {
 	display: block;
 	width: 506px;
 	padding: 13px 17px 12px 17px;
 	margin: 0 0 0 43px;
 }
 
-#todo-list li.editing .view {
+.todo-list li.editing .view {
 	display: none;
 }
 
-#todo-list li .toggle {
+.todo-list li .toggle {
 	text-align: center;
 	width: 40px;
 	/* auto, since non-WebKit browsers doesn't support input styling */
@@ -188,15 +188,15 @@ label[for='toggle-all'] {
 	appearance: none;
 }
 
-#todo-list li .toggle:after {
+.todo-list li .toggle:after {
 	content: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="-10 -18 100 135"><circle cx="50" cy="50" r="50" fill="none" stroke="#ededed" stroke-width="3"/></svg>');
 }
 
-#todo-list li .toggle:checked:after {
+.todo-list li .toggle:checked:after {
 	content: url('data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="-10 -18 100 135"><circle cx="50" cy="50" r="50" fill="none" stroke="#bddad5" stroke-width="3"/><path fill="#5dc2af" d="M72 25L42 71 27 56l-4 4 20 20 34-52z"/></svg>');
 }
 
-#todo-list li label {
+.todo-list li label {
 	white-space: pre;
 	word-break: break-word;
 	padding: 15px 60px 15px 15px;
@@ -206,12 +206,12 @@ label[for='toggle-all'] {
 	transition: color 0.4s;
 }
 
-#todo-list li.completed label {
+.todo-list li.completed label {
 	color: #d9d9d9;
 	text-decoration: line-through;
 }
 
-#todo-list li .destroy {
+.todo-list li .destroy {
 	display: none;
 	position: absolute;
 	top: 0;
@@ -226,27 +226,27 @@ label[for='toggle-all'] {
 	transition: color 0.2s ease-out;
 }
 
-#todo-list li .destroy:hover {
+.todo-list li .destroy:hover {
 	color: #af5b5e;
 }
 
-#todo-list li .destroy:after {
+.todo-list li .destroy:after {
 	content: '×';
 }
 
-#todo-list li:hover .destroy {
+.todo-list li:hover .destroy {
 	display: block;
 }
 
-#todo-list li .edit {
+.todo-list li .edit {
 	display: none;
 }
 
-#todo-list li.editing:last-child {
+.todo-list li.editing:last-child {
 	margin-bottom: -1px;
 }
 
-#footer {
+.footer {
 	color: #777;
 	padding: 10px 15px;
 	height: 20px;
@@ -254,7 +254,7 @@ label[for='toggle-all'] {
 	border-top: 1px solid #e6e6e6;
 }
 
-#footer:before {
+.footer:before {
 	content: '';
 	position: absolute;
 	right: 0;
@@ -269,16 +269,16 @@ label[for='toggle-all'] {
 	            0 17px 2px -6px rgba(0, 0, 0, 0.2);
 }
 
-#todo-count {
+.todo-count {
 	float: left;
 	text-align: left;
 }
 
-#todo-count strong {
+.todo-count strong {
 	font-weight: 300;
 }
 
-#filters {
+.filters {
 	margin: 0;
 	padding: 0;
 	list-style: none;
@@ -287,11 +287,11 @@ label[for='toggle-all'] {
 	left: 0;
 }
 
-#filters li {
+.filters li {
 	display: inline;
 }
 
-#filters li a {
+.filters li a {
 	color: inherit;
 	margin: 3px;
 	padding: 3px 7px;
@@ -300,17 +300,17 @@ label[for='toggle-all'] {
 	border-radius: 3px;
 }
 
-#filters li a.selected,
-#filters li a:hover {
+.filters li a.selected,
+.filters li a:hover {
 	border-color: rgba(175, 47, 47, 0.1);
 }
 
-#filters li a.selected {
+.filters li a.selected {
 	border-color: rgba(175, 47, 47, 0.2);
 }
 
-#clear-completed,
-html #clear-completed:active {
+.clear-completed,
+html .clear-completed:active {
 	float: right;
 	position: relative;
 	line-height: 20px;
@@ -319,11 +319,11 @@ html #clear-completed:active {
 	position: relative;
 }
 
-#clear-completed:hover {
+.clear-completed:hover {
 	text-decoration: underline;
 }
 
-#info {
+.info {
 	margin: 65px auto 0;
 	color: #bfbfbf;
 	font-size: 10px;
@@ -331,17 +331,17 @@ html #clear-completed:active {
 	text-align: center;
 }
 
-#info p {
+.info p {
 	line-height: 1;
 }
 
-#info a {
+.info a {
 	color: inherit;
 	text-decoration: none;
 	font-weight: 400;
 }
 
-#info a:hover {
+.info a:hover {
 	text-decoration: underline;
 }
 
@@ -350,16 +350,16 @@ html #clear-completed:active {
 	Can't use it globally since it destroys checkboxes in Firefox
 */
 @media screen and (-webkit-min-device-pixel-ratio:0) {
-	#toggle-all,
-	#todo-list li .toggle {
+	.toggle-all,
+	.todo-list li .toggle {
 		background: none;
 	}
 
-	#todo-list li .toggle {
+	.todo-list li .toggle {
 		height: 40px;
 	}
 
-	#toggle-all {
+	.toggle-all {
 		-webkit-transform: rotate(90deg);
 		transform: rotate(90deg);
 		-webkit-appearance: none;
@@ -368,11 +368,11 @@ html #clear-completed:active {
 }
 
 @media (max-width: 430px) {
-	#footer {
+	.footer {
 		height: 50px;
 	}
 
-	#filters {
+	.filters {
 		bottom: 10px;
 	}
 }
diff --git a/examples/knockback/node_modules/todomvc-common/base.js b/examples/knockback/node_modules/todomvc-common/base.js
index 44fb50c613..3c6723f390 100644
--- a/examples/knockback/node_modules/todomvc-common/base.js
+++ b/examples/knockback/node_modules/todomvc-common/base.js
@@ -114,7 +114,12 @@
 	})({});
 
 	if (location.hostname === 'todomvc.com') {
-		window._gaq = [['_setAccount','UA-31081062-1'],['_trackPageview']];(function(d,t){var g=d.createElement(t),s=d.getElementsByTagName(t)[0];g.src='//www.google-analytics.com/ga.js';s.parentNode.insertBefore(g,s)}(document,'script'));
+		(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
+		(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+		m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+		})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
+		ga('create', 'UA-31081062-1', 'auto');
+		ga('send', 'pageview');
 	}
 	/* jshint ignore:end */
 
@@ -228,7 +233,7 @@
 			xhr.onload = function (e) {
 				var parsedResponse = JSON.parse(e.target.responseText);
 				if (parsedResponse instanceof Array) {
-					var count = parsedResponse.length
+					var count = parsedResponse.length;
 					if (count !== 0) {
 						issueLink.innerHTML = 'This app has ' + count + ' open issues';
 						document.getElementById('issue-count').style.display = 'inline';
diff --git a/examples/knockback/package.json b/examples/knockback/package.json
index 37fe4db07e..88f78bfbb9 100644
--- a/examples/knockback/package.json
+++ b/examples/knockback/package.json
@@ -1,10 +1,13 @@
 {
   "private": true,
   "dependencies": {
-    "backbone.localStorage": "^1.1.3",
-    "jquery": "^2.0.0",
-    "knockback": "^0.20.5",
-    "todomvc-app-css": "^1.0.0",
-    "todomvc-common": "^1.0.1"
+    "backbone": "^1.2.3",
+    "backbone.localstorage": "^1.1.16",
+    "jquery": "^2.1.4",
+    "knockback": "^1.0.0",
+    "knockout": "^3.3.0",
+    "todomvc-app-css": "^2.0.1",
+    "todomvc-common": "^1.0.2",
+    "underscore": "^1.8.3"
   }
 }
diff --git a/examples/knockback/src/lib/knockout-extended-bindings.coffee b/examples/knockback/src/lib/knockout-extended-bindings.coffee
deleted file mode 100644
index 16d60a6708..0000000000
--- a/examples/knockback/src/lib/knockout-extended-bindings.coffee
+++ /dev/null
@@ -1,15 +0,0 @@
-# Add custom handlers to Knockout.js - adapted from Knockout.js Todos app: https://github.com/ashish01/knockoutjs-todos
-ko.bindingHandlers.dblclick =
-	init: (element, value_accessor) -> $(element).dblclick(ko.utils.unwrapObservable(value_accessor()))
-
-ko.bindingHandlers.block =
-	update: (element, value_accessor) -> element.style.display = if ko.utils.unwrapObservable(value_accessor()) then 'block' else 'none'
-
-ko.bindingHandlers.selectAndFocus =
-	init: (element, value_accessor, all_bindings_accessor) ->
-		ko.bindingHandlers.hasfocus.init(element, value_accessor, all_bindings_accessor)
-		ko.utils.registerEventHandler(element, 'focus', -> element.select())
-
-	update: (element, value_accessor) ->
-		ko.utils.unwrapObservable(value_accessor()) # create dependency
-		_.defer -> ko.bindingHandlers.hasfocus.update(element, value_accessor)
\ No newline at end of file
diff --git a/examples/knockback/src/models/todo.coffee b/examples/knockback/src/models/todo.coffee
deleted file mode 100644
index 532ec781a0..0000000000
--- a/examples/knockback/src/models/todo.coffee
+++ /dev/null
@@ -1,5 +0,0 @@
-class window.Todo extends Backbone.Model
-	completed: (completed) ->
-		return !!@get('completed') if arguments.length is 0 # getter
-
-		@save({completed: if completed then new Date() else null}) # setter
\ No newline at end of file
diff --git a/examples/knockback/src/models/todo_collection.coffee b/examples/knockback/src/models/todo_collection.coffee
index 27aae7adb5..37e37a61da 100644
--- a/examples/knockback/src/models/todo_collection.coffee
+++ b/examples/knockback/src/models/todo_collection.coffee
@@ -1,13 +1,2 @@
 class window.TodoCollection extends Backbone.Collection
 	localStorage: new Store('todos-knockback') # Save all of the todos under the "todos-knockback" namespace.
-	model: Todo
-
-	completedCount: -> @models.reduce(((prev,cur)-> return prev + if cur.completed() then 1 else 0), 0)
-	remainingCount: -> @models.length - @completedCount()
-
-	completeAll: (completed) -> @each((todo) -> todo.completed(completed))
-
-	destroyCompleted: ->
-		completed_tasks = @filter((todo) -> return todo.completed())
-		model.destroy() for model in completed_tasks
-		return
\ No newline at end of file
diff --git a/examples/knockback/src/viewmodels/app.coffee b/examples/knockback/src/viewmodels/app.coffee
index a4eb493631..04633b9ceb 100644
--- a/examples/knockback/src/viewmodels/app.coffee
+++ b/examples/knockback/src/viewmodels/app.coffee
@@ -1,65 +1,43 @@
 ENTER_KEY = 13
 
-window.AppViewModel = ->
-	#############################
-	# Shared
-	#############################
-	# collections
-	@collections =
-		todos: new TodoCollection()
-	@collections.todos.fetch()
-
-	# shared observables
-	@list_filter_mode = ko.observable('')
-	filter_fn = ko.computed =>
-		switch @list_filter_mode()
-			when 'active' then return (model) -> return not model.completed()
-			when 'completed' then return (model) -> return model.completed()
-			else return -> return true
-
-	@todos = kb.collectionObservable(@collections.todos, {view_model: TodoViewModel, filters: filter_fn})
-	@todos_changed = kb.triggeredObservable(@collections.todos, 'change add remove')
-	@tasks_exist = ko.computed(=> @todos_changed(); return !!@collections.todos.length)
-
-	#############################
-	# Header Section
-	#############################
-	@title = ko.observable('')
-	@onAddTodo = (view_model, event) =>
-		return true if not $.trim(@title()) or (event.keyCode != ENTER_KEY)
-
-		# Create task and reset UI
-		@collections.todos.create({title: $.trim(@title())})
+class window.AppViewModel
+	constructor: ->
+		@list_filter_mode = ko.observable('')
+		filter_fn = ko.computed(=>
+			switch @list_filter_mode()
+				when 'active' then return ((model) -> return !model.get('completed'))
+				when 'completed' then return ((model) -> return model.get('completed'))
+				else return (-> return true)
+		)
+		@todos = kb.collectionObservable(new TodoCollection(), TodoViewModel, {filters: filter_fn})
+		@todos.collection().fetch()
+
+		# Note: collectionObservables only track additions and removals so model attribute changes need to be manually triggered
+		@_todos_changed = kb.triggeredObservable(@todos.collection(), 'change add remove')
+		@tasks_exist = ko.computed(=> @_todos_changed(); return !!@todos.collection().models.length)
+
+		@title = ko.observable('')
+
+		@completed_count = ko.computed(=> @_todos_changed(); return @todos.collection().filter((model) -> return model.get('completed')).length)
+		@remaining_count = ko.computed(=> @_todos_changed(); return @todos.collection().length - @completed_count())
+		@all_completed = ko.computed({
+			read: => return not @remaining_count()
+			write: (completed) => @todos.collection().each((model) -> model.save({completed}))
+		})
+
+		@loc =
+			remaining_message: ko.computed(=> return "<strong>#{@remaining_count()}</strong> #{if @remaining_count() == 1 then 'item' else 'items'} left")
+			clear_message: ko.computed(=> return if @completed_count() then 'Clear completed' else '')
+
+		router = new Backbone.Router
+		for route in ['', 'active', 'completed'] then do (route) =>
+			router.route(route, null, => @list_filter_mode(route))
+		Backbone.history.start()
+
+	onAddTodo: (vm, event) =>
+		return if not $.trim(@title()) or (event.keyCode isnt ENTER_KEY)
+
+		@todos.collection().create({title: $.trim(@title())})
 		@title('')
 
-	#############################
-	# Main Section
-	#############################
-	@remaining_count = ko.computed => @todos_changed(); return @collections.todos.remainingCount()
-	@completed_count = ko.computed => @todos_changed(); return @collections.todos.completedCount()
-	@all_completed = ko.computed
-		read: => return not @remaining_count()
-		write: (completed) => @collections.todos.completeAll(completed)
-
-	#############################
-	# Footer Section
-	#############################
-	@onDestroyCompleted = => @collections.todos.destroyCompleted()
-
-	#############################
-	# Localization
-	#############################
-	@loc =
-		remaining_message: ko.computed(=> return "<strong>#{@remaining_count()}</strong> #{if @remaining_count() == 1 then 'item' else 'items'} left")
-		clear_message: ko.computed(=> return if (count = @completed_count()) then "Clear completed (#{count})" else '')
-
-	#############################
-	# Routing
-	#############################
-	router = new Backbone.Router
-	router.route('', null, => @list_filter_mode(''))
-	router.route('active', null, => @list_filter_mode('active'))
-	router.route('completed', null, => @list_filter_mode('completed'))
-	Backbone.history.start()
-
-	return
\ No newline at end of file
+	onClearCompleted: => model.destroy() for model in @todos.collection().filter((model) -> return model.get('completed'))
diff --git a/examples/knockback/src/viewmodels/todo.coffee b/examples/knockback/src/viewmodels/todo.coffee
index 42bd7124bb..3abea16040 100644
--- a/examples/knockback/src/viewmodels/todo.coffee
+++ b/examples/knockback/src/viewmodels/todo.coffee
@@ -1,30 +1,31 @@
-window.TodoViewModel = (model) ->
-	ENTER_KEY = 13
-	ESCAPE_KEY = 27
+ENTER_KEY = 13
+ESCAPE_KEY = 27
 
-	@editing = ko.observable(false)
-	@completed = kb.observable(model, {key: 'completed', read: (-> return model.completed()), write: ((completed) -> model.completed(completed)) }, @)
+class window.TodoViewModel extends kb.ViewModel
+	constructor: (model, options) ->
+		super(model, {requires: ['title', 'completed']}, options)
 
-	@title = kb.observable(model, {
-		key: 'title'
-		write: ((title) =>
-			if $.trim(title) then model.save(title: $.trim(title)) else _.defer(->model.destroy())
-			@editing(false)
-		)
-	}, @)
+		@completed.subscribe((completed) => @model().save({completed}))
+		@edit_title = ko.observable()
+		@editing = ko.observable(false)
+
+	onDestroy: => @model().destroy()
+
+	onCheckEditBegin: =>
+		return if @editing()
 
-	@onDestroyTodo = => model.destroy()
+		@edit_title(@title())
+		@editing(true)
+		$('.todo-input').focus()
 
-	@onCheckEditBegin = =>
-		if not @editing()
-			@editing(true)
-			$('.todo-input').focus()
+	onCheckEditEnd: (vm, event) =>
+		return unless @editing()
 
-	@onCheckEditEnd = (view_model, event) =>
-		if (event.keyCode == ESCAPE_KEY)
+		if (event.keyCode is ESCAPE_KEY)
 			@editing(false)
-		if (event.keyCode == ENTER_KEY) or (event.type == 'blur')
+
+		if (event.keyCode is ENTER_KEY) or (event.type is 'blur')
 			$('.todo-input').blur()
+			title = @edit_title()
+			if $.trim(title) then @model().set({title}).save({title: $.trim(title)}) else _.defer(=>@model().destroy())
 			@editing(false)
-
-	return
\ No newline at end of file
