/*global log4javascript*/
(function () {/*
    json2.js
    2013-05-26

    Public Domain.

    NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.

    See http://www.JSON.org/js.html

    This code should be minified before deployment.
    See http://javascript.crockford.com/jsmin.html

    USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO
    NOT CONTROL.

    This file creates a global JSON object containing two methods: stringify
    and parse.

        JSON.stringify(value, replacer, space)
            value       any JavaScript value, usually an object or array.

            replacer    an optional parameter that determines how object
                        values are stringified for objects. It can be a
                        function or an array of strings.

            space       an optional parameter that specifies the indentation
                        of nested structures. If it is omitted, the text will
                        be packed without extra whitespace. If it is a number,
                        it will specify the number of spaces to indent at each
                        level. If it is a string (such as '\t' or '&nbsp;'),
                        it contains the characters used to indent at each level.

            This method produces a JSON text from a JavaScript value.

            When an object value is found, if the object contains a toJSON
            method, its toJSON method will be called and the result will be
            stringified. A toJSON method does not serialize: it returns the
            value represented by the name/value pair that should be serialized,
            or undefined if nothing should be serialized. The toJSON method
            will be passed the key associated with the value, and this will be
            bound to the value

            For example, this would serialize Dates as ISO strings.

                Date.prototype.toJSON = function (key) {
                    function f(n) {
                        // Format integers to have at least two digits.
                        return n < 10 ? '0' + n : n;
                    }

                    return this.getUTCFullYear()   + '-' +
                         f(this.getUTCMonth() + 1) + '-' +
                         f(this.getUTCDate())      + 'T' +
                         f(this.getUTCHours())     + ':' +
                         f(this.getUTCMinutes())   + ':' +
                         f(this.getUTCSeconds())   + 'Z';
                };

            You can provide an optional replacer method. It will be passed the
            key and value of each member, with this bound to the containing
            object. The value that is returned from your method will be
            serialized. If your method returns undefined, then the member will
            be excluded from the serialization.

            If the replacer parameter is an array of strings, then it will be
            used to select the members to be serialized. It filters the results
            such that only members with keys listed in the replacer array are
            stringified.

            Values that do not have JSON representations, such as undefined or
            functions, will not be serialized. Such values in objects will be
            dropped; in arrays they will be replaced with null. You can use
            a replacer function to replace those with JSON values.
            JSON.stringify(undefined) returns undefined.

            The optional space parameter produces a stringification of the
            value that is filled with line breaks and indentation to make it
            easier to read.

            If the space parameter is a non-empty string, then that string will
            be used for indentation. If the space parameter is a number, then
            the indentation will be that many spaces.

            Example:

            text = JSON.stringify(['e', {pluribus: 'unum'}]);
            // text is '["e",{"pluribus":"unum"}]'

            text = JSON.stringify(['e', {pluribus: 'unum'}], null, '\t');
            // text is '[\n\t"e",\n\t{\n\t\t"pluribus": "unum"\n\t}\n]'

            text = JSON.stringify([new Date()], function (key, value) {
                return this[key] instanceof Date ?
                    'Date(' + this[key] + ')' : value;
            });
            // text is '["Date(---current time---)"]'

        JSON.parse(text, reviver)
            This method parses a JSON text to produce an object or array.
            It can throw a SyntaxError exception.

            The optional reviver parameter is a function that can filter and
            transform the results. It receives each of the keys and values,
            and its return value is used instead of the original value.
            If it returns what it received, then the structure is not modified.
            If it returns undefined then the member is deleted.

            Example:

            // Parse the text. Values that look like ISO date strings will
            // be converted to Date objects.

            myData = JSON.parse(text, function (key, value) {
                var a;
                if (typeof value === 'string') {
                    a =
/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
                    if (a) {
                        return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4],
                            +a[5], +a[6]));
                    }
                }
                return value;
            });

            myData = JSON.parse('["Date(09/09/2001)"]', function (key, value) {
                var d;
                if (typeof value === 'string' &&
                        value.slice(0, 5) === 'Date(' &&
                        value.slice(-1) === ')') {
                    d = new Date(value.slice(5, -1));
                    if (d) {
                        return d;
                    }
                }
                return value;
            });

    This is a reference implementation. You are free to copy, modify, or
    redistribute.
*/

/*jslint evil: true, regexp: true */

/*members "", "\b", "\t", "\n", "\f", "\r", "\"", JSON, "\\", apply,
    call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours,
    getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join,
    lastIndex, length, parse, prototype, push, replace, slice, stringify,
    test, toJSON, toString, valueOf
*/

// Create a JSON object only if one does not already exist. We create the
// methods in a closure to avoid creating global variables.

  if (typeof JSON !== 'object') {
    // eslint-disable-next-line no-global-assign
    JSON = {};
  }

/*global define*/
  define('json-ie7',['require'],function(require) {

    function f(n) {
        // Format integers to have at least two digits.
      return n < 10 ? '0' + n : n;
    }

    if (typeof Date.prototype.toJSON !== 'function') {

      Date.prototype.toJSON = function () {

        return isFinite(this.valueOf())
                ? this.getUTCFullYear() + '-' +
                    f(this.getUTCMonth() + 1) + '-' +
                    f(this.getUTCDate()) + 'T' +
                    f(this.getUTCHours()) + ':' +
                    f(this.getUTCMinutes()) + ':' +
                    f(this.getUTCSeconds()) + 'Z'
                : null;
      };

      String.prototype.toJSON =
            Number.prototype.toJSON =
            Boolean.prototype.toJSON = function () {
              return this.valueOf();
            };
    }

    // eslint-disable-next-line no-control-regex
    var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
    // eslint-disable-next-line no-control-regex
      escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
      gap,
      indent,
      meta = {    // table of character substitutions
        '\b': '\\b',
        '\t': '\\t',
        '\n': '\\n',
        '\f': '\\f',
        '\r': '\\r',
        '"' : '\\"',
        '\\': '\\\\'
      },
      rep;

    function quote(string) {

// If the string contains no control characters, no quote characters, and no
// backslash characters, then we can safely slap some quotes around it.
// Otherwise we must also replace the offending characters with safe escape
// sequences.

      escapable.lastIndex = 0;
      return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
        var c = meta[a];
        return typeof c === 'string'
                ? c
                : '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
      }) + '"' : '"' + string + '"';
    }

    function str(key, holder) {

// Produce a string from holder[key].

      var i,          // The loop counter.
        k,          // The member key.
        v,          // The member value.
        length,
        mind = gap,
        partial,
        value = holder[key];

// If the value has a toJSON method, call it to obtain a replacement value.

      if (value && typeof value === 'object' &&
                typeof value.toJSON === 'function') {
        value = value.toJSON(key);
      }

// If we were called with a replacer function, then call the replacer to
// obtain a replacement value.

      if (typeof rep === 'function') {
        value = rep.call(holder, key, value);
      }

// What happens next depends on the value's type.

      switch (typeof value) {
      case 'string':
        return quote(value);

      case 'number':

// JSON numbers must be finite. Encode non-finite numbers as null.

        return isFinite(value) ? String(value) : 'null';

      case 'boolean':
      case 'null':

// If the value is a boolean or null, convert it to a string. Note:
// typeof null does not produce 'null'. The case is included here in
// the remote chance that this gets fixed someday.

        return String(value);

// If the type is 'object', we might be dealing with an object or an array or
// null.

      case 'object':

// Due to a specification blunder in ECMAScript, typeof null is 'object',
// so watch out for that case.

        if (!value) {
          return 'null';
        }

// Make an array to hold the partial results of stringifying this object value.

        gap += indent;
        partial = [];

// Is the value an array?

        if (Object.prototype.toString.apply(value) === '[object Array]') {

// The value is an array. Stringify every element. Use null as a placeholder
// for non-JSON values.

          length = value.length;
          for (i = 0; i < length; i += 1) {
            partial[i] = str(i, value) || 'null';
          }

// Join all of the elements together, separated with commas, and wrap them in
// brackets.

          v = partial.length === 0
                    ? '[]'
                    : gap
                    ? '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']'
                    : '[' + partial.join(',') + ']';
          gap = mind;
          return v;
        }

// If the replacer is an array, use it to select the members to be stringified.

        if (rep && typeof rep === 'object') {
          length = rep.length;
          for (i = 0; i < length; i += 1) {
            if (typeof rep[i] === 'string') {
              k = rep[i];
              v = str(k, value);
              if (v) {
                partial.push(quote(k) + (gap ? ': ' : ':') + v);
              }
            }
          }
        } else {

// Otherwise, iterate through all of the keys in the object.

          for (k in value) {
            if (Object.prototype.hasOwnProperty.call(value, k)) {
              v = str(k, value);
              if (v) {
                partial.push(quote(k) + (gap ? ': ' : ':') + v);
              }
            }
          }
        }

// Join all of the member texts together, separated with commas,
// and wrap them in braces.

        v = partial.length === 0
                ? '{}'
                : gap
                ? '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}'
                : '{' + partial.join(',') + '}';
        gap = mind;
        return v;
      }
    }

// If the JSON object does not yet have a stringify method, give it one.

    if (typeof JSON.stringify !== 'function') {
      JSON.stringify = function (value, replacer, space) {

// The stringify method takes a value and an optional replacer, and an optional
// space parameter, and returns a JSON text. The replacer can be a function
// that can replace values, or an array of strings that will select the keys.
// A default replacer method can be provided. Use of the space parameter can
// produce text that is more easily readable.

        var i;
        gap = '';
        indent = '';

// If the space parameter is a number, make an indent string containing that
// many spaces.

        if (typeof space === 'number') {
          for (i = 0; i < space; i += 1) {
            indent += ' ';
          }

// If the space parameter is a string, it will be used as the indent string.

        } else if (typeof space === 'string') {
          indent = space;
        }

// If there is a replacer, it must be a function or an array.
// Otherwise, throw an error.

        rep = replacer;
        if (replacer && typeof replacer !== 'function' &&
                    (typeof replacer !== 'object' ||
                    typeof replacer.length !== 'number')) {
          throw new Error('JSON.stringify');
        }

// Make a fake root object containing our value under the key of ''.
// Return the result of stringifying the value.

        return str('', {'': value});
      };
    }

// If the JSON object does not yet have a parse method, give it one.

    if (typeof JSON.parse !== 'function') {
      JSON.parse = function (text, reviver) {

// The parse method takes a text and an optional reviver function, and returns
// a JavaScript value if the text is a valid JSON text.

        var j;

        function walk(holder, key) {

// The walk method is used to recursively walk the resulting structure so
// that modifications can be made.

          var k, v, value = holder[key];
          if (value && typeof value === 'object') {
            for (k in value) {
              if (Object.prototype.hasOwnProperty.call(value, k)) {
                v = walk(value, k);
                if (v !== undefined) {
                  value[k] = v;
                } else {
                  delete value[k];
                }
              }
            }
          }
          return reviver.call(holder, key, value);
        }

// Parsing happens in four stages. In the first stage, we replace certain
// Unicode characters with escape sequences. JavaScript handles many characters
// incorrectly, either silently deleting them, or treating them as line endings.

        text = String(text);
        cx.lastIndex = 0;
        if (cx.test(text)) {
          text = text.replace(cx, function (a) {
            return '\\u' +
                        ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
          });
        }

// In the second stage, we run the text against regular expressions that look
// for non-JSON patterns. We are especially concerned with '()' and 'new'
// because they can cause invocation, and '=' because it can cause mutation.
// But just to be safe, we want to reject all unexpected forms.

// We split the second stage into 4 regexp operations in order to work around
// crippling inefficiencies in IE's and Safari's regexp engines. First we
// replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
// replace all simple value tokens with ']' characters. Third, we delete all
// open brackets that follow a colon or comma or that begin the text. Finally,
// we look to see that the remaining characters are only whitespace or ']' or
// ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.

        if (/^[\],:{}\s]*$/
                    .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
                        .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
                        .replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {

// In the third stage we use the eval function to compile the text into a
// JavaScript structure. The '{' operator is subject to a syntactic ambiguity
// in JavaScript: it can begin a block or an object literal. We wrap the text
// in parens to eliminate the ambiguity.

          j = eval('(' + text + ')');

// In the optional fourth stage, we recursively walk the new structure, passing
// each name/value pair to a reviver function for possible transformation.

          return typeof reviver === 'function'
                    ? walk({'': j}, '')
                    : j;
        }

// If the text is not JSON parseable, then a SyntaxError is thrown.

        throw new SyntaxError('JSON.parse');
      };
    }
  });

/*global define*/
  define('chiropractor/views/base',['require','underscore','json-ie7','jquery','backbone','handlebars'],function(require) {

    var _ = require('underscore'),
      JSON = require('json-ie7'),
      $ = require('jquery'),
      Backbone = require('backbone'),
      Handlebars = require('handlebars'),
      removeHandlerTest = $('<span></span>'),
      removeHandlerExists = false,
      placeholderId;

    removeHandlerTest.on('remove', function() { removeHandlerExists = true; });
    removeHandlerTest.remove();

    if (!removeHandlerExists) {
      $.event.special.remove = {
        remove: function(e) {
          if (e.handler) {
            var $el = $(this);
                    // Since this event gets fired on calling $el.off('remove')
                    // as well as when the $el.remove() gets called, we need to
                    // allow the Backbone View to unregister this without
                    // firing it.
            if (!$el.hasClass('removedEventFired')) {
              $el.addClass('removedEventFired');
              e.handler.call(this, new $.Event('remove', {target: this}));
            }
          }
        }
      };
    }

    placeholderId = function(view) {
      return 'chiropractorId' + view.cid;
    };

    return Backbone.View.extend({
      initialize: function(options) {
        options = options || {};
        Backbone.View.prototype.initialize.call(this, options);

        _.bindAll(this, 'remove');

        this._childViews = [];
        this._context = options.context || {};

        this.$el.on('remove', this.remove);
      },

      _addChild: function(view) {
        this._childViews.push(view);
        return '<' + view.el.tagName +
                ' id="' + placeholderId(view) + '"></div>';
      },

      context: function() {
        return {
          model: this.model,
          collection: this.collection
        };
      },

      render: function() {
        var template = typeof(this.template) === 'string' ?
                    Handlebars.compile(this.template) : this.template,
          context = typeof(this.context) === 'function' ?
                    this.context() : this.context;

        context.declaringView = this;
        _.defaults(context, this._context);

        if (template) {
          this.$el.html(template(context));
        }

        _(this._childViews).each(function(view) {
          this.$('#' + placeholderId(view)).replaceWith(view.el);
        }, this);
        return this;
      },

      remove: function() {
        this.$el.addClass('removedEventFired');
        this.$el.off('remove', this.remove);
        _(this._childViews).each(function(view) {
          view.remove();
        });
        this._childViews = [];
        Backbone.View.prototype.remove.apply(this, arguments);
      }
    });
  });

/*global define*/
  define('chiropractor/views/form',['require','underscore','json-ie7','jquery','backbone','./base'],function(require) {

    var _ = require('underscore'),
      JSON = require('json-ie7'),
      $ = require('jquery'),
      Backbone = require('backbone'),
      Base = require('./base');

    return Base.extend({
      initialize: function() {
        Base.prototype.initialize.apply(this, arguments);
        this.listenForErrors(this.model);
        this.listenForErrors(this.collection);
      },

      listenForErrors: function(obj) {
        if (obj) {
          if (obj instanceof Backbone.Model) {
            this.listenTo(obj, 'invalid', this.renderFormErrors);
            this.listenTo(obj, 'change', this.clearFormErrors);
          } else if (obj instanceof Backbone.Collection) {
            obj.each(function(model) {
              this.listenTo(model, 'invalid', this.renderFormErrors);
              this.listenTo(model, 'change', this.clearFormErrors);
            }, this);
          } else {
            throw new Error('Invalid object to associate errors with.');
          }
        }
      },

      clearFormErrors: function(model) {
        _(model.changed).each(function(value, field) {
          this.$('#container-' + model.fieldId(field))
                    .find('.help-inline').html('');
        }, this);
      },

      renderFormErrors: function(model, errors) {
        _(errors).each(function(errorMessages, field) {
          var help;
          errorMessages = typeof(errorMessages) === 'string' ?
                    [errorMessages] : errorMessages;

          if (field === '__all__') {
            help = $('<div class="errors"></div>');
            this.$el.prepend(help);
          } else {
            help = this.$('#container-' + model.fieldId(field))
                        .find('.help-inline');
          }

          help.html(errorMessages.join(', '));
        }, this);
      }
    });
  });

/* START_TEMPLATE */
  define('hbs!chiropractor/views/templates/fields/label',['hbs','handlebars'], function( hbs, Handlebars ) { 
    var t = Handlebars.template(function (Handlebars,depth0,helpers,partials,data) {
      helpers = helpers || Handlebars.helpers;
      var stack1, foundHelper, functionType="function", escapeExpression=this.escapeExpression;

      foundHelper = helpers.value;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.value; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      return escapeExpression(stack1);
    });
    Handlebars.registerPartial('chiropractor_views_templates_fields_label', t);
    return t;
  });
/* END_TEMPLATE */

/*global define*/
  define('chiropractor/views/field',['require','json-ie7','jquery','underscore','handlebars','hbs!./templates/fields/label'],function(require) {

    var JSON = require('json-ie7'),
      $ = require('jquery'),
      _ = require('underscore'),
      Handlebars = require('handlebars'),
      fieldTemplates = {},
      label = require('hbs!./templates/fields/label');

    fieldTemplates = {
      'defaults': label
    };

    Handlebars.registerHelper('field', function(type, model, fieldName) {
            // template helper in the form of:
            //
            //      {{ field 'text' model 'fieldname' [attrName="attrValue"]*}}
      var template = fieldTemplates[type],
        options = arguments[arguments.length - 1],
        opts = options.hash || {},
        field = opts.field,
        id = '',
        value = '';

      if (!template) {
        template = fieldTemplates.defaults;
      }

      if (model) {
        id = model.fieldId(fieldName);
                //console.log(model);
        if (field) {
          value = model.get(field.id);
        }
      }

      _.defaults(opts, {
        id: id,
        label: fieldName,
        name: fieldName,
        options: [],
        blank: false,
        value: value,
        help: '',
        model: model
      });
      return new Handlebars.SafeString(template(opts));
    });

    return {
      Templates: fieldTemplates,
      addTemplate: function(name,template) {
        fieldTemplates[name] = template;
      }
    };
  });

/* START_TEMPLATE */
  define('hbs!chiropractor/views/templates/row/row',['hbs','handlebars'], function( hbs, Handlebars ) { 
    var t = Handlebars.template(function (Handlebars,depth0,helpers,partials,data) {
      helpers = helpers || Handlebars.helpers;
      var buffer = "", stack1, foundHelper, helperMissing=helpers.helperMissing, escapeExpression=this.escapeExpression, functionType="function", self=this;

      function program1(depth0,data,depth1) {
  
        var buffer = "", stack1, stack2, stack3, foundHelper;
        buffer += "\r\n    <td>";
        stack1 = depth1.model;
        stack2 = depth0.fieldtype;
        stack3 = {};
        stack3['field'] = depth0;
        foundHelper = helpers.field;
        stack1 = foundHelper ? foundHelper.call(depth0, stack2, stack1, {hash:stack3}) : helperMissing.call(depth0, "field", stack2, stack1, {hash:stack3});
        buffer += escapeExpression(stack1) + "</td>\r\n  ";
        return buffer;
      }

      buffer += "<tr class=\"";
      foundHelper = helpers.rowclass;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.rowclass; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\">\r\n  ";
      stack1 = depth0.options;
      stack1 = stack1 == null || stack1 === false ? stack1 : stack1.fields;
      stack1 = helpers.each.call(depth0, stack1, {hash:{},inverse:self.noop,fn:self.programWithDepth(program1, data, depth0)});
      if (stack1 || stack1 === 0) { buffer += stack1; }
      buffer += "\r\n</tr>";
      return buffer;
    });
    Handlebars.registerPartial('chiropractor_views_templates_row_row', t);
    return t;
  });
/* END_TEMPLATE */

/* START_TEMPLATE */
  define('hbs!chiropractor/views/templates/row/error_messagebox',['hbs','handlebars'], function( hbs, Handlebars ) { 
    var t = Handlebars.template(function (Handlebars,depth0,helpers,partials,data) {
      helpers = helpers || Handlebars.helpers;
      var buffer = "", stack1, functionType="function", escapeExpression=this.escapeExpression;

      buffer += "<div id=\"chiropractor-error-box\" style=\"color: #a94442;background-color: #f2dede;border-color: #ebccd1;padding: 15px;border: 1px solid transparent;border-radius: 4px;\">\r\n<div aria-hidden=\"true\" style=\"float:right;\" onClick=\"javascript:var element = document.getElementById('chiropractor-error-box');element.parentNode.removeChild(element);\">&times;</div>\r\n<div style=\"font-weight:bold\">";
      stack1 = depth0.model;
      stack1 = stack1 == null || stack1 === false ? stack1 : stack1.errorMessage;
      stack1 = typeof stack1 === functionType ? stack1() : stack1;
      buffer += escapeExpression(stack1) + "</div>\r\n<div>Message: ";
      stack1 = depth0.model;
      stack1 = stack1 == null || stack1 === false ? stack1 : stack1.response;
      stack1 = stack1 == null || stack1 === false ? stack1 : stack1.responseText;
      stack1 = typeof stack1 === functionType ? stack1() : stack1;
      buffer += escapeExpression(stack1) + "</div>\r\n<div>Status: ";
      stack1 = depth0.model;
      stack1 = stack1 == null || stack1 === false ? stack1 : stack1.response;
      stack1 = stack1 == null || stack1 === false ? stack1 : stack1.statusText;
      stack1 = typeof stack1 === functionType ? stack1() : stack1;
      buffer += escapeExpression(stack1) + "</div>\r\n<div>StatusCode: ";
      stack1 = depth0.model;
      stack1 = stack1 == null || stack1 === false ? stack1 : stack1.response;
      stack1 = stack1 == null || stack1 === false ? stack1 : stack1.status;
      stack1 = typeof stack1 === functionType ? stack1() : stack1;
      buffer += escapeExpression(stack1) + "</div>\r\n<div>Url: <a href=\"";
      stack1 = depth0.model;
      stack1 = stack1 == null || stack1 === false ? stack1 : stack1.url;
      stack1 = typeof stack1 === functionType ? stack1() : stack1;
      buffer += escapeExpression(stack1) + "\">";
      stack1 = depth0.model;
      stack1 = stack1 == null || stack1 === false ? stack1 : stack1.url;
      stack1 = typeof stack1 === functionType ? stack1() : stack1;
      buffer += escapeExpression(stack1) + "</a></div>\r\n</div>";
      return buffer;
    });
    Handlebars.registerPartial('chiropractor_views_templates_row_error_messagebox', t);
    return t;
  });
/* END_TEMPLATE */

/*global define*/
  define('chiropractor/views/row',['require','json-ie7','jquery','underscore','handlebars','hbs!./templates/row/row','hbs!./templates/row/error_messagebox'],function(require) {

    var JSON = require('json-ie7'),
      $ = require('jquery'),
      _ = require('underscore'),
      Handlebars = require('handlebars'),
      RowTemplates = {},
      Row = require('hbs!./templates/row/row'),
      ErrorTemplate = require('hbs!./templates/row/error_messagebox');

    RowTemplates = {
      'row': Row,
      'error': ErrorTemplate
    };

    Handlebars.registerHelper('row', function(type, model, fieldName) {
            // template helper in the form of:
            //
            //      {{ field 'text' model 'fieldname' [attrName="attrValue"]*}}
      var current = RowTemplates[type],
        options = arguments[arguments.length - 1],
        opts = options.hash || {},
        id = '',
        value = '';

      if (!current) {
        throw new Error('Unregistered field template: ' + type);
      }
            //console.log(opt);
      return new Handlebars.SafeString(current({ model: model, options: opts }));
    });

    return {
      Templates: RowTemplates,
      addTemplate: function(name,template) {
        RowTemplates[name] = template;
      }
    };
  });

/*global define*/
  define('chiropractor/hbs/view',['require','underscore','backbone','handlebars'],function(require) {

    var _ = require('underscore'),
      Backbone = require('backbone'),
      Handlebars = require('handlebars'),
      view;

    view = function() {
        // template helper in the form of:
        //
        //      {{ view "path/to/require/module[|ViewName]" [viewOptions] [context] [viewOption1=val viewOption2=val]}}
      var View, view, options, requirePath,
        viewName, attrs, requireBits, placeholder,
        context = {};

      options = arguments[arguments.length - 1];
      attrs = arguments[1] || {};
      _.defaults(attrs, options.hash || {});

      if (arguments.length === 4) {
        context = arguments[2];
      }
      _.defaults(this, context);

      if (typeof(arguments[0]) === 'string') {
        requireBits = arguments[0].split('|');
        requirePath = requireBits[0];
        viewName = requireBits[1];

        View = require(requirePath);
        if (typeof(viewName) === 'string') {
          View = View[viewName];
        }
      } else {
        View = arguments[0];
      }

      if (options.fn) {
        View = View.extend({
          template: options.fn
        });
      }

      view = new View(attrs).render();

      placeholder = this.declaringView._addChild(view);

        // Return a placeholder that the Chiropractor.View can replace with
        // the child view appended above.
        // If this is called as a block hbs helper, then we do not need to
        // use safe string, while as a hbs statement it needs to be declared
        // safe.
      if (options.fn) {
        return placeholder;
      } else {
        return new Handlebars.SafeString(placeholder);
      }
    };

    Handlebars.registerHelper('view', view);

    return view;
  });

/* START_TEMPLATE */
  define('hbs!chiropractor/views/templates/formfield/text',['hbs','handlebars'], function( hbs, Handlebars ) { 
    var t = Handlebars.template(function (Handlebars,depth0,helpers,partials,data) {
      helpers = helpers || Handlebars.helpers;
      var buffer = "", stack1, foundHelper, functionType="function", escapeExpression=this.escapeExpression;

      buffer += "<div class=\"control-group\" id=\"container-";
      foundHelper = helpers.id;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\">\r\n    <label class=\"control-label ";
      foundHelper = helpers.labelclass;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.labelclass; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\" for=\"";
      foundHelper = helpers.id;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\">";
      foundHelper = helpers.label;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.label; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "</label>\r\n    <div class=\"controls\">\r\n        <input type=\"text\" placeholder=\"";
      foundHelper = helpers.placeholder;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.placeholder; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\" id=\"";
      foundHelper = helpers.id;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\" name=\"";
      foundHelper = helpers.name;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\" value=\"";
      foundHelper = helpers.value;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.value; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\" class=\"";
      foundHelper = helpers['class'];
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0['class']; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\" />\r\n        <span class=\"description\">";
      foundHelper = helpers.description;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.description; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "</span>\r\n        <span class=\"help-inline\">";
      foundHelper = helpers.help;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.help; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "</span>\r\n    </div>\r\n</div>\r\n";
      return buffer;
    });
    Handlebars.registerPartial('chiropractor_views_templates_formfield_text', t);
    return t;
  });
/* END_TEMPLATE */

/* START_TEMPLATE */
  define('hbs!chiropractor/views/templates/formfield/textarea',['hbs','handlebars'], function( hbs, Handlebars ) { 
    var t = Handlebars.template(function (Handlebars,depth0,helpers,partials,data) {
      helpers = helpers || Handlebars.helpers;
      var buffer = "", stack1, foundHelper, functionType="function", escapeExpression=this.escapeExpression;

      buffer += "<div class=\"control-group\" id=\"container-";
      foundHelper = helpers.id;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\">\r\n    <label class=\"control-label\" for=\"";
      foundHelper = helpers.id;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\">";
      foundHelper = helpers.label;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.label; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "</label>\r\n    <div class=\"controls\">\r\n        <textarea id=\"";
      foundHelper = helpers.id;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\" name=\"";
      foundHelper = helpers.name;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\">";
      foundHelper = helpers.value;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.value; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "</textarea>\r\n        <span class=\"help-inline\">";
      foundHelper = helpers.help;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.help; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "</span>\r\n    </div>\r\n</div>\r\n";
      return buffer;
    });
    Handlebars.registerPartial('chiropractor_views_templates_formfield_textarea', t);
    return t;
  });
/* END_TEMPLATE */

/* START_TEMPLATE */
  define('hbs!chiropractor/views/templates/formfield/select',['hbs','handlebars'], function( hbs, Handlebars ) { 
    var t = Handlebars.template(function (Handlebars,depth0,helpers,partials,data) {
      helpers = helpers || Handlebars.helpers;
      var buffer = "", stack1, foundHelper, functionType="function", escapeExpression=this.escapeExpression, self=this, helperMissing=helpers.helperMissing;

      function program1(depth0,data) {
  
        var buffer = "", stack1, foundHelper;
        buffer += "\r\n                <option value=\"\">";
        foundHelper = helpers.blank;
        if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.blank; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
        buffer += escapeExpression(stack1) + "</option>\r\n            ";
        return buffer;
      }

      function program3(depth0,data,depth1) {
  
        var buffer = "", stack1, stack2, foundHelper;
        buffer += "\r\n                <option value=\"";
        foundHelper = helpers.value;
        if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.value; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
        buffer += escapeExpression(stack1) + "\"";
        stack1 = depth1.value;
        stack2 = depth0.value;
        foundHelper = helpers.ifequal;
        stack1 = foundHelper ? foundHelper.call(depth0, stack2, stack1, {hash:{},inverse:self.noop,fn:self.program(4, program4, data)}) : helperMissing.call(depth0, "ifequal", stack2, stack1, {hash:{},inverse:self.noop,fn:self.program(4, program4, data)});
        if (stack1 || stack1 === 0) { buffer += stack1; }
        buffer += ">";
        foundHelper = helpers.label;
        if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.label; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
        buffer += escapeExpression(stack1) + "</option>\r\n            ";
        return buffer;
      }
      function program4(depth0,data) {
  
        return " selected=\"selected\"";
      }

      buffer += "<div class=\"control-group\" id=\"container-";
      foundHelper = helpers.id;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\">\r\n    <label class=\"control-label ";
      foundHelper = helpers.labelclass;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.labelclass; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\" for=\"";
      foundHelper = helpers.id;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\">";
      foundHelper = helpers.label;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.label; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "</label>\r\n    <div class=\"controls\">\r\n        <select id=\"";
      foundHelper = helpers.id;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\" name=\"";
      foundHelper = helpers.name;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\">\r\n            ";
      stack1 = depth0.blank;
      stack1 = helpers['if'].call(depth0, stack1, {hash:{},inverse:self.noop,fn:self.program(1, program1, data)});
      if (stack1 || stack1 === 0) { buffer += stack1; }
      buffer += "\r\n            ";
      stack1 = depth0.options;
      stack1 = helpers.each.call(depth0, stack1, {hash:{},inverse:self.noop,fn:self.programWithDepth(program3, data, depth0)});
      if (stack1 || stack1 === 0) { buffer += stack1; }
      buffer += "\r\n        </select>\r\n        <span class=\"description\">";
      foundHelper = helpers.description;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.description; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "</span>\r\n        <span class=\"help-inline\">";
      foundHelper = helpers.help;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.help; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "</span>\r\n    </div>\r\n</div>\r\n";
      return buffer;
    });
    Handlebars.registerPartial('chiropractor_views_templates_formfield_select', t);
    return t;
  });
/* END_TEMPLATE */

/* START_TEMPLATE */
  define('hbs!chiropractor/views/templates/formfield/checkbox',['hbs','handlebars'], function( hbs, Handlebars ) { 
    var t = Handlebars.template(function (Handlebars,depth0,helpers,partials,data) {
      helpers = helpers || Handlebars.helpers;
      var buffer = "", stack1, foundHelper, functionType="function", escapeExpression=this.escapeExpression, self=this;

      function program1(depth0,data) {
  
        var buffer = "", stack1, foundHelper;
        buffer += " \r\n            <input type=\"checkbox\" id=\"";
        foundHelper = helpers.id;
        if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
        buffer += escapeExpression(stack1) + "\" name=\"";
        foundHelper = helpers.name;
        if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
        buffer += escapeExpression(stack1) + "\" value=\"";
        foundHelper = helpers.value;
        if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.value; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
        buffer += escapeExpression(stack1) + "\" /> ";
        foundHelper = helpers.label;
        if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.label; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
        buffer += escapeExpression(stack1) + "\r\n        ";
        return buffer;
      }

      buffer += "<div class=\"control-group\" id=\"container-";
      foundHelper = helpers.id;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\">\r\n    <label class=\"control-label\" for=\"";
      foundHelper = helpers.id;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\">";
      foundHelper = helpers.label;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.label; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "</label>\r\n    <div class=\"controls\">\r\n        ";
      stack1 = depth0.options;
      stack1 = helpers.each.call(depth0, stack1, {hash:{},inverse:self.noop,fn:self.program(1, program1, data)});
      if (stack1 || stack1 === 0) { buffer += stack1; }
      buffer += "\r\n        <span class=\"help-inline\">";
      foundHelper = helpers.help;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.help; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "</span>\r\n    </div>\r\n</div>\r\n";
      return buffer;
    });
    Handlebars.registerPartial('chiropractor_views_templates_formfield_checkbox', t);
    return t;
  });
/* END_TEMPLATE */

/* START_TEMPLATE */
  define('hbs!chiropractor/views/templates/formfield/radio',['hbs','handlebars'], function( hbs, Handlebars ) { 
    var t = Handlebars.template(function (Handlebars,depth0,helpers,partials,data) {
      helpers = helpers || Handlebars.helpers;
      var buffer = "", stack1, foundHelper, functionType="function", escapeExpression=this.escapeExpression, self=this;

      function program1(depth0,data) {
  
        var buffer = "", stack1, foundHelper;
        buffer += " \r\n            <input type=\"radio\" id=\"";
        foundHelper = helpers.id;
        if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
        buffer += escapeExpression(stack1) + "\" name=\"";
        foundHelper = helpers.name;
        if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.name; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
        buffer += escapeExpression(stack1) + "\" value=\"";
        foundHelper = helpers.value;
        if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.value; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
        buffer += escapeExpression(stack1) + "\" /> ";
        foundHelper = helpers.label;
        if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.label; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
        buffer += escapeExpression(stack1) + "\r\n        ";
        return buffer;
      }

      buffer += "<div class=\"control-group\" id=\"container-";
      foundHelper = helpers.id;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\">\r\n    <label class=\"control-label\" for=\"";
      foundHelper = helpers.id;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.id; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "\">";
      foundHelper = helpers.label;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.label; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "</label>\r\n    <div class=\"controls\">\r\n        ";
      stack1 = depth0.options;
      stack1 = helpers.each.call(depth0, stack1, {hash:{},inverse:self.noop,fn:self.program(1, program1, data)});
      if (stack1 || stack1 === 0) { buffer += stack1; }
      buffer += "\r\n        <span class=\"help-inline\">";
      foundHelper = helpers.help;
      if (foundHelper) { stack1 = foundHelper.call(depth0, {hash:{}}); } else { stack1 = depth0.help; stack1 = typeof stack1 === functionType ? stack1() : stack1; }
      buffer += escapeExpression(stack1) + "</span>\r\n    </div>\r\n</div>\r\n";
      return buffer;
    });
    Handlebars.registerPartial('chiropractor_views_templates_formfield_radio', t);
    return t;
  });
/* END_TEMPLATE */

/*global define*/
  define('chiropractor/views/formfield',['require','json-ie7','jquery','underscore','handlebars','../hbs/view','./base','hbs!./templates/formfield/text','hbs!./templates/formfield/textarea','hbs!./templates/formfield/select','hbs!./templates/formfield/checkbox','hbs!./templates/formfield/radio'],function(require) {

    var JSON = require('json-ie7'),
      $ = require('jquery'),
      _ = require('underscore'),
      Handlebars = require('handlebars'),
      viewHelper = require('../hbs/view'),
      Base = require('./base'),
      fieldTemplates = {},
      View, register;

    View = Base.extend({
      events: {
        'change input': 'inputChanged',
        'blur input': 'inputChanged',
        'change select': 'inputChanged',
        'blur select': 'inputChanged',
        'change textarea': 'inputChanged',
        'blur textarea': 'inputChanged'
      },

      initialize: function(options) {
        Base.prototype.initialize.apply(this, arguments);
        this.config = options.context;
        this.field = options.field;
      },
      inputChanged: function() {
        var val = this.$('[name=' + this.field + ']').val();
        this.model.set(this.field, val, {validate: true});
            // We want to ensure that the model value is really updated even
            // if validation fails in the previous step. However, it should be
            // silent and not trigger any change events since the previous step
            // will take care of that in the case of success.
        this.model.set(this.field, val, {silent: true});
      }
    });

    View.register = register = function(type, def) {
      var SubClass = fieldTemplates[type] = this.extend(def);
      SubClass.register = register;
      return SubClass;
    };

    View.unregister = function(type) {
      if (fieldTemplates[type]) {
        delete fieldTemplates[type];
      }
    };

    View.register('text', {
      template: require('hbs!./templates/formfield/text')
    });

    View.register('textarea', {
      template: require('hbs!./templates/formfield/textarea')
    });

    View.register('select', {
      template: require('hbs!./templates/formfield/select')
    });

    View.register('checkbox', {
      template: require('hbs!./templates/formfield/checkbox')
    });

    View.register('radio', {
      template: require('hbs!./templates/formfield/radio')
    });

    Handlebars.registerHelper('formfield', function(type, model, fieldName) {
        // template helper in the form of:
        //
        //      {{ formfield 'text' model 'fieldname' [attrName="attrValue"]*}}
      var FormField = fieldTemplates[type],
        options = arguments[arguments.length - 1],
        opts = options.hash || {};

      if (!FormField) {
        throw new Error('Unregistered formfield template: ' + type);
      }

      _.defaults(opts, {
        id: model.fieldId(fieldName),
        label: fieldName,
        name: fieldName,
        options: [],
        blank: false,
        value: model.get(fieldName) || '',
        help: ''
      });
      return viewHelper.call(this, FormField, {
        field: fieldName,
        model: model,
        context: opts
      }, options);
    });

    return View;
  });

/*global define*/
  define('chiropractor/views',['require','./views/base','./views/form','./views/field','./views/row','./views/formfield'],function(require) {

    var Base = require('./views/base'),
      Form = require('./views/form'),
      Field = require('./views/field'),
      Row = require('./views/row'),
      FormField = require('./views/formfield');

    return {
      Base: Base,
      Form: Form,
      Row: Row,
      Field: Field,
      FormField: FormField
    };
  });

/**
 * @preserve console-shim 1.0.3
 * https://github.com/kayahr/console-shim
 * Copyright (C) 2011 Klaus Reimer <k@ailis.de>
 * Licensed under the MIT license
 * (See http://www.opensource.org/licenses/mit-license)
 */
 
  (function() {

/**
 * Returns a function which calls the specified function in the specified
 * scope.
 *
 * @param {Function} func
 *            The function to call.
 * @param {Object} scope
 *            The scope to call the function in.
 * @param {...*} args
 *            Additional arguments to pass to the bound function.
 * @returns {function(...[*]): undefined}
 *            The bound function.
 */
    var bind = function(func, scope, args) {
      var fixedArgs = Array.prototype.slice.call(arguments, 2);
      return function() {
        var args = fixedArgs.concat(Array.prototype.slice.call(arguments, 0));
        (/** @type {Function} */ func).apply(scope, args);
      };
    };

// Create console if not present
    if (!window["console"]) window.console = /** @type {Console} */ ({});
    var console = (/** @type {Object} */ window.console);

// Implement console log if needed
    if (!console["log"]) {
    // Use log4javascript if present
      if (window["log4javascript"]) {
        var log = log4javascript.getDefaultLogger();
        console.log = bind(log.info, log);
        console.debug = bind(log.debug, log);
        console.info = bind(log.info, log);
        console.warn = bind(log.warn, log);
        console.error = bind(log.error, log);
      } else {
    // Use empty dummy implementation to ignore logging
        console.log = (/** @param {...*} args */ function(args) {});
      }
    }

// Implement other log levels to console.log if missing
    if (!console["debug"]) console.debug = console.log;
    if (!console["info"]) console.info = console.log;
    if (!console["warn"]) console.warn = console.log;
    if (!console["error"]) console.error = console.log;

// Wrap the log methods in IE (<=9) because their argument handling is wrong
// This wrapping is also done if the __consoleShimTest__ symbol is set. This
// is needed for unit testing.
    if (window["__consoleShimTest__"] != null || 
    eval("/*@cc_on @_jscript_version <= 9@*/")) {
    /**
     * Wraps the call to a real IE logging method. Modifies the arguments so
     * parameters which are not represented by a placeholder are properly
     * printed with a space character as separator.
     *
     * @param {...*} args
     *            The function arguments. First argument is the log function
     *            to call, the other arguments are the log arguments.
     */
      var wrap = function(args) {
        var i, max, match, log;
        
        // Convert argument list to real array
        args = Array.prototype.slice.call(arguments, 0);
        
        // First argument is the log method to call
        log = args.shift();
        
        max = args.length;
        if (max > 1 && window["__consoleShimTest__"] !== false) {
            // When first parameter is not a string then add a format string to
            // the argument list so we are able to modify it in the next stop
          if (typeof(args[0]) != "string") {
            args.unshift("%o");
            max += 1;
          }
            
            // For each additional parameter which has no placeholder in the
            // format string we add another placeholder separated with a
            // space character.
          match = args[0].match(/%[a-z]/g);
          for (i = match ? match.length + 1 : 1; i < max; i += 1) {
            args[0] += " %o";
          }
        }
        Function.apply.call(log, console, args);
      };
    
    // Wrap the native log methods of IE to fix argument output problems
      console.log = bind(wrap, window, console.log);
      console.debug = bind(wrap, window, console.debug);
      console.info = bind(wrap, window, console.info);
      console.warn = bind(wrap, window, console.warn);
      console.error = bind(wrap, window, console.error);
    }

// Implement console.assert if missing
    if (!console["assert"]) {
      console["assert"] = function() {
        var args = Array.prototype.slice.call(arguments, 0);
        var expr = args.shift();
        if (!expr) {
          args[0] = "Assertion failed: " + args[0];
          console.error.apply(console, args);
        }
      };
    }

// Linking console.dir and console.dirxml to the console.log method if
// missing. Hopefully the browser already logs objects and DOM nodes as a
// tree.
    if (!console["dir"]) console["dir"] = console.log;
    if (!console["dirxml"]) console["dirxml"] = console.log;

// Linking console.exception to console.error. This is not the same but
// at least some error message is displayed.
    if (!console["exception"]) console["exception"] = console.error;

// Implement console.time and console.timeEnd if one of them is missing
    if (!console["time"] || !console["timeEnd"]) {
      var timers = {};
      console["time"] = function(id) {
        timers[id] = new Date().getTime();
      };
      console["timeEnd"] = function(id) {
        var start = timers[id];
        if (start) {
          console.log(id + ": " + (new Date().getTime() - start) + "ms");
          delete timers[id];
        }
      };
    }

// Implement console.table if missing
    if (!console["table"]) {
      console["table"] = function(data, columns) {
        var i, iMax, row, j, jMax, k;
        
        // Do nothing if data has wrong type or no data was specified
        if (!data || !(data instanceof Array) || !data.length) return;
        
        // Auto-calculate columns array if not set
        if (!columns || !(columns instanceof Array)) {
          columns = [];
          for (k in data[0]) {
            if (!data[0].hasOwnProperty(k)) continue;
            columns.push(k);
          }
        }
        
        for (i = 0, iMax = data.length; i < iMax; i += 1) {
          row = [];
          for (j = 0, jMax = columns.length; j < jMax; j += 1) {
            row.push(data[i][columns[j]]);
          }
            
          Function.apply.call(console.log, console, row);
        }
      };
    }

// Dummy implementations of other console features to prevent error messages
// in browsers not supporting it.
    if (!console["clear"]) console["clear"] = function() {};
    if (!console["trace"]) console["trace"] = function() {};
    if (!console["group"]) console["group"] = function() {};
    if (!console["groupCollapsed"]) console["groupCollapsed"] = function() {};
    if (!console["groupEnd"]) console["groupEnd"] = function() {};
    if (!console["timeStamp"]) console["timeStamp"] = function() {};
    if (!console["profile"]) console["profile"] = function() {};
    if (!console["profileEnd"]) console["profileEnd"] = function() {};
    if (!console["count"]) console["count"] = function() {};

  })();

  define("console-shim", (function (global) {
    return function () {
      var ret, fn;
      return ret || global.console;
    };
  }(this)));

/**
 * easyXDM
 * http://easyxdm.net/
 * Copyright(c) 2009-2011, Øyvind Sean Kinsey, oyvind@kinsey.no.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
  define('jquery.cors/easyxdm/easyxdm',['require','json2'],function(require) {
    
    var JSON = require('json2');
    var global = this;
    var channelId = Math.floor(Math.random() * 10000); // randomize the initial id in case of multiple closures loaded
    var emptyFn = Function.prototype;
    var reURI = /^((http.?:)\/\/([^:\/\s]+)(:\d+)*)/; // returns groups for protocol (2), domain (3) and port (4)
    var reParent = /[\-\w]+\/\.\.\//; // matches a foo/../ expression
    var reDoubleSlash = /([^:])\/\//g; // matches // anywhere but in the protocol
    var namespace = ""; // stores namespace under which easyXDM object is stored on the page (empty if object is global)
    var easyXDM = {};
    var _easyXDM = window.easyXDM; // map over global easyXDM in case of overwrite
    var IFRAME_PREFIX = "easyXDM_";
    var HAS_NAME_PROPERTY_BUG;
    var useHash = false; // whether to use the hash over the query
    var flashVersion; // will be set if using flash
    var HAS_FLASH_THROTTLED_BUG;

    //(function(window, document, location, setTimeout, decodeURIComponent, encodeURIComponent) {
        /*jslint evil: true, browser: true, immed: true, passfail: true, undef: true, newcap: true*/
        /*global JSON, XMLHttpRequest, window, escape, unescape, ActiveXObject */
        //
        // easyXDM
        // http://easyxdm.net/
        // Copyright(c) 2009-2011, Øyvind Sean Kinsey, oyvind@kinsey.no.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a copy
        // of this software and associated documentation files (the "Software"), to deal
        // in the Software without restriction, including without limitation the rights
        // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        // copies of the Software, and to permit persons to whom the Software is
        // furnished to do so, subject to the following conditions:
        //
        // The above copyright notice and this permission notice shall be included in
        // all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        // THE SOFTWARE.
        //

        // http://peter.michaux.ca/articles/feature-detection-state-of-the-art-browser-scripting
    function isHostMethod(object, property) {
      var t = typeof object[property];
      return t == 'function' ||
                ( !! (t == 'object' && object[property])) ||
                t == 'unknown';
    }

    function isHostObject(object, property) {
      return !!(typeof(object[property]) == 'object' && object[property]);
    }

        // end

        // http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/
    function isArray(o) {
      return Object.prototype.toString.call(o) === '[object Array]';
    }

        // end
    function hasFlash() {
      var name = "Shockwave Flash",
        mimeType = "application/x-shockwave-flash";

      if (!undef(navigator.plugins) && typeof navigator.plugins[name] == "object") {
                // adapted from the swfobject code
        var description = navigator.plugins[name].description;
        if (description && !undef(navigator.mimeTypes) && navigator.mimeTypes[mimeType] && navigator.mimeTypes[mimeType].enabledPlugin) {
          flashVersion = description.match(/\d+/g);
        }
      }
      if (!flashVersion) {
        var flash;
        try {
          flash = new ActiveXObject("ShockwaveFlash.ShockwaveFlash");
          flashVersion = Array.prototype.slice.call(flash.GetVariable("$version").match(/(\d+),(\d+),(\d+),(\d+)/), 1);
          flash = null;
        } catch (notSupportedException) {
                    // swallow error
        }
      }
      if (!flashVersion) {
        return false;
      }
      var major = parseInt(flashVersion[0], 10),
        minor = parseInt(flashVersion[1], 10);
      HAS_FLASH_THROTTLED_BUG = major > 9 && minor > 0;
      return true;
    }

        /*
         * Cross Browser implementation for adding and removing event listeners.
         */
    var on, un;
    if (isHostMethod(window, "addEventListener")) {
      on = function(target, type, listener) {
        target.addEventListener(type, listener, false);
      };
      un = function(target, type, listener) {
        target.removeEventListener(type, listener, false);
      };
    } else if (isHostMethod(window, "attachEvent")) {
      on = function(object, sEvent, fpNotify) {
        object.attachEvent("on" + sEvent, fpNotify);
      };
      un = function(object, sEvent, fpNotify) {
        object.detachEvent("on" + sEvent, fpNotify);
      };
    } else {
      throw new Error("Browser not supported");
    }

        /*
         * Cross Browser implementation of DOMContentLoaded.
         */
    var domIsReady = false,
      domReadyQueue = [],
      readyState;
    if ("readyState" in document) {
            // If browser is WebKit-powered, check for both 'loaded' (legacy browsers) and
            // 'interactive' (HTML5 specs, recent WebKit builds) states.
            // https://bugs.webkit.org/show_bug.cgi?id=45119
      readyState = document.readyState;
      domIsReady = readyState == "complete" || (~navigator.userAgent.indexOf('AppleWebKit/') && (readyState == "loaded" || readyState == "interactive"));
    } else {
            // If readyState is not supported in the browser, then in order to be able to fire whenReady functions apropriately
            // when added dynamically _after_ DOM load, we have to deduce wether the DOM is ready or not.
            // We only need a body to add elements to, so the existence of document.body is enough for us.
      domIsReady = !! document.body;
    }

    function dom_onReady() {
      if (domIsReady) {
        return;
      }
      domIsReady = true;
      for (var i = 0; i < domReadyQueue.length; i++) {
        domReadyQueue[i]();
      }
      domReadyQueue.length = 0;
    }

    if (!domIsReady) {
      if (isHostMethod(window, "addEventListener")) {
        on(document, "DOMContentLoaded", dom_onReady);
      } else {
        on(document, "readystatechange", function() {
          if (document.readyState == "complete") {
            dom_onReady();
          }
        });
        if (document.documentElement.doScroll && window === top) {
          var doScrollCheck = function() {
            if (domIsReady) {
              return;
            }
                        // http://javascript.nwbox.com/IEContentLoaded/
            try {
              document.documentElement.doScroll("left");
            } catch (e) {
              setTimeout(doScrollCheck, 1);
              return;
            }
            dom_onReady();
          };
          doScrollCheck();
        }
      }

            // A fallback to window.onload, that will always work
      on(window, "load", dom_onReady);
    }
        /**
         * This will add a function to the queue of functions to be run once the DOM reaches a ready state.
         * If functions are added after this event then they will be executed immediately.
         * @param {function} fn The function to add
         * @param {Object} scope An optional scope for the function to be called with.
         */
    function whenReady(fn, scope) {
      if (domIsReady) {
        fn.call(scope);
        return;
      }
      domReadyQueue.push(function() {
        fn.call(scope);
      });
    }

        /**
         * Returns an instance of easyXDM from the parent window with
         * respect to the namespace.
         *
         * @return An instance of easyXDM (in the parent window)
         */
    function getParentObject() {
      var obj = parent;
      if (namespace !== "") {
        for (var i = 0, ii = namespace.split("."); i < ii.length; i++) {
          obj = obj[ii[i]];
        }
      }
      return obj.easyXDM;
    }

        /**
         * Removes easyXDM variable from the global scope. It also returns control
         * of the easyXDM variable to whatever code used it before.
         *
         * @param {String} ns A string representation of an object that will hold
         *                    an instance of easyXDM.
         * @return An instance of easyXDM
         */
    function noConflict(ns) {

      window.easyXDM = _easyXDM;
      namespace = ns;
      if (namespace) {
        IFRAME_PREFIX = "easyXDM_" + namespace.replace(".", "_") + "_";
      }
      return easyXDM;
    }

        /*
         * Methods for working with URLs
         */
        /**
         * Get the domain name from a url.
         * @param {String} url The url to extract the domain from.
         * @return The domain part of the url.
         * @type {String}
         */
    function getDomainName(url) {
      return url.match(reURI)[3];
    }

        /**
         * Get the port for a given URL, or "" if none
         * @param {String} url The url to extract the port from.
         * @return The port part of the url.
         * @type {String}
         */
    function getPort(url) {
      return url.match(reURI)[4] || "";
    }

        /**
         * Returns  a string containing the schema, domain and if present the port
         * @param {String} url The url to extract the location from
         * @return {String} The location part of the url
         */
    function getLocation(url) {
      var m = url.toLowerCase().match(reURI);
      var proto = m[2],
        domain = m[3],
        port = m[4] || "";
      if ((proto == "http:" && port == ":80") || (proto == "https:" && port == ":443")) {
        port = "";
      }
      return proto + "//" + domain + port;
    }

        /**
         * Resolves a relative url into an absolute one.
         * @param {String} url The path to resolve.
         * @return {String} The resolved url.
         */
    function resolveUrl(url) {

            // replace all // except the one in proto with /
      url = url.replace(reDoubleSlash, "$1/");

            // If the url is a valid url we do nothing
      if (!url.match(/^(http||https):\/\//)) {
                // If this is a relative path
        var path = (url.substring(0, 1) === "/") ? "" : location.pathname;
        if (path.substring(path.length - 1) !== "/") {
          path = path.substring(0, path.lastIndexOf("/") + 1);
        }

        url = location.protocol + "//" + location.host + path + url;
      }

            // reduce all 'xyz/../' to just ''
      while (reParent.test(url)) {
        url = url.replace(reParent, "");
      }

      return url;
    }

        /**
         * Appends the parameters to the given url.<br/>
         * The base url can contain existing query parameters.
         * @param {String} url The base url.
         * @param {Object} parameters The parameters to add.
         * @return {String} A new valid url with the parameters appended.
         */
    function appendQueryParameters(url, parameters) {

      var hash = "",
        indexOf = url.indexOf("#");
      if (indexOf !== -1) {
        hash = url.substring(indexOf);
        url = url.substring(0, indexOf);
      }
      var q = [];
      for (var key in parameters) {
        if (parameters.hasOwnProperty(key)) {
          q.push(key + "=" + encodeURIComponent(parameters[key]));
        }
      }
      return url + (useHash ? "#" : (url.indexOf("?") == -1 ? "?" : "&")) + q.join("&") + hash;
    }

        // build the query object either from location.query, if it contains the xdm_e argument, or from location.hash
    var query = (function(input) {
      input = input.substring(1).split("&");
      var data = {}, pair, i = input.length;
      while (i--) {
        pair = input[i].split("=");
        data[pair[0]] = decodeURIComponent(pair[1]);
      }
      return data;
    }(/xdm_e=/.test(location.search) ? location.search : location.hash));

        /*
         * Helper methods
         */
        /**
         * Helper for checking if a variable/property is undefined
         * @param {Object} v The variable to test
         * @return {Boolean} True if the passed variable is undefined
         */
    function undef(v) {
      return typeof v === "undefined";
    }

        /**
         * A safe implementation of HTML5 JSON. Feature testing is used to make sure the implementation works.
         * @return {JSON} A valid JSON conforming object, or null if not found.
         */
    var getJSON = function() {
      var cached = {};
      var obj = {
          a: [1, 2, 3]
        }, json = "{\"a\":[1,2,3]}";

      if (typeof JSON != "undefined" && typeof JSON.stringify === "function" && JSON.stringify(obj).replace((/\s/g), "") === json) {
                // this is a working JSON instance
        return JSON;
      }
      if (Object.toJSON) {
        if (Object.toJSON(obj).replace((/\s/g), "") === json) {
                    // this is a working stringify method
          cached.stringify = Object.toJSON;
        }
      }

      if (typeof String.prototype.evalJSON === "function") {
        obj = json.evalJSON();
        if (obj.a && obj.a.length === 3 && obj.a[2] === 3) {
                    // this is a working parse method
          cached.parse = function(str) {
            return str.evalJSON();
          };
        }
      }

      if (cached.stringify && cached.parse) {
                // Only memoize the result if we have valid instance
        getJSON = function() {
          return cached;
        };
        return cached;
      }
      return null;
    };

        /**
         * Applies properties from the source object to the target object.<br/>
         * @param {Object} target The target of the properties.
         * @param {Object} source The source of the properties.
         * @param {Boolean} noOverwrite Set to True to only set non-existing properties.
         */
    function apply(destination, source, noOverwrite) {
      var member;
      for (var prop in source) {
        if (source.hasOwnProperty(prop)) {
          if (prop in destination) {
            member = source[prop];
            if (typeof member === "object") {
              apply(destination[prop], member, noOverwrite);
            } else if (!noOverwrite) {
              destination[prop] = source[prop];
            }
          } else {
            destination[prop] = source[prop];
          }
        }
      }
      return destination;
    }

        // This tests for the bug in IE where setting the [name] property using javascript causes the value to be redirected into [submitName].
    function testForNamePropertyBug() {
      var form = document.body.appendChild(document.createElement("form")),
        input = form.appendChild(document.createElement("input"));
      input.name = IFRAME_PREFIX + "TEST" + channelId; // append channelId in order to avoid caching issues
      HAS_NAME_PROPERTY_BUG = input !== form.elements[input.name];
      document.body.removeChild(form);
    }

        /**
         * Creates a frame and appends it to the DOM.
         * @param config {object} This object can have the following properties
         * <ul>
         * <li> {object} prop The properties that should be set on the frame. This should include the 'src' property.</li>
         * <li> {object} attr The attributes that should be set on the frame.</li>
         * <li> {DOMElement} container Its parent element (Optional).</li>
         * <li> {function} onLoad A method that should be called with the frames contentWindow as argument when the frame is fully loaded. (Optional)</li>
         * </ul>
         * @return The frames DOMElement
         * @type DOMElement
         */
    function createFrame(config) {
      if (undef(HAS_NAME_PROPERTY_BUG)) {
        testForNamePropertyBug();
      }
      var frame;
            // This is to work around the problems in IE6/7 with setting the name property.
            // Internally this is set as 'submitName' instead when using 'iframe.name = ...'
            // This is not required by easyXDM itself, but is to facilitate other use cases
      if (HAS_NAME_PROPERTY_BUG) {
        frame = document.createElement("<iframe name=\"" + config.props.name + "\"/>");
      } else {
        frame = document.createElement("IFRAME");
        frame.name = config.props.name;
      }

      frame.id = frame.name = config.props.name;
      delete config.props.name;

      if (typeof config.container == "string") {
        config.container = document.getElementById(config.container);
      }

      if (!config.container) {
                // This needs to be hidden like this, simply setting display:none and the like will cause failures in some browsers.
        apply(frame.style, {
          position: "absolute",
          top: "-2000px",
                    // Avoid potential horizontal scrollbar
          left: "0px"
        });
        config.container = document.body;
      }

            // HACK: IE cannot have the src attribute set when the frame is appended
            //       into the container, so we set it to "javascript:false" as a
            //       placeholder for now.  If we left the src undefined, it would
            //       instead default to "about:blank", which causes SSL mixed-content
            //       warnings in IE6 when on an SSL parent page.
      var src = config.props.src;
      config.props.src = "javascript:false";

            // transfer properties to the frame
      apply(frame, config.props);

      frame.border = frame.frameBorder = 0;
      frame.allowTransparency = true;
      config.container.appendChild(frame);

      if (config.onLoad) {
        on(frame, "load", config.onLoad);
      }

            // set the frame URL to the proper value (we previously set it to
            // "javascript:false" to work around the IE issue mentioned above)
      if (config.usePost) {
        var form = config.container.appendChild(document.createElement('form')),
          input;
        form.target = frame.name;
        form.action = src;
        form.method = 'POST';
        if (typeof(config.usePost) === 'object') {
          for (var i in config.usePost) {
            if (config.usePost.hasOwnProperty(i)) {
              if (HAS_NAME_PROPERTY_BUG) {
                input = document.createElement('<input name="' + i + '"/>');
              } else {
                input = document.createElement("INPUT");
                input.name = i;
              }
              input.value = config.usePost[i];
              form.appendChild(input);
            }
          }
        }
        form.submit();
        form.parentNode.removeChild(form);
      } else {
        frame.src = src;
      }
      config.props.src = src;

      return frame;
    }

        /**
         * Check whether a domain is allowed using an Access Control List.
         * The ACL can contain * and ? as wildcards, or can be regular expressions.
         * If regular expressions they need to begin with ^ and end with $.
         * @param {Array/String} acl The list of allowed domains
         * @param {String} domain The domain to test.
         * @return {Boolean} True if the domain is allowed, false if not.
         */
    function checkAcl(acl, domain) {
            // normalize into an array
      if (typeof acl == "string") {
        acl = [acl];
      }
      var re, i = acl.length;
      while (i--) {
        re = acl[i];
        re = new RegExp(re.substr(0, 1) == "^" ? re : ("^" + re.replace(/(\*)/g, ".$1").replace(/\?/g, ".") + "$"));
        if (re.test(domain)) {
          return true;
        }
      }
      return false;
    }

        /*
         * Functions related to stacks
         */
        /**
         * Prepares an array of stack-elements suitable for the current configuration
         * @param {Object} config The Transports configuration. See easyXDM.Socket for more.
         * @return {Array} An array of stack-elements with the TransportElement at index 0.
         */
    function prepareTransportStack(config) {
      var protocol = config.protocol,
        stackEls;
      config.isHost = config.isHost || undef(query.xdm_p);
      useHash = config.hash || false;

      if (!config.props) {
        config.props = {};
      }
      if (!config.isHost) {
        config.channel = query.xdm_c.replace(/["'<>\\]/g, "");
        config.secret = query.xdm_s;
        config.remote = query.xdm_e.replace(/["'<>\\]/g, "");
        protocol = query.xdm_p;
        if (config.acl && !checkAcl(config.acl, config.remote)) {
          throw new Error("Access denied for " + config.remote);
        }
      } else {
        config.remote = resolveUrl(config.remote);
        config.channel = config.channel || "default" + channelId++;
        config.secret = Math.random().toString(16).substring(2);
        if (undef(protocol)) {
          if (getLocation(location.href) == getLocation(config.remote)) {
                        /*
                         * Both documents has the same origin, lets use direct access.
                         */
            protocol = "4";
          } else if (isHostMethod(window, "postMessage") || isHostMethod(document, "postMessage")) {
                        /*
                         * This is supported in IE8+, Firefox 3+, Opera 9+, Chrome 2+ and Safari 4+
                         */
            protocol = "1";
          } else if (config.swf && isHostMethod(window, "ActiveXObject") && hasFlash()) {
                        /*
                         * The Flash transport superseedes the NixTransport as the NixTransport has been blocked by MS
                         */
            protocol = "6";
          } else if (navigator.product === "Gecko" && "frameElement" in window && navigator.userAgent.indexOf('WebKit') == -1) {
                        /*
                         * This is supported in Gecko (Firefox 1+)
                         */
            protocol = "5";
          } else if (config.remoteHelper) {
                        /*
                         * This is supported in all browsers that retains the value of window.name when
                         * navigating from one domain to another, and where parent.frames[foo] can be used
                         * to get access to a frame from the same domain
                         */
            protocol = "2";
          } else {
                        /*
                         * This is supported in all browsers where [window].location is writable for all
                         * The resize event will be used if resize is supported and the iframe is not put
                         * into a container, else polling will be used.
                         */
            protocol = "0";
          }
        }
      }
      config.protocol = protocol; // for conditional branching
      switch (protocol) {
      case "0": // 0 = HashTransport
        apply(config, {
          interval: 100,
          delay: 2000,
          useResize: true,
          useParent: false,
          usePolling: false
        }, true);
        if (config.isHost) {
          if (!config.local) {
                            // If no local is set then we need to find an image hosted on the current domain
            var domain = location.protocol + "//" + location.host,
              images = document.body.getElementsByTagName("img"),
              image;
            var i = images.length;
            while (i--) {
              image = images[i];
              if (image.src.substring(0, domain.length) === domain) {
                config.local = image.src;
                break;
              }
            }
            if (!config.local) {
                                // If no local was set, and we are unable to find a suitable file, then we resort to using the current window
              config.local = window;
            }
          }

          var parameters = {
            xdm_c: config.channel,
            xdm_p: 0
          };

          if (config.local === window) {
                            // We are using the current window to listen to
            config.usePolling = true;
            config.useParent = true;
            config.local = location.protocol + "//" + location.host + location.pathname + location.search;
            parameters.xdm_e = config.local;
            parameters.xdm_pa = 1; // use parent
          } else {
            parameters.xdm_e = resolveUrl(config.local);
          }

          if (config.container) {
            config.useResize = false;
            parameters.xdm_po = 1; // use polling
          }
          config.remote = appendQueryParameters(config.remote, parameters);
        } else {
          apply(config, {
            channel: query.xdm_c,
            remote: query.xdm_e,
            useParent: !undef(query.xdm_pa),
            usePolling: !undef(query.xdm_po),
            useResize: config.useParent ? false : config.useResize
          });
        }
        stackEls = [new easyXDM.stack.HashTransport(config), new easyXDM.stack.ReliableBehavior({}), new easyXDM.stack.QueueBehavior({
          encode: true,
          maxLength: 4000 - config.remote.length
        }), new easyXDM.stack.VerifyBehavior({
          initiate: config.isHost
        })];
        break;
      case "1":
        stackEls = [new easyXDM.stack.PostMessageTransport(config)];
        break;
      case "2":
        config.remoteHelper = resolveUrl(config.remoteHelper);
        stackEls = [new easyXDM.stack.NameTransport(config), new easyXDM.stack.QueueBehavior(), new easyXDM.stack.VerifyBehavior({
          initiate: config.isHost
        })];
        break;
      case "3":
        stackEls = [new easyXDM.stack.NixTransport(config)];
        break;
      case "4":
        stackEls = [new easyXDM.stack.SameOriginTransport(config)];
        break;
      case "5":
        stackEls = [new easyXDM.stack.FrameElementTransport(config)];
        break;
      case "6":
        if (!flashVersion) {
          hasFlash();
        }
        stackEls = [new easyXDM.stack.FlashTransport(config)];
        break;
      }
            // this behavior is responsible for buffering outgoing messages, and for performing lazy initialization
      stackEls.push(new easyXDM.stack.QueueBehavior({
        lazy: config.lazy,
        remove: true
      }));
      return stackEls;
    }

        /**
         * Chains all the separate stack elements into a single usable stack.<br/>
         * If an element is missing a necessary method then it will have a pass-through method applied.
         * @param {Array} stackElements An array of stack elements to be linked.
         * @return {easyXDM.stack.StackElement} The last element in the chain.
         */
    function chainStack(stackElements) {
      var stackEl, defaults = {
          incoming: function(message, origin) {
            this.up.incoming(message, origin);
          },
          outgoing: function(message, recipient) {
            this.down.outgoing(message, recipient);
          },
          callback: function(success) {
            this.up.callback(success);
          },
          init: function() {
            this.down.init();
          },
          destroy: function() {
            this.down.destroy();
          }
        };
      for (var i = 0, len = stackElements.length; i < len; i++) {
        stackEl = stackElements[i];
        apply(stackEl, defaults, true);
        if (i !== 0) {
          stackEl.down = stackElements[i - 1];
        }
        if (i !== len - 1) {
          stackEl.up = stackElements[i + 1];
        }
      }
      return stackEl;
    }

        /**
         * This will remove a stackelement from its stack while leaving the stack functional.
         * @param {Object} element The elment to remove from the stack.
         */
    function removeFromStack(element) {
      element.up.down = element.down;
      element.down.up = element.up;
      element.up = element.down = null;
    }

        /*
         * Export the main object and any other methods applicable
         */
        /**
         * @class easyXDM
         * A javascript library providing cross-browser, cross-domain messaging/RPC.
         * @version 2.4.17.1
         * @singleton
         */
    apply(easyXDM, {
            /**
             * The version of the library
             * @type {string}
             */
      version: "2.4.17.1",
            /**
             * This is a map containing all the query parameters passed to the document.
             * All the values has been decoded using decodeURIComponent.
             * @type {object}
             */
      query: query,
            /**
             * @private
             */
      stack: {},
            /**
             * Applies properties from the source object to the target object.<br/>
             * @param {object} target The target of the properties.
             * @param {object} source The source of the properties.
             * @param {boolean} noOverwrite Set to True to only set non-existing properties.
             */
      apply: apply,

            /**
             * A safe implementation of HTML5 JSON. Feature testing is used to make sure the implementation works.
             * @return {JSON} A valid JSON conforming object, or null if not found.
             */
      getJSONObject: getJSON,
            /**
             * This will add a function to the queue of functions to be run once the DOM reaches a ready state.
             * If functions are added after this event then they will be executed immediately.
             * @param {function} fn The function to add
             * @param {object} scope An optional scope for the function to be called with.
             */
      whenReady: whenReady,
            /**
             * Removes easyXDM variable from the global scope. It also returns control
             * of the easyXDM variable to whatever code used it before.
             *
             * @param {String} ns A string representation of an object that will hold
             *                    an instance of easyXDM.
             * @return An instance of easyXDM
             */
      noConflict: noConflict
    });

        /*jslint evil: true, browser: true, immed: true, passfail: true, undef: true, newcap: true*/
        /*global console, _FirebugCommandLine,  easyXDM, window, escape, unescape, isHostObject, undef, _trace, domIsReady, emptyFn, namespace */
        //
        // easyXDM
        // http://easyxdm.net/
        // Copyright(c) 2009-2011, Øyvind Sean Kinsey, oyvind@kinsey.no.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a copy
        // of this software and associated documentation files (the "Software"), to deal
        // in the Software without restriction, including without limitation the rights
        // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        // copies of the Software, and to permit persons to whom the Software is
        // furnished to do so, subject to the following conditions:
        //
        // The above copyright notice and this permission notice shall be included in
        // all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        // THE SOFTWARE.
        //

        /*jslint evil: true, browser: true, immed: true, passfail: true, undef: true, newcap: true*/
        /*global easyXDM, window, escape, unescape, isHostObject, isHostMethod, un, on, createFrame, debug */
        //
        // easyXDM
        // http://easyxdm.net/
        // Copyright(c) 2009-2011, Øyvind Sean Kinsey, oyvind@kinsey.no.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a copy
        // of this software and associated documentation files (the "Software"), to deal
        // in the Software without restriction, including without limitation the rights
        // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        // copies of the Software, and to permit persons to whom the Software is
        // furnished to do so, subject to the following conditions:
        //
        // The above copyright notice and this permission notice shall be included in
        // all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        // THE SOFTWARE.
        //

        /**
         * @class easyXDM.DomHelper
         * Contains methods for dealing with the DOM
         * @singleton
         */
    easyXDM.DomHelper = {
            /**
             * Provides a consistent interface for adding eventhandlers
             * @param {Object} target The target to add the event to
             * @param {String} type The name of the event
             * @param {Function} listener The listener
             */
      on: on,
            /**
             * Provides a consistent interface for removing eventhandlers
             * @param {Object} target The target to remove the event from
             * @param {String} type The name of the event
             * @param {Function} listener The listener
             */
      un: un,
            /**
             * Checks for the presence of the JSON object.
             * If it is not present it will use the supplied path to load the JSON2 library.
             * This should be called in the documents head right after the easyXDM script tag.
             * http://json.org/json2.js
             * @param {String} path A valid path to json2.js
             */
      requiresJSON: function(path) {
        if (!isHostObject(window, "JSON")) {
                    // we need to encode the < in order to avoid an illegal token error
                    // when the script is inlined in a document.
          document.write('<' + 'script type="text/javascript" src="' + path + '"><' + '/script>');
        }
      }
    };
        /*jslint evil: true, browser: true, immed: true, passfail: true, undef: true, newcap: true*/
        /*global easyXDM, window, escape, unescape, debug */
        //
        // easyXDM
        // http://easyxdm.net/
        // Copyright(c) 2009-2011, Øyvind Sean Kinsey, oyvind@kinsey.no.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a copy
        // of this software and associated documentation files (the "Software"), to deal
        // in the Software without restriction, including without limitation the rights
        // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        // copies of the Software, and to permit persons to whom the Software is
        // furnished to do so, subject to the following conditions:
        //
        // The above copyright notice and this permission notice shall be included in
        // all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        // THE SOFTWARE.
        //

    (function() {
            // The map containing the stored functions
      var _map = {};

            /**
             * @class easyXDM.Fn
             * This contains methods related to function handling, such as storing callbacks.
             * @singleton
             * @namespace easyXDM
             */
      easyXDM.Fn = {
                /**
                 * Stores a function using the given name for reference
                 * @param {String} name The name that the function should be referred by
                 * @param {Function} fn The function to store
                 * @namespace easyXDM.fn
                 */
        set: function(name, fn) {
          _map[name] = fn;
        },
                /**
                 * Retrieves the function referred to by the given name
                 * @param {String} name The name of the function to retrieve
                 * @param {Boolean} del If the function should be deleted after retrieval
                 * @return {Function} The stored function
                 * @namespace easyXDM.fn
                 */
        get: function(name, del) {
          var fn = _map[name];

          if (del) {
            delete _map[name];
          }
          return fn;
        }
      };

    }());
        /*jslint evil: true, browser: true, immed: true, passfail: true, undef: true, newcap: true*/
        /*global easyXDM, window, escape, unescape, chainStack, prepareTransportStack, getLocation, debug */
        //
        // easyXDM
        // http://easyxdm.net/
        // Copyright(c) 2009-2011, Øyvind Sean Kinsey, oyvind@kinsey.no.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a copy
        // of this software and associated documentation files (the "Software"), to deal
        // in the Software without restriction, including without limitation the rights
        // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        // copies of the Software, and to permit persons to whom the Software is
        // furnished to do so, subject to the following conditions:
        //
        // The above copyright notice and this permission notice shall be included in
        // all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        // THE SOFTWARE.
        //

        /**
         * @class easyXDM.Socket
         * This class creates a transport channel between two domains that is usable for sending and receiving string-based messages.<br/>
         * The channel is reliable, supports queueing, and ensures that the message originates from the expected domain.<br/>
         * Internally different stacks will be used depending on the browsers features and the available parameters.
         * <h2>How to set up</h2>
         * Setting up the provider:
         * <pre><code>
         * var socket = new easyXDM.Socket({
         * &nbsp; local: "name.html",
         * &nbsp; onReady: function(){
         * &nbsp; &nbsp; &#47;&#47; you need to wait for the onReady callback before using the socket
         * &nbsp; &nbsp; socket.postMessage("foo-message");
         * &nbsp; },
         * &nbsp; onMessage: function(message, origin) {
         * &nbsp;&nbsp; alert("received " + message + " from " + origin);
         * &nbsp; }
         * });
         * </code></pre>
         * Setting up the consumer:
         * <pre><code>
         * var socket = new easyXDM.Socket({
         * &nbsp; remote: "http:&#47;&#47;remotedomain/page.html",
         * &nbsp; remoteHelper: "http:&#47;&#47;remotedomain/name.html",
         * &nbsp; onReady: function(){
         * &nbsp; &nbsp; &#47;&#47; you need to wait for the onReady callback before using the socket
         * &nbsp; &nbsp; socket.postMessage("foo-message");
         * &nbsp; },
         * &nbsp; onMessage: function(message, origin) {
         * &nbsp;&nbsp; alert("received " + message + " from " + origin);
         * &nbsp; }
         * });
         * </code></pre>
         * If you are unable to upload the <code>name.html</code> file to the consumers domain then remove the <code>remoteHelper</code> property
         * and easyXDM will fall back to using the HashTransport instead of the NameTransport when not able to use any of the primary transports.
         * @namespace easyXDM
         * @constructor
         * @cfg {String/Window} local The url to the local name.html document, a local static file, or a reference to the local window.
         * @cfg {Boolean} lazy (Consumer only) Set this to true if you want easyXDM to defer creating the transport until really needed.
         * @cfg {String} remote (Consumer only) The url to the providers document.
         * @cfg {String} remoteHelper (Consumer only) The url to the remote name.html file. This is to support NameTransport as a fallback. Optional.
         * @cfg {Number} delay The number of milliseconds easyXDM should try to get a reference to the local window.  Optional, defaults to 2000.
         * @cfg {Number} interval The interval used when polling for messages. Optional, defaults to 300.
         * @cfg {String} channel (Consumer only) The name of the channel to use. Can be used to set consistent iframe names. Must be unique. Optional.
         * @cfg {Function} onMessage The method that should handle incoming messages.<br/> This method should accept two arguments, the message as a string, and the origin as a string. Optional.
         * @cfg {Function} onReady A method that should be called when the transport is ready. Optional.
         * @cfg {DOMElement|String} container (Consumer only) The element, or the id of the element that the primary iframe should be inserted into. If not set then the iframe will be positioned off-screen. Optional.
         * @cfg {Array/String} acl (Provider only) Here you can specify which '[protocol]://[domain]' patterns that should be allowed to act as the consumer towards this provider.<br/>
         * This can contain the wildcards ? and *.  Examples are 'http://example.com', '*.foo.com' and '*dom?.com'. If you want to use reqular expressions then you pattern needs to start with ^ and end with $.
         * If none of the patterns match an Error will be thrown.
         * @cfg {Object} props (Consumer only) Additional properties that should be applied to the iframe. This can also contain nested objects e.g: <code>{style:{width:"100px", height:"100px"}}</code>.
         * Properties such as 'name' and 'src' will be overrided. Optional.
         */
    easyXDM.Socket = function(config) {

            // create the stack
      var stack = chainStack(prepareTransportStack(config).concat([{
          incoming: function(message, origin) {
            config.onMessage(message, origin);
          },
          callback: function(success) {
            if (config.onReady) {
              config.onReady(success);
            }
          }
        }])),
        recipient = getLocation(config.remote);

            // set the origin
      this.origin = getLocation(config.remote);

            /**
             * Initiates the destruction of the stack.
             */
      this.destroy = function() {
        stack.destroy();
      };

            /**
             * Posts a message to the remote end of the channel
             * @param {String} message The message to send
             */
      this.postMessage = function(message) {
        stack.outgoing(message, recipient);
      };

      stack.init();
    };
        /*jslint evil: true, browser: true, immed: true, passfail: true, undef: true, newcap: true*/
        /*global easyXDM, window, escape, unescape, undef,, chainStack, prepareTransportStack, debug, getLocation */
        //
        // easyXDM
        // http://easyxdm.net/
        // Copyright(c) 2009-2011, Øyvind Sean Kinsey, oyvind@kinsey.no.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a copy
        // of this software and associated documentation files (the "Software"), to deal
        // in the Software without restriction, including without limitation the rights
        // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        // copies of the Software, and to permit persons to whom the Software is
        // furnished to do so, subject to the following conditions:
        //
        // The above copyright notice and this permission notice shall be included in
        // all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        // THE SOFTWARE.
        //

        /**
         * @class easyXDM.Rpc
         * Creates a proxy object that can be used to call methods implemented on the remote end of the channel, and also to provide the implementation
         * of methods to be called from the remote end.<br/>
         * The instantiated object will have methods matching those specified in <code>config.remote</code>.<br/>
         * This requires the JSON object present in the document, either natively, using json.org's json2 or as a wrapper around library spesific methods.
         * <h2>How to set up</h2>
         * <pre><code>
         * var rpc = new easyXDM.Rpc({
         * &nbsp; &#47;&#47; this configuration is equal to that used by the Socket.
         * &nbsp; remote: "http:&#47;&#47;remotedomain/...",
         * &nbsp; onReady: function(){
         * &nbsp; &nbsp; &#47;&#47; you need to wait for the onReady callback before using the proxy
         * &nbsp; &nbsp; rpc.foo(...
         * &nbsp; }
         * },{
         * &nbsp; local: {..},
         * &nbsp; remote: {..}
         * });
         * </code></pre>
         *
         * <h2>Exposing functions (procedures)</h2>
         * <pre><code>
         * var rpc = new easyXDM.Rpc({
         * &nbsp; ...
         * },{
         * &nbsp; local: {
         * &nbsp; &nbsp; nameOfMethod: {
         * &nbsp; &nbsp; &nbsp; method: function(arg1, arg2, success, error){
         * &nbsp; &nbsp; &nbsp; &nbsp; ...
         * &nbsp; &nbsp; &nbsp; }
         * &nbsp; &nbsp; },
         * &nbsp; &nbsp; &#47;&#47; with shorthand notation
         * &nbsp; &nbsp; nameOfAnotherMethod:  function(arg1, arg2, success, error){
         * &nbsp; &nbsp; }
         * &nbsp; },
         * &nbsp; remote: {...}
         * });
         * </code></pre>

         * The function referenced by  [method] will receive the passed arguments followed by the callback functions <code>success</code> and <code>error</code>.<br/>
         * To send a successfull result back you can use
         *     <pre><code>
         *     return foo;
         *     </pre></code>
         * or
         *     <pre><code>
         *     success(foo);
         *     </pre></code>
         *  To return an error you can use
         *     <pre><code>
         *     throw new Error("foo error");
         *     </code></pre>
         * or
         *     <pre><code>
         *     error("foo error");
         *     </code></pre>
         *
         * <h2>Defining remotely exposed methods (procedures/notifications)</h2>
         * The definition of the remote end is quite similar:
         * <pre><code>
         * var rpc = new easyXDM.Rpc({
         * &nbsp; ...
         * },{
         * &nbsp; local: {...},
         * &nbsp; remote: {
         * &nbsp; &nbsp; nameOfMethod: {}
         * &nbsp; }
         * });
         * </code></pre>
         * To call a remote method use
         * <pre><code>
         * rpc.nameOfMethod("arg1", "arg2", function(value) {
         * &nbsp; alert("success: " + value);
         * }, function(message) {
         * &nbsp; alert("error: " + message + );
         * });
         * </code></pre>
         * Both the <code>success</code> and <code>errror</code> callbacks are optional.<br/>
         * When called with no callback a JSON-RPC 2.0 notification will be executed.
         * Be aware that you will not be notified of any errors with this method.
         * <br/>
         * <h2>Specifying a custom serializer</h2>
         * If you do not want to use the JSON2 library for non-native JSON support, but instead capabilities provided by some other library
         * then you can specify a custom serializer using <code>serializer: foo</code>
         * <pre><code>
         * var rpc = new easyXDM.Rpc({
         * &nbsp; ...
         * },{
         * &nbsp; local: {...},
         * &nbsp; remote: {...},
         * &nbsp; serializer : {
         * &nbsp; &nbsp; parse: function(string){ ... },
         * &nbsp; &nbsp; stringify: function(object) {...}
         * &nbsp; }
         * });
         * </code></pre>
         * If <code>serializer</code> is set then the class will not attempt to use the native implementation.
         * @namespace easyXDM
         * @constructor
         * @param {Object} config The underlying transports configuration. See easyXDM.Socket for available parameters.
         * @param {Object} jsonRpcConfig The description of the interface to implement.
         */
    easyXDM.Rpc = function(config, jsonRpcConfig) {

            // expand shorthand notation
      if (jsonRpcConfig.local) {
        for (var method in jsonRpcConfig.local) {
          if (jsonRpcConfig.local.hasOwnProperty(method)) {
            var member = jsonRpcConfig.local[method];
            if (typeof member === "function") {
              jsonRpcConfig.local[method] = {
                method: member
              };
            }
          }
        }
      }

            // create the stack
      var stack = chainStack(prepareTransportStack(config).concat([new easyXDM.stack.RpcBehavior(this, jsonRpcConfig), {
        callback: function(success) {
          if (config.onReady) {
            config.onReady(success);
          }
        }
      }]));

            // set the origin
      this.origin = getLocation(config.remote);

            /**
             * Initiates the destruction of the stack.
             */
      this.destroy = function() {
        stack.destroy();
      };

      stack.init();
    };
        /*jslint evil: true, browser: true, immed: true, passfail: true, undef: true, newcap: true*/
        /*global easyXDM, window, escape, unescape, getLocation, appendQueryParameters, createFrame, debug, un, on, apply, whenReady, getParentObject, IFRAME_PREFIX*/
        //
        // easyXDM
        // http://easyxdm.net/
        // Copyright(c) 2009-2011, Øyvind Sean Kinsey, oyvind@kinsey.no.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a copy
        // of this software and associated documentation files (the "Software"), to deal
        // in the Software without restriction, including without limitation the rights
        // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        // copies of the Software, and to permit persons to whom the Software is
        // furnished to do so, subject to the following conditions:
        //
        // The above copyright notice and this permission notice shall be included in
        // all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        // THE SOFTWARE.
        //

        /**
         * @class easyXDM.stack.SameOriginTransport
         * SameOriginTransport is a transport class that can be used when both domains have the same origin.<br/>
         * This can be useful for testing and for when the main application supports both internal and external sources.
         * @namespace easyXDM.stack
         * @constructor
         * @param {Object} config The transports configuration.
         * @cfg {String} remote The remote document to communicate with.
         */
    easyXDM.stack.SameOriginTransport = function(config) {
      var pub, frame, send, targetOrigin;

      return (pub = {
        outgoing: function(message, domain, fn) {
          send(message);
          if (fn) {
            fn();
          }
        },
        destroy: function() {
          if (frame) {
            frame.parentNode.removeChild(frame);
            frame = null;
          }
        },
        onDOMReady: function() {
          targetOrigin = getLocation(config.remote);

          if (config.isHost) {
                        // set up the iframe
            apply(config.props, {
              src: appendQueryParameters(config.remote, {
                xdm_e: location.protocol + "//" + location.host + location.pathname,
                xdm_c: config.channel,
                xdm_p: 4 // 4 = SameOriginTransport
              }),
              name: IFRAME_PREFIX + config.channel + "_provider"
            });
            frame = createFrame(config);
            easyXDM.Fn.set(config.channel, function(sendFn) {
              send = sendFn;
              setTimeout(function() {
                pub.up.callback(true);
              }, 0);
              return function(msg) {
                pub.up.incoming(msg, targetOrigin);
              };
            });
          } else {
            send = getParentObject().Fn.get(config.channel, true)(function(msg) {
              pub.up.incoming(msg, targetOrigin);
            });
            setTimeout(function() {
              pub.up.callback(true);
            }, 0);
          }
        },
        init: function() {
          whenReady(pub.onDOMReady, pub);
        }
      });
    };
        /*jslint evil: true, browser: true, immed: true, passfail: true, undef: true, newcap: true*/
        /*global global, easyXDM, window, getLocation, appendQueryParameters, createFrame, debug, apply, whenReady, IFRAME_PREFIX, namespace, resolveUrl, getDomainName, HAS_FLASH_THROTTLED_BUG, getPort, query*/
        //
        // easyXDM
        // http://easyxdm.net/
        // Copyright(c) 2009-2011, Øyvind Sean Kinsey, oyvind@kinsey.no.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a copy
        // of this software and associated documentation files (the "Software"), to deal
        // in the Software without restriction, including without limitation the rights
        // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        // copies of the Software, and to permit persons to whom the Software is
        // furnished to do so, subject to the following conditions:
        //
        // The above copyright notice and this permission notice shall be included in
        // all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        // THE SOFTWARE.
        //

        /**
         * @class easyXDM.stack.FlashTransport
         * FlashTransport is a transport class that uses an SWF with LocalConnection to pass messages back and forth.
         * @namespace easyXDM.stack
         * @constructor
         * @param {Object} config The transports configuration.
         * @cfg {String} remote The remote domain to communicate with.
         * @cfg {String} secret the pre-shared secret used to secure the communication.
         * @cfg {String} swf The path to the swf file
         * @cfg {Boolean} swfNoThrottle Set this to true if you want to take steps to avoid beeing throttled when hidden.
         * @cfg {String || DOMElement} swfContainer Set this if you want to control where the swf is placed
         */
    easyXDM.stack.FlashTransport = function(config) {
      var pub, // the public interface
        frame, send, targetOrigin, swf, swfContainer;

      function onMessage(message, origin) {
        setTimeout(function() {
          pub.up.incoming(message, targetOrigin);
        }, 0);
      }

            /**
             * This method adds the SWF to the DOM and prepares the initialization of the channel
             */
      function addSwf(domain) {
                // the differentiating query argument is needed in Flash9 to avoid a caching issue where LocalConnection would throw an error.
        var url = config.swf + "?host=" + config.isHost;
        var id = "easyXDM_swf_" + Math.floor(Math.random() * 10000);

                // prepare the init function that will fire once the swf is ready
        easyXDM.Fn.set("flash_loaded" + domain.replace(/[\-.]/g, "_"), function() {
          easyXDM.stack.FlashTransport[domain].swf = swf = swfContainer.firstChild;
          var queue = easyXDM.stack.FlashTransport[domain].queue;
          for (var i = 0; i < queue.length; i++) {
            queue[i]();
          }
          queue.length = 0;
        });

        if (config.swfContainer) {
          swfContainer = (typeof config.swfContainer == "string") ? document.getElementById(config.swfContainer) : config.swfContainer;
        } else {
                    // create the container that will hold the swf
          swfContainer = document.createElement('div');

                    // http://bugs.adobe.com/jira/browse/FP-4796
                    // http://tech.groups.yahoo.com/group/flexcoders/message/162365
                    // https://groups.google.com/forum/#!topic/easyxdm/mJZJhWagoLc
          apply(swfContainer.style, HAS_FLASH_THROTTLED_BUG && config.swfNoThrottle ? {
            height: "20px",
            width: "20px",
            position: "fixed",
            right: 0,
            top: 0
          } : {
            height: "1px",
            width: "1px",
            position: "absolute",
            overflow: "hidden",
            right: 0,
            top: 0
          });
          document.body.appendChild(swfContainer);
        }

                // create the object/embed
        var flashVars = "callback=flash_loaded" + domain.replace(/[\-.]/g, "_") + "&proto=" + global.location.protocol + "&domain=" + getDomainName(global.location.href) + "&port=" + getPort(global.location.href) + "&ns=" + namespace;
        swfContainer.innerHTML = "<object height='20' width='20' type='application/x-shockwave-flash' id='" + id + "' data='" + url + "'>" +
                    "<param name='allowScriptAccess' value='always'></param>" +
                    "<param name='wmode' value='transparent'>" +
                    "<param name='movie' value='" +
                    url +
                    "'></param>" +
                    "<param name='flashvars' value='" +
                    flashVars +
                    "'></param>" +
                    "<embed type='application/x-shockwave-flash' FlashVars='" +
                    flashVars +
                    "' allowScriptAccess='always' wmode='transparent' src='" +
                    url +
                    "' height='1' width='1'></embed>" +
                    "</object>";
      }

      return (pub = {
        outgoing: function(message, domain, fn) {
          swf.postMessage(config.channel, message.toString());
          if (fn) {
            fn();
          }
        },
        destroy: function() {
          try {
            swf.destroyChannel(config.channel);
          } catch (e) {
                        // swallow error
          }
          swf = null;
          if (frame) {
            frame.parentNode.removeChild(frame);
            frame = null;
          }
        },
        onDOMReady: function() {

          targetOrigin = config.remote;

                    // Prepare the code that will be run after the swf has been intialized
          easyXDM.Fn.set("flash_" + config.channel + "_init", function() {
            setTimeout(function() {
              pub.up.callback(true);
            });
          });

                    // set up the omMessage handler
          easyXDM.Fn.set("flash_" + config.channel + "_onMessage", onMessage);

          config.swf = resolveUrl(config.swf); // reports have been made of requests gone rogue when using relative paths
          var swfdomain = getDomainName(config.swf);
          var fn = function() {
                        // set init to true in case the fn was called was invoked from a separate instance
            easyXDM.stack.FlashTransport[swfdomain].init = true;
            swf = easyXDM.stack.FlashTransport[swfdomain].swf;
                        // create the channel
            swf.createChannel(config.channel, config.secret, getLocation(config.remote), config.isHost);

            if (config.isHost) {
                            // if Flash is going to be throttled and we want to avoid this
              if (HAS_FLASH_THROTTLED_BUG && config.swfNoThrottle) {
                apply(config.props, {
                  position: "fixed",
                  right: 0,
                  top: 0,
                  height: "20px",
                  width: "20px"
                });
              }
                            // set up the iframe
              apply(config.props, {
                src: appendQueryParameters(config.remote, {
                  xdm_e: getLocation(location.href),
                  xdm_c: config.channel,
                  xdm_p: 6, // 6 = FlashTransport
                  xdm_s: config.secret
                }),
                name: IFRAME_PREFIX + config.channel + "_provider"
              });
              frame = createFrame(config);
            }
          };

          if (easyXDM.stack.FlashTransport[swfdomain] && easyXDM.stack.FlashTransport[swfdomain].init) {
                        // if the swf is in place and we are the consumer
            fn();
          } else {
                        // if the swf does not yet exist
            if (!easyXDM.stack.FlashTransport[swfdomain]) {
                            // add the queue to hold the init fn's
              easyXDM.stack.FlashTransport[swfdomain] = {
                queue: [fn]
              };
              addSwf(swfdomain);
            } else {
              easyXDM.stack.FlashTransport[swfdomain].queue.push(fn);
            }
          }
        },
        init: function() {
          whenReady(pub.onDOMReady, pub);
        }
      });
    };
        /*jslint evil: true, browser: true, immed: true, passfail: true, undef: true, newcap: true*/
        /*global easyXDM, window, escape, unescape, getLocation, appendQueryParameters, createFrame, debug, un, on, apply, whenReady, IFRAME_PREFIX*/
        //
        // easyXDM
        // http://easyxdm.net/
        // Copyright(c) 2009-2011, Øyvind Sean Kinsey, oyvind@kinsey.no.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a copy
        // of this software and associated documentation files (the "Software"), to deal
        // in the Software without restriction, including without limitation the rights
        // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        // copies of the Software, and to permit persons to whom the Software is
        // furnished to do so, subject to the following conditions:
        //
        // The above copyright notice and this permission notice shall be included in
        // all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        // THE SOFTWARE.
        //

        /**
         * @class easyXDM.stack.PostMessageTransport
         * PostMessageTransport is a transport class that uses HTML5 postMessage for communication.<br/>
         * <a href="http://msdn.microsoft.com/en-us/library/ms644944(VS.85).aspx">http://msdn.microsoft.com/en-us/library/ms644944(VS.85).aspx</a><br/>
         * <a href="https://developer.mozilla.org/en/DOM/window.postMessage">https://developer.mozilla.org/en/DOM/window.postMessage</a>
         * @namespace easyXDM.stack
         * @constructor
         * @param {Object} config The transports configuration.
         * @cfg {String} remote The remote domain to communicate with.
         */
    easyXDM.stack.PostMessageTransport = function(config) {
      var pub, // the public interface
        frame, // the remote frame, if any
        callerWindow, // the window that we will call with
        targetOrigin; // the domain to communicate with
            /**
             * Resolves the origin from the event object
             * @private
             * @param {Object} event The messageevent
             * @return {String} The scheme, host and port of the origin
             */
      function _getOrigin(event) {
        if (event.origin) {
                    // This is the HTML5 property
          return getLocation(event.origin);
        }
        if (event.uri) {
                    // From earlier implementations
          return getLocation(event.uri);
        }
        if (event.domain) {
                    // This is the last option and will fail if the
                    // origin is not using the same schema as we are
          return location.protocol + "//" + event.domain;
        }
        throw "Unable to retrieve the origin of the event";
      }

            /**
             * This is the main implementation for the onMessage event.<br/>
             * It checks the validity of the origin and passes the message on if appropriate.
             * @private
             * @param {Object} event The messageevent
             */
      function _window_onMessage(event) {
        var origin = _getOrigin(event);
        if (origin == targetOrigin && event.data.substring(0, config.channel.length + 1) == config.channel + " ") {
          pub.up.incoming(event.data.substring(config.channel.length + 1), origin);
        }
      }

      return (pub = {
        outgoing: function(message, domain, fn) {
          callerWindow.postMessage(config.channel + " " + message, domain || targetOrigin);
          if (fn) {
            fn();
          }
        },
        destroy: function() {
          un(window, "message", _window_onMessage);
          if (frame) {
            callerWindow = null;
            frame.parentNode.removeChild(frame);
            frame = null;
          }
        },
        onDOMReady: function() {
          targetOrigin = getLocation(config.remote);
          if (config.isHost) {
                        // add the event handler for listening
            var waitForReady = function(event) {
              if (event.data == config.channel + "-ready") {
                                // replace the eventlistener
                callerWindow = ("postMessage" in frame.contentWindow) ? frame.contentWindow : frame.contentWindow.document;
                un(window, "message", waitForReady);
                on(window, "message", _window_onMessage);
                setTimeout(function() {
                  pub.up.callback(true);
                }, 0);
              }
            };
            on(window, "message", waitForReady);

                        // set up the iframe
            apply(config.props, {
              src: appendQueryParameters(config.remote, {
                xdm_e: getLocation(location.href),
                xdm_c: config.channel,
                xdm_p: 1 // 1 = PostMessage
              }),
              name: IFRAME_PREFIX + config.channel + "_provider"
            });
            frame = createFrame(config);
          } else {
                        // add the event handler for listening
            on(window, "message", _window_onMessage);
            callerWindow = ("postMessage" in window.parent) ? window.parent : window.parent.document;
            callerWindow.postMessage(config.channel + "-ready", targetOrigin);

            setTimeout(function() {
              pub.up.callback(true);
            }, 0);
          }
        },
        init: function() {
          whenReady(pub.onDOMReady, pub);
        }
      });
    };
        /*jslint evil: true, browser: true, immed: true, passfail: true, undef: true, newcap: true*/
        /*global easyXDM, window, escape, unescape, getLocation, appendQueryParameters, createFrame, debug, apply, query, whenReady, IFRAME_PREFIX*/
        //
        // easyXDM
        // http://easyxdm.net/
        // Copyright(c) 2009-2011, Øyvind Sean Kinsey, oyvind@kinsey.no.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a copy
        // of this software and associated documentation files (the "Software"), to deal
        // in the Software without restriction, including without limitation the rights
        // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        // copies of the Software, and to permit persons to whom the Software is
        // furnished to do so, subject to the following conditions:
        //
        // The above copyright notice and this permission notice shall be included in
        // all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        // THE SOFTWARE.
        //

        /**
         * @class easyXDM.stack.FrameElementTransport
         * FrameElementTransport is a transport class that can be used with Gecko-browser as these allow passing variables using the frameElement property.<br/>
         * Security is maintained as Gecho uses Lexical Authorization to determine under which scope a function is running.
         * @namespace easyXDM.stack
         * @constructor
         * @param {Object} config The transports configuration.
         * @cfg {String} remote The remote document to communicate with.
         */
    easyXDM.stack.FrameElementTransport = function(config) {
      var pub, frame, send, targetOrigin;

      return (pub = {
        outgoing: function(message, domain, fn) {
          send.call(this, message);
          if (fn) {
            fn();
          }
        },
        destroy: function() {
          if (frame) {
            frame.parentNode.removeChild(frame);
            frame = null;
          }
        },
        onDOMReady: function() {
          targetOrigin = getLocation(config.remote);

          if (config.isHost) {
                        // set up the iframe
            apply(config.props, {
              src: appendQueryParameters(config.remote, {
                xdm_e: getLocation(location.href),
                xdm_c: config.channel,
                xdm_p: 5 // 5 = FrameElementTransport
              }),
              name: IFRAME_PREFIX + config.channel + "_provider"
            });
            frame = createFrame(config);
            frame.fn = function(sendFn) {
              delete frame.fn;
              send = sendFn;
              setTimeout(function() {
                pub.up.callback(true);
              }, 0);
                            // remove the function so that it cannot be used to overwrite the send function later on
              return function(msg) {
                pub.up.incoming(msg, targetOrigin);
              };
            };
          } else {
                        // This is to mitigate origin-spoofing
            if (document.referrer && getLocation(document.referrer) != query.xdm_e) {
              window.top.location = query.xdm_e;
            }
            send = window.frameElement.fn(function(msg) {
              pub.up.incoming(msg, targetOrigin);
            });
            pub.up.callback(true);
          }
        },
        init: function() {
          whenReady(pub.onDOMReady, pub);
        }
      });
    };
        /*jslint evil: true, browser: true, immed: true, passfail: true, undef: true, newcap: true*/
        /*global easyXDM, window, escape, unescape, undef, getLocation, appendQueryParameters, resolveUrl, createFrame, debug, un, apply, whenReady, IFRAME_PREFIX*/
        //
        // easyXDM
        // http://easyxdm.net/
        // Copyright(c) 2009-2011, Øyvind Sean Kinsey, oyvind@kinsey.no.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a copy
        // of this software and associated documentation files (the "Software"), to deal
        // in the Software without restriction, including without limitation the rights
        // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        // copies of the Software, and to permit persons to whom the Software is
        // furnished to do so, subject to the following conditions:
        //
        // The above copyright notice and this permission notice shall be included in
        // all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        // THE SOFTWARE.
        //

        /**
         * @class easyXDM.stack.NameTransport
         * NameTransport uses the window.name property to relay data.
         * The <code>local</code> parameter needs to be set on both the consumer and provider,<br/>
         * and the <code>remoteHelper</code> parameter needs to be set on the consumer.
         * @constructor
         * @param {Object} config The transports configuration.
         * @cfg {String} remoteHelper The url to the remote instance of hash.html - this is only needed for the host.
         * @namespace easyXDM.stack
         */
    easyXDM.stack.NameTransport = function(config) {

      var pub; // the public interface
      var isHost, callerWindow, remoteWindow, readyCount, callback, remoteOrigin, remoteUrl;

      function _sendMessage(message) {
        var url = config.remoteHelper + (isHost ? "#_3" : "#_2") + config.channel;
        callerWindow.contentWindow.sendMessage(message, url);
      }

      function _onReady() {
        if (isHost) {
          if (++readyCount === 2 || !isHost) {
            pub.up.callback(true);
          }
        } else {
          _sendMessage("ready");
          pub.up.callback(true);
        }
      }

      function _onMessage(message) {
        pub.up.incoming(message, remoteOrigin);
      }

      function _onLoad() {
        if (callback) {
          setTimeout(function() {
            callback(true);
          }, 0);
        }
      }

      return (pub = {
        outgoing: function(message, domain, fn) {
          callback = fn;
          _sendMessage(message);
        },
        destroy: function() {
          callerWindow.parentNode.removeChild(callerWindow);
          callerWindow = null;
          if (isHost) {
            remoteWindow.parentNode.removeChild(remoteWindow);
            remoteWindow = null;
          }
        },
        onDOMReady: function() {
          isHost = config.isHost;
          readyCount = 0;
          remoteOrigin = getLocation(config.remote);
          config.local = resolveUrl(config.local);

          if (isHost) {
                        // Register the callback
            easyXDM.Fn.set(config.channel, function(message) {
              if (isHost && message === "ready") {
                                // Replace the handler
                easyXDM.Fn.set(config.channel, _onMessage);
                _onReady();
              }
            });

                        // Set up the frame that points to the remote instance
            remoteUrl = appendQueryParameters(config.remote, {
              xdm_e: config.local,
              xdm_c: config.channel,
              xdm_p: 2
            });
            apply(config.props, {
              src: remoteUrl + '#' + config.channel,
              name: IFRAME_PREFIX + config.channel + "_provider"
            });
            remoteWindow = createFrame(config);
          } else {
            config.remoteHelper = config.remote;
            easyXDM.Fn.set(config.channel, _onMessage);
          }

                    // Set up the iframe that will be used for the transport
          var onLoad = function() {
                        // Remove the handler
            var w = callerWindow || this;
            un(w, "load", onLoad);
            easyXDM.Fn.set(config.channel + "_load", _onLoad);
            (function test() {
              if (typeof w.contentWindow.sendMessage == "function") {
                _onReady();
              } else {
                setTimeout(test, 50);
              }
            }());
          };

          callerWindow = createFrame({
            props: {
              src: config.local + "#_4" + config.channel
            },
            onLoad: onLoad
          });
        },
        init: function() {
          whenReady(pub.onDOMReady, pub);
        }
      });
    };
        /*jslint evil: true, browser: true, immed: true, passfail: true, undef: true, newcap: true*/
        /*global easyXDM, window, escape, unescape, getLocation, createFrame, debug, un, on, apply, whenReady, IFRAME_PREFIX*/
        //
        // easyXDM
        // http://easyxdm.net/
        // Copyright(c) 2009-2011, Øyvind Sean Kinsey, oyvind@kinsey.no.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a copy
        // of this software and associated documentation files (the "Software"), to deal
        // in the Software without restriction, including without limitation the rights
        // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        // copies of the Software, and to permit persons to whom the Software is
        // furnished to do so, subject to the following conditions:
        //
        // The above copyright notice and this permission notice shall be included in
        // all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        // THE SOFTWARE.
        //

        /**
         * @class easyXDM.stack.HashTransport
         * HashTransport is a transport class that uses the IFrame URL Technique for communication.<br/>
         * <a href="http://msdn.microsoft.com/en-us/library/bb735305.aspx">http://msdn.microsoft.com/en-us/library/bb735305.aspx</a><br/>
         * @namespace easyXDM.stack
         * @constructor
         * @param {Object} config The transports configuration.
         * @cfg {String/Window} local The url to the local file used for proxying messages, or the local window.
         * @cfg {Number} delay The number of milliseconds easyXDM should try to get a reference to the local window.
         * @cfg {Number} interval The interval used when polling for messages.
         */
    easyXDM.stack.HashTransport = function(config) {
      var pub;
      var me = this,
        isHost, _timer, pollInterval, _lastMsg, _msgNr, _listenerWindow, _callerWindow;
      var useParent, _remoteOrigin;

      function _sendMessage(message) {
        if (!_callerWindow) {
          return;
        }
        var url = config.remote + "#" + (_msgNr++) + "_" + message;
        ((isHost || !useParent) ? _callerWindow.contentWindow : _callerWindow).location = url;
      }

      function _handleHash(hash) {
        _lastMsg = hash;
        pub.up.incoming(_lastMsg.substring(_lastMsg.indexOf("_") + 1), _remoteOrigin);
      }

            /**
             * Checks location.hash for a new message and relays this to the receiver.
             * @private
             */
      function _pollHash() {
        if (!_listenerWindow) {
          return;
        }
        var href = _listenerWindow.location.href,
          hash = "",
          indexOf = href.indexOf("#");
        if (indexOf != -1) {
          hash = href.substring(indexOf);
        }
        if (hash && hash != _lastMsg) {
          _handleHash(hash);
        }
      }

      function _attachListeners() {
        _timer = setInterval(_pollHash, pollInterval);
      }

      return (pub = {
        outgoing: function(message, domain) {
          _sendMessage(message);
        },
        destroy: function() {
          window.clearInterval(_timer);
          if (isHost || !useParent) {
            _callerWindow.parentNode.removeChild(_callerWindow);
          }
          _callerWindow = null;
        },
        onDOMReady: function() {
          isHost = config.isHost;
          pollInterval = config.interval;
          _lastMsg = "#" + config.channel;
          _msgNr = 0;
          useParent = config.useParent;
          _remoteOrigin = getLocation(config.remote);
          if (isHost) {
            apply(config.props, {
              src: config.remote,
              name: IFRAME_PREFIX + config.channel + "_provider"
            });
            if (useParent) {
              config.onLoad = function() {
                _listenerWindow = window;
                _attachListeners();
                pub.up.callback(true);
              };
            } else {
              var tries = 0,
                max = config.delay / 50;
              (function getRef() {
                if (++tries > max) {
                  throw new Error("Unable to reference listenerwindow");
                }
                try {
                  _listenerWindow = _callerWindow.contentWindow.frames[IFRAME_PREFIX + config.channel + "_consumer"];
                } catch (ex) {
                                    // swallow error
                }
                if (_listenerWindow) {
                  _attachListeners();
                  pub.up.callback(true);
                } else {
                  setTimeout(getRef, 50);
                }
              }());
            }
            _callerWindow = createFrame(config);
          } else {
            _listenerWindow = window;
            _attachListeners();
            if (useParent) {
              _callerWindow = parent;
              pub.up.callback(true);
            } else {
              apply(config, {
                props: {
                  src: config.remote + "#" + config.channel + new Date(),
                  name: IFRAME_PREFIX + config.channel + "_consumer"
                },
                onLoad: function() {
                  pub.up.callback(true);
                }
              });
              _callerWindow = createFrame(config);
            }
          }
        },
        init: function() {
          whenReady(pub.onDOMReady, pub);
        }
      });
    };
        /*jslint evil: true, browser: true, immed: true, passfail: true, undef: true, newcap: true*/
        /*global easyXDM, window, escape, unescape, debug */
        //
        // easyXDM
        // http://easyxdm.net/
        // Copyright(c) 2009-2011, Øyvind Sean Kinsey, oyvind@kinsey.no.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a copy
        // of this software and associated documentation files (the "Software"), to deal
        // in the Software without restriction, including without limitation the rights
        // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        // copies of the Software, and to permit persons to whom the Software is
        // furnished to do so, subject to the following conditions:
        //
        // The above copyright notice and this permission notice shall be included in
        // all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        // THE SOFTWARE.
        //

        /**
         * @class easyXDM.stack.ReliableBehavior
         * This is a behavior that tries to make the underlying transport reliable by using acknowledgements.
         * @namespace easyXDM.stack
         * @constructor
         * @param {Object} config The behaviors configuration.
         */
    easyXDM.stack.ReliableBehavior = function(config) {
      var pub, // the public interface
        callback; // the callback to execute when we have a confirmed success/failure
      var idOut = 0,
        idIn = 0,
        currentMessage = "";

      return (pub = {
        incoming: function(message, origin) {
          var indexOf = message.indexOf("_"),
            ack = message.substring(0, indexOf).split(",");
          message = message.substring(indexOf + 1);

          if (ack[0] == idOut) {
            currentMessage = "";
            if (callback) {
              callback(true);
              callback = null;
            }
          }
          if (message.length > 0) {
            pub.down.outgoing(ack[1] + "," + idOut + "_" + currentMessage, origin);
            if (idIn != ack[1]) {
              idIn = ack[1];
              pub.up.incoming(message, origin);
            }
          }

        },
        outgoing: function(message, origin, fn) {
          currentMessage = message;
          callback = fn;
          pub.down.outgoing(idIn + "," + (++idOut) + "_" + message, origin);
        }
      });
    };
        /*jslint evil: true, browser: true, immed: true, passfail: true, undef: true, newcap: true*/
        /*global easyXDM, window, escape, unescape, debug, undef, removeFromStack*/
        //
        // easyXDM
        // http://easyxdm.net/
        // Copyright(c) 2009-2011, Øyvind Sean Kinsey, oyvind@kinsey.no.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a copy
        // of this software and associated documentation files (the "Software"), to deal
        // in the Software without restriction, including without limitation the rights
        // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        // copies of the Software, and to permit persons to whom the Software is
        // furnished to do so, subject to the following conditions:
        //
        // The above copyright notice and this permission notice shall be included in
        // all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        // THE SOFTWARE.
        //

        /**
         * @class easyXDM.stack.QueueBehavior
         * This is a behavior that enables queueing of messages. <br/>
         * It will buffer incoming messages and dispach these as fast as the underlying transport allows.
         * This will also fragment/defragment messages so that the outgoing message is never bigger than the
         * set length.
         * @namespace easyXDM.stack
         * @constructor
         * @param {Object} config The behaviors configuration. Optional.
         * @cfg {Number} maxLength The maximum length of each outgoing message. Set this to enable fragmentation.
         */
    easyXDM.stack.QueueBehavior = function(config) {
      var pub, queue = [],
        waiting = true,
        incoming = "",
        destroying, maxLength = 0,
        lazy = false,
        doFragment = false;

      function dispatch() {
        if (config.remove && queue.length === 0) {
          removeFromStack(pub);
          return;
        }
        if (waiting || queue.length === 0 || destroying) {
          return;
        }
        waiting = true;
        var message = queue.shift();

        pub.down.outgoing(message.data, message.origin, function(success) {
          waiting = false;
          if (message.callback) {
            setTimeout(function() {
              message.callback(success);
            }, 0);
          }
          dispatch();
        });
      }
      return (pub = {
        init: function() {
          if (undef(config)) {
            config = {};
          }
          if (config.maxLength) {
            maxLength = config.maxLength;
            doFragment = true;
          }
          if (config.lazy) {
            lazy = true;
          } else {
            pub.down.init();
          }
        },
        callback: function(success) {
          waiting = false;
          var up = pub.up; // in case dispatch calls removeFromStack
          dispatch();
          up.callback(success);
        },
        incoming: function(message, origin) {
          if (doFragment) {
            var indexOf = message.indexOf("_"),
              seq = parseInt(message.substring(0, indexOf), 10);
            incoming += message.substring(indexOf + 1);
            if (seq === 0) {
              if (config.encode) {
                incoming = decodeURIComponent(incoming);
              }
              pub.up.incoming(incoming, origin);
              incoming = "";
            }
          } else {
            pub.up.incoming(message, origin);
          }
        },
        outgoing: function(message, origin, fn) {
          if (config.encode) {
            message = encodeURIComponent(message);
          }
          var fragments = [],
            fragment;
          if (doFragment) {
                        // fragment into chunks
            while (message.length !== 0) {
              fragment = message.substring(0, maxLength);
              message = message.substring(fragment.length);
              fragments.push(fragment);
            }
                        // enqueue the chunks
            while ((fragment = fragments.shift())) {
              queue.push({
                data: fragments.length + "_" + fragment,
                origin: origin,
                callback: fragments.length === 0 ? fn : null
              });
            }
          } else {
            queue.push({
              data: message,
              origin: origin,
              callback: fn
            });
          }
          if (lazy) {
            pub.down.init();
          } else {
            dispatch();
          }
        },
        destroy: function() {
          destroying = true;
          pub.down.destroy();
        }
      });
    };
        /*jslint evil: true, browser: true, immed: true, passfail: true, undef: true, newcap: true*/
        /*global easyXDM, window, escape, unescape, undef, debug */
        //
        // easyXDM
        // http://easyxdm.net/
        // Copyright(c) 2009-2011, Øyvind Sean Kinsey, oyvind@kinsey.no.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a copy
        // of this software and associated documentation files (the "Software"), to deal
        // in the Software without restriction, including without limitation the rights
        // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        // copies of the Software, and to permit persons to whom the Software is
        // furnished to do so, subject to the following conditions:
        //
        // The above copyright notice and this permission notice shall be included in
        // all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        // THE SOFTWARE.
        //

        /**
         * @class easyXDM.stack.VerifyBehavior
         * This behavior will verify that communication with the remote end is possible, and will also sign all outgoing,
         * and verify all incoming messages. This removes the risk of someone hijacking the iframe to send malicious messages.
         * @namespace easyXDM.stack
         * @constructor
         * @param {Object} config The behaviors configuration.
         * @cfg {Boolean} initiate If the verification should be initiated from this end.
         */
    easyXDM.stack.VerifyBehavior = function(config) {
      var pub, mySecret, theirSecret, verified = false;

      function startVerification() {
        mySecret = Math.random().toString(16).substring(2);
        pub.down.outgoing(mySecret);
      }

      return (pub = {
        incoming: function(message, origin) {
          var indexOf = message.indexOf("_");
          if (indexOf === -1) {
            if (message === mySecret) {
              pub.up.callback(true);
            } else if (!theirSecret) {
              theirSecret = message;
              if (!config.initiate) {
                startVerification();
              }
              pub.down.outgoing(message);
            }
          } else {
            if (message.substring(0, indexOf) === theirSecret) {
              pub.up.incoming(message.substring(indexOf + 1), origin);
            }
          }
        },
        outgoing: function(message, origin, fn) {
          pub.down.outgoing(mySecret + "_" + message, origin, fn);
        },
        callback: function(success) {
          if (config.initiate) {
            startVerification();
          }
        }
      });
    };
        /*jslint evil: true, browser: true, immed: true, passfail: true, undef: true, newcap: true*/
        /*global easyXDM, window, escape, unescape, undef, getJSON, debug, emptyFn, isArray */
        //
        // easyXDM
        // http://easyxdm.net/
        // Copyright(c) 2009-2011, Øyvind Sean Kinsey, oyvind@kinsey.no.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a copy
        // of this software and associated documentation files (the "Software"), to deal
        // in the Software without restriction, including without limitation the rights
        // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
        // copies of the Software, and to permit persons to whom the Software is
        // furnished to do so, subject to the following conditions:
        //
        // The above copyright notice and this permission notice shall be included in
        // all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
        // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
        // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
        // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
        // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
        // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
        // THE SOFTWARE.
        //

        /**
         * @class easyXDM.stack.RpcBehavior
         * This uses JSON-RPC 2.0 to expose local methods and to invoke remote methods and have responses returned over the the string based transport stack.<br/>
         * Exposed methods can return values synchronous, asyncronous, or bet set up to not return anything.
         * @namespace easyXDM.stack
         * @constructor
         * @param {Object} proxy The object to apply the methods to.
         * @param {Object} config The definition of the local and remote interface to implement.
         * @cfg {Object} local The local interface to expose.
         * @cfg {Object} remote The remote methods to expose through the proxy.
         * @cfg {Object} serializer The serializer to use for serializing and deserializing the JSON. Should be compatible with the HTML5 JSON object. Optional, will default to JSON.
         */
    easyXDM.stack.RpcBehavior = function(proxy, config) {
      var pub, serializer = config.serializer || getJSON();
      var _callbackCounter = 0,
        _callbacks = {};

            /**
             * Serializes and sends the message
             * @private
             * @param {Object} data The JSON-RPC message to be sent. The jsonrpc property will be added.
             */
      function _send(data) {
        data.jsonrpc = "2.0";
        pub.down.outgoing(serializer.stringify(data));
      }

            /**
             * Creates a method that implements the given definition
             * @private
             * @param {Object} The method configuration
             * @param {String} method The name of the method
             * @return {Function} A stub capable of proxying the requested method call
             */
      function _createMethod(definition, method) {
        var slice = Array.prototype.slice;

        return function() {
          var l = arguments.length,
            callback, message = {
              method: method
            };

          if (l > 0 && typeof arguments[l - 1] === "function") {
                        //with callback, procedure
            if (l > 1 && typeof arguments[l - 2] === "function") {
                            // two callbacks, success and error
              callback = {
                success: arguments[l - 2],
                error: arguments[l - 1]
              };
              message.params = slice.call(arguments, 0, l - 2);
            } else {
                            // single callback, success
              callback = {
                success: arguments[l - 1]
              };
              message.params = slice.call(arguments, 0, l - 1);
            }
            _callbacks["" + (++_callbackCounter)] = callback;
            message.id = _callbackCounter;
          } else {
                        // no callbacks, a notification
            message.params = slice.call(arguments, 0);
          }
          if (definition.namedParams && message.params.length === 1) {
            message.params = message.params[0];
          }
                    // Send the method request
          _send(message);
        };
      }

            /**
             * Executes the exposed method
             * @private
             * @param {String} method The name of the method
             * @param {Number} id The callback id to use
             * @param {Function} method The exposed implementation
             * @param {Array} params The parameters supplied by the remote end
             */
      function _executeMethod(method, id, fn, params) {
        if (!fn) {
          if (id) {
            _send({
              id: id,
              error: {
                code: -32601,
                message: "Procedure not found."
              }
            });
          }
          return;
        }

        var success, error;
        if (id) {
          success = function(result) {
            success = emptyFn;
            _send({
              id: id,
              result: result
            });
          };
          error = function(message, data) {
            error = emptyFn;
            var msg = {
              id: id,
              error: {
                code: -32099,
                message: message
              }
            };
            if (data) {
              msg.error.data = data;
            }
            _send(msg);
          };
        } else {
          success = error = emptyFn;
        }
                // Call local method
        if (!isArray(params)) {
          params = [params];
        }
        try {
          var result = fn.method.apply(fn.scope, params.concat([success, error]));
          if (!undef(result)) {
            success(result);
          }
        } catch (ex1) {
          error(ex1.message);
        }
      }

      return (pub = {
        incoming: function(message, origin) {
          var data = serializer.parse(message);
          if (data.method) {
                        // A method call from the remote end
            if (config.handle) {
              config.handle(data, _send);
            } else {
              _executeMethod(data.method, data.id, config.local[data.method], data.params);
            }
          } else {
                        // A method response from the other end
            var callback = _callbacks[data.id];
            if (data.error) {
              if (callback.error) {
                callback.error(data.error);
              }
            } else if (callback.success) {
              callback.success(data.result);
            }
            delete _callbacks[data.id];
          }
        },
        init: function() {
          if (config.remote) {
                        // Implement the remote sides exposed methods
            for (var method in config.remote) {
              if (config.remote.hasOwnProperty(method)) {
                proxy[method] = _createMethod(config.remote[method], method);
              }
            }
          }
          pub.down.init();
        },
        destroy: function() {
          for (var method in config.remote) {
            if (config.remote.hasOwnProperty(method) && proxy.hasOwnProperty(method)) {
              delete proxy[method];
            }
          }
          pub.down.destroy();
        }
      });
    };
    window.easyXDM = easyXDM;

        //returning the module instance
    return easyXDM;

    //})(window, document, location, window.setTimeout, decodeURIComponent, encodeURIComponent);

  });
/**
 * jquery.cors
 *
 * Implements CORS functionality for browsers supporting it natively with an automatic
 * fallback to easyXDM which implements cors via an embedded iframe or swf. To use it,
 * you must do two things:
 *
 * 1. Include the jquery plugin and use jquery.ajax calls as usual.
 * 2. Make jquery.cors available via require.js:
 * shim: {
 *   'jquery.cors/easyxdm/easyxdm': { exports: 'easyXDM' },
 * }
 * paths: {
 *   'jquery.cors':          'lib/jquery.cors/0.1',   // shim all paths
 * }
 * 3. Adjust jquery_cors_path to match the location where jquery.easyxdm.provider.js
 * 4. Adjust jquery.easyxdm.provider.js to allow calls from the domains needing CORS
 * 5. Adjust server to apply CORS headers for domains that should be able to. For
 *    Allow-Credentials to work properly, the server must dynamically set the Allow-Origin
 *    to match the Origin: from the request, you cannot simply use *
 *
 *    Access-Control-Allow-Credentials: true
 *    Access-Control-Allow-Origin: https://localhost:2443
 *    Access-Control-Allow-Methods: GET, POST, PUT, PATCH, DELETE, OPTIONS
 *    Access-Control-Allow-Headers: x-requested-with, content-type, accept, origin, authorization
 *
 */

  define('jquery.cors/jquery.cors',['require','underscore','jquery','json2','console-shim','jquery.cors/easyxdm/easyxdm'],function (require) {
    
    var _ = require('underscore'),
      $ = require('jquery'),
      JSON = require('json2'),
      console = require('console-shim'),
      easyXDM = require('jquery.cors/easyxdm/easyxdm'),
      jquery_cors_path = '/static-optimized/js/lib/jquery.cors/0.1/',
      easyXDM_path = jquery_cors_path + '/easyxdm/',
      easyXDM_connections = {},
      jquery_cors = {};
        // $.support.cors = false;

    /**
     * Configure jQuery for CrossDomain CORS requests
     */
    $.ajaxSetup({
      xhrFields: {
        withCredentials: true
      }
    });
    //console.log('using jquery cors');
    /**
     * register a custom ajaxTransport, per
     * http://api.jquery.com/jQuery.ajaxTransport/
     */
    $.ajaxTransport("+*", function (options, originalOptions, jqXHR) {

        // Uncomment these two lines if want to test easyXDM
        // $.support.cors = false;
        // options.crossDomain = true;

      if (options.crossDomain && !$.support.cors) {
        var provider_base_url = "",
          regexp_results = options.url.match(/^(https?:\/\/[^\/]*)\/?.*/);
        if (regexp_results) {
          provider_base_url = regexp_results[1];
        }

        if (!easyXDM_connections.hasOwnProperty(provider_base_url)) {
          console.log('creating easyXDM pool entry for ' + provider_base_url);
          easyXDM_connections[provider_base_url] = {
            callbackQueue: [],
            connection: undefined,
            error: undefined,
            state: "before"
          };
        }
        console.log('jquery.cors easyXDM request for ' + options.url + ' using ' + provider_base_url);

        return provider_base_url === "" ? null : {
          send: function (headers, completeCallback) {
            jquery_cors.getConnection(provider_base_url, {
              'success': function (easyXDM_connection) {
                function continuation_proxy(results) {
                  console.log('easyXDM connection for ' + options.url + ' via ' + provider_base_url + ' continuation proxy excecuting');
                  completeCallback(results.status,
                                    results.statusText,
                                    results.responses,
                                    results.headers
                                    );
                }
                originalOptions.context = null;
                easyXDM_connection.jquery_proxy(originalOptions, continuation_proxy);
                console.log('easyXDM connection for ' + options.url + ' via ' + provider_base_url + ' initialized');
              },
              'error': function () {
                console.log('easyXDM connection for ' + provider_base_url + ' failed to initialize');
              }
            });
          },
          'abort': function () {
            console.log('easyXDM connection for ' + provider_base_url + ' aborted');
          }
        };
      }
    });

    jquery_cors.doRequests = function (provider_base_url, callbacks) {
      var scoped_easyXDM = easyXDM.noConflict("jquery_easyXDM" + provider_base_url),
        remote_url = provider_base_url + jquery_cors_path + "jquery.easyxdm.provider.html";

      console.log('doRequests for ' + provider_base_url);

      jquery_cors.easyXDM = scoped_easyXDM;
      easyXDM_connections[provider_base_url]['connection'] = new jquery_cors.easyXDM.Rpc(
        {
          channel: provider_base_url,
          remote: remote_url,
          swf: provider_base_url + easyXDM_path + "easyxdm.swf",
          onReady: function () {
            callbacks.success(easyXDM_connections[provider_base_url]['connection']);
          }
        },
            { remote: { jquery_proxy: function() { console.log('jquery_proxy'); }}}
        );
    };

    jquery_cors.getConnection = function (provider_base_url, callbacks) {
      var i;

      switch (easyXDM_connections[provider_base_url]['state']) {
      case "before":
        console.log('before: ' + provider_base_url);
        easyXDM_connections[provider_base_url]['state'] = "working";
        easyXDM_connections[provider_base_url]['callbackQueue'].push(callbacks);
        jquery_cors.doRequests(provider_base_url,{
          'success': function (singletonInstance) {
            console.log('doRequests.success for ' + provider_base_url);
            easyXDM_connections[provider_base_url]['state'] = "success";
            easyXDM_connections[provider_base_url]['connection'] = singletonInstance;
            for (i = 0; i < easyXDM_connections[provider_base_url]['callbackQueue'].length; i++) {
              easyXDM_connections[provider_base_url]['callbackQueue'][i].success(easyXDM_connections[provider_base_url]['connection']);
            }
            easyXDM_connections[provider_base_url]['callbackQueue'] = [];
          },
          'failure': function (errorObj) {
            console.log('doRequests.failure for ' + provider_base_url);
            easyXDM_connections[provider_base_url]['state'] = "failure";
            easyXDM_connections[provider_base_url]['error'] = errorObj;
            for (i = 0; i < easyXDM_connections[provider_base_url]['callbackQueue'].length; i++) {
              easyXDM_connections[provider_base_url]['callbackQueue'][i].failure(errorObj);
            }
            easyXDM_connections[provider_base_url]['callbackQueue'] = [];
          }
        });
        break;
      case "working":
        console.log('working: ' + provider_base_url);
        easyXDM_connections[provider_base_url]['callbackQueue'].push(callbacks);
        break;
      case "success":
        console.log('success: ' + provider_base_url);
        callbacks.success(easyXDM_connections[provider_base_url]['connection']);
        break;
      case "failure":
        console.log('failure: ' + provider_base_url);
        callbacks.failure(easyXDM_connections[provider_base_url]['error']);
        break;
      default:
        console.log('invalid state: ' + provider_base_url);
        throw new Error("Invalid state: " + easyXDM_connections[provider_base_url]['state']);
      }
    };
    window.$ = $;
    window.jquery_cors = jquery_cors;
    return jquery_cors;
  });
/*global define,setTimeout,clearTimeout*/
  define('chiropractor/models/auth',['require','backbone','jquery','json-ie7','underscore','jquery.cookie'],function(require) {

    var Backbone = require('backbone'),
      $ = require('jquery'),
      JSON = require('json-ie7'),
      _ = require('underscore'),
      tokenCookie = 'wttoken',
      expirationWarningMinutes = 2,
      expirationWarningActive = false,
      expirationTimeoutId, expirationWarning,
      activeToken, getToken, setToken, clearToken;

    require('jquery.cookie');

    expirationWarning = function() {
      Backbone.Events.trigger('authentication:expiration');
      expirationWarningActive = true;

      expirationTimeoutId = setTimeout(
            function() {
              Backbone.Events.trigger('authentication:failure');
            },
            expirationWarningMinutes * 60 * 1000
        );
    };

    getToken = function() {
      if (typeof(activeToken) === 'undefined') {
        activeToken = $.cookie(tokenCookie);
      }
      return activeToken;
    };

    setToken = function(token) {
      var tokenComponents = token.split('::'),
        serverTime = tokenComponents[1],
        expireTime = tokenComponents[2],
            // We want an expiration alert to happen two minutes before the
            // token is going to expire.
        expirationTimeout = Math.max(
                0,
                expireTime - serverTime - (expirationWarningMinutes * 60)
            ) * 1000;

      activeToken = token;
      $.cookie(tokenCookie, token);

      if (expirationTimeoutId) {
        clearTimeout(expirationTimeoutId);
      }

      if (expirationWarningActive) {
        Backbone.Events.trigger('authentication:renewal');
        expirationWarningActive = false;
      }

      expirationTimeoutId = setTimeout(expirationWarning, expirationTimeout);
    };

    clearToken = function() {
      activeToken = undefined;
      $.removeCookie(tokenCookie);

      if (expirationTimeoutId) {
        clearTimeout(expirationTimeoutId);
      }
    };

    Backbone.Events.on(
        'authentication:logout authentication:failure',
        clearToken
    );

    return {
      sync: function(method, model, options) {
        var beforeSend = options.beforeSend,
          onError = options.error,
          onSuccess = options.success,
          self = this,
          opts = _(options).clone();

        options.success = function(model, data, xhr) {
          var token = xhr.getResponseHeader('Authorization');
          if (token) {
            setToken(token);
          }
          return onSuccess.apply(self, arguments);
        };

            // This is a jQuery error handler.
        options.error = function(xhr, statusText, error) {
          if (xhr.status === 400) {
                    // TODO: add logic to only trigger unauthenticated if the
                    // bad request is due to malformed token
            Backbone.Events.trigger('authentication:failure', self, xhr);
          }
          if (xhr.status === 401) {
            Backbone.Events.trigger('authentication:failure', self, xhr);

            self.listenToOnce(
                        Backbone.Events,
                        'authentication:success',
                        function() {
                          self.sync(method, model, opts);
                        }
                    );
          }

                // Call the original onError handler.
          if (onError) {
            return onError.apply(self, arguments);
          }
        };

        options.beforeSend = function(xhr) {
          var token = getToken();
          if (!self.disableAuthToken && token) {
            xhr.setRequestHeader(
                        'Authorization',
                        token
                    );
          }

          if (beforeSend) {
            return beforeSend.apply(this, arguments);
          }
        };
      },
      cleanup: clearToken
    };
  });

/* START_TEMPLATE */
  define('hbs!chiropractor/views/templates/error/modelfetch',['hbs','handlebars'], function( hbs, Handlebars ) { 
    var t = Handlebars.template(function (Handlebars,depth0,helpers,partials,data) {
      helpers = helpers || Handlebars.helpers;
      var stack1, stack2, foundHelper, helperMissing=helpers.helperMissing, escapeExpression=this.escapeExpression;

      stack1 = {};
      stack2 = depth0.response;
      stack1['response'] = stack2;
      stack2 = depth0.url;
      stack1['url'] = stack2;
      foundHelper = helpers.row;
      stack1 = foundHelper ? foundHelper.call(depth0, "error", depth0, {hash:stack1}) : helperMissing.call(depth0, "row", "error", depth0, {hash:stack1});
      return escapeExpression(stack1);
    });
    Handlebars.registerPartial('chiropractor_views_templates_error_modelfetch', t);
    return t;
  });
/* END_TEMPLATE */

/*global define,setTimeout,clearTimeout*/
  define('chiropractor/models',['require','jquery.cors/jquery.cors','backbone','underscore','json-ie7','jquery','./models/auth','backbone.deep.model','backbone.validation','hbs!./views/templates/error/modelfetch','underscore.mixin.deepextend'],function (require) {

    require('jquery.cors/jquery.cors');

    var Backbone = require('backbone'),
      _ = require('underscore'),
      JSON = require('json-ie7'),
      $ = require('jquery'),
      auth = require('./models/auth'),
      BackboneDeepModel = require('backbone.deep.model'),
      Validation = require('backbone.validation'),
      TemplateError = require('hbs!./views/templates/error/modelfetch'),
      Base,
      Revision,
      UserAgent,
      RegExpression,
      ASSETS_BASE_URL;

  // Add Wiser specific settings Issue #31

    if (window && window.Wiser && window.Wiser.ASSETS_BASE_URL) {
      ASSETS_BASE_URL = window.Wiser.ASSETS_BASE_URL;
    } else {
      ASSETS_BASE_URL = '';
    }

    require('underscore.mixin.deepextend');

    Base = BackboneDeepModel.DeepModel.extend({
      errorHandler: function(response) {
        var errorMessage;
        switch (response.status) {
        case 0:
          errorMessage = "The API was unreachable";
          break;
        case 503:
          errorMessage = "There was an Error Communicating with the API";
          break;
        default:
        }
        $('body').before(TemplateError({ url: this.url , errorMessage: errorMessage, response: response }));
      },
      successHandler: function(model, response, options) {
      },
      sync: function (method, model, options) {
      // Setup the authentication handlers for the BaseModel
      //

        auth.sync.call(this, method, model, options);
        switch (method) {
        case 'read':
        //Empty the error message box for other fetches
          $('#chiropractor-error-box').empty();
          if (this.enableErrorHandler) {
            options.error = this.errorHandler;
          // Timeout set to 30 seconds.
            options.timeout = 30000;
          }
          break;
        case 'update':
        // Remove Wiser specific settings Issue #31
          model.unset('Wiser');
          break;
        default:
        }
        return Backbone.Model.prototype.sync.call(
        this, method, model, options
      );
      },
      parse: function (resp, options) {
        options = options || {};
      // We need to unwrap the old WiserTogether API envelop format.
        if (resp.data && resp.meta) {
          if (parseInt(resp.meta.status, 10) >= 400) {
            options.legacyError = true;
            if (resp.meta.errors && resp.meta.errors.form) {
              this.validationError = resp.meta.errors.form;
              this.trigger(
              'invalid',
              this,
              this.validationError,
              _.extend(options || {}, {
                validationError: this.validationError
              })
            );
            } else {
              this.trigger('error', this, resp.data, options);

              if (options.error) {
                options.error(this, resp.data, options);

              }
            }
          // We do not want an error response to update the model
          // attributes (returning an empty object leaves the model
          // state as it was
            return {};
          }

        // Add Wiser specific settings Issue #31
          resp.Wiser = {};
          resp.Wiser.ASSETS_BASE_URL = ASSETS_BASE_URL;

          return resp.data;
        }

      // Add Wiser specific settings Issue #31
        resp.Wiser = {};
        resp.Wiser.ASSETS_BASE_URL = ASSETS_BASE_URL;

        return Backbone.Model.prototype.parse.apply(this, arguments);
      },

      fieldId: function (field, prefix) {
        prefix = prefix || 'formfield';
        return [prefix, field, this.cid].join('-');
      },

      set: function (attrs, options) {
      // We need to allow the legacy errors to short circuit the Backbone
      // success handler in the case of a legacy server error.
        if (options && options.legacyError) {
          delete options.legacyError;
          return false;
        }
        return BackboneDeepModel.DeepModel.prototype.set.apply(this, arguments);
      }
    });

    _.extend(Base.prototype, Validation.mixin);

    return {
      Base: Base,
      cleanup: auth.cleanup
    };
  });
/*global define*/
  define('chiropractor/collections',['require','jquery.cors/jquery.cors','backbone','underscore','jquery','hbs!./views/templates/error/modelfetch','underscore.mixin.deepextend'],function (require) {

    require('jquery.cors/jquery.cors');

    var Backbone = require('backbone'),
      _ = require('underscore'),
      Base,
      $ = require('jquery'),
      TemplateError = require('hbs!./views/templates/error/modelfetch'),
      ASSETS_BASE_URL;

  // Add Wiser specific settings Issue #31

    if (window && window.Wiser && window.Wiser.ASSETS_BASE_URL) {
      ASSETS_BASE_URL = window.Wiser.ASSETS_BASE_URL;
    } else {
      ASSETS_BASE_URL = '';
    }

    require('underscore.mixin.deepextend');

    Base = Backbone.Collection.extend({
      errorHandler: function (response) {
        var errorMessage;
        switch (response.status) {
        case 0:
          errorMessage = "The API was unreachable";
          break;
        case 503:
          errorMessage = "There was an Error Communicating with the API";
          break;
        default:
        }
        $('body').before(TemplateError({
          url: this.url,
          errorMessage: errorMessage,
          response: response
        }));
      },
      sync: function (method, model, options) {
        switch (method) {
        case 'read':
        //Empty the error message box for other fetches
          $('#chiropractor-error-box').empty();
          if (this.enableErrorHandler) {
            options.error = this.errorHandler;
          // Timeout set to 30 seconds.
            options.timeout = 30000;
          }
          break;
        case 'update':
        // Remove Wiser specific settings Issue #31
          model.unset('Wiser');
          break;
        default:
        }
        return Backbone.Collection.prototype.sync.call(
        this, method, model, options
      );
      },
      parse: function (resp, options) {
      // Add Wiser specific settings Issue #31
        resp.Wiser = {};
        resp.Wiser.ASSETS_BASE_URL = ASSETS_BASE_URL;
        return Backbone.Collection.prototype.parse.apply(this, arguments);
      }
    });

    return {
      Base: Base
    };
  });
/*global define*/
  define('chiropractor/routers',['require','backbone'],function(require) {

    var Backbone = require('backbone'),
      Base;

    Base = Backbone.Router.extend({
    });

    return {
      Base: Base
    };
  });

/*global define*/
  (function(window) {

    define('chiropractor/browser',['require'],function(require) {
      var ieVersion = (function() {
        var rv = -1; // Return value assumes failure.
        if (window.navigator.appName === 'Microsoft Internet Explorer') {
          var ua = window.navigator.userAgent;
          var re = new RegExp("MSIE ([0-9]{1,}[.0-9]{0,})");
          if (re.exec(ua) !== null) {
            rv = parseFloat(RegExp.$1);
          }
        }
        return rv;
      }());
      return {
        isOldIE: ieVersion !== -1 && ieVersion < 9,
        window: window,
        navigator: window.navigator,
        document: window.document
      };
    });
  }(this));

/*global define,alert*/
  define('chiropractor/debug',['require','exports','module','chiropractor/browser'],function(require, exports, module) {
    var window = require('chiropractor/browser').window,
      console = window.console;

    if (require.specified('console')) {
      require(['console'], function(mod) {
        console = mod;
      });
    }

    function isInspectorOpen() {
      if (console.firebug) {
        return true;
      } else if (console.profile) {
        console.profile();
        console.profileEnd();
        if (console.clear) {
          console.clear();
        }

        if (console.profiles && console.profiles.length > 0) {
          return true;
        }
      }

      if ((window.outerHeight - window.innerHeight) > 100) {
        return true;
      }

      return false;
    }

    if (module.config().enabled) {
      window.onerror = function(message, url, linenumber) {
        alert("JavaScript error: " + message + " on line " + linenumber + " for " + url);
      };
    }
  });

/*global define*/
  define('chiropractor/hbs/ifequal',['require','handlebars'],function(require) {

    var Handlebars = require('handlebars');

    Handlebars.registerHelper('ifequal', function(val1, val2, options) {
      if (val1 === val2) {
        return options.fn(this);
      } else {
        return options.inverse(this);
      }
    });
  });

/*global define*/
  define('chiropractor/hbs/log',['require','handlebars','json-ie7'],function(require) {

    var Handlebars = require('handlebars'),
      JSON = require('json-ie7');

    function log(context, options) {
      console.log(JSON.stringify(context));
    }
    Handlebars.registerHelper('log', log);

    return log;
  });
/*global define*/
  define('chiropractor/hbs',['require','./hbs/view','./hbs/ifequal','./hbs/log'],function(require) {

    require('./hbs/view');
    require('./hbs/ifequal');
    require('./hbs/log');
  });

/*global define*/
  define('chiropractor/main',['require','backbone','underscore','backbone.subroute','./views','./models','./collections','./routers','./debug','./hbs'],function(require) {

    var Backbone = require('backbone'),
      _ = require('underscore'),
      SubRoute = require('backbone.subroute'),
      Views = require('./views'),
      Models = require('./models'),
      Collections = require('./collections'),
      Routers = require('./routers'),
      Channels = {},
      Subscribe,
      Publish;

    require('./debug');
    require('./hbs');

    Subscribe = function(channel,object) {
      //We want to be able to push new listeners into Channels[channel]
      if (!Channels[channel]) {
        Channels[channel] = [];
      }
      Channels[channel].push(object);
    };
    Publish = function(channel,options) {
      if (Channels[channel]) {
        var listeners = Channels[channel];
        _.each(listeners, function(listener) {
          listener.trigger(channel,options);
        });
      }
    };

    return {
        // Channel events
      Subscribe: Subscribe,
      Publish: Publish,
      Channels: Channels,
      Collection: Collections.Base,
      Collections: Collections,
      Events: Backbone.Events,
      history: Backbone.history,
      Model: Models.Base,
      Models: Models,
      Router: Routers.Base,
      SubRoute: SubRoute,
      View: Views.Base,
      Views: Views
    };
  });

  define('chiropractor', ['chiropractor/main'], function (main) { return main; });

}());