Synnefo

  // Save the previous value of the `Backbone` variable.

  var previousBackbone = root.Backbone;

  // The top-level namespace. All public Backbone classes and modules will

  // be attached to this. Exported for both CommonJS and the browser.

  var Backbone;

    // Passing `"all"` will bind the callback to all events fired.

    bind : function(ev, callback, context) {

      var calls = this._callbacks || (this._callbacks = {});

      return this;

    },

    // callbacks for the event. If `ev` is null, removes all bound callbacks

    // for all events.

    unbind : function(ev, callback) {

      if (!ev) {

      } else if (calls = this._callbacks) {

        if (!callback) {

          }

        }

      }

    // same arguments as `trigger` is, apart from the event name.

    // Listening for `"all"` passes the true event name as the first argument.

    trigger : function(eventName) {

      if (!(calls = this._callbacks)) return this;

      }

      return this;

    }

  // Attach all inheritable methods to the Model prototype.

  _.extend(Backbone.Model.prototype, Backbone.Events, {

    // Has the item been changed since the last `"change"` event?

    _changed : false,

      var html;

      if (html = this._escapedAttributes[attr]) return html;

      var val = this.attributes[attr];

    },

    // Returns `true` if the attribute contains a value that is not null

      validObj[attr] = void 0;

      if (!options.silent && this.validate && !this._performValidation(validObj, options)) return false;

      // Remove the attribute.

      delete this.attributes[attr];

      delete this._escapedAttributes[attr];

    change : function(options) {

      this.trigger('change', this, options);

      this._previousAttributes = _.clone(this.attributes);

      this._changed = false;

    },

    // 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

    changedAttributes : function(now) {

      now || (now = this.attributes);

      var changed = false;

      for (var attr in now) {

        if (!_.isEqual(old[attr], now[attr])) {

          changed[attr] = now[attr];

        }

      }

      return changed;

    },

    },

    // Get the model at the given index.

      return this.models[index];

    },

    // Proxy to _'s chain. Can't be proxied the same way the rest of the

    // underscore methods are proxied because it relies on the underscore

    // constructor.

      return _(this.models).chain();

    },

    },

    // Prepare a model to be added to this collection

      if (!(model instanceof Backbone.Model)) {

        var attrs = model;

        model = new this.model(attrs, {collection: this});

      } else if (!model.collection) {

        model.collection = this;

      }

      this.models.splice(index, 0, model);

      model.bind('all', this._onModelEvent);

      this.length++;

      if (!options.silent) model.trigger('add', model, this, options);

      return model;

    },

      if (!model) return null;

      delete this._byId[model.id];

      delete this._byCid[model.cid];

      this.length--;

      if (!options.silent) model.trigger('remove', model, this, options);

      this._removeReference(model);

      return model;

      if (!_.isRegExp(route)) route = this._routeToRegExp(route);

      Backbone.history.route(route, _.bind(function(fragment) {

        var args = this._extractParameters(route, fragment);

        this.trigger.apply(this, ['route:' + name].concat(args));

      }, this));

    },

          fragment = window.location.pathname;

          var search = window.location.search;

          if (search) fragment += search;

        } else {

          fragment = window.location.hash;

        }

      }

    },

    // Start the hash change handling, returning `true` if the current URL matches

  // This should be prefered to global lookups, if you're dealing with

  // a specific view.

  var selectorDelegate = function(selector) {

  };

  // Cached regex to split keys for `delegate`.

      return el;

    },

    //

    // *{"event selector": "callback"}*

    //

    delegateEvents : function(events) {

      if (!(events || (events = this.events))) return;

      if (_.isFunction(events)) events = events.call(this);

      for (var key in events) {

        var method = this[events[key]];

        if (!method) throw new Error('Event "' + events[key] + '" does not exist');

      }

    },

    // Performs the initial configuration of a View with a set of options.

    // Keys with special meaning *(model, collection, id, className)*, are

    // attached directly to the view.

  // 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

  // to the model's `url()`. Some possible customizations could be:

  //

  // * Use `setTimeout` to batch rapid-fire updates into a single request.

    var type = methodMap[method];

    // Default JSON-request options.

    // Ensure that we have a URL.

      params.url = getUrl(model, options) || urlError();

    }

    // Ensure that we have the appropriate request data.

      params.contentType = 'application/json';

      params.data = JSON.stringify(model.toJSON());

    }

    // For older servers, emulate JSON by encoding the request into an HTML-form.

    if (Backbone.emulateJSON) {

      params.contentType = 'application/x-www-form-urlencoded';

    }

    // For older servers, emulate HTTP by mimicking the HTTP method with `_method`

    if (params.type !== 'GET' && !Backbone.emulateJSON) {

      params.processData = false;

    }

  };

  // Helpers

  };

  // Wrap an optional error callback with a fallback error event.

      if (onError) {

        onError(model, resp, options);

      } else {

    };

  };

}).call(this);