dropbox.js

// https://dl.dropboxusercontent.com/spa/pjlfdak1tmznswp/api_keys.js/public/index.html
// Generated by CoffeeScript 1.6.2
(function() {
  var Dropbox, DropboxChromeOnMessage, DropboxChromeSendMessage, DropboxClient, DropboxXhrArrayBufferView, DropboxXhrCanSendForms, DropboxXhrDoesPreflight, DropboxXhrIeMode, DropboxXhrRequest, DropboxXhrSendArrayBufferView, DropboxXhrWrapBlob, add32, arrayToBase64, atob, atobNibble, base64Digits, base64HmacSha1, base64Sha1, blobError, btoa, btoaNibble, crypto, dropboxEncodeKey, hmacSha1, name, requireError, rotateLeft32, sha1, stringToArray, value, _base64Digits,
    __indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; },
    __hasProp = {}.hasOwnProperty,
    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

  Dropbox = function() {
    return null;
  };

  Dropbox.Util = {};

  Dropbox.EventSource = (function() {
    function EventSource(options) {
      this._cancelable = options && options.cancelable;
      this._listeners = [];
    }

    EventSource.prototype.addListener = function(listener) {
      if (typeof listener !== 'function') {
        throw new TypeError('Invalid listener type; expected function');
      }
      if (__indexOf.call(this._listeners, listener) < 0) {
        this._listeners.push(listener);
      }
      return this;
    };

    EventSource.prototype.removeListener = function(listener) {
      var i, index, subscriber, _i, _len, _ref;

      if (this._listeners.indexOf) {
        index = this._listeners.indexOf(listener);
        if (index !== -1) {
          this._listeners.splice(index, 1);
        }
      } else {
        _ref = this._listeners;
        for (i = _i = 0, _len = _ref.length; _i < _len; i = ++_i) {
          subscriber = _ref[i];
          if (subscriber === listener) {
            this._listeners.splice(i, 1);
            break;
          }
        }
      }
      return this;
    };

    EventSource.prototype.dispatch = function(event) {
      var listener, returnValue, _i, _len, _ref;

      _ref = this._listeners;
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        listener = _ref[_i];
        returnValue = listener(event);
        if (this._cancelable && returnValue === false) {
          return false;
        }
      }
      return true;
    };

    return EventSource;

  })();

  Dropbox.ApiError = (function() {
    ApiError.prototype.status = void 0;

    ApiError.prototype.method = void 0;

    ApiError.prototype.url = void 0;

    ApiError.prototype.responseText = void 0;

    ApiError.prototype.response = void 0;

    ApiError.NETWORK_ERROR = 0;

    ApiError.INVALID_PARAM = 400;

    ApiError.INVALID_TOKEN = 401;

    ApiError.OAUTH_ERROR = 403;

    ApiError.NOT_FOUND = 404;

    ApiError.INVALID_METHOD = 405;

    ApiError.RATE_LIMITED = 503;

    ApiError.OVER_QUOTA = 507;

    function ApiError(xhr, method, url) {
      var text, xhrError;

      this.method = method;
      this.url = url;
      this.status = xhr.status;
      if (xhr.responseType) {
        try {
          text = xhr.response || xhr.responseText;
        } catch (_error) {
          xhrError = _error;
          try {
            text = xhr.responseText;
          } catch (_error) {
            xhrError = _error;
            text = null;
          }
        }
      } else {
        try {
          text = xhr.responseText;
        } catch (_error) {
          xhrError = _error;
          text = null;
        }
      }
      if (text) {
        try {
          this.responseText = text.toString();
          this.response = JSON.parse(text);
        } catch (_error) {
          xhrError = _error;
          this.response = null;
        }
      } else {
        this.responseText = '(no response)';
        this.response = null;
      }
    }

    ApiError.prototype.toString = function() {
      return "Dropbox API error " + this.status + " from " + this.method + " " + this.url + " :: " + this.responseText;
    };

    ApiError.prototype.inspect = function() {
      return this.toString();
    };

    return ApiError;

  })();

  Dropbox.AuthDriver = (function() {
    function AuthDriver() {}

    AuthDriver.prototype.url = function(token) {
      return "https://some.url?dboauth_token=" + (Dropbox.Xhr.urlEncode(token));
    };

    AuthDriver.prototype.doAuthorize = function(authUrl, token, tokenSecret, callback) {
      return callback('oauth-token');
    };

    AuthDriver.prototype.onAuthStateChange = function(client, callback) {
      return callback();
    };

    return AuthDriver;

  })();

  Dropbox.Drivers = {};

  if (typeof atob === 'function' && typeof btoa === 'function') {
    atob = function(string) {
      return window.atob(string);
    };
    btoa = function(base64) {
      return window.btoa(base64);
    };
  } else if ((typeof window !== 'undefined' || typeof self !== 'undefined') && (typeof navigator !== 'undefined' && typeof navigator.userAgent === 'string')) {
    base64Digits = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
    btoaNibble = function(accumulator, bytes, result) {
      var i, limit;

      limit = 3 - bytes;
      accumulator <<= limit * 8;
      i = 3;
      while (i >= limit) {
        result.push(base64Digits.charAt((accumulator >> (i * 6)) & 0x3F));
        i -= 1;
      }
      i = bytes;
      while (i < 3) {
        result.push('=');
        i += 1;
      }
      return null;
    };
    atobNibble = function(accumulator, digits, result) {
      var i, limit;

      limit = 4 - digits;
      accumulator <<= limit * 6;
      i = 2;
      while (i >= limit) {
        result.push(String.fromCharCode((accumulator >> (8 * i)) & 0xFF));
        i -= 1;
      }
      return null;
    };
    btoa = function(string) {
      var accumulator, bytes, i, result, _i, _ref;

      result = [];
      accumulator = 0;
      bytes = 0;
      for (i = _i = 0, _ref = string.length; 0 <= _ref ? _i < _ref : _i > _ref; i = 0 <= _ref ? ++_i : --_i) {
        accumulator = (accumulator << 8) | string.charCodeAt(i);
        bytes += 1;
        if (bytes === 3) {
          btoaNibble(accumulator, bytes, result);
          accumulator = bytes = 0;
        }
      }
      if (bytes > 0) {
        btoaNibble(accumulator, bytes, result);
      }
      return result.join('');
    };
    atob = function(base64) {
      var accumulator, digit, digits, i, result, _i, _ref;

      result = [];
      accumulator = 0;
      digits = 0;
      for (i = _i = 0, _ref = base64.length; 0 <= _ref ? _i < _ref : _i > _ref; i = 0 <= _ref ? ++_i : --_i) {
        digit = base64.charAt(i);
        if (digit === '=') {
          break;
        }
        accumulator = (accumulator << 6) | base64Digits.indexOf(digit);
        digits += 1;
        if (digits === 4) {
          atobNibble(accumulator, digits, result);
          accumulator = digits = 0;
        }
      }
      if (digits > 0) {
        atobNibble(accumulator, digits, result);
      }
      return result.join('');
    };
  } else {
    atob = function(arg) {
      var buffer, i;

      buffer = new Buffer(arg, 'base64');
      return ((function() {
        var _i, _ref, _results;

        _results = [];
        for (i = _i = 0, _ref = buffer.length; 0 <= _ref ? _i < _ref : _i > _ref; i = 0 <= _ref ? ++_i : --_i) {
          _results.push(String.fromCharCode(buffer[i]));
        }
        return _results;
      })()).join('');
    };
    btoa = function(arg) {
      var buffer, i;

      buffer = new Buffer((function() {
        var _i, _ref, _results;

        _results = [];
        for (i = _i = 0, _ref = arg.length; 0 <= _ref ? _i < _ref : _i > _ref; i = 0 <= _ref ? ++_i : --_i) {
          _results.push(arg.charCodeAt(i));
        }
        return _results;
      })());
      return buffer.toString('base64');
    };
  }

  Dropbox.Util.atob = atob;

  Dropbox.Util.btoa = btoa;

  Dropbox.Client = (function() {
    function Client(options) {
      var _this = this;

      this.sandbox = options.sandbox || false;
      this.apiServer = options.server || this.defaultApiServer();
      this.authServer = options.authServer || this.defaultAuthServer();
      this.fileServer = options.fileServer || this.defaultFileServer();
      this.downloadServer = options.downloadServer || this.defaultDownloadServer();
      this.onXhr = new Dropbox.EventSource({
        cancelable: true
      });
      this.onError = new Dropbox.EventSource;
      this.onAuthStateChange = new Dropbox.EventSource;
      this.xhrOnErrorHandler = function(error, callback) {
        return _this.handleXhrError(error, callback);
      };
      this.oauth = new Dropbox.Oauth(options);
      this.driver = null;
      this.filter = null;
      this.uid = null;
      this.authState = null;
      this.authError = null;
      this._credentials = null;
      this.setCredentials(options);
      this.setupUrls();
    }

    Client.prototype.authDriver = function(driver) {
      this.driver = driver;
      return this;
    };

    Client.prototype.onXhr = null;

    Client.prototype.onError = null;

    Client.prototype.onAuthStateChange = null;

    Client.prototype.dropboxUid = function() {
      return this.uid;
    };

    Client.prototype.credentials = function() {
      if (!this._credentials) {
        this.computeCredentials();
      }
      return this._credentials;
    };

    Client.prototype.authenticate = function(options, callback) {
      var interactive, oldAuthState, _fsmStep,
        _this = this;

      if (!callback && typeof options === 'function') {
        callback = options;
        options = null;
      }
      if (options && 'interactive' in options) {
        interactive = options.interactive;
      } else {
        interactive = true;
      }
      if (!(this.driver || this.authState === DropboxClient.DONE)) {
        throw new Error('Call authDriver to set an authentication driver');
      }
      if (this.authState === DropboxClient.ERROR) {
        throw new Error('Client got in an error state. Call reset() to reuse it!');
      }
      oldAuthState = null;
      _fsmStep = function() {
        var authUrl;

        if (oldAuthState !== _this.authState) {
          oldAuthState = _this.authState;
          if (_this.driver && _this.driver.onAuthStateChange) {
            _this.driver.onAuthStateChange(_this, _fsmStep);
            return;
          }
        }
        switch (_this.authState) {
          case DropboxClient.RESET:
            if (!interactive) {
              if (callback) {
                callback(null, _this);
              }
              return;
            }
            return _this.requestToken(function(error, data) {
              var token, tokenSecret;

              if (error) {
                _this.authError = error;
                _this.authState = DropboxClient.ERROR;
              } else {
                token = data.oauth_token;
                tokenSecret = data.oauth_token_secret;
                _this.oauth.setToken(token, tokenSecret);
                _this.authState = DropboxClient.REQUEST;
              }
              _this._credentials = null;
              _this.onAuthStateChange.dispatch(_this);
              return _fsmStep();
            });
          case DropboxClient.REQUEST:
            if (!interactive) {
              if (callback) {
                callback(null, _this);
              }
              return;
            }
            authUrl = _this.authorizeUrl(_this.oauth.token);
            return _this.driver.doAuthorize(authUrl, _this.oauth.token, _this.oauth.tokenSecret, function() {
              _this.authState = DropboxClient.AUTHORIZED;
              _this._credentials = null;
              _this.onAuthStateChange.dispatch(_this);
              return _fsmStep();
            });
          case DropboxClient.AUTHORIZED:
            return _this.getAccessToken(function(error, data) {
              if (error) {
                _this.authError = error;
                _this.authState = DropboxClient.ERROR;
              } else {
                _this.oauth.setToken(data.oauth_token, data.oauth_token_secret);
                _this.uid = data.uid;
                _this.authState = DropboxClient.DONE;
              }
              _this._credentials = null;
              _this.onAuthStateChange.dispatch(_this);
              return _fsmStep();
            });
          case DropboxClient.DONE:
            if (callback) {
              callback(null, _this);
            }
            break;
          case DropboxClient.SIGNED_OFF:
            _this.authState = DropboxClient.RESET;
            _this.reset();
            return _fsmStep();
          case DropboxClient.ERROR:
            if (callback) {
              callback(_this.authError, _this);
            }
        }
      };
      _fsmStep();
      return this;
    };

    Client.prototype.isAuthenticated = function() {
      return this.authState === DropboxClient.DONE;
    };

    Client.prototype.signOut = function(callback) {
      var xhr,
        _this = this;

      xhr = new Dropbox.Xhr('POST', this.urls.signOut);
      xhr.signWithOauth(this.oauth);
      return this.dispatchXhr(xhr, function(error) {
        if (error) {
          if (callback) {
            callback(error);
          }
          return;
        }
        _this.authState = DropboxClient.RESET;
        _this.reset();
        _this.authState = DropboxClient.SIGNED_OFF;
        _this.onAuthStateChange.dispatch(_this);
        if (_this.driver && _this.driver.onAuthStateChange) {
          return _this.driver.onAuthStateChange(_this, function() {
            if (callback) {
              return callback(error);
            }
          });
        } else {
          if (callback) {
            return callback(error);
          }
        }
      });
    };

    Client.prototype.signOff = function(callback) {
      return this.signOut(callback);
    };

    Client.prototype.getUserInfo = function(options, callback) {
      var httpCache, xhr;

      if ((!callback) && (typeof options === 'function')) {
        callback = options;
        options = null;
      }
      httpCache = false;
      if (options && options.httpCache) {
        httpCache = true;
      }
      xhr = new Dropbox.Xhr('GET', this.urls.accountInfo);
      xhr.signWithOauth(this.oauth, httpCache);
      return this.dispatchXhr(xhr, function(error, userData) {
        return callback(error, Dropbox.UserInfo.parse(userData), userData);
      });
    };

    Client.prototype.readFile = function(path, options, callback) {
      var httpCache, params, rangeEnd, rangeHeader, rangeStart, responseType, xhr;

      if ((!callback) && (typeof options === 'function')) {
        callback = options;
        options = null;
      }
      params = {};
      responseType = 'text';
      rangeHeader = null;
      httpCache = false;
      if (options) {
        if (options.versionTag) {
          params.rev = options.versionTag;
        } else if (options.rev) {
          params.rev = options.rev;
        }
        if (options.arrayBuffer) {
          responseType = 'arraybuffer';
        } else if (options.blob) {
          responseType = 'blob';
        } else if (options.buffer) {
          responseType = 'buffer';
        } else if (options.binary) {
          responseType = 'b';
        }
        if (options.length) {
          if (options.start != null) {
            rangeStart = options.start;
            rangeEnd = options.start + options.length - 1;
          } else {
            rangeStart = '';
            rangeEnd = options.length;
          }
          rangeHeader = "bytes=" + rangeStart + "-" + rangeEnd;
        } else if (options.start != null) {
          rangeHeader = "bytes=" + options.start + "-";
        }
        if (options.httpCache) {
          httpCache = true;
        }
      }
      xhr = new Dropbox.Xhr('GET', "" + this.urls.getFile + "/" + (this.urlEncodePath(path)));
      xhr.setParams(params).signWithOauth(this.oauth, httpCache);
      xhr.setResponseType(responseType);
      if (rangeHeader) {
        if (rangeHeader) {
          xhr.setHeader('Range', rangeHeader);
        }
        xhr.reportResponseHeaders();
      }
      return this.dispatchXhr(xhr, function(error, data, metadata, headers) {
        var rangeInfo;

        if (headers) {
          rangeInfo = Dropbox.RangeInfo.parse(headers['content-range']);
        } else {
          rangeInfo = null;
        }
        return callback(error, data, Dropbox.Stat.parse(metadata), rangeInfo);
      });
    };

    Client.prototype.writeFile = function(path, data, options, callback) {
      var useForm;

      if ((!callback) && (typeof options === 'function')) {
        callback = options;
        options = null;
      }
      useForm = Dropbox.Xhr.canSendForms && typeof data === 'object';
      if (useForm) {
        return this.writeFileUsingForm(path, data, options, callback);
      } else {
        return this.writeFileUsingPut(path, data, options, callback);
      }
    };

    Client.prototype.writeFileUsingForm = function(path, data, options, callback) {
      var fileName, params, slashIndex, xhr;

      slashIndex = path.lastIndexOf('/');
      if (slashIndex === -1) {
        fileName = path;
        path = '';
      } else {
        fileName = path.substring(slashIndex);
        path = path.substring(0, slashIndex);
      }
      params = {
        file: fileName
      };
      if (options) {
        if (options.noOverwrite) {
          params.overwrite = 'false';
        }
        if (options.lastVersionTag) {
          params.parent_rev = options.lastVersionTag;
        } else if (options.parentRev || options.parent_rev) {
          params.parent_rev = options.parentRev || options.parent_rev;
        }
      }
      xhr = new Dropbox.Xhr('POST', "" + this.urls.postFile + "/" + (this.urlEncodePath(path)));
      xhr.setParams(params).signWithOauth(this.oauth).setFileField('file', fileName, data, 'application/octet-stream');
      delete params.file;
      return this.dispatchXhr(xhr, function(error, metadata) {
        if (callback) {
          return callback(error, Dropbox.Stat.parse(metadata));
        }
      });
    };

    Client.prototype.writeFileUsingPut = function(path, data, options, callback) {
      var params, xhr;

      params = {};
      if (options) {
        if (options.noOverwrite) {
          params.overwrite = 'false';
        }
        if (options.lastVersionTag) {
          params.parent_rev = options.lastVersionTag;
        } else if (options.parentRev || options.parent_rev) {
          params.parent_rev = options.parentRev || options.parent_rev;
        }
      }
      xhr = new Dropbox.Xhr('POST', "" + this.urls.putFile + "/" + (this.urlEncodePath(path)));
      xhr.setBody(data).setParams(params).signWithOauth(this.oauth);
      return this.dispatchXhr(xhr, function(error, metadata) {
        if (callback) {
          return callback(error, Dropbox.Stat.parse(metadata));
        }
      });
    };

    Client.prototype.resumableUploadStep = function(data, cursor, callback) {
      var params, xhr;

      if (cursor) {
        params = {
          offset: cursor.offset
        };
        if (cursor.tag) {
          params.upload_id = cursor.tag;
        }
      } else {
        params = {
          offset: 0
        };
      }
      xhr = new Dropbox.Xhr('POST', this.urls.chunkedUpload);
      xhr.setBody(data).setParams(params).signWithOauth(this.oauth);
      return this.dispatchXhr(xhr, function(error, cursor) {
        if (error && error.status === Dropbox.ApiError.INVALID_PARAM && error.response && error.response.upload_id && error.response.offset) {
          return callback(null, Dropbox.UploadCursor.parse(error.response));
        } else {
          return callback(error, Dropbox.UploadCursor.parse(cursor));
        }
      });
    };

    Client.prototype.resumableUploadFinish = function(path, cursor, options, callback) {
      var params, xhr;

      if ((!callback) && (typeof options === 'function')) {
        callback = options;
        options = null;
      }
      params = {
        upload_id: cursor.tag
      };
      if (options) {
        if (options.lastVersionTag) {
          params.parent_rev = options.lastVersionTag;
        } else if (options.parentRev || options.parent_rev) {
          params.parent_rev = options.parentRev || options.parent_rev;
        }
        if (options.noOverwrite) {
          params.overwrite = 'false';
        }
      }
      xhr = new Dropbox.Xhr('POST', "" + this.urls.commitChunkedUpload + "/" + (this.urlEncodePath(path)));
      xhr.setParams(params).signWithOauth(this.oauth);
      return this.dispatchXhr(xhr, function(error, metadata) {
        if (callback) {
          return callback(error, Dropbox.Stat.parse(metadata));
        }
      });
    };

    Client.prototype.stat = function(path, options, callback) {
      var httpCache, params, xhr;

      if ((!callback) && (typeof options === 'function')) {
        callback = options;
        options = null;
      }
      params = {};
      httpCache = false;
      if (options) {
        if (options.version != null) {
          params.rev = options.version;
        }
        if (options.removed || options.deleted) {
          params.include_deleted = 'true';
        }
        if (options.readDir) {
          params.list = 'true';
          if (options.readDir !== true) {
            params.file_limit = options.readDir.toString();
          }
        }
        if (options.cacheHash) {
          params.hash = options.cacheHash;
        }
        if (options.httpCache) {
          httpCache = true;
        }
      }
      params.include_deleted || (params.include_deleted = 'false');
      params.list || (params.list = 'false');
      xhr = new Dropbox.Xhr('GET', "" + this.urls.metadata + "/" + (this.urlEncodePath(path)));
      xhr.setParams(params).signWithOauth(this.oauth, httpCache);
      return this.dispatchXhr(xhr, function(error, metadata) {
        var entries, entry, stat;

        stat = Dropbox.Stat.parse(metadata);
        if (metadata != null ? metadata.contents : void 0) {
          entries = (function() {
            var _i, _len, _ref, _results;

            _ref = metadata.contents;
            _results = [];
            for (_i = 0, _len = _ref.length; _i < _len; _i++) {
              entry = _ref[_i];
              _results.push(Dropbox.Stat.parse(entry));
            }
            return _results;
          })();
        } else {
          entries = void 0;
        }
        return callback(error, stat, entries);
      });
    };

    Client.prototype.readdir = function(path, options, callback) {
      var statOptions;

      if ((!callback) && (typeof options === 'function')) {
        callback = options;
        options = null;
      }
      statOptions = {
        readDir: true
      };
      if (options) {
        if (options.limit != null) {
          statOptions.readDir = options.limit;
        }
        if (options.versionTag) {
          statOptions.versionTag = options.versionTag;
        }
        if (options.removed || options.deleted) {
          statOptions.removed = options.removed || options.deleted;
        }
        if (options.httpCache) {
          statOptions.httpCache = options.httpCache;
        }
      }
      return this.stat(path, statOptions, function(error, stat, entry_stats) {
        var entries, entry_stat;

        if (entry_stats) {
          entries = (function() {
            var _i, _len, _results;

            _results = [];
            for (_i = 0, _len = entry_stats.length; _i < _len; _i++) {
              entry_stat = entry_stats[_i];
              _results.push(entry_stat.name);
            }
            return _results;
          })();
        } else {
          entries = null;
        }
        return callback(error, entries, stat, entry_stats);
      });
    };

    Client.prototype.metadata = function(path, options, callback) {
      return this.stat(path, options, callback);
    };

    Client.prototype.makeUrl = function(path, options, callback) {
      var isDirect, params, url, useDownloadHack, xhr,
        _this = this;

      if ((!callback) && (typeof options === 'function')) {
        callback = options;
        options = null;
      }
      if (options && (options['long'] || options.longUrl || options.downloadHack)) {
        params = {
          short_url: 'false'
        };
      } else {
        params = {};
      }
      path = this.urlEncodePath(path);
      url = "" + this.urls.shares + "/" + path;
      isDirect = false;
      useDownloadHack = false;
      if (options) {
        if (options.downloadHack) {
          isDirect = true;
          useDownloadHack = true;
        } else if (options.download) {
          isDirect = true;
          url = "" + this.urls.media + "/" + path;
        }
      }
      xhr = new Dropbox.Xhr('POST', url).setParams(params).signWithOauth(this.oauth);
      return this.dispatchXhr(xhr, function(error, urlData) {
        if (useDownloadHack && (urlData != null ? urlData.url : void 0)) {
          urlData.url = urlData.url.replace(_this.authServer, _this.downloadServer);
        }
        return callback(error, Dropbox.PublicUrl.parse(urlData, isDirect));
      });
    };

    Client.prototype.history = function(path, options, callback) {
      var httpCache, params, xhr;

      if ((!callback) && (typeof options === 'function')) {
        callback = options;
        options = null;
      }
      params = {};
      httpCache = false;
      if (options) {
        if (options.limit != null) {
          params.rev_limit = options.limit;
        }
        if (options.httpCache) {
          httpCache = true;
        }
      }
      xhr = new Dropbox.Xhr('GET', "" + this.urls.revisions + "/" + (this.urlEncodePath(path)));
      xhr.setParams(params).signWithOauth(this.oauth, httpCache);
      return this.dispatchXhr(xhr, function(error, versions) {
        var metadata, stats;

        if (versions) {
          stats = (function() {
            var _i, _len, _results;

            _results = [];
            for (_i = 0, _len = versions.length; _i < _len; _i++) {
              metadata = versions[_i];
              _results.push(Dropbox.Stat.parse(metadata));
            }
            return _results;
          })();
        } else {
          stats = void 0;
        }
        return callback(error, stats);
      });
    };

    Client.prototype.revisions = function(path, options, callback) {
      return this.history(path, options, callback);
    };

    Client.prototype.thumbnailUrl = function(path, options) {
      var xhr;

      xhr = this.thumbnailXhr(path, options);
      return xhr.paramsToUrl().url;
    };

    Client.prototype.readThumbnail = function(path, options, callback) {
      var responseType, xhr;

      if ((!callback) && (typeof options === 'function')) {
        callback = options;
        options = null;
      }
      responseType = 'b';
      if (options) {
        if (options.blob) {
          responseType = 'blob';
        }
        if (options.arrayBuffer) {
          responseType = 'arraybuffer';
        }
        if (options.buffer) {
          responseType = 'buffer';
        }
      }
      xhr = this.thumbnailXhr(path, options);
      xhr.setResponseType(responseType);
      return this.dispatchXhr(xhr, function(error, data, metadata) {
        return callback(error, data, Dropbox.Stat.parse(metadata));
      });
    };

    Client.prototype.thumbnailXhr = function(path, options) {
      var params, xhr;

      params = {};
      if (options) {
        if (options.format) {
          params.format = options.format;
        } else if (options.png) {
          params.format = 'png';
        }
        if (options.size) {
          params.size = options.size;
        }
      }
      xhr = new Dropbox.Xhr('GET', "" + this.urls.thumbnails + "/" + (this.urlEncodePath(path)));
      return xhr.setParams(params).signWithOauth(this.oauth);
    };

    Client.prototype.revertFile = function(path, versionTag, callback) {
      var xhr;

      xhr = new Dropbox.Xhr('POST', "" + this.urls.restore + "/" + (this.urlEncodePath(path)));
      xhr.setParams({
        rev: versionTag
      }).signWithOauth(this.oauth);
      return this.dispatchXhr(xhr, function(error, metadata) {
        if (callback) {
          return callback(error, Dropbox.Stat.parse(metadata));
        }
      });
    };

    Client.prototype.restore = function(path, versionTag, callback) {
      return this.revertFile(path, versionTag, callback);
    };

    Client.prototype.findByName = function(path, namePattern, options, callback) {
      var httpCache, params, xhr;

      if ((!callback) && (typeof options === 'function')) {
        callback = options;
        options = null;
      }
      params = {
        query: namePattern
      };
      httpCache = false;
      if (options) {
        if (options.limit != null) {
          params.file_limit = options.limit;
        }
        if (options.removed || options.deleted) {
          params.include_deleted = true;
        }
        if (options.httpCache) {
          httpCache = true;
        }
      }
      xhr = new Dropbox.Xhr('GET', "" + this.urls.search + "/" + (this.urlEncodePath(path)));
      xhr.setParams(params).signWithOauth(this.oauth, httpCache);
      return this.dispatchXhr(xhr, function(error, results) {
        var metadata, stats;

        if (results) {
          stats = (function() {
            var _i, _len, _results;

            _results = [];
            for (_i = 0, _len = results.length; _i < _len; _i++) {
              metadata = results[_i];
              _results.push(Dropbox.Stat.parse(metadata));
            }
            return _results;
          })();
        } else {
          stats = void 0;
        }
        return callback(error, stats);
      });
    };

    Client.prototype.search = function(path, namePattern, options, callback) {
      return this.findByName(path, namePattern, options, callback);
    };

    Client.prototype.makeCopyReference = function(path, callback) {
      var xhr;

      xhr = new Dropbox.Xhr('GET', "" + this.urls.copyRef + "/" + (this.urlEncodePath(path)));
      xhr.signWithOauth(this.oauth);
      return this.dispatchXhr(xhr, function(error, refData) {
        return callback(error, Dropbox.CopyReference.parse(refData));
      });
    };

    Client.prototype.copyRef = function(path, callback) {
      return this.makeCopyReference(path, callback);
    };

    Client.prototype.pullChanges = function(cursor, callback) {
      var params, xhr;

      if ((!callback) && (typeof cursor === 'function')) {
        callback = cursor;
        cursor = null;
      }
      if (cursor) {
        if (cursor.cursorTag) {
          params = {
            cursor: cursor.cursorTag
          };
        } else {
          params = {
            cursor: cursor
          };
        }
      } else {
        params = {};
      }
      xhr = new Dropbox.Xhr('POST', this.urls.delta);
      xhr.setParams(params).signWithOauth(this.oauth);
      return this.dispatchXhr(xhr, function(error, deltaInfo) {
        return callback(error, Dropbox.PulledChanges.parse(deltaInfo));
      });
    };

    Client.prototype.delta = function(cursor, callback) {
      return this.pullChanges(cursor, callback);
    };

    Client.prototype.mkdir = function(path, callback) {
      var xhr;

      xhr = new Dropbox.Xhr('POST', this.urls.fileopsCreateFolder);
      xhr.setParams({
        root: this.fileRoot,
        path: this.normalizePath(path)
      }).signWithOauth(this.oauth);
      return this.dispatchXhr(xhr, function(error, metadata) {
        if (callback) {
          return callback(error, Dropbox.Stat.parse(metadata));
        }
      });
    };

    Client.prototype.remove = function(path, callback) {
      var xhr;

      xhr = new Dropbox.Xhr('POST', this.urls.fileopsDelete);
      xhr.setParams({
        root: this.fileRoot,
        path: this.normalizePath(path)
      }).signWithOauth(this.oauth);
      return this.dispatchXhr(xhr, function(error, metadata) {
        if (callback) {
          return callback(error, Dropbox.Stat.parse(metadata));
        }
      });
    };

    Client.prototype.unlink = function(path, callback) {
      return this.remove(path, callback);
    };

    Client.prototype["delete"] = function(path, callback) {
      return this.remove(path, callback);
    };

    Client.prototype.copy = function(from, toPath, callback) {
      var options, params, xhr;

      if ((!callback) && (typeof options === 'function')) {
        callback = options;
        options = null;
      }
      params = {
        root: this.fileRoot,
        to_path: this.normalizePath(toPath)
      };
      if (from instanceof Dropbox.CopyReference) {
        params.from_copy_ref = from.tag;
      } else {
        params.from_path = this.normalizePath(from);
      }
      xhr = new Dropbox.Xhr('POST', this.urls.fileopsCopy);
      xhr.setParams(params).signWithOauth(this.oauth);
      return this.dispatchXhr(xhr, function(error, metadata) {
        if (callback) {
          return callback(error, Dropbox.Stat.parse(metadata));
        }
      });
    };

    Client.prototype.move = function(fromPath, toPath, callback) {
      var options, xhr;

      if ((!callback) && (typeof options === 'function')) {
        callback = options;
        options = null;
      }
      xhr = new Dropbox.Xhr('POST', this.urls.fileopsMove);
      xhr.setParams({
        root: this.fileRoot,
        from_path: this.normalizePath(fromPath),
        to_path: this.normalizePath(toPath)
      }).signWithOauth(this.oauth);
      return this.dispatchXhr(xhr, function(error, metadata) {
        if (callback) {
          return callback(error, Dropbox.Stat.parse(metadata));
        }
      });
    };

    Client.prototype.reset = function() {
      var oldAuthState;

      this.uid = null;
      this.oauth.setToken(null, '');
      oldAuthState = this.authState;
      this.authState = DropboxClient.RESET;
      if (oldAuthState !== this.authState) {
        this.onAuthStateChange.dispatch(this);
      }
      this.authError = null;
      this._credentials = null;
      return this;
    };

    Client.prototype.setCredentials = function(credentials) {
      var oldAuthState;

      oldAuthState = this.authState;
      this.oauth.reset(credentials);
      this.uid = credentials.uid || null;
      if (credentials.authState) {
        this.authState = credentials.authState;
      } else {
        if (credentials.token) {
          this.authState = DropboxClient.DONE;
        } else {
          this.authState = DropboxClient.RESET;
        }
      }
      this.authError = null;
      this._credentials = null;
      if (oldAuthState !== this.authState) {
        this.onAuthStateChange.dispatch(this);
      }
      return this;
    };

    Client.prototype.appHash = function() {
      return this.oauth.appHash();
    };

    Client.prototype.setupUrls = function() {
      this.fileRoot = this.sandbox ? 'sandbox' : 'dropbox';
      return this.urls = {
        requestToken: "" + this.apiServer + "/1/oauth/request_token",
        authorize: "" + this.authServer + "/1/oauth/authorize",
        accessToken: "" + this.apiServer + "/1/oauth/access_token",
        signOut: "" + this.apiServer + "/1/unlink_access_token",
        accountInfo: "" + this.apiServer + "/1/account/info",
        getFile: "" + this.fileServer + "/1/files/" + this.fileRoot,
        postFile: "" + this.fileServer + "/1/files/" + this.fileRoot,
        putFile: "" + this.fileServer + "/1/files_put/" + this.fileRoot,
        metadata: "" + this.apiServer + "/1/metadata/" + this.fileRoot,
        delta: "" + this.apiServer + "/1/delta",
        revisions: "" + this.apiServer + "/1/revisions/" + this.fileRoot,
        restore: "" + this.apiServer + "/1/restore/" + this.fileRoot,
        search: "" + this.apiServer + "/1/search/" + this.fileRoot,
        shares: "" + this.apiServer + "/1/shares/" + this.fileRoot,
        media: "" + this.apiServer + "/1/media/" + this.fileRoot,
        copyRef: "" + this.apiServer + "/1/copy_ref/" + this.fileRoot,
        thumbnails: "" + this.fileServer + "/1/thumbnails/" + this.fileRoot,
        chunkedUpload: "" + this.fileServer + "/1/chunked_upload",
        commitChunkedUpload: "" + this.fileServer + "/1/commit_chunked_upload/" + this.fileRoot,
        fileopsCopy: "" + this.apiServer + "/1/fileops/copy",
        fileopsCreateFolder: "" + this.apiServer + "/1/fileops/create_folder",
        fileopsDelete: "" + this.apiServer + "/1/fileops/delete",
        fileopsMove: "" + this.apiServer + "/1/fileops/move"
      };
    };

    Client.prototype.authState = null;

    Client.ERROR = 0;

    Client.RESET = 1;

    Client.REQUEST = 2;

    Client.AUTHORIZED = 3;

    Client.DONE = 4;

    Client.SIGNED_OFF = 5;

    Client.prototype.urlEncodePath = function(path) {
      return Dropbox.Xhr.urlEncodeValue(this.normalizePath(path)).replace(/%2F/gi, '/');
    };

    Client.prototype.normalizePath = function(path) {
      var i;

      if (path.substring(0, 1) === '/') {
        i = 1;
        while (path.substring(i, i + 1) === '/') {
          i += 1;
        }
        return path.substring(i);
      } else {
        return path;
      }
    };

    Client.prototype.requestToken = function(callback) {
      var xhr;

      xhr = new Dropbox.Xhr('POST', this.urls.requestToken).signWithOauth(this.oauth);
      return this.dispatchXhr(xhr, callback);
    };

    Client.prototype.authorizeUrl = function(token) {
      var callbackUrl, params;

      callbackUrl = this.driver.url(token);
      if (callbackUrl === null) {
        params = {
          oauth_token: token
        };
      } else {
        params = {
          oauth_token: token,
          oauth_callback: callbackUrl
        };
      }
      return ("" + this.urls.authorize + "?") + Dropbox.Xhr.urlEncode(params);
    };

    Client.prototype.getAccessToken = function(callback) {
      var xhr;

      xhr = new Dropbox.Xhr('POST', this.urls.accessToken).signWithOauth(this.oauth);
      return this.dispatchXhr(xhr, callback);
    };

    Client.prototype.dispatchXhr = function(xhr, callback) {
      var nativeXhr;

      xhr.setCallback(callback);
      xhr.onError = this.xhrOnErrorHandler;
      xhr.prepare();
      nativeXhr = xhr.xhr;
      if (this.onXhr.dispatch(xhr)) {
        xhr.send();
      }
      return nativeXhr;
    };

    Client.prototype.handleXhrError = function(error, callback) {
      var _this = this;

      if (error.status === Dropbox.ApiError.INVALID_TOKEN && this.authState === DropboxClient.DONE) {
        this.authError = error;
        this.authState = DropboxClient.ERROR;
        this.onAuthStateChange.dispatch(this);
        if (this.driver && this.driver.onAuthStateChange) {
          this.driver.onAuthStateChange(this, function() {
            _this.onError.dispatch(error);
            return callback(error);
          });
          return null;
        }
      }
      this.onError.dispatch(error);
      callback(error);
      return null;
    };

    Client.prototype.defaultApiServer = function() {
      return 'https://api.dropbox.com';
    };

    Client.prototype.defaultAuthServer = function() {
      return this.apiServer.replace('api.', 'www.');
    };

    Client.prototype.defaultFileServer = function() {
      return this.apiServer.replace('api.', 'api-content.');
    };

    Client.prototype.defaultDownloadServer = function() {
      return this.apiServer.replace('api.', 'dl.');
    };

    Client.prototype.computeCredentials = function() {
      var value;

      value = {
        key: this.oauth.key,
        sandbox: this.sandbox
      };
      if (this.oauth.secret) {
        value.secret = this.oauth.secret;
      }
      if (this.oauth.token) {
        value.token = this.oauth.token;
        value.tokenSecret = this.oauth.tokenSecret;
      }
      if (this.uid) {
        value.uid = this.uid;
      }
      if (this.authState !== DropboxClient.ERROR && this.authState !== DropboxClient.RESET && this.authState !== DropboxClient.DONE && this.authState !== DropboxClient.SIGNED_OFF) {
        value.authState = this.authState;
      }
      if (this.apiServer !== this.defaultApiServer()) {
        value.server = this.apiServer;
      }
      if (this.authServer !== this.defaultAuthServer()) {
        value.authServer = this.authServer;
      }
      if (this.fileServer !== this.defaultFileServer()) {
        value.fileServer = this.fileServer;
      }
      if (this.downloadServer !== this.defaultDownloadServer()) {
        value.downloadServer = this.downloadServer;
      }
      return this._credentials = value;
    };

    return Client;

  })();

  DropboxClient = Dropbox.Client;

  Dropbox.Drivers.BrowserBase = (function() {
    function BrowserBase(options) {
      this.rememberUser = (options != null ? options.rememberUser : void 0) || false;
      this.useQuery = (options != null ? options.useQuery : void 0) || false;
      this.scope = (options != null ? options.scope : void 0) || 'default';
      this.storageKey = null;
      this.dbTokenRe = new RegExp("(#|\\?|&)dboauth_token=([^&#]+)(&|#|$)");
      this.rejectedRe = new RegExp("(#|\\?|&)not_approved=true(&|#|$)");
      this.tokenRe = new RegExp("(#|\\?|&)oauth_token=([^&#]+)(&|#|$)");
    }

    BrowserBase.prototype.onAuthStateChange = function(client, callback) {
      var _this = this;

      this.setStorageKey(client);
      switch (client.authState) {
        case DropboxClient.RESET:
          return this.loadCredentials(function(credentials) {
            if (!credentials) {
              return callback();
            }
            if (credentials.authState) {
              client.setCredentials(credentials);
              return callback();
            }
            if (!_this.rememberUser) {
              return _this.forgetCredentials(callback);
            }
            client.setCredentials(credentials);
            return client.getUserInfo(function(error) {
              if (error) {
                client.reset();
                return _this.forgetCredentials(callback);
              } else {
                return callback();
              }
            });
          });
        case DropboxClient.REQUEST:
          return this.storeCredentials(client.credentials(), callback);
        case DropboxClient.DONE:
          if (this.rememberUser) {
            return this.storeCredentials(client.credentials(), callback);
          }
          return this.forgetCredentials(callback);
        case DropboxClient.SIGNED_OFF:
          return this.forgetCredentials(callback);
        case DropboxClient.ERROR:
          return this.forgetCredentials(callback);
        default:
          callback();
          return this;
      }
    };

    BrowserBase.prototype.setStorageKey = function(client) {
      this.storageKey = "dropbox-auth:" + this.scope + ":" + (client.appHash());
      return this;
    };

    BrowserBase.prototype.storeCredentials = function(credentials, callback) {
      localStorage.setItem(this.storageKey, JSON.stringify(credentials));
      callback();
      return this;
    };

    BrowserBase.prototype.loadCredentials = function(callback) {
      var jsonError, jsonString;

      jsonString = localStorage.getItem(this.storageKey);
      if (!jsonString) {
        callback(null);
        return this;
      }
      try {
        callback(JSON.parse(jsonString));
      } catch (_error) {
        jsonError = _error;
        callback(null);
      }
      return this;
    };

    BrowserBase.prototype.forgetCredentials = function(callback) {
      localStorage.removeItem(this.storageKey);
      callback();
      return this;
    };

    BrowserBase.prototype.computeUrl = function(baseUrl) {
      var fragment, location, locationPair, querySuffix;

      querySuffix = "_dropboxjs_scope=" + (encodeURIComponent(this.scope)) + "&dboauth_token=";
      location = baseUrl;
      if (location.indexOf('#') === -1) {
        fragment = null;
      } else {
        locationPair = location.split('#', 2);
        location = locationPair[0];
        fragment = locationPair[1];
      }
      if (this.useQuery) {
        if (location.indexOf('?') === -1) {
          location += "?" + querySuffix;
        } else {
          location += "&" + querySuffix;
        }
        if (fragment) {
          return [location, '#' + fragment];
        } else {
          return [location, ''];
        }
      } else {
        return [location + '#?' + querySuffix, ''];
      }
    };

    BrowserBase.prototype.locationToken = function(url) {
      var location, match, scopePattern;

      location = url || Dropbox.Drivers.BrowserBase.currentLocation();
      scopePattern = "_dropboxjs_scope=" + (encodeURIComponent(this.scope)) + "&";
      if ((typeof location.indexOf === "function" ? location.indexOf(scopePattern) : void 0) === -1) {
        return null;
      }
      if (this.rejectedRe.test(location)) {
        match = this.dbTokenRe.exec(location);
        if (match) {
          return decodeURIComponent(match[2]);
        } else {
          return null;
        }
      }
      match = this.tokenRe.exec(location);
      if (match) {
        return decodeURIComponent(match[2]);
      }
      return null;
    };

    BrowserBase.currentLocation = function() {
      return window.location.href;
    };

    return BrowserBase;

  })();

  Dropbox.Drivers.Redirect = (function(_super) {
    __extends(Redirect, _super);

    function Redirect(options) {
      var _ref;

      Redirect.__super__.constructor.call(this, options);
      _ref = this.computeUrl(Dropbox.Drivers.BrowserBase.currentLocation()), this.receiverUrl1 = _ref[0], this.receiverUrl2 = _ref[1];
    }

    Redirect.prototype.onAuthStateChange = function(client, callback) {
      var superCall,
        _this = this;

      superCall = (function() {
        return function() {
          return Redirect.__super__.onAuthStateChange.call(_this, client, callback);
        };
      })();
      this.setStorageKey(client);
      if (client.authState === DropboxClient.RESET) {
        return this.loadCredentials(function(credentials) {
          if (credentials && credentials.authState) {
            if (credentials.token === _this.locationToken() && credentials.authState === DropboxClient.REQUEST) {
              credentials.authState = DropboxClient.AUTHORIZED;
              return _this.storeCredentials(credentials, superCall);
            } else {
              return _this.forgetCredentials(superCall);
            }
          }
          return superCall();
        });
      } else {
        return superCall();
      }
    };

    Redirect.prototype.url = function(token) {
      return this.receiverUrl1 + encodeURIComponent(token) + this.receiverUrl2;
    };

    Redirect.prototype.doAuthorize = function(authUrl) {
      return window.location.assign(authUrl);
    };

    return Redirect;

  })(Dropbox.Drivers.BrowserBase);

  Dropbox.Drivers.Popup = (function(_super) {
    __extends(Popup, _super);

    function Popup(options) {
      var _ref;

      Popup.__super__.constructor.call(this, options);
      _ref = this.computeUrl(this.baseUrl(options)), this.receiverUrl1 = _ref[0], this.receiverUrl2 = _ref[1];
    }

    Popup.prototype.onAuthStateChange = function(client, callback) {
      var superCall,
        _this = this;

      superCall = (function() {
        return function() {
          return Popup.__super__.onAuthStateChange.call(_this, client, callback);
        };
      })();
      this.setStorageKey(client);
      if (client.authState === DropboxClient.RESET) {
        return this.loadCredentials(function(credentials) {
          if (credentials && credentials.authState) {
            return _this.forgetCredentials(superCall);
          }
          return superCall();
        });
      } else {
        return superCall();
      }
    };

    Popup.prototype.doAuthorize = function(authUrl, token, tokenSecret, callback) {
      this.listenForMessage(token, callback);
      return this.openWindow(authUrl);
    };

    Popup.prototype.url = function(token) {
      return this.receiverUrl1 + encodeURIComponent(token) + this.receiverUrl2;
    };

    Popup.prototype.baseUrl = function(options) {
      var fragments;

      if (options) {
        if (options.receiverUrl) {
          return options.receiverUrl;
        } else if (options.receiverFile) {
          fragments = Dropbox.Drivers.BrowserBase.currentLocation().split('/');
          fragments[fragments.length - 1] = options.receiverFile;
          return fragments.join('/');
        }
      }
      return Dropbox.Drivers.BrowserBase.currentLocation();
    };

    Popup.prototype.openWindow = function(url) {
      return window.open(url, '_dropboxOauthSigninWindow', this.popupWindowSpec(980, 700));
    };

    Popup.prototype.popupWindowSpec = function(popupWidth, popupHeight) {
      var height, popupLeft, popupTop, width, x0, y0, _ref, _ref1, _ref2, _ref3;

      x0 = (_ref = window.screenX) != null ? _ref : window.screenLeft;
      y0 = (_ref1 = window.screenY) != null ? _ref1 : window.screenTop;
      width = (_ref2 = window.outerWidth) != null ? _ref2 : document.documentElement.clientWidth;
      height = (_ref3 = window.outerHeight) != null ? _ref3 : document.documentElement.clientHeight;
      popupLeft = Math.round(x0 + (width - popupWidth) / 2);
      popupTop = Math.round(y0 + (height - popupHeight) / 2.5);
      if (popupLeft < x0) {
        popupLeft = x0;
      }
      if (popupTop < y0) {
        popupTop = y0;
      }
      return ("width=" + popupWidth + ",height=" + popupHeight + ",") + ("left=" + popupLeft + ",top=" + popupTop) + 'dialog=yes,dependent=yes,scrollbars=yes,location=yes';
    };

    Popup.prototype.listenForMessage = function(token, callback) {
      var listener,
        _this = this;

      listener = function(event) {
        var data;

        if (event.data) {
          data = event.data;
        } else {
          data = event;
        }
        if (_this.locationToken(data) === token) {
          token = null;
          window.removeEventListener('message', listener);
          Dropbox.Drivers.Popup.onMessage.removeListener(listener);
          return callback();
        }
      };
      window.addEventListener('message', listener, false);
      return Dropbox.Drivers.Popup.onMessage.addListener(listener);
    };

    Popup.oauthReceiver = function() {
      return window.addEventListener('load', function() {
        var frameError, ieError, opener;

        opener = window.opener;
        if (window.parent !== window.top) {
          opener || (opener = window.parent);
        }
        if (opener) {
          try {
            opener.postMessage(window.location.href, '*');
          } catch (_error) {
            ieError = _error;
          }
          try {
            opener.Dropbox.Drivers.Popup.onMessage.dispatch(window.location.href);
          } catch (_error) {
            frameError = _error;
          }
        }
        return window.close();
      });
    };

    Popup.onMessage = new Dropbox.EventSource;

    return Popup;

  })(Dropbox.Drivers.BrowserBase);

  DropboxChromeOnMessage = null;

  DropboxChromeSendMessage = null;

  if (typeof chrome !== "undefined" && chrome !== null) {
    if (chrome.runtime) {
      if (chrome.runtime.onMessage) {
        DropboxChromeOnMessage = chrome.runtime.onMessage;
      }
      if (chrome.runtime.sendMessage) {
        DropboxChromeSendMessage = function(m) {
          return chrome.runtime.sendMessage(m);
        };
      }
    }
    if (chrome.extension) {
      if (chrome.extension.onMessage) {
        DropboxChromeOnMessage || (DropboxChromeOnMessage = chrome.extension.onMessage);
      }
      if (chrome.extension.sendMessage) {
        DropboxChromeSendMessage || (DropboxChromeSendMessage = function(m) {
          return chrome.extension.sendMessage(m);
        });
      }
    }
    if (!DropboxChromeOnMessage) {
      (function() {
        var page, pageHack;

        pageHack = function(page) {
          if (page.Dropbox) {
            Dropbox.Drivers.Chrome.prototype.onMessage = page.Dropbox.Drivers.Chrome.onMessage;
            return Dropbox.Drivers.Chrome.prototype.sendMessage = page.Dropbox.Drivers.Chrome.sendMessage;
          } else {
            page.Dropbox = Dropbox;
            Dropbox.Drivers.Chrome.prototype.onMessage = new Dropbox.EventSource;
            return Dropbox.Drivers.Chrome.prototype.sendMessage = function(m) {
              return Dropbox.Drivers.Chrome.prototype.onMessage.dispatch(m);
            };
          }
        };
        if (chrome.extension && chrome.extension.getBackgroundPage) {
          if (page = chrome.extension.getBackgroundPage()) {
            return pageHack(page);
          }
        }
        if (chrome.runtime && chrome.runtime.getBackgroundPage) {
          return chrome.runtime.getBackgroundPage(function(page) {
            return pageHack(page);
          });
        }
      })();
    }
  }

  Dropbox.Drivers.Chrome = (function(_super) {
    __extends(Chrome, _super);

    Chrome.prototype.onMessage = DropboxChromeOnMessage;

    Chrome.prototype.sendMessage = DropboxChromeSendMessage;

    Chrome.prototype.expandUrl = function(url) {
      if (chrome.runtime && chrome.runtime.getURL) {
        return chrome.runtime.getURL(url);
      }
      if (chrome.extension && chrome.extension.getURL) {
        return chrome.extension.getURL(url);
      }
      return url;
    };

    function Chrome(options) {
      var receiverPath, _ref;

      Chrome.__super__.constructor.call(this, options);
      receiverPath = (options && options.receiverPath) || 'chrome_oauth_receiver.html';
      this.rememberUser = true;
      this.useQuery = true;
      _ref = this.computeUrl(this.expandUrl(receiverPath)), this.receiverUrl = _ref[0], this.receiverUrl2 = _ref[1];
      this.storageKey = "dropbox_js_" + this.scope + "_credentials";
    }

    Chrome.prototype.onAuthStateChange = function(client, callback) {
      var _this = this;

      switch (client.authState) {
        case Dropbox.Client.RESET:
          return this.loadCredentials(function(credentials) {
            if (credentials) {
              if (credentials.authState) {
                return _this.forgetCredentials(callback);
              }
              client.setCredentials(credentials);
            }
            return callback();
          });
        case Dropbox.Client.DONE:
          return this.storeCredentials(client.credentials(), callback);
        case Dropbox.Client.SIGNED_OFF:
          return this.forgetCredentials(callback);
        case Dropbox.Client.ERROR:
          return this.forgetCredentials(callback);
        default:
          return callback();
      }
    };

    Chrome.prototype.doAuthorize = function(authUrl, token, tokenSecret, callback) {
      var window, _ref, _ref1, _ref2,
        _this = this;

      if ((_ref = chrome.identity) != null ? _ref.launchWebAuthFlow : void 0) {
        return chrome.identity.launchWebAuthFlow({
          url: authUrl,
          interactive: true
        }, function(redirectUrl) {
          if (_this.locationToken(redirectUrl) === token) {
            return callback();
          }
        });
      } else if ((_ref1 = chrome.experimental) != null ? (_ref2 = _ref1.identity) != null ? _ref2.launchWebAuthFlow : void 0 : void 0) {
        return chrome.experimental.identity.launchWebAuthFlow({
          url: authUrl,
          interactive: true
        }, function(redirectUrl) {
          if (_this.locationToken(redirectUrl) === token) {
            return callback();
          }
        });
      } else {
        window = {
          handle: null
        };
        this.listenForMessage(token, window, callback);
        return this.openWindow(authUrl, function(handle) {
          return window.handle = handle;
        });
      }
    };

    Chrome.prototype.openWindow = function(url, callback) {
      if (chrome.tabs && chrome.tabs.create) {
        chrome.tabs.create({
          url: url,
          active: true,
          pinned: false
        }, function(tab) {
          return callback(tab);
        });
        return this;
      }
      return this;
    };

    Chrome.prototype.closeWindow = function(handle) {
      if (chrome.tabs && chrome.tabs.remove && handle.id) {
        chrome.tabs.remove(handle.id);
        return this;
      }
      if (chrome.app && chrome.app.window && handle.close) {
        handle.close();
        return this;
      }
      return this;
    };

    Chrome.prototype.url = function(token) {
      return this.receiverUrl + encodeURIComponent(token);
    };

    Chrome.prototype.listenForMessage = function(token, window, callback) {
      var listener,
        _this = this;

      listener = function(message, sender) {
        if (sender && sender.tab) {
          if (sender.tab.url.substring(0, _this.receiverUrl.length) !== _this.receiverUrl) {
            return;
          }
        }
        if (!message.dropbox_oauth_receiver_href) {
          return;
        }
        if (_this.locationToken(message.dropbox_oauth_receiver_href) === token) {
          if (window.handle) {
            _this.closeWindow(window.handle);
          }
          _this.onMessage.removeListener(listener);
          return callback();
        }
      };
      return this.onMessage.addListener(listener);
    };

    Chrome.prototype.storeCredentials = function(credentials, callback) {
      var items;

      items = {};
      items[this.storageKey] = credentials;
      chrome.storage.local.set(items, callback);
      return this;
    };

    Chrome.prototype.loadCredentials = function(callback) {
      var _this = this;

      chrome.storage.local.get(this.storageKey, function(items) {
        return callback(items[_this.storageKey] || null);
      });
      return this;
    };

    Chrome.prototype.forgetCredentials = function(callback) {
      chrome.storage.local.remove(this.storageKey, callback);
      return this;
    };

    Chrome.oauthReceiver = function() {
      return window.addEventListener('load', function() {
        var driver;

        driver = new Dropbox.Drivers.Chrome();
        driver.sendMessage({
          dropbox_oauth_receiver_href: window.location.href
        });
        if (window.close) {
          return window.close();
        }
      });
    };

    return Chrome;

  })(Dropbox.Drivers.BrowserBase);

  Dropbox.Drivers.Cordova = (function(_super) {
    __extends(Cordova, _super);

    function Cordova(options) {
      this.rememberUser = (options != null ? options.rememberUser : void 0) || false;
      this.scope = (options != null ? options.scope : void 0) || 'default';
    }

    Cordova.prototype.doAuthorize = function(authUrl, token, tokenSecret, callback) {
      var authHost, browser, onEvent, promptPageLoaded;

      browser = window.open(authUrl, '_blank', 'location=yes');
      promptPageLoaded = false;
      authHost = /^[^/]*\/\/[^/]*\//.exec(authUrl)[0];
      onEvent = function(event) {
        if (event.url === authUrl && promptPageLoaded === false) {
          promptPageLoaded = true;
          return;
        }
        if (event.url && event.url.substring(0, authHost.length) !== authHost) {
          promptPageLoaded = false;
          return;
        }
        if (event.type === 'exit' || promptPageLoaded) {
          browser.removeEventListener('loadstop', onEvent);
          browser.removeEventListener('exit', onEvent);
          if (event.type !== 'exit') {
            browser.close();
          }
          return callback();
        }
      };
      browser.addEventListener('loadstop', onEvent);
      return browser.addEventListener('exit', onEvent);
    };

    Cordova.prototype.url = function() {
      return null;
    };

    Cordova.prototype.onAuthStateChange = function(client, callback) {
      var superCall,
        _this = this;

      superCall = (function() {
        return function() {
          return Cordova.__super__.onAuthStateChange.call(_this, client, callback);
        };
      })();
      this.setStorageKey(client);
      if (client.authState === DropboxClient.RESET) {
        return this.loadCredentials(function(credentials) {
          if (credentials && credentials.authState) {
            return _this.forgetCredentials(superCall);
          } else {
            return superCall();
          }
        });
      } else {
        return superCall();
      }
    };

    return Cordova;

  })(Dropbox.Drivers.BrowserBase);

  Dropbox.Drivers.NodeServer = (function() {
    function NodeServer(options) {
      this.port = (options != null ? options.port : void 0) || 8912;
      this.faviconFile = (options != null ? options.favicon : void 0) || null;
      this.fs = require('fs');
      this.http = require('http');
      this.open = require('open');
      this.callbacks = {};
      this.nodeUrl = require('url');
      this.createApp();
    }

    NodeServer.prototype.url = function(token) {
      return ("http://localhost:" + this.port + "/oauth_callback?dboauth_token=") + encodeURIComponent(token);
    };

    NodeServer.prototype.doAuthorize = function(authUrl, token, tokenSecret, callback) {
      this.callbacks[token] = callback;
      return this.openBrowser(authUrl);
    };

    NodeServer.prototype.openBrowser = function(url) {
      if (!url.match(/^https?:\/\//)) {
        throw new Error("Not a http/https URL: " + url);
      }
      if ('BROWSER' in process.env) {
        return this.open(url, process.env['BROWSER']);
      } else {
        return this.open(url);
      }
    };

    NodeServer.prototype.createApp = function() {
      var _this = this;

      this.app = this.http.createServer(function(request, response) {
        return _this.doRequest(request, response);
      });
      return this.app.listen(this.port);
    };

    NodeServer.prototype.closeServer = function() {
      return this.app.close();
    };

    NodeServer.prototype.doRequest = function(request, response) {
      var data, rejected, token, url,
        _this = this;

      url = this.nodeUrl.parse(request.url, true);
      if (url.pathname === '/oauth_callback') {
        if (url.query.not_approved === 'true') {
          rejected = true;
          token = url.query.dboauth_token;
        } else {
          rejected = false;
          token = url.query.oauth_token;
        }
        if (this.callbacks[token]) {
          this.callbacks[token](rejected);
          delete this.callbacks[token];
        }
      }
      data = '';
      request.on('data', function(dataFragment) {
        return data += dataFragment;
      });
      return request.on('end', function() {
        if (_this.faviconFile && (url.pathname === '/favicon.ico')) {
          return _this.sendFavicon(response);
        } else {
          return _this.closeBrowser(response);
        }
      });
    };

    NodeServer.prototype.closeBrowser = function(response) {
      var closeHtml;

      closeHtml = "<!doctype html>\n<script type=\"text/javascript\">window.close();</script>\n<p>Please close this window.</p>";
      response.writeHead(200, {
        'Content-Length': closeHtml.length,
        'Content-Type': 'text/html'
      });
      response.write(closeHtml);
      return response.end();
    };

    NodeServer.prototype.sendFavicon = function(response) {
      return this.fs.readFile(this.faviconFile, function(error, data) {
        response.writeHead(200, {
          'Content-Length': data.length,
          'Content-Type': 'image/x-icon'
        });
        response.write(data);
        return response.end();
      });
    };

    return NodeServer;

  })();

  base64HmacSha1 = function(string, key) {
    return arrayToBase64(hmacSha1(stringToArray(string), stringToArray(key), string.length, key.length));
  };

  base64Sha1 = function(string) {
    return arrayToBase64(sha1(stringToArray(string), string.length));
  };

  if (typeof require !== 'undefined') {
    try {
      crypto = require('crypto');
      if (crypto.createHmac && crypto.createHash) {
        base64HmacSha1 = function(string, key) {
          var hmac;

          hmac = crypto.createHmac('sha1', key);
          hmac.update(string);
          return hmac.digest('base64');
        };
        base64Sha1 = function(string) {
          var hash;

          hash = crypto.createHash('sha1');
          hash.update(string);
          return hash.digest('base64');
        };
      }
    } catch (_error) {
      requireError = _error;
    }
  }

  Dropbox.Util.hmac = base64HmacSha1;

  Dropbox.Util.sha1 = base64Sha1;

  hmacSha1 = function(string, key, length, keyLength) {
    var hash1, i, ipad, opad;

    if (key.length > 16) {
      key = sha1(key, keyLength);
    }
    ipad = (function() {
      var _i, _results;

      _results = [];
      for (i = _i = 0; _i < 16; i = ++_i) {
        _results.push(key[i] ^ 0x36363636);
      }
      return _results;
    })();
    opad = (function() {
      var _i, _results;

      _results = [];
      for (i = _i = 0; _i < 16; i = ++_i) {
        _results.push(key[i] ^ 0x5C5C5C5C);
      }
      return _results;
    })();
    hash1 = sha1(ipad.concat(string), 64 + length);
    return sha1(opad.concat(hash1), 64 + 20);
  };

  sha1 = function(string, length) {
    var a, a0, b, b0, c, c0, d, d0, e, e0, ft, i, j, kt, limit, state, t, _i;

    string[length >> 2] |= 1 << (31 - ((length & 0x03) << 3));
    string[(((length + 8) >> 6) << 4) + 15] = length << 3;
    state = Array(80);
    a = 1732584193;
    b = -271733879;
    c = -1732584194;
    d = 271733878;
    e = -1009589776;
    i = 0;
    limit = string.length;
    while (i < limit) {
      a0 = a;
      b0 = b;
      c0 = c;
      d0 = d;
      e0 = e;
      for (j = _i = 0; _i < 80; j = ++_i) {
        if (j < 16) {
          state[j] = string[i + j];
        } else {
          state[j] = rotateLeft32(state[j - 3] ^ state[j - 8] ^ state[j - 14] ^ state[j - 16], 1);
        }
        if (j < 20) {
          ft = (b & c) | ((~b) & d);
          kt = 1518500249;
        } else if (j < 40) {
          ft = b ^ c ^ d;
          kt = 1859775393;
        } else if (j < 60) {
          ft = (b & c) | (b & d) | (c & d);
          kt = -1894007588;
        } else {
          ft = b ^ c ^ d;
          kt = -899497514;
        }
        t = add32(add32(rotateLeft32(a, 5), ft), add32(add32(e, state[j]), kt));
        e = d;
        d = c;
        c = rotateLeft32(b, 30);
        b = a;
        a = t;
      }
      a = add32(a, a0);
      b = add32(b, b0);
      c = add32(c, c0);
      d = add32(d, d0);
      e = add32(e, e0);
      i += 16;
    }
    return [a, b, c, d, e];
  };

  /*
  # Uncomment the definition below for debugging.
  #
  # Returns the hexadecimal representation of a 32-bit number.
  xxx = (n) ->
    if n < 0
      n = (1 << 30) * 4 + n
    n.toString 16
  */


  rotateLeft32 = function(value, count) {
    return (value << count) | (value >>> (32 - count));
  };

  add32 = function(a, b) {
    var high, low;

    low = (a & 0xFFFF) + (b & 0xFFFF);
    high = (a >> 16) + (b >> 16) + (low >> 16);
    return (high << 16) | (low & 0xFFFF);
  };

  arrayToBase64 = function(array) {
    var i, i2, limit, string, trit;

    string = "";
    i = 0;
    limit = array.length * 4;
    while (i < limit) {
      i2 = i;
      trit = ((array[i2 >> 2] >> ((3 - (i2 & 3)) << 3)) & 0xFF) << 16;
      i2 += 1;
      trit |= ((array[i2 >> 2] >> ((3 - (i2 & 3)) << 3)) & 0xFF) << 8;
      i2 += 1;
      trit |= (array[i2 >> 2] >> ((3 - (i2 & 3)) << 3)) & 0xFF;
      string += _base64Digits[(trit >> 18) & 0x3F];
      string += _base64Digits[(trit >> 12) & 0x3F];
      i += 1;
      if (i >= limit) {
        string += '=';
      } else {
        string += _base64Digits[(trit >> 6) & 0x3F];
      }
      i += 1;
      if (i >= limit) {
        string += '=';
      } else {
        string += _base64Digits[trit & 0x3F];
      }
      i += 1;
    }
    return string;
  };

  _base64Digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

  stringToArray = function(string) {
    var array, i, mask, _i, _ref;

    array = [];
    mask = 0xFF;
    for (i = _i = 0, _ref = string.length; 0 <= _ref ? _i < _ref : _i > _ref; i = 0 <= _ref ? ++_i : --_i) {
      array[i >> 2] |= (string.charCodeAt(i) & mask) << ((3 - (i & 3)) << 3);
    }
    return array;
  };

  Dropbox.Oauth = (function() {
    function Oauth(options) {
      this.key = this.k = null;
      this.secret = this.s = null;
      this.token = null;
      this.tokenSecret = null;
      this._appHash = null;
      this.reset(options);
    }

    Oauth.prototype.reset = function(options) {
      var k, s, secret, _ref;

      if (options.secret) {
        this.k = this.key = options.key;
        this.s = this.secret = options.secret;
        this._appHash = null;
      } else if (options.key) {
        this.key = options.key;
        this.secret = null;
        secret = atob(dropboxEncodeKey(this.key).split('|', 2)[1]);
        _ref = secret.split('?', 2), k = _ref[0], s = _ref[1];
        this.k = decodeURIComponent(k);
        this.s = decodeURIComponent(s);
        this._appHash = null;
      } else {
        if (!this.k) {
          throw new Error('No API key supplied');
        }
      }
      if (options.token) {
        return this.setToken(options.token, options.tokenSecret);
      } else {
        return this.setToken(null, '');
      }
    };

    Oauth.prototype.setToken = function(token, tokenSecret) {
      if (token && (!tokenSecret)) {
        throw new Error('No secret supplied with the user token');
      }
      this.token = token;
      this.tokenSecret = tokenSecret || '';
      this.hmacKey = Dropbox.Xhr.urlEncodeValue(this.s) + '&' + Dropbox.Xhr.urlEncodeValue(tokenSecret);
      return null;
    };

    Oauth.prototype.authHeader = function(method, url, params) {
      var header, oauth_params, param, value, _i, _len;

      this.addAuthParams(method, url, params);
      oauth_params = [];
      for (param in params) {
        value = params[param];
        if (param.substring(0, 6) === 'oauth_') {
          oauth_params.push(param);
        }
      }
      oauth_params.sort();
      header = [];
      for (_i = 0, _len = oauth_params.length; _i < _len; _i++) {
        param = oauth_params[_i];
        header.push(Dropbox.Xhr.urlEncodeValue(param) + '="' + Dropbox.Xhr.urlEncodeValue(params[param]) + '"');
        delete params[param];
      }
      return 'OAuth ' + header.join(',');
    };

    Oauth.prototype.addAuthParams = function(method, url, params) {
      this.boilerplateParams(params);
      params.oauth_signature = this.signature(method, url, params);
      return params;
    };

    Oauth.prototype.boilerplateParams = function(params) {
      params.oauth_consumer_key = this.k;
      params.oauth_nonce = Dropbox.Oauth.nonce();
      params.oauth_signature_method = 'HMAC-SHA1';
      if (this.token) {
        params.oauth_token = this.token;
      }
      params.oauth_timestamp = Math.floor(Date.now() / 1000);
      params.oauth_version = '1.0';
      return params;
    };

    Oauth.nonce = function() {
      return Math.random().toString(36);
    };

    Oauth.prototype.signature = function(method, url, params) {
      var string;

      string = method.toUpperCase() + '&' + Dropbox.Xhr.urlEncodeValue(url) + '&' + Dropbox.Xhr.urlEncodeValue(Dropbox.Xhr.urlEncode(params));
      return base64HmacSha1(string, this.hmacKey);
    };

    Oauth.prototype.appHash = function() {
      if (this._appHash) {
        return this._appHash;
      }
      return this._appHash = base64Sha1(this.k).replace(/\=/g, '');
    };

    return Oauth;

  })();

  if (Date.now == null) {
    Date.now = function() {
      return (new Date()).getTime();
    };
  }

  dropboxEncodeKey = function(key, secret) {
    var i, k, result, s, x, y, z, _i, _j, _ref, _ref1, _results;

    if (secret) {
      secret = [encodeURIComponent(key), encodeURIComponent(secret)].join('?');
      key = (function() {
        var _i, _ref, _results;

        _results = [];
        for (i = _i = 0, _ref = key.length / 2; 0 <= _ref ? _i < _ref : _i > _ref; i = 0 <= _ref ? ++_i : --_i) {
          _results.push(((key.charCodeAt(i * 2) & 15) * 16) + (key.charCodeAt(i * 2 + 1) & 15));
        }
        return _results;
      })();
    } else {
      _ref = key.split('|', 2), key = _ref[0], secret = _ref[1];
      key = atob(key);
      key = (function() {
        var _i, _ref1, _results;

        _results = [];
        for (i = _i = 0, _ref1 = key.length; 0 <= _ref1 ? _i < _ref1 : _i > _ref1; i = 0 <= _ref1 ? ++_i : --_i) {
          _results.push(key.charCodeAt(i));
        }
        return _results;
      })();
      secret = atob(secret);
    }
    s = (function() {
      _results = [];
      for (_i = 0; _i < 256; _i++){ _results.push(_i); }
      return _results;
    }).apply(this);
    y = 0;
    for (x = _j = 0; _j < 256; x = ++_j) {
      y = (y + s[i] + key[x % key.length]) % 256;
      _ref1 = [s[y], s[x]], s[x] = _ref1[0], s[y] = _ref1[1];
    }
    x = y = 0;
    result = (function() {
      var _k, _ref2, _ref3, _results1;

      _results1 = [];
      for (z = _k = 0, _ref2 = secret.length; 0 <= _ref2 ? _k < _ref2 : _k > _ref2; z = 0 <= _ref2 ? ++_k : --_k) {
        x = (x + 1) % 256;
        y = (y + s[x]) % 256;
        _ref3 = [s[y], s[x]], s[x] = _ref3[0], s[y] = _ref3[1];
        k = s[(s[x] + s[y]) % 256];
        _results1.push(String.fromCharCode((k ^ secret.charCodeAt(z)) % 256));
      }
      return _results1;
    })();
    key = (function() {
      var _k, _ref2, _results1;

      _results1 = [];
      for (i = _k = 0, _ref2 = key.length; 0 <= _ref2 ? _k < _ref2 : _k > _ref2; i = 0 <= _ref2 ? ++_k : --_k) {
        _results1.push(String.fromCharCode(key[i]));
      }
      return _results1;
    })();
    return [btoa(key.join('')), btoa(result.join(''))].join('|');
  };

  Dropbox.Util.encodeKey = dropboxEncodeKey;

  Dropbox.PulledChanges = (function() {
    PulledChanges.parse = function(deltaInfo) {
      if (deltaInfo && typeof deltaInfo === 'object') {
        return new Dropbox.PulledChanges(deltaInfo);
      } else {
        return deltaInfo;
      }
    };

    PulledChanges.prototype.blankSlate = void 0;

    PulledChanges.prototype.cursorTag = void 0;

    PulledChanges.prototype.changes = void 0;

    PulledChanges.prototype.shouldPullAgain = void 0;

    PulledChanges.prototype.shouldBackOff = void 0;

    PulledChanges.prototype.cursor = function() {
      return this.cursorTag;
    };

    function PulledChanges(deltaInfo) {
      var entry;

      this.blankSlate = deltaInfo.reset || false;
      this.cursorTag = deltaInfo.cursor;
      this.shouldPullAgain = deltaInfo.has_more;
      this.shouldBackOff = !this.shouldPullAgain;
      if (deltaInfo.cursor && deltaInfo.cursor.length) {
        this.changes = (function() {
          var _i, _len, _ref, _results;

          _ref = deltaInfo.entries;
          _results = [];
          for (_i = 0, _len = _ref.length; _i < _len; _i++) {
            entry = _ref[_i];
            _results.push(Dropbox.PullChange.parse(entry));
          }
          return _results;
        })();
      } else {
        this.changes = [];
      }
    }

    return PulledChanges;

  })();

  Dropbox.PullChange = (function() {
    PullChange.parse = function(entry) {
      if (entry && typeof entry === 'object') {
        return new Dropbox.PullChange(entry);
      } else {
        return entry;
      }
    };

    PullChange.prototype.path = void 0;

    PullChange.prototype.wasRemoved = void 0;

    PullChange.prototype.stat = void 0;

    function PullChange(entry) {
      this.path = entry[0];
      this.stat = Dropbox.Stat.parse(entry[1]);
      if (this.stat) {
        this.wasRemoved = false;
      } else {
        this.stat = null;
        this.wasRemoved = true;
      }
    }

    return PullChange;

  })();

  Dropbox.RangeInfo = (function() {
    RangeInfo.parse = function(headerValue) {
      if (typeof headerValue === 'string') {
        return new Dropbox.RangeInfo(headerValue);
      } else {
        return headerValue;
      }
    };

    RangeInfo.prototype.start = null;

    RangeInfo.prototype.size = null;

    RangeInfo.prototype.end = null;

    function RangeInfo(headerValue) {
      var match;

      if (match = /^bytes (\d*)-(\d*)\/(.*)$/.exec(headerValue)) {
        this.start = parseInt(match[1]);
        this.end = parseInt(match[2]);
        if (match[3] === '*') {
          this.size = null;
        } else {
          this.size = parseInt(match[3]);
        }
      } else {
        this.start = 0;
        this.end = 0;
        this.size = null;
      }
    }

    return RangeInfo;

  })();

  Dropbox.PublicUrl = (function() {
    PublicUrl.parse = function(urlData, isDirect) {
      if (urlData && typeof urlData === 'object') {
        return new Dropbox.PublicUrl(urlData, isDirect);
      } else {
        return urlData;
      }
    };

    PublicUrl.prototype.url = null;

    PublicUrl.prototype.expiresAt = null;

    PublicUrl.prototype.isDirect = null;

    PublicUrl.prototype.isPreview = null;

    PublicUrl.prototype.json = function() {
      return this._json || (this._json = {
        url: this.url,
        expires: this.expiresAt.toString(),
        direct: this.isDirect
      });
    };

    function PublicUrl(urlData, isDirect) {
      this.url = urlData.url;
      this.expiresAt = new Date(Date.parse(urlData.expires));
      if (isDirect === true) {
        this.isDirect = true;
      } else if (isDirect === false) {
        this.isDirect = false;
      } else {
        if ('direct' in urlData) {
          this.isDirect = urlData.direct;
        } else {
          this.isDirect = Date.now() - this.expiresAt <= 86400000;
        }
      }
      this.isPreview = !this.isDirect;
      this._json = null;
    }

    return PublicUrl;

  })();

  Dropbox.CopyReference = (function() {
    CopyReference.parse = function(refData) {
      if (refData && (typeof refData === 'object' || typeof refData === 'string')) {
        return new Dropbox.CopyReference(refData);
      } else {
        return refData;
      }
    };

    CopyReference.prototype.tag = null;

    CopyReference.prototype.expiresAt = null;

    CopyReference.prototype.json = function() {
      return this._json || (this._json = {
        copy_ref: this.tag,
        expires: this.expiresAt.toString()
      });
    };

    function CopyReference(refData) {
      if (typeof refData === 'object') {
        this.tag = refData.copy_ref;
        this.expiresAt = new Date(Date.parse(refData.expires));
        this._json = refData;
      } else {
        this.tag = refData;
        this.expiresAt = new Date(Math.ceil(Date.now() / 1000) * 1000);
        this._json = null;
      }
    }

    return CopyReference;

  })();

  Dropbox.Stat = (function() {
    Stat.parse = function(metadata) {
      if (metadata && typeof metadata === 'object') {
        return new Dropbox.Stat(metadata);
      } else {
        return metadata;
      }
    };

    Stat.prototype.path = null;

    Stat.prototype.name = null;

    Stat.prototype.inAppFolder = null;

    Stat.prototype.isFolder = null;

    Stat.prototype.isFile = null;

    Stat.prototype.isRemoved = null;

    Stat.prototype.typeIcon = null;

    Stat.prototype.versionTag = null;

    Stat.prototype.mimeType = null;

    Stat.prototype.size = null;

    Stat.prototype.humanSize = null;

    Stat.prototype.hasThumbnail = null;

    Stat.prototype.modifiedAt = null;

    Stat.prototype.clientModifiedAt = null;

    Stat.prototype.json = function() {
      return this._json;
    };

    function Stat(metadata) {
      var lastIndex, nameSlash, _ref, _ref1;

      this._json = metadata;
      this.path = metadata.path;
      if (this.path.substring(0, 1) !== '/') {
        this.path = '/' + this.path;
      }
      lastIndex = this.path.length - 1;
      if (lastIndex >= 0 && this.path.substring(lastIndex) === '/') {
        this.path = this.path.substring(0, lastIndex);
      }
      nameSlash = this.path.lastIndexOf('/');
      this.name = this.path.substring(nameSlash + 1);
      this.isFolder = metadata.is_dir || false;
      this.isFile = !this.isFolder;
      this.isRemoved = metadata.is_deleted || false;
      this.typeIcon = metadata.icon;
      if ((_ref = metadata.modified) != null ? _ref.length : void 0) {
        this.modifiedAt = new Date(Date.parse(metadata.modified));
      } else {
        this.modifiedAt = null;
      }
      if ((_ref1 = metadata.client_mtime) != null ? _ref1.length : void 0) {
        this.clientModifiedAt = new Date(Date.parse(metadata.client_mtime));
      } else {
        this.clientModifiedAt = null;
      }
      switch (metadata.root) {
        case 'dropbox':
          this.inAppFolder = false;
          break;
        case 'app_folder':
          this.inAppFolder = true;
          break;
        default:
          this.inAppFolder = null;
      }
      this.size = metadata.bytes || 0;
      this.humanSize = metadata.size || '';
      this.hasThumbnail = metadata.thumb_exists || false;
      if (this.isFolder) {
        this.versionTag = metadata.hash;
        this.mimeType = metadata.mime_type || 'inode/directory';
      } else {
        this.versionTag = metadata.rev;
        this.mimeType = metadata.mime_type || 'application/octet-stream';
      }
    }

    return Stat;

  })();

  Dropbox.UploadCursor = (function() {
    UploadCursor.parse = function(cursorData) {
      if (cursorData && (typeof cursorData === 'object' || typeof cursorData === 'string')) {
        return new Dropbox.UploadCursor(cursorData);
      } else {
        return cursorData;
      }
    };

    UploadCursor.prototype.tag = null;

    UploadCursor.prototype.offset = null;

    UploadCursor.prototype.expiresAt = null;

    UploadCursor.prototype.json = function() {
      return this._json || (this._json = {
        upload_id: this.tag,
        offset: this.offset,
        expires: this.expiresAt.toString()
      });
    };

    function UploadCursor(cursorData) {
      this.replace(cursorData);
    }

    UploadCursor.prototype.replace = function(cursorData) {
      if (typeof cursorData === 'object') {
        this.tag = cursorData.upload_id || null;
        this.offset = cursorData.offset || 0;
        this.expiresAt = new Date(Date.parse(cursorData.expires) || Date.now());
        this._json = cursorData;
      } else {
        this.tag = cursorData || null;
        this.offset = 0;
        this.expiresAt = new Date(Math.floor(Date.now() / 1000) * 1000);
        this._json = null;
      }
      return this;
    };

    return UploadCursor;

  })();

  Dropbox.UserInfo = (function() {
    UserInfo.parse = function(userInfo) {
      if (userInfo && typeof userInfo === 'object') {
        return new Dropbox.UserInfo(userInfo);
      } else {
        return userInfo;
      }
    };

    UserInfo.prototype.name = null;

    UserInfo.prototype.email = null;

    UserInfo.prototype.countryCode = null;

    UserInfo.prototype.uid = null;

    UserInfo.prototype.referralUrl = null;

    UserInfo.prototype.publicAppUrl = null;

    UserInfo.prototype.quota = null;

    UserInfo.prototype.usedQuota = null;

    UserInfo.prototype.privateBytes = null;

    UserInfo.prototype.sharedBytes = null;

    UserInfo.prototype.json = function() {
      return this._json;
    };

    function UserInfo(userInfo) {
      var lastIndex;

      this._json = userInfo;
      this.name = userInfo.display_name;
      this.email = userInfo.email;
      this.countryCode = userInfo.country || null;
      this.uid = userInfo.uid.toString();
      if (userInfo.public_app_url) {
        this.publicAppUrl = userInfo.public_app_url;
        lastIndex = this.publicAppUrl.length - 1;
        if (lastIndex >= 0 && this.publicAppUrl.substring(lastIndex) === '/') {
          this.publicAppUrl = this.publicAppUrl.substring(0, lastIndex);
        }
      } else {
        this.publicAppUrl = null;
      }
      this.referralUrl = userInfo.referral_link;
      this.quota = userInfo.quota_info.quota;
      this.privateBytes = userInfo.quota_info.normal || 0;
      this.sharedBytes = userInfo.quota_info.shared || 0;
      this.usedQuota = this.privateBytes + this.sharedBytes;
    }

    return UserInfo;

  })();

  if (typeof XMLHttpRequest !== 'undefined' && (typeof window !== 'undefined' || typeof self !== 'undefined') && typeof navigator !== 'undefined' && typeof navigator.userAgent === 'string') {
    if (typeof XDomainRequest !== 'undefined' && !('withCredentials' in new XMLHttpRequest())) {
      DropboxXhrRequest = XDomainRequest;
      DropboxXhrIeMode = true;
      DropboxXhrCanSendForms = false;
    } else {
      DropboxXhrRequest = XMLHttpRequest;
      DropboxXhrIeMode = false;
      DropboxXhrCanSendForms = typeof FormData !== 'undefined' && navigator.userAgent.indexOf('Firefox') === -1;
    }
    DropboxXhrDoesPreflight = true;
  } else {
    DropboxXhrRequest = require('xhr2');
    DropboxXhrIeMode = false;
    DropboxXhrCanSendForms = false;
    DropboxXhrDoesPreflight = false;
  }

  if (typeof Uint8Array === 'undefined') {
    DropboxXhrArrayBufferView = null;
    DropboxXhrWrapBlob = false;
    DropboxXhrSendArrayBufferView = false;
  } else {
    if (Object.getPrototypeOf) {
      DropboxXhrArrayBufferView = Object.getPrototypeOf(Object.getPrototypeOf(new Uint8Array(0))).constructor;
    } else if (Object.__proto__) {
      DropboxXhrArrayBufferView = (new Uint8Array(0)).__proto__.__proto__.constructor;
    }
    if (typeof Blob === 'undefined') {
      DropboxXhrWrapBlob = false;
      DropboxXhrSendArrayBufferView = true;
    } else {
      try {
        if ((new Blob([new Uint8Array(2)])).size === 2) {
          DropboxXhrWrapBlob = true;
          DropboxXhrSendArrayBufferView = true;
        } else {
          DropboxXhrSendArrayBufferView = false;
          DropboxXhrWrapBlob = (new Blob([new ArrayBuffer(2)])).size === 2;
        }
      } catch (_error) {
        blobError = _error;
        DropboxXhrSendArrayBufferView = false;
        DropboxXhrWrapBlob = false;
        if (typeof WebKitBlobBuilder !== 'undefined') {
          if (navigator.userAgent.indexOf('Android') !== -1) {
            DropboxXhrCanSendForms = false;
          }
        }
      }
      if (DropboxXhrArrayBufferView === Object) {
        DropboxXhrSendArrayBufferView = false;
      }
    }
  }

  Dropbox.Xhr = (function() {
    Xhr.Request = DropboxXhrRequest;

    Xhr.ieXdr = DropboxXhrIeMode;

    Xhr.canSendForms = DropboxXhrCanSendForms;

    Xhr.doesPreflight = DropboxXhrDoesPreflight;

    Xhr.ArrayBufferView = DropboxXhrArrayBufferView;

    Xhr.sendArrayBufferView = DropboxXhrSendArrayBufferView;

    Xhr.wrapBlob = DropboxXhrWrapBlob;

    function Xhr(method, baseUrl) {
      this.method = method;
      this.isGet = this.method === 'GET';
      this.url = baseUrl;
      this.wantHeaders = false;
      this.headers = {};
      this.params = null;
      this.body = null;
      this.preflight = !(this.isGet || (this.method === 'POST'));
      this.signed = false;
      this.completed = false;
      this.responseType = null;
      this.callback = null;
      this.xhr = null;
      this.onError = null;
    }

    Xhr.prototype.xhr = null;

    Xhr.prototype.onError = null;

    Xhr.prototype.setParams = function(params) {
      if (this.signed) {
        throw new Error('setParams called after addOauthParams or addOauthHeader');
      }
      if (this.params) {
        throw new Error('setParams cannot be called twice');
      }
      this.params = params;
      return this;
    };

    Xhr.prototype.setCallback = function(callback) {
      this.callback = callback;
      return this;
    };

    Xhr.prototype.signWithOauth = function(oauth, cacheFriendly) {
      if (Dropbox.Xhr.ieXdr) {
        return this.addOauthParams(oauth);
      } else if (this.preflight || !Dropbox.Xhr.doesPreflight) {
        return this.addOauthHeader(oauth);
      } else {
        if (this.isGet && cacheFriendly) {
          return this.addOauthHeader(oauth);
        } else {
          return this.addOauthParams(oauth);
        }
      }
    };

    Xhr.prototype.addOauthParams = function(oauth) {
      if (this.signed) {
        throw new Error('Request already has an OAuth signature');
      }
      this.params || (this.params = {});
      oauth.addAuthParams(this.method, this.url, this.params);
      this.signed = true;
      return this;
    };

    Xhr.prototype.addOauthHeader = function(oauth) {
      if (this.signed) {
        throw new Error('Request already has an OAuth signature');
      }
      this.params || (this.params = {});
      this.signed = true;
      return this.setHeader('Authorization', oauth.authHeader(this.method, this.url, this.params));
    };

    Xhr.prototype.setBody = function(body) {
      if (this.isGet) {
        throw new Error('setBody cannot be called on GET requests');
      }
      if (this.body !== null) {
        throw new Error('Request already has a body');
      }
      if (typeof body === 'string') {

      } else if ((typeof FormData !== 'undefined') && (body instanceof FormData)) {

      } else {
        this.headers['Content-Type'] = 'application/octet-stream';
        this.preflight = true;
      }
      this.body = body;
      return this;
    };

    Xhr.prototype.setResponseType = function(responseType) {
      this.responseType = responseType;
      return this;
    };

    Xhr.prototype.setHeader = function(headerName, value) {
      var oldValue;

      if (this.headers[headerName]) {
        oldValue = this.headers[headerName];
        throw new Error("HTTP header " + headerName + " already set to " + oldValue);
      }
      if (headerName === 'Content-Type') {
        throw new Error('Content-Type is automatically computed based on setBody');
      }
      this.preflight = true;
      this.headers[headerName] = value;
      return this;
    };

    Xhr.prototype.reportResponseHeaders = function() {
      return this.wantHeaders = true;
    };

    Xhr.prototype.setFileField = function(fieldName, fileName, fileData, contentType) {
      var blob, boundary, builder, useFormData;

      if (this.body !== null) {
        throw new Error('Request already has a body');
      }
      if (this.isGet) {
        throw new Error('setFileField cannot be called on GET requests');
      }
      if (typeof fileData === 'object') {
        if (typeof ArrayBuffer !== 'undefined') {
          if (fileData instanceof ArrayBuffer) {
            if (Dropbox.Xhr.sendArrayBufferView) {
              fileData = new Uint8Array(fileData);
            }
          } else {
            if (!Dropbox.Xhr.sendArrayBufferView && fileData.byteOffset === 0 && fileData.buffer instanceof ArrayBuffer) {
              fileData = fileData.buffer;
            }
          }
        }
        contentType || (contentType = 'application/octet-stream');
        try {
          fileData = new Blob([fileData], {
            type: contentType
          });
        } catch (_error) {
          blobError = _error;
          if (window.WebKitBlobBuilder) {
            builder = new WebKitBlobBuilder;
            builder.append(fileData);
            if (blob = builder.getBlob(contentType)) {
              fileData = blob;
            }
          }
        }
        if (typeof File !== 'undefined' && fileData instanceof File) {
          fileData = new Blob([fileData], {
            type: fileData.type
          });
        }
        useFormData = fileData instanceof Blob;
      } else {
        useFormData = false;
      }
      if (useFormData) {
        this.body = new FormData();
        return this.body.append(fieldName, fileData, fileName);
      } else {
        contentType || (contentType = 'application/octet-stream');
        boundary = this.multipartBoundary();
        this.headers['Content-Type'] = "multipart/form-data; boundary=" + boundary;
        return this.body = ['--', boundary, "\r\n", 'Content-Disposition: form-data; name="', fieldName, '"; filename="', fileName, "\"\r\n", 'Content-Type: ', contentType, "\r\n", "Content-Transfer-Encoding: binary\r\n\r\n", fileData, "\r\n", '--', boundary, '--', "\r\n"].join('');
      }
    };

    Xhr.prototype.multipartBoundary = function() {
      return [Date.now().toString(36), Math.random().toString(36)].join('----');
    };

    Xhr.prototype.paramsToUrl = function() {
      var queryString;

      if (this.params) {
        queryString = Dropbox.Xhr.urlEncode(this.params);
        if (queryString.length !== 0) {
          this.url = [this.url, '?', queryString].join('');
        }
        this.params = null;
      }
      return this;
    };

    Xhr.prototype.paramsToBody = function() {
      if (this.params) {
        if (this.body !== null) {
          throw new Error('Request already has a body');
        }
        if (this.isGet) {
          throw new Error('paramsToBody cannot be called on GET requests');
        }
        this.headers['Content-Type'] = 'application/x-www-form-urlencoded';
        this.body = Dropbox.Xhr.urlEncode(this.params);
        this.params = null;
      }
      return this;
    };

    Xhr.prototype.prepare = function() {
      var header, ieXdr, value, _ref,
        _this = this;

      ieXdr = Dropbox.Xhr.ieXdr;
      if (this.isGet || this.body !== null || ieXdr) {
        this.paramsToUrl();
        if (this.body !== null && typeof this.body === 'string') {
          this.headers['Content-Type'] = 'text/plain; charset=utf8';
        }
      } else {
        this.paramsToBody();
      }
      this.xhr = new Dropbox.Xhr.Request();
      if (ieXdr) {
        this.xhr.onload = function() {
          return _this.onXdrLoad();
        };
        this.xhr.onerror = function() {
          return _this.onXdrError();
        };
        this.xhr.ontimeout = function() {
          return _this.onXdrError();
        };
        this.xhr.onprogress = function() {};
      } else {
        this.xhr.onreadystatechange = function() {
          return _this.onReadyStateChange();
        };
      }
      this.xhr.open(this.method, this.url, true);
      if (!ieXdr) {
        _ref = this.headers;
        for (header in _ref) {
          if (!__hasProp.call(_ref, header)) continue;
          value = _ref[header];
          this.xhr.setRequestHeader(header, value);
        }
      }
      if (this.responseType) {
        if (this.responseType === 'b') {
          if (this.xhr.overrideMimeType) {
            this.xhr.overrideMimeType('text/plain; charset=x-user-defined');
          }
        } else {
          this.xhr.responseType = this.responseType;
        }
      }
      return this;
    };

    Xhr.prototype.send = function(callback) {
      var body, xhrError;

      this.callback = callback || this.callback;
      if (this.body !== null) {
        body = this.body;
        if (Dropbox.Xhr.sendArrayBufferView) {
          if (body instanceof ArrayBuffer) {
            body = new Uint8Array(body);
          }
        } else {
          if (body.byteOffset === 0 && body.buffer instanceof ArrayBuffer) {
            body = body.buffer;
          }
        }
        try {
          this.xhr.send(body);
        } catch (_error) {
          xhrError = _error;
          if (!Dropbox.Xhr.sendArrayBufferView && Dropbox.Xhr.wrapBlob) {
            body = new Blob([body], {
              type: 'application/octet-stream'
            });
            this.xhr.send(body);
          } else {
            throw xhrError;
          }
        }
      } else {
        this.xhr.send();
      }
      return this;
    };

    Xhr.urlEncode = function(object) {
      var chunks, key, value;

      chunks = [];
      for (key in object) {
        value = object[key];
        chunks.push(this.urlEncodeValue(key) + '=' + this.urlEncodeValue(value));
      }
      return chunks.sort().join('&');
    };

    Xhr.urlEncodeValue = function(object) {
      return encodeURIComponent(object.toString()).replace(/\!/g, '%21').replace(/'/g, '%27').replace(/\(/g, '%28').replace(/\)/g, '%29').replace(/\*/g, '%2A');
    };

    Xhr.urlDecode = function(string) {
      var kvp, result, token, _i, _len, _ref;

      result = {};
      _ref = string.split('&');
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        token = _ref[_i];
        kvp = token.split('=');
        result[decodeURIComponent(kvp[0])] = decodeURIComponent(kvp[1]);
      }
      return result;
    };

    Xhr.prototype.onReadyStateChange = function() {
      var allHeaders, apiError, bytes, dirtyText, headers, i, jsonError, metadata, metadataJson, text, _i, _ref;

      if (this.xhr.readyState !== 4) {
        return true;
      }
      if (this.completed) {
        return true;
      }
      this.completed = true;
      if (this.xhr.status < 200 || this.xhr.status >= 300) {
        apiError = new Dropbox.ApiError(this.xhr, this.method, this.url);
        if (this.onError) {
          this.onError(apiError, this.callback);
        } else {
          this.callback(apiError);
        }
        return true;
      }
      if (this.wantHeaders) {
        allHeaders = this.xhr.getAllResponseHeaders();
        if (allHeaders) {
          headers = Dropbox.Xhr.parseResponseHeaders(allHeaders);
        } else {
          headers = this.guessResponseHeaders();
        }
        metadataJson = headers['x-dropbox-metadata'];
      } else {
        headers = void 0;
        metadataJson = this.xhr.getResponseHeader('x-dropbox-metadata');
      }
      if (metadataJson != null ? metadataJson.length : void 0) {
        try {
          metadata = JSON.parse(metadataJson);
        } catch (_error) {
          jsonError = _error;
          metadata = void 0;
        }
      } else {
        metadata = void 0;
      }
      if (this.responseType) {
        if (this.responseType === 'b') {
          dirtyText = this.xhr.responseText != null ? this.xhr.responseText : this.xhr.response;
          bytes = [];
          for (i = _i = 0, _ref = dirtyText.length; 0 <= _ref ? _i < _ref : _i > _ref; i = 0 <= _ref ? ++_i : --_i) {
            bytes.push(String.fromCharCode(dirtyText.charCodeAt(i) & 0xFF));
          }
          text = bytes.join('');
          this.callback(null, text, metadata, headers);
        } else {
          this.callback(null, this.xhr.response, metadata, headers);
        }
        return true;
      }
      text = this.xhr.responseText != null ? this.xhr.responseText : this.xhr.response;
      switch (this.xhr.getResponseHeader('Content-Type')) {
        case 'application/x-www-form-urlencoded':
          this.callback(null, Dropbox.Xhr.urlDecode(text), metadata, headers);
          break;
        case 'application/json':
        case 'text/javascript':
          this.callback(null, JSON.parse(text), metadata, headers);
          break;
        default:
          this.callback(null, text, metadata, headers);
      }
      return true;
    };

    Xhr.parseResponseHeaders = function(allHeaders) {
      var colonIndex, headerLines, headers, line, name, value, _i, _len;

      headers = {};
      headerLines = allHeaders.split("\n");
      for (_i = 0, _len = headerLines.length; _i < _len; _i++) {
        line = headerLines[_i];
        colonIndex = line.indexOf(':');
        name = line.substring(0, colonIndex).trim().toLowerCase();
        value = line.substring(colonIndex + 1).trim();
        headers[name] = value;
      }
      return headers;
    };

    Xhr.prototype.guessResponseHeaders = function() {
      var headers, name, value, _i, _len, _ref;

      headers = {};
      _ref = ['cache-control', 'content-language', 'content-range', 'content-type', 'expires', 'last-modified', 'pragma', 'x-dropbox-metadata'];
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        name = _ref[_i];
        value = this.xhr.getResponseHeader(name);
        if (value) {
          headers[name] = value;
        }
      }
      return headers;
    };

    Xhr.prototype.onXdrLoad = function() {
      var headers, metadata, text;

      if (this.completed) {
        return true;
      }
      this.completed = true;
      text = this.xhr.responseText;
      if (this.wantHeaders) {
        headers = {
          'content-type': this.xhr.contentType
        };
      } else {
        headers = void 0;
      }
      metadata = void 0;
      if (this.responseType) {
        this.callback(null, text, metadata, headers);
        return true;
      }
      switch (this.xhr.contentType) {
        case 'application/x-www-form-urlencoded':
          this.callback(null, Dropbox.Xhr.urlDecode(text), metadata, headers);
          break;
        case 'application/json':
        case 'text/javascript':
          this.callback(null, JSON.parse(text), metadata, headers);
          break;
        default:
          this.callback(null, text, metadata, headers);
      }
      return true;
    };

    Xhr.prototype.onXdrError = function() {
      var apiError;

      if (this.completed) {
        return true;
      }
      this.completed = true;
      apiError = new Dropbox.ApiError(this.xhr, this.method, this.url);
      if (this.onError) {
        this.onError(apiError, this.callback);
      } else {
        this.callback(apiError);
      }
      return true;
    };

    return Xhr;

  })();

  if (typeof module !== 'undefined' && 'exports' in module) {
    module.exports = Dropbox;
  } else if (typeof window !== "undefined" && window !== null) {
    if (window.Dropbox) {
      for (name in Dropbox) {
        if (!__hasProp.call(Dropbox, name)) continue;
        value = Dropbox[name];
        window.Dropbox[name] = value;
      }
    } else {
      window.Dropbox = Dropbox;
    }
  } else if (typeof self !== "undefined" && self !== null) {
    self.Dropbox = Dropbox;
  } else {
    throw new Error('This library only supports node.js and modern browsers.');
  }

}).call(this);