Use nodeJS, Grunt, npm to ease development environnment.

Drop jQuery usage in test.

.gitignore

 #vi
 *.swp
 *~
-
+node_modules/
+tmp/

Gruntfile.js

+/*global require */
+module.exports = function (grunt) {
+  "use strict";
+
+  var LIVERELOAD_PORT, lrSnippet, livereloadMiddleware;
+
+  // This is the default port that livereload listens on;
+  // change it if you configure livereload to use another port.
+  LIVERELOAD_PORT = 35729;
+  // lrSnippet is just a function.
+  // It's a piece of Connect middleware that injects
+  // a script into the static served html.
+  lrSnippet = require('connect-livereload')({ port: LIVERELOAD_PORT });
+  // All the middleware necessary to serve static files.
+  livereloadMiddleware = function (connect, options) {
+    return [
+      // Inject a livereloading script into static files.
+      lrSnippet,
+      // Serve static files.
+      connect.static(options.base),
+      // Make empty directories browsable.
+      connect.directory(options.base)
+    ];
+  };
+
+  grunt.loadNpmTasks("grunt-jslint");
+  grunt.loadNpmTasks("grunt-contrib-uglify");
+  grunt.loadNpmTasks('grunt-contrib-watch');
+  grunt.loadNpmTasks('grunt-contrib-qunit');
+  grunt.loadNpmTasks('grunt-contrib-connect');
+  grunt.loadNpmTasks('grunt-contrib-copy');
+  grunt.loadNpmTasks('grunt-curl');
+  grunt.loadNpmTasks('grunt-open');
+
+  grunt.initConfig({
+    pkg: grunt.file.readJSON('package.json'),
+
+    jslint: {
+      config: {
+        src: ['package.json', 'Gruntfile.js'],
+        directives: {
+          maxlen: 100,
+          indent: 2,
+          maxerr: 3,
+          predef: [
+            'module'
+          ]
+        }
+      },
+      client: {
+        src: ['renderjs.js'],
+        directives: {
+          maxlen: 79,
+          indent: 2,
+          maxerr: 3,
+          unparam: true,
+          predef: [
+            'RSVP',
+            'window',
+            'document',
+            'DOMParser',
+            'Channel',
+            'XMLHttpRequest'
+          ]
+        }
+      },
+      test: {
+        src: ['test/embedded.js', 'test/renderjs_test.js'],
+        directives: {
+          maxlen: 79,
+          indent: 2,
+          maxerr: 3,
+          unparam: true,
+          predef: [
+            'window',
+            'document',
+            'QUnit',
+            'renderJS',
+            'rJS',
+            'RenderJSGadget',
+            'sinon',
+            'RSVP',
+            'DOMParser',
+            'RenderJSIframeGadget',
+            'RenderJSEmbeddedGadget'
+          ]
+        }
+      },
+      examples: {
+        src: ['examples/officejs/*.js'],
+        directives: {
+          maxlen: 79,
+          indent: 2,
+          maxerr: 3,
+          unparam: true,
+          predef: [
+            'window',
+            'document',
+            'rJS',
+            'RSVP',
+            'jQuery',
+            'jIO'
+          ]
+        }
+      }
+    },
+
+    copy: {
+      renderjs: {
+        src: '<%= pkg.name %>.js',
+        dest: "dist/<%= pkg.name %>-<%= pkg.version %>.js"
+      },
+      latest: {
+        files: [{
+          src: '<%= pkg.name %>.js',
+          dest: "dist/<%= pkg.name %>-latest.js"
+        }, {
+          src: '<%= uglify.stateless.dest %>',
+          dest: "dist/<%= pkg.name %>-latest.min.js"
+        }]
+      }
+    },
+
+    uglify: {
+      stateless: {
+        src: "dist/<%= pkg.name %>-<%= pkg.version %>.js",
+        dest: "dist/<%= pkg.name %>-<%= pkg.version %>.min.js"
+      }
+    },
+
+    watch: {
+      src: {
+        files: [
+          '<%= jslint.client.src %>',
+          '<%= jslint.config.src %>',
+          '<%= jslint.test.src %>',
+          '<%= qunit.all %>',
+          ['test/*.html', 'test/*.js']
+        ],
+        tasks: ['default'],
+        options: {
+          livereload: LIVERELOAD_PORT
+        }
+      },
+      examples: {
+        files: [
+          ['examples/**']
+        ],
+        tasks: ['lint'],
+        options: {
+          livereload: LIVERELOAD_PORT
+        }
+      }
+    },
+
+    curl: {
+      jschannel: {
+        src: 'http://mozilla.github.io/jschannel/src/jschannel.js',
+        dest: 'lib/jschannel/jschannel.js'
+      },
+      jquery: {
+        src: 'http://code.jquery.com/jquery-2.0.3.js',
+        dest: 'lib/jquery/jquery.js'
+      },
+      jio: {
+        src: 'http://git.erp5.org/gitweb/jio.git/blob_plain/refs/heads/master:/jio.js',
+        dest: 'lib/jio/jio.js'
+      },
+      md5: {
+        src: 'http://git.erp5.org/gitweb/jio.git/blob_plain/HEAD:/src/md5.amd.js',
+        dest: 'lib/jio/md5.js'
+      },
+      sha256: {
+        src: 'http://git.erp5.org/gitweb/jio.git/blob_plain/HEAD:/src/sha256.amd.js',
+        dest: 'lib/jio/sha256.js'
+      },
+      localstorage: {
+        src: 'http://git.erp5.org/gitweb/jio.git/blob_plain/HEAD:/src/jio.storage/localstorage.js',
+        dest: 'lib/jio/localstorage.js'
+      },
+      complex_queries: {
+        src: 'http://git.erp5.org/gitweb/jio.git/blob_plain/HEAD:/complex_queries.js',
+        dest: 'lib/jio/complex_queries.js'
+      }
+    },
+
+    qunit: {
+      all: ['test/index.html']
+    },
+
+    connect: {
+      client: {
+        options: {
+          port: 9000,
+          base: '.',
+          directory: '.',
+          middleware: livereloadMiddleware
+        }
+      }
+    },
+
+    open: {
+      all: {
+        // Gets the port from the connect configuration
+        path: 'http://localhost:<%= connect.client.options.port%>/test/'
+      }
+    }
+  });
+
+  grunt.registerTask('default', ['all']);
+  grunt.registerTask('all', ['lint', 'build', 'test']);
+  grunt.registerTask('lint', ['jslint']);
+  grunt.registerTask('test', ['qunit']);
+  grunt.registerTask('server', ['connect:client', 'open', 'watch']);
+  grunt.registerTask('build', ['copy:renderjs', 'uglify', 'copy:latest']);
+
+};

Makefile

-# files
-RENDERJS = renderjs.js
-RENDERJS_MIN = renderjs.min.js
-BUILDDIR = tmp
-
-LINT_OPTS = --maxlen 79 --indent 2 --maxerr 3
-
-include config.mk
-
-all: external lint test build doc
-
-#########################################
-# Download external lib
-#########################################
-# Download all external libs
-external: lib/sinon/sinon.js \
-     lib/sinon/sinon-qunit.js \
-     lib/jquery/jquery.js \
-     lib/rsvp/rsvp.js \
-     lib/jschannel/jschannel.js \
-     lib/require/require.js \
-     lib/qunit/qunit.js \
-     lib/qunit/qunit.css \
-     lib/jio/jio.js \
-     lib/jio/md5.js \
-     lib/jio/sha256.js \
-     lib/jio/complex_queries.js \
-     lib/jio/localstorage.js
-
-lib/sinon/sinon.js:
-	@mkdir -p $(@D)
-	curl -s -o $@ http://sinonjs.org/releases/sinon-1.7.3.js
-
-lib/sinon/sinon-qunit.js:
-	@mkdir -p $(@D)
-	curl -s -o $@ http://sinonjs.org/releases/sinon-qunit-1.0.0.js
-# 	curl -s -o $@ https://raw.github.com/jfromaniello/jmail/master/scripts/Tests/sinon-qunit-1.0.0.js
-
-lib/jquery/jquery.js:
-	@mkdir -p $(@D)
-	curl -s -o $@ http://code.jquery.com/jquery-2.0.3.js
-
-lib/rsvp/rsvp.js:
-	@mkdir -p $(@D)
-	curl -s -o $@ http://git.erp5.org/gitweb/rsvp.js.git/blob_plain/HEAD:/dist/rsvp-2.0.4.js
-
-lib/jschannel/jschannel.js:
-	@mkdir -p $(@D)
-	curl -s -o $@ http://mozilla.github.io/jschannel/src/jschannel.js
-
-lib/require/require.js:
-	@mkdir -p $(@D)
-	curl -s -o $@ http://requirejs.org/docs/release/2.1.8/comments/require.js
-
-lib/qunit/qunit.%:
-	@mkdir -p $(@D)
-	curl -s -o $@ http://code.jquery.com/qunit/qunit-1.12.0$(suffix $@)
-
-lib/jio/jio.js:
-	@mkdir -p $(@D)
-	curl -s -o $@ http://git.erp5.org/gitweb/jio.git/blob_plain/refs/heads/master:/jio.js
-
-lib/jio/md5.js:
-	@mkdir -p $(@D)
-	curl -s -o $@ http://git.erp5.org/gitweb/jio.git/blob_plain/HEAD:/src/md5.amd.js
-
-lib/jio/sha256.js:
-	@mkdir -p $(@D)
-	curl -s -o $@ http://git.erp5.org/gitweb/jio.git/blob_plain/HEAD:/src/sha256.amd.js
-
-lib/jio/localstorage.js:
-	@mkdir -p $(@D)
-	curl -s -o $@ http://git.erp5.org/gitweb/jio.git/blob_plain/HEAD:/src/jio.storage/localstorage.js
-
-lib/jio/complex_queries.js:
-	@mkdir -p $(@D)
-	curl -s -o $@ http://git.erp5.org/gitweb/jio.git/blob_plain/HEAD:/complex_queries.js
-
-$(RENDERJS_MIN): $(RENDERJS)
-	$(UGLIFY_CMD) "$<" > "$@"
-
-${BUILDDIR}/$(RENDERJS).lint: $(RENDERJS) test/renderjs_test.js examples/officejs/*.js
-	@mkdir -p $(@D)
-	$(LINT_CMD) $(LINT_OPTS) "$(RENDERJS)"
-	$(LINT_CMD) $(LINT_OPTS) "test/renderjs_test.js"
-	$(LINT_CMD) $(LINT_OPTS) examples/officejs/*.js
-	touch $@
-
-${BUILDDIR}/index.html.ok: test/index.html
-	$(PHANTOMJS_CMD) ./test/run-qunit.js $<
-	@mkdir -p $(@D)
-	@sleep 1
-	touch $@
-
-build: $(RENDERJS_MIN)
-test: ${BUILDDIR}/index.html.ok
-lint: ${BUILDDIR}/$(RENDERJS).lint
-doc:
-	$(YUIDOC_CMD) .
-clean:
-	rm -rf $(RENDERJS_MIN) ${BUILDDIR} lib/sinon lib/jquery lib/jschannel lib/qunit lib/jio lib/require lib/rsvp

config.mk

-# npm install uglify-js
-UGLIFY_CMD = ~/node_modules/.bin/uglifyjs
-# npm install jslint
-LINT_CMD = /home/romain/devel/nowm/gidzit/node_modules/.bin/jslint
-YUIDOC_CMD = $(shell which yuidoc)
-PHANTOMJS_CMD = xvfb-run phantomjs

dist/renderjs-0.3.2.js

+/*! RenderJs v0.3.2 */
+
+/*
+ * DOMParser HTML extension
+ * 2012-09-04
+ *
+ * By Eli Grey, http://eligrey.com
+ * Public domain.
+ * NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
+ */
+/*! @source https://gist.github.com/1129031 */
+(function (DOMParser) {
+  "use strict";
+  var DOMParser_proto = DOMParser.prototype,
+    real_parseFromString = DOMParser_proto.parseFromString;
+
+  // Firefox/Opera/IE throw errors on unsupported types
+  try {
+    // WebKit returns null on unsupported types
+    if ((new DOMParser()).parseFromString("", "text/html")) {
+      // text/html parsing is natively supported
+      return;
+    }
+  } catch (ignore) {}
+
+  DOMParser_proto.parseFromString = function (markup, type) {
+    var result, doc, doc_elt, first_elt;
+    if (/^\s*text\/html\s*(?:;|$)/i.test(type)) {
+      doc = document.implementation.createHTMLDocument("");
+      doc_elt = doc.documentElement;
+
+      doc_elt.innerHTML = markup;
+      first_elt = doc_elt.firstElementChild;
+
+      if (doc_elt.childElementCount === 1
+          && first_elt.localName.toLowerCase() === "html") {
+        doc.replaceChild(first_elt, doc_elt);
+      }
+
+      result = doc;
+    } else {
+      result = real_parseFromString.apply(this, arguments);
+    }
+    return result;
+  };
+}(DOMParser));
+
+/*
+ * renderJs - Generic Gadget library renderer.
+ * http://www.renderjs.org/documentation
+ */
+(function (document, window, RSVP, DOMParser, Channel, undefined) {
+  "use strict";
+
+  var gadget_model_dict = {},
+    javascript_registration_dict = {},
+    stylesheet_registration_dict = {},
+    gadget_loading_klass,
+    loading_gadget_promise,
+    renderJS;
+
+  /////////////////////////////////////////////////////////////////
+  // RenderJSGadget
+  /////////////////////////////////////////////////////////////////
+  function RenderJSGadget() {
+    if (!(this instanceof RenderJSGadget)) {
+      return new RenderJSGadget();
+    }
+  }
+  RenderJSGadget.prototype.title = "";
+  RenderJSGadget.prototype.interface_list = [];
+  RenderJSGadget.prototype.path = "";
+  RenderJSGadget.prototype.html = "";
+  RenderJSGadget.prototype.required_css_list = [];
+  RenderJSGadget.prototype.required_js_list = [];
+
+  RenderJSGadget.ready_list = [];
+  RenderJSGadget.ready = function (callback) {
+    this.ready_list.push(callback);
+    return this;
+  };
+
+  /////////////////////////////////////////////////////////////////
+  // RenderJSGadget.declareMethod
+  /////////////////////////////////////////////////////////////////
+  RenderJSGadget.declareMethod = function (name, callback) {
+    this.prototype[name] = function () {
+      var context = this,
+        argument_list = arguments;
+
+      return new RSVP.Queue()
+        .push(function () {
+          return callback.apply(context, argument_list);
+        });
+    };
+    // Allow chain
+    return this;
+  };
+
+  RenderJSGadget
+    .declareMethod('getInterfaceList', function () {
+      // Returns the list of gadget prototype
+      return this.interface_list;
+    })
+    .declareMethod('getRequiredCSSList', function () {
+      // Returns a list of CSS required by the gadget
+      return this.required_css_list;
+    })
+    .declareMethod('getRequiredJSList', function () {
+      // Returns a list of JS required by the gadget
+      return this.required_js_list;
+    })
+    .declareMethod('getPath', function () {
+      // Returns the path of the code of a gadget
+      return this.path;
+    })
+    .declareMethod('getTitle', function () {
+      // Returns the title of a gadget
+      return this.title;
+    })
+    .declareMethod('getElement', function () {
+      // Returns the DOM Element of a gadget
+      if (this.element === undefined) {
+        throw new Error("No element defined");
+      }
+      return this.element;
+    });
+
+  /////////////////////////////////////////////////////////////////
+  // RenderJSEmbeddedGadget
+  /////////////////////////////////////////////////////////////////
+  // Class inheritance
+  function RenderJSEmbeddedGadget() {
+    if (!(this instanceof RenderJSEmbeddedGadget)) {
+      return new RenderJSEmbeddedGadget();
+    }
+    RenderJSGadget.call(this);
+  }
+  RenderJSEmbeddedGadget.ready_list = [];
+  RenderJSEmbeddedGadget.ready =
+    RenderJSGadget.ready;
+  RenderJSEmbeddedGadget.prototype = new RenderJSGadget();
+  RenderJSEmbeddedGadget.prototype.constructor = RenderJSEmbeddedGadget;
+
+  /////////////////////////////////////////////////////////////////
+  // privateDeclarePublicGadget
+  /////////////////////////////////////////////////////////////////
+  function privateDeclarePublicGadget(url, options) {
+    var gadget_instance;
+    if (options.element === undefined) {
+      options.element = document.createElement("div");
+    }
+    return new RSVP.Queue()
+      .push(function () {
+        return renderJS.declareGadgetKlass(url);
+      })
+      // Get the gadget class and instanciate it
+      .push(function (Klass) {
+        var i,
+          template_node_list = Klass.template_element.body.childNodes;
+        gadget_loading_klass = Klass;
+        gadget_instance = new Klass();
+        gadget_instance.element = options.element;
+        for (i = 0; i < template_node_list.length; i += 1) {
+          gadget_instance.element.appendChild(
+            template_node_list[i].cloneNode(true)
+          );
+        }
+        // Load dependencies if needed
+        return RSVP.all([
+          gadget_instance.getRequiredJSList(),
+          gadget_instance.getRequiredCSSList()
+        ]);
+      })
+      // Load all JS/CSS
+      .push(function (all_list) {
+        var parameter_list = [],
+          i;
+        // Load JS
+        for (i = 0; i < all_list[0].length; i += 1) {
+          parameter_list.push(renderJS.declareJS(all_list[0][i]));
+        }
+        // Load CSS
+        for (i = 0; i < all_list[1].length; i += 1) {
+          parameter_list.push(renderJS.declareCSS(all_list[1][i]));
+        }
+        return RSVP.all(parameter_list);
+      })
+      .push(function () {
+        return gadget_instance;
+      });
+  }
+
+  /////////////////////////////////////////////////////////////////
+  // RenderJSIframeGadget
+  /////////////////////////////////////////////////////////////////
+  function RenderJSIframeGadget() {
+    if (!(this instanceof RenderJSIframeGadget)) {
+      return new RenderJSIframeGadget();
+    }
+    RenderJSGadget.call(this);
+  }
+  RenderJSIframeGadget.ready_list = [];
+  RenderJSIframeGadget.ready =
+    RenderJSGadget.ready;
+  RenderJSIframeGadget.prototype = new RenderJSGadget();
+  RenderJSIframeGadget.prototype.constructor = RenderJSIframeGadget;
+
+  /////////////////////////////////////////////////////////////////
+  // privateDeclareIframeGadget
+  /////////////////////////////////////////////////////////////////
+  function privateDeclareIframeGadget(url, options) {
+    var gadget_instance,
+      iframe,
+      node,
+      iframe_loading_deferred = RSVP.defer();
+
+    if (options.element === undefined) {
+      throw new Error("DOM element is required to create Iframe Gadget " +
+                      url);
+    }
+
+    // Check if the element is attached to the DOM
+    node = options.element.parentNode;
+    while (node !== null) {
+      if (node === document) {
+        break;
+      }
+      node = node.parentNode;
+    }
+    if (node === null) {
+      throw new Error("The parent element is not attached to the DOM for " +
+                      url);
+    }
+
+    gadget_instance = new RenderJSIframeGadget();
+    iframe = document.createElement("iframe");
+//    gadget_instance.element.setAttribute("seamless", "seamless");
+    iframe.setAttribute("src", url);
+    gadget_instance.path = url;
+    gadget_instance.element = options.element;
+
+    // Attach it to the DOM
+    options.element.appendChild(iframe);
+
+    // XXX Manage unbind when deleting the gadget
+
+    // Create the communication channel with the iframe
+    gadget_instance.chan = Channel.build({
+      window: iframe.contentWindow,
+      origin: "*",
+      scope: "renderJS"
+    });
+
+    // Create new method from the declareMethod call inside the iframe
+    gadget_instance.chan.bind("declareMethod", function (trans, method_name) {
+      gadget_instance[method_name] = function () {
+        var argument_list = arguments;
+        return new RSVP.Promise(function (resolve, reject) {
+          gadget_instance.chan.call({
+            method: "methodCall",
+            params: [
+              method_name,
+              Array.prototype.slice.call(argument_list, 0)],
+            success: function (s) {
+              resolve(s);
+            },
+            error: function (e) {
+              reject(e);
+            }
+          });
+        });
+      };
+      return "OK";
+    });
+
+    // Wait for the iframe to be loaded before continuing
+    gadget_instance.chan.bind("ready", function (trans) {
+      iframe_loading_deferred.resolve(gadget_instance);
+      return "OK";
+    });
+    gadget_instance.chan.bind("failed", function (trans, params) {
+      iframe_loading_deferred.reject(params);
+      return "OK";
+    });
+    return RSVP.any([
+      iframe_loading_deferred.promise,
+      // Timeout to prevent non renderJS embeddable gadget
+      // XXX Maybe using iframe.onload/onerror would be safer?
+      RSVP.timeout(5000)
+    ]);
+  }
+
+  /////////////////////////////////////////////////////////////////
+  // RenderJSGadget.declareGadget
+  /////////////////////////////////////////////////////////////////
+  RenderJSGadget.prototype.declareGadget = function (url, options) {
+    var queue,
+      previous_loading_gadget_promise = loading_gadget_promise;
+
+    if (options === undefined) {
+      options = {};
+    }
+    if (options.sandbox === undefined) {
+      options.sandbox = "public";
+    }
+
+    // Change the global variable to update the loading queue
+    queue = new RSVP.Queue()
+      // Wait for previous gadget loading to finish first
+      .push(function () {
+        return previous_loading_gadget_promise;
+      })
+      .push(function () {
+        var method;
+        if (options.sandbox === "public") {
+          method = privateDeclarePublicGadget;
+        } else if (options.sandbox === "iframe") {
+          method = privateDeclareIframeGadget;
+        } else {
+          throw new Error("Unsupported sandbox options '" +
+                          options.sandbox + "'");
+        }
+        return method(url, options);
+      })
+      // Set the HTML context
+      .push(function (gadget_instance) {
+        var i;
+        // Drop the current loading klass info used by selector
+        gadget_loading_klass = undefined;
+        // Trigger calling of all ready callback
+        function ready_wrapper() {
+          return gadget_instance;
+        }
+        for (i = 0; i < gadget_instance.constructor.ready_list.length;
+             i += 1) {
+          // Put a timeout?
+          queue.push(gadget_instance.constructor.ready_list[i]);
+          // Always return the gadget instance after ready function
+          queue.push(ready_wrapper);
+        }
+        return gadget_instance;
+      })
+      .push(undefined, function (e) {
+        // Drop the current loading klass info used by selector
+        // even in case of error
+        gadget_loading_klass = undefined;
+        throw e;
+      });
+    loading_gadget_promise = queue;
+    return loading_gadget_promise;
+  };
+
+  /////////////////////////////////////////////////////////////////
+  // renderJS selector
+  /////////////////////////////////////////////////////////////////
+  renderJS = function (selector) {
+    var result;
+    if (selector === window) {
+      // window is the 'this' value when loading a javascript file
+      // In this case, use the current loading gadget constructor
+      result = gadget_loading_klass;
+    } else if (selector instanceof RenderJSGadget) {
+      result = selector;
+    }
+    if (result === undefined) {
+      throw new Error("Unknown selector '" + selector + "'");
+    }
+    return result;
+  };
+
+  /////////////////////////////////////////////////////////////////
+  // renderJS.declareJS
+  /////////////////////////////////////////////////////////////////
+  renderJS.declareJS = function (url) {
+    // Prevent infinite recursion if loading render.js
+    // more than once
+    var result;
+    if (javascript_registration_dict.hasOwnProperty(url)) {
+      result = RSVP.resolve();
+    } else {
+      result = new RSVP.Promise(function (resolve, reject) {
+        var newScript;
+        newScript = document.createElement('script');
+        newScript.type = 'text/javascript';
+        newScript.src = url;
+        newScript.onload = function () {
+          javascript_registration_dict[url] = null;
+          resolve();
+        };
+        newScript.onerror = function (e) {
+          reject(e);
+        };
+        document.head.appendChild(newScript);
+      });
+    }
+    return result;
+  };
+
+  /////////////////////////////////////////////////////////////////
+  // renderJS.declareCSS
+  /////////////////////////////////////////////////////////////////
+  renderJS.declareCSS = function (url) {
+    // https://github.com/furf/jquery-getCSS/blob/master/jquery.getCSS.js
+    // No way to cleanly check if a css has been loaded
+    // So, always resolve the promise...
+    // http://requirejs.org/docs/faq-advanced.html#css
+    var result;
+    if (stylesheet_registration_dict.hasOwnProperty(url)) {
+      result = RSVP.resolve();
+    } else {
+      result = new RSVP.Promise(function (resolve, reject) {
+        var link;
+        link = document.createElement('link');
+        link.rel = 'stylesheet';
+        link.type = 'text/css';
+        link.href = url;
+        link.onload = function () {
+          stylesheet_registration_dict[url] = null;
+          resolve();
+        };
+        link.onerror = function (e) {
+          reject(e);
+        };
+        document.head.appendChild(link);
+      });
+    }
+    return result;
+  };
+
+  /////////////////////////////////////////////////////////////////
+  // renderJS.declareGadgetKlass
+  /////////////////////////////////////////////////////////////////
+  renderJS.declareGadgetKlass = function (url) {
+    var result,
+      xhr;
+
+    function parse() {
+      var tmp_constructor,
+        key,
+        parsed_html;
+      if (!gadget_model_dict.hasOwnProperty(url)) {
+        // Class inheritance
+        tmp_constructor = function () {
+          RenderJSGadget.call(this);
+        };
+        tmp_constructor.ready_list = [];
+        tmp_constructor.declareMethod =
+          RenderJSGadget.declareMethod;
+        tmp_constructor.ready =
+          RenderJSGadget.ready;
+        tmp_constructor.prototype = new RenderJSGadget();
+        tmp_constructor.prototype.constructor = tmp_constructor;
+        tmp_constructor.prototype.path = url;
+        // https://developer.mozilla.org/en-US/docs/HTML_in_XMLHttpRequest
+        // https://developer.mozilla.org/en-US/docs/Web/API/DOMParser
+        // https://developer.mozilla.org/en-US/docs/Code_snippets/HTML_to_DOM
+        tmp_constructor.template_element =
+          (new DOMParser()).parseFromString(xhr.responseText, "text/html");
+        parsed_html = renderJS.parseGadgetHTMLDocument(
+          tmp_constructor.template_element
+        );
+        for (key in parsed_html) {
+          if (parsed_html.hasOwnProperty(key)) {
+            tmp_constructor.prototype[key] = parsed_html[key];
+          }
+        }
+
+        gadget_model_dict[url] = tmp_constructor;
+      }
+
+      return gadget_model_dict[url];
+    }
+
+    function resolver(resolve, reject) {
+      function handler() {
+        var tmp_result;
+        try {
+          if (xhr.readyState === 0) {
+            // UNSENT
+            reject(xhr);
+          } else if (xhr.readyState === 4) {
+            // DONE
+            if ((xhr.status < 200) || (xhr.status >= 300) ||
+                (!/^text\/html[;]?/.test(
+                  xhr.getResponseHeader("Content-Type") || ""
+                ))) {
+              reject(xhr);
+            } else {
+              tmp_result = parse();
+              resolve(tmp_result);
+            }
+          }
+        } catch (e) {
+          reject(e);
+        }
+      }
+
+      xhr = new XMLHttpRequest();
+      xhr.open("GET", url);
+      xhr.onreadystatechange = handler;
+      xhr.setRequestHeader('Accept', 'text/html');
+      xhr.withCredentials = true;
+      xhr.send();
+    }
+
+    function canceller() {
+      if ((xhr !== undefined) && (xhr.readyState !== xhr.DONE)) {
+        xhr.abort();
+      }
+    }
+
+    if (gadget_model_dict.hasOwnProperty(url)) {
+      // Return klass object if it already exists
+      result = RSVP.resolve(gadget_model_dict[url]);
+    } else {
+      // Fetch the HTML page and parse it
+      result = new RSVP.Promise(resolver, canceller);
+    }
+    return result;
+  };
+
+  /////////////////////////////////////////////////////////////////
+  // renderJS.clearGadgetKlassList
+  /////////////////////////////////////////////////////////////////
+  // For test purpose only
+  renderJS.clearGadgetKlassList = function () {
+    gadget_model_dict = {};
+    javascript_registration_dict = {};
+    stylesheet_registration_dict = {};
+  };
+
+  /////////////////////////////////////////////////////////////////
+  // renderJS.parseGadgetHTMLDocument
+  /////////////////////////////////////////////////////////////////
+  renderJS.parseGadgetHTMLDocument = function (document_element) {
+    var settings = {
+        title: "",
+        interface_list: [],
+        required_css_list: [],
+        required_js_list: []
+      },
+      i,
+      element;
+    if (document_element.nodeType === 9) {
+      settings.title = document_element.title;
+
+      for (i = 0; i < document_element.head.children.length; i += 1) {
+        element = document_element.head.children[i];
+        if (element.href !== null) {
+          // XXX Manage relative URL during extraction of URLs
+          // element.href returns absolute URL in firefox but "" in chrome;
+          if (element.rel === "stylesheet") {
+            settings.required_css_list.push(element.getAttribute("href"));
+          } else if (element.type === "text/javascript") {
+            settings.required_js_list.push(element.getAttribute("src"));
+          } else if (element.rel === "http://www.renderjs.org/rel/interface") {
+            settings.interface_list.push(element.getAttribute("href"));
+          }
+        }
+      }
+    } else {
+      throw new Error("The first parameter should be an HTMLDocument");
+    }
+    return settings;
+  };
+
+  /////////////////////////////////////////////////////////////////
+  // global
+  /////////////////////////////////////////////////////////////////
+  window.rJS = window.renderJS = renderJS;
+  window.RenderJSGadget = RenderJSGadget;
+  window.RenderJSEmbeddedGadget = RenderJSEmbeddedGadget;
+  window.RenderJSIframeGadget = RenderJSIframeGadget;
+
+  ///////////////////////////////////////////////////
+  // Bootstrap process. Register the self gadget.
+  ///////////////////////////////////////////////////
+
+  function bootstrap() {
+    var url = window.location.href,
+      tmp_constructor,
+      root_gadget,
+      declare_method_count = 0,
+      embedded_channel,
+      notifyReady,
+      notifyDeclareMethod,
+      gadget_ready = false;
+
+
+    // Create the gadget class for the current url
+    if (gadget_model_dict.hasOwnProperty(url)) {
+      throw new Error("bootstrap should not be called twice");
+    }
+    loading_gadget_promise = new RSVP.Promise(function (resolve, reject) {
+      if (window.self === window.top) {
+        // XXX Copy/Paste from declareGadgetKlass
+        tmp_constructor = function () {
+          RenderJSGadget.call(this);
+        };
+        tmp_constructor.declareMethod = RenderJSGadget.declareMethod;
+        tmp_constructor.ready_list = [];
+        tmp_constructor.ready = RenderJSGadget.ready;
+        tmp_constructor.prototype = new RenderJSGadget();
+        tmp_constructor.prototype.constructor = tmp_constructor;
+        tmp_constructor.prototype.path = url;
+        gadget_model_dict[url] = tmp_constructor;
+
+        // Create the root gadget instance and put it in the loading stack
+        root_gadget = new gadget_model_dict[url]();
+
+      } else {
+        // Create the communication channel
+        embedded_channel = Channel.build({
+          window: window.parent,
+          origin: "*",
+          scope: "renderJS"
+        });
+        // Create the root gadget instance and put it in the loading stack
+        tmp_constructor = RenderJSEmbeddedGadget;
+        root_gadget = new RenderJSEmbeddedGadget();
+
+        // Bind calls to renderJS method on the instance
+        embedded_channel.bind("methodCall", function (trans, v) {
+          root_gadget[v[0]].apply(root_gadget, v[1]).then(function (g) {
+            trans.complete(g);
+          }).fail(function (e) {
+            trans.error(e.toString());
+          });
+          trans.delayReturn(true);
+        });
+
+        // Notify parent about gadget instanciation
+        notifyReady = function () {
+          if ((declare_method_count === 0) && (gadget_ready === true)) {
+            embedded_channel.notify({method: "ready"});
+          }
+        };
+
+        // Inform parent gadget about declareMethod calls here.
+        notifyDeclareMethod = function (name) {
+          declare_method_count += 1;
+          embedded_channel.call({
+            method: "declareMethod",
+            params: name,
+            success: function () {
+              declare_method_count -= 1;
+              notifyReady();
+            },
+            error: function () {
+              declare_method_count -= 1;
+            }
+          });
+        };
+
+        notifyDeclareMethod("getInterfaceList");
+        notifyDeclareMethod("getRequiredCSSList");
+        notifyDeclareMethod("getRequiredJSList");
+        notifyDeclareMethod("getPath");
+        notifyDeclareMethod("getTitle");
+
+        // Surcharge declareMethod to inform parent window
+        tmp_constructor.declareMethod = function (name, callback) {
+          var result = RenderJSGadget.declareMethod.apply(
+              this,
+              [name, callback]
+            );
+          notifyDeclareMethod(name);
+          return result;
+        };
+      }
+
+      gadget_loading_klass = tmp_constructor;
+
+      function init() {
+        // XXX HTML properties can only be set when the DOM is fully loaded
+        var settings = renderJS.parseGadgetHTMLDocument(document),
+          j,
+          key;
+        for (key in settings) {
+          if (settings.hasOwnProperty(key)) {
+            tmp_constructor.prototype[key] = settings[key];
+          }
+        }
+        tmp_constructor.template_element = document.createElement("div");
+        root_gadget.element = document.body;
+        for (j = 0; j < root_gadget.element.childNodes.length; j += 1) {
+          tmp_constructor.template_element.appendChild(
+            root_gadget.element.childNodes[j].cloneNode(true)
+          );
+        }
+        RSVP.all([root_gadget.getRequiredJSList(),
+                  root_gadget.getRequiredCSSList()])
+          .then(function (all_list) {
+            var i,
+              js_list = all_list[0],
+              css_list = all_list[1],
+              queue;
+            for (i = 0; i < js_list.length; i += 1) {
+              javascript_registration_dict[js_list[i]] = null;
+            }
+            for (i = 0; i < css_list.length; i += 1) {
+              stylesheet_registration_dict[css_list[i]] = null;
+            }
+            gadget_loading_klass = undefined;
+            queue = new RSVP.Queue();
+            function ready_wrapper() {
+              return root_gadget;
+            }
+            queue.push(ready_wrapper);
+            for (i = 0; i < tmp_constructor.ready_list.length; i += 1) {
+              // Put a timeout?
+              queue.push(tmp_constructor.ready_list[i]);
+              // Always return the gadget instance after ready function
+              queue.push(ready_wrapper);
+            }
+            queue.push(resolve, function (e) {
+              reject(e);
+              throw e;
+            });
+            return queue;
+          }).fail(function (e) {
+            reject(e);
+          });
+      }
+      document.addEventListener('DOMContentLoaded', init, false);
+    });
+
+    if (window.self !== window.top) {
+      // Inform parent window that gadget is correctly loaded
+      loading_gadget_promise.then(function () {
+        gadget_ready = true;
+        notifyReady();
+      }).fail(function (e) {
+        embedded_channel.notify({method: "failed", params: e.toString()});
+        throw e;
+      });
+    }
+
+  }
+  bootstrap();
+
+}(document, window, RSVP, DOMParser, Channel));

dist/renderjs-0.3.2.min.js

+!function(a){"use strict";var b=a.prototype,c=b.parseFromString;try{if((new a).parseFromString("","text/html"))return}catch(d){}b.parseFromString=function(a,b){var d,e,f,g;return/^\s*text\/html\s*(?:;|$)/i.test(b)?(e=document.implementation.createHTMLDocument(""),f=e.documentElement,f.innerHTML=a,g=f.firstElementChild,1===f.childElementCount&&"html"===g.localName.toLowerCase()&&e.replaceChild(g,f),d=e):d=c.apply(this,arguments),d}}(DOMParser),function(a,b,c,d,e,f){"use strict";function g(){return this instanceof g?void 0:new g}function h(){return this instanceof h?(g.call(this),void 0):new h}function i(b,d){var e;return d.element===f&&(d.element=a.createElement("div")),(new c.Queue).push(function(){return o.declareGadgetKlass(b)}).push(function(a){var b,f=a.template_element.body.childNodes;for(m=a,e=new a,e.element=d.element,b=0;b<f.length;b+=1)e.element.appendChild(f[b].cloneNode(!0));return c.all([e.getRequiredJSList(),e.getRequiredCSSList()])}).push(function(a){var b,d=[];for(b=0;b<a[0].length;b+=1)d.push(o.declareJS(a[0][b]));for(b=0;b<a[1].length;b+=1)d.push(o.declareCSS(a[1][b]));return c.all(d)}).push(function(){return e})}function j(){return this instanceof j?(g.call(this),void 0):new j}function k(b,d){var g,h,i,k=c.defer();if(d.element===f)throw new Error("DOM element is required to create Iframe Gadget "+b);for(i=d.element.parentNode;null!==i&&i!==a;)i=i.parentNode;if(null===i)throw new Error("The parent element is not attached to the DOM for "+b);return g=new j,h=a.createElement("iframe"),h.setAttribute("src",b),g.path=b,g.element=d.element,d.element.appendChild(h),g.chan=e.build({window:h.contentWindow,origin:"*",scope:"renderJS"}),g.chan.bind("declareMethod",function(a,b){return g[b]=function(){var a=arguments;return new c.Promise(function(c,d){g.chan.call({method:"methodCall",params:[b,Array.prototype.slice.call(a,0)],success:function(a){c(a)},error:function(a){d(a)}})})},"OK"}),g.chan.bind("ready",function(){return k.resolve(g),"OK"}),g.chan.bind("failed",function(a,b){return k.reject(b),"OK"}),c.any([k.promise,c.timeout(5e3)])}function l(){var d,i,j,k,l,s=b.location.href,t=0,u=!1;if(p.hasOwnProperty(s))throw new Error("bootstrap should not be called twice");n=new c.Promise(function(n,v){function w(){var b,e,g=o.parseGadgetHTMLDocument(a);for(e in g)g.hasOwnProperty(e)&&(d.prototype[e]=g[e]);for(d.template_element=a.createElement("div"),i.element=a.body,b=0;b<i.element.childNodes.length;b+=1)d.template_element.appendChild(i.element.childNodes[b].cloneNode(!0));c.all([i.getRequiredJSList(),i.getRequiredCSSList()]).then(function(a){function b(){return i}var e,g,h=a[0],j=a[1];for(e=0;e<h.length;e+=1)q[h[e]]=null;for(e=0;e<j.length;e+=1)r[j[e]]=null;for(m=f,g=new c.Queue,g.push(b),e=0;e<d.ready_list.length;e+=1)g.push(d.ready_list[e]),g.push(b);return g.push(n,function(a){throw v(a),a}),g}).fail(function(a){v(a)})}b.self===b.top?(d=function(){g.call(this)},d.declareMethod=g.declareMethod,d.ready_list=[],d.ready=g.ready,d.prototype=new g,d.prototype.constructor=d,d.prototype.path=s,p[s]=d,i=new p[s]):(j=e.build({window:b.parent,origin:"*",scope:"renderJS"}),d=h,i=new h,j.bind("methodCall",function(a,b){i[b[0]].apply(i,b[1]).then(function(b){a.complete(b)}).fail(function(b){a.error(b.toString())}),a.delayReturn(!0)}),k=function(){0===t&&u===!0&&j.notify({method:"ready"})},l=function(a){t+=1,j.call({method:"declareMethod",params:a,success:function(){t-=1,k()},error:function(){t-=1}})},l("getInterfaceList"),l("getRequiredCSSList"),l("getRequiredJSList"),l("getPath"),l("getTitle"),d.declareMethod=function(a,b){var c=g.declareMethod.apply(this,[a,b]);return l(a),c}),m=d,a.addEventListener("DOMContentLoaded",w,!1)}),b.self!==b.top&&n.then(function(){u=!0,k()}).fail(function(a){throw j.notify({method:"failed",params:a.toString()}),a})}var m,n,o,p={},q={},r={};g.prototype.title="",g.prototype.interface_list=[],g.prototype.path="",g.prototype.html="",g.prototype.required_css_list=[],g.prototype.required_js_list=[],g.ready_list=[],g.ready=function(a){return this.ready_list.push(a),this},g.declareMethod=function(a,b){return this.prototype[a]=function(){var a=this,d=arguments;return(new c.Queue).push(function(){return b.apply(a,d)})},this},g.declareMethod("getInterfaceList",function(){return this.interface_list}).declareMethod("getRequiredCSSList",function(){return this.required_css_list}).declareMethod("getRequiredJSList",function(){return this.required_js_list}).declareMethod("getPath",function(){return this.path}).declareMethod("getTitle",function(){return this.title}).declareMethod("getElement",function(){if(this.element===f)throw new Error("No element defined");return this.element}),h.ready_list=[],h.ready=g.ready,h.prototype=new g,h.prototype.constructor=h,j.ready_list=[],j.ready=g.ready,j.prototype=new g,j.prototype.constructor=j,g.prototype.declareGadget=function(a,b){var d,e=n;return b===f&&(b={}),b.sandbox===f&&(b.sandbox="public"),d=(new c.Queue).push(function(){return e}).push(function(){var c;if("public"===b.sandbox)c=i;else{if("iframe"!==b.sandbox)throw new Error("Unsupported sandbox options '"+b.sandbox+"'");c=k}return c(a,b)}).push(function(a){function b(){return a}var c;for(m=f,c=0;c<a.constructor.ready_list.length;c+=1)d.push(a.constructor.ready_list[c]),d.push(b);return a}).push(f,function(a){throw m=f,a}),n=d},o=function(a){var c;if(a===b?c=m:a instanceof g&&(c=a),c===f)throw new Error("Unknown selector '"+a+"'");return c},o.declareJS=function(b){var d;return d=q.hasOwnProperty(b)?c.resolve():new c.Promise(function(c,d){var e;e=a.createElement("script"),e.type="text/javascript",e.src=b,e.onload=function(){q[b]=null,c()},e.onerror=function(a){d(a)},a.head.appendChild(e)})},o.declareCSS=function(b){var d;return d=r.hasOwnProperty(b)?c.resolve():new c.Promise(function(c,d){var e;e=a.createElement("link"),e.rel="stylesheet",e.type="text/css",e.href=b,e.onload=function(){r[b]=null,c()},e.onerror=function(a){d(a)},a.head.appendChild(e)})},o.declareGadgetKlass=function(a){function b(){var b,c,e;if(!p.hasOwnProperty(a)){b=function(){g.call(this)},b.ready_list=[],b.declareMethod=g.declareMethod,b.ready=g.ready,b.prototype=new g,b.prototype.constructor=b,b.prototype.path=a,b.template_element=(new d).parseFromString(j.responseText,"text/html"),e=o.parseGadgetHTMLDocument(b.template_element);for(c in e)e.hasOwnProperty(c)&&(b.prototype[c]=e[c]);p[a]=b}return p[a]}function e(c,d){function e(){var a;try{0===j.readyState?d(j):4===j.readyState&&(j.status<200||j.status>=300||!/^text\/html[;]?/.test(j.getResponseHeader("Content-Type")||"")?d(j):(a=b(),c(a)))}catch(e){d(e)}}j=new XMLHttpRequest,j.open("GET",a),j.onreadystatechange=e,j.setRequestHeader("Accept","text/html"),j.withCredentials=!0,j.send()}function h(){j!==f&&j.readyState!==j.DONE&&j.abort()}var i,j;return i=p.hasOwnProperty(a)?c.resolve(p[a]):new c.Promise(e,h)},o.clearGadgetKlassList=function(){p={},q={},r={}},o.parseGadgetHTMLDocument=function(a){var b,c,d={title:"",interface_list:[],required_css_list:[],required_js_list:[]};if(9!==a.nodeType)throw new Error("The first parameter should be an HTMLDocument");for(d.title=a.title,b=0;b<a.head.children.length;b+=1)c=a.head.children[b],null!==c.href&&("stylesheet"===c.rel?d.required_css_list.push(c.getAttribute("href")):"text/javascript"===c.type?d.required_js_list.push(c.getAttribute("src")):"http://www.renderjs.org/rel/interface"===c.rel&&d.interface_list.push(c.getAttribute("href")));return d},b.rJS=b.renderJS=o,b.RenderJSGadget=g,b.RenderJSEmbeddedGadget=h,b.RenderJSIframeGadget=j,l()}(document,window,RSVP,DOMParser,Channel);
\ No newline at end of file

dist/renderjs-latest.js

+/*! RenderJs v0.3.2 */
+
+/*
+ * DOMParser HTML extension
+ * 2012-09-04
+ *
+ * By Eli Grey, http://eligrey.com
+ * Public domain.
+ * NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
+ */
+/*! @source https://gist.github.com/1129031 */
+(function (DOMParser) {
+  "use strict";
+  var DOMParser_proto = DOMParser.prototype,
+    real_parseFromString = DOMParser_proto.parseFromString;
+
+  // Firefox/Opera/IE throw errors on unsupported types
+  try {
+    // WebKit returns null on unsupported types
+    if ((new DOMParser()).parseFromString("", "text/html")) {
+      // text/html parsing is natively supported
+      return;
+    }
+  } catch (ignore) {}
+
+  DOMParser_proto.parseFromString = function (markup, type) {
+    var result, doc, doc_elt, first_elt;
+    if (/^\s*text\/html\s*(?:;|$)/i.test(type)) {
+      doc = document.implementation.createHTMLDocument("");
+      doc_elt = doc.documentElement;
+
+      doc_elt.innerHTML = markup;
+      first_elt = doc_elt.firstElementChild;
+
+      if (doc_elt.childElementCount === 1
+          && first_elt.localName.toLowerCase() === "html") {
+        doc.replaceChild(first_elt, doc_elt);
+      }
+
+      result = doc;
+    } else {
+      result = real_parseFromString.apply(this, arguments);
+    }
+    return result;
+  };
+}(DOMParser));
+
+/*
+ * renderJs - Generic Gadget library renderer.
+ * http://www.renderjs.org/documentation
+ */
+(function (document, window, RSVP, DOMParser, Channel, undefined) {
+  "use strict";
+
+  var gadget_model_dict = {},
+    javascript_registration_dict = {},
+    stylesheet_registration_dict = {},
+    gadget_loading_klass,
+    loading_gadget_promise,
+    renderJS;
+
+  /////////////////////////////////////////////////////////////////
+  // RenderJSGadget
+  /////////////////////////////////////////////////////////////////
+  function RenderJSGadget() {
+    if (!(this instanceof RenderJSGadget)) {
+      return new RenderJSGadget();
+    }
+  }
+  RenderJSGadget.prototype.title = "";
+  RenderJSGadget.prototype.interface_list = [];
+  RenderJSGadget.prototype.path = "";
+  RenderJSGadget.prototype.html = "";
+  RenderJSGadget.prototype.required_css_list = [];
+  RenderJSGadget.prototype.required_js_list = [];
+
+  RenderJSGadget.ready_list = [];
+  RenderJSGadget.ready = function (callback) {
+    this.ready_list.push(callback);
+    return this;
+  };
+
+  /////////////////////////////////////////////////////////////////
+  // RenderJSGadget.declareMethod
+  /////////////////////////////////////////////////////////////////
+  RenderJSGadget.declareMethod = function (name, callback) {
+    this.prototype[name] = function () {
+      var context = this,
+        argument_list = arguments;
+
+      return new RSVP.Queue()
+        .push(function () {
+          return callback.apply(context, argument_list);
+        });
+    };
+    // Allow chain
+    return this;
+  };
+
+  RenderJSGadget
+    .declareMethod('getInterfaceList', function () {
+      // Returns the list of gadget prototype
+      return this.interface_list;
+    })
+    .declareMethod('getRequiredCSSList', function () {
+      // Returns a list of CSS required by the gadget
+      return this.required_css_list;
+    })
+    .declareMethod('getRequiredJSList', function () {
+      // Returns a list of JS required by the gadget
+      return this.required_js_list;
+    })
+    .declareMethod('getPath', function () {
+      // Returns the path of the code of a gadget
+      return this.path;
+    })
+    .declareMethod('getTitle', function () {
+      // Returns the title of a gadget
+      return this.title;
+    })
+    .declareMethod('getElement', function () {
+      // Returns the DOM Element of a gadget
+      if (this.element === undefined) {
+        throw new Error("No element defined");
+      }
+      return this.element;
+    });
+
+  /////////////////////////////////////////////////////////////////
+  // RenderJSEmbeddedGadget
+  /////////////////////////////////////////////////////////////////
+  // Class inheritance
+  function RenderJSEmbeddedGadget() {
+    if (!(this instanceof RenderJSEmbeddedGadget)) {
+      return new RenderJSEmbeddedGadget();
+    }
+    RenderJSGadget.call(this);
+  }
+  RenderJSEmbeddedGadget.ready_list = [];
+  RenderJSEmbeddedGadget.ready =
+    RenderJSGadget.ready;
+  RenderJSEmbeddedGadget.prototype = new RenderJSGadget();
+  RenderJSEmbeddedGadget.prototype.constructor = RenderJSEmbeddedGadget;
+
+  /////////////////////////////////////////////////////////////////
+  // privateDeclarePublicGadget
+  /////////////////////////////////////////////////////////////////
+  function privateDeclarePublicGadget(url, options) {
+    var gadget_instance;
+    if (options.element === undefined) {
+      options.element = document.createElement("div");
+    }
+    return new RSVP.Queue()
+      .push(function () {
+        return renderJS.declareGadgetKlass(url);
+      })
+      // Get the gadget class and instanciate it
+      .push(function (Klass) {
+        var i,
+          template_node_list = Klass.template_element.body.childNodes;
+        gadget_loading_klass = Klass;
+        gadget_instance = new Klass();
+        gadget_instance.element = options.element;
+        for (i = 0; i < template_node_list.length; i += 1) {
+          gadget_instance.element.appendChild(
+            template_node_list[i].cloneNode(true)
+          );
+        }
+        // Load dependencies if needed
+        return RSVP.all([
+          gadget_instance.getRequiredJSList(),
+          gadget_instance.getRequiredCSSList()
+        ]);
+      })
+      // Load all JS/CSS
+      .push(function (all_list) {
+        var parameter_list = [],
+          i;
+        // Load JS
+        for (i = 0; i < all_list[0].length; i += 1) {
+          parameter_list.push(renderJS.declareJS(all_list[0][i]));
+        }
+        // Load CSS
+        for (i = 0; i < all_list[1].length; i += 1) {
+          parameter_list.push(renderJS.declareCSS(all_list[1][i]));
+        }
+        return RSVP.all(parameter_list);
+      })
+      .push(function () {
+        return gadget_instance;
+      });
+  }
+
+  /////////////////////////////////////////////////////////////////
+  // RenderJSIframeGadget
+  /////////////////////////////////////////////////////////////////
+  function RenderJSIframeGadget() {
+    if (!(this instanceof RenderJSIframeGadget)) {
+      return new RenderJSIframeGadget();
+    }
+    RenderJSGadget.call(this);
+  }
+  RenderJSIframeGadget.ready_list = [];
+  RenderJSIframeGadget.ready =
+    RenderJSGadget.ready;
+  RenderJSIframeGadget.prototype = new RenderJSGadget();
+  RenderJSIframeGadget.prototype.constructor = RenderJSIframeGadget;
+
+  /////////////////////////////////////////////////////////////////
+  // privateDeclareIframeGadget
+  /////////////////////////////////////////////////////////////////
+  function privateDeclareIframeGadget(url, options) {
+    var gadget_instance,
+      iframe,
+      node,
+      iframe_loading_deferred = RSVP.defer();
+
+    if (options.element === undefined) {
+      throw new Error("DOM element is required to create Iframe Gadget " +
+                      url);
+    }
+
+    // Check if the element is attached to the DOM
+    node = options.element.parentNode;
+    while (node !== null) {
+      if (node === document) {
+        break;
+      }
+      node = node.parentNode;
+    }
+    if (node === null) {
+      throw new Error("The parent element is not attached to the DOM for " +
+                      url);
+    }
+
+    gadget_instance = new RenderJSIframeGadget();
+    iframe = document.createElement("iframe");
+//    gadget_instance.element.setAttribute("seamless", "seamless");
+    iframe.setAttribute("src", url);
+    gadget_instance.path = url;
+    gadget_instance.element = options.element;
+
+    // Attach it to the DOM
+    options.element.appendChild(iframe);
+
+    // XXX Manage unbind when deleting the gadget
+
+    // Create the communication channel with the iframe
+    gadget_instance.chan = Channel.build({
+      window: iframe.contentWindow,
+      origin: "*",
+      scope: "renderJS"
+    });
+
+    // Create new method from the declareMethod call inside the iframe
+    gadget_instance.chan.bind("declareMethod", function (trans, method_name) {
+      gadget_instance[method_name] = function () {
+        var argument_list = arguments;
+        return new RSVP.Promise(function (resolve, reject) {
+          gadget_instance.chan.call({
+            method: "methodCall",
+            params: [
+              method_name,
+              Array.prototype.slice.call(argument_list, 0)],
+            success: function (s) {
+              resolve(s);
+            },
+            error: function (e) {
+              reject(e);
+            }
+          });
+        });
+      };
+      return "OK";
+    });
+
+    // Wait for the iframe to be loaded before continuing
+    gadget_instance.chan.bind("ready", function (trans) {
+      iframe_loading_deferred.resolve(gadget_instance);
+      return "OK";
+    });
+    gadget_instance.chan.bind("failed", function (trans, params) {
+      iframe_loading_deferred.reject(params);
+      return "OK";
+    });
+    return RSVP.any([
+      iframe_loading_deferred.promise,
+      // Timeout to prevent non renderJS embeddable gadget
+      // XXX Maybe using iframe.onload/onerror would be safer?
+      RSVP.timeout(5000)
+    ]);
+  }
+
+  /////////////////////////////////////////////////////////////////
+  // RenderJSGadget.declareGadget
+  /////////////////////////////////////////////////////////////////
+  RenderJSGadget.prototype.declareGadget = function (url, options) {
+    var queue,
+      previous_loading_gadget_promise = loading_gadget_promise;
+
+    if (options === undefined) {
+      options = {};
+    }
+    if (options.sandbox === undefined) {
+      options.sandbox = "public";
+    }
+
+    // Change the global variable to update the loading queue
+    queue = new RSVP.Queue()
+      // Wait for previous gadget loading to finish first
+      .push(function () {
+        return previous_loading_gadget_promise;
+      })
+      .push(function () {
+        var method;
+        if (options.sandbox === "public") {
+          method = privateDeclarePublicGadget;
+        } else if (options.sandbox === "iframe") {
+          method = privateDeclareIframeGadget;
+        } else {
+          throw new Error("Unsupported sandbox options '" +
+                          options.sandbox + "'");
+        }
+        return method(url, options);
+      })
+      // Set the HTML context
+      .push(function (gadget_instance) {
+        var i;
+        // Drop the current loading klass info used by selector
+        gadget_loading_klass = undefined;
+        // Trigger calling of all ready callback
+        function ready_wrapper() {
+          return gadget_instance;
+        }
+        for (i = 0; i < gadget_instance.constructor.ready_list.length;
+             i += 1) {
+          // Put a timeout?
+          queue.push(gadget_instance.constructor.ready_list[i]);
+          // Always return the gadget instance after ready function
+          queue.push(ready_wrapper);
+        }
+        return gadget_instance;
+      })
+      .push(undefined, function (e) {
+        // Drop the current loading klass info used by selector
+        // even in case of error
+        gadget_loading_klass = undefined;
+        throw e;
+      });
+    loading_gadget_promise = queue;
+    return loading_gadget_promise;
+  };
+
+  /////////////////////////////////////////////////////////////////
+  // renderJS selector
+  /////////////////////////////////////////////////////////////////
+  renderJS = function (selector) {
+    var result;
+    if (selector === window) {
+      // window is the 'this' value when loading a javascript file
+      // In this case, use the current loading gadget constructor
+      result = gadget_loading_klass;
+    } else if (selector instanceof RenderJSGadget) {
+      result = selector;
+    }
+    if (result === undefined) {
+      throw new Error("Unknown selector '" + selector + "'");
+    }
+    return result;
+  };
+
+  /////////////////////////////////////////////////////////////////
+  // renderJS.declareJS
+  /////////////////////////////////////////////////////////////////
+  renderJS.declareJS = function (url) {
+    // Prevent infinite recursion if loading render.js
+    // more than once
+    var result;
+    if (javascript_registration_dict.hasOwnProperty(url)) {
+      result = RSVP.resolve();
+    } else {
+      result = new RSVP.Promise(function (resolve, reject) {
+        var newScript;
+        newScript = document.createElement('script');
+        newScript.type = 'text/javascript';
+        newScript.src = url;
+        newScript.onload = function () {
+          javascript_registration_dict[url] = null;
+          resolve();
+        };
+        newScript.onerror = function (e) {
+          reject(e);
+        };
+        document.head.appendChild(newScript);
+      });
+    }
+    return result;
+  };
+
+  /////////////////////////////////////////////////////////////////
+  // renderJS.declareCSS
+  /////////////////////////////////////////////////////////////////
+  renderJS.declareCSS = function (url) {
+    // https://github.com/furf/jquery-getCSS/blob/master/jquery.getCSS.js
+    // No way to cleanly check if a css has been loaded
+    // So, always resolve the promise...
+    // http://requirejs.org/docs/faq-advanced.html#css
+    var result;
+    if (stylesheet_registration_dict.hasOwnProperty(url)) {
+      result = RSVP.resolve();
+    } else {
+      result = new RSVP.Promise(function (resolve, reject) {
+        var link;
+        link = document.createElement('link');
+        link.rel = 'stylesheet';
+        link.type = 'text/css';
+        link.href = url;
+        link.onload = function () {
+          stylesheet_registration_dict[url] = null;
+          resolve();
+        };
+        link.onerror = function (e) {
+          reject(e);
+        };
+        document.head.appendChild(link);
+      });
+    }
+    return result;
+  };
+
+  /////////////////////////////////////////////////////////////////
+  // renderJS.declareGadgetKlass
+  /////////////////////////////////////////////////////////////////
+  renderJS.declareGadgetKlass = function (url) {
+    var result,
+      xhr;
+
+    function parse() {
+      var tmp_constructor,
+        key,
+        parsed_html;
+      if (!gadget_model_dict.hasOwnProperty(url)) {
+        // Class inheritance
+        tmp_constructor = function () {
+          RenderJSGadget.call(this);
+        };
+        tmp_constructor.ready_list = [];
+        tmp_constructor.declareMethod =
+          RenderJSGadget.declareMethod;
+        tmp_constructor.ready =
+          RenderJSGadget.ready;
+        tmp_constructor.prototype = new RenderJSGadget();
+        tmp_constructor.prototype.constructor = tmp_constructor;
+        tmp_constructor.prototype.path = url;
+        // https://developer.mozilla.org/en-US/docs/HTML_in_XMLHttpRequest
+        // https://developer.mozilla.org/en-US/docs/Web/API/DOMParser
+        // https://developer.mozilla.org/en-US/docs/Code_snippets/HTML_to_DOM
+        tmp_constructor.template_element =
+          (new DOMParser()).parseFromString(xhr.responseText, "text/html");
+        parsed_html = renderJS.parseGadgetHTMLDocument(
+          tmp_constructor.template_element
+        );
+        for (key in parsed_html) {
+          if (parsed_html.hasOwnProperty(key)) {
+            tmp_constructor.prototype[key] = parsed_html[key];
+          }
+        }
+
+        gadget_model_dict[url] = tmp_constructor;
+      }
+
+      return gadget_model_dict[url];
+    }
+
+    function resolver(resolve, reject) {
+      function handler() {
+        var tmp_result;
+        try {
+          if (xhr.readyState === 0) {
+            // UNSENT
+            reject(xhr);
+          } else if (xhr.readyState === 4) {
+            // DONE
+            if ((xhr.status < 200) || (xhr.status >= 300) ||
+                (!/^text\/html[;]?/.test(
+                  xhr.getResponseHeader("Content-Type") || ""
+                ))) {
+              reject(xhr);
+            } else {
+              tmp_result = parse();
+              resolve(tmp_result);
+            }
+          }
+        } catch (e) {
+          reject(e);
+        }
+      }
+
+      xhr = new XMLHttpRequest();
+      xhr.open("GET", url);
+      xhr.onreadystatechange = handler;
+      xhr.setRequestHeader('Accept', 'text/html');
+      xhr.withCredentials = true;
+      xhr.send();
+    }
+
+    function canceller() {
+      if ((xhr !== undefined) && (xhr.readyState !== xhr.DONE)) {
+        xhr.abort();
+      }
+    }
+
+    if (gadget_model_dict.hasOwnProperty(url)) {
+      // Return klass object if it already exists
+      result = RSVP.resolve(gadget_model_dict[url]);
+    } else {
+      // Fetch the HTML page and parse it
+      result = new RSVP.Promise(resolver, canceller);
+    }
+    return result;
+  };
+
+  /////////////////////////////////////////////////////////////////
+  // renderJS.clearGadgetKlassList
+  /////////////////////////////////////////////////////////////////
+  // For test purpose only
+  renderJS.clearGadgetKlassList = function () {
+    gadget_model_dict = {};
+    javascript_registration_dict = {};
+    stylesheet_registration_dict = {};
+  };
+
+  /////////////////////////////////////////////////////////////////
+  // renderJS.parseGadgetHTMLDocument
+  /////////////////////////////////////////////////////////////////
+  renderJS.parseGadgetHTMLDocument = function (document_element) {
+    var settings = {
+        title: "",
+        interface_list: [],
+        required_css_list: [],
+        required_js_list: []
+      },
+      i,
+      element;
+    if (document_element.nodeType === 9) {
+      settings.title = document_element.title;
+
+      for (i = 0; i < document_element.head.children.length; i += 1) {
+        element = document_element.head.children[i];
+        if (element.href !== null) {
+          // XXX Manage relative URL during extraction of URLs
+          // element.href returns absolute URL in firefox but "" in chrome;
+          if (element.rel === "stylesheet") {
+            settings.required_css_list.push(element.getAttribute("href"));
+          } else if (element.type === "text/javascript") {
+            settings.required_js_list.push(element.getAttribute("src"));
+          } else if (element.rel === "http://www.renderjs.org/rel/interface") {
+            settings.interface_list.push(element.getAttribute("href"));
+          }
+        }
+      }
+    } else {
+      throw new Error("The first parameter should be an HTMLDocument");
+    }
+    return settings;
+  };
+
+  /////////////////////////////////////////////////////////////////
+  // global
+  /////////////////////////////////////////////////////////////////
+  window.rJS = window.renderJS = renderJS;
+  window.RenderJSGadget = RenderJSGadget;
+  window.RenderJSEmbeddedGadget = RenderJSEmbeddedGadget;
+  window.RenderJSIframeGadget = RenderJSIframeGadget;
+
+  ///////////////////////////////////////////////////
+  // Bootstrap process. Register the self gadget.
+  ///////////////////////////////////////////////////
+
+  function bootstrap() {
+    var url = window.location.href,
+      tmp_constructor,
+      root_gadget,
+      declare_method_count = 0,
+      embedded_channel,
+      notifyReady,
+      notifyDeclareMethod,
+      gadget_ready = false;
+
+
+    // Create the gadget class for the current url
+    if (gadget_model_dict.hasOwnProperty(url)) {
+      throw new Error("bootstrap should not be called twice");
+    }
+    loading_gadget_promise = new RSVP.Promise(function (resolve, reject) {
+      if (window.self === window.top) {
+        // XXX Copy/Paste from declareGadgetKlass
+        tmp_constructor = function () {
+          RenderJSGadget.call(this);
+        };
+        tmp_constructor.declareMethod = RenderJSGadget.declareMethod;
+        tmp_constructor.ready_list = [];
+        tmp_constructor.ready = RenderJSGadget.ready;
+        tmp_constructor.prototype = new RenderJSGadget();
+        tmp_constructor.prototype.constructor = tmp_constructor;
+        tmp_constructor.prototype.path = url;
+        gadget_model_dict[url] = tmp_constructor;
+
+        // Create the root gadget instance and put it in the loading stack
+        root_gadget = new gadget_model_dict[url]();
+
+      } else {
+        // Create the communication channel
+        embedded_channel = Channel.build({
+          window: window.parent,
+          origin: "*",
+          scope: "renderJS"
+        });
+        // Create the root gadget instance and put it in the loading stack
+        tmp_constructor = RenderJSEmbeddedGadget;
+        root_gadget = new RenderJSEmbeddedGadget();
+
+        // Bind calls to renderJS method on the instance
+        embedded_channel.bind("methodCall", function (trans, v) {
+          root_gadget[v[0]].apply(root_gadget, v[1]).then(function (g) {
+            trans.complete(g);
+          }).fail(function (e) {
+            trans.error(e.toString());
+          });
+          trans.delayReturn(true);
+        });
+
+        // Notify parent about gadget instanciation
+        notifyReady = function () {
+          if ((declare_method_count === 0) && (gadget_ready === true)) {
+            embedded_channel.notify({method: "ready"});
+          }
+        };
+
+        // Inform parent gadget about declareMethod calls here.
+        notifyDeclareMethod = function (name) {
+          declare_method_count += 1;
+          embedded_channel.call({
+            method: "declareMethod",
+            params: name,
+            success: function () {
+              declare_method_count -= 1;
+              notifyReady();
+            },
+            error: function () {
+              declare_method_count -= 1;
+            }
+          });
+        };
+
+        notifyDeclareMethod("getInterfaceList");
+        notifyDeclareMethod("getRequiredCSSList");
+        notifyDeclareMethod("getRequiredJSList");
+        notifyDeclareMethod("getPath");
+        notifyDeclareMethod("getTitle");
+
+        // Surcharge declareMethod to inform parent window
+        tmp_constructor.declareMethod = function (name, callback) {
+          var result = RenderJSGadget.declareMethod.apply(
+              this,
+              [name, callback]
+            );
+          notifyDeclareMethod(name);
+          return result;
+        };
+      }
+
+      gadget_loading_klass = tmp_constructor;
+
+      function init() {
+        // XXX HTML properties can only be set when the DOM is fully loaded
+        var settings = renderJS.parseGadgetHTMLDocument(document),
+          j,
+          key;
+        for (key in settings) {
+          if (settings.hasOwnProperty(key)) {
+            tmp_constructor.prototype[key] = settings[key];
+          }
+        }
+        tmp_constructor.template_element = document.createElement("div");
+        root_gadget.element = document.body;
+        for (j = 0; j < root_gadget.element.childNodes.length; j += 1) {
+          tmp_constructor.template_element.appendChild(
+            root_gadget.element.childNodes[j].cloneNode(true)
+          );
+        }
+        RSVP.all([root_gadget.getRequiredJSList(),
+                  root_gadget.getRequiredCSSList()])
+          .then(function (all_list) {
+            var i,
+              js_list = all_list[0],
+              css_list = all_list[1],
+              queue;
+            for (i = 0; i < js_list.length; i += 1) {
+              javascript_registration_dict[js_list[i]] = null;
+            }
+            for (i = 0; i < css_list.length; i += 1) {
+              stylesheet_registration_dict[css_list[i]] = null;
+            }
+            gadget_loading_klass = undefined;
+            queue = new RSVP.Queue();
+            function ready_wrapper() {
+              return root_gadget;
+            }
+            queue.push(ready_wrapper);
+            for (i = 0; i < tmp_constructor.ready_list.length; i += 1) {
+              // Put a timeout?
+              queue.push(tmp_constructor.ready_list[i]);
+              // Always return the gadget instance after ready function
+              queue.push(ready_wrapper);
+            }
+            queue.push(resolve, function (e) {
+              reject(e);
+              throw e;
+            });
+            return queue;
+          }).fail(function (e) {
+            reject(e);
+          });
+      }
+      document.addEventListener('DOMContentLoaded', init, false);
+    });
+
+    if (window.self !== window.top) {
+      // Inform parent window that gadget is correctly loaded
+      loading_gadget_promise.then(function () {
+        gadget_ready = true;
+        notifyReady();
+      }).fail(function (e) {
+        embedded_channel.notify({method: "failed", params: e.toString()});
+        throw e;
+      });
+    }
+
+  }
+  bootstrap();
+
+}(document, window, RSVP, DOMParser, Channel));

dist/renderjs-latest.min.js

+!function(a){"use strict";var b=a.prototype,c=b.parseFromString;try{if((new a).parseFromString("","text/html"))return}catch(d){}b.parseFromString=function(a,b){var d,e,f,g;return/^\s*text\/html\s*(?:;|$)/i.test(b)?(e=document.implementation.createHTMLDocument(""),f=e.documentElement,f.innerHTML=a,g=f.firstElementChild,1===f.childElementCount&&"html"===g.localName.toLowerCase()&&e.replaceChild(g,f),d=e):d=c.apply(this,arguments),d}}(DOMParser),function(a,b,c,d,e,f){"use strict";function g(){return this instanceof g?void 0:new g}function h(){return this instanceof h?(g.call(this),void 0):new h}function i(b,d){var e;return d.element===f&&(d.element=a.createElement("div")),(new c.Queue).push(function(){return o.declareGadgetKlass(b)}).push(function(a){var b,f=a.template_element.body.childNodes;for(m=a,e=new a,e.element=d.element,b=0;b<f.length;b+=1)e.element.appendChild(f[b].cloneNode(!0));return c.all([e.getRequiredJSList(),e.getRequiredCSSList()])}).push(function(a){var b,d=[];for(b=0;b<a[0].length;b+=1)d.push(o.declareJS(a[0][b]));for(b=0;b<a[1].length;b+=1)d.push(o.declareCSS(a[1][b]));return c.all(d)}).push(function(){return e})}function j(){return this instanceof j?(g.call(this),void 0):new j}function k(b,d){var g,h,i,k=c.defer();if(d.element===f)throw new Error("DOM element is required to create Iframe Gadget "+b);for(i=d.element.parentNode;null!==i&&i!==a;)i=i.parentNode;if(null===i)throw new Error("The parent element is not attached to the DOM for "+b);return g=new j,h=a.createElement("iframe"),h.setAttribute("src",b),g.path=b,g.element=d.element,d.element.appendChild(h),g.chan=e.build({window:h.contentWindow,origin:"*",scope:"renderJS"}),g.chan.bind("declareMethod",function(a,b){return g[b]=function(){var a=arguments;return new c.Promise(function(c,d){g.chan.call({method:"methodCall",params:[b,Array.prototype.slice.call(a,0)],success:function(a){c(a)},error:function(a){d(a)}})})},"OK"}),g.chan.bind("ready",function(){return k.resolve(g),"OK"}),g.chan.bind("failed",function(a,b){return k.reject(b),"OK"}),c.any([k.promise,c.timeout(5e3)])}function l(){var d,i,j,k,l,s=b.location.href,t=0,u=!1;if(p.hasOwnProperty(s))throw new Error("bootstrap should not be called twice");n=new c.Promise(function(n,v){function w(){var b,e,g=o.parseGadgetHTMLDocument(a);for(e in g)g.hasOwnProperty(e)&&(d.prototype[e]=g[e]);for(d.template_element=a.createElement("div"),i.element=a.body,b=0;b<i.element.childNodes.length;b+=1)d.template_element.appendChild(i.element.childNodes[b].cloneNode(!0));c.all([i.getRequiredJSList(),i.getRequiredCSSList()]).then(function(a){function b(){return i}var e,g,h=a[0],j=a[1];for(e=0;e<h.length;e+=1)q[h[e]]=null;for(e=0;e<j.length;e+=1)r[j[e]]=null;for(m=f,g=new c.Queue,g.push(b),e=0;e<d.ready_list.length;e+=1)g.push(d.ready_list[e]),g.push(b);return g.push(n,function(a){throw v(a),a}),g}).fail(function(a){v(a)})}b.self===b.top?(d=function(){g.call(this)},d.declareMethod=g.declareMethod,d.ready_list=[],d.ready=g.ready,d.prototype=new g,d.prototype.constructor=d,d.prototype.path=s,p[s]=d,i=new p[s]):(j=e.build({window:b.parent,origin:"*",scope:"renderJS"}),d=h,i=new h,j.bind("methodCall",function(a,b){i[b[0]].apply(i,b[1]).then(function(b){a.complete(b)}).fail(function(b){a.error(b.toString())}),a.delayReturn(!0)}),k=function(){0===t&&u===!0&&j.notify({method:"ready"})},l=function(a){t+=1,j.call({method:"declareMethod",params:a,success:function(){t-=1,k()},error:function(){t-=1}})},l("getInterfaceList"),l("getRequiredCSSList"),l("getRequiredJSList"),l("getPath"),l("getTitle"),d.declareMethod=function(a,b){var c=g.declareMethod.apply(this,[a,b]);return l(a),c}),m=d,a.addEventListener("DOMContentLoaded",w,!1)}),b.self!==b.top&&n.then(function(){u=!0,k()}).fail(function(a){throw j.notify({method:"failed",params:a.toString()}),a})}var m,n,o,p={},q={},r={};g.prototype.title="",g.prototype.interface_list=[],g.prototype.path="",g.prototype.html="",g.prototype.required_css_list=[],g.prototype.required_js_list=[],g.ready_list=[],g.ready=function(a){return this.ready_list.push(a),this},g.declareMethod=function(a,b){return this.prototype[a]=function(){var a=this,d=arguments;return(new c.Queue).push(function(){return b.apply(a,d)})},this},g.declareMethod("getInterfaceList",function(){return this.interface_list}).declareMethod("getRequiredCSSList",function(){return this.required_css_list}).declareMethod("getRequiredJSList",function(){return this.required_js_list}).declareMethod("getPath",function(){return this.path}).declareMethod("getTitle",function(){return this.title}).declareMethod("getElement",function(){if(this.element===f)throw new Error("No element defined");return this.element}),h.ready_list=[],h.ready=g.ready,h.prototype=new g,h.prototype.constructor=h,j.ready_list=[],j.ready=g.ready,j.prototype=new g,j.prototype.constructor=j,g.prototype.declareGadget=function(a,b){var d,e=n;return b===f&&(b={}),b.sandbox===f&&(b.sandbox="public"),d=(new c.Queue).push(function(){return e}).push(function(){var c;if("public"===b.sandbox)c=i;else{if("iframe"!==b.sandbox)throw new Error("Unsupported sandbox options '"+b.sandbox+"'");c=k}return c(a,b)}).push(function(a){function b(){return a}var c;for(m=f,c=0;c<a.constructor.ready_list.length;c+=1)d.push(a.constructor.ready_list[c]),d.push(b);return a}).push(f,function(a){throw m=f,a}),n=d},o=function(a){var c;if(a===b?c=m:a instanceof g&&(c=a),c===f)throw new Error("Unknown selector '"+a+"'");return c},o.declareJS=function(b){var d;return d=q.hasOwnProperty(b)?c.resolve():new c.Promise(function(c,d){var e;e=a.createElement("script"),e.type="text/javascript",e.src=b,e.onload=function(){q[b]=null,c()},e.onerror=function(a){d(a)},a.head.appendChild(e)})},o.declareCSS=function(b){var d;return d=r.hasOwnProperty(b)?c.resolve():new c.Promise(function(c,d){var e;e=a.createElement("link"),e.rel="stylesheet",e.type="text/css",e.href=b,e.onload=function(){r[b]=null,c()},e.onerror=function(a){d(a)},a.head.appendChild(e)})},o.declareGadgetKlass=function(a){function b(){var b,c,e;if(!p.hasOwnProperty(a)){b=function(){g.call(this)},b.ready_list=[],b.declareMethod=g.declareMethod,b.ready=g.ready,b.prototype=new g,b.prototype.constructor=b,b.prototype.path=a,b.template_element=(new d).parseFromString(j.responseText,"text/html"),e=o.parseGadgetHTMLDocument(b.template_element);for(c in e)e.hasOwnProperty(c)&&(b.prototype[c]=e[c]);p[a]=b}return p[a]}function e(c,d){function e(){var a;try{0===j.readyState?d(j):4===j.readyState&&(j.status<200||j.status>=300||!/^text\/html[;]?/.test(j.getResponseHeader("Content-Type")||"")?d(j):(a=b(),c(a)))}catch(e){d(e)}}j=new XMLHttpRequest,j.open("GET",a),j.onreadystatechange=e,j.setRequestHeader("Accept","text/html"),j.withCredentials=!0,j.send()}function h(){j!==f&&j.readyState!==j.DONE&&j.abort()}var i,j;return i=p.hasOwnProperty(a)?c.resolve(p[a]):new c.Promise(e,h)},o.clearGadgetKlassList=function(){p={},q={},r={}},o.parseGadgetHTMLDocument=function(a){var b,c,d={title:"",interface_list:[],required_css_list:[],required_js_list:[]};if(9!==a.nodeType)throw new Error("The first parameter should be an HTMLDocument");for(d.title=a.title,b=0;b<a.head.children.length;b+=1)c=a.head.children[b],null!==c.href&&("stylesheet"===c.rel?d.required_css_list.push(c.getAttribute("href")):"text/javascript"===c.type?d.required_js_list.push(c.getAttribute("src")):"http://www.renderjs.org/rel/interface"===c.rel&&d.interface_list.push(c.getAttribute("href")));return d},b.rJS=b.renderJS=o,b.RenderJSGadget=g,b.RenderJSEmbeddedGadget=h,b.RenderJSIframeGadget=j,l()}(document,window,RSVP,DOMParser,Channel);
\ No newline at end of file

examples/officejs/aceeditor.html

@@ -3,9 +3,9 @@
 <head>
   <title>Ace Editor</title>
   <script src="./ace/ace.js" type="text/javascript" charset="utf-8"></script>
-  <script src="../../lib/rsvp/rsvp.js" type="text/javascript"></script>
+  <script src="../../node_modules/rsvp/dist/rsvp-2.0.4.js" type="text/javascript"></script>
   <script src="../../lib/jschannel/jschannel.js" type="text/javascript"></script>
-  <script src="../../renderjs.js" type="text/javascript"></script>
+  <script src="../../dist/renderjs-latest.js" type="text/javascript"></script>
   <script src="aceeditor.js" type="text/javascript"></script>
   <!--script src="./ace/theme-monokai.js" type="text/javascript"></script>
   <script src="./ace/mode-javascript.js" type="text/javascript"></script>

examples/officejs/aceeditor.js

-/*global window, rJS, ace */
-"use strict";
+/*global ace */
 (function (window, rJS) {
+  "use strict";
 
   var gk = rJS(window);
 

examples/officejs/catalog.html

@@ -2,9 +2,9 @@
   <head>
     <title>Catalog Gadget</title>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <script src="../../lib/rsvp/rsvp.js" type="text/javascript"></script>
+    <script src="../../node_modules/rsvp/dist/rsvp-2.0.4.js" type="text/javascript"></script>
     <script src="../../lib/jschannel/jschannel.js" type="text/javascript"></script>
-    <script src="../../renderjs.js" type="text/javascript"></script>
+    <script src="../../dist/renderjs-latest.js" type="text/javascript"></script>
     <script src="catalog.js" type="text/javascript"></script>
   </head>
   <body>

examples/officejs/catalog.js

-/*global window, jQuery, rJS */
-"use strict";
 (function (window, $, rJS) {
+  "use strict";
 
   var gk = rJS(window),
     io_dict = {
       "path" :      "./io.html",
       "title" :     "IO",
-      "interface" : "http://www.renderjs.org/interface/io",
+      "interface" : "http://www.renderjs.org/interface/io"
     },
     editor_1_dict = {
       "path" :      "./editor.html",
       "title" :     "Simple Text Editor Gadget",
-      "interface" : "http://www.renderjs.org/interface/editor",
+      "interface" : "http://www.renderjs.org/interface/editor"
     },
     editor_2_dict = {
       "path" :      "./jqteditor.html",
       "title" :     "JQuery Text Editor Gadget",
-      "interface" : "http://www.renderjs.org/interface/editor",
+      "interface" : "http://www.renderjs.org/interface/editor"
     },
     editor_3_dict = {
       "path" :      "./aceeditor.html",
       "title" :     "Ace Editor Gadget",
-      "interface" : "http://www.renderjs.org/interface/editor",
+      "interface" : "http://www.renderjs.org/interface/editor"
     },
     catalog_list = [
       {
         "path" :      "./officejs.html",
         "title" :     "Office JS",
-        "interface" : "http://www.renderjs.org/interface/officejs",
-      },
+        "interface" : "http://www.renderjs.org/interface/officejs"
+      }
     ];
 
   catalog_list.push(io_dict);

examples/officejs/editor.html

@@ -2,9 +2,9 @@
   <head>
     <title>Simple Text Editor Gadget</title>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <script src="../../lib/rsvp/rsvp.js" type="text/javascript"></script>
+    <script src="../../node_modules/rsvp/dist/rsvp-2.0.4.js" type="text/javascript"></script>
     <script src="../../lib/jschannel/jschannel.js" type="text/javascript"></script>
-    <script src="../../renderjs.js" type="text/javascript"></script>
+    <script src="../../dist/renderjs-latest.js" type="text/javascript"></script>
     <script src="editor.js" type="text/javascript"></script>
     <link rel="http://www.renderjs.org/rel/interface"
           href="http://www.renderjs.org/interface/editor"/>

examples/officejs/editor.js

-/*global window, rJS */
-"use strict";
 (function (window, rJS) {
+  "use strict";
 
   function escape_text(text) {
     // &, ", ', <, >, /

examples/officejs/io.html

@@ -2,9 +2,9 @@
   <head>
     <title>IO</title>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <script src="../../lib/rsvp/rsvp.js" type="text/javascript"></script>
+    <script src="../../node_modules/rsvp/dist/rsvp-2.0.4.js" type="text/javascript"></script>
     <script src="../../lib/jschannel/jschannel.js" type="text/javascript"></script>
-    <script src="../../renderjs.js" type="text/javascript"></script>
+    <script src="../../dist/renderjs-latest.js" type="text/javascript"></script>
     <script src="../../lib/jio/sha256.js" type="text/javascript"></script>
     <script src="../../lib/jio/jio.js" type="text/javascript"></script>
     <script src="../../lib/jio/complex_queries.js" type="text/javascript"></script>

examples/officejs/io.js

-/*global window, jQuery, jIO, rJS */
-"use strict";
 (function (window, $, jIO, rJS) {
+  "use strict";
 
   var gk = rJS(window);
 

examples/officejs/jqteditor.html

@@ -3,9 +3,9 @@
     <title>JQuery Text Editor Gadget</title>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
     <link rel="stylesheet" href="jqte/jquery-te-1.4.0.css" />
-    <script src="../../lib/rsvp/rsvp.js" type="text/javascript"></script>
+    <script src="../../node_modules/rsvp/dist/rsvp-2.0.4.js" type="text/javascript"></script>
     <script src="../../lib/jschannel/jschannel.js" type="text/javascript"></script>
-    <script src="../../renderjs.js" type="text/javascript"></script>
+    <script src="../../dist/renderjs-latest.js" type="text/javascript"></script>
     <script src="../../lib/jquery/jquery.js" type="text/javascript"></script>
     <script src="jqte/jquery-te-1.4.0.js" type="text/javascript"></script>
     <script src="jqteditor.js" type="text/javascript"></script>

examples/officejs/jqteditor.js

-/*global window, rJS, jQuery */
-"use strict";
 (function (window, rJS, $) {
+  "use strict";
 
   var gk = rJS(window);
 

examples/officejs/officejs.html

@@ -6,9 +6,9 @@
     <title>Office JS</title>
     <link rel="stylesheet" href="../../lib/jqm/jquery.mobile.css" />
     <link rel="stylesheet" href="officejs.css" />
-    <script src="../../lib/rsvp/rsvp.js" type="text/javascript"></script>
+    <script src="../../node_modules/rsvp/dist/rsvp-2.0.4.js" type="text/javascript"></script>
     <script src="../../lib/jschannel/jschannel.js" type="text/javascript"></script>
-    <script src="../../renderjs.js" type="text/javascript"></script>
+    <script src="../../dist/renderjs-latest.js" type="text/javascript"></script>
     <script src="../../lib/jquery/jquery.js" type="text/javascript"></script>
     <script src="officejs.js" type="text/javascript"></script>
     <script src="../../lib/jqm/jquery.mobile.js" type="text/javascript"></script>

examples/officejs/officejs.js

-/*global document, window, jQuery, rJS, RSVP */
-"use strict";
+/*global console */
 (function (window, $, rJS, RSVP) {
+  "use strict";
 
   function attachIOToEditor(all_param) {
     var editor = all_param[0],

lib/qunit/qunit.css

-/**
- * QUnit v1.12.0 - A JavaScript Unit Testing Framework
- *
- * http://qunitjs.com
- *
- * Copyright 2012 jQuery Foundation and other contributors
- * Released under the MIT license.
- * http://jquery.org/license
- */
-
-/** Font Family and Sizes */
-
-#qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
-	font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
-}
-
-#qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
-#qunit-tests { font-size: smaller; }
-
-
-/** Resets */
-
-#qunit-tests, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter {
-	margin: 0;
-	padding: 0;
-}
-
-
-/** Header */
-
-#qunit-header {
-	padding: 0.5em 0 0.5em 1em;
-
-	color: #8699a4;
-	background-color: #0d3349;
-
-	font-size: 1.5em;
-	line-height: 1em;
-	font-weight: normal;
-
-	border-radius: 5px 5px 0 0;
-	-moz-border-radius: 5px 5px 0 0;
-	-webkit-border-top-right-radius: 5px;
-	-webkit-border-top-left-radius: 5px;
-}
-
-#qunit-header a {
-	text-decoration: none;
-	color: #c2ccd1;
-}
-
-#qunit-header a:hover,
-#qunit-header a:focus {
-	color: #fff;
-}
-
-#qunit-testrunner-toolbar label {
-	display: inline-block;
-	padding: 0 .5em 0 .1em;
-}
-
-#qunit-banner {
-	height: 5px;
-}
-
-#qunit-testrunner-toolbar {
-	padding: 0.5em 0 0.5em 2em;
-	color: #5E740B;
-	background-color: #eee;
-	overflow: hidden;
-}
-
-#qunit-userAgent {
-	padding: 0.5em 0 0.5em 2.5em;
-	background-color: #2b81af;
-	color: #fff;
-	text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
-}
-
-#qunit-modulefilter-container {
-	float: right;
-}
-
-/** Tests: Pass/Fail */
-
-#qunit-tests {
-	list-style-position: inside;
-}
-
-#qunit-tests li {
-	padding: 0.4em 0.5em 0.4em 2.5em;
-	border-bottom: 1px solid #fff;
-	list-style-position: inside;
-}
-
-#qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running  {
-	display: none;
-}
-
-#qunit-tests li strong {
-	cursor: pointer;
-}
-
-#qunit-tests li a {
-	padding: 0.5em;
-	color: #c2ccd1;
-	text-decoration: none;
-}
-#qunit-tests li a:hover,
-#qunit-tests li a:focus {
-	color: #000;
-}
-
-#qunit-tests li .runtime {
-	float: right;
-	font-size: smaller;
-}
-
-.qunit-assert-list {
-	margin-top: 0.5em;
-	padding: 0.5em;
-
-	background-color: #fff;
-
-	border-radius: 5px;
-	-moz-border-radius: 5px;
-	-webkit-border-radius: 5px;
-}
-
-.qunit-collapsed {
-	display: none;
-}
-
-#qunit-tests table {
-	border-collapse: collapse;
-	margin-top: .2em;
-}
-
-#qunit-tests th {
-	text-align: right;
-	vertical-align: top;
-	padding: 0 .5em 0 0;
-}
-
-#qunit-tests td {
-	vertical-align: top;
-}
-
-#qunit-tests pre {
-	margin: 0;
-	white-space: pre-wrap;
-	word-wrap: break-word;
-}
-
-#qunit-tests del {
-	background-color: #e0f2be;
-	color: #374e0c;
-	text-decoration: none;
-}
-
-#qunit-tests ins {
-	background-color: #ffcaca;
-	color: #500;
-	text-decoration: none;
-}
-
-/*** Test Counts */
-
-#qunit-tests b.counts                       { color: black; }
-#qunit-tests b.passed                       { color: #5E740B; }
-#qunit-tests b.failed                       { color: #710909; }
-
-#qunit-tests li li {
-	padding: 5px;
-	background-color: #fff;
-	border-bottom: none;
-	list-style-position: inside;
-}
-
-/*** Passing Styles */
-
-#qunit-tests li li.pass {
-	color: #3c510c;
-	background-color: #fff;
-	border-left: 10px solid #C6E746;
-}
-
-#qunit-tests .pass                          { color: #528CE0; background-color: #D2E0E6; }
-#qunit-tests .pass .test-name               { color: #366097; }
-
-#qunit-tests .pass .test-actual,
-#qunit-tests .pass .test-expected           { color: #999999; }
-
-#qunit-banner.qunit-pass                    { background-color: #C6E746; }
-
-/*** Failing Styles */
-
-#qunit-tests li li.fail {
-	color: #710909;
-	background-color: #fff;
-	border-left: 10px solid #EE5757;
-	white-space: pre;
-}
-
-#qunit-tests > li:last-child {
-	border-radius: 0 0 5px 5px;
-	-moz-border-radius: 0 0 5px 5px;
-	-webkit-border-bottom-right-radius: 5px;
-	-webkit-border-bottom-left-radius: 5px;
-}
-
-#qunit-tests .fail                          { color: #000000; background-color: #EE5757; }
-#qunit-tests .fail .test-name,
-#qunit-tests .fail .module-name             { color: #000000; }
-
-#qunit-tests .fail .test-actual             { color: #EE5757; }
-#qunit-tests .fail .test-expected           { color: green;   }
-
-#qunit-banner.qunit-fail                    { background-color: #EE5757; }
-
-
-/** Result */
-
-#qunit-testresult {
-	padding: 0.5em 0.5em 0.5em 2.5em;
-
-	color: #2b81af;
-	background-color: #D2E0E6;
-
-	border-bottom: 1px solid white;
-}
-#qunit-testresult .module-name {
-	font-weight: bold;
-}
-
-/** Fixture */
-
-#qunit-fixture {
-	position: absolute;
-	top: -10000px;
-	left: -10000px;
-	width: 1000px;
-	height: 1000px;
-}

lib/qunit/qunit.js

-/**
- * QUnit v1.12.0 - A JavaScript Unit Testing Framework
- *
- * http://qunitjs.com
- *
- * Copyright 2013 jQuery Foundation and other contributors
- * Released under the MIT license.
- * https://jquery.org/license/
- */
-
-(function( window ) {
-
-var QUnit,
-	assert,
-	config,
-	onErrorFnPrev,
-	testId = 0,
-	fileName = (sourceFromStacktrace( 0 ) || "" ).replace(/(:\d+)+\)?/, "").replace(/.+\//, ""),
-	toString = Object.prototype.toString,
-	hasOwn = Object.prototype.hasOwnProperty,
-	// Keep a local reference to Date (GH-283)
-	Date = window.Date,
-	setTimeout = window.setTimeout,
-	defined = {
-		setTimeout: typeof window.setTimeout !== "undefined",
-		sessionStorage: (function() {
-			var x = "qunit-test-string";
-			try {
-				sessionStorage.setItem( x, x );
-				sessionStorage.removeItem( x );
-				return true;
-			} catch( e ) {
-				return false;
-			}
-		}())
-	},
-	/**
-	 * Provides a normalized error string, correcting an issue
-	 * with IE 7 (and prior) where Error.prototype.toString is
-	 * not properly implemented
-	 *
-	 * Based on http://es5.github.com/#x15.11.4.4
-	 *
-	 * @param {String|Error} error
-	 * @return {String} error message
-	 */
-	errorString = function( error ) {
-		var name, message,
-			errorString = error.toString();
-		if ( errorString.substring( 0, 7 ) === "[object" ) {
-			name = error.name ? error.name.toString() : "Error";
-			message = error.message ? error.message.toString() : "";
-			if ( name && message ) {
-				return name + ": " + message;
-			} else if ( name ) {
-				return name;
-			} else if ( message ) {
-				return message;
-			} else {
-				return "Error";
-			}
-		} else {
-			return errorString;
-		}
-	},
-	/**
-	 * Makes a clone of an object using only Array or Object as base,
-	 * and copies over the own enumerable properties.
-	 *
-	 * @param {Object} obj
-	 * @return {Object} New object with only the own properties (recursively).
-	 */
-	objectValues = function( obj ) {
-		// Grunt 0.3.x uses an older version of jshint that still has jshint/jshint#392.
-		/*jshint newcap: false */
-		var key, val,
-			vals = QUnit.is( "array", obj ) ? [] : {};
-		for ( key in obj ) {
-			if ( hasOwn.call( obj, key ) ) {
-				val = obj[key];
-				vals[key] = val === Object(val) ? objectValues(val) : val;
-			}
-		}
-		return vals;
-	};
-
-function Test( settings ) {
-	extend( this, settings );
-	this.assertions = [];
-	this.testNumber = ++Test.count;
-}
-
-Test.count = 0;
-
-Test.prototype = {
-	init: function() {
-		var a, b, li,
-			tests = id( "qunit-tests" );
-
-		if ( tests ) {
-			b = document.createElement( "strong" );
-			b.innerHTML = this.nameHtml;
-
-			// `a` initialized at top of scope
-			a = document.createElement( "a" );
-			a.innerHTML = "Rerun";
-			a.href = QUnit.url({ testNumber: this.testNumber });
-
-			li = document.createElement( "li" );
-			li.appendChild( b );
-			li.appendChild( a );
-			li.className = "running";
-			li.id = this.id = "qunit-test-output" + testId++;
-
-			tests.appendChild( li );
-		}
-	},
-	setup: function() {
-		if (
-			// Emit moduleStart when we're switching from one module to another
-			this.module !== config.previousModule ||
-				// They could be equal (both undefined) but if the previousModule property doesn't
-				// yet exist it means this is the first test in a suite that isn't wrapped in a
-				// module, in which case we'll just emit a moduleStart event for 'undefined'.
-				// Without this, reporters can get testStart before moduleStart  which is a problem.
-				!hasOwn.call( config, "previousModule" )
-		) {
-			if ( hasOwn.call( config, "previousModule" ) ) {
-				runLoggingCallbacks( "moduleDone", QUnit, {
-					name: config.previousModule,
-					failed: config.moduleStats.bad,
-					passed: config.moduleStats.all - config.moduleStats.bad,
-					total: config.moduleStats.all
-				});
-			}
-			config.previousModule = this.module;
-			config.moduleStats = { all: 0, bad: 0 };
-			runLoggingCallbacks( "moduleStart", QUnit, {
-				name: this.module
-			});
-		}
-
-		config.current = this;
-
-		this.testEnvironment = extend({
-			setup: function() {},
-			teardown: function() {}
-		}, this.moduleTestEnvironment );
-
-		this.started = +new Date();
-		runLoggingCallbacks( "testStart", QUnit, {
-			name: this.testName,
-			module: this.module
-		});
-
-		/*jshint camelcase:false */
-
-
-		/**
-		 * Expose the current test environment.
-		 *
-		 * @deprecated since 1.12.0: Use QUnit.config.current.testEnvironment instead.
-		 */
-		QUnit.current_testEnvironment = this.testEnvironment;
-
-		/*jshint camelcase:true */
-
-		if ( !config.pollution ) {
-			saveGlobal();
-		}
-		if ( config.notrycatch ) {
-			this.testEnvironment.setup.call( this.testEnvironment, QUnit.assert );
-			return;
-		}
-		try {
-			this.testEnvironment.setup.call( this.testEnvironment, QUnit.assert );
-		} catch( e ) {
-			QUnit.pushFailure( "Setup failed on " + this.testName + ": " + ( e.message || e ), extractStacktrace( e, 1 ) );
-		}
-	},
-	run: function() {
-		config.current = this;
-
-		var running = id( "qunit-testresult" );
-
-		if ( running ) {
-			running.innerHTML = "Running: <br/>" + this.nameHtml;
-		}
-
-		if ( this.async ) {
-			QUnit.stop();
-		}
-
-		this.callbackStarted = +new Date();
-
-		if ( config.notrycatch ) {
-			this.callback.call( this.testEnvironment, QUnit.assert );
-			this.callbackRuntime = +new Date() - this.callbackStarted;
-			return;
-		}
-
-		try {
-			this.callback.call( this.testEnvironment, QUnit.assert );
-			this.callbackRuntime = +new Date() - this.callbackStarted;
-		} catch( e ) {
-			this.callbackRuntime = +new Date() - this.callbackStarted;
-
-			QUnit.pushFailure( "Died on test #" + (this.assertions.length + 1) + " " + this.stack + ": " + ( e.message || e ), extractStacktrace( e, 0 ) );
-			// else next test will carry the responsibility
-			saveGlobal();
-
-			// Restart the tests if they're blocking
-			if ( config.blocking ) {
-				QUnit.start();
-			}
-		}
-	},
-	teardown: function() {
-		config.current = this;
-		if ( config.notrycatch ) {
-			if ( typeof this.callbackRuntime === "undefined" ) {
-				this.callbackRuntime = +new Date() - this.callbackStarted;
-			}
-			this.testEnvironment.teardown.call( this.testEnvironment, QUnit.assert );
-			return;
-		} else {
-			try {
-				this.testEnvironment.teardown.call( this.testEnvironment, QUnit.assert );
-			} catch( e ) {
-				QUnit.pushFailure( "Teardown failed on " + this.testName + ": " + ( e.message || e ), extractStacktrace( e, 1 ) );
-			}
-		}
-		checkPollution();
-	},
-	finish: function() {
-		config.current = this;
-		if ( config.requireExpects && this.expected === null ) {
-			QUnit.pushFailure( "Expected number of assertions to be defined, but expect() was not called.", this.stack );
-		} else if ( this.expected !== null && this.expected !== this.assertions.length ) {
-			QUnit.pushFailure( "Expected " + this.expected + " assertions, but " + this.assertions.length + " were run", this.stack );
-		} else if ( this.expected === null && !this.assertions.length ) {
-			QUnit.pushFailure( "Expected at least one assertion, but none were run - call expect(0) to accept zero assertions.", this.stack );
-		}
-
-		var i, assertion, a, b, time, li, ol,
-			test = this,
-			good = 0,
-			bad = 0,
-			tests = id( "qunit-tests" );
-
-		this.runtime = +new Date() - this.started;
-		config.stats.all += this.assertions.length;
-		config.moduleStats.all += this.assertions.length;
-
-		if ( tests ) {
-			ol = document.createElement( "ol" );
-			ol.className = "qunit-assert-list";
-
-			for ( i = 0; i < this.assertions.length; i++ ) {
-				assertion = this.assertions[i];
-
-				li = document.createElement( "li" );
-				li.className = assertion.result ? "pass" : "fail";
-				li.innerHTML = assertion.message || ( assertion.result ? "okay" : "failed" );
-				ol.appendChild( li );
-
-				if ( assertion.result ) {
-					good++;
-				} else {
-					bad++;
-					config.stats.bad++;
-					config.moduleStats.bad++;
-				}
-			}
-
-			// store result when possible
-			if ( QUnit.config.reorder && defined.sessionStorage ) {
-				if ( bad ) {
-					sessionStorage.setItem( "qunit-test-" + this.module + "-" + this.testName, bad );
-				} else {
-					sessionStorage.removeItem( "qunit-test-" + this.module + "-" + this.testName );
-				}
-			}
-
-			if ( bad === 0 ) {
-				addClass( ol, "qunit-collapsed" );
-			}
-
-			// `b` initialized at top of scope
-			b = document.createElement( "strong" );
-			b.innerHTML = this.nameHtml + " <b class='counts'>(<b class='failed'>" + bad + "</b>, <b class='passed'>" + good + "</b>, " + this.assertions.length + ")</b>";
-
-			addEvent(b, "click", function() {
-				var next = b.parentNode.lastChild,
-					collapsed = hasClass( next, "qunit-collapsed" );
-				( collapsed ? removeClass : addClass )( next, "qunit-collapsed" );
-			});
-
-			addEvent(b, "dblclick", function( e ) {
-				var target = e && e.target ? e.target : window.event.srcElement;
-				if ( target.nodeName.toLowerCase() === "span" || target.nodeName.toLowerCase() === "b" ) {
-					target = target.parentNode;
-				}
-				if ( window.location && target.nodeName.toLowerCase() === "strong" ) {
-					window.location = QUnit.url({ testNumber: test.testNumber });
-				}
-			});
-
-			// `time` initialized at top of scope
-			time = document.createElement( "span" );
-			time.className = "runtime";
-			time.innerHTML = this.runtime + " ms";
-
-			// `li` initialized at top of scope
-			li = id( this.id );
-			li.className = bad ? "fail" : "pass";
-			li.removeChild( li.firstChild );
-			a = li.firstChild;
-			li.appendChild( b );
-			li.appendChild( a );
-			li.appendChild( time );
-			li.appendChild( ol );
-
-		} else {
-			for ( i = 0; i < this.assertions.length; i++ ) {
-				if ( !this.assertions[i].result ) {
-					bad++;
-					config.stats.bad++;
-					config.moduleStats.bad++;
-				}
-			}
-		}
-
-		runLoggingCallbacks( "testDone", QUnit, {
-			name: this.testName,
-			module: this.module,
-			failed: bad,
-			passed: this.assertions.length - bad,
-			total: this.assertions.length,
-			duration: this.runtime
-		});
-
-		QUnit.reset();
-
-		config.current = undefined;
-	},
-
-	queue: function() {
-		var bad,
-			test = this;
-
-		synchronize(function() {
-			test.init();
-		});
-		function run() {
-			// each of these can by async
-			synchronize(function() {
-				test.setup();
-			});
-			synchronize(function() {
-				test.run();
-			});
-			synchronize(function() {
-				test.teardown();
-			});
-			synchronize(function() {
-				test.finish();
-			});
-		}
-
-		// `bad` initialized at top of scope
-		// defer when previous test run passed, if storage is available
-		bad = QUnit.config.reorder && defined.sessionStorage &&
-						+sessionStorage.getItem( "qunit-test-" + this.module + "-" + this.testName );
-
-		if ( bad ) {
-			run();
-		} else {
-			synchronize( run, true );
-		}
-	}
-};
-
-// Root QUnit object.
-// `QUnit` initialized at top of scope
-QUnit = {
-
-	// call on start of module test to prepend name to all tests
-	module: function( name, testEnvironment ) {
-		config.currentModule = name;
-		config.currentModuleTestEnvironment = testEnvironment;
-		config.modules[name] = true;
-	},
-
-	asyncTest: function( testName, expected, callback ) {
-		if ( arguments.length === 2 ) {
-			callback = expected;
-			expected = null;
-		}
-
-		QUnit.test( testName, expected, callback, true );
-	},
-
-	test: function( testName, expected, callback, async ) {
-		var test,
-			nameHtml = "<span class='test-name'>" + escapeText( testName ) + "</span>";
-
-		if ( arguments.length === 2 ) {
-			callback = expected;
-			expected = null;
-		}
-
-		if ( config.currentModule ) {
-			nameHtml = "<span class='module-name'>" + escapeText( config.currentModule ) + "</span>: " + nameHtml;
-		}
-
-		test = new Test({
-			nameHtml: nameHtml,
-			testName: testName,
-			expected: expected,
-			async: async,
-			callback: callback,
-			module: config.currentModule,
-			moduleTestEnvironment: config.currentModuleTestEnvironment,
-			stack: sourceFromStacktrace( 2 )
-		});
-
-		if ( !validTest( test ) ) {
-			return;
-		}
-
-		test.queue();
-	},
-
-	// Specify the number of expected assertions to guarantee that failed test (no assertions are run at all) don't slip through.
-	expect: function( asserts ) {
-		if (arguments.length === 1) {
-			config.current.expected = asserts;
-		} else {
-			return config.current.expected;
-		}
-	},
-
-	start: function( count ) {
-		// QUnit hasn't been initialized yet.
-		// Note: RequireJS (et al) may delay onLoad
-		if ( config.semaphore === undefined ) {
-			QUnit.begin(function() {
-				// This is triggered at the top of QUnit.load, push start() to the event loop, to allow QUnit.load to finish first
-				setTimeout(function() {
-					QUnit.start( count );
-				});
-			});
-			return;
-		}
-
-		config.semaphore -= count || 1;
-		// don't start until equal number of stop-calls
-		if ( config.semaphore > 0 ) {
-			return;
-		}
-		// ignore if start is called more often then stop
-		if ( config.semaphore < 0 ) {
-			config.semaphore = 0;
-			QUnit.pushFailure( "Called start() while already started (QUnit.config.semaphore was 0 already)", null, sourceFromStacktrace(2) );
-			return;
-		}
-		// A slight delay, to avoid any current callbacks
-		if ( defined.setTimeout ) {
-			setTimeout(function() {
-				if ( config.semaphore > 0 ) {
-					return;
-				}
-				if ( config.timeout ) {
-					clearTimeout( config.timeout );
-				}
-
-				config.blocking = false;
-				process( true );
-			}, 13);
-		} else {
-			config.blocking = false;
-			process( true );
-		}
-	},
-
-	stop: function( count ) {
-		config.semaphore += count || 1;
-		config.blocking = true;
-
-		if ( config.testTimeout && defined.setTimeout ) {
-			clearTimeout( config.timeout );
-			config.timeout = setTimeout(function() {
-				QUnit.ok( false, "Test timed out" );
-				config.semaphore = 1;
-				QUnit.start();
-			}, config.testTimeout );
-		}
-	}
-};
-
-// `assert` initialized at top of scope
-// Assert helpers
-// All of these must either call QUnit.push() or manually do:
-// - runLoggingCallbacks( "log", .. );
-// - config.current.assertions.push({ .. });
-// We attach it to the QUnit object *after* we expose the public API,
-// otherwise `assert` will become a global variable in browsers (#341).
-assert = {
-	/**
-	 * Asserts rough true-ish result.
-	 * @name ok
-	 * @function
-	 * @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" );
-	 */
-	ok: function( result, msg ) {
-		if ( !config.current ) {
-			throw new Error( "ok() assertion outside test context, was " + sourceFromStacktrace(2) );
-		}
-		result = !!result;
-		msg = msg || (result ? "okay" : "failed" );
-
-		var source,
-			details = {
-				module: config.current.module,
-				name: config.current.testName,
-				result: result,
-				message: msg
-			};
-
-		msg = "<span class='test-message'>" + escapeText( msg ) + "</span>";
-
-		if ( !result ) {
-			source = sourceFromStacktrace( 2 );
-			if ( source ) {
-				details.source = source;
-				msg += "<table><tr class='test-source'><th>Source: </th><td><pre>" + escapeText( source ) + "</pre></td></tr></table>";
-			}
-		}
-		runLoggingCallbacks( "log", QUnit, details );
-		config.current.assertions.push({
-			result: result,
-			message: msg
-		});
-	},
-
-	/**
-	 * Assert that the first two arguments are equal, with an optional message.
-	 * Prints out both actual and expected values.
-	 * @name equal
-	 * @function
-	 * @example equal( format( "Received {0} bytes.", 2), "Received 2 bytes.", "format() replaces {0} with next argument" );
-	 */
-	equal: function( actual, expected, message ) {
-		/*jshint eqeqeq:false */
-		QUnit.push( expected == actual, actual, expected, message );
-	},
-
-	/**
-	 * @name notEqual
-	 * @function
-	 */
-	notEqual: function( actual, expected, message ) {
-		/*jshint eqeqeq:false */
-		QUnit.push( expected != actual, actual, expected, message );
-	},
-
-	/**
-	 * @name propEqual
-	 * @function
-	 */
-	propEqual: function( actual, expected, message ) {
-		actual = objectValues(actual);
-		expected = objectValues(expected);
-		QUnit.push( QUnit.equiv(actual, expected), actual, expected, message );
-	},
-
-	/**
-	 * @name notPropEqual
-	 * @function
-	 */
-	notPropEqual: function( actual, expected, message ) {
-		actual = objectValues(actual);
-		expected = objectValues(expected);
-		QUnit.push( !QUnit.equiv(actual, expected), actual, expected, message );
-	},
-
-	/**
-	 * @name deepEqual
-	 * @function
-	 */
-	deepEqual: function( actual, expected, message ) {
-		QUnit.push( QUnit.equiv(actual, expected), actual, expected, message );
-	},
-
-	/**
-	 * @name notDeepEqual
-	 * @function
-	 */
-	notDeepEqual: function( actual, expected, message ) {
-		QUnit.push( !QUnit.equiv(actual, expected), actual, expected, message );
-	},
-
-	/**
-	 * @name strictEqual
-	 * @function
-	 */
-	strictEqual: function( actual, expected, message ) {
-		QUnit.push( expected === actual, actual, expected, message );
-	},
-
-	/**
-	 * @name notStrictEqual
-	 * @function
-	 */
-	notStrictEqual: function( actual, expected, message ) {
-		QUnit.push( expected !== actual, actual, expected, message );
-	},
-
-	"throws": function( block, expected, message ) {
-		var actual,
-			expectedOutput = expected,
-			ok = false;
-
-		// 'expected' is optional
-		if ( typeof expected === "string" ) {
-			message = expected;
-			expected = null;
-		}
-
-		config.current.ignoreGlobalErrors = true;
-		try {
-			block.call( config.current.testEnvironment );
-		} catch (e) {
-			actual = e;
-		}
-		config.current.ignoreGlobalErrors = false;
-
-		if ( actual ) {
-			// we don't want to validate thrown error
-			if ( !expected ) {
-				ok = true;
-				expectedOutput = null;
-			// expected is a regexp
-			} else if ( QUnit.objectType( expected ) === "regexp" ) {
-				ok = expected.test( errorString( actual ) );
-			// expected is a constructor
-			} else if ( actual instanceof expected ) {
-				ok = true;
-			// expected is a validation function which returns true is validation passed
-			} else if ( expected.call( {}, actual ) === true ) {
-				expectedOutput = null;
-				ok = true;
-			}
-
-			QUnit.push( ok, actual, expectedOutput, message );
-		} else {
-			QUnit.pushFailure( message, null, "No exception was thrown." );
-		}
-	}
-};
-
-/**
- * @deprecated since 1.8.0
- * Kept assertion helpers in root for backwards compatibility.
- */
-extend( QUnit, assert );
-
-/**
- * @deprecated since 1.9.0
- * Kept root "raises()" for backwards compatibility.
- * (Note that we don't introduce assert.raises).
- */
-QUnit.raises = assert[ "throws" ];
-
-/**
- * @deprecated since 1.0.0, replaced with error pushes since 1.3.0
- * Kept to avoid TypeErrors for undefined methods.
- */
-QUnit.equals = function() {
-	QUnit.push( false, false, false, "QUnit.equals has been deprecated since 2009 (e88049a0), use QUnit.equal instead" );
-};
-QUnit.same = function() {
-	QUnit.push( false, false, false, "QUnit.same has been deprecated since 2009 (e88049a0), use QUnit.deepEqual instead" );
-};
-
-// We want access to the constructor's prototype
-(function() {
-	function F() {}
-	F.prototype = QUnit;
-	QUnit = new F();
-	// Make F QUnit's constructor so that we can add to the prototype later
-	QUnit.constructor = F;
-}());
-
-/**
- * Config object: Maintain internal state
- * Later exposed as QUnit.config
- * `config` initialized at top of scope
- */
-config = {
-	// The queue of tests to run
-	queue: [],
-
-	// block until document ready
-	blocking: true,
-
-	// when enabled, show only failing tests
-	// gets persisted through sessionStorage and can be changed in UI via checkbox
-	hidepassed: false,
-
-	// by default, run previously failed tests first
-	// very useful in combination with "Hide passed tests" checked
-	reorder: true,
-
-	// by default, modify document.title when suite is done
-	altertitle: true,
-
-	// when enabled, all tests must call expect()
-	requireExpects: false,
-
-	// add checkboxes that are persisted in the query-string
-	// when enabled, the id is set to `true` as a `QUnit.config` property
-	urlConfig: [
-		{
-			id: "noglobals",
-			label: "Check for Globals",
-			tooltip: "Enabling this will test if any test introduces new properties on the `window` object. Stored as query-strings."
-		},
-		{
-			id: "notrycatch",
-			label: "No try-catch",
-			tooltip: "Enabling this will run tests outside of a try-catch block. Makes debugging exceptions in IE reasonable. Stored as query-strings."
-		}
-	],
-
-	// Set of all modules.
-	modules: {},
-
-	// logging callback queues
-	begin: [],
-	done: [],
-	log: [],
-	testStart: [],
-	testDone: [],
-	moduleStart: [],
-	moduleDone: []
-};
-
-// Export global variables, unless an 'exports' object exists,
-// in that case we assume we're in CommonJS (dealt with on the bottom of the script)
-if ( typeof exports === "undefined" ) {
-	extend( window, QUnit.constructor.prototype );
-
-	// Expose QUnit object
-	window.QUnit = QUnit;
-}
-
-// Initialize more QUnit.config and QUnit.urlParams
-(function() {
-	var i,
-		location = window.location || { search: "", protocol: "file:" },
-		params = location.search.slice( 1 ).split( "&" ),
-		length = params.length,
-		urlParams = {},
-		current;
-
-	if ( params[ 0 ] ) {
-		for ( i = 0; i < length; i++ ) {
-			current = params[ i ].split( "=" );
-			current[ 0 ] = decodeURIComponent( current[ 0 ] );
-			// allow just a key to turn on a flag, e.g., test.html?noglobals
-			current[ 1 ] = current[ 1 ] ? decodeURIComponent( current[ 1 ] ) : true;
-			urlParams[ current[ 0 ] ] = current[ 1 ];
-		}
-	}
-
-	QUnit.urlParams = urlParams;
-
-	// String search anywhere in moduleName+testName
-	config.filter = urlParams.filter;
-
-	// Exact match of the module name
-	config.module = urlParams.module;
-
-	config.testNumber = parseInt( urlParams.testNumber, 10 ) || null;
-
-	// Figure out if we're running the tests from a server or not
-	QUnit.isLocal = location.protocol === "file:";
-}());
-
-// Extend QUnit object,
-// these after set here because they should not be exposed as global functions
-extend( QUnit, {
-	assert: assert,
-
-	config: config,
-
-	// Initialize the configuration options
-	init: function() {
-		extend( config, {
-			stats: { all: 0, bad: 0 },
-			moduleStats: { all: 0, bad: 0 },
-			started: +new Date(),
-			updateRate: 1000,
-			blocking: false,
-			autostart: true,
-			autorun: false,
-			filter: "",
-			queue: [],
-			semaphore: 1
-		});
-
-		var tests, banner, result,
-			qunit = id( "qunit" );
-
-		if ( qunit ) {
-			qunit.innerHTML =
-				"<h1 id='qunit-header'>" + escapeText( document.title ) + "</h1>" +
-				"<h2 id='qunit-banner'></h2>" +
-				"<div id='qunit-testrunner-toolbar'></div>" +
-				"<h2 id='qunit-userAgent'></h2>" +
-				"<ol id='qunit-tests'></ol>";
-		}
-
-		tests = id( "qunit-tests" );
-		banner = id( "qunit-banner" );
-		result = id( "qunit-testresult" );
-
-		if ( tests ) {
-			tests.innerHTML = "";
-		}
-
-		if ( banner ) {
-			banner.className = "";
-		}
-
-		if ( result ) {
-			result.parentNode.removeChild( result );
-		}
-
-		if ( tests ) {
-			result = document.createElement( "p" );
-			result.id = "qunit-testresult";
-			result.className = "result";
-			tests.parentNode.insertBefore( result, tests );
-			result.innerHTML = "Running...<br/>&nbsp;";
-		}
-	},
-
-	// Resets the test setup. Useful for tests that modify the DOM.
-	/*
-	DEPRECATED: Use multiple tests instead of resetting inside a test.
-	Use testStart or testDone for custom cleanup.
-	This method will throw an error in 2.0, and will be removed in 2.1
-	*/
-	reset: function() {
-		var fixture = id( "qunit-fixture" );
-		if ( fixture ) {
-			fixture.innerHTML = config.fixture;
-		}
-	},
-
-	// Trigger an event on an element.
-	// @example triggerEvent( document.body, "click" );
-	triggerEvent: function( elem, type, event ) {
-		if ( document.createEvent ) {
-			event = document.createEvent( "MouseEvents" );
-			event.initMouseEvent(type, true, true, elem.ownerDocument.defaultView,
-				0, 0, 0, 0, 0, false, false, false, false, 0, null);
-
-			elem.dispatchEvent( event );
-		} else if ( elem.fireEvent ) {
-			elem.fireEvent( "on" + type );
-		}
-	},
-
-	// Safe object type checking
-	is: function( type, obj ) {
-		return QUnit.objectType( obj ) === type;
-	},
-
-	objectType: function( obj ) {
-		if ( typeof obj === "undefined" ) {
-				return "undefined";
-		// consider: typeof null === object
-		}
-		if ( obj === null ) {
-				return "null";
-		}
-
-		var match = toString.call( obj ).match(/^\[object\s(.*)\]$/),
-			type = match && match[1] || "";
-
-		switch ( type ) {
-			case "Number":
-				if ( isNaN(obj) ) {
-					return "nan";
-				}
-				return "number";
-			case "String":
-			case "Boolean":
-			case "Array":
-			case "Date":
-			case "RegExp":
-			case "Function":
-				return type.toLowerCase();
-		}
-		if ( typeof obj === "object" ) {
-			return "object";
-		}
-		return undefined;
-	},
-
-	push: function( result, actual, expected, message ) {
-		if ( !config.current ) {
-			throw new Error( "assertion outside test context, was " + sourceFromStacktrace() );
-		}
-
-		var output, source,
-			details = {
-				module: config.current.module,
-				name: config.current.testName,
-				result: result,
-				message: message,
-				actual: actual,
-				expected: expected
-			};
-
-		message = escapeText( message ) || ( result ? "okay" : "failed" );
-		message = "<span class='test-message'>" + message + "</span>";
-		output = message;
-
-		if ( !result ) {
-			expected = escapeText( QUnit.jsDump.parse(expected) );
-			actual = escapeText( QUnit.jsDump.parse(actual) );
-			output += "<table><tr class='test-expected'><th>Expected: </th><td><pre>" + expected + "</pre></td></tr>";
-
-			if ( actual !== expected ) {
-				output += "<tr class='test-actual'><th>Result: </th><td><pre>" + actual + "</pre></td></tr>";
-				output += "<tr class='test-diff'><th>Diff: </th><td><pre>" + QUnit.diff( expected, actual ) + "</pre></td></tr>";
-			}
-
-			source = sourceFromStacktrace();
-
-			if ( source ) {
-				details.source = source;
-				output += "<tr class='test-source'><th>Source: </th><td><pre>" + escapeText( source ) + "</pre></td></tr>";
-			}
-
-			output += "</table>";
-		}
-
-		runLoggingCallbacks( "log", QUnit, details );
-
-		config.current.assertions.push({
-			result: !!result,
-			message: output
-		});
-	},
-
-	pushFailure: function( message, source, actual ) {
-		if ( !config.current ) {
-			throw new Error( "pushFailure() assertion outside test context, was " + sourceFromStacktrace(2) );
-		}
-
-		var output,
-			details = {
-				module: config.current.module,
-				name: config.current.testName,
-				result: false,
-				message: message
-			};
-
-		message = escapeText( message ) || "error";
-		message = "<span class='test-message'>" + message + "</span>";
-		output = message;
-
-		output += "<table>";
-
-		if ( actual ) {
-			output += "<tr class='test-actual'><th>Result: </th><td><pre>" + escapeText( actual ) + "</pre></td></tr>";
-		}
-
-		if ( source ) {
-			details.source = source;
-			output += "<tr class='test-source'><th>Source: </th><td><pre>" + escapeText( source ) + "</pre></td></tr>";
-		}
-
-		output += "</table>";
-
-		runLoggingCallbacks( "log", QUnit, details );
-
-		config.current.assertions.push({
-			result: false,
-			message: output
-		});
-	},
-
-	url: function( params ) {
-		params = extend( extend( {}, QUnit.urlParams ), params );
-		var key,
-			querystring = "?";
-
-		for ( key in params ) {
-			if ( hasOwn.call( params, key ) ) {
-				querystring += encodeURIComponent( key ) + "=" +
-					encodeURIComponent( params[ key ] ) + "&";
-			}
-		}
-		return window.location.protocol + "//" + window.location.host +
-			window.location.pathname + querystring.slice( 0, -1 );
-	},
-
-	extend: extend,
-	id: id,
-	addEvent: addEvent,
-	addClass: addClass,
-	hasClass: hasClass,
-	removeClass: removeClass
-	// load, equiv, jsDump, diff: Attached later
-});
-
-/**
- * @deprecated: Created for backwards compatibility with test runner that set the hook function
- * into QUnit.{hook}, instead of invoking it and passing the hook function.
- * QUnit.constructor is set to the empty F() above so that we can add to it's prototype here.
- * Doing this allows us to tell if the following methods have been overwritten on the actual
- * QUnit object.
- */
-extend( QUnit.constructor.prototype, {
-
-	// Logging callbacks; all receive a single argument with the listed properties
-	// run test/logs.html for any related changes
-	begin: registerLoggingCallback( "begin" ),
-
-	// done: { failed, passed, total, runtime }
-	done: registerLoggingCallback( "done" ),
-
-	// log: { result, actual, expected, message }
-	log: registerLoggingCallback( "log" ),
-
-	// testStart: { name }
-	testStart: registerLoggingCallback( "testStart" ),
-
-	// testDone: { name, failed, passed, total, duration }
-	testDone: registerLoggingCallback( "testDone" ),
-
-	// moduleStart: { name }
-	moduleStart: registerLoggingCallback( "moduleStart" ),
-
-	// moduleDone: { name, failed, passed, total }
-	moduleDone: registerLoggingCallback( "moduleDone" )
-});
-
-if ( typeof document === "undefined" || document.readyState === "complete" ) {
-	config.autorun = true;
-}
-
-QUnit.load = function() {
-	runLoggingCallbacks( "begin", QUnit, {} );
-
-	// Initialize the config, saving the execution queue
-	var banner, filter, i, label, len, main, ol, toolbar, userAgent, val,
-		urlConfigCheckboxesContainer, urlConfigCheckboxes, moduleFilter,
-		numModules = 0,
-		moduleNames = [],
-		moduleFilterHtml = "",
-		urlConfigHtml = "",
-		oldconfig = extend( {}, config );
-
-	QUnit.init();
-	extend(config, oldconfig);
-
-	config.blocking = false;
-
-	len = config.urlConfig.length;
-
-	for ( i = 0; i < len; i++ ) {
-		val = config.urlConfig[i];
-		if ( typeof val === "string" ) {
-			val = {
-				id: val,
-				label: val,
-				tooltip: "[no tooltip available]"
-			};
-		}
-		config[ val.id ] = QUnit.urlParams[ val.id ];
-		urlConfigHtml += "<input id='qunit-urlconfig-" + escapeText( val.id ) +
-			"' name='" + escapeText( val.id ) +
-			"' type='checkbox'" + ( config[ val.id ] ? " checked='checked'" : "" ) +
-			" title='" + escapeText( val.tooltip ) +
-			"'><label for='qunit-urlconfig-" + escapeText( val.id ) +
-			"' title='" + escapeText( val.tooltip ) + "'>" + val.label + "</label>";
-	}
-	for ( i in config.modules ) {
-		if ( config.modules.hasOwnProperty( i ) ) {
-			moduleNames.push(i);
-		}
-	}
-	numModules = moduleNames.length;
-	moduleNames.sort( function( a, b ) {
-		return a.localeCompare( b );
-	});
-	moduleFilterHtml += "<label for='qunit-modulefilter'>Module: </label><select id='qunit-modulefilter' name='modulefilter'><option value='' " +
-		( config.module === undefined  ? "selected='selected'" : "" ) +
-		">< All Modules ></option>";
-
-
-	for ( i = 0; i < numModules; i++) {
-			moduleFilterHtml += "<option value='" + escapeText( encodeURIComponent(moduleNames[i]) ) + "' " +
-				( config.module === moduleNames[i] ? "selected='selected'" : "" ) +
-				">" + escapeText(moduleNames[i]) + "</option>";
-	}
-	moduleFilterHtml += "</select>";
-
-	// `userAgent` initialized at top of scope
-	userAgent = id( "qunit-userAgent" );
-	if ( userAgent ) {
-		userAgent.innerHTML = navigator.userAgent;
-	}
-
-	// `banner` initialized at top of scope
-	banner = id( "qunit-header" );
-	if ( banner ) {
-		banner.innerHTML = "<a href='" + QUnit.url({ filter: undefined, module: undefined, testNumber: undefined }) + "'>" + banner.innerHTML + "</a> ";
-	}
-
-	// `toolbar` initialized at top of scope
-	toolbar = id( "qunit-testrunner-toolbar" );
-	if ( toolbar ) {
-		// `filter` initialized at top of scope
-		filter = document.createElement( "input" );
-		filter.type = "checkbox";
-		filter.id = "qunit-filter-pass";
-
-		addEvent( filter, "click", function() {
-			var tmp,
-				ol = document.getElementById( "qunit-tests" );
-
-			if ( filter.checked ) {
-				ol.className = ol.className + " hidepass";
-			} else {
-				tmp = " " + ol.className.replace( /[\n\t\r]/g, " " ) + " ";
-				ol.className = tmp.replace( / hidepass /, " " );
-			}
-			if ( defined.sessionStorage ) {
-				if (filter.checked) {
-					sessionStorage.setItem( "qunit-filter-passed-tests", "true" );
-				} else {
-					sessionStorage.removeItem( "qunit-filter-passed-tests" );
-				}
-			}
-		});
-
-		if ( config.hidepassed || defined.sessionStorage && sessionStorage.getItem( "qunit-filter-passed-tests" ) ) {
-			filter.checked = true;
-			// `ol` initialized at top of scope
-			ol = document.getElementById( "qunit-tests" );
-			ol.className = ol.className + " hidepass";
-		}
-		toolbar.appendChild( filter );
-
-		// `label` initialized at top of scope
-		label = document.createElement( "label" );
-		label.setAttribute( "for", "qunit-filter-pass" );
-		label.setAttribute( "title", "Only show tests and assertions that fail. Stored in sessionStorage." );
-		label.innerHTML = "Hide passed tests";
-		toolbar.appendChild( label );
-
-		urlConfigCheckboxesContainer = document.createElement("span");
-		urlConfigCheckboxesContainer.innerHTML = urlConfigHtml;
-		urlConfigCheckboxes = urlConfigCheckboxesContainer.getElementsByTagName("input");
-		// For oldIE support:
-		// * Add handlers to the individual elements instead of the container
-		// * Use "click" instead of "change"
-		// * Fallback from event.target to event.srcElement
-		addEvents( urlConfigCheckboxes, "click", function( event ) {
-			var params = {},
-				target = event.target || event.srcElement;
-			params[ target.name ] = target.checked ? true : undefined;
-			window.location = QUnit.url( params );
-		});
-		toolbar.appendChild( urlConfigCheckboxesContainer );
-
-		if (numModules > 1) {
-			moduleFilter = document.createElement( "span" );
-			moduleFilter.setAttribute( "id", "qunit-modulefilter-container" );
-			moduleFilter.innerHTML = moduleFilterHtml;
-			addEvent( moduleFilter.lastChild, "change", function() {
-				var selectBox = moduleFilter.getElementsByTagName("select")[0],
-					selectedModule = decodeURIComponent(selectBox.options[selectBox.selectedIndex].value);
-
-				window.location = QUnit.url({
-					module: ( selectedModule === "" ) ? undefined : selectedModule,
-					// Remove any existing filters
-					filter: undefined,
-					testNumber: undefined
-				});
-			});
-			toolbar.appendChild(moduleFilter);
-		}
-	}
-
-	// `main` initialized at top of scope
-	main = id( "qunit-fixture" );
-	if ( main ) {
-		config.fixture = main.innerHTML;
-	}
-
-	if ( config.autostart ) {
-		QUnit.start();
-	}
-};
-
-addEvent( window, "load", QUnit.load );
-
-// `onErrorFnPrev` initialized at top of scope
-// Preserve other handlers
-onErrorFnPrev = window.onerror;
-
-// Cover uncaught exceptions
-// Returning true will suppress the default browser handler,
-// returning false will let it run.
-window.onerror = function ( error, filePath, linerNr ) {
-	var ret = false;
-	if ( onErrorFnPrev ) {
-		ret = onErrorFnPrev( error, filePath, linerNr );
-	}
-
-	// Treat return value as window.onerror itself does,
-	// Only do our handling if not suppressed.
-	if ( ret !== true ) {
-		if ( QUnit.config.current ) {
-			if ( QUnit.config.current.ignoreGlobalErrors ) {
-				return true;
-			}
-			QUnit.pushFailure( error, filePath + ":" + linerNr );
-		} else {
-			QUnit.test( "global failure", extend( function() {
-				QUnit.pushFailure( error, filePath + ":" + linerNr );
-			}, { validTest: validTest } ) );
-		}
-		return false;
-	}
-
-	return ret;
-};
-
-function done() {
-	config.autorun = true;
-
-	// Log the last module results
-	if ( config.currentModule ) {
-		runLoggingCallbacks( "moduleDone", QUnit, {
-			name: config.currentModule,
-			failed: config.moduleStats.bad,
-			passed: config.moduleStats.all - config.moduleStats.bad,
-			total: config.moduleStats.all
-		});
-	}
-	delete config.previousModule;
-
-	var i, key,
-		banner = id( "qunit-banner" ),
-		tests = id( "qunit-tests" ),
-		runtime = +new Date() - config.started,
-		passed = config.stats.all - config.stats.bad,
-		html = [
-			"Tests completed in ",
-			runtime,
-			" milliseconds.<br/>",
-			"<span class='passed'>",
-			passed,
-			"</span> assertions of <span class='total'>",
-			config.stats.all,
-			"</span> passed, <span class='failed'>",
-			config.stats.bad,
-			"</span> failed."
-		].join( "" );
-
-	if ( banner ) {
-		banner.className = ( config.stats.bad ? "qunit-fail" : "qunit-pass" );
-	}
-
-	if ( tests ) {
-		id( "qunit-testresult" ).innerHTML = html;
-	}
-
-	if ( config.altertitle && typeof document !== "undefined" && document.title ) {
-		// show ✖ for good, ✔ for bad suite result in title
-		// use escape sequences in case file gets loaded with non-utf-8-charset
-		document.title = [
-			( config.stats.bad ? "\u2716" : "\u2714" ),
-			document.title.replace( /^[\u2714\u2716] /i, "" )
-		].join( " " );
-	}
-
-	// clear own sessionStorage items if all tests passed
-	if ( config.reorder && defined.sessionStorage && config.stats.bad === 0 ) {
-		// `key` & `i` initialized at top of scope
-		for ( i = 0; i < sessionStorage.length; i++ ) {
-			key = sessionStorage.key( i++ );
-			if ( key.indexOf( "qunit-test-" ) === 0 ) {
-				sessionStorage.removeItem( key );
-			}
-		}
-	}
-
-	// scroll back to top to show results
-	if ( window.scrollTo ) {
-		window.scrollTo(0, 0);
-	}
-
-	runLoggingCallbacks( "done", QUnit, {
-		failed: config.stats.bad,
-		passed: passed,
-		total: config.stats.all,
-		runtime: runtime
-	});
-}
-
-/** @return Boolean: true if this test should be ran */
-function validTest( test ) {
-	var include,
-		filter = config.filter && config.filter.toLowerCase(),
-		module = config.module && config.module.toLowerCase(),
-		fullName = (test.module + ": " + test.testName).toLowerCase();
-
-	// Internally-generated tests are always valid
-	if ( test.callback && test.callback.validTest === validTest ) {
-		delete test.callback.validTest;
-		return true;
-	}
-
-	if ( config.testNumber ) {
-		return test.testNumber === config.testNumber;
-	}
-
-	if ( module && ( !test.module || test.module.toLowerCase() !== module ) ) {
-		return false;
-	}
-
-	if ( !filter ) {
-		return true;
-	}
-
-	include = filter.charAt( 0 ) !== "!";
-	if ( !include ) {
-		filter = filter.slice( 1 );
-	}
-
-	// If the filter matches, we need to honour include
-	if ( fullName.indexOf( filter ) !== -1 ) {
-		return include;
-	}
-
-	// Otherwise, do the opposite
-	return !include;
-}
-
-// so far supports only Firefox, Chrome and Opera (buggy), Safari (for real exceptions)
-// Later Safari and IE10 are supposed to support error.stack as well
-// See also https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error/Stack
-function extractStacktrace( e, offset ) {
-	offset = offset === undefined ? 3 : offset;
-
-	var stack, include, i;
-
-	if ( e.stacktrace ) {
-		// Opera
-		return e.stacktrace.split( "\n" )[ offset + 3 ];
-	} else if ( e.stack ) {
-		// Firefox, Chrome
-		stack = e.stack.split( "\n" );
-		if (/^error$/i.test( stack[0] ) ) {
-			stack.shift();
-		}
-		if ( fileName ) {
-			include = [];
-			for ( i = offset; i < stack.length; i++ ) {
-				if ( stack[ i ].indexOf( fileName ) !== -1 ) {
-					break;
-				}
-				include.push( stack[ i ] );
-			}
-			if ( include.length ) {
-				return include.join( "\n" );
-			}
-		}
-		return stack[ offset ];
-	} else if ( e.sourceURL ) {
-		// Safari, PhantomJS
-		// hopefully one day Safari provides actual stacktraces
-		// exclude useless self-reference for generated Error objects
-		if ( /qunit.js$/.test( e.sourceURL ) ) {
-			return;
-		}
-		// for actual exceptions, this is useful
-		return e.sourceURL + ":" + e.line;
-	}
-}
-function sourceFromStacktrace( offset ) {
-	try {
-		throw new Error();
-	} catch ( e ) {
-		return extractStacktrace( e, offset );
-	}
-}
-
-/**
- * Escape text for attribute or text content.
- */
-function escapeText( s ) {
-	if ( !s ) {
-		return "";
-	}
-	s = s + "";
-	// Both single quotes and double quotes (for attributes)
-	return s.replace( /['"<>&]/g, function( s ) {
-		switch( s ) {
-			case "'":
-				return "&#039;";
-			case "\"":
-				return "&quot;";
-			case "<":
-				return "&lt;";
-			case ">":
-				return "&gt;";
-			case "&":
-				return "&amp;";
-		}
-	});
-}
-
-function synchronize( callback, last ) {
-	config.queue.push( callback );
-
-	if ( config.autorun && !config.blocking ) {
-		process( last );
-	}
-}
-
-function process( last ) {
-	function next() {
-		process( last );
-	}
-	var start = new Date().getTime();
-	config.depth = config.depth ? config.depth + 1 : 1;
-
-	while ( config.queue.length && !config.blocking ) {
-		if ( !defined.setTimeout || config.updateRate <= 0 || ( ( new Date().getTime() - start ) < config.updateRate ) ) {
-			config.queue.shift()();
-		} else {
-			setTimeout( next, 13 );
-			break;
-		}
-	}
-	config.depth--;
-	if ( last && !config.blocking && !config.queue.length && config.depth === 0 ) {
-		done();
-	}
-}
-
-function saveGlobal() {
-	config.pollution = [];
-
-	if ( config.noglobals ) {
-		for ( var key in window ) {
-			if ( hasOwn.call( window, key ) ) {
-				// in Opera sometimes DOM element ids show up here, ignore them
-				if ( /^qunit-test-output/.test( key ) ) {
-					continue;
-				}
-				config.pollution.push( key );
-			}
-		}
-	}
-}
-
-function checkPollution() {
-	var newGlobals,
-		deletedGlobals,
-		old = config.pollution;
-
-	saveGlobal();
-
-	newGlobals = diff( config.pollution, old );
-	if ( newGlobals.length > 0 ) {
-		QUnit.pushFailure( "Introduced global variable(s): " + newGlobals.join(", ") );
-	}
-
-	deletedGlobals = diff( old, config.pollution );
-	if ( deletedGlobals.length > 0 ) {
-		QUnit.pushFailure( "Deleted global variable(s): " + deletedGlobals.join(", ") );
-	}
-}
-
-// returns a new Array with the elements that are in a but not in b
-function diff( a, b ) {
-	var i, j,
-		result = a.slice();
-
-	for ( i = 0; i < result.length; i++ ) {
-		for ( j = 0; j < b.length; j++ ) {
-			if ( result[i] === b[j] ) {
-				result.splice( i, 1 );
-				i--;
-				break;
-			}
-		}
-	}
-	return result;
-}
-
-function extend( a, b ) {
-	for ( var prop in b ) {
-		if ( hasOwn.call( b, prop ) ) {
-			// Avoid "Member not found" error in IE8 caused by messing with window.constructor
-			if ( !( prop === "constructor" && a === window ) ) {
-				if ( b[ prop ] === undefined ) {
-					delete a[ prop ];
-				} else {
-					a[ prop ] = b[ prop ];
-				}
-			}
-		}
-	}
-
-	return a;
-}
-
-/**
- * @param {HTMLElement} elem
- * @param {string} type
- * @param {Function} fn
- */
-function addEvent( elem, type, fn ) {
-	// Standards-based browsers
-	if ( elem.addEventListener ) {
-		elem.addEventListener( type, fn, false );
-	// IE
-	} else {
-		elem.attachEvent( "on" + type, fn );
-	}
-}
-
-/**
- * @param {Array|NodeList} elems
- * @param {string} type
- * @param {Function} fn
- */
-function addEvents( elems, type, fn ) {
-	var i = elems.length;
-	while ( i-- ) {
-		addEvent( elems[i], type, fn );
-	}
-}
-
-function hasClass( elem, name ) {
-	return (" " + elem.className + " ").indexOf(" " + name + " ") > -1;
-}
-
-function addClass( elem, name ) {
-	if ( !hasClass( elem, name ) ) {
-		elem.className += (elem.className ? " " : "") + name;
-	}
-}
-
-function removeClass( elem, name ) {
-	var set = " " + elem.className + " ";
-	// Class name may appear multiple times
-	while ( set.indexOf(" " + name + " ") > -1 ) {
-		set = set.replace(" " + name + " " , " ");
-	}
-	// If possible, trim it for prettiness, but not necessarily
-	elem.className = typeof set.trim === "function" ? set.trim() : set.replace(/^\s+|\s+$/g, "");
-}
-
-function id( name ) {
-	return !!( typeof document !== "undefined" && document && document.getElementById ) &&
-		document.getElementById( name );
-}
-
-function registerLoggingCallback( key ) {
-	return function( callback ) {
-		config[key].push( callback );
-	};
-}
-
-// Supports deprecated method of completely overwriting logging callbacks
-function runLoggingCallbacks( key, scope, args ) {
-	var i, callbacks;
-	if ( QUnit.hasOwnProperty( key ) ) {
-		QUnit[ key ].call(scope, args );
-	} else {
-		callbacks = config[ key ];
-		for ( i = 0; i < callbacks.length; i++ ) {
-			callbacks[ i ].call( scope, args );
-		}
-	}
-}
-
-// Test for equality any JavaScript type.
-// Author: Philippe Rathé <prathe@gmail.com>
-QUnit.equiv = (function() {
-
-	// Call the o related callback with the given arguments.
-	function bindCallbacks( o, callbacks, args ) {
-		var prop = QUnit.objectType( o );
-		if ( prop ) {
-			if ( QUnit.objectType( callbacks[ prop ] ) === "function" ) {
-				return callbacks[ prop ].apply( callbacks, args );
-			} else {
-				return callbacks[ prop ]; // or undefined
-			}
-		}
-	}
-
-	// the real equiv function
-	var innerEquiv,
-		// stack to decide between skip/abort functions
-		callers = [],
-		// stack to avoiding loops from circular referencing
-		parents = [],
-		parentsB = [],
-
-		getProto = Object.getPrototypeOf || function ( obj ) {
-			/*jshint camelcase:false */
-			return obj.__proto__;
-		},
-		callbacks = (function () {
-
-			// for string, boolean, number and null
-			function useStrictEquality( b, a ) {
-				/*jshint eqeqeq:false */
-				if ( b instanceof a.constructor || a instanceof b.constructor ) {
-					// to catch short annotation VS 'new' annotation of a
-					// declaration
-					// e.g. var i = 1;
-					// var j = new Number(1);
-					return a == b;
-				} else {
-					return a === b;
-				}
-			}
-
-			return {
-				"string": useStrictEquality,
-				"boolean": useStrictEquality,
-				"number": useStrictEquality,
-				"null": useStrictEquality,
-				"undefined": useStrictEquality,
-
-				"nan": function( b ) {
-					return isNaN( b );
-				},
-
-				"date": function( b, a ) {
-					return QUnit.objectType( b ) === "date" && a.valueOf() === b.valueOf();
-				},
-
-				"regexp": function( b, a ) {
-					return QUnit.objectType( b ) === "regexp" &&
-						// the regex itself
-						a.source === b.source &&
-						// and its modifiers
-						a.global === b.global &&
-						// (gmi) ...
-						a.ignoreCase === b.ignoreCase &&
-						a.multiline === b.multiline &&
-						a.sticky === b.sticky;
-				},
-
-				// - skip when the property is a method of an instance (OOP)
-				// - abort otherwise,
-				// initial === would have catch identical references anyway
-				"function": function() {
-					var caller = callers[callers.length - 1];
-					return caller !== Object && typeof caller !== "undefined";
-				},
-
-				"array": function( b, a ) {
-					var i, j, len, loop, aCircular, bCircular;
-
-					// b could be an object literal here
-					if ( QUnit.objectType( b ) !== "array" ) {
-						return false;
-					}
-
-					len = a.length;
-					if ( len !== b.length ) {
-						// safe and faster
-						return false;
-					}
-
-					// track reference to avoid circular references
-					parents.push( a );
-					parentsB.push( b );
-					for ( i = 0; i < len; i++ ) {
-						loop = false;
-						for ( j = 0; j < parents.length; j++ ) {
-							aCircular = parents[j] === a[i];
-							bCircular = parentsB[j] === b[i];
-							if ( aCircular || bCircular ) {
-								if ( a[i] === b[i] || aCircular && bCircular ) {
-									loop = true;
-								} else {
-									parents.pop();
-									parentsB.pop();
-									return false;
-								}
-							}
-						}
-						if ( !loop && !innerEquiv(a[i], b[i]) ) {
-							parents.pop();
-							parentsB.pop();
-							return false;
-						}
-					}
-					parents.pop();
-					parentsB.pop();
-					return true;
-				},
-
-				"object": function( b, a ) {
-					/*jshint forin:false */
-					var i, j, loop, aCircular, bCircular,
-						// Default to true
-						eq = true,
-						aProperties = [],
-						bProperties = [];
-
-					// comparing constructors is more strict than using
-					// instanceof
-					if ( a.constructor !== b.constructor ) {
-						// Allow objects with no prototype to be equivalent to
-						// objects with Object as their constructor.
-						if ( !(( getProto(a) === null && getProto(b) === Object.prototype ) ||
-							( getProto(b) === null && getProto(a) === Object.prototype ) ) ) {
-								return false;
-						}
-					}
-
-					// stack constructor before traversing properties
-					callers.push( a.constructor );
-
-					// track reference to avoid circular references
-					parents.push( a );
-					parentsB.push( b );
-
-					// be strict: don't ensure hasOwnProperty and go deep
-					for ( i in a ) {
-						loop = false;
-						for ( j = 0; j < parents.length; j++ ) {
-							aCircular = parents[j] === a[i];
-							bCircular = parentsB[j] === b[i];
-							if ( aCircular || bCircular ) {
-								if ( a[i] === b[i] || aCircular && bCircular ) {
-									loop = true;
-								} else {
-									eq = false;
-									break;
-								}
-							}
-						}
-						aProperties.push(i);
-						if ( !loop && !innerEquiv(a[i], b[i]) ) {
-							eq = false;
-							break;
-						}
-					}
-
-					parents.pop();
-					parentsB.pop();
-					callers.pop(); // unstack, we are done
-
-					for ( i in b ) {
-						bProperties.push( i ); // collect b's properties
-					}
-
-					// Ensures identical properties name
-					return eq && innerEquiv( aProperties.sort(), bProperties.sort() );
-				}
-			};
-		}());
-
-	innerEquiv = function() { // can take multiple arguments
-		var args = [].slice.apply( arguments );
-		if ( args.length < 2 ) {
-			return true; // end transition
-		}
-
-		return (function( a, b ) {
-			if ( a === b ) {
-				return true; // catch the most you can
-			} else if ( a === null || b === null || typeof a === "undefined" ||
-					typeof b === "undefined" ||
-					QUnit.objectType(a) !== QUnit.objectType(b) ) {
-				return false; // don't lose time with error prone cases
-			} else {
-				return bindCallbacks(a, callbacks, [ b, a ]);
-			}
-
-			// apply transition with (1..n) arguments
-		}( args[0], args[1] ) && innerEquiv.apply( this, args.splice(1, args.length - 1 )) );
-	};
-
-	return innerEquiv;
-}());
-
-/**
- * jsDump Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com |
- * http://flesler.blogspot.com Licensed under BSD
- * (http://www.opensource.org/licenses/bsd-license.php) Date: 5/15/2008
- *
- * @projectDescription Advanced and extensible data dumping for Javascript.
- * @version 1.0.0
- * @author Ariel Flesler
- * @link {http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html}
- */
-QUnit.jsDump = (function() {
-	function quote( str ) {
-		return "\"" + str.toString().replace( /"/g, "\\\"" ) + "\"";
-	}
-	function literal( o ) {
-		return o + "";
-	}
-	function join( pre, arr, post ) {
-		var s = jsDump.separator(),
-			base = jsDump.indent(),
-			inner = jsDump.indent(1);
-		if ( arr.join ) {
-			arr = arr.join( "," + s + inner );
-		}
-		if ( !arr ) {
-			return pre + post;
-		}
-		return [ pre, inner + arr, base + post ].join(s);
-	}
-	function array( arr, stack ) {
-		var i = arr.length, ret = new Array(i);
-		this.up();
-		while ( i-- ) {
-			ret[i] = this.parse( arr[i] , undefined , stack);
-		}
-		this.down();
-		return join( "[", ret, "]" );
-	}
-
-	var reName = /^function (\w+)/,
-		jsDump = {
-			// type is used mostly internally, you can fix a (custom)type in advance
-			parse: function( obj, type, stack ) {
-				stack = stack || [ ];
-				var inStack, res,
-					parser = this.parsers[ type || this.typeOf(obj) ];
-
-				type = typeof parser;
-				inStack = inArray( obj, stack );
-
-				if ( inStack !== -1 ) {
-					return "recursion(" + (inStack - stack.length) + ")";
-				}
-				if ( type === "function" )  {
-					stack.push( obj );
-					res = parser.call( this, obj, stack );
-					stack.pop();
-					return res;
-				}
-				return ( type === "string" ) ? parser : this.parsers.error;
-			},
-			typeOf: function( obj ) {
-				var type;
-				if ( obj === null ) {
-					type = "null";
-				} else if ( typeof obj === "undefined" ) {
-					type = "undefined";
-				} else if ( QUnit.is( "regexp", obj) ) {
-					type = "regexp";
-				} else if ( QUnit.is( "date", obj) ) {
-					type = "date";
-				} else if ( QUnit.is( "function", obj) ) {
-					type = "function";
-				} else if ( typeof obj.setInterval !== undefined && typeof obj.document !== "undefined" && typeof obj.nodeType === "undefined" ) {
-					type = "window";
-				} else if ( obj.nodeType === 9 ) {
-					type = "document";
-				} else if ( obj.nodeType ) {
-					type = "node";
-				} else if (
-					// native arrays
-					toString.call( obj ) === "[object Array]" ||
-					// NodeList objects
-					( typeof obj.length === "number" && typeof obj.item !== "undefined" && ( obj.length ? obj.item(0) === obj[0] : ( obj.item( 0 ) === null && typeof obj[0] === "undefined" ) ) )
-				) {
-					type = "array";
-				} else if ( obj.constructor === Error.prototype.constructor ) {
-					type = "error";
-				} else {
-					type = typeof obj;
-				}
-				return type;
-			},
-			separator: function() {
-				return this.multiline ?	this.HTML ? "<br />" : "\n" : this.HTML ? "&nbsp;" : " ";
-			},
-			// extra can be a number, shortcut for increasing-calling-decreasing
-			indent: function( extra ) {
-				if ( !this.multiline ) {
-					return "";
-				}
-				var chr = this.indentChar;
-				if ( this.HTML ) {
-					chr = chr.replace( /\t/g, "   " ).replace( / /g, "&nbsp;" );
-				}
-				return new Array( this.depth + ( extra || 0 ) ).join(chr);
-			},
-			up: function( a ) {
-				this.depth += a || 1;
-			},
-			down: function( a ) {
-				this.depth -= a || 1;
-			},
-			setParser: function( name, parser ) {
-				this.parsers[name] = parser;
-			},
-			// The next 3 are exposed so you can use them
-			quote: quote,
-			literal: literal,
-			join: join,
-			//
-			depth: 1,
-			// This is the list of parsers, to modify them, use jsDump.setParser
-			parsers: {
-				window: "[Window]",
-				document: "[Document]",
-				error: function(error) {
-					return "Error(\"" + error.message + "\")";
-				},
-				unknown: "[Unknown]",
-				"null": "null",
-				"undefined": "undefined",
-				"function": function( fn ) {
-					var ret = "function",
-						// functions never have name in IE
-						name = "name" in fn ? fn.name : (reName.exec(fn) || [])[1];
-
-					if ( name ) {
-						ret += " " + name;
-					}
-					ret += "( ";
-
-					ret = [ ret, QUnit.jsDump.parse( fn, "functionArgs" ), "){" ].join( "" );
-					return join( ret, QUnit.jsDump.parse(fn,"functionCode" ), "}" );
-				},
-				array: array,
-				nodelist: array,
-				"arguments": array,
-				object: function( map, stack ) {
-					/*jshint forin:false */
-					var ret = [ ], keys, key, val, i;
-					QUnit.jsDump.up();
-					keys = [];
-					for ( key in map ) {
-						keys.push( key );
-					}
-					keys.sort();
-					for ( i = 0; i < keys.length; i++ ) {
-						key = keys[ i ];
-						val = map[ key ];
-						ret.push( QUnit.jsDump.parse( key, "key" ) + ": " + QUnit.jsDump.parse( val, undefined, stack ) );
-					}
-					QUnit.jsDump.down();
-					return join( "{", ret, "}" );
-				},
-				node: function( node ) {
-					var len, i, val,
-						open = QUnit.jsDump.HTML ? "&lt;" : "<",
-						close = QUnit.jsDump.HTML ? "&gt;" : ">",
-						tag = node.nodeName.toLowerCase(),
-						ret = open + tag,
-						attrs = node.attributes;
-
-					if ( attrs ) {
-						for ( i = 0, len = attrs.length; i < len; i++ ) {
-							val = attrs[i].nodeValue;
-							// IE6 includes all attributes in .attributes, even ones not explicitly set.
-							// Those have values like undefined, null, 0, false, "" or "inherit".
-							if ( val && val !== "inherit" ) {
-								ret += " " + attrs[i].nodeName + "=" + QUnit.jsDump.parse( val, "attribute" );
-							}
-						}
-					}
-					ret += close;
-
-					// Show content of TextNode or CDATASection
-					if ( node.nodeType === 3 || node.nodeType === 4 ) {
-						ret += node.nodeValue;
-					}
-
-					return ret + open + "/" + tag + close;
-				},
-				// function calls it internally, it's the arguments part of the function
-				functionArgs: function( fn ) {
-					var args,
-						l = fn.length;
-
-					if ( !l ) {
-						return "";
-					}
-
-					args = new Array(l);
-					while ( l-- ) {
-						// 97 is 'a'
-						args[l] = String.fromCharCode(97+l);
-					}
-					return " " + args.join( ", " ) + " ";
-				},
-				// object calls it internally, the key part of an item in a map
-				key: quote,
-				// function calls it internally, it's the content of the function
-				functionCode: "[code]",
-				// node calls it internally, it's an html attribute value
-				attribute: quote,
-				string: quote,
-				date: quote,
-				regexp: literal,
-				number: literal,
-				"boolean": literal
-			},
-			// if true, entities are escaped ( <, >, \t, space and \n )
-			HTML: false,
-			// indentation unit
-			indentChar: "  ",
-			// if true, items in a collection, are separated by a \n, else just a space.
-			multiline: true
-		};
-
-	return jsDump;
-}());
-
-// from jquery.js
-function inArray( elem, array ) {
-	if ( array.indexOf ) {
-		return array.indexOf( elem );
-	}
-
-	for ( var i = 0, length = array.length; i < length; i++ ) {
-		if ( array[ i ] === elem ) {
-			return i;
-		}
-	}
-
-	return -1;
-}
-
-/*
- * Javascript Diff Algorithm
- *  By John Resig (http://ejohn.org/)
- *  Modified by Chu Alan "sprite"
- *
- * Released under the MIT license.
- *
- * More Info:
- *  http://ejohn.org/projects/javascript-diff-algorithm/
- *
- * Usage: QUnit.diff(expected, actual)
- *
- * QUnit.diff( "the quick brown fox jumped over", "the quick fox jumps over" ) == "the  quick <del>brown </del> fox <del>jumped </del><ins>jumps </ins> over"
- */
-QUnit.diff = (function() {
-	/*jshint eqeqeq:false, eqnull:true */
-	function diff( o, n ) {
-		var i,
-			ns = {},
-			os = {};
-
-		for ( i = 0; i < n.length; i++ ) {
-			if ( !hasOwn.call( ns, n[i] ) ) {
-				ns[ n[i] ] = {
-					rows: [],
-					o: null
-				};
-			}
-			ns[ n[i] ].rows.push( i );
-		}
-
-		for ( i = 0; i < o.length; i++ ) {
-			if ( !hasOwn.call( os, o[i] ) ) {
-				os[ o[i] ] = {
-					rows: [],
-					n: null
-				};
-			}
-			os[ o[i] ].rows.push( i );
-		}
-
-		for ( i in ns ) {
-			if ( hasOwn.call( ns, i ) ) {
-				if ( ns[i].rows.length === 1 && hasOwn.call( os, i ) && os[i].rows.length === 1 ) {
-					n[ ns[i].rows[0] ] = {
-						text: n[ ns[i].rows[0] ],
-						row: os[i].rows[0]
-					};
-					o[ os[i].rows[0] ] = {
-						text: o[ os[i].rows[0] ],
-						row: ns[i].rows[0]
-					};
-				}
-			}
-		}
-
-		for ( i = 0; i < n.length - 1; i++ ) {
-			if ( n[i].text != null && n[ i + 1 ].text == null && n[i].row + 1 < o.length && o[ n[i].row + 1 ].text == null &&
-						n[ i + 1 ] == o[ n[i].row + 1 ] ) {
-
-				n[ i + 1 ] = {
-					text: n[ i + 1 ],
-					row: n[i].row + 1
-				};
-				o[ n[i].row + 1 ] = {
-					text: o[ n[i].row + 1 ],
-					row: i + 1
-				};
-			}
-		}
-
-		for ( i = n.length - 1; i > 0; i-- ) {
-			if ( n[i].text != null && n[ i - 1 ].text == null && n[i].row > 0 && o[ n[i].row - 1 ].text == null &&
-						n[ i - 1 ] == o[ n[i].row - 1 ]) {
-
-				n[ i - 1 ] = {
-					text: n[ i - 1 ],
-					row: n[i].row - 1
-				};
-				o[ n[i].row - 1 ] = {
-					text: o[ n[i].row - 1 ],
-					row: i - 1
-				};
-			}
-		}
-
-		return {
-			o: o,
-			n: n
-		};
-	}
-
-	return function( o, n ) {
-		o = o.replace( /\s+$/, "" );
-		n = n.replace( /\s+$/, "" );
-
-		var i, pre,
-			str = "",
-			out = diff( o === "" ? [] : o.split(/\s+/), n === "" ? [] : n.split(/\s+/) ),
-			oSpace = o.match(/\s+/g),
-			nSpace = n.match(/\s+/g);
-
-		if ( oSpace == null ) {
-			oSpace = [ " " ];
-		}
-		else {
-			oSpace.push( " " );
-		}
-
-		if ( nSpace == null ) {
-			nSpace = [ " " ];
-		}
-		else {
-			nSpace.push( " " );
-		}
-
-		if ( out.n.length === 0 ) {
-			for ( i = 0; i < out.o.length; i++ ) {
-				str += "<del>" + out.o[i] + oSpace[i] + "</del>";
-			}
-		}
-		else {
-			if ( out.n[0].text == null ) {
-				for ( n = 0; n < out.o.length && out.o[n].text == null; n++ ) {
-					str += "<del>" + out.o[n] + oSpace[n] + "</del>";
-				}
-			}
-
-			for ( i = 0; i < out.n.length; i++ ) {
-				if (out.n[i].text == null) {
-					str += "<ins>" + out.n[i] + nSpace[i] + "</ins>";
-				}
-				else {
-					// `pre` initialized at top of scope
-					pre = "";
-
-					for ( n = out.n[i].row + 1; n < out.o.length && out.o[n].text == null; n++ ) {
-						pre += "<del>" + out.o[n] + oSpace[n] + "</del>";
-					}
-					str += " " + out.n[i].text + nSpace[i] + pre;
-				}
-			}
-		}
-
-		return str;
-	};
-}());
-
-// for CommonJS environments, export everything
-if ( typeof exports !== "undefined" ) {
-	extend( exports, QUnit.constructor.prototype );
-}
-
-// get at whatever the global object is, like window in browsers
-}( (function() {return this;}.call()) ));

lib/require/require.js

-/** vim: et:ts=4:sw=4:sts=4
- * @license RequireJS 2.1.8 Copyright (c) 2010-2012, The Dojo Foundation All Rights Reserved.
- * Available via the MIT or new BSD license.
- * see: http://github.com/jrburke/requirejs for details
- */
-//Not using strict: uneven strict support in browsers, #392, and causes
-//problems with requirejs.exec()/transpiler plugins that may not be strict.
-/*jslint regexp: true, nomen: true, sloppy: true */
-/*global window, navigator, document, importScripts, setTimeout, opera */
-
-var requirejs, require, define;
-(function (global) {
-    var req, s, head, baseElement, dataMain, src,
-        interactiveScript, currentlyAddingScript, mainScript, subPath,
-        version = '2.1.8',
-        commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,
-        cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
-        jsSuffixRegExp = /\.js$/,
-        currDirRegExp = /^\.\//,
-        op = Object.prototype,
-        ostring = op.toString,
-        hasOwn = op.hasOwnProperty,
-        ap = Array.prototype,
-        apsp = ap.splice,
-        isBrowser = !!(typeof window !== 'undefined' && navigator && window.document),
-        isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
-        //PS3 indicates loaded and complete, but need to wait for complete
-        //specifically. Sequence is 'loading', 'loaded', execution,
-        // then 'complete'. The UA check is unfortunate, but not sure how
-        //to feature test w/o causing perf issues.
-        readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
-                      /^complete$/ : /^(complete|loaded)$/,
-        defContextName = '_',
-        //Oh the tragedy, detecting opera. See the usage of isOpera for reason.
-        isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
-        contexts = {},
-        cfg = {},
-        globalDefQueue = [],
-        useInteractive = false;
-
-    function isFunction(it) {
-        return ostring.call(it) === '[object Function]';
-    }
-
-    function isArray(it) {
-        return ostring.call(it) === '[object Array]';
-    }
-
-    /**
-     * Helper function for iterating over an array. If the func returns
-     * a true value, it will break out of the loop.
-     */
-    function each(ary, func) {
-        if (ary) {
-            var i;
-            for (i = 0; i < ary.length; i += 1) {
-                if (ary[i] && func(ary[i], i, ary)) {
-                    break;
-                }
-            }
-        }
-    }
-
-    /**
-     * Helper function for iterating over an array backwards. If the func
-     * returns a true value, it will break out of the loop.
-     */
-    function eachReverse(ary, func) {
-        if (ary) {
-            var i;
-            for (i = ary.length - 1; i > -1; i -= 1) {
-                if (ary[i] && func(ary[i], i, ary)) {
-                    break;
-                }
-            }
-        }
-    }
-
-    function hasProp(obj, prop) {
-        return hasOwn.call(obj, prop);
-    }
-
-    function getOwn(obj, prop) {
-        return hasProp(obj, prop) && obj[prop];
-    }
-
-    /**
-     * Cycles over properties in an object and calls a function for each
-     * property value. If the function returns a truthy value, then the
-     * iteration is stopped.
-     */
-    function eachProp(obj, func) {
-        var prop;
-        for (prop in obj) {
-            if (hasProp(obj, prop)) {
-                if (func(obj[prop], prop)) {
-                    break;
-                }
-            }
-        }
-    }
-
-    /**
-     * Simple function to mix in properties from source into target,
-     * but only if target does not already have a property of the same name.
-     */
-    function mixin(target, source, force, deepStringMixin) {
-        if (source) {
-            eachProp(source, function (value, prop) {
-                if (force || !hasProp(target, prop)) {
-                    if (deepStringMixin && typeof value !== 'string') {
-                        if (!target[prop]) {
-                            target[prop] = {};
-                        }
-                        mixin(target[prop], value, force, deepStringMixin);
-                    } else {
-                        target[prop] = value;
-                    }
-                }
-            });
-        }
-        return target;
-    }
-
-    //Similar to Function.prototype.bind, but the 'this' object is specified
-    //first, since it is easier to read/figure out what 'this' will be.
-    function bind(obj, fn) {
-        return function () {
-            return fn.apply(obj, arguments);
-        };
-    }
-
-    function scripts() {
-        return document.getElementsByTagName('script');
-    }
-
-    function defaultOnError(err) {
-        throw err;
-    }
-
-    //Allow getting a global that expressed in
-    //dot notation, like 'a.b.c'.
-    function getGlobal(value) {
-        if (!value) {
-            return value;
-        }
-        var g = global;
-        each(value.split('.'), function (part) {
-            g = g[part];
-        });
-        return g;
-    }
-
-    /**
-     * Constructs an error with a pointer to an URL with more information.
-     * @param {String} id the error ID that maps to an ID on a web page.
-     * @param {String} message human readable error.
-     * @param {Error} [err] the original error, if there is one.
-     *
-     * @returns {Error}
-     */
-    function makeError(id, msg, err, requireModules) {
-        var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
-        e.requireType = id;
-        e.requireModules = requireModules;
-        if (err) {
-            e.originalError = err;
-        }
-        return e;
-    }
-
-    if (typeof define !== 'undefined') {
-        //If a define is already in play via another AMD loader,
-        //do not overwrite.
-        return;
-    }
-
-    if (typeof requirejs !== 'undefined') {
-        if (isFunction(requirejs)) {
-            //Do not overwrite and existing requirejs instance.
-            return;
-        }
-        cfg = requirejs;
-        requirejs = undefined;
-    }
-
-    //Allow for a require config object
-    if (typeof require !== 'undefined' && !isFunction(require)) {
-        //assume it is a config object.
-        cfg = require;
-        require = undefined;
-    }
-
-    function newContext(contextName) {
-        var inCheckLoaded, Module, context, handlers,
-            checkLoadedTimeoutId,
-            config = {
-                //Defaults. Do not set a default for map
-                //config to speed up normalize(), which
-                //will run faster if there is no default.
-                waitSeconds: 7,
-                baseUrl: './',
-                paths: {},
-                pkgs: {},
-                shim: {},
-                config: {}
-            },
-            registry = {},
-            //registry of just enabled modules, to speed
-            //cycle breaking code when lots of modules
-            //are registered, but not activated.
-            enabledRegistry = {},
-            undefEvents = {},
-            defQueue = [],
-            defined = {},
-            urlFetched = {},
-            requireCounter = 1,
-            unnormalizedCounter = 1;
-
-        /**
-         * Trims the . and .. from an array of path segments.
-         * It will keep a leading path segment if a .. will become
-         * the first path segment, to help with module name lookups,
-         * which act like paths, but can be remapped. But the end result,
-         * all paths that use this function should look normalized.
-         * NOTE: this method MODIFIES the input array.
-         * @param {Array} ary the array of path segments.
-         */
-        function trimDots(ary) {
-            var i, part;
-            for (i = 0; ary[i]; i += 1) {
-                part = ary[i];
-                if (part === '.') {
-                    ary.splice(i, 1);
-                    i -= 1;
-                } else if (part === '..') {
-                    if (i === 1 && (ary[2] === '..' || ary[0] === '..')) {
-                        //End of the line. Keep at least one non-dot
-                        //path segment at the front so it can be mapped
-                        //correctly to disk. Otherwise, there is likely
-                        //no path mapping for a path starting with '..'.
-                        //This can still fail, but catches the most reasonable
-                        //uses of ..
-                        break;
-                    } else if (i > 0) {
-                        ary.splice(i - 1, 2);
-                        i -= 2;
-                    }
-                }
-            }
-        }
-
-        /**
-         * Given a relative module name, like ./something, normalize it to
-         * a real name that can be mapped to a path.
-         * @param {String} name the relative name
-         * @param {String} baseName a real name that the name arg is relative
-         * to.
-         * @param {Boolean} applyMap apply the map config to the value. Should
-         * only be done if this normalization is for a dependency ID.
-         * @returns {String} normalized name
-         */
-        function normalize(name, baseName, applyMap) {
-            var pkgName, pkgConfig, mapValue, nameParts, i, j, nameSegment,
-                foundMap, foundI, foundStarMap, starI,
-                baseParts = baseName && baseName.split('/'),
-                normalizedBaseParts = baseParts,
-                map = config.map,
-                starMap = map && map['*'];
-
-            //Adjust any relative paths.
-            if (name && name.charAt(0) === '.') {
-                //If have a base name, try to normalize against it,
-                //otherwise, assume it is a top-level require that will
-                //be relative to baseUrl in the end.
-                if (baseName) {
-                    if (getOwn(config.pkgs, baseName)) {
-                        //If the baseName is a package name, then just treat it as one
-                        //name to concat the name with.
-                        normalizedBaseParts = baseParts = [baseName];
-                    } else {
-                        //Convert baseName to array, and lop off the last part,
-                        //so that . matches that 'directory' and not name of the baseName's
-                        //module. For instance, baseName of 'one/two/three', maps to
-                        //'one/two/three.js', but we want the directory, 'one/two' for
-                        //this normalization.
-                        normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
-                    }
-
-                    name = normalizedBaseParts.concat(name.split('/'));
-                    trimDots(name);
-
-                    //Some use of packages may use a . path to reference the
-                    //'main' module name, so normalize for that.
-                    pkgConfig = getOwn(config.pkgs, (pkgName = name[0]));
-                    name = name.join('/');
-                    if (pkgConfig && name === pkgName + '/' + pkgConfig.main) {
-                        name = pkgName;
-                    }
-                } else if (name.indexOf('./') === 0) {
-                    // No baseName, so this is ID is resolved relative
-                    // to baseUrl, pull off the leading dot.
-                    name = name.substring(2);
-                }
-            }
-
-            //Apply map config if available.
-            if (applyMap && map && (baseParts || starMap)) {
-                nameParts = name.split('/');
-
-                for (i = nameParts.length; i > 0; i -= 1) {
-                    nameSegment = nameParts.slice(0, i).join('/');
-
-                    if (baseParts) {
-                        //Find the longest baseName segment match in the config.
-                        //So, do joins on the biggest to smallest lengths of baseParts.
-                        for (j = baseParts.length; j > 0; j -= 1) {
-                            mapValue = getOwn(map, baseParts.slice(0, j).join('/'));
-
-                            //baseName segment has config, find if it has one for
-                            //this name.
-                            if (mapValue) {
-                                mapValue = getOwn(mapValue, nameSegment);
-                                if (mapValue) {
-                                    //Match, update name to the new value.
-                                    foundMap = mapValue;
-                                    foundI = i;
-                                    break;
-                                }
-                            }
-                        }
-                    }
-
-                    if (foundMap) {
-                        break;
-                    }
-
-                    //Check for a star map match, but just hold on to it,
-                    //if there is a shorter segment match later in a matching
-                    //config, then favor over this star map.
-                    if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
-                        foundStarMap = getOwn(starMap, nameSegment);
-                        starI = i;
-                    }
-                }
-
-                if (!foundMap && foundStarMap) {
-                    foundMap = foundStarMap;
-                    foundI = starI;
-                }
-
-                if (foundMap) {
-                    nameParts.splice(0, foundI, foundMap);
-                    name = nameParts.join('/');
-                }
-            }
-
-            return name;
-        }
-
-        function removeScript(name) {
-            if (isBrowser) {
-                each(scripts(), function (scriptNode) {
-                    if (scriptNode.getAttribute('data-requiremodule') === name &&
-                            scriptNode.getAttribute('data-requirecontext') === context.contextName) {
-                        scriptNode.parentNode.removeChild(scriptNode);
-                        return true;
-                    }
-                });
-            }
-        }
-
-        function hasPathFallback(id) {
-            var pathConfig = getOwn(config.paths, id);
-            if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
-                removeScript(id);
-                //Pop off the first array value, since it failed, and
-                //retry
-                pathConfig.shift();
-                context.require.undef(id);
-                context.require([id]);
-                return true;
-            }
-        }
-
-        //Turns a plugin!resource to [plugin, resource]
-        //with the plugin being undefined if the name
-        //did not have a plugin prefix.
-        function splitPrefix(name) {
-            var prefix,
-                index = name ? name.indexOf('!') : -1;
-            if (index > -1) {
-                prefix = name.substring(0, index);
-                name = name.substring(index + 1, name.length);
-            }
-            return [prefix, name];
-        }
-
-        /**
-         * Creates a module mapping that includes plugin prefix, module
-         * name, and path. If parentModuleMap is provided it will
-         * also normalize the name via require.normalize()
-         *
-         * @param {String} name the module name
-         * @param {String} [parentModuleMap] parent module map
-         * for the module name, used to resolve relative names.
-         * @param {Boolean} isNormalized: is the ID already normalized.
-         * This is true if this call is done for a define() module ID.
-         * @param {Boolean} applyMap: apply the map config to the ID.
-         * Should only be true if this map is for a dependency.
-         *
-         * @returns {Object}
-         */
-        function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
-            var url, pluginModule, suffix, nameParts,
-                prefix = null,
-                parentName = parentModuleMap ? parentModuleMap.name : null,
-                originalName = name,
-                isDefine = true,
-                normalizedName = '';
-
-            //If no name, then it means it is a require call, generate an
-            //internal name.
-            if (!name) {
-                isDefine = false;
-                name = '_@r' + (requireCounter += 1);
-            }
-
-            nameParts = splitPrefix(name);
-            prefix = nameParts[0];
-            name = nameParts[1];
-
-            if (prefix) {
-                prefix = normalize(prefix, parentName, applyMap);
-                pluginModule = getOwn(defined, prefix);
-            }
-
-            //Account for relative paths if there is a base name.
-            if (name) {
-                if (prefix) {
-                    if (pluginModule && pluginModule.normalize) {
-                        //Plugin is loaded, use its normalize method.
-                        normalizedName = pluginModule.normalize(name, function (name) {
-                            return normalize(name, parentName, applyMap);
-                        });
-                    } else {
-                        normalizedName = normalize(name, parentName, applyMap);
-                    }
-                } else {
-                    //A regular module.
-                    normalizedName = normalize(name, parentName, applyMap);
-
-                    //Normalized name may be a plugin ID due to map config
-                    //application in normalize. The map config values must
-                    //already be normalized, so do not need to redo that part.
-                    nameParts = splitPrefix(normalizedName);
-                    prefix = nameParts[0];
-                    normalizedName = nameParts[1];
-                    isNormalized = true;
-
-                    url = context.nameToUrl(normalizedName);
-                }
-            }
-
-            //If the id is a plugin id that cannot be determined if it needs
-            //normalization, stamp it with a unique ID so two matching relative
-            //ids that may conflict can be separate.
-            suffix = prefix && !pluginModule && !isNormalized ?
-                     '_unnormalized' + (unnormalizedCounter += 1) :
-                     '';
-
-            return {
-                prefix: prefix,
-                name: normalizedName,
-                parentMap: parentModuleMap,
-                unnormalized: !!suffix,
-                url: url,
-                originalName: originalName,
-                isDefine: isDefine,
-                id: (prefix ?
-                        prefix + '!' + normalizedName :
-                        normalizedName) + suffix
-            };
-        }
-
-        function getModule(depMap) {
-            var id = depMap.id,
-                mod = getOwn(registry, id);
-
-            if (!mod) {
-                mod = registry[id] = new context.Module(depMap);
-            }
-
-            return mod;
-        }
-
-        function on(depMap, name, fn) {
-            var id = depMap.id,
-                mod = getOwn(registry, id);
-
-            if (hasProp(defined, id) &&
-                    (!mod || mod.defineEmitComplete)) {
-                if (name === 'defined') {
-                    fn(defined[id]);
-                }
-            } else {
-                mod = getModule(depMap);
-                if (mod.error && name === 'error') {
-                    fn(mod.error);
-                } else {
-                    mod.on(name, fn);
-                }
-            }
-        }
-
-        function onError(err, errback) {
-            var ids = err.requireModules,
-                notified = false;
-
-            if (errback) {
-                errback(err);
-            } else {
-                each(ids, function (id) {
-                    var mod = getOwn(registry, id);
-                    if (mod) {
-                        //Set error on module, so it skips timeout checks.
-                        mod.error = err;
-                        if (mod.events.error) {
-                            notified = true;
-                            mod.emit('error', err);
-                        }
-                    }
-                });
-
-                if (!notified) {
-                    req.onError(err);
-                }
-            }
-        }
-
-        /**
-         * Internal method to transfer globalQueue items to this context's
-         * defQueue.
-         */
-        function takeGlobalQueue() {
-            //Push all the globalDefQueue items into the context's defQueue
-            if (globalDefQueue.length) {
-                //Array splice in the values since the context code has a
-                //local var ref to defQueue, so cannot just reassign the one
-                //on context.
-                apsp.apply(defQueue,
-                           [defQueue.length - 1, 0].concat(globalDefQueue));
-                globalDefQueue = [];
-            }
-        }
-
-        handlers = {
-            'require': function (mod) {
-                if (mod.require) {
-                    return mod.require;
-                } else {
-                    return (mod.require = context.makeRequire(mod.map));
-                }
-            },
-            'exports': function (mod) {
-                mod.usingExports = true;
-                if (mod.map.isDefine) {
-                    if (mod.exports) {
-                        return mod.exports;
-                    } else {
-                        return (mod.exports = defined[mod.map.id] = {});
-                    }
-                }
-            },
-            'module': function (mod) {
-                if (mod.module) {
-                    return mod.module;
-                } else {
-                    return (mod.module = {
-                        id: mod.map.id,
-                        uri: mod.map.url,
-                        config: function () {
-                            var c,
-                                pkg = getOwn(config.pkgs, mod.map.id);
-                            // For packages, only support config targeted
-                            // at the main module.
-                            c = pkg ? getOwn(config.config, mod.map.id + '/' + pkg.main) :
-                                      getOwn(config.config, mod.map.id);
-                            return  c || {};
-                        },
-                        exports: defined[mod.map.id]
-                    });
-                }
-            }
-        };
-
-        function cleanRegistry(id) {
-            //Clean up machinery used for waiting modules.
-            delete registry[id];
-            delete enabledRegistry[id];
-        }
-
-        function breakCycle(mod, traced, processed) {
-            var id = mod.map.id;
-
-            if (mod.error) {
-                mod.emit('error', mod.error);
-            } else {
-                traced[id] = true;
-                each(mod.depMaps, function (depMap, i) {
-                    var depId = depMap.id,
-                        dep = getOwn(registry, depId);
-
-                    //Only force things that have not completed
-                    //being defined, so still in the registry,
-                    //and only if it has not been matched up
-                    //in the module already.
-                    if (dep && !mod.depMatched[i] && !processed[depId]) {
-                        if (getOwn(traced, depId)) {
-                            mod.defineDep(i, defined[depId]);
-                            mod.check(); //pass false?
-                        } else {
-                            breakCycle(dep, traced, processed);
-                        }
-                    }
-                });
-                processed[id] = true;
-            }
-        }
-
-        function checkLoaded() {
-            var map, modId, err, usingPathFallback,
-                waitInterval = config.waitSeconds * 1000,
-                //It is possible to disable the wait interval by using waitSeconds of 0.
-                expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
-                noLoads = [],
-                reqCalls = [],
-                stillLoading = false,
-                needCycleCheck = true;
-
-            //Do not bother if this call was a result of a cycle break.
-            if (inCheckLoaded) {
-                return;
-            }
-
-            inCheckLoaded = true;
-
-            //Figure out the state of all the modules.
-            eachProp(enabledRegistry, function (mod) {
-                map = mod.map;
-                modId = map.id;
-
-                //Skip things that are not enabled or in error state.
-                if (!mod.enabled) {
-                    return;
-                }
-
-                if (!map.isDefine) {
-                    reqCalls.push(mod);
-                }
-
-                if (!mod.error) {
-                    //If the module should be executed, and it has not
-                    //been inited and time is up, remember it.
-                    if (!mod.inited && expired) {
-                        if (hasPathFallback(modId)) {
-                            usingPathFallback = true;
-                            stillLoading = true;
-                        } else {
-                            noLoads.push(modId);
-                            removeScript(modId);
-                        }
-                    } else if (!mod.inited && mod.fetched && map.isDefine) {
-                        stillLoading = true;
-                        if (!map.prefix) {
-                            //No reason to keep looking for unfinished
-                            //loading. If the only stillLoading is a
-                            //plugin resource though, keep going,
-                            //because it may be that a plugin resource
-                            //is waiting on a non-plugin cycle.
-                            return (needCycleCheck = false);
-                        }
-                    }
-                }
-            });
-
-            if (expired && noLoads.length) {
-                //If wait time expired, throw error of unloaded modules.
-                err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
-                err.contextName = context.contextName;
-                return onError(err);
-            }
-
-            //Not expired, check for a cycle.
-            if (needCycleCheck) {
-                each(reqCalls, function (mod) {
-                    breakCycle(mod, {}, {});
-                });
-            }
-
-            //If still waiting on loads, and the waiting load is something
-            //other than a plugin resource, or there are still outstanding
-            //scripts, then just try back later.
-            if ((!expired || usingPathFallback) && stillLoading) {
-                //Something is still waiting to load. Wait for it, but only
-                //if a timeout is not already in effect.
-                if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
-                    checkLoadedTimeoutId = setTimeout(function () {
-                        checkLoadedTimeoutId = 0;
-                        checkLoaded();
-                    }, 50);
-                }
-            }
-
-            inCheckLoaded = false;
-        }
-
-        Module = function (map) {
-            this.events = getOwn(undefEvents, map.id) || {};
-            this.map = map;
-            this.shim = getOwn(config.shim, map.id);
-            this.depExports = [];
-            this.depMaps = [];
-            this.depMatched = [];
-            this.pluginMaps = {};
-            this.depCount = 0;
-
-            /* this.exports this.factory
-               this.depMaps = [],
-               this.enabled, this.fetched
-            */
-        };
-
-        Module.prototype = {
-            init: function (depMaps, factory, errback, options) {
-                options = options || {};
-
-                //Do not do more inits if already done. Can happen if there
-                //are multiple define calls for the same module. That is not
-                //a normal, common case, but it is also not unexpected.
-                if (this.inited) {
-                    return;
-                }
-
-                this.factory = factory;
-
-                if (errback) {
-                    //Register for errors on this module.
-                    this.on('error', errback);
-                } else if (this.events.error) {
-                    //If no errback already, but there are error listeners
-                    //on this module, set up an errback to pass to the deps.
-                    errback = bind(this, function (err) {
-                        this.emit('error', err);
-                    });
-                }
-
-                //Do a copy of the dependency array, so that
-                //source inputs are not modified. For example
-                //"shim" deps are passed in here directly, and
-                //doing a direct modification of the depMaps array
-                //would affect that config.
-                this.depMaps = depMaps && depMaps.slice(0);
-
-                this.errback = errback;
-
-                //Indicate this module has be initialized
-                this.inited = true;
-
-                this.ignore = options.ignore;
-
-                //Could have option to init this module in enabled mode,
-                //or could have been previously marked as enabled. However,
-                //the dependencies are not known until init is called. So
-                //if enabled previously, now trigger dependencies as enabled.
-                if (options.enabled || this.enabled) {
-                    //Enable this module and dependencies.
-                    //Will call this.check()
-                    this.enable();
-                } else {
-                    this.check();
-                }
-            },
-
-            defineDep: function (i, depExports) {
-                //Because of cycles, defined callback for a given
-                //export can be called more than once.
-                if (!this.depMatched[i]) {
-                    this.depMatched[i] = true;
-                    this.depCount -= 1;
-                    this.depExports[i] = depExports;
-                }
-            },
-
-            fetch: function () {
-                if (this.fetched) {
-                    return;
-                }
-                this.fetched = true;
-
-                context.startTime = (new Date()).getTime();
-
-                var map = this.map;
-
-                //If the manager is for a plugin managed resource,
-                //ask the plugin to load it now.
-                if (this.shim) {
-                    context.makeRequire(this.map, {
-                        enableBuildCallback: true
-                    })(this.shim.deps || [], bind(this, function () {
-                        return map.prefix ? this.callPlugin() : this.load();
-                    }));
-                } else {
-                    //Regular dependency.
-                    return map.prefix ? this.callPlugin() : this.load();
-                }
-            },
-
-            load: function () {
-                var url = this.map.url;
-
-                //Regular dependency.
-                if (!urlFetched[url]) {
-                    urlFetched[url] = true;
-                    context.load(this.map.id, url);
-                }
-            },
-
-            /**
-             * Checks if the module is ready to define itself, and if so,
-             * define it.
-             */
-            check: function () {
-                if (!this.enabled || this.enabling) {
-                    return;
-                }
-
-                var err, cjsModule,
-                    id = this.map.id,
-                    depExports = this.depExports,
-                    exports = this.exports,
-                    factory = this.factory;
-
-                if (!this.inited) {
-                    this.fetch();
-                } else if (this.error) {
-                    this.emit('error', this.error);
-                } else if (!this.defining) {
-                    //The factory could trigger another require call
-                    //that would result in checking this module to
-                    //define itself again. If already in the process
-                    //of doing that, skip this work.
-                    this.defining = true;
-
-                    if (this.depCount < 1 && !this.defined) {
-                        if (isFunction(factory)) {
-                            //If there is an error listener, favor passing
-                            //to that instead of throwing an error. However,
-                            //only do it for define()'d  modules. require
-                            //errbacks should not be called for failures in
-                            //their callbacks (#699). However if a global
-                            //onError is set, use that.
-                            if ((this.events.error && this.map.isDefine) ||
-                                req.onError !== defaultOnError) {
-                                try {
-                                    exports = context.execCb(id, factory, depExports, exports);
-                                } catch (e) {
-                                    err = e;
-                                }
-                            } else {
-                                exports = context.execCb(id, factory, depExports, exports);
-                            }
-
-                            if (this.map.isDefine) {
-                                //If setting exports via 'module' is in play,
-                                //favor that over return value and exports. After that,
-                                //favor a non-undefined return value over exports use.
-                                cjsModule = this.module;
-                                if (cjsModule &&
-                                        cjsModule.exports !== undefined &&
-                                        //Make sure it is not already the exports value
-                                        cjsModule.exports !== this.exports) {
-                                    exports = cjsModule.exports;
-                                } else if (exports === undefined && this.usingExports) {
-                                    //exports already set the defined value.
-                                    exports = this.exports;
-                                }
-                            }
-
-                            if (err) {
-                                err.requireMap = this.map;
-                                err.requireModules = this.map.isDefine ? [this.map.id] : null;
-                                err.requireType = this.map.isDefine ? 'define' : 'require';
-                                return onError((this.error = err));
-                            }
-
-                        } else {
-                            //Just a literal value
-                            exports = factory;
-                        }
-
-                        this.exports = exports;
-
-                        if (this.map.isDefine && !this.ignore) {
-                            defined[id] = exports;
-
-                            if (req.onResourceLoad) {
-                                req.onResourceLoad(context, this.map, this.depMaps);
-                            }
-                        }
-
-                        //Clean up
-                        cleanRegistry(id);
-
-                        this.defined = true;
-                    }
-
-                    //Finished the define stage. Allow calling check again
-                    //to allow define notifications below in the case of a
-                    //cycle.
-                    this.defining = false;
-
-                    if (this.defined && !this.defineEmitted) {
-                        this.defineEmitted = true;
-                        this.emit('defined', this.exports);
-                        this.defineEmitComplete = true;
-                    }
-
-                }
-            },
-
-            callPlugin: function () {
-                var map = this.map,
-                    id = map.id,
-                    //Map already normalized the prefix.
-                    pluginMap = makeModuleMap(map.prefix);
-
-                //Mark this as a dependency for this plugin, so it
-                //can be traced for cycles.
-                this.depMaps.push(pluginMap);
-
-                on(pluginMap, 'defined', bind(this, function (plugin) {
-                    var load, normalizedMap, normalizedMod,
-                        name = this.map.name,
-                        parentName = this.map.parentMap ? this.map.parentMap.name : null,
-                        localRequire = context.makeRequire(map.parentMap, {
-                            enableBuildCallback: true
-                        });
-
-                    //If current map is not normalized, wait for that
-                    //normalized name to load instead of continuing.
-                    if (this.map.unnormalized) {
-                        //Normalize the ID if the plugin allows it.
-                        if (plugin.normalize) {
-                            name = plugin.normalize(name, function (name) {
-                                return normalize(name, parentName, true);
-                            }) || '';
-                        }
-
-                        //prefix and name should already be normalized, no need
-                        //for applying map config again either.
-                        normalizedMap = makeModuleMap(map.prefix + '!' + name,
-                                                      this.map.parentMap);
-                        on(normalizedMap,
-                            'defined', bind(this, function (value) {
-                                this.init([], function () { return value; }, null, {
-                                    enabled: true,
-                                    ignore: true
-                                });
-                            }));
-
-                        normalizedMod = getOwn(registry, normalizedMap.id);
-                        if (normalizedMod) {
-                            //Mark this as a dependency for this plugin, so it
-                            //can be traced for cycles.
-                            this.depMaps.push(normalizedMap);
-
-                            if (this.events.error) {
-                                normalizedMod.on('error', bind(this, function (err) {
-                                    this.emit('error', err);
-                                }));
-                            }
-                            normalizedMod.enable();
-                        }
-
-                        return;
-                    }
-
-                    load = bind(this, function (value) {
-                        this.init([], function () { return value; }, null, {
-                            enabled: true
-                        });
-                    });
-
-                    load.error = bind(this, function (err) {
-                        this.inited = true;
-                        this.error = err;
-                        err.requireModules = [id];
-
-                        //Remove temp unnormalized modules for this module,
-                        //since they will never be resolved otherwise now.
-                        eachProp(registry, function (mod) {
-                            if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
-                                cleanRegistry(mod.map.id);
-                            }
-                        });
-
-                        onError(err);
-                    });
-
-                    //Allow plugins to load other code without having to know the
-                    //context or how to 'complete' the load.
-                    load.fromText = bind(this, function (text, textAlt) {
-                        /*jslint evil: true */
-                        var moduleName = map.name,
-                            moduleMap = makeModuleMap(moduleName),
-                            hasInteractive = useInteractive;
-
-                        //As of 2.1.0, support just passing the text, to reinforce
-                        //fromText only being called once per resource. Still
-                        //support old style of passing moduleName but discard
-                        //that moduleName in favor of the internal ref.
-                        if (textAlt) {
-                            text = textAlt;
-                        }
-
-                        //Turn off interactive script matching for IE for any define
-                        //calls in the text, then turn it back on at the end.
-                        if (hasInteractive) {
-                            useInteractive = false;
-                        }
-
-                        //Prime the system by creating a module instance for
-                        //it.
-                        getModule(moduleMap);
-
-                        //Transfer any config to this other module.
-                        if (hasProp(config.config, id)) {
-                            config.config[moduleName] = config.config[id];
-                        }
-
-                        try {
-                            req.exec(text);
-                        } catch (e) {
-                            return onError(makeError('fromtexteval',
-                                             'fromText eval for ' + id +
-                                            ' failed: ' + e,
-                                             e,
-                                             [id]));
-                        }
-
-                        if (hasInteractive) {
-                            useInteractive = true;
-                        }
-
-                        //Mark this as a dependency for the plugin
-                        //resource
-                        this.depMaps.push(moduleMap);
-
-                        //Support anonymous modules.
-                        context.completeLoad(moduleName);
-
-                        //Bind the value of that module to the value for this
-                        //resource ID.
-                        localRequire([moduleName], load);
-                    });
-
-                    //Use parentName here since the plugin's name is not reliable,
-                    //could be some weird string with no path that actually wants to
-                    //reference the parentName's path.
-                    plugin.load(map.name, localRequire, load, config);
-                }));
-
-                context.enable(pluginMap, this);
-                this.pluginMaps[pluginMap.id] = pluginMap;
-            },
-
-            enable: function () {
-                enabledRegistry[this.map.id] = this;
-                this.enabled = true;
-
-                //Set flag mentioning that the module is enabling,
-                //so that immediate calls to the defined callbacks
-                //for dependencies do not trigger inadvertent load
-                //with the depCount still being zero.
-                this.enabling = true;
-
-                //Enable each dependency
-                each(this.depMaps, bind(this, function (depMap, i) {
-                    var id, mod, handler;
-
-                    if (typeof depMap === 'string') {
-                        //Dependency needs to be converted to a depMap
-                        //and wired up to this module.
-                        depMap = makeModuleMap(depMap,
-                                               (this.map.isDefine ? this.map : this.map.parentMap),
-                                               false,
-                                               !this.skipMap);
-                        this.depMaps[i] = depMap;
-
-                        handler = getOwn(handlers, depMap.id);
-
-                        if (handler) {
-                            this.depExports[i] = handler(this);
-                            return;
-                        }
-
-                        this.depCount += 1;
-
-                        on(depMap, 'defined', bind(this, function (depExports) {
-                            this.defineDep(i, depExports);
-                            this.check();
-                        }));
-
-                        if (this.errback) {
-                            on(depMap, 'error', bind(this, this.errback));
-                        }
-                    }
-
-                    id = depMap.id;
-                    mod = registry[id];
-
-                    //Skip special modules like 'require', 'exports', 'module'
-                    //Also, don't call enable if it is already enabled,
-                    //important in circular dependency cases.
-                    if (!hasProp(handlers, id) && mod && !mod.enabled) {
-                        context.enable(depMap, this);
-                    }
-                }));
-
-                //Enable each plugin that is used in
-                //a dependency
-                eachProp(this.pluginMaps, bind(this, function (pluginMap) {
-                    var mod = getOwn(registry, pluginMap.id);
-                    if (mod && !mod.enabled) {
-                        context.enable(pluginMap, this);
-                    }
-                }));
-
-                this.enabling = false;
-
-                this.check();
-            },
-
-            on: function (name, cb) {
-                var cbs = this.events[name];
-                if (!cbs) {
-                    cbs = this.events[name] = [];
-                }
-                cbs.push(cb);
-            },
-
-            emit: function (name, evt) {
-                each(this.events[name], function (cb) {
-                    cb(evt);
-                });
-                if (name === 'error') {
-                    //Now that the error handler was triggered, remove
-                    //the listeners, since this broken Module instance
-                    //can stay around for a while in the registry.
-                    delete this.events[name];
-                }
-            }
-        };
-
-        function callGetModule(args) {
-            //Skip modules already defined.
-            if (!hasProp(defined, args[0])) {
-                getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
-            }
-        }
-
-        function removeListener(node, func, name, ieName) {
-            //Favor detachEvent because of IE9
-            //issue, see attachEvent/addEventListener comment elsewhere
-            //in this file.
-            if (node.detachEvent && !isOpera) {
-                //Probably IE. If not it will throw an error, which will be
-                //useful to know.
-                if (ieName) {
-                    node.detachEvent(ieName, func);
-                }
-            } else {
-                node.removeEventListener(name, func, false);
-            }
-        }
-
-        /**
-         * Given an event from a script node, get the requirejs info from it,
-         * and then removes the event listeners on the node.
-         * @param {Event} evt
-         * @returns {Object}
-         */
-        function getScriptData(evt) {
-            //Using currentTarget instead of target for Firefox 2.0's sake. Not
-            //all old browsers will be supported, but this one was easy enough
-            //to support and still makes sense.
-            var node = evt.currentTarget || evt.srcElement;
-
-            //Remove the listeners once here.
-            removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
-            removeListener(node, context.onScriptError, 'error');
-
-            return {
-                node: node,
-                id: node && node.getAttribute('data-requiremodule')
-            };
-        }
-
-        function intakeDefines() {
-            var args;
-
-            //Any defined modules in the global queue, intake them now.
-            takeGlobalQueue();
-
-            //Make sure any remaining defQueue items get properly processed.
-            while (defQueue.length) {
-                args = defQueue.shift();
-                if (args[0] === null) {
-                    return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' + args[args.length - 1]));
-                } else {
-                    //args are id, deps, factory. Should be normalized by the
-                    //define() function.
-                    callGetModule(args);
-                }
-            }
-        }
-
-        context = {
-            config: config,
-            contextName: contextName,
-            registry: registry,
-            defined: defined,
-            urlFetched: urlFetched,
-            defQueue: defQueue,
-            Module: Module,
-            makeModuleMap: makeModuleMap,
-            nextTick: req.nextTick,
-            onError: onError,
-
-            /**
-             * Set a configuration for the context.
-             * @param {Object} cfg config object to integrate.
-             */
-            configure: function (cfg) {
-                //Make sure the baseUrl ends in a slash.
-                if (cfg.baseUrl) {
-                    if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
-                        cfg.baseUrl += '/';
-                    }
-                }
-
-                //Save off the paths and packages since they require special processing,
-                //they are additive.
-                var pkgs = config.pkgs,
-                    shim = config.shim,
-                    objs = {
-                        paths: true,
-                        config: true,
-                        map: true
-                    };
-
-                eachProp(cfg, function (value, prop) {
-                    if (objs[prop]) {
-                        if (prop === 'map') {
-                            if (!config.map) {
-                                config.map = {};
-                            }
-                            mixin(config[prop], value, true, true);
-                        } else {
-                            mixin(config[prop], value, true);
-                        }
-                    } else {
-                        config[prop] = value;
-                    }
-                });
-
-                //Merge shim
-                if (cfg.shim) {
-                    eachProp(cfg.shim, function (value, id) {
-                        //Normalize the structure
-                        if (isArray(value)) {
-                            value = {
-                                deps: value
-                            };
-                        }
-                        if ((value.exports || value.init) && !value.exportsFn) {
-                            value.exportsFn = context.makeShimExports(value);
-                        }
-                        shim[id] = value;
-                    });
-                    config.shim = shim;
-                }
-
-                //Adjust packages if necessary.
-                if (cfg.packages) {
-                    each(cfg.packages, function (pkgObj) {
-                        var location;
-
-                        pkgObj = typeof pkgObj === 'string' ? { name: pkgObj } : pkgObj;
-                        location = pkgObj.location;
-
-                        //Create a brand new object on pkgs, since currentPackages can
-                        //be passed in again, and config.pkgs is the internal transformed
-                        //state for all package configs.
-                        pkgs[pkgObj.name] = {
-                            name: pkgObj.name,
-                            location: location || pkgObj.name,
-                            //Remove leading dot in main, so main paths are normalized,
-                            //and remove any trailing .js, since different package
-                            //envs have different conventions: some use a module name,
-                            //some use a file name.
-                            main: (pkgObj.main || 'main')
-                                  .replace(currDirRegExp, '')
-                                  .replace(jsSuffixRegExp, '')
-                        };
-                    });
-
-                    //Done with modifications, assing packages back to context config
-                    config.pkgs = pkgs;
-                }
-
-                //If there are any "waiting to execute" modules in the registry,
-                //update the maps for them, since their info, like URLs to load,
-                //may have changed.
-                eachProp(registry, function (mod, id) {
-                    //If module already has init called, since it is too
-                    //late to modify them, and ignore unnormalized ones
-                    //since they are transient.
-                    if (!mod.inited && !mod.map.unnormalized) {
-                        mod.map = makeModuleMap(id);
-                    }
-                });
-
-                //If a deps array or a config callback is specified, then call
-                //require with those args. This is useful when require is defined as a
-                //config object before require.js is loaded.
-                if (cfg.deps || cfg.callback) {
-                    context.require(cfg.deps || [], cfg.callback);
-                }
-            },
-
-            makeShimExports: function (value) {
-                function fn() {
-                    var ret;
-                    if (value.init) {
-                        ret = value.init.apply(global, arguments);
-                    }
-                    return ret || (value.exports && getGlobal(value.exports));
-                }
-                return fn;
-            },
-
-            makeRequire: function (relMap, options) {
-                options = options || {};
-
-                function localRequire(deps, callback, errback) {
-                    var id, map, requireMod;
-
-                    if (options.enableBuildCallback && callback && isFunction(callback)) {
-                        callback.__requireJsBuild = true;
-                    }
-
-                    if (typeof deps === 'string') {
-                        if (isFunction(callback)) {
-                            //Invalid call
-                            return onError(makeError('requireargs', 'Invalid require call'), errback);
-                        }
-
-                        //If require|exports|module are requested, get the
-                        //value for them from the special handlers. Caveat:
-                        //this only works while module is being defined.
-                        if (relMap && hasProp(handlers, deps)) {
-                            return handlers[deps](registry[relMap.id]);
-                        }
-
-                        //Synchronous access to one module. If require.get is
-                        //available (as in the Node adapter), prefer that.
-                        if (req.get) {
-                            return req.get(context, deps, relMap, localRequire);
-                        }
-
-                        //Normalize module name, if it contains . or ..
-                        map = makeModuleMap(deps, relMap, false, true);
-                        id = map.id;
-
-                        if (!hasProp(defined, id)) {
-                            return onError(makeError('notloaded', 'Module name "' +
-                                        id +
-                                        '" has not been loaded yet for context: ' +
-                                        contextName +
-                                        (relMap ? '' : '. Use require([])')));
-                        }
-                        return defined[id];
-                    }
-
-                    //Grab defines waiting in the global queue.
-                    intakeDefines();
-
-                    //Mark all the dependencies as needing to be loaded.
-                    context.nextTick(function () {
-                        //Some defines could have been added since the
-                        //require call, collect them.
-                        intakeDefines();
-
-                        requireMod = getModule(makeModuleMap(null, relMap));
-
-                        //Store if map config should be applied to this require
-                        //call for dependencies.
-                        requireMod.skipMap = options.skipMap;
-
-                        requireMod.init(deps, callback, errback, {
-                            enabled: true
-                        });
-
-                        checkLoaded();
-                    });
-
-                    return localRequire;
-                }
-
-                mixin(localRequire, {
-                    isBrowser: isBrowser,
-
-                    /**
-                     * Converts a module name + .extension into an URL path.
-                     * *Requires* the use of a module name. It does not support using
-                     * plain URLs like nameToUrl.
-                     */
-                    toUrl: function (moduleNamePlusExt) {
-                        var ext,
-                            index = moduleNamePlusExt.lastIndexOf('.'),
-                            segment = moduleNamePlusExt.split('/')[0],
-                            isRelative = segment === '.' || segment === '..';
-
-                        //Have a file extension alias, and it is not the
-                        //dots from a relative path.
-                        if (index !== -1 && (!isRelative || index > 1)) {
-                            ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
-                            moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
-                        }
-
-                        return context.nameToUrl(normalize(moduleNamePlusExt,
-                                                relMap && relMap.id, true), ext,  true);
-                    },
-
-                    defined: function (id) {
-                        return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
-                    },
-
-                    specified: function (id) {
-                        id = makeModuleMap(id, relMap, false, true).id;
-                        return hasProp(defined, id) || hasProp(registry, id);
-                    }
-                });
-
-                //Only allow undef on top level require calls
-                if (!relMap) {
-                    localRequire.undef = function (id) {
-                        //Bind any waiting define() calls to this context,
-                        //fix for #408
-                        takeGlobalQueue();
-
-                        var map = makeModuleMap(id, relMap, true),
-                            mod = getOwn(registry, id);
-
-                        delete defined[id];
-                        delete urlFetched[map.url];
-                        delete undefEvents[id];
-
-                        if (mod) {
-                            //Hold on to listeners in case the
-                            //module will be attempted to be reloaded
-                            //using a different config.
-                            if (mod.events.defined) {
-                                undefEvents[id] = mod.events;
-                            }
-
-                            cleanRegistry(id);
-                        }
-                    };
-                }
-
-                return localRequire;
-            },
-
-            /**
-             * Called to enable a module if it is still in the registry
-             * awaiting enablement. A second arg, parent, the parent module,
-             * is passed in for context, when this method is overriden by
-             * the optimizer. Not shown here to keep code compact.
-             */
-            enable: function (depMap) {
-                var mod = getOwn(registry, depMap.id);
-                if (mod) {
-                    getModule(depMap).enable();
-                }
-            },
-
-            /**
-             * Internal method used by environment adapters to complete a load event.
-             * A load event could be a script load or just a load pass from a synchronous
-             * load call.
-             * @param {String} moduleName the name of the module to potentially complete.
-             */
-            completeLoad: function (moduleName) {
-                var found, args, mod,
-                    shim = getOwn(config.shim, moduleName) || {},
-                    shExports = shim.exports;
-
-                takeGlobalQueue();
-
-                while (defQueue.length) {
-                    args = defQueue.shift();
-                    if (args[0] === null) {
-                        args[0] = moduleName;
-                        //If already found an anonymous module and bound it
-                        //to this name, then this is some other anon module
-                        //waiting for its completeLoad to fire.
-                        if (found) {
-                            break;
-                        }
-                        found = true;
-                    } else if (args[0] === moduleName) {
-                        //Found matching define call for this script!
-                        found = true;
-                    }
-
-                    callGetModule(args);
-                }
-
-                //Do this after the cycle of callGetModule in case the result
-                //of those calls/init calls changes the registry.
-                mod = getOwn(registry, moduleName);
-
-                if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {
-                    if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
-                        if (hasPathFallback(moduleName)) {
-                            return;
-                        } else {
-                            return onError(makeError('nodefine',
-                                             'No define call for ' + moduleName,
-                                             null,
-                                             [moduleName]));
-                        }
-                    } else {
-                        //A script that does not call define(), so just simulate
-                        //the call for it.
-                        callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
-                    }
-                }
-
-                checkLoaded();
-            },
-
-            /**
-             * Converts a module name to a file path. Supports cases where
-             * moduleName may actually be just an URL.
-             * Note that it **does not** call normalize on the moduleName,
-             * it is assumed to have already been normalized. This is an
-             * internal API, not a public one. Use toUrl for the public API.
-             */
-            nameToUrl: function (moduleName, ext, skipExt) {
-                var paths, pkgs, pkg, pkgPath, syms, i, parentModule, url,
-                    parentPath;
-
-                //If a colon is in the URL, it indicates a protocol is used and it is just
-                //an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
-                //or ends with .js, then assume the user meant to use an url and not a module id.
-                //The slash is important for protocol-less URLs as well as full paths.
-                if (req.jsExtRegExp.test(moduleName)) {
-                    //Just a plain path, not module name lookup, so just return it.
-                    //Add extension if it is included. This is a bit wonky, only non-.js things pass
-                    //an extension, this method probably needs to be reworked.
-                    url = moduleName + (ext || '');
-                } else {
-                    //A module that needs to be converted to a path.
-                    paths = config.paths;
-                    pkgs = config.pkgs;
-
-                    syms = moduleName.split('/');
-                    //For each module name segment, see if there is a path
-                    //registered for it. Start with most specific name
-                    //and work up from it.
-                    for (i = syms.length; i > 0; i -= 1) {
-                        parentModule = syms.slice(0, i).join('/');
-                        pkg = getOwn(pkgs, parentModule);
-                        parentPath = getOwn(paths, parentModule);
-                        if (parentPath) {
-                            //If an array, it means there are a few choices,
-                            //Choose the one that is desired
-                            if (isArray(parentPath)) {
-                                parentPath = parentPath[0];
-                            }
-                            syms.splice(0, i, parentPath);
-                            break;
-                        } else if (pkg) {
-                            //If module name is just the package name, then looking
-                            //for the main module.
-                            if (moduleName === pkg.name) {
-                                pkgPath = pkg.location + '/' + pkg.main;
-                            } else {
-                                pkgPath = pkg.location;
-                            }
-                            syms.splice(0, i, pkgPath);
-                            break;
-                        }
-                    }
-
-                    //Join the path parts together, then figure out if baseUrl is needed.
-                    url = syms.join('/');
-                    url += (ext || (/\?/.test(url) || skipExt ? '' : '.js'));
-                    url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
-                }
-
-                return config.urlArgs ? url +
-                                        ((url.indexOf('?') === -1 ? '?' : '&') +
-                                         config.urlArgs) : url;
-            },
-
-            //Delegates to req.load. Broken out as a separate function to
-            //allow overriding in the optimizer.
-            load: function (id, url) {
-                req.load(context, id, url);
-            },
-
-            /**
-             * Executes a module callback function. Broken out as a separate function
-             * solely to allow the build system to sequence the files in the built
-             * layer in the right sequence.
-             *
-             * @private
-             */
-            execCb: function (name, callback, args, exports) {
-                return callback.apply(exports, args);
-            },
-
-            /**
-             * callback for script loads, used to check status of loading.
-             *
-             * @param {Event} evt the event from the browser for the script
-             * that was loaded.
-             */
-            onScriptLoad: function (evt) {
-                //Using currentTarget instead of target for Firefox 2.0's sake. Not
-                //all old browsers will be supported, but this one was easy enough
-                //to support and still makes sense.
-                if (evt.type === 'load' ||
-                        (readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
-                    //Reset interactive script so a script node is not held onto for
-                    //to long.
-                    interactiveScript = null;
-
-                    //Pull out the name of the module and the context.
-                    var data = getScriptData(evt);
-                    context.completeLoad(data.id);
-                }
-            },
-
-            /**
-             * Callback for script errors.
-             */
-            onScriptError: function (evt) {
-                var data = getScriptData(evt);
-                if (!hasPathFallback(data.id)) {
-                    return onError(makeError('scripterror', 'Script error for: ' + data.id, evt, [data.id]));
-                }
-            }
-        };
-
-        context.require = context.makeRequire();
-        return context;
-    }
-
-    /**
-     * Main entry point.
-     *
-     * If the only argument to require is a string, then the module that
-     * is represented by that string is fetched for the appropriate context.
-     *
-     * If the first argument is an array, then it will be treated as an array
-     * of dependency string names to fetch. An optional function callback can
-     * be specified to execute when all of those dependencies are available.
-     *
-     * Make a local req variable to help Caja compliance (it assumes things
-     * on a require that are not standardized), and to give a short
-     * name for minification/local scope use.
-     */
-    req = requirejs = function (deps, callback, errback, optional) {
-
-        //Find the right context, use default
-        var context, config,
-            contextName = defContextName;
-
-        // Determine if have config object in the call.
-        if (!isArray(deps) && typeof deps !== 'string') {
-            // deps is a config object
-            config = deps;
-            if (isArray(callback)) {
-                // Adjust args if there are dependencies
-                deps = callback;
-                callback = errback;
-                errback = optional;
-            } else {
-                deps = [];
-            }
-        }
-
-        if (config && config.context) {
-            contextName = config.context;
-        }
-
-        context = getOwn(contexts, contextName);
-        if (!context) {
-            context = contexts[contextName] = req.s.newContext(contextName);
-        }
-
-        if (config) {
-            context.configure(config);
-        }
-
-        return context.require(deps, callback, errback);
-    };
-
-    /**
-     * Support require.config() to make it easier to cooperate with other
-     * AMD loaders on globally agreed names.
-     */
-    req.config = function (config) {
-        return req(config);
-    };
-
-    /**
-     * Execute something after the current tick
-     * of the event loop. Override for other envs
-     * that have a better solution than setTimeout.
-     * @param  {Function} fn function to execute later.
-     */
-    req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
-        setTimeout(fn, 4);
-    } : function (fn) { fn(); };
-
-    /**
-     * Export require as a global, but only if it does not already exist.
-     */
-    if (!require) {
-        require = req;
-    }
-
-    req.version = version;
-
-    //Used to filter out dependencies that are already paths.
-    req.jsExtRegExp = /^\/|:|\?|\.js$/;
-    req.isBrowser = isBrowser;
-    s = req.s = {
-        contexts: contexts,
-        newContext: newContext
-    };
-
-    //Create default context.
-    req({});
-
-    //Exports some context-sensitive methods on global require.
-    each([
-        'toUrl',
-        'undef',
-        'defined',
-        'specified'
-    ], function (prop) {
-        //Reference from contexts instead of early binding to default context,
-        //so that during builds, the latest instance of the default context
-        //with its config gets used.
-        req[prop] = function () {
-            var ctx = contexts[defContextName];
-            return ctx.require[prop].apply(ctx, arguments);
-        };
-    });
-
-    if (isBrowser) {
-        head = s.head = document.getElementsByTagName('head')[0];
-        //If BASE tag is in play, using appendChild is a problem for IE6.
-        //When that browser dies, this can be removed. Details in this jQuery bug:
-        //http://dev.jquery.com/ticket/2709
-        baseElement = document.getElementsByTagName('base')[0];
-        if (baseElement) {
-            head = s.head = baseElement.parentNode;
-        }
-    }
-
-    /**
-     * Any errors that require explicitly generates will be passed to this
-     * function. Intercept/override it if you want custom error handling.
-     * @param {Error} err the error object.
-     */
-    req.onError = defaultOnError;
-
-    /**
-     * Creates the node for the load command. Only used in browser envs.
-     */
-    req.createNode = function (config, moduleName, url) {
-        var node = config.xhtml ?
-                document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
-                document.createElement('script');
-        node.type = config.scriptType || 'text/javascript';
-        node.charset = 'utf-8';
-        node.async = true;
-        return node;
-    };
-
-    /**
-     * Does the request to load a module for the browser case.
-     * Make this a separate function to allow other environments
-     * to override it.
-     *
-     * @param {Object} context the require context to find state.
-     * @param {String} moduleName the name of the module.
-     * @param {Object} url the URL to the module.
-     */
-    req.load = function (context, moduleName, url) {
-        var config = (context && context.config) || {},
-            node;
-        if (isBrowser) {
-            //In the browser so use a script tag
-            node = req.createNode(config, moduleName, url);
-
-            node.setAttribute('data-requirecontext', context.contextName);
-            node.setAttribute('data-requiremodule', moduleName);
-
-            //Set up load listener. Test attachEvent first because IE9 has
-            //a subtle issue in its addEventListener and script onload firings
-            //that do not match the behavior of all other browsers with
-            //addEventListener support, which fire the onload event for a
-            //script right after the script execution. See:
-            //https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
-            //UNFORTUNATELY Opera implements attachEvent but does not follow the script
-            //script execution mode.
-            if (node.attachEvent &&
-                    //Check if node.attachEvent is artificially added by custom script or
-                    //natively supported by browser
-                    //read https://github.com/jrburke/requirejs/issues/187
-                    //if we can NOT find [native code] then it must NOT natively supported.
-                    //in IE8, node.attachEvent does not have toString()
-                    //Note the test for "[native code" with no closing brace, see:
-                    //https://github.com/jrburke/requirejs/issues/273
-                    !(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
-                    !isOpera) {
-                //Probably IE. IE (at least 6-8) do not fire
-                //script onload right after executing the script, so
-                //we cannot tie the anonymous define call to a name.
-                //However, IE reports the script as being in 'interactive'
-                //readyState at the time of the define call.
-                useInteractive = true;
-
-                node.attachEvent('onreadystatechange', context.onScriptLoad);
-                //It would be great to add an error handler here to catch
-                //404s in IE9+. However, onreadystatechange will fire before
-                //the error handler, so that does not help. If addEventListener
-                //is used, then IE will fire error before load, but we cannot
-                //use that pathway given the connect.microsoft.com issue
-                //mentioned above about not doing the 'script execute,
-                //then fire the script load event listener before execute
-                //next script' that other browsers do.
-                //Best hope: IE10 fixes the issues,
-                //and then destroys all installs of IE 6-9.
-                //node.attachEvent('onerror', context.onScriptError);
-            } else {
-                node.addEventListener('load', context.onScriptLoad, false);
-                node.addEventListener('error', context.onScriptError, false);
-            }
-            node.src = url;
-
-            //For some cache cases in IE 6-8, the script executes before the end
-            //of the appendChild execution, so to tie an anonymous define
-            //call to the module name (which is stored on the node), hold on
-            //to a reference to this node, but clear after the DOM insertion.
-            currentlyAddingScript = node;
-            if (baseElement) {
-                head.insertBefore(node, baseElement);
-            } else {
-                head.appendChild(node);
-            }
-            currentlyAddingScript = null;
-
-            return node;
-        } else if (isWebWorker) {
-            try {
-                //In a web worker, use importScripts. This is not a very
-                //efficient use of importScripts, importScripts will block until
-                //its script is downloaded and evaluated. However, if web workers
-                //are in play, the expectation that a build has been done so that
-                //only one script needs to be loaded anyway. This may need to be
-                //reevaluated if other use cases become common.
-                importScripts(url);
-
-                //Account for anonymous modules
-                context.completeLoad(moduleName);
-            } catch (e) {
-                context.onError(makeError('importscripts',
-                                'importScripts failed for ' +
-                                    moduleName + ' at ' + url,
-                                e,
-                                [moduleName]));
-            }
-        }
-    };
-
-    function getInteractiveScript() {
-        if (interactiveScript && interactiveScript.readyState === 'interactive') {
-            return interactiveScript;
-        }
-
-        eachReverse(scripts(), function (script) {
-            if (script.readyState === 'interactive') {
-                return (interactiveScript = script);
-            }
-        });
-        return interactiveScript;
-    }
-
-    //Look for a data-main script attribute, which could also adjust the baseUrl.
-    if (isBrowser) {
-        //Figure out baseUrl. Get it from the script tag with require.js in it.
-        eachReverse(scripts(), function (script) {
-            //Set the 'head' where we can append children by
-            //using the script's parent.
-            if (!head) {
-                head = script.parentNode;
-            }
-
-            //Look for a data-main attribute to set main script for the page
-            //to load. If it is there, the path to data main becomes the
-            //baseUrl, if it is not already set.
-            dataMain = script.getAttribute('data-main');
-            if (dataMain) {
-                //Preserve dataMain in case it is a path (i.e. contains '?')
-                mainScript = dataMain;
-
-                //Set final baseUrl if there is not already an explicit one.
-                if (!cfg.baseUrl) {
-                    //Pull off the directory of data-main for use as the
-                    //baseUrl.
-                    src = mainScript.split('/');
-                    mainScript = src.pop();
-                    subPath = src.length ? src.join('/')  + '/' : './';
-
-                    cfg.baseUrl = subPath;
-                }
-
-                //Strip off any trailing .js since mainScript is now
-                //like a module name.
-                mainScript = mainScript.replace(jsSuffixRegExp, '');
-
-                 //If mainScript is still a path, fall back to dataMain
-                if (req.jsExtRegExp.test(mainScript)) {
-                    mainScript = dataMain;
-                }
-
-                //Put the data-main script in the files to load.
-                cfg.deps = cfg.deps ? cfg.deps.concat(mainScript) : [mainScript];
-
-                return true;
-            }
-        });
-    }
-
-    /**
-     * The function that handles definitions of modules. Differs from
-     * require() in that a string for the module should be the first argument,
-     * and the function to execute after dependencies are loaded should
-     * return a value to define the module corresponding to the first argument's
-     * name.
-     */
-    define = function (name, deps, callback) {
-        var node, context;
-
-        //Allow for anonymous modules
-        if (typeof name !== 'string') {
-            //Adjust args appropriately
-            callback = deps;
-            deps = name;
-            name = null;
-        }
-
-        //This module may not have dependencies
-        if (!isArray(deps)) {
-            callback = deps;
-            deps = null;
-        }
-
-        //If no name, and callback is a function, then figure out if it a
-        //CommonJS thing with dependencies.
-        if (!deps && isFunction(callback)) {
-            deps = [];
-            //Remove comments from the callback string,
-            //look for require calls, and pull them into the dependencies,
-            //but only if there are function args.
-            if (callback.length) {
-                callback
-                    .toString()
-                    .replace(commentRegExp, '')
-                    .replace(cjsRequireRegExp, function (match, dep) {
-                        deps.push(dep);
-                    });
-
-                //May be a CommonJS thing even without require calls, but still
-                //could use exports, and module. Avoid doing exports and module
-                //work though if it just needs require.
-                //REQUIRES the function to expect the CommonJS variables in the
-                //order listed below.
-                deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
-            }
-        }
-
-        //If in IE 6-8 and hit an anonymous define() call, do the interactive
-        //work.
-        if (useInteractive) {
-            node = currentlyAddingScript || getInteractiveScript();
-            if (node) {
-                if (!name) {
-                    name = node.getAttribute('data-requiremodule');
-                }
-                context = contexts[node.getAttribute('data-requirecontext')];
-            }
-        }
-
-        //Always save off evaluating the def call until the script onload handler.
-        //This allows multiple modules to be in a file without prematurely
-        //tracing dependencies, and allows for anonymous module support,
-        //where the module name is not known until the script onload event
-        //occurs. If no context, use the global queue, and get it processed
-        //in the onscript load callback.
-        (context ? context.defQueue : globalDefQueue).push([name, deps, callback]);
-    };
-
-    define.amd = {
-        jQuery: true
-    };
-
-
-    /**
-     * Executes the text. Normally just uses eval, but can be modified
-     * to use a better, environment-specific call. Only used for transpiling
-     * loader plugins, not for plain JS modules.
-     * @param {String} text the text to execute/evaluate.
-     */
-    req.exec = function (text) {
-        /*jslint evil: true */
-        return eval(text);
-    };
-
-    //Set up with config info.
-    req(cfg);
-}(this));

lib/rsvp/rsvp.js

-(function(globals) {
-var define, requireModule;
-
-(function() {
-  var registry = {}, seen = {};
-
-  define = function(name, deps, callback) {
-    registry[name] = { deps: deps, callback: callback };
-  };
-
-  requireModule = function(name) {
-    if (seen[name]) { return seen[name]; }
-    seen[name] = {};
-
-    var mod = registry[name];
-    if (!mod) {
-      throw new Error("Module '" + name + "' not found.");
-    }
-
-    var deps = mod.deps,
-        callback = mod.callback,
-        reified = [],
-        exports;
-
-    for (var i=0, l=deps.length; i<l; i++) {
-      if (deps[i] === 'exports') {
-        reified.push(exports = {});
-      } else {
-        reified.push(requireModule(deps[i]));
-      }
-    }
-
-    var value = callback.apply(this, reified);
-    return seen[name] = exports || value;
-  };
-})();
-
-define("rsvp/all",
-  ["rsvp/promise","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Promise = __dependency1__.Promise;
-    /* global toString */
-
-
-    function promiseAtLeast(expected_count, promises) {
-      if (Object.prototype.toString.call(promises) !== "[object Array]") {
-        throw new TypeError('You must pass an array to all.');
-      }
-
-      function canceller() {
-        var promise;
-        for (var i = 0; i < promises.length; i++) {
-          promise = promises[i];
-
-          if (promise && typeof promise.then === 'function' &&
-              typeof promise.cancel === 'function') {
-            promise.cancel();
-          }
-        }
-      }
-
-      return new Promise(function(resolve, reject, notify) {
-        var results = [], remaining = promises.length,
-        promise, remaining_count = promises.length - expected_count;
-
-        if (remaining === 0) {
-          if (expected_count === 1) {
-            resolve();
-          } else {
-            resolve([]);
-          }
-        }
-
-        function resolver(index) {
-          return function(value) {
-            resolveAll(index, value);
-          };
-        }
-
-        function resolveAll(index, value) {
-          results[index] = value;
-          if (--remaining === remaining_count) {
-            if (remaining_count === 0) {
-              resolve(results);
-            } else {
-              resolve(value);
-              canceller();
-            }
-          }
-        }
-
-        function notifier(index) {
-          return function(value) {
-            notify({"index": index, "value": value});
-          };
-        }
-
-        function cancelAll(rejectionValue) {
-          reject(rejectionValue);
-          canceller();
-        }
-
-        for (var i = 0; i < promises.length; i++) {
-          promise = promises[i];
-
-          if (promise && typeof promise.then === 'function') {
-            promise.then(resolver(i), cancelAll, notifier(i));
-          } else {
-            resolveAll(i, promise);
-          }
-        }
-      }, canceller
-      );
-    }
-
-    function all(promises) {
-      return promiseAtLeast(promises.length, promises);
-    }
-
-    function any(promises) {
-      return promiseAtLeast(1, promises);
-    }
-
-
-    __exports__.all = all;
-    __exports__.any = any;
-  });
-define("rsvp/async",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    var browserGlobal = (typeof window !== 'undefined') ? window : {};
-    var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
-    var async;
-    var local = (typeof global !== 'undefined') ? global : this;
-
-    // old node
-    function useNextTick() {
-      return function(callback, arg) {
-        process.nextTick(function() {
-          callback(arg);
-        });
-      };
-    }
-
-    // node >= 0.10.x
-    function useSetImmediate() {
-      return function(callback, arg) {
-        /* global  setImmediate */
-        setImmediate(function(){
-          callback(arg);
-        });
-      };
-    }
-
-    function useMutationObserver() {
-      var queue = [];
-
-      var observer = new BrowserMutationObserver(function() {
-        var toProcess = queue.slice();
-        queue = [];
-
-        toProcess.forEach(function(tuple) {
-          var callback = tuple[0], arg= tuple[1];
-          callback(arg);
-        });
-      });
-
-      var element = document.createElement('div');
-      observer.observe(element, { attributes: true });
-
-      // Chrome Memory Leak: https://bugs.webkit.org/show_bug.cgi?id=93661
-      window.addEventListener('unload', function(){
-        observer.disconnect();
-        observer = null;
-      }, false);
-
-      return function(callback, arg) {
-        queue.push([callback, arg]);
-        element.setAttribute('drainQueue', 'drainQueue');
-      };
-    }
-
-    function useSetTimeout() {
-      return function(callback, arg) {
-        local.setTimeout(function() {
-          callback(arg);
-        }, 1);
-      };
-    }
-
-    if (typeof setImmediate === 'function') {
-      async = useSetImmediate();
-    } else if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
-      async = useNextTick();
-    } else if (BrowserMutationObserver) {
-      async = useMutationObserver();
-    } else {
-      async = useSetTimeout();
-    }
-
-
-    __exports__.async = async;
-  });
-define("rsvp/cancellation_error",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
-    function CancellationError(message) {
-      this.name = "cancel";
-      if ((message !== undefined) && (typeof message !== "string")) {
-        throw new TypeError('You must pass a string.');
-      }
-      this.message = message || "Default Message";
-    }
-    CancellationError.prototype = new Error();
-    CancellationError.prototype.constructor = CancellationError;
-
-
-    __exports__.CancellationError = CancellationError;
-  });
-define("rsvp/config",
-  ["rsvp/async","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var async = __dependency1__.async;
-
-    var config = {};
-    config.async = async;
-
-
-    __exports__.config = config;
-  });
-define("rsvp/defer",
-  ["rsvp/promise","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Promise = __dependency1__.Promise;
-
-    function defer() {
-      var deferred = {
-        // pre-allocate shape
-        resolve: undefined,
-        reject:  undefined,
-        promise: undefined
-      };
-
-      deferred.promise = new Promise(function(resolve, reject) {
-        deferred.resolve = resolve;
-        deferred.reject = reject;
-      });
-
-      return deferred;
-    }
-
-
-    __exports__.defer = defer;
-  });
-define("rsvp/events",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    var Event = function(type, options) {
-      this.type = type;
-
-      for (var option in options) {
-        if (!options.hasOwnProperty(option)) { continue; }
-
-        this[option] = options[option];
-      }
-    };
-
-    var indexOf = function(callbacks, callback) {
-      for (var i=0, l=callbacks.length; i<l; i++) {
-        if (callbacks[i][0] === callback) { return i; }
-      }
-
-      return -1;
-    };
-
-    var callbacksFor = function(object) {
-      var callbacks = object._promiseCallbacks;
-
-      if (!callbacks) {
-        callbacks = object._promiseCallbacks = {};
-      }
-
-      return callbacks;
-    };
-
-    var EventTarget = {
-      mixin: function(object) {
-        object.on = this.on;
-        object.off = this.off;
-        object.trigger = this.trigger;
-        return object;
-      },
-
-      on: function(eventNames, callback, binding) {
-        var allCallbacks = callbacksFor(this), callbacks, eventName;
-        eventNames = eventNames.split(/\s+/);
-        binding = binding || this;
-
-        while (eventName = eventNames.shift()) {
-          callbacks = allCallbacks[eventName];
-
-          if (!callbacks) {
-            callbacks = allCallbacks[eventName] = [];
-          }
-
-          if (indexOf(callbacks, callback) === -1) {
-            callbacks.push([callback, binding]);
-          }
-        }
-      },
-
-      off: function(eventNames, callback) {
-        var allCallbacks = callbacksFor(this), callbacks, eventName, index;
-        eventNames = eventNames.split(/\s+/);
-
-        while (eventName = eventNames.shift()) {
-          if (!callback) {
-            allCallbacks[eventName] = [];
-            continue;
-          }
-
-          callbacks = allCallbacks[eventName];
-
-          index = indexOf(callbacks, callback);
-
-          if (index !== -1) { callbacks.splice(index, 1); }
-        }
-      },
-
-      trigger: function(eventName, options) {
-        var allCallbacks = callbacksFor(this),
-            callbacks, callbackTuple, callback, binding, event;
-
-        if (callbacks = allCallbacks[eventName]) {
-          // Don't cache the callbacks.length since it may grow
-          for (var i=0; i<callbacks.length; i++) {
-            callbackTuple = callbacks[i];
-            callback = callbackTuple[0];
-            binding = callbackTuple[1];
-
-            if (typeof options !== 'object') {
-              options = { detail: options };
-            }
-
-            event = new Event(eventName, options);
-            callback.call(binding, event);
-          }
-        }
-      }
-    };
-
-
-    __exports__.EventTarget = EventTarget;
-  });
-define("rsvp/hash",
-  ["rsvp/defer","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var defer = __dependency1__.defer;
-
-    function size(object) {
-      var s = 0;
-
-      for (var prop in object) {
-        s++;
-      }
-
-      return s;
-    }
-
-    function hash(promises) {
-      var results = {}, deferred = defer(), remaining = size(promises);
-
-      if (remaining === 0) {
-        deferred.resolve({});
-      }
-
-      var resolver = function(prop) {
-        return function(value) {
-          resolveAll(prop, value);
-        };
-      };
-
-      var resolveAll = function(prop, value) {
-        results[prop] = value;
-        if (--remaining === 0) {
-          deferred.resolve(results);
-        }
-      };
-
-      var rejectAll = function(error) {
-        deferred.reject(error);
-      };
-
-      for (var prop in promises) {
-        if (promises[prop] && typeof promises[prop].then === 'function') {
-          promises[prop].then(resolver(prop), rejectAll);
-        } else {
-          resolveAll(prop, promises[prop]);
-        }
-      }
-
-      return deferred.promise;
-    }
-
-
-    __exports__.hash = hash;
-  });
-define("rsvp/node",
-  ["rsvp/promise","rsvp/all","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var Promise = __dependency1__.Promise;
-    var all = __dependency2__.all;
-
-    function makeNodeCallbackFor(resolve, reject) {
-      return function (error, value) {
-        if (error) {
-          reject(error);
-        } else if (arguments.length > 2) {
-          resolve(Array.prototype.slice.call(arguments, 1));
-        } else {
-          resolve(value);
-        }
-      };
-    }
-
-    function denodeify(nodeFunc) {
-      return function()  {
-        var nodeArgs = Array.prototype.slice.call(arguments), resolve, reject;
-        var thisArg = this;
-
-        var promise = new Promise(function(nodeResolve, nodeReject) {
-          resolve = nodeResolve;
-          reject = nodeReject;
-        });
-
-        all(nodeArgs).then(function(nodeArgs) {
-          nodeArgs.push(makeNodeCallbackFor(resolve, reject));
-
-          try {
-            nodeFunc.apply(thisArg, nodeArgs);
-          } catch(e) {
-            reject(e);
-          }
-        });
-
-        return promise;
-      };
-    }
-
-
-    __exports__.denodeify = denodeify;
-  });
-define("rsvp/promise",
-  ["rsvp/config","rsvp/events","rsvp/cancellation_error","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __exports__) {
-    "use strict";
-    var config = __dependency1__.config;
-    var EventTarget = __dependency2__.EventTarget;
-    var CancellationError = __dependency3__.CancellationError;
-
-    function objectOrFunction(x) {
-      return isFunction(x) || (typeof x === "object" && x !== null);
-    }
-
-    function isFunction(x){
-      return typeof x === "function";
-    }
-
-    var Promise = function(resolver, canceller) {
-      var promise = this,
-      resolved = false;
-
-      if (typeof resolver !== 'function') {
-        throw new TypeError('You must pass a resolver function as the sole argument to the promise constructor');
-      }
-
-      if ((canceller !== undefined) && (typeof canceller !== 'function')) {
-        throw new TypeError('You can only pass a canceller function' +
-          ' as the second argument to the promise constructor');
-      }
-
-      if (!(promise instanceof Promise)) {
-        return new Promise(resolver, canceller);
-      }
-
-      var resolvePromise = function(value) {
-        if (resolved) { return; }
-        resolved = true;
-        resolve(promise, value);
-      };
-
-      var rejectPromise = function(value) {
-        if (resolved) { return; }
-        resolved = true;
-        reject(promise, value);
-      };
-
-      var notifyPromise = function(value) {
-        if (resolved) { return; }
-        notify(promise, value);
-      };
-
-      this.on('promise:failed', function(event) {
-        this.trigger('error', { detail: event.detail });
-      }, this);
-
-      this.on('error', onerror);
-
-      this.cancel = function () {
-        // For now, simply reject the promise and does not propagate the cancel
-        // to parent or children
-        if (resolved) { return; }
-        if (canceller !== undefined) {
-          try {
-            canceller();
-          } catch (e) {
-            rejectPromise(e);
-            return;
-          }
-        }
-        // Trigger cancel?
-        rejectPromise(new CancellationError());
-      };
-
-      try {
-        resolver(resolvePromise, rejectPromise, notifyPromise);
-      } catch(e) {
-        rejectPromise(e);
-      }
-    };
-
-    function onerror(event) {
-      if (config.onerror) {
-        config.onerror(event.detail);
-      }
-    }
-
-    var invokeCallback = function(type, promise, callback, event) {
-      var hasCallback = isFunction(callback),
-          value, error, succeeded, failed;
-
-      if (promise.isFulfilled) { return; }
-      if (promise.isRejected) { return; }
-
-      if (hasCallback) {
-        try {
-          value = callback(event.detail);
-          succeeded = true;
-        } catch(e) {
-          failed = true;
-          error = e;
-        }
-      } else {
-        value = event.detail;
-        succeeded = true;
-      }
-
-      if (handleThenable(promise, value)) {
-        return;
-      } else if (hasCallback && succeeded) {
-        resolve(promise, value);
-      } else if (failed) {
-        reject(promise, error);
-      } else if (type === 'resolve') {
-        resolve(promise, value);
-      } else if (type === 'reject') {
-        reject(promise, value);
-      }
-    };
-
-
-    var invokeNotifyCallback = function(promise, callback, event) {
-      var value;
-      if (typeof callback === 'function') {
-        try {
-          value = callback(event.detail);
-        } catch (e) {
-          // stop propagating
-          return;
-        }
-        notify(promise, value);
-      } else {
-        notify(promise, event.detail);
-      }
-    };
-
-    Promise.prototype = {
-      constructor: Promise,
-
-      isRejected: undefined,
-      isFulfilled: undefined,
-      rejectedReason: undefined,
-      fulfillmentValue: undefined,
-
-      then: function(done, fail, progress) {
-        this.off('error', onerror);
-
-        var thenPromise = new this.constructor(function() {},
-            function () {
-              thenPromise.trigger('promise:cancelled', {});
-            });
-
-        if (this.isFulfilled) {
-          config.async(function(promise) {
-            invokeCallback('resolve', thenPromise, done, { detail: promise.fulfillmentValue });
-          }, this);
-        }
-
-        if (this.isRejected) {
-          config.async(function(promise) {
-            invokeCallback('reject', thenPromise, fail, { detail: promise.rejectedReason });
-          }, this);
-        }
-
-        this.on('promise:resolved', function(event) {
-          invokeCallback('resolve', thenPromise, done, event);
-        });
-
-        this.on('promise:failed', function(event) {
-          invokeCallback('reject', thenPromise, fail, event);
-        });
-
-        this.on('promise:notified', function (event) {
-          invokeNotifyCallback(thenPromise, progress, event);
-        });
-
-        return thenPromise;
-      },
-
-      fail: function(fail) {
-        return this.then(null, fail);
-      },
-
-      always: function(fail) {
-        return this.then(fail, fail);
-      }
-    };
-
-    EventTarget.mixin(Promise.prototype);
-
-    function resolve(promise, value) {
-      if (promise === value) {
-        fulfill(promise, value);
-      } else if (!handleThenable(promise, value)) {
-        fulfill(promise, value);
-      }
-    }
-
-    function handleThenable(promise, value) {
-      var then = null,
-      resolved;
-
-      try {
-        if (promise === value) {
-          throw new TypeError("A promises callback cannot return that same promise.");
-        }
-
-        if (objectOrFunction(value)) {
-          then = value.then;
-
-          if (isFunction(then)) {
-            promise.on('promise:cancelled', function(event) {
-              if (isFunction(value.cancel)) {
-                value.cancel();
-              }
-            });
-            then.call(value, function(val) {
-              if (resolved) { return true; }
-              resolved = true;
-
-              if (value !== val) {
-                resolve(promise, val);
-              } else {
-                fulfill(promise, val);
-              }
-            }, function(val) {
-              if (resolved) { return true; }
-              resolved = true;
-
-              reject(promise, val);
-            });
-
-            return true;
-          }
-        }
-      } catch (error) {
-        reject(promise, error);
-        return true;
-      }
-
-      return false;
-    }
-
-    function fulfill(promise, value) {
-      config.async(function() {
-        if (promise.isFulfilled) { return; }
-        if (promise.isRejected) { return; }
-        promise.trigger('promise:resolved', { detail: value });
-        promise.isFulfilled = true;
-        promise.fulfillmentValue = value;
-      });
-    }
-
-    function reject(promise, value) {
-      config.async(function() {
-        if (promise.isFulfilled) { return; }
-        if (promise.isRejected) { return; }
-        promise.trigger('promise:failed', { detail: value });
-        promise.isRejected = true;
-        promise.rejectedReason = value;
-      });
-    }
-
-    function notify(promise, value) {
-      config.async(function() {
-        promise.trigger('promise:notified', { detail: value });
-      });
-    }
-
-
-    __exports__.Promise = Promise;
-  });
-define("rsvp/queue",
-  ["rsvp/promise","rsvp/timeout","exports"],
-  function(__dependency1__, __dependency2__, __exports__) {
-    "use strict";
-    var Promise = __dependency1__.Promise;
-    var delay = __dependency2__.delay;
-
-    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
-    function ResolvedQueueError(message) {
-      this.name = "resolved";
-      if ((message !== undefined) && (typeof message !== "string")) {
-        throw new TypeError('You must pass a string.');
-      }
-      this.message = message || "Default Message";
-    }
-    ResolvedQueueError.prototype = new Error();
-    ResolvedQueueError.prototype.constructor = ResolvedQueueError;
-
-    var Queue = function() {
-      var queue = this,
-        promise_list = [],
-        promise,
-        fulfill,
-        reject,
-        resolved;
-
-      if (!(this instanceof Queue)) {
-        return new Queue();
-      }
-
-      function canceller() {
-        for (var i = 0; i < 2; i++) {
-          promise_list[i].cancel();
-        }
-      }
-
-      promise = new Promise(function(done, fail) {
-        fulfill = function (fulfillmentValue) {
-          if (resolved) {return;}
-          queue.isFulfilled = true;
-          queue.fulfillmentValue = fulfillmentValue;
-          resolved = true;
-          return done(fulfillmentValue);
-        };
-        reject = function (rejectedReason) {
-          if (resolved) {return;}
-          queue.isRejected = true;
-          queue.rejectedReason = rejectedReason ;
-          resolved = true;
-          return fail(rejectedReason);
-        };
-      }, canceller);
-
-      promise_list.push(delay());
-      promise_list.push(promise_list[0].then(function () {
-        promise_list.splice(0, 2);
-        if (promise_list.length === 0) {
-          fulfill();
-        }
-      }));
-
-      queue.cancel = function () {
-        if (resolved) {return;}
-        resolved = true;
-        promise.cancel();
-        promise.fail(function (rejectedReason) {
-          queue.isRejected = true;
-          queue.rejectedReason = rejectedReason;
-        });
-      };
-      queue.then = function () {
-        return promise.then.apply(promise, arguments);
-      };
-
-      queue.push = function(done, fail) {
-        var last_promise = promise_list[promise_list.length - 1],
-          next_promise;
-
-        if (resolved) {
-          throw new ResolvedQueueError();
-        }
-
-        next_promise = last_promise.then(done, fail);
-        promise_list.push(next_promise);
-
-        // Handle pop
-        promise_list.push(next_promise.then(function (fulfillmentValue) {
-          promise_list.splice(0, 2);
-          if (promise_list.length === 0) {
-            fulfill(fulfillmentValue);
-          } else {
-            return fulfillmentValue;
-          }
-        }, function (rejectedReason) {
-          promise_list.splice(0, 2);
-          if (promise_list.length === 0) {
-            reject(rejectedReason);
-          } else {
-            throw rejectedReason;
-          }
-        }));
-
-        return this;
-      };
-    };
-
-    Queue.prototype = Object.create(Promise.prototype);
-    Queue.prototype.constructor = Queue;
-
-
-    __exports__.Queue = Queue;
-    __exports__.ResolvedQueueError = ResolvedQueueError;
-  });
-define("rsvp/reject",
-  ["rsvp/promise","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Promise = __dependency1__.Promise;
-
-    function reject(reason) {
-      return new Promise(function (resolve, reject) {
-        reject(reason);
-      });
-    }
-
-
-    __exports__.reject = reject;
-  });
-define("rsvp/resolve",
-  ["rsvp/promise","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Promise = __dependency1__.Promise;
-
-    function resolve(thenable) {
-      return new Promise(function(resolve, reject) {
-        if (typeof thenable === "object" && thenable !== null) {
-          var then = thenable.then;
-          if ((then !== undefined) && (typeof then === "function")) {
-            return then.apply(thenable, [resolve, reject]);
-          }
-        }
-        return resolve(thenable);
-      }, function () {
-        if ((thenable !== undefined) && (thenable.cancel !== undefined)) {
-          thenable.cancel();
-        }
-      });
-    }
-
-
-    __exports__.resolve = resolve;
-  });
-define("rsvp/rethrow",
-  ["exports"],
-  function(__exports__) {
-    "use strict";
-    var local = (typeof global === "undefined") ? this : global;
-
-    function rethrow(reason) {
-      local.setTimeout(function() {
-        throw reason;
-      });
-      throw reason;
-    }
-
-
-    __exports__.rethrow = rethrow;
-  });
-define("rsvp/timeout",
-  ["rsvp/promise","exports"],
-  function(__dependency1__, __exports__) {
-    "use strict";
-    var Promise = __dependency1__.Promise;
-
-    function promiseSetTimeout(millisecond, should_reject, message) {
-      var timeout_id;
-
-      function resolver(resolve, reject) {
-        timeout_id = setTimeout(function () {
-          if (should_reject) {
-            reject(message);
-          } else {
-            resolve(message);
-          }
-        }, millisecond);
-      }
-      function canceller() {
-        clearTimeout(timeout_id);
-      }
-      return new Promise(resolver, canceller);
-    }
-
-    function delay(millisecond, message) {
-      return promiseSetTimeout(millisecond, false, message);
-    }
-
-    function timeout(millisecond) {
-      return promiseSetTimeout(millisecond, true,
-                               "Timed out after " + millisecond + " ms");
-    }
-
-    Promise.prototype.delay = function(millisecond) {
-      return this.then(function (fulfillmentValue) {
-        return delay(millisecond, fulfillmentValue);
-      });
-    };
-
-
-    __exports__.delay = delay;
-    __exports__.timeout = timeout;
-  });
-define("rsvp",
-  ["rsvp/events","rsvp/cancellation_error","rsvp/promise","rsvp/node","rsvp/all","rsvp/queue","rsvp/timeout","rsvp/hash","rsvp/rethrow","rsvp/defer","rsvp/config","rsvp/resolve","rsvp/reject","exports"],
-  function(__dependency1__, __dependency2__, __dependency3__, __dependency4__, __dependency5__, __dependency6__, __dependency7__, __dependency8__, __dependency9__, __dependency10__, __dependency11__, __dependency12__, __dependency13__, __exports__) {
-    "use strict";
-    var EventTarget = __dependency1__.EventTarget;
-    var CancellationError = __dependency2__.CancellationError;
-    var Promise = __dependency3__.Promise;
-    var denodeify = __dependency4__.denodeify;
-    var all = __dependency5__.all;
-    var any = __dependency5__.any;
-    var Queue = __dependency6__.Queue;
-    var ResolvedQueueError = __dependency6__.ResolvedQueueError;
-    var delay = __dependency7__.delay;
-    var timeout = __dependency7__.timeout;
-    var hash = __dependency8__.hash;
-    var rethrow = __dependency9__.rethrow;
-    var defer = __dependency10__.defer;
-    var config = __dependency11__.config;
-    var resolve = __dependency12__.resolve;
-    var reject = __dependency13__.reject;
-
-    function configure(name, value) {
-      config[name] = value;
-    }
-
-
-    __exports__.CancellationError = CancellationError;
-    __exports__.Promise = Promise;
-    __exports__.EventTarget = EventTarget;
-    __exports__.all = all;
-    __exports__.any = any;
-    __exports__.Queue = Queue;
-    __exports__.ResolvedQueueError = ResolvedQueueError;
-    __exports__.delay = delay;
-    __exports__.timeout = timeout;
-    __exports__.hash = hash;
-    __exports__.rethrow = rethrow;
-    __exports__.defer = defer;
-    __exports__.denodeify = denodeify;
-    __exports__.configure = configure;
-    __exports__.resolve = resolve;
-    __exports__.reject = reject;
-  });
-window.RSVP = requireModule("rsvp");
-})(window);
\ No newline at end of file

lib/sinon/sinon-qunit.js

-/**
- * sinon-qunit 1.0.0, 2010/12/09
- *
- * @author Christian Johansen (christian@cjohansen.no)
- *
- * (The BSD License)
- * 
- * Copyright (c) 2010-2011, Christian Johansen, christian@cjohansen.no
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- * 
- *     * Redistributions of source code must retain the above copyright notice,
- *       this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright notice,
- *       this list of conditions and the following disclaimer in the documentation
- *       and/or other materials provided with the distribution.
- *     * Neither the name of Christian Johansen nor the names of his contributors
- *       may be used to endorse or promote products derived from this software
- *       without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-/*global sinon, QUnit, test*/
-sinon.assert.fail = function (msg) {
-    QUnit.ok(false, msg);
-};
-
-sinon.assert.pass = function (assertion) {
-    QUnit.ok(true, assertion);
-};
-
-sinon.config = {
-    injectIntoThis: true,
-    injectInto: null,
-    properties: ["spy", "stub", "mock", "clock", "sandbox"],
-    useFakeTimers: true,
-    useFakeServer: false
-};
-
-(function (global) {
-    var qTest = QUnit.test;
-    
-    QUnit.test = global.test = function (testName, expected, callback, async) {
-        if (arguments.length === 2) {
-            callback = expected;
-            expected = null;
-        }
-
-        return qTest(testName, expected, sinon.test(callback), async);
-    };
-}(this));

package.json

+{
+  "name": "renderjs",
+  "version": "0.3.2",
+  "description": "RenderJs provides HTML5 gadgets",
+  "main": "dist/renderjs-latest.js",
+  "directories": {
+    "lib": "lib"
+  },
+  "dependencies": {
+    "rsvp": "git+http://git.erp5.org/repos/rsvp.js.git"
+  },
+  "devDependencies": {
+    "grunt": "~0.4.1",
+    "grunt-cli": "~0.1.11",
+    "grunt-jslint": "~1.1.x",
+    "grunt-contrib-uglify": "~0.2.x",
+    "grunt-contrib-watch": "~0.5.3",
+    "grunt-contrib-qunit": "~0.3.0",
+    "grunt-contrib-connect": "~0.5.0",
+    "grunt-contrib-copy": "~0.4.1",
+    "grunt-curl": "~1.2.1",
+    "sinon": "~1.7.3",
+    "connect-livereload": "~0.3.0",
+    "grunt-open": "~0.2.2"
+  },
+  "scripts": {
+    "test": "./node_modules/.bin/grunt test",
+    "lint": "./node_modules/.bin/grunt lint",
+    "prepublish": "./node_modules/.bin/grunt build"
+  },
+  "keywords": [
+    "component",
+    "html5"
+  ],
+  "author": "Nexedi SA",
+  "license": "LGPL 3"
+}

renderjs.js

-/*! RenderJs v0.3.1 */
-/*global RSVP, window, document, DOMParser, Channel, XMLHttpRequest, alert */
-/*jslint unparam: true, maxlen: 150 */
-"use strict";
+/*! RenderJs v0.3.2 */
 
 /*
  * DOMParser HTML extension
@@ -13,6 +10,7 @@
  */
 /*! @source https://gist.github.com/1129031 */
 (function (DOMParser) {
+  "use strict";
   var DOMParser_proto = DOMParser.prototype,
     real_parseFromString = DOMParser_proto.parseFromString;
 
@@ -23,7 +21,7 @@
       // text/html parsing is natively supported
       return;
     }
-  } catch (ex) {console.warn(ex); }
+  } catch (ignore) {}
 
   DOMParser_proto.parseFromString = function (markup, type) {
     var result, doc, doc_elt, first_elt;
@@ -52,6 +50,7 @@
  * http://www.renderjs.org/documentation
  */
 (function (document, window, RSVP, DOMParser, Channel, undefined) {
+  "use strict";
 
   var gadget_model_dict = {},
     javascript_registration_dict = {},
@@ -163,7 +162,9 @@
         gadget_instance = new Klass();
         gadget_instance.element = options.element;
         for (i = 0; i < template_node_list.length; i += 1) {
-          gadget_instance.element.appendChild(template_node_list[i].cloneNode(true));
+          gadget_instance.element.appendChild(
+            template_node_list[i].cloneNode(true)
+          );
         }
         // Load dependencies if needed
         return RSVP.all([
@@ -215,7 +216,8 @@
       iframe_loading_deferred = RSVP.defer();
 
     if (options.element === undefined) {
-      throw new Error("DOM element is required to create Iframe Gadget " + url);
+      throw new Error("DOM element is required to create Iframe Gadget " +
+                      url);
     }
 
     // Check if the element is attached to the DOM
@@ -227,7 +229,8 @@
       node = node.parentNode;
     }
     if (node === null) {
-      throw new Error("The parent element is not attached to the DOM for " + url);
+      throw new Error("The parent element is not attached to the DOM for " +
+                      url);
     }
 
     gadget_instance = new RenderJSIframeGadget();
@@ -315,7 +318,8 @@
         } else if (options.sandbox === "iframe") {
           method = privateDeclareIframeGadget;
         } else {
-          throw new Error("Unsupported sandbox options '" + options.sandbox + "'");
+          throw new Error("Unsupported sandbox options '" +
+                          options.sandbox + "'");
         }
         return method(url, options);
       })
@@ -341,8 +345,6 @@
         // Drop the current loading klass info used by selector
         // even in case of error
         gadget_loading_klass = undefined;
-        console.warn("failed to declare " + url);
-        console.warn(e);
         throw e;
       });
     loading_gadget_promise = queue;
@@ -536,7 +538,7 @@
         title: "",
         interface_list: [],
         required_css_list: [],
-        required_js_list: [],
+        required_js_list: []
       },
       i,
       element;
@@ -623,7 +625,6 @@
           root_gadget[v[0]].apply(root_gadget, v[1]).then(function (g) {
             trans.complete(g);
           }).fail(function (e) {
-            console.warn(e);
             trans.error(e.toString());
           });
           trans.delayReturn(true);
@@ -648,7 +649,7 @@
             },
             error: function () {
               declare_method_count -= 1;
-            },
+            }
           });
         };
 
@@ -660,7 +661,10 @@
 
         // Surcharge declareMethod to inform parent window
         tmp_constructor.declareMethod = function (name, callback) {
-          var result = RenderJSGadget.declareMethod.apply(this, [name, callback]);
+          var result = RenderJSGadget.declareMethod.apply(
+              this,
+              [name, callback]
+            );
           notifyDeclareMethod(name);
           return result;
         };
@@ -712,7 +716,6 @@
             }
             queue.push(resolve, function (e) {
               reject(e);
-              console.warn(e);
               throw e;
             });
             return queue;
@@ -729,7 +732,6 @@
         gadget_ready = true;
         notifyReady();
       }).fail(function (e) {
-        console.warn(e);
         embedded_channel.notify({method: "failed", params: e.toString()});
         throw e;
       });

sinon-qunit.js

-/**
- * sinon-qunit 1.0.0, 2010/12/09
- *
- * @author Gustavo Machado (@machadogj), Jose Romaniello (@jfroma)
- * Modified version of sinon-qunit from Christian Johansen
- *
- * (The BSD License)
- * 
- * Copyright (c) 2010-2011, Christian Johansen, christian@cjohansen.no
- * All rights reserved.
- * 
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- * 
- *     * Redistributions of source code must retain the above copyright notice,
- *       this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright notice,
- *       this list of conditions and the following disclaimer in the documentation
- *       and/or other materials provided with the distribution.
- *     * Neither the name of Christian Johansen nor the names of his contributors
- *       may be used to endorse or promote products derived from this software
- *       without specific prior written permission.
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-/*global sinon, QUnit, test*/
-sinon.assert.fail = function (msg) {
-    QUnit.ok(false, msg);
-};
-
-sinon.assert.pass = function (assertion) {
-    QUnit.ok(true, assertion);
-};
-
-sinon.config = {
-    injectIntoThis: true,
-    injectInto: null,
-    properties: ["spy", "stub", "mock", "clock", "sandbox"],
-    useFakeTimers: false,
-    useFakeServer: true
-};
-
-(function (global) {
-    var qModule = QUnit.module;
-    
-    var setup = function () {
-        $.extend(this, sinon.sandbox.create(sinon.config));
-    };
-
-    var teardown = function () { this.verifyAndRestore(); };
-                                                  
-    QUnit.module = global.module = function (name, lifecycle) {
-        lifecycle = lifecycle || {};
-        var newlc = {};
-        newlc.setup = function(){
-            setup.bind(this)();
-            lifecycle.setup && lifecycle.setup.bind(this)();
-        };
-        newlc.teardown = function(){
-            teardown.bind(this)();
-            lifecycle.teardown && lifecycle.teardown.bind(this)();
-        };         
-        qModule(name, newlc);          
-    };
-}(this));

test/embedded.html

@@ -5,9 +5,9 @@
     <title>Embedded page for renderJS test</title>
     <meta name="viewport" content="width=device-width, height=device-height"/>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <script src="../lib/rsvp/rsvp.js" type="text/javascript"></script>
-    <script src="../../lib/jschannel/jschannel.js" type="text/javascript"></script>
-    <script src="../renderjs.js" type="text/javascript"></script>
+    <script src="../node_modules/rsvp/dist/rsvp-2.0.4.js" type="text/javascript"></script>
+    <script src="../lib/jschannel/jschannel.js" type="text/javascript"></script>
+    <script src="../dist/renderjs-latest.js" type="text/javascript"></script>
     <script src="./embedded.js" type="text/javascript"></script>
   </head>
   <body>

test/embedded.js

-/*global window, rJS */
-"use strict";
 (function (window, rJS) {
+  "use strict";
 
   var gk = rJS(window),
     ready_called = false;

test/index.html

@@ -5,13 +5,12 @@
     <title>Test renderJS</title>
     <meta name="viewport" content="width=device-width, height=device-height"/>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-    <link rel="stylesheet" href="../lib/qunit/qunit.css" type="text/css" media="screen"/>
-    <script src="../lib/rsvp/rsvp.js" type="text/javascript"></script>
-    <script src="../lib/jquery/jquery.js" type="text/javascript"></script>
-    <script src="../lib/qunit/qunit.js" type="text/javascript"></script>
-    <script src="../lib/sinon/sinon.js" type="text/javascript"></script>
-    <script src="../../lib/jschannel/jschannel.js" type="text/javascript"></script>
-    <script src="../renderjs.js" type="text/javascript"></script>
+    <link rel="stylesheet" href="../node_modules/grunt-contrib-qunit/test/libs/qunit.css" type="text/css" media="screen"/>
+    <script src="../node_modules/rsvp/dist/rsvp-2.0.4.js" type="text/javascript"></script>
+    <script src="../node_modules/grunt-contrib-qunit/test/libs/qunit.js" type="text/javascript"></script>
+    <script src="../node_modules/sinon/pkg/sinon.js" type="text/javascript"></script>
+    <script src="../lib/jschannel/jschannel.js" type="text/javascript"></script>
+    <script src="../dist/renderjs-latest.js" type="text/javascript"></script>
     <script src="renderjs_test.js" type="text/javascript"></script>
   </head>
   <body>

test/renderjs_test.js

-/*jslint indent: 2, maxerr: 3, maxlen: 79 */
-/*global window, document, QUnit, jQuery, renderJS, RenderJSGadget, sinon,
-  RSVP, DOMParser, RenderJSIframeGadget, RenderJSEmbeddedGadget */
-/*jslint unparam: true */
-"use strict";
-
-(function (document, $, renderJS, QUnit, sinon) {
+(function (document, renderJS, QUnit, sinon) {
+  "use strict";
   var test = QUnit.test,
     stop = QUnit.stop,
     start = QUnit.start,
@@ -12,6 +7,7 @@
     equal = QUnit.equal,
     throws = QUnit.throws,
     deepEqual = QUnit.deepEqual,
+    module = QUnit.module,
     root_gadget_klass = renderJS(window),
     root_gadget_defer = RSVP.defer();
 
@@ -21,7 +17,8 @@
   });
 
 
-  QUnit.config.testTimeout = 500;
+  QUnit.config.testTimeout = 1000;
+//   QUnit.config.reorder = false;
 //   sinon.log = function (message) {
 //     console.log(message);
 //   };
@@ -47,7 +44,7 @@
       title: "",
       interface_list: [],
       required_css_list: [],
-      required_js_list: [],
+      required_js_list: []
     });
   });
 
@@ -67,7 +64,7 @@
       title: "",
       interface_list: [],
       required_css_list: [],
-      required_js_list: [],
+      required_js_list: []
     });
   });
 
@@ -104,7 +101,7 @@
 //         "<title>Great title</title>" +
 //         "</body></html>";
 // 
-//     settings = renderJS.parseGadgetHTML(html);
+//     settings = parseGadgetHTML(html);
 //     equal(settings.title, '', 'Title not found');
 //   });
 
@@ -291,7 +288,7 @@
       title: "Test non valid XML",
       interface_list: [],
       required_css_list: [],
-      required_js_list: [],
+      required_js_list: []
 //       html: "<p>Non valid XML</p>",
     });
   });
@@ -302,18 +299,22 @@
   module("renderJS.declareGadgetKlass", {
     setup: function () {
       renderJS.clearGadgetKlassList();
+      this.server = sinon.fakeServer.create();
+
+      this.server.autoRespond = true;
+      this.server.autoRespondAfter = 5;
+    },
+    teardown: function () {
+      this.server.restore();
+      delete this.server;
     }
   });
   test('Ajax error reject the promise', function () {
     // Check that declareGadgetKlass fails if ajax fails
-    var server = sinon.fakeServer.create(),
-      url = 'https://example.org/files/qunittest/test';
-
-    server.autoRespond = true;
-    server.autoRespondAfter = 5;
+    var url = 'https://example.org/files/qunittest/test';
 
-    server.respondWith("GET", url, [404, {
-      "Content-Type": "text/html",
+    this.server.respondWith("GET", url, [404, {
+      "Content-Type": "text/html"
     }, "foo"]);
 
     stop();
@@ -327,20 +328,15 @@
       })
       .always(function () {
         start();
-        server.restore();
       });
   });
 
   test('Non HTML reject the promise', function () {
     // Check that declareGadgetKlass fails if non html is retrieved
-    var server = sinon.fakeServer.create(),
-      url = 'https://example.org/files/qunittest/test';
-
-    server.autoRespond = true;
-    server.autoRespondAfter = 5;
+    var url = 'https://example.org/files/qunittest/test';
 
-    server.respondWith("GET", url, [200, {
-      "Content-Type": "text/plain",
+    this.server.respondWith("GET", url, [200, {
+      "Content-Type": "text/plain"
     }, "foo"]);
 
     stop();
@@ -354,21 +350,16 @@
       })
       .always(function () {
         start();
-        server.restore();
       });
   });
 
   test('HTML parsing failure reject the promise', function () {
     // Check that declareGadgetKlass fails if the html can not be parsed
-    var server = sinon.fakeServer.create(),
-      url = 'https://example.org/files/qunittest/test',
+    var url = 'https://example.org/files/qunittest/test',
       mock;
 
-    server.autoRespond = true;
-    server.autoRespondAfter = 5;
-
-    server.respondWith("GET", url, [200, {
-      "Content-Type": "text/html",
+    this.server.respondWith("GET", url, [200, {
+      "Content-Type": "text/html"
     }, ""]);
 
     mock = sinon.mock(renderJS, "parseGadgetHTMLDocument", function () {
@@ -388,22 +379,17 @@
         start();
         mock.verify();
         mock.restore();
-        server.restore();
       });
   });
 
   test('Klass creation', function () {
     // Check that declareGadgetKlass returns a subclass of RenderJSGadget
     // and contains all extracted properties on the prototype
-    var server = sinon.fakeServer.create(),
-      url = 'https://example.org/files/qunittest/test',
+    var url = 'https://example.org/files/qunittest/test',
       mock;
 
-    server.autoRespond = true;
-    server.autoRespondAfter = 5;
-
-    server.respondWith("GET", url, [200, {
-      "Content-Type": "text/html",
+    this.server.respondWith("GET", url, [200, {
+      "Content-Type": "text/html"
     }, "foo"]);
 
     mock = sinon.mock(renderJS, "parseGadgetHTMLDocument");
@@ -432,23 +418,18 @@
         start();
         mock.verify();
         mock.restore();
-        server.restore();
       });
   });
 
   test('Klass is not reloaded if called twice', function () {
     // Check that declareGadgetKlass does not reload the gadget
     // if it has already been loaded
-    var server = sinon.fakeServer.create(),
-      url = 'https://example.org/files/qunittest/test',
+    var url = 'https://example.org/files/qunittest/test',
       klass1,
       mock;
 
-    server.autoRespond = true;
-    server.autoRespondAfter = 5;
-
-    server.respondWith("GET", url, [200, {
-      "Content-Type": "text/html",
+    this.server.respondWith("GET", url, [200, {
+      "Content-Type": "text/html"
     }, "foo"]);
 
     mock = sinon.mock(renderJS, "parseGadgetHTMLDocument");
@@ -472,21 +453,16 @@
         start();
         mock.verify();
         mock.restore();
-        server.restore();
       });
   });
 
   test('Content type parameter are supported', function () {
     // Check that declareGadgetKlass does not fail if the page content type
     // contains a parameter
-    var server = sinon.fakeServer.create(),
-      url = 'https://example.org/files/qunittest/test';
-
-    server.autoRespond = true;
-    server.autoRespondAfter = 5;
+    var url = 'https://example.org/files/qunittest/test';
 
-    server.respondWith("GET", url, [200, {
-      "Content-Type": "text/html; charset=utf-8",
+    this.server.respondWith("GET", url, [200, {
+      "Content-Type": "text/html; charset=utf-8"
     }, "<html></html>"]);
 
     stop();
@@ -506,7 +482,6 @@
       })
       .always(function () {
         start();
-        server.restore();
       });
   });
 
@@ -542,7 +517,7 @@
 
     stop();
     renderJS.declareJS(url)
-      .always(function () {
+      .then(function () {
         return renderJS.declareJS(url);
       })
       .then(function () {
@@ -581,12 +556,16 @@
   test('JS cleanly loaded', function () {
     // Check that declareJS is fetched and loaded
     var url = "data:application/javascript;base64," +
-         window.btoa("$('#qunit-fixture').text('JS fetched and loaded');");
+         window.btoa("document.getElementById('qunit-fixture').textContent " +
+                     "= 'JS fetched and loaded';");
 
     stop();
     renderJS.declareJS(url)
       .then(function () {
-        equal($("#qunit-fixture").text(), "JS fetched and loaded");
+        equal(
+          document.getElementById("qunit-fixture").textContent,
+          "JS fetched and loaded"
+        );
       })
       .fail(function (jqXHR) {
         ok(false, "Failed to load " + jqXHR);
@@ -620,17 +599,21 @@
   test('JS is not fetched twice', function () {
     // Check that declareJS does not load the JS twice
     var url = "data:application/javascript;base64," +
-         window.btoa("$('#qunit-fixture').text('JS not fetched twice');");
+         window.btoa("document.getElementById('qunit-fixture').textContent " +
+                     "= 'JS not fetched twice';");
 
     stop();
     renderJS.declareJS(url)
       .then(function () {
-        equal($("#qunit-fixture").text(), "JS not fetched twice");
-        $("#qunit-fixture").text("");
+        equal(
+          document.getElementById("qunit-fixture").textContent,
+          "JS not fetched twice"
+        );
+        document.getElementById("qunit-fixture").textContent = "";
         return renderJS.declareJS(url);
       })
       .then(function () {
-        equal($("#qunit-fixture").text(), "");
+        equal(document.getElementById("qunit-fixture").textContent, "");
       })
       .fail(function (jqXHR) {
         ok(false, "Failed to load " + jqXHR);
@@ -695,14 +678,15 @@
     stop();
     renderJS.declareCSS(url)
       .then(function () {
-        var found = false;
-        $('head').find('link[rel=stylesheet]').each(function (i, style) {
-          if (style.href === url) {
-            found = true;
-          }
-        });
-        ok(found, "CSS in the head");
-        equal($("#qunit-fixture").css("background-color"), "rgb(255, 0, 0)");
+        var result = document.querySelectorAll("link[href='" + url + "']");
+        ok(result.length > 0, "CSS in the head");
+        equal(
+          window.getComputedStyle(
+            document.getElementById("qunit-fixture"),
+            null
+          ).backgroundColor,
+          "rgb(255, 0, 0)"
+        );
       })
       .fail(function (e) {
         ok(false, e);
@@ -740,26 +724,34 @@
     stop();
     renderJS.declareCSS(url)
       .then(function () {
-        equal($("#qunit-fixture").css("background-color"), "rgb(0, 0, 255)");
-        $('head').find('link[rel=stylesheet]').each(function (i, style) {
-          if (style.href === url) {
-            $(style).remove();
-          }
-        });
-        ok($("#qunit-fixture").css("background-color") !== "rgb(0, 0, 255)");
+        equal(
+          window.getComputedStyle(
+            document.getElementById("qunit-fixture"),
+            null
+          ).backgroundColor,
+          "rgb(0, 0, 255)"
+        );
+        var element = document.querySelectorAll("link[href='" + url + "']")[0];
+        element.parentNode.removeChild(element);
+        ok(
+          window.getComputedStyle(
+            document.getElementById("qunit-fixture"),
+            null
+          ).backgroundColor !== "rgb(0, 0, 255)"
+        );
 
         return renderJS.declareCSS(url);
       })
       .then(function () {
-        var found = false;
-        $('head').find('link[rel=stylesheet]').each(function (i, style) {
-          if (style.href === url) {
-            found = true;
-          }
-        });
-        ok($("#qunit-fixture").css("background-color") !==
-           "rgb(0, 0, 255)", $("#qunit-fixture").css("background-color"));
-        ok(!found);
+        var element_list =
+          document.querySelectorAll("link[href='" + url + "']");
+        equal(element_list.length, 0);
+        ok(
+          window.getComputedStyle(
+            document.getElementById("qunit-fixture"),
+            null
+          ).backgroundColor !== "rgb(0, 0, 255)"
+        );
       })
       .fail(function (jqXHR) {
         ok(false, "Failed to load " + jqXHR);
@@ -775,22 +767,26 @@
   module("renderJS.clearGadgetKlassList", {
     setup: function () {
       renderJS.clearGadgetKlassList();
+      this.server = sinon.fakeServer.create();
+
+      this.server.autoRespond = true;
+      this.server.autoRespondAfter = 5;
+    },
+    teardown: function () {
+      this.server.restore();
+      delete this.server;
     }
   });
 
   test('clearGadgetKlassList leads to gadget reload', function () {
     // Check that declareGadgetKlass reload the gadget
     // after clearGadgetKlassList is called
-    var server = sinon.fakeServer.create(),
-      url = 'https://example.org/files/qunittest/test',
+    var url = 'https://example.org/files/qunittest/test',
       klass1,
       mock;
 
-    server.autoRespond = true;
-    server.autoRespondAfter = 5;
-
-    server.respondWith("GET", url, [200, {
-      "Content-Type": "text/html",
+    this.server.respondWith("GET", url, [200, {
+      "Content-Type": "text/html"
     }, "foo"]);
 
     mock = sinon.mock(renderJS, "parseGadgetHTMLDocument");
@@ -815,7 +811,6 @@
       })
       .always(function () {
         start();
-        server.restore();
         mock.verify();
         mock.restore();
       });
@@ -825,18 +820,25 @@
     // Check that declareJS reload the JS
     // after clearGadgetKlassList is called
     var url = "data:application/javascript;base64," +
-         window.btoa("$('#qunit-fixture').text('JS not fetched twice');");
+         window.btoa("document.getElementById('qunit-fixture').textContent " +
+                     "= 'JS not fetched twice';");
 
     stop();
     renderJS.declareJS(url)
       .then(function () {
         renderJS.clearGadgetKlassList();
-        equal($("#qunit-fixture").text(), "JS not fetched twice");
-        $("#qunit-fixture").text("");
+        equal(
+          document.getElementById("qunit-fixture").textContent,
+          "JS not fetched twice"
+        );
+        document.getElementById("qunit-fixture").textContent = "";
         return renderJS.declareJS(url);
       })
       .then(function () {
-        equal($("#qunit-fixture").text(), "JS not fetched twice");
+        equal(
+          document.getElementById("qunit-fixture").textContent,
+          "JS not fetched twice"
+        );
       })
       .fail(function (jqXHR) {
         ok(false, "Failed to load " + jqXHR);
@@ -851,17 +853,23 @@
     // after clearGadgetKlassList is called
     var url = "data:text/css;base64," +
          window.btoa("#qunit-fixture {background-color: blue;}"),
-      count = $('head').find('link[rel=stylesheet]').length;
+      count = document.querySelectorAll("link[rel=stylesheet]").length;
 
     stop();
     renderJS.declareCSS(url)
       .then(function () {
         renderJS.clearGadgetKlassList();
-        equal($('head').find('link[rel=stylesheet]').length, count + 1);
+        equal(
+          document.querySelectorAll("link[rel=stylesheet]").length,
+          count + 1
+        );
         return renderJS.declareCSS(url);
       })
       .then(function () {
-        equal($('head').find('link[rel=stylesheet]').length, count + 2);
+        equal(
+          document.querySelectorAll("link[rel=stylesheet]").length,
+          count + 2
+        );
       })
       .fail(function (jqXHR) {
         ok(false, "Failed to load " + jqXHR);
@@ -1115,7 +1123,6 @@
         ok(false, "getElement should fail");
       })
       .fail(function (e) {
-        console.log(e);
         ok(e instanceof Error);
       })
       .always(function () {
@@ -1145,7 +1152,7 @@
     gadget = new Klass();
     equal(gadget.testFoo, undefined);
     result = Klass.declareMethod('testFoo', function () {
-      console.log("");
+      return;
     });
     // declareMethod is chainable
     equal(result, Klass);
@@ -1231,9 +1238,7 @@
 
     gadget = new Klass();
     Klass.declareMethod('testFoo', function (value) {
-      var dfr = $.Deferred();
-      dfr.reject(value);
-      return dfr.promise();
+      return RSVP.reject(value);
     });
 
     // method can be called
@@ -1271,7 +1276,7 @@
     Klass.ready = RenderJSGadget.ready;
 
     result = Klass.ready(function () {
-      console.log("");
+      return;
     });
     // ready is chainable
     equal(result, Klass);
@@ -1284,7 +1289,7 @@
     var Klass = function () {
       RenderJSGadget.call(this);
     },
-      callback = function () {console.log(""); };
+      callback = function () {return; };
     Klass.prototype = new RenderJSGadget();
     Klass.prototype.constructor = Klass;
     Klass.ready_list = [];
@@ -1383,12 +1388,19 @@
   module("RenderJSGadget.declareGadget", {
     setup: function () {
       renderJS.clearGadgetKlassList();
+      this.server = sinon.fakeServer.create();
+
+      this.server.autoRespond = true;
+      this.server.autoRespondAfter = 5;
+    },
+    teardown: function () {
+      this.server.restore();
+      delete this.server;
     }
   });
   test('returns a Promise', function () {
     // Check that declareGadget return a Promise
     var gadget = new RenderJSGadget(),
-      server = sinon.fakeServer.create(),
       url = 'https://example.org/files/qunittest/test',
       html = "<html>" +
         "<body>" +
@@ -1396,32 +1408,26 @@
         "type='text/javascript'></script>" +
         "</body></html>";
 
-    server.autoRespond = true;
-    server.autoRespondAfter = 5;
-
-    server.respondWith("GET", url, [200, {
-      "Content-Type": "text/html",
+    this.server.respondWith("GET", url, [200, {
+      "Content-Type": "text/html"
     }, html]);
 
     stop();
-    gadget.declareGadget(url)//, $('#qunit-fixture'))
+    gadget.declareGadget(url)//, document.getElementById('qunit-fixture'))
       .then(function () {
         ok(true);
       })
       .fail(function (e) {
-        console.warn(e);
         ok(false, e);
       })
       .always(function () {
         start();
-        server.restore();
       });
   });
 
   test('provide a gadget instance as callback parameter', function () {
     // Check that declare gadget returns the gadget
     var gadget = new RenderJSGadget(),
-      server = sinon.fakeServer.create(),
       url = 'https://example.org/files/qunittest/test',
       html = "<html>" +
         "<body>" +
@@ -1429,50 +1435,47 @@
         "type='text/javascript'></script>" +
         "</body></html>";
 
-    server.autoRespond = true;
-    server.autoRespondAfter = 5;
-
-    server.respondWith("GET", url, [200, {
-      "Content-Type": "text/html",
+    this.server.respondWith("GET", url, [200, {
+      "Content-Type": "text/html"
     }, html]);
 
     stop();
-    gadget.declareGadget(url)//, $('#qunit-fixture'))
+    gadget.declareGadget(url)//, document.getElementById('qunit-fixture'))
       .then(function (new_gadget) {
         equal(new_gadget.path, url);
         ok(new_gadget instanceof RenderJSGadget);
       })
       .always(function () {
         start();
-        server.restore();
       });
   });
 
-//   test('no parameter', function () {
-//     // Check that missing url reject the declaration
-//     var gadget = new RenderJSGadget();
-//     stop();
-//     gadget.declareGadget()
-//       .fail(function () {
-//         ok(true);
-//       })
-//       .always(function () {
-//         start();
-//       });
-//   });
+  test('no parameter', function () {
+    // Check that missing url reject the declaration
+    var gadget = new RenderJSGadget();
+    stop();
+    gadget.declareGadget()
+      .fail(function () {
+        ok(true);
+      })
+      .always(function () {
+        start();
+      });
+  });
 
   test('load dependency before returning gadget', function () {
     // Check that dependencies are loaded before gadget creation
     var gadget = new RenderJSGadget(),
-      server = sinon.fakeServer.create(),
       html_url = 'https://example.org/files/qunittest/test2.html',
       js1_url = "data:application/javascript;base64," +
          window.btoa(
-          "$('#qunit-fixture').find('div').first().text('youhou');"
+          "document.getElementById('qunit-fixture').getElementsByTagName" +
+            "('div')[0].textContent = 'youhou';"
         ),
       js2_url = "data:application/javascript;base64," +
          window.btoa(
-          "$('#qunit-fixture').find('div').first().text('youhou2');"
+          "document.getElementById('qunit-fixture').getElementsByTagName" +
+            "('div')[0].textContent = 'youhou2';"
         ),
       css1_url = "data:text/css;base64," +
          window.btoa(""),
@@ -1488,11 +1491,8 @@
       spy_js,
       spy_css;
 
-    server.autoRespond = true;
-    server.autoRespondAfter = 5;
-
-    server.respondWith("GET", html_url, [200, {
-      "Content-Type": "text/html",
+    this.server.respondWith("GET", html_url, [200, {
+      "Content-Type": "text/html"
     }, html]);
 
     spy_js = sinon.spy(renderJS, "declareJS");
@@ -1505,11 +1505,12 @@
 //       html: "<p>Bar content</p>",
 //     });
 
-    $('#qunit-fixture').html("<div></div><div>bar</div>");
+    document.getElementById('qunit-fixture').innerHTML =
+      "<div></div><div>bar</div>";
     stop();
     gadget.declareGadget(html_url)
       .then(function (new_gadget) {
-        equal($('#qunit-fixture').html(),
+        equal(document.getElementById('qunit-fixture').innerHTML,
               "<div>youhou2</div><div>bar</div>");
         equal(new_gadget.element.outerHTML,
               "<div><p>Bar content</p></div>");
@@ -1521,12 +1522,10 @@
         equal(spy_css.secondCall.args[0], css2_url, "Second CSS call");
       })
       .fail(function (e) {
-        console.warn(e);
         ok(false);
       })
       .always(function () {
         start();
-        server.restore();
         spy_js.restore();
         spy_css.restore();
       });
@@ -1543,18 +1542,14 @@
   test('Fail if klass can not be loaded', function () {
     // Check that gadget is not created if klass is can not be loaded
     var gadget = new RenderJSGadget(),
-      server = sinon.fakeServer.create(),
-      html_url = 'https://example.org/files/qunittest/test3.html';
+      html_url = 'http://example.org/files/qunittest/test3.html';
 
-    server.autoRespond = true;
-    server.autoRespondAfter = 5;
-
-    server.respondWith("GET", html_url, [404, {
-      "Content-Type": "text/html",
+    this.server.respondWith("GET", html_url, [404, {
+      "Content-Type": "text/html"
     }, ""]);
 
     stop();
-    gadget.declareGadget(html_url)//, $('#qunit-fixture').find("div").last())
+    gadget.declareGadget(html_url)
       .then(function (new_gadget) {
         ok(false);
       })
@@ -1563,23 +1558,18 @@
       })
       .always(function () {
         start();
-        server.restore();
       });
   });
 
   test('Fail if js can not be loaded', function () {
     // Check that dependencies are loaded before gadget creation
     var gadget = new RenderJSGadget(),
-      server = sinon.fakeServer.create(),
       html_url = 'http://example.org/files/qunittest/test5.html',
       js1_url = 'http://0.0.0.0/test.js',
       mock;
 
-    server.autoRespond = true;
-    server.autoRespondAfter = 5;
-
-    server.respondWith("GET", html_url, [200, {
-      "Content-Type": "text/html",
+    this.server.respondWith("GET", html_url, [200, {
+      "Content-Type": "text/html"
     }, "raw html"]);
 
     mock = sinon.mock(renderJS, "parseGadgetHTMLDocument");
@@ -1588,7 +1578,7 @@
     });
 
     stop();
-    gadget.declareGadget(html_url)//, $('#qunit-fixture'))
+    gadget.declareGadget(html_url)
       .then(function (new_gadget) {
         ok(false);
       })
@@ -1597,7 +1587,6 @@
       })
       .always(function () {
         start();
-        server.restore();
         mock.verify();
         mock.restore();
       });
@@ -1606,19 +1595,16 @@
   test('Do not load gadget dependency twice', function () {
     // Check that dependencies are not reloaded if 2 gadgets are created
     var gadget = new RenderJSGadget(),
-      server = sinon.fakeServer.create(),
       html_url = 'https://example.org/files/qunittest/test254.html',
       js1_url = "data:application/javascript;base64," +
          window.btoa(
-          "$('#qunit-fixture').find('div').first().append('youhou');"
+          "document.getElementById('qunit-fixture').getElementsByTagName" +
+            "('div')[0].textContent += 'youhou';"
         ),
       mock;
 
-    server.autoRespond = true;
-    server.autoRespondAfter = 5;
-
-    server.respondWith("GET", html_url, [200, {
-      "Content-Type": "text/html",
+    this.server.respondWith("GET", html_url, [200, {
+      "Content-Type": "text/html"
     }, "raw html"]);
 
     mock = sinon.mock(renderJS, "parseGadgetHTMLDocument");
@@ -1627,25 +1613,26 @@
     });
 
     stop();
-    $('#qunit-fixture').html("<div></div><div></div>");
+    document.getElementById('qunit-fixture').innerHTML =
+      "<div></div><div></div>";
     gadget.declareGadget(html_url)
-      .always(function () {
-        equal($('#qunit-fixture').html(),
+      .fail(function (e) {
+        ok(false, "1 + " + e.toString());
+      })
+      .then(function () {
+        equal(document.getElementById('qunit-fixture').innerHTML,
               "<div>youhou</div><div></div>");
-        return gadget.declareGadget(html_url);//,
-          //$('#qunit-fixture').find("div").last()[0]
-//         );
+        return gadget.declareGadget(html_url);
       })
       .then(function (new_gadget) {
-        equal($('#qunit-fixture').html(),
+        equal(document.getElementById('qunit-fixture').innerHTML,
               "<div>youhou</div><div></div>");
       })
-      .fail(function () {
-        ok(false);
+      .fail(function (e) {
+        ok(false, "2 + " + e.toString());
       })
       .always(function () {
         start();
-        server.restore();
         mock.verify();
         mock.restore();
       });
@@ -1654,15 +1641,11 @@
   test('Load 2 concurrent gadgets in parallel', function () {
     // Check that dependencies are loaded once if 2 gadgets are created
     var gadget = new RenderJSGadget(),
-      server = sinon.fakeServer.create(),
       html_url = 'https://example.org/files/qunittest/test987.html',
       mock;
 
-    server.autoRespond = true;
-    server.autoRespondAfter = 5;
-
-    server.respondWith("GET", html_url, [200, {
-      "Content-Type": "text/html",
+    this.server.respondWith("GET", html_url, [200, {
+      "Content-Type": "text/html"
     }, "raw html"]);
 
     mock = sinon.mock(renderJS, "parseGadgetHTMLDocument");
@@ -1670,8 +1653,8 @@
 
     stop();
     RSVP.all([
-      gadget.declareGadget(html_url),// $('#qunit-fixture')),
-      gadget.declareGadget(html_url)//, $('#qunit-fixture'))
+      gadget.declareGadget(html_url),
+      gadget.declareGadget(html_url)
     ])
       .then(function () {
         ok(true);
@@ -1681,7 +1664,6 @@
         start();
         mock.verify();
         mock.restore();
-        server.restore();
       });
   });
 
@@ -1690,14 +1672,10 @@
     // Subclass RenderJSGadget to not pollute its namespace
     var called = false,
       gadget = new RenderJSGadget(),
-      server = sinon.fakeServer.create(),
       html_url = 'https://example.org/files/qunittest/test98.html';
 
-    server.autoRespond = true;
-    server.autoRespondAfter = 5;
-
-    server.respondWith("GET", html_url, [200, {
-      "Content-Type": "text/html",
+    this.server.respondWith("GET", html_url, [200, {
+      "Content-Type": "text/html"
     }, "<html><body></body></html>"]);
 
     stop();
@@ -1710,18 +1688,16 @@
             called = true;
           });
         });
-        return gadget.declareGadget(html_url);//, $('#qunit-fixture')[0]);
+        return gadget.declareGadget(html_url);
       })
       .then(function () {
         ok(called);
       })
       .fail(function (e) {
-        console.warn(e);
         ok(false);
       })
       .always(function () {
         start();
-        server.restore();
       });
   });
 
@@ -1729,36 +1705,32 @@
 
     // Subclass RenderJSGadget to not pollute its namespace
     var gadget = new RenderJSGadget(),
-      server = sinon.fakeServer.create(),
       html_url = 'https://example.org/files/qunittest/test98.html';
 
-    server.autoRespond = true;
-    server.autoRespondAfter = 5;
-
-    server.respondWith("GET", html_url, [200, {
-      "Content-Type": "text/html",
+    this.server.respondWith("GET", html_url, [200, {
+      "Content-Type": "text/html"
     }, "<html><body><p>foo</p></body></html>"]);
 
-    $('#qunit-fixture').empty();
-
+    document.getElementById('qunit-fixture').textContent = "";
     stop();
     renderJS.declareGadgetKlass(html_url)
       .then(function (Klass) {
         return gadget.declareGadget(
           html_url,
-          {element: $('#qunit-fixture')[0]}
+          {element: document.getElementById('qunit-fixture')}
         );
       })
       .then(function () {
-        equal($('#qunit-fixture').html(), '<p>foo</p>');
+        equal(
+          document.getElementById('qunit-fixture').innerHTML,
+          '<p>foo</p>'
+        );
       })
       .fail(function (e) {
-        console.warn(e);
         ok(false);
       })
       .always(function () {
         start();
-        server.restore();
       });
   });
 
@@ -1768,14 +1740,10 @@
   test('Require the element options', function () {
     // Subclass RenderJSGadget to not pollute its namespace
     var gadget = new RenderJSGadget(),
-      server = sinon.fakeServer.create(),
       html_url = 'https://example.org/files/qunittest/test98.html';
 
-    server.autoRespond = true;
-    server.autoRespondAfter = 5;
-
-    server.respondWith("GET", html_url, [200, {
-      "Content-Type": "text/html",
+    this.server.respondWith("GET", html_url, [200, {
+      "Content-Type": "text/html"
     }, "<html><body><p>foo</p></body></html>"]);
 
     stop();
@@ -1795,21 +1763,16 @@
       })
       .always(function () {
         start();
-        server.restore();
       });
   });
 
   test('Require a DOM element as option', function () {
     // Subclass RenderJSGadget to not pollute its namespace
     var gadget = new RenderJSGadget(),
-      server = sinon.fakeServer.create(),
       html_url = 'https://example.org/files/qunittest/test98.html';
 
-    server.autoRespond = true;
-    server.autoRespondAfter = 5;
-
-    server.respondWith("GET", html_url, [200, {
-      "Content-Type": "text/html",
+    this.server.respondWith("GET", html_url, [200, {
+      "Content-Type": "text/html"
     }, "<html><body><p>foo</p></body></html>"]);
 
     stop();
@@ -1832,7 +1795,6 @@
       })
       .always(function () {
         start();
-        server.restore();
       });
   });
 
@@ -1841,18 +1803,18 @@
     var gadget = new RenderJSGadget(),
       url = "./embedded.html";
 
-    $('#qunit-fixture').text('');
+    document.getElementById("qunit-fixture").textContent = "";
 
     stop();
     gadget.declareGadget(url, {
       sandbox: 'iframe',
-      element: $('#qunit-fixture')[0]
+      element: document.getElementById('qunit-fixture')
     })
       .then(function (new_gadget) {
         equal(new_gadget.path, url);
         ok(new_gadget instanceof RenderJSIframeGadget);
         equal(
-          $(new_gadget.element).html(),
+          new_gadget.element.innerHTML,
           '<iframe src="' + url + '"></iframe>'
         );
         ok(new_gadget.chan !== undefined);
@@ -1867,12 +1829,10 @@
     var gadget = new RenderJSGadget(),
       url = "./embedded.html";
 
-    $('#qunit-fixture').text('');
-
     stop();
     gadget.declareGadget(url, {
       sandbox: 'iframe',
-      element: $('#qunit-fixture')[0]
+      element: document.getElementById('qunit-fixture')
     })
       .then(function (new_gadget) {
         return new RSVP.Queue()
@@ -1928,22 +1888,21 @@
 
   test('Check that the root gadget is cleanly implemented', function () {
     stop();
-    console.log(root_gadget_klass);
     root_gadget_defer.promise
       .then(function (root_gadget) {
         // Check instance
         equal(root_gadget.path, window.location.href);
         equal(root_gadget.title, document.title);
         deepEqual(root_gadget.interface_list, []);
-        deepEqual(root_gadget.required_css_list, ["../lib/qunit/qunit.css"]);
+        deepEqual(root_gadget.required_css_list,
+                  ["../node_modules/grunt-contrib-qunit/test/libs/qunit.css"]);
         deepEqual(root_gadget.required_js_list, [
-          "../lib/rsvp/rsvp.js",
-          "../lib/jquery/jquery.js",
-          "../lib/qunit/qunit.js",
-          "../lib/sinon/sinon.js",
-          "../../lib/jschannel/jschannel.js",
-          "../renderjs.js",
-          "renderjs_test.js",
+          "../node_modules/rsvp/dist/rsvp-2.0.4.js",
+          "../node_modules/grunt-contrib-qunit/test/libs/qunit.js",
+          "../node_modules/sinon/pkg/sinon.js",
+          "../lib/jschannel/jschannel.js",
+          "../dist/renderjs-latest.js",
+          "renderjs_test.js"
         ]);
         equal(root_gadget.element.outerHTML, document.body.outerHTML);
         // Check klass
@@ -1951,18 +1910,19 @@
         equal(root_gadget.constructor.prototype.title, document.title);
         deepEqual(root_gadget.constructor.prototype.interface_list, []);
         deepEqual(root_gadget.constructor.prototype.required_css_list,
-                  ["../lib/qunit/qunit.css"]);
+                  ["../node_modules/grunt-contrib-qunit/test/libs/qunit.css"]);
         deepEqual(root_gadget.constructor.prototype.required_js_list, [
-          "../lib/rsvp/rsvp.js",
-          "../lib/jquery/jquery.js",
-          "../lib/qunit/qunit.js",
-          "../lib/sinon/sinon.js",
-          "../../lib/jschannel/jschannel.js",
-          "../renderjs.js",
-          "renderjs_test.js",
+          "../node_modules/rsvp/dist/rsvp-2.0.4.js",
+          "../node_modules/grunt-contrib-qunit/test/libs/qunit.js",
+          "../node_modules/sinon/pkg/sinon.js",
+          "../lib/jschannel/jschannel.js",
+          "../dist/renderjs-latest.js",
+          "renderjs_test.js"
         ]);
         var html = root_gadget.constructor.template_element.outerHTML;
         ok(/^<div>\s*<h1 id="qunit-header">/.test(html), html);
+        ok(root_gadget instanceof RenderJSGadget);
+        ok(root_gadget_klass, root_gadget.constructor);
       })
       .fail(function (e) {
         ok(false, e);
@@ -1972,4 +1932,4 @@
       });
   });
 
-}(document, jQuery, renderJS, QUnit, sinon));
+}(document, renderJS, QUnit, sinon));