//     Backbone.js 0.9.2

//     (c) 2010-2012 Jeremy Ashkenas, DocumentCloud Inc.

//     Backbone may be freely distributed under the MIT license.

//     For all details and documentation:

//     http://backbonejs.org

(function(){

  // Initial Setup

  // -------------

  // Save a reference to the global object (`window` in the browser, `global`

  // on the server).

  var root = this;

  // 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 a local reference to slice/splice.

  var slice = Array.prototype.slice;

  var splice = Array.prototype.splice;

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

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

  var Backbone;

  if (typeof exports !== 'undefined') {

    Backbone = exports;

  } else {

    Backbone = root.Backbone = {};

  }

  // Current version of the library. Keep in sync with `package.json`.

  Backbone.VERSION = '0.9.2';

  // Require Underscore, if we're on the server, and it's not already present.

  var _ = root._;

  if (!_ && (typeof require !== 'undefined')) _ = require('underscore');

  // For Backbone's purposes, jQuery, Zepto, or Ender owns the `$` variable.

  var $ = root.jQuery || root.Zepto || root.ender;

  // Set the JavaScript library that will be used for DOM manipulation and

  // Ajax calls (a.k.a. the `$` variable). By default Backbone will use: jQuery,

  // Zepto, or Ender; but the `setDomLibrary()` method lets you inject an

  // alternate JavaScript library (or a mock library for testing your views

  // outside of a browser).

  Backbone.setDomLibrary = function(lib) {

    $ = lib;

  };

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

  // -----------------

  // Regular expression used to split event strings

  var eventSplitter = /\s+/;

  // 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 one or more space separated events, `events`, to a `callback`

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

    on: function(events, callback, context) {

      var calls, event, node, tail, list;

      if (!callback) return this;

      events = events.split(eventSplitter);

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

      // Create an immutable callback list, allowing traversal during

      // modification.  The tail is an empty object that will always be used

      // as the next node.

      while (event = events.shift()) {

        list = calls[event];

        node = list ? list.tail : {};

        node.next = tail = {};

        node.context = context;

        node.callback = callback;

        calls[event] = {tail: tail, next: list ? list.next : node};

      }

      return this;

    },

    // 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 `events` is null, removes all bound callbacks for all events.

    off: function(events, callback, context) {

      var event, calls, node, tail, cb, ctx;

      // No events, or removing *all* events.

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

      if (!(events || callback || context)) {

        delete this._callbacks;

        return this;

      }

      // Loop through the listed events and contexts, splicing them out of the

      // linked list of callbacks if appropriate.

      events = events ? events.split(eventSplitter) : _.keys(calls);

      while (event = events.shift()) {

        node = calls[event];

        delete calls[event];

        if (!node || !(callback || context)) continue;

        // Create a new list, omitting the indicated callbacks.

        tail = node.tail;

        while ((node = node.next) !== tail) {

          cb = node.callback;

          ctx = node.context;

          if ((callback && cb !== callback) || (context && ctx !== context)) {

            this.on(event, cb, ctx);

          }

        }

      }

      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(events) {

      var event, node, calls, tail, args, all, rest;

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

      all = calls.all;

      events = events.split(eventSplitter);

      rest = slice.call(arguments, 1);

      // For each event, walk through the linked list of callbacks twice,

      // first to trigger the event, then to trigger any `"all"` callbacks.

      while (event = events.shift()) {

        if (node = calls[event]) {

          tail = node.tail;

          while ((node = node.next) !== tail) {

            node.callback.apply(node.context || this, rest);

          }

        }

        if (node = all) {

          tail = node.tail;

          args = [event].concat(rest);

          while ((node = node.next) !== tail) {

            node.callback.apply(node.context || this, args);

          }

        }

      }

      return this;

    }

  };

  // Aliases for backwards compatibility.

  Events.bind   = Events.on;

  Events.unbind = Events.off;

  // Backbone.Model

  // --------------

  // Create a new model, with defined attributes. A client id (`cid`)

  // is automatically generated and assigned for you.

  var Model = Backbone.Model = function(attributes, options) {

    var defaults;

    attributes || (attributes = {});

    if (options && options.parse) attributes = this.parse(attributes);

    if (defaults = getValue(this, 'defaults')) {

      attributes = _.extend({}, defaults, attributes);

    }

    if (options && options.collection) this.collection = options.collection;

    this.attributes = {};

    this._escapedAttributes = {};

    this.cid = _.uniqueId('c');

    this.changed = {};

    this._silent = {};

    this._pending = {};

    this.set(attributes, {silent: true});

    // Reset change tracking.

    this.changed = {};

    this._silent = {};

    this._pending = {};

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

    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,

    // A hash of attributes that have silently changed since the last time

    // `change` was called.  Will become pending attributes on the next call.

    _silent: null,

    // A hash of attributes that have changed since the last `'change'` event

    // began.

    _pending: 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);

    },

    // Get the value of an attribute.

    get: function(attr) {

      return this.attributes[attr];

    },

    // Get the HTML-escaped value of an attribute.

    escape: function(attr) {

      var html;

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

      var val = this.get(attr);

      return this._escapedAttributes[attr] = _.escape(val == null ? '' : '' + val);

    },

    // 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"` unless

    // you choose to silence it.

    set: function(key, value, options) {

      var attrs, attr, val;

      // Handle both `"key", value` and `{key: value}` -style arguments.

      if (_.isObject(key) || key == null) {

        attrs = key;

        options = value;

      } else {

        attrs = {};

        attrs[key] = value;

      }

      // Extract attributes and options.

      options || (options = {});

      if (!attrs) return this;

      if (attrs instanceof Model) attrs = attrs.attributes;

      if (options.unset) for (attr in attrs) attrs[attr] = void 0;

      // Run validation.

      if (!this._validate(attrs, options)) return false;

      // Check for changes of `id`.

      if (this.idAttribute in attrs) this.id = attrs[this.idAttribute];

      var changes = options.changes = {};

      var now = this.attributes;

      var escaped = this._escapedAttributes;

      var prev = this._previousAttributes || {};

      // For each `set` attribute...

      for (attr in attrs) {

        val = attrs[attr];

        // If the new and current value differ, record the change.

        if (!_.isEqual(now[attr], val) || (options.unset && _.has(now, attr))) {

          delete escaped[attr];

          (options.silent ? this._silent : changes)[attr] = true;

        }

        // Update or delete the current value.

        options.unset ? delete now[attr] : now[attr] = val;

        // If the new and previous value differ, record the change.  If not,

        // then remove changes for this attribute.

        if (!_.isEqual(prev[attr], val) || (_.has(now, attr) != _.has(prev, attr))) {

          this.changed[attr] = val;

          if (!options.silent) this._pending[attr] = true;

        } else {

          delete this.changed[attr];

          delete this._pending[attr];

        }

      }

      // Fire the `"change"` events.

      if (!options.silent) this.change(options);

      return this;

    },

    // Remove an attribute from the model, firing `"change"` unless you choose

    // to silence it. `unset` is a noop if the attribute doesn't exist.

    unset: function(attr, options) {

      (options || (options = {})).unset = true;

      return this.set(attr, null, options);

    },

    // Clear all attributes on the model, firing `"change"` unless you choose

    // to silence it.

    clear: function(options) {

      (options || (options = {})).unset = true;

      return this.set(_.clone(this.attributes), options);

    },

    // Fetch the model from the server. If the server's representation of the

    // model differs from its current attributes, they will be overriden,

    // triggering a `"change"` event.

    fetch: function(options) {

      options = options ? _.clone(options) : {};

      var model = this;

      var success = options.success;

      options.success = function(resp, status, xhr) {

        if (!model.set(model.parse(resp, xhr), options)) return false;

        if (success) success(model, resp);

      };

      options.error = Backbone.wrapError(options.error, model, options);

      return (this.sync || Backbone.sync).call(this, '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, value, options) {

      var attrs, current;

      // Handle both `("key", value)` and `({key: value})` -style calls.

      if (_.isObject(key) || key == null) {

        attrs = key;

        options = value;

      } else {

        attrs = {};

        attrs[key] = value;

      }

      options = options ? _.clone(options) : {};

      // If we're "wait"-ing to set changed attributes, validate early.

      if (options.wait) {