(function() {
  chai.should();

  describe("Dropzone", function() {
    var getMockFile, xhr;
    getMockFile = function() {
      return {
        name: "test file name",
        size: 123456,
        type: "text/html"
      };
    };
    xhr = null;
    beforeEach(function() {
      return xhr = sinon.useFakeXMLHttpRequest();
    });
    describe("static functions", function() {
      describe("Dropzone.createElement()", function() {
        var element;
        element = Dropzone.createElement("<div class=\"test\"><span>Hallo</span></div>");
        it("should properly create an element from a string", function() {
          return element.tagName.should.equal("DIV");
        });
        it("should properly add the correct class", function() {
          return element.classList.contains("test").should.be.ok;
        });
        it("should properly create child elements", function() {
          return element.querySelector("span").tagName.should.equal("SPAN");
        });
        return it("should always return only one element", function() {
          element = Dropzone.createElement("<div></div><span></span>");
          return element.tagName.should.equal("DIV");
        });
      });
      describe("Dropzone.elementInside()", function() {
        var child1, child2, element;
        element = Dropzone.createElement("<div id=\"test\"><div class=\"child1\"><div class=\"child2\"></div></div></div>");
        document.body.appendChild(element);
        child1 = element.querySelector(".child1");
        child2 = element.querySelector(".child2");
        after(function() {
          return document.body.removeChild(element);
        });
        it("should return yes if elements are the same", function() {
          return Dropzone.elementInside(element, element).should.be.ok;
        });
        it("should return yes if element is direct child", function() {
          return Dropzone.elementInside(child1, element).should.be.ok;
        });
        it("should return yes if element is some child", function() {
          Dropzone.elementInside(child2, element).should.be.ok;
          return Dropzone.elementInside(child2, document.body).should.be.ok;
        });
        return it("should return no unless element is some child", function() {
          Dropzone.elementInside(element, child1).should.not.be.ok;
          return Dropzone.elementInside(document.body, child1).should.not.be.ok;
        });
      });
      describe("Dropzone.optionsForElement()", function() {
        var element, testOptions;
        testOptions = {
          url: "/some/url",
          method: "put"
        };
        before(function() {
          return Dropzone.options.testElement = testOptions;
        });
        after(function() {
          return delete Dropzone.options.testElement;
        });
        element = document.createElement("div");
        it("should take options set in Dropzone.options from camelized id", function() {
          element.id = "test-element";
          return Dropzone.optionsForElement(element).should.equal(testOptions);
        });
        return it("should return undefined if no options set", function() {
          element.id = "test-element2";
          return expect(Dropzone.optionsForElement(element)).to.equal(void 0);
        });
      });
      describe("Dropzone.forElement()", function() {
        var dropzone, element;
        element = document.createElement("div");
        element.id = "some-test-element";
        dropzone = null;
        before(function() {
          document.body.appendChild(element);
          return dropzone = new Dropzone(element, {
            url: "/test"
          });
        });
        after(function() {
          dropzone.disable();
          return document.body.removeChild(element);
        });
        it("should throw an exception if no dropzone attached", function() {
          return expect(function() {
            return Dropzone.forElement(document.createElement("div"));
          }).to["throw"]("No Dropzone found for given element. This is probably because you're trying to access it before Dropzone had the time to initialize. Use the `init` option to setup any additional observers on your Dropzone.");
        });
        it("should accept css selectors", function() {
          return expect(Dropzone.forElement("#some-test-element")).to.equal(dropzone);
        });
        return it("should accept native elements", function() {
          return expect(Dropzone.forElement(element)).to.equal(dropzone);
        });
      });
      describe("Dropzone.discover()", function() {
        var element1, element2, element3;
        element1 = document.createElement("div");
        element1.className = "dropzone";
        element2 = element1.cloneNode();
        element3 = element1.cloneNode();
        element1.id = "test-element-1";
        element2.id = "test-element-2";
        element3.id = "test-element-3";
        describe("specific options", function() {
          before(function() {
            Dropzone.options.testElement1 = {
              url: "test-url"
            };
            Dropzone.options.testElement2 = false;
            document.body.appendChild(element1);
            document.body.appendChild(element2);
            return Dropzone.discover();
          });
          after(function() {
            document.body.removeChild(element1);
            return document.body.removeChild(element2);
          });
          it("should find elements with a .dropzone class", function() {
            return element1.dropzone.should.be.ok;
          });
          return it("should not create dropzones with disabled options", function() {
            return expect(element2.dropzone).to.not.be.ok;
          });
        });
        return describe("Dropzone.autoDiscover", function() {
          before(function() {
            Dropzone.options.testElement3 = {
              url: "test-url"
            };
            return document.body.appendChild(element3);
          });
          after(function() {
            return document.body.removeChild(element3);
          });
          it("should create dropzones even if Dropzone.autoDiscover == false", function() {
            Dropzone.autoDiscover = false;
            Dropzone.discover();
            return expect(element3.dropzone).to.be.ok;
          });
          return it("should not automatically be called if Dropzone.autoDiscover == false", function() {
            Dropzone.autoDiscover = false;
            Dropzone.discover = function() {
              return expect(false).to.be.ok;
            };
            return Dropzone._autoDiscoverFunction();
          });
        });
      });
      describe("Dropzone.isValidFile()", function() {
        it("should return true if called without acceptedFiles", function() {
          return Dropzone.isValidFile({
            type: "some/type"
          }, null).should.be.ok;
        });
        it("should properly validate if called with concrete mime types", function() {
          var acceptedMimeTypes;
          acceptedMimeTypes = "text/html,image/jpeg,application/json";
          Dropzone.isValidFile({
            type: "text/html"
          }, acceptedMimeTypes).should.be.ok;
          Dropzone.isValidFile({
            type: "image/jpeg"
          }, acceptedMimeTypes).should.be.ok;
          Dropzone.isValidFile({
            type: "application/json"
          }, acceptedMimeTypes).should.be.ok;
          return Dropzone.isValidFile({
            type: "image/bmp"
          }, acceptedMimeTypes).should.not.be.ok;
        });
        it("should properly validate if called with base mime types", function() {
          var acceptedMimeTypes;
          acceptedMimeTypes = "text/*,image/*,application/*";
          Dropzone.isValidFile({
            type: "text/html"
          }, acceptedMimeTypes).should.be.ok;
          Dropzone.isValidFile({
            type: "image/jpeg"
          }, acceptedMimeTypes).should.be.ok;
          Dropzone.isValidFile({
            type: "application/json"
          }, acceptedMimeTypes).should.be.ok;
          Dropzone.isValidFile({
            type: "image/bmp"
          }, acceptedMimeTypes).should.be.ok;
          return Dropzone.isValidFile({
            type: "some/type"
          }, acceptedMimeTypes).should.not.be.ok;
        });
        it("should properly validate if called with mixed mime types", function() {
          var acceptedMimeTypes;
          acceptedMimeTypes = "text/*,image/jpeg,application/*";
          Dropzone.isValidFile({
            type: "text/html"
          }, acceptedMimeTypes).should.be.ok;
          Dropzone.isValidFile({
            type: "image/jpeg"
          }, acceptedMimeTypes).should.be.ok;
          Dropzone.isValidFile({
            type: "image/bmp"
          }, acceptedMimeTypes).should.not.be.ok;
          Dropzone.isValidFile({
            type: "application/json"
          }, acceptedMimeTypes).should.be.ok;
          return Dropzone.isValidFile({
            type: "some/type"
          }, acceptedMimeTypes).should.not.be.ok;
        });
        it("should properly validate even with spaces in between", function() {
          var acceptedMimeTypes;
          acceptedMimeTypes = "text/html ,   image/jpeg, application/json";
          Dropzone.isValidFile({
            type: "text/html"
          }, acceptedMimeTypes).should.be.ok;
          return Dropzone.isValidFile({
            type: "image/jpeg"
          }, acceptedMimeTypes).should.be.ok;
        });
        return it("should properly validate extensions", function() {
          var acceptedMimeTypes;
          acceptedMimeTypes = "text/html ,    image/jpeg, .pdf  ,.png";
          Dropzone.isValidFile({
            name: "somxsfsd",
            type: "text/html"
          }, acceptedMimeTypes).should.be.ok;
          Dropzone.isValidFile({
            name: "somesdfsdf",
            type: "image/jpeg"
          }, acceptedMimeTypes).should.be.ok;
          Dropzone.isValidFile({
            name: "somesdfadfadf",
            type: "application/json"
          }, acceptedMimeTypes).should.not.be.ok;
          Dropzone.isValidFile({
            name: "some-file file.pdf",
            type: "random/type"
          }, acceptedMimeTypes).should.be.ok;
          Dropzone.isValidFile({
            name: "some-file.pdf file.gif",
            type: "random/type"
          }, acceptedMimeTypes).should.not.be.ok;
          return Dropzone.isValidFile({
            name: "some-file file.png",
            type: "random/type"
          }, acceptedMimeTypes).should.be.ok;
        });
      });
      return describe("Dropzone.confirm", function() {
        beforeEach(function() {
          return sinon.stub(window, "confirm");
        });
        afterEach(function() {
          return window.confirm.restore();
        });
        it("should forward to window.confirm and call the callbacks accordingly", function() {
          var accepted, rejected;
          accepted = rejected = false;
          window.confirm.returns(true);
          Dropzone.confirm("test question", (function() {
            return accepted = true;
          }), (function() {
            return rejected = true;
          }));
          window.confirm.args[0][0].should.equal("test question");
          accepted.should.equal(true);
          rejected.should.equal(false);
          accepted = rejected = false;
          window.confirm.returns(false);
          Dropzone.confirm("test question 2", (function() {
            return accepted = true;
          }), (function() {
            return rejected = true;
          }));
          window.confirm.args[1][0].should.equal("test question 2");
          accepted.should.equal(false);
          return rejected.should.equal(true);
        });
        return it("should not error if rejected is not provided", function() {
          var accepted, rejected;
          accepted = rejected = false;
          window.confirm.returns(false);
          Dropzone.confirm("test question", (function() {
            return accepted = true;
          }));
          window.confirm.args[0][0].should.equal("test question");
          accepted.should.equal(false);
          return rejected.should.equal(false);
        });
      });
    });
    describe("Dropzone.getElement() / getElements()", function() {
      var tmpElements;
      tmpElements = [];
      beforeEach(function() {
        tmpElements = [];
        tmpElements.push(Dropzone.createElement("<div class=\"tmptest\"></div>"));
        tmpElements.push(Dropzone.createElement("<div id=\"tmptest1\" class=\"random\"></div>"));
        tmpElements.push(Dropzone.createElement("<div class=\"random div\"></div>"));
        return tmpElements.forEach(function(el) {
          return document.body.appendChild(el);
        });
      });
      afterEach(function() {
        return tmpElements.forEach(function(el) {
          return document.body.removeChild(el);
        });
      });
      describe(".getElement()", function() {
        it("should accept a string", function() {
          var el;
          el = Dropzone.getElement(".tmptest");
          el.should.equal(tmpElements[0]);
          el = Dropzone.getElement("#tmptest1");
          return el.should.equal(tmpElements[1]);
        });
        it("should accept a node", function() {
          var el;
          el = Dropzone.getElement(tmpElements[2]);
          return el.should.equal(tmpElements[2]);
        });
        return it("should fail if invalid selector", function() {
          var errorMessage;
          errorMessage = "Invalid `clickable` option provided. Please provide a CSS selector or a plain HTML element.";
          expect(function() {
            return Dropzone.getElement("lblasdlfsfl", "clickable");
          }).to["throw"](errorMessage);
          expect(function() {
            return Dropzone.getElement({
              "lblasdlfsfl": "lblasdlfsfl"
            }, "clickable");
          }).to["throw"](errorMessage);
          return expect(function() {
            return Dropzone.getElement(["lblasdlfsfl"], "clickable");
          }).to["throw"](errorMessage);
        });
      });
      return describe(".getElements()", function() {
        it("should accept a list of strings", function() {
          var els;
          els = Dropzone.getElements([".tmptest", "#tmptest1"]);
          return els.should.eql([tmpElements[0], tmpElements[1]]);
        });
        it("should accept a list of nodes", function() {
          var els;
          els = Dropzone.getElements([tmpElements[0], tmpElements[2]]);
          return els.should.eql([tmpElements[0], tmpElements[2]]);
        });
        it("should accept a mixed list", function() {
          var els;
          els = Dropzone.getElements(["#tmptest1", tmpElements[2]]);
          return els.should.eql([tmpElements[1], tmpElements[2]]);
        });
        it("should accept a string selector", function() {
          var els;
          els = Dropzone.getElements(".random");
          return els.should.eql([tmpElements[1], tmpElements[2]]);
        });
        it("should accept a single node", function() {
          var els;
          els = Dropzone.getElements(tmpElements[1]);
          return els.should.eql([tmpElements[1]]);
        });
        return it("should fail if invalid selector", function() {
          var errorMessage;
          errorMessage = "Invalid `clickable` option provided. Please provide a CSS selector, a plain HTML element or a list of those.";
          expect(function() {
            return Dropzone.getElements("lblasdlfsfl", "clickable");
          }).to["throw"](errorMessage);
          return expect(function() {
            return Dropzone.getElements(["lblasdlfsfl"], "clickable");
          }).to["throw"](errorMessage);
        });
      });
    });
    describe("constructor()", function() {
      var dropzone;
      dropzone = null;
      afterEach(function() {
        if (dropzone != null) {
          return dropzone.destroy();
        }
      });
      it("should throw an exception if the element is invalid", function() {
        return expect(function() {
          return dropzone = new Dropzone("#invalid-element");
        }).to["throw"]("Invalid dropzone element.");
      });
      it("should throw an exception if assigned twice to the same element", function() {
        var element;
        element = document.createElement("div");
        dropzone = new Dropzone(element, {
          url: "url"
        });
        return expect(function() {
          return new Dropzone(element, {
            url: "url"
          });
        }).to["throw"]("Dropzone already attached.");
      });
      it("should throw an exception if both acceptedFiles and acceptedMimeTypes are specified", function() {
        var element;
        element = document.createElement("div");
        return expect(function() {
          return dropzone = new Dropzone(element, {
            url: "test",
            acceptedFiles: "param",
            acceptedMimeTypes: "types"
          });
        }).to["throw"]("You can't provide both 'acceptedFiles' and 'acceptedMimeTypes'. 'acceptedMimeTypes' is deprecated.");
      });
      it("should set itself as element.dropzone", function() {
        var element;
        element = document.createElement("div");
        dropzone = new Dropzone(element, {
          url: "url"
        });
        return element.dropzone.should.equal(dropzone);
      });
      it("should use the action attribute not the element with the name action", function() {
        var element;
        element = Dropzone.createElement("<form action=\"real-action\"><input type=\"hidden\" name=\"action\" value=\"wrong-action\" /></form>");
        dropzone = new Dropzone(element);
        return dropzone.options.url.should.equal("real-action");
      });
      return describe("options", function() {
        var element, element2;
        element = null;
        element2 = null;
        beforeEach(function() {
          element = document.createElement("div");
          element.id = "test-element";
          element2 = document.createElement("div");
          element2.id = "test-element2";
          return Dropzone.options.testElement = {
            url: "/some/url",
            parallelUploads: 10
          };
        });
        afterEach(function() {
          return delete Dropzone.options.testElement;
        });
        it("should take the options set in Dropzone.options", function() {
          dropzone = new Dropzone(element);
          dropzone.options.url.should.equal("/some/url");
          return dropzone.options.parallelUploads.should.equal(10);
        });
        it("should prefer passed options over Dropzone.options", function() {
          dropzone = new Dropzone(element, {
            url: "/some/other/url"
          });
          return dropzone.options.url.should.equal("/some/other/url");
        });
        it("should take the default options if nothing set in Dropzone.options", function() {
          dropzone = new Dropzone(element2, {
            url: "/some/url"
          });
          return dropzone.options.parallelUploads.should.equal(2);
        });
        it("should call the fallback function if forceFallback == true", function(done) {
          return dropzone = new Dropzone(element, {
            url: "/some/other/url",
            forceFallback: true,
            fallback: function() {
              return done();
            }
          });
        });
        it("should set acceptedFiles if deprecated acceptedMimetypes option has been passed", function() {
          dropzone = new Dropzone(element, {
            url: "/some/other/url",
            acceptedMimeTypes: "my/type"
          });
          return dropzone.options.acceptedFiles.should.equal("my/type");
        });
        return describe("options.clickable", function() {
          var clickableElement;
          clickableElement = null;
          dropzone = null;
          beforeEach(function() {
            clickableElement = document.createElement("div");
            clickableElement.className = "some-clickable";
            return document.body.appendChild(clickableElement);
          });
          afterEach(function() {
            document.body.removeChild(clickableElement);
            if (dropzone != null) {
              return dropzone.destroy;
            }
          });
          it("should use the default element if clickable == true", function() {
            dropzone = new Dropzone(element, {
              clickable: true
            });
            return dropzone.clickableElements.should.eql([dropzone.element]);
          });
          it("should lookup the element if clickable is a CSS selector", function() {
            dropzone = new Dropzone(element, {
              clickable: ".some-clickable"
            });
            return dropzone.clickableElements.should.eql([clickableElement]);
          });
          it("should simply use the provided element", function() {
            dropzone = new Dropzone(element, {
              clickable: clickableElement
            });
            return dropzone.clickableElements.should.eql([clickableElement]);
          });
          it("should accept multiple clickable elements", function() {
            dropzone = new Dropzone(element, {
              clickable: [document.body, ".some-clickable"]
            });
            return dropzone.clickableElements.should.eql([document.body, clickableElement]);
          });
          return it("should throw an exception if the element is invalid", function() {
            return expect(function() {
              return dropzone = new Dropzone(element, {
                clickable: ".some-invalid-clickable"
              });
            }).to["throw"]("Invalid `clickable` option provided. Please provide a CSS selector, a plain HTML element or a list of those.");
          });
        });
      });
    });
    describe("init()", function() {
      describe("clickable", function() {
        var dropzone, dropzones, name, _results;
        dropzones = {
          "using acceptedFiles": new Dropzone(Dropzone.createElement("<form action=\"/\"></form>"), {
            clickable: true,
            acceptedFiles: "audio/*,video/*"
          }),
          "using acceptedMimeTypes": new Dropzone(Dropzone.createElement("<form action=\"/\"></form>"), {
            clickable: true,
            acceptedMimeTypes: "audio/*,video/*"
          })
        };
        it("should not add an accept attribute if no acceptParameter", function() {
          var dropzone;
          dropzone = new Dropzone(Dropzone.createElement("<form action=\"/\"></form>"), {
            clickable: true,
            acceptParameter: null,
            acceptedMimeTypes: null
          });
          return dropzone.hiddenFileInput.hasAttribute("accept").should.be["false"];
        });
        _results = [];
        for (name in dropzones) {
          dropzone = dropzones[name];
          _results.push(describe(name, function() {
            return (function(dropzone) {
              it("should create a hidden file input if clickable", function() {
                dropzone.hiddenFileInput.should.be.ok;
                return dropzone.hiddenFileInput.tagName.should.equal("INPUT");
              });
              it("should use the acceptParameter", function() {
                return dropzone.hiddenFileInput.getAttribute("accept").should.equal("audio/*,video/*");
              });
              return it("should create a new input element when something is selected to reset the input field", function() {
                var event, hiddenFileInput, i, _i, _results1;
                _results1 = [];
                for (i = _i = 0; _i <= 3; i = ++_i) {
                  hiddenFileInput = dropzone.hiddenFileInput;
                  event = document.createEvent("HTMLEvents");
                  event.initEvent("change", true, true);
                  hiddenFileInput.dispatchEvent(event);
                  dropzone.hiddenFileInput.should.not.equal(hiddenFileInput);
                  _results1.push(Dropzone.elementInside(hiddenFileInput, document).should.not.be.ok);
                }
                return _results1;
              });
            })(dropzone);
          }));
        }
        return _results;
      });
      it("should create a .dz-message element", function() {
        var dropzone, element;
        element = Dropzone.createElement("<form class=\"dropzone\" action=\"/\"></form>");
        dropzone = new Dropzone(element, {
          clickable: true,
          acceptParameter: null,
          acceptedMimeTypes: null
        });
        return element.querySelector(".dz-message").should.be["instanceof"](Element);
      });
      return it("should not create a .dz-message element if there already is one", function() {
        var dropzone, element, msg;
        element = Dropzone.createElement("<form class=\"dropzone\" action=\"/\"></form>");
        msg = Dropzone.createElement("<div class=\"dz-message\">TEST</div>");
        element.appendChild(msg);
        dropzone = new Dropzone(element, {
          clickable: true,
          acceptParameter: null,
          acceptedMimeTypes: null
        });
        element.querySelector(".dz-message").should.equal(msg);
        return element.querySelectorAll(".dz-message").length.should.equal(1);
      });
    });
    describe("options", function() {
      var dropzone, element;
      element = null;
      dropzone = null;
      beforeEach(function() {
        element = Dropzone.createElement("<div></div>");
        return dropzone = new Dropzone(element, {
          maxFilesize: 4,
          url: "url",
          acceptedMimeTypes: "audio/*,image/png",
          maxFiles: 3
        });
      });
      return describe("file specific", function() {
        var file;
        file = null;
        beforeEach(function() {
          file = {
            name: "test name",
            size: 2 * 1000 * 1000
          };
          return dropzone.options.addedfile.call(dropzone, file);
        });
        describe(".addedFile()", function() {
          return it("should properly create the previewElement", function() {
            file.previewElement.should.be["instanceof"](Element);
            file.previewElement.querySelector("[data-dz-name]").innerHTML.should.eql("test name");
            return file.previewElement.querySelector("[data-dz-size]").innerHTML.should.eql("<strong>2</strong> MB");
          });
        });
        describe(".error()", function() {
          return it("should properly insert the error", function() {
            dropzone.options.error.call(dropzone, file, "test message");
            return file.previewElement.querySelector("[data-dz-errormessage]").innerHTML.should.eql("test message");
          });
        });
        describe(".thumbnail()", function() {
          return it("should properly insert the error", function() {
            var thumbnail, transparentGif;
            transparentGif = "data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==";
            dropzone.options.thumbnail.call(dropzone, file, transparentGif);
            thumbnail = file.previewElement.querySelector("[data-dz-thumbnail]");
            thumbnail.src.should.eql(transparentGif);
            return thumbnail.alt.should.eql("test name");
          });
        });
        return describe(".uploadprogress()", function() {
          return it("should properly set the width", function() {
            dropzone.options.uploadprogress.call(dropzone, file, 0);
            file.previewElement.querySelector("[data-dz-uploadprogress]").style.width.should.eql("0%");
            dropzone.options.uploadprogress.call(dropzone, file, 80);
            file.previewElement.querySelector("[data-dz-uploadprogress]").style.width.should.eql("80%");
            dropzone.options.uploadprogress.call(dropzone, file, 90);
            file.previewElement.querySelector("[data-dz-uploadprogress]").style.width.should.eql("90%");
            dropzone.options.uploadprogress.call(dropzone, file, 100);
            return file.previewElement.querySelector("[data-dz-uploadprogress]").style.width.should.eql("100%");
          });
        });
      });
    });
    describe("instance", function() {
      var dropzone, element, requests;
      element = null;
      dropzone = null;
      requests = null;
      beforeEach(function() {
        requests = [];
        xhr.onCreate = function(xhr) {
          return requests.push(xhr);
        };
        element = Dropzone.createElement("<div></div>");
        document.body.appendChild(element);
        return dropzone = new Dropzone(element, {
          maxFilesize: 4,
          maxFiles: 100,
          url: "url",
          acceptedMimeTypes: "audio/*,image/png",
          uploadprogress: function() {}
        });
      });
      afterEach(function() {
        document.body.removeChild(element);
        dropzone.destroy();
        return xhr.restore();
      });
      describe(".accept()", function() {
        it("should pass if the filesize is OK", function() {
          return dropzone.accept({
            size: 2 * 1024 * 1024,
            type: "audio/mp3"
          }, function(err) {
            return expect(err).to.be.undefined;
          });
        });
        it("shouldn't pass if the filesize is too big", function() {
          return dropzone.accept({
            size: 10 * 1024 * 1024,
            type: "audio/mp3"
          }, function(err) {
            return err.should.eql("File is too big (10MB). Max filesize: 4MB.");
          });
        });
        it("should properly accept files which mime types are listed in acceptedFiles", function() {
          dropzone.accept({
            type: "audio/mp3"
          }, function(err) {
            return expect(err).to.be.undefined;
          });
          dropzone.accept({
            type: "image/png"
          }, function(err) {
            return expect(err).to.be.undefined;
          });
          return dropzone.accept({
            type: "audio/wav"
          }, function(err) {
            return expect(err).to.be.undefined;
          });
        });
        it("should properly reject files when the mime type isn't listed in acceptedFiles", function() {
          return dropzone.accept({
            type: "image/jpeg"
          }, function(err) {
            return err.should.eql("You can't upload files of this type.");
          });
        });
        return it("should fail if maxFiles has been exceeded and call the event maxfilesexceeded", function() {
          var called, file;
          sinon.stub(dropzone, "getAcceptedFiles");
          file = {
            type: "audio/mp3"
          };
          dropzone.getAcceptedFiles.returns({
            length: 99
          });
          called = false;
          dropzone.on("maxfilesexceeded", function(lfile) {
            lfile.should.equal(file);
            return called = true;
          });
          dropzone.accept(file, function(err) {
            return expect(err).to.be.undefined;
          });
          called.should.not.be.ok;
          dropzone.getAcceptedFiles.returns({
            length: 100
          });
          dropzone.accept(file, function(err) {
            return expect(err).to.equal("You can only upload 100 files.");
          });
          called.should.be.ok;
          return dropzone.getAcceptedFiles.restore();
        });
      });
      describe(".removeFile()", function() {
        return it("should abort uploading if file is currently being uploaded", function(done) {
          var mockFile;
          mockFile = getMockFile();
          dropzone.uploadFile = function(file) {};
          dropzone.accept = function(file, done) {
            return done();
          };
          sinon.stub(dropzone, "cancelUpload");
          dropzone.addFile(mockFile);
          return setTimeout(function() {
            mockFile.status.should.equal(Dropzone.UPLOADING);
            dropzone.getUploadingFiles()[0].should.equal(mockFile);
            dropzone.cancelUpload.callCount.should.equal(0);
            dropzone.removeFile(mockFile);
            dropzone.cancelUpload.callCount.should.equal(1);
            return done();
          }, 10);
        });
      });
      describe(".cancelUpload()", function() {
        it("should properly cancel upload if file currently uploading", function(done) {
          var mockFile;
          mockFile = getMockFile();
          dropzone.accept = function(file, done) {
            return done();
          };
          dropzone.addFile(mockFile);
          return setTimeout(function() {
            mockFile.status.should.equal(Dropzone.UPLOADING);
            dropzone.getUploadingFiles()[0].should.equal(mockFile);
            dropzone.cancelUpload(mockFile);
            mockFile.status.should.equal(Dropzone.CANCELED);
            dropzone.getUploadingFiles().length.should.equal(0);
            dropzone.getQueuedFiles().length.should.equal(0);
            return done();
          }, 10);
        });
        it("should properly cancel the upload if file is not yet uploading", function() {
          var mockFile;
          mockFile = getMockFile();
          dropzone.accept = function(file, done) {
            return done();
          };
          dropzone.options.parallelUploads = 0;
          dropzone.addFile(mockFile);
          mockFile.status.should.equal(Dropzone.QUEUED);
          dropzone.getQueuedFiles()[0].should.equal(mockFile);
          dropzone.cancelUpload(mockFile);
          mockFile.status.should.equal(Dropzone.CANCELED);
          dropzone.getQueuedFiles().length.should.equal(0);
          return dropzone.getUploadingFiles().length.should.equal(0);
        });
        it("should call processQueue()", function(done) {
          var mockFile;
          mockFile = getMockFile();
          dropzone.accept = function(file, done) {
            return done();
          };
          dropzone.options.parallelUploads = 0;
          sinon.spy(dropzone, "processQueue");
          dropzone.addFile(mockFile);
          return setTimeout(function() {
            dropzone.processQueue.callCount.should.equal(1);
            dropzone.cancelUpload(mockFile);
            dropzone.processQueue.callCount.should.equal(2);
            return done();
          }, 10);
        });
        return it("should properly cancel all files with the same XHR if uploadMultiple is true", function(done) {
          var mock1, mock2, mock3;
          mock1 = getMockFile();
          mock2 = getMockFile();
          mock3 = getMockFile();
          dropzone.accept = function(file, done) {
            return done();
          };
          dropzone.options.uploadMultiple = true;
          dropzone.options.parallelUploads = 3;
          sinon.spy(dropzone, "processFiles");
          dropzone.addFile(mock1);
          dropzone.addFile(mock2);
          dropzone.addFile(mock3);
          return setTimeout(function() {
            var _ref;
            dropzone.processFiles.callCount.should.equal(1);
            sinon.spy(mock1.xhr, "abort");
            dropzone.cancelUpload(mock1);
            expect((mock1.xhr === (_ref = mock2.xhr) && _ref === mock3.xhr)).to.be.ok;
            mock1.status.should.equal(Dropzone.CANCELED);
            mock2.status.should.equal(Dropzone.CANCELED);
            mock3.status.should.equal(Dropzone.CANCELED);
            mock1.xhr.abort.callCount.should.equal(1);
            return done();
          }, 10);
        });
      });
      describe(".disable()", function() {
        return it("should properly cancel all pending uploads", function(done) {
          dropzone.accept = function(file, done) {
            return done();
          };
          dropzone.options.parallelUploads = 1;
          dropzone.addFile(getMockFile());
          dropzone.addFile(getMockFile());
          return setTimeout(function() {
            dropzone.getUploadingFiles().length.should.equal(1);
            dropzone.getQueuedFiles().length.should.equal(1);
            dropzone.files.length.should.equal(2);
            sinon.spy(requests[0], "abort");
            requests[0].abort.callCount.should.equal(0);
            dropzone.disable();
            requests[0].abort.callCount.should.equal(1);
            dropzone.getUploadingFiles().length.should.equal(0);
            dropzone.getQueuedFiles().length.should.equal(0);
            dropzone.files.length.should.equal(2);
            dropzone.files[0].status.should.equal(Dropzone.CANCELED);
            dropzone.files[1].status.should.equal(Dropzone.CANCELED);
            return done();
          }, 10);
        });
      });
      describe(".destroy()", function() {
        it("should properly cancel all pending uploads and remove all file references", function(done) {
          dropzone.accept = function(file, done) {
            return done();
          };
          dropzone.options.parallelUploads = 1;
          dropzone.addFile(getMockFile());
          dropzone.addFile(getMockFile());
          return setTimeout(function() {
            dropzone.getUploadingFiles().length.should.equal(1);
            dropzone.getQueuedFiles().length.should.equal(1);
            dropzone.files.length.should.equal(2);
            sinon.spy(dropzone, "disable");
            dropzone.destroy();
            dropzone.disable.callCount.should.equal(1);
            element.should.not.have.property("dropzone");
            return done();
          }, 10);
        });
        return it("should be able to create instance of dropzone on the same element after destroy", function() {
          dropzone.destroy();
          return (function() {
            return new Dropzone(element, {
              maxFilesize: 4,
              url: "url",
              acceptedMimeTypes: "audio/*,image/png",
              uploadprogress: function() {}
            });
          }).should.not["throw"](Error);
        });
      });
      describe(".filesize()", function() {
        return it("should convert to KiloBytes, etc.. not KibiBytes", function() {
          dropzone.filesize(2 * 1024 * 1024).should.eql("<strong>2.1</strong> MB");
          dropzone.filesize(2 * 1000 * 1000).should.eql("<strong>2</strong> MB");
          dropzone.filesize(2 * 1024 * 1024 * 1024).should.eql("<strong>2.1</strong> GB");
          return dropzone.filesize(2 * 1000 * 1000 * 1000).should.eql("<strong>2</strong> GB");
        });
      });
      describe("._updateMaxFilesReachedClass()", function() {
        it("should properly add the dz-max-files-reached class", function() {
          dropzone.getAcceptedFiles = function() {
            return {
              length: 10
            };
          };
          dropzone.options.maxFiles = 10;
          dropzone.element.classList.contains("dz-max-files-reached").should.not.be.ok;
          dropzone._updateMaxFilesReachedClass();
          return dropzone.element.classList.contains("dz-max-files-reached").should.be.ok;
        });
        return it("should properly remove the dz-max-files-reached class", function() {
          dropzone.getAcceptedFiles = function() {
            return {
              length: 10
            };
          };
          dropzone.options.maxFiles = 10;
          dropzone.element.classList.contains("dz-max-files-reached").should.not.be.ok;
          dropzone._updateMaxFilesReachedClass();
          dropzone.element.classList.contains("dz-max-files-reached").should.be.ok;
          dropzone.getAcceptedFiles = function() {
            return {
              length: 9
            };
          };
          dropzone._updateMaxFilesReachedClass();
          return dropzone.element.classList.contains("dz-max-files-reached").should.not.be.ok;
        });
      });
      return describe("events", function() {
        return describe("progress updates", function() {
          return it("should properly emit a totaluploadprogress event", function(done) {
            var totalProgressExpectation, _called;
            dropzone.files = [
              {
                size: 1990,
                accepted: true,
                upload: {
                  progress: 20,
                  total: 2000,
                  bytesSent: 400
                }
              }, {
                size: 1990,
                accepted: true,
                upload: {
                  progress: 10,
                  total: 2000,
                  bytesSent: 200
                }
              }
            ];
            _called = 0;
            dropzone.on("totaluploadprogress", function(progress) {
              progress.should.equal(totalProgressExpectation);
              if (++_called === 3) {
                return done();
              }
            });
            totalProgressExpectation = 15;
            dropzone.emit("uploadprogress", {});
            totalProgressExpectation = 97.5;
            dropzone.files[0].upload.bytesSent = 2000;
            dropzone.files[1].upload.bytesSent = 1900;
            dropzone.emit("uploadprogress", {});
            totalProgressExpectation = 100;
            dropzone.files[0].upload.bytesSent = 2000;
            dropzone.files[1].upload.bytesSent = 2000;
            return dropzone.emit("uploadprogress", {});
          });
        });
      });
    });
    describe("helper function", function() {
      var dropzone, element;
      element = null;
      dropzone = null;
      beforeEach(function() {
        element = Dropzone.createElement("<div></div>");
        return dropzone = new Dropzone(element, {
          url: "url"
        });
      });
      describe("getExistingFallback()", function() {
        it("should return undefined if no fallback", function() {
          return expect(dropzone.getExistingFallback()).to.equal(void 0);
        });
        it("should only return the fallback element if it contains exactly fallback", function() {
          element.appendChild(Dropzone.createElement("<form class=\"fallbacks\"></form>"));
          element.appendChild(Dropzone.createElement("<form class=\"sfallback\"></form>"));
          return expect(dropzone.getExistingFallback()).to.equal(void 0);
        });
        it("should return divs as fallback", function() {
          var fallback;
          fallback = Dropzone.createElement("<form class=\" abc fallback test \"></form>");
          element.appendChild(fallback);
          return fallback.should.equal(dropzone.getExistingFallback());
        });
        return it("should return forms as fallback", function() {
          var fallback;
          fallback = Dropzone.createElement("<div class=\" abc fallback test \"></div>");
          element.appendChild(fallback);
          return fallback.should.equal(dropzone.getExistingFallback());
        });
      });
      describe("getFallbackForm()", function() {
        it("should use the paramName without [] if uploadMultiple is false", function() {
          var fallback, fileInput;
          dropzone.options.uploadMultiple = false;
          dropzone.options.paramName = "myFile";
          fallback = dropzone.getFallbackForm();
          fileInput = fallback.querySelector("input[type=file]");
          return fileInput.name.should.equal("myFile");
        });
        return it("should properly add [] to the file name if uploadMultiple is true", function() {
          var fallback, fileInput;
          dropzone.options.uploadMultiple = true;
          dropzone.options.paramName = "myFile";
          fallback = dropzone.getFallbackForm();
          fileInput = fallback.querySelector("input[type=file]");
          return fileInput.name.should.equal("myFile[]");
        });
      });
      describe("getAcceptedFiles() / getRejectedFiles()", function() {
        var mock1, mock2, mock3, mock4;
        mock1 = mock2 = mock3 = mock4 = null;
        beforeEach(function() {
          mock1 = getMockFile();
          mock2 = getMockFile();
          mock3 = getMockFile();
          mock4 = getMockFile();
          dropzone.options.accept = function(file, done) {
            if (file === mock1 || file === mock3) {
              return done();
            } else {
              return done("error");
            }
          };
          dropzone.addFile(mock1);
          dropzone.addFile(mock2);
          dropzone.addFile(mock3);
          return dropzone.addFile(mock4);
        });
        it("getAcceptedFiles() should only return accepted files", function() {
          return dropzone.getAcceptedFiles().should.eql([mock1, mock3]);
        });
        return it("getRejectedFiles() should only return rejected files", function() {
          return dropzone.getRejectedFiles().should.eql([mock2, mock4]);
        });
      });
      describe("getQueuedFiles()", function() {
        return it("should return all files with the status Dropzone.QUEUED", function() {
          var mock1, mock2, mock3, mock4;
          mock1 = getMockFile();
          mock2 = getMockFile();
          mock3 = getMockFile();
          mock4 = getMockFile();
          dropzone.options.accept = function(file, done) {
            return file.done = done;
          };
          dropzone.addFile(mock1);
          dropzone.addFile(mock2);
          dropzone.addFile(mock3);
          dropzone.addFile(mock4);
          dropzone.getQueuedFiles().should.eql([]);
          mock1.done();
          mock3.done();
          dropzone.getQueuedFiles().should.eql([mock1, mock3]);
          mock1.status.should.equal(Dropzone.QUEUED);
          mock3.status.should.equal(Dropzone.QUEUED);
          mock2.status.should.equal(Dropzone.ADDED);
          return mock4.status.should.equal(Dropzone.ADDED);
        });
      });
      return describe("getUploadingFiles()", function() {
        return it("should return all files with the status Dropzone.UPLOADING", function(done) {
          var mock1, mock2, mock3, mock4;
          mock1 = getMockFile();
          mock2 = getMockFile();
          mock3 = getMockFile();
          mock4 = getMockFile();
          dropzone.options.accept = function(file, _done) {
            return file.done = _done;
          };
          dropzone.uploadFile = function() {};
          dropzone.addFile(mock1);
          dropzone.addFile(mock2);
          dropzone.addFile(mock3);
          dropzone.addFile(mock4);
          dropzone.getUploadingFiles().should.eql([]);
          mock1.done();
          mock3.done();
          return setTimeout((function() {
            dropzone.getUploadingFiles().should.eql([mock1, mock3]);
            mock1.status.should.equal(Dropzone.UPLOADING);
            mock3.status.should.equal(Dropzone.UPLOADING);
            mock2.status.should.equal(Dropzone.ADDED);
            mock4.status.should.equal(Dropzone.ADDED);
            return done();
          }), 10);
        });
      });
    });
    return describe("file handling", function() {
      var dropzone, mockFile;
      mockFile = null;
      dropzone = null;
      beforeEach(function() {
        var element;
        mockFile = getMockFile();
        element = Dropzone.createElement("<div></div>");
        return dropzone = new Dropzone(element, {
          url: "/the/url"
        });
      });
      afterEach(function() {
        return dropzone.destroy();
      });
      describe("addFile()", function() {
        it("should properly set the status of the file", function() {
          var doneFunction;
          doneFunction = null;
          dropzone.accept = function(file, done) {
            return doneFunction = done;
          };
          dropzone.processFile = function() {};
          dropzone.uploadFile = function() {};
          dropzone.addFile(mockFile);
          mockFile.status.should.eql(Dropzone.ADDED);
          doneFunction();
          mockFile.status.should.eql(Dropzone.QUEUED);
          mockFile = getMockFile();
          dropzone.addFile(mockFile);
          mockFile.status.should.eql(Dropzone.ADDED);
          doneFunction("error");
          return mockFile.status.should.eql(Dropzone.ERROR);
        });
        return it("should properly set the status of the file if autoProcessQueue is false and not call processQueue", function(done) {
          var doneFunction;
          doneFunction = null;
          dropzone.options.autoProcessQueue = false;
          dropzone.accept = function(file, done) {
            return doneFunction = done;
          };
          dropzone.processFile = function() {};
          dropzone.uploadFile = function() {};
          dropzone.addFile(mockFile);
          sinon.stub(dropzone, "processQueue");
          mockFile.status.should.eql(Dropzone.ADDED);
          doneFunction();
          mockFile.status.should.eql(Dropzone.QUEUED);
          dropzone.processQueue.callCount.should.equal(0);
          return setTimeout((function() {
            dropzone.processQueue.callCount.should.equal(0);
            return done();
          }), 10);
        });
      });
      describe("enqueueFile()", function() {
        it("should be wrapped by enqueueFiles()", function() {
          var mock1, mock2, mock3;
          sinon.stub(dropzone, "enqueueFile");
          mock1 = getMockFile();
          mock2 = getMockFile();
          mock3 = getMockFile();
          dropzone.enqueueFiles([mock1, mock2, mock3]);
          dropzone.enqueueFile.callCount.should.equal(3);
          dropzone.enqueueFile.args[0][0].should.equal(mock1);
          dropzone.enqueueFile.args[1][0].should.equal(mock2);
          return dropzone.enqueueFile.args[2][0].should.equal(mock3);
        });
        it("should fail if the file has already been processed", function() {
          mockFile.status = Dropzone.ERROR;
          expect((function() {
            return dropzone.enqueueFile(mockFile);
          })).to["throw"]("This file can't be queued because it has already been processed or was rejected.");
          mockFile.status = Dropzone.COMPLETE;
          expect((function() {
            return dropzone.enqueueFile(mockFile);
          })).to["throw"]("This file can't be queued because it has already been processed or was rejected.");
          mockFile.status = Dropzone.UPLOADING;
          return expect((function() {
            return dropzone.enqueueFile(mockFile);
          })).to["throw"]("This file can't be queued because it has already been processed or was rejected.");
        });
        return it("should set the status to QUEUED and call processQueue asynchronously if everything's ok", function(done) {
          mockFile.status = Dropzone.ADDED;
          sinon.stub(dropzone, "processQueue");
          dropzone.processQueue.callCount.should.equal(0);
          dropzone.enqueueFile(mockFile);
          mockFile.status.should.equal(Dropzone.QUEUED);
          dropzone.processQueue.callCount.should.equal(0);
          return setTimeout(function() {
            dropzone.processQueue.callCount.should.equal(1);
            return done();
          }, 10);
        });
      });
      return describe("uploadFiles()", function() {
        var requests;
        requests = null;
        beforeEach(function() {
          requests = [];
          return xhr.onCreate = function(xhr) {
            return requests.push(xhr);
          };
        });
        afterEach(function() {
          return xhr.restore();
        });
        it("should be wrapped by uploadFile()", function() {
          sinon.stub(dropzone, "uploadFiles");
          dropzone.uploadFile(mockFile);
          dropzone.uploadFiles.callCount.should.equal(1);
          return dropzone.uploadFiles.calledWith([mockFile]).should.be.ok;
        });
        it("should ignore the onreadystate callback if readyState != 4", function(done) {
          dropzone.addFile(mockFile);
          return setTimeout(function() {
            mockFile.status.should.eql(Dropzone.UPLOADING);
            requests[0].status = 200;
            requests[0].readyState = 3;
            requests[0].onload();
            mockFile.status.should.eql(Dropzone.UPLOADING);
            requests[0].readyState = 4;
            requests[0].onload();
            mockFile.status.should.eql(Dropzone.SUCCESS);
            return done();
          }, 10);
        });
        it("should emit error and errormultiple when response was not OK", function(done) {
          var complete, completemultiple, error, errormultiple;
          dropzone.options.uploadMultiple = true;
          error = false;
          errormultiple = false;
          complete = false;
          completemultiple = false;
          dropzone.on("error", function() {
            return error = true;
          });
          dropzone.on("errormultiple", function() {
            return errormultiple = true;
          });
          dropzone.on("complete", function() {
            return complete = true;
          });
          dropzone.on("completemultiple", function() {
            return completemultiple = true;
          });
          dropzone.addFile(mockFile);
          return setTimeout(function() {
            mockFile.status.should.eql(Dropzone.UPLOADING);
            requests[0].status = 400;
            requests[0].readyState = 4;
            requests[0].onload();
            expect((((true === error && error === errormultiple) && errormultiple === complete) && complete === completemultiple)).to.be.ok;
            return done();
          }, 10);
        });
        it("should include hidden files in the form and unchecked checkboxes and radiobuttons should be excluded", function(done) {
          var element, formData, mock1;
          element = Dropzone.createElement("<form action=\"/the/url\">\n  <input type=\"hidden\" name=\"test\" value=\"hidden\" />\n  <input type=\"checkbox\" name=\"unchecked\" value=\"1\" />\n  <input type=\"checkbox\" name=\"checked\" value=\"value1\" checked=\"checked\" />\n  <input type=\"radio\" value=\"radiovalue1\" name=\"radio1\" />\n  <input type=\"radio\" value=\"radiovalue2\" name=\"radio1\" checked=\"checked\" />\n</form>");
          dropzone = new Dropzone(element, {
            url: "/the/url"
          });
          formData = null;
          dropzone.on("sending", function(file, xhr, tformData) {
            formData = tformData;
            return sinon.spy(tformData, "append");
          });
          mock1 = getMockFile();
          dropzone.addFile(mock1);
          return setTimeout(function() {
            formData.append.callCount.should.equal(4);
            formData.append.args[0][0].should.eql("test");
            formData.append.args[0][1].should.eql("hidden");
            formData.append.args[1][0].should.eql("checked");
            formData.append.args[1][1].should.eql("value1");
            formData.append.args[2][0].should.eql("radio1");
            formData.append.args[2][1].should.eql("radiovalue2");
            formData.append.args[3][0].should.eql("file");
            formData.append.args[3][1].should.equal(mock1);
            return done();
          }, 10);
        });
        describe("settings()", function() {
          it("should correctly set `withCredentials` on the xhr object", function() {
            dropzone.uploadFile(mockFile);
            requests.length.should.eql(1);
            requests[0].withCredentials.should.eql(false);
            dropzone.options.withCredentials = true;
            dropzone.uploadFile(mockFile);
            requests.length.should.eql(2);
            return requests[1].withCredentials.should.eql(true);
          });
          it("should correctly override headers on the xhr object", function() {
            dropzone.options.headers = {
              "Foo-Header": "foobar"
            };
            dropzone.uploadFile(mockFile);
            return requests[0].requestHeaders["Foo-Header"].should.eql('foobar');
          });
          it("should properly use the paramName without [] as file upload if uploadMultiple is false", function(done) {
            var formData, mock1, mock2, sendingCount;
            dropzone.options.uploadMultiple = false;
            dropzone.options.paramName = "myName";
            formData = [];
            sendingCount = 0;
            dropzone.on("sending", function(files, xhr, tformData) {
              sendingCount++;
              formData.push(tformData);
              return sinon.spy(tformData, "append");
            });
            mock1 = getMockFile();
            mock2 = getMockFile();
            dropzone.addFile(mock1);
            dropzone.addFile(mock2);
            return setTimeout(function() {
              sendingCount.should.equal(2);
              formData.length.should.equal(2);
              formData[0].append.callCount.should.equal(1);
              formData[1].append.callCount.should.equal(1);
              formData[0].append.args[0][0].should.eql("myName");
              formData[0].append.args[0][0].should.eql("myName");
              return done();
            }, 10);
          });
          return it("should properly use the paramName with [] as file upload if uploadMultiple is true", function(done) {
            var formData, mock1, mock2, sendingCount, sendingMultipleCount;
            dropzone.options.uploadMultiple = true;
            dropzone.options.paramName = "myName";
            formData = null;
            sendingMultipleCount = 0;
            sendingCount = 0;
            dropzone.on("sending", function(file, xhr, tformData) {
              return sendingCount++;
            });
            dropzone.on("sendingmultiple", function(files, xhr, tformData) {
              sendingMultipleCount++;
              formData = tformData;
              return sinon.spy(tformData, "append");
            });
            mock1 = getMockFile();
            mock2 = getMockFile();
            dropzone.addFile(mock1);
            dropzone.addFile(mock2);
            return setTimeout(function() {
              sendingCount.should.equal(2);
              sendingMultipleCount.should.equal(1);
              dropzone.uploadFiles([mock1, mock2]);
              formData.append.callCount.should.equal(2);
              formData.append.args[0][0].should.eql("myName[]");
              formData.append.args[1][0].should.eql("myName[]");
              return done();
            }, 10);
          });
        });
        return describe("should properly set status of file", function() {
          return it("should correctly set `withCredentials` on the xhr object", function(done) {
            dropzone.addFile(mockFile);
            return setTimeout(function() {
              mockFile.status.should.eql(Dropzone.UPLOADING);
              requests.length.should.equal(1);
              requests[0].status = 400;
              requests[0].readyState = 4;
              requests[0].onload();
              mockFile.status.should.eql(Dropzone.ERROR);
              mockFile = getMockFile();
              dropzone.addFile(mockFile);
              return setTimeout(function() {
                mockFile.status.should.eql(Dropzone.UPLOADING);
                requests.length.should.equal(2);
                requests[1].status = 200;
                requests[1].readyState = 4;
                requests[1].onload();
                mockFile.status.should.eql(Dropzone.SUCCESS);
                return done();
              }, 10);
            }, 10);
          });
        });
      });
    });
  });

}).call(this);
