├── .gitignore
├── .travis.yml
├── LICENSE
├── README.md
├── bower.json
├── dist
    ├── pouchdb.migrate.js
    └── pouchdb.migrate.min.js
├── index.js
├── lib
    ├── checkpointer.js
    ├── md5.js
    └── migrate.js
├── package.json
└── test.js


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | sudo: false
 2 | language: node_js
 3 | cache:
 4 |   directories:
 5 |     - node_modules
 6 | notifications:
 7 |   email: false
 8 | node_js:
 9 |   - 4
10 |   - iojs-v3
11 |   - iojs-v2
12 |   - iojs-v1
13 |   - '0.12'
14 |   - '0.10'
15 | before_install:
16 |   - npm i -g npm@^2.0.0
17 | before_script:
18 |   - npm prune
19 | after_success:
20 |   - npm run build
21 |   - npm run semantic-release
22 | branches:
23 |   except:
24 |     # ignore git tags created by semantic-release, like "v1.2.3"
25 |     - /^v\d+\.\d+\.\d+$/
26 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Licensed under the Apache License, Version 2.0 (the "License"); you
 2 | may not use this file except in compliance with the License. You may
 3 | obtain a copy of the License at
 4 | 
 5 | http://www.apache.org/licenses/LICENSE-2.0
 6 | 
 7 | Unless required by applicable law or agreed to in writing, software
 8 | distributed under the License is distributed on an "AS IS" BASIS,
 9 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
10 | implied. See the License for the specific language governing
11 | permissions and limitations under the License.
12 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # pouchdb-migrate
 2 | PouchDB plugin for running migrations.
 3 | 
 4 | [![Build
 5 | Status](https://travis-ci.org/eHealthAfrica/pouchdb-migrate.svg?branch=master)](https://travis-ci.org/eHealthAfrica/pouchdb-migrate)
 6 | 
 7 | ## Setup
 8 | ```html
 9 | <script src="pouchdb.js"></script>
10 | <script src="pouchdb.migrator.js"></script>
11 | ```
12 | 
13 | Or to use it in Node.js, just npm install it:
14 | 
15 | ```
16 | npm install pouchdb-migrate
17 | ```
18 | 
19 | And then attach it to the `PouchDB` object:
20 | 
21 | ```js
22 | var PouchDB = require('pouchdb');
23 | PouchDB.plugin(require('pouchdb-migrate'));
24 | ```
25 | 
26 | ## Usage
27 | ```js
28 | var db = new PouchDB('mydb')
29 | 
30 | // Migration script
31 | // * Return falsy value to skip the doc
32 | // * Make sure to prevent from loops
33 | var migration = function(doc) {
34 |   if ('foo' in doc) return
35 | 
36 |   doc.foo = 'bar'
37 |   return [doc]
38 | }
39 | 
40 | db.migrate(migration)
41 |   .then //... every doc has `foo` now
42 | ```
43 | 
44 | ## Testing
45 | Run the tests with
46 | ```sh
47 | npm test
48 | ```
49 | 


--------------------------------------------------------------------------------
/bower.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "pouchdb-migrate",
 3 |   "main": "dist/pouchdb.migrate.js",
 4 |   "version": "1.1.1",
 5 |   "homepage": "https://github.com/eHealthAfrica/pouchdb-migrate",
 6 |   "authors": [
 7 |     "Johannes J. Schmidt <jo@die-tf.de>"
 8 |   ],
 9 |   "description": "PouchDB plugin for running migrations.",
10 |   "moduleType": [
11 |     "node"
12 |   ],
13 |   "keywords": [
14 |     "pouchdb"
15 |   ],
16 |   "license": "Apache-2.0",
17 |   "ignore": [
18 |     "**/.*",
19 |     "node_modules",
20 |     "bower_components",
21 |     "test",
22 |     "tests"
23 |   ]
24 | }
25 | 


--------------------------------------------------------------------------------
/dist/pouchdb.migrate.js:
--------------------------------------------------------------------------------
   1 | (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
   2 | var Promise = require('pouchdb/extras/promise')
   3 | var checkpointer = require('./lib/checkpointer')
   4 | var migrate = require('./lib/migrate')
   5 | 
   6 | exports.migrate = function(migration, options, callback) {
   7 |   var db = this
   8 | 
   9 |   if (!migration) {
  10 |     throw(new Error('no migration given'))
  11 |   }
  12 |   if (typeof migration !== 'function') {
  13 |     throw(new Error('migration must be a function'))
  14 |   }
  15 | 
  16 |   if (typeof options === 'function') {
  17 |     callback = options
  18 |     options = {}
  19 |   }
  20 |   if (typeof options === 'undefined') {
  21 |     options = {}
  22 |   }
  23 | 
  24 |   var promise = checkpointer(db, migration)
  25 |     .then(function(cp) {
  26 |       return migrate(db, cp, migration, options)
  27 |     })
  28 | 
  29 |   if (typeof callback === 'function') {
  30 |     return promise
  31 |       .then(function(result) {
  32 |         callback(null, result)
  33 |       })
  34 |       .catch(function(error) {
  35 |         callback(error)
  36 |         return Promise.reject(error)
  37 |       })
  38 |   }
  39 | 
  40 |   return promise
  41 | }
  42 | 
  43 | if (typeof window !== 'undefined' && window.PouchDB) {
  44 |   window.PouchDB.plugin(exports)
  45 | }
  46 | 
  47 | },{"./lib/checkpointer":2,"./lib/migrate":4,"pouchdb/extras/promise":10}],2:[function(require,module,exports){
  48 | var MD5 = require('./md5')
  49 | var Promise = require('pouchdb/extras/promise')
  50 | 
  51 | var md5Promise = function(data) {
  52 |   return new Promise(function(resolve, reject) {
  53 |     MD5(data, function(error, result) {
  54 |       if (error) { return reject(error) }
  55 | 
  56 |       resolve(result)
  57 |     })
  58 |   })
  59 | }
  60 | 
  61 | module.exports = function(db, migration) {
  62 |   var doc = {
  63 |     last_seq: 0
  64 |   }
  65 | 
  66 |   return md5Promise(migration.toString())
  67 |     .then(function(md5sum) {
  68 |       doc._id = '_local/' + md5sum
  69 |     })
  70 |     .then(function() {
  71 |       return {
  72 |         get: function() {
  73 |           return db.get(doc._id)
  74 |             .then(function(response) {
  75 |               doc._rev = response._rev
  76 |               doc.last_seq = response.last_seq
  77 |             })
  78 |             .catch(function(error) {
  79 |               if (error.status !== 404) return Promise.reject()
  80 |             })
  81 |             .then(function() {
  82 |               return doc.last_seq
  83 |             })
  84 |         },
  85 |         set: function(seq) {
  86 |           doc.last_seq = seq
  87 | 
  88 |           return db.put(doc)
  89 |             .then(function(response) {
  90 |               doc._rev = response.rev
  91 |             })
  92 |         }
  93 |       }
  94 |     })
  95 | }
  96 | 
  97 | },{"./md5":3,"pouchdb/extras/promise":10}],3:[function(require,module,exports){
  98 | (function (process,global){
  99 | 'use strict';
 100 | /* istanbul ignore next */
 101 | var crypto = require('crypto');
 102 | /* istanbul ignore next */
 103 | var Md5 = require('spark-md5');
 104 | /* istanbul ignore next */
 105 | var setImmediateShim = global.setImmediate || global.setTimeout;
 106 | /* istanbul ignore next */
 107 | var MD5_CHUNK_SIZE = 32768;
 108 | 
 109 | /* istanbul ignore next */
 110 | function sliceShim(arrayBuffer, begin, end) {
 111 |   if (typeof arrayBuffer.slice === 'function') {
 112 |     if (!begin) {
 113 |       return arrayBuffer.slice();
 114 |     } else if (!end) {
 115 |       return arrayBuffer.slice(begin);
 116 |     } else {
 117 |       return arrayBuffer.slice(begin, end);
 118 |     }
 119 |   }
 120 |   //
 121 |   // shim for IE courtesy of http://stackoverflow.com/a/21440217
 122 |   //
 123 | 
 124 |   //If `begin`/`end` is unspecified, Chrome assumes 0, so we do the same
 125 |   //Chrome also converts the values to integers via flooring
 126 |   begin = Math.floor(begin || 0);
 127 |   end = Math.floor(end || 0);
 128 | 
 129 |   var len = arrayBuffer.byteLength;
 130 | 
 131 |   //If either `begin` or `end` is negative, it refers to an
 132 |   //index from the end of the array, as opposed to from the beginning.
 133 |   //The range specified by the `begin` and `end` values is clamped to the
 134 |   //valid index range for the current array.
 135 |   begin = begin < 0 ? Math.max(begin + len, 0) : Math.min(len, begin);
 136 |   end = end < 0 ? Math.max(end + len, 0) : Math.min(len, end);
 137 | 
 138 |   //If the computed length of the new ArrayBuffer would be negative, it
 139 |   //is clamped to zero.
 140 |   if (end - begin <= 0) {
 141 |     return new ArrayBuffer(0);
 142 |   }
 143 | 
 144 |   var result = new ArrayBuffer(end - begin);
 145 |   var resultBytes = new Uint8Array(result);
 146 |   var sourceBytes = new Uint8Array(arrayBuffer, begin, end - begin);
 147 | 
 148 |   resultBytes.set(sourceBytes);
 149 | 
 150 |   return result;
 151 | }
 152 | 
 153 | // convert a 64-bit int to a binary string
 154 | /* istanbul ignore next */
 155 | function intToString(int) {
 156 |   var bytes = [
 157 |     (int & 0xff),
 158 |     ((int >>> 8) & 0xff),
 159 |     ((int >>> 16) & 0xff),
 160 |     ((int >>> 24) & 0xff)
 161 |   ];
 162 |   return bytes.map(function (byte) {
 163 |     return String.fromCharCode(byte);
 164 |   }).join('');
 165 | }
 166 | 
 167 | // convert an array of 64-bit ints into
 168 | // a base64-encoded string
 169 | /* istanbul ignore next */
 170 | function rawToBase64(raw) {
 171 |   var res = '';
 172 |   for (var i = 0; i < raw.length; i++) {
 173 |     res += intToString(raw[i]);
 174 |   }
 175 |   return global.btoa(res);
 176 | }
 177 | 
 178 | /* istanbul ignore next */
 179 | module.exports = function (data, callback) {
 180 |   if (!process.browser) {
 181 |     var base64 = crypto.createHash('md5').update(data).digest('base64');
 182 |     callback(null, base64);
 183 |     return;
 184 |   }
 185 |   var inputIsString = typeof data === 'string';
 186 |   var len = inputIsString ? data.length : data.byteLength;
 187 |   var chunkSize = Math.min(MD5_CHUNK_SIZE, len);
 188 |   var chunks = Math.ceil(len / chunkSize);
 189 |   var currentChunk = 0;
 190 |   var buffer = inputIsString ? new Md5() : new Md5.ArrayBuffer();
 191 | 
 192 |   function append(buffer, data, start, end) {
 193 |     if (inputIsString) {
 194 |       buffer.appendBinary(data.substring(start, end));
 195 |     } else {
 196 |       buffer.append(sliceShim(data, start, end));
 197 |     }
 198 |   }
 199 | 
 200 |   function loadNextChunk() {
 201 |     var start = currentChunk * chunkSize;
 202 |     var end = start + chunkSize;
 203 |     if ((start + chunkSize) >= data.size) {
 204 |       end = data.size;
 205 |     }
 206 |     currentChunk++;
 207 |     if (currentChunk < chunks) {
 208 |       append(buffer, data, start, end);
 209 |       setImmediateShim(loadNextChunk);
 210 |     } else {
 211 |       append(buffer, data, start, end);
 212 |       var raw = buffer.end(true);
 213 |       var base64 = rawToBase64(raw);
 214 |       callback(null, base64);
 215 |       buffer.destroy();
 216 |     }
 217 |   }
 218 |   loadNextChunk();
 219 | };
 220 | 
 221 | }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
 222 | },{"_process":12,"crypto":6,"spark-md5":13}],4:[function(require,module,exports){
 223 | var Promise = require('pouchdb/extras/promise')
 224 | var extend = require('pouchdb-extend')
 225 | var async = require('async')
 226 | 
 227 | module.exports = function migrate(db, checkpointer, migration, options) {
 228 |   return checkpointer.get()
 229 |     .then(function(since) {
 230 |       return new Promise(function(resolve, reject) {
 231 |         var docs = []
 232 |   
 233 |         var queue = async.queue(function(result, next) {
 234 |           if (!result) {
 235 |             return checkpointer
 236 |               .set(change.seq)
 237 |               .then(next.bind({}, null))
 238 |               .catch(next)
 239 |           }
 240 |             
 241 |           db
 242 |             .bulkDocs({ docs: result })
 243 |             .then(function(response) {
 244 |               return checkpointer.set(change.seq)
 245 |             })
 246 |             .then(next.bind({}, null))
 247 |             .catch(next)
 248 |         }, 1)
 249 | 
 250 |         
 251 |         var feed = db.changes(extend({}, options, {
 252 |           include_docs: true,
 253 |           since: since
 254 |         }))
 255 |         
 256 |         feed.on('change', function(change) {
 257 |           var result = migration(change.doc)
 258 | 
 259 |           if (!options.live) {
 260 |             docs = result ? docs.concat(result) : docs
 261 |             return
 262 |           }
 263 |           
 264 |           queue.push(result)
 265 |         })
 266 |         
 267 |         feed.on('complete', function(info) {
 268 |           if (options.live) { return resolve(info) }
 269 | 
 270 |           db
 271 |             .bulkDocs({ docs: docs })
 272 |             .then(function(response) {
 273 |               return checkpointer.set(info.last_seq)
 274 |             })
 275 |             .then(function() {
 276 |               return db.info()
 277 |             })
 278 |             .then(function(dbinfo) {
 279 |               if (dbinfo.update_seq > info.last_seq) {
 280 |                 return migrate(db, checkpointer, migration, options)
 281 |               }
 282 |               return info
 283 |             })
 284 |             .then(resolve)
 285 |         })
 286 | 
 287 |         feed.on('error', reject)
 288 |       })
 289 |     })
 290 | }
 291 | 
 292 | },{"async":5,"pouchdb-extend":9,"pouchdb/extras/promise":10}],5:[function(require,module,exports){
 293 | (function (process,global){
 294 | /*!
 295 |  * async
 296 |  * https://github.com/caolan/async
 297 |  *
 298 |  * Copyright 2010-2014 Caolan McMahon
 299 |  * Released under the MIT license
 300 |  */
 301 | (function () {
 302 | 
 303 |     var async = {};
 304 |     function noop() {}
 305 |     function identity(v) {
 306 |         return v;
 307 |     }
 308 |     function toBool(v) {
 309 |         return !!v;
 310 |     }
 311 |     function notId(v) {
 312 |         return !v;
 313 |     }
 314 | 
 315 |     // global on the server, window in the browser
 316 |     var previous_async;
 317 | 
 318 |     // Establish the root object, `window` (`self`) in the browser, `global`
 319 |     // on the server, or `this` in some virtual machines. We use `self`
 320 |     // instead of `window` for `WebWorker` support.
 321 |     var root = typeof self === 'object' && self.self === self && self ||
 322 |             typeof global === 'object' && global.global === global && global ||
 323 |             this;
 324 | 
 325 |     if (root != null) {
 326 |         previous_async = root.async;
 327 |     }
 328 | 
 329 |     async.noConflict = function () {
 330 |         root.async = previous_async;
 331 |         return async;
 332 |     };
 333 | 
 334 |     function only_once(fn) {
 335 |         return function() {
 336 |             if (fn === null) throw new Error("Callback was already called.");
 337 |             fn.apply(this, arguments);
 338 |             fn = null;
 339 |         };
 340 |     }
 341 | 
 342 |     function _once(fn) {
 343 |         return function() {
 344 |             if (fn === null) return;
 345 |             fn.apply(this, arguments);
 346 |             fn = null;
 347 |         };
 348 |     }
 349 | 
 350 |     //// cross-browser compatiblity functions ////
 351 | 
 352 |     var _toString = Object.prototype.toString;
 353 | 
 354 |     var _isArray = Array.isArray || function (obj) {
 355 |         return _toString.call(obj) === '[object Array]';
 356 |     };
 357 | 
 358 |     // Ported from underscore.js isObject
 359 |     var _isObject = function(obj) {
 360 |         var type = typeof obj;
 361 |         return type === 'function' || type === 'object' && !!obj;
 362 |     };
 363 | 
 364 |     function _isArrayLike(arr) {
 365 |         return _isArray(arr) || (
 366 |             // has a positive integer length property
 367 |             typeof arr.length === "number" &&
 368 |             arr.length >= 0 &&
 369 |             arr.length % 1 === 0
 370 |         );
 371 |     }
 372 | 
 373 |     function _each(coll, iterator) {
 374 |         return _isArrayLike(coll) ?
 375 |             _arrayEach(coll, iterator) :
 376 |             _forEachOf(coll, iterator);
 377 |     }
 378 | 
 379 |     function _arrayEach(arr, iterator) {
 380 |         var index = -1,
 381 |             length = arr.length;
 382 | 
 383 |         while (++index < length) {
 384 |             iterator(arr[index], index, arr);
 385 |         }
 386 |     }
 387 | 
 388 |     function _map(arr, iterator) {
 389 |         var index = -1,
 390 |             length = arr.length,
 391 |             result = Array(length);
 392 | 
 393 |         while (++index < length) {
 394 |             result[index] = iterator(arr[index], index, arr);
 395 |         }
 396 |         return result;
 397 |     }
 398 | 
 399 |     function _range(count) {
 400 |         return _map(Array(count), function (v, i) { return i; });
 401 |     }
 402 | 
 403 |     function _reduce(arr, iterator, memo) {
 404 |         _arrayEach(arr, function (x, i, a) {
 405 |             memo = iterator(memo, x, i, a);
 406 |         });
 407 |         return memo;
 408 |     }
 409 | 
 410 |     function _forEachOf(object, iterator) {
 411 |         _arrayEach(_keys(object), function (key) {
 412 |             iterator(object[key], key);
 413 |         });
 414 |     }
 415 | 
 416 |     function _indexOf(arr, item) {
 417 |         for (var i = 0; i < arr.length; i++) {
 418 |             if (arr[i] === item) return i;
 419 |         }
 420 |         return -1;
 421 |     }
 422 | 
 423 |     var _keys = Object.keys || function (obj) {
 424 |         var keys = [];
 425 |         for (var k in obj) {
 426 |             if (obj.hasOwnProperty(k)) {
 427 |                 keys.push(k);
 428 |             }
 429 |         }
 430 |         return keys;
 431 |     };
 432 | 
 433 |     function _keyIterator(coll) {
 434 |         var i = -1;
 435 |         var len;
 436 |         var keys;
 437 |         if (_isArrayLike(coll)) {
 438 |             len = coll.length;
 439 |             return function next() {
 440 |                 i++;
 441 |                 return i < len ? i : null;
 442 |             };
 443 |         } else {
 444 |             keys = _keys(coll);
 445 |             len = keys.length;
 446 |             return function next() {
 447 |                 i++;
 448 |                 return i < len ? keys[i] : null;
 449 |             };
 450 |         }
 451 |     }
 452 | 
 453 |     // Similar to ES6's rest param (http://ariya.ofilabs.com/2013/03/es6-and-rest-parameter.html)
 454 |     // This accumulates the arguments passed into an array, after a given index.
 455 |     // From underscore.js (https://github.com/jashkenas/underscore/pull/2140).
 456 |     function _restParam(func, startIndex) {
 457 |         startIndex = startIndex == null ? func.length - 1 : +startIndex;
 458 |         return function() {
 459 |             var length = Math.max(arguments.length - startIndex, 0);
 460 |             var rest = Array(length);
 461 |             for (var index = 0; index < length; index++) {
 462 |                 rest[index] = arguments[index + startIndex];
 463 |             }
 464 |             switch (startIndex) {
 465 |                 case 0: return func.call(this, rest);
 466 |                 case 1: return func.call(this, arguments[0], rest);
 467 |             }
 468 |             // Currently unused but handle cases outside of the switch statement:
 469 |             // var args = Array(startIndex + 1);
 470 |             // for (index = 0; index < startIndex; index++) {
 471 |             //     args[index] = arguments[index];
 472 |             // }
 473 |             // args[startIndex] = rest;
 474 |             // return func.apply(this, args);
 475 |         };
 476 |     }
 477 | 
 478 |     function _withoutIndex(iterator) {
 479 |         return function (value, index, callback) {
 480 |             return iterator(value, callback);
 481 |         };
 482 |     }
 483 | 
 484 |     //// exported async module functions ////
 485 | 
 486 |     //// nextTick implementation with browser-compatible fallback ////
 487 | 
 488 |     // capture the global reference to guard against fakeTimer mocks
 489 |     var _setImmediate = typeof setImmediate === 'function' && setImmediate;
 490 | 
 491 |     var _delay = _setImmediate ? function(fn) {
 492 |         // not a direct alias for IE10 compatibility
 493 |         _setImmediate(fn);
 494 |     } : function(fn) {
 495 |         setTimeout(fn, 0);
 496 |     };
 497 | 
 498 |     if (typeof process === 'object' && typeof process.nextTick === 'function') {
 499 |         async.nextTick = process.nextTick;
 500 |     } else {
 501 |         async.nextTick = _delay;
 502 |     }
 503 |     async.setImmediate = _setImmediate ? _delay : async.nextTick;
 504 | 
 505 | 
 506 |     async.forEach =
 507 |     async.each = function (arr, iterator, callback) {
 508 |         return async.eachOf(arr, _withoutIndex(iterator), callback);
 509 |     };
 510 | 
 511 |     async.forEachSeries =
 512 |     async.eachSeries = function (arr, iterator, callback) {
 513 |         return async.eachOfSeries(arr, _withoutIndex(iterator), callback);
 514 |     };
 515 | 
 516 | 
 517 |     async.forEachLimit =
 518 |     async.eachLimit = function (arr, limit, iterator, callback) {
 519 |         return _eachOfLimit(limit)(arr, _withoutIndex(iterator), callback);
 520 |     };
 521 | 
 522 |     async.forEachOf =
 523 |     async.eachOf = function (object, iterator, callback) {
 524 |         callback = _once(callback || noop);
 525 |         object = object || [];
 526 |         var size = _isArrayLike(object) ? object.length : _keys(object).length;
 527 |         var completed = 0;
 528 |         if (!size) {
 529 |             return callback(null);
 530 |         }
 531 |         _each(object, function (value, key) {
 532 |             iterator(object[key], key, only_once(done));
 533 |         });
 534 |         function done(err) {
 535 |             if (err) {
 536 |                 callback(err);
 537 |             }
 538 |             else {
 539 |                 completed += 1;
 540 |                 if (completed >= size) {
 541 |                     callback(null);
 542 |                 }
 543 |             }
 544 |         }
 545 |     };
 546 | 
 547 |     async.forEachOfSeries =
 548 |     async.eachOfSeries = function (obj, iterator, callback) {
 549 |         callback = _once(callback || noop);
 550 |         obj = obj || [];
 551 |         var nextKey = _keyIterator(obj);
 552 |         var key = nextKey();
 553 |         function iterate() {
 554 |             var sync = true;
 555 |             if (key === null) {
 556 |                 return callback(null);
 557 |             }
 558 |             iterator(obj[key], key, only_once(function (err) {
 559 |                 if (err) {
 560 |                     callback(err);
 561 |                 }
 562 |                 else {
 563 |                     key = nextKey();
 564 |                     if (key === null) {
 565 |                         return callback(null);
 566 |                     } else {
 567 |                         if (sync) {
 568 |                             async.nextTick(iterate);
 569 |                         } else {
 570 |                             iterate();
 571 |                         }
 572 |                     }
 573 |                 }
 574 |             }));
 575 |             sync = false;
 576 |         }
 577 |         iterate();
 578 |     };
 579 | 
 580 | 
 581 | 
 582 |     async.forEachOfLimit =
 583 |     async.eachOfLimit = function (obj, limit, iterator, callback) {
 584 |         _eachOfLimit(limit)(obj, iterator, callback);
 585 |     };
 586 | 
 587 |     function _eachOfLimit(limit) {
 588 | 
 589 |         return function (obj, iterator, callback) {
 590 |             callback = _once(callback || noop);
 591 |             obj = obj || [];
 592 |             var nextKey = _keyIterator(obj);
 593 |             if (limit <= 0) {
 594 |                 return callback(null);
 595 |             }
 596 |             var done = false;
 597 |             var running = 0;
 598 |             var errored = false;
 599 | 
 600 |             (function replenish () {
 601 |                 if (done && running <= 0) {
 602 |                     return callback(null);
 603 |                 }
 604 | 
 605 |                 while (running < limit && !errored) {
 606 |                     var key = nextKey();
 607 |                     if (key === null) {
 608 |                         done = true;
 609 |                         if (running <= 0) {
 610 |                             callback(null);
 611 |                         }
 612 |                         return;
 613 |                     }
 614 |                     running += 1;
 615 |                     iterator(obj[key], key, only_once(function (err) {
 616 |                         running -= 1;
 617 |                         if (err) {
 618 |                             callback(err);
 619 |                             errored = true;
 620 |                         }
 621 |                         else {
 622 |                             replenish();
 623 |                         }
 624 |                     }));
 625 |                 }
 626 |             })();
 627 |         };
 628 |     }
 629 | 
 630 | 
 631 |     function doParallel(fn) {
 632 |         return function (obj, iterator, callback) {
 633 |             return fn(async.eachOf, obj, iterator, callback);
 634 |         };
 635 |     }
 636 |     function doParallelLimit(fn) {
 637 |         return function (obj, limit, iterator, callback) {
 638 |             return fn(_eachOfLimit(limit), obj, iterator, callback);
 639 |         };
 640 |     }
 641 |     function doSeries(fn) {
 642 |         return function (obj, iterator, callback) {
 643 |             return fn(async.eachOfSeries, obj, iterator, callback);
 644 |         };
 645 |     }
 646 | 
 647 |     function _asyncMap(eachfn, arr, iterator, callback) {
 648 |         callback = _once(callback || noop);
 649 |         var results = [];
 650 |         eachfn(arr, function (value, index, callback) {
 651 |             iterator(value, function (err, v) {
 652 |                 results[index] = v;
 653 |                 callback(err);
 654 |             });
 655 |         }, function (err) {
 656 |             callback(err, results);
 657 |         });
 658 |     }
 659 | 
 660 |     async.map = doParallel(_asyncMap);
 661 |     async.mapSeries = doSeries(_asyncMap);
 662 |     async.mapLimit = doParallelLimit(_asyncMap);
 663 | 
 664 |     // reduce only has a series version, as doing reduce in parallel won't
 665 |     // work in many situations.
 666 |     async.inject =
 667 |     async.foldl =
 668 |     async.reduce = function (arr, memo, iterator, callback) {
 669 |         async.eachOfSeries(arr, function (x, i, callback) {
 670 |             iterator(memo, x, function (err, v) {
 671 |                 memo = v;
 672 |                 callback(err);
 673 |             });
 674 |         }, function (err) {
 675 |             callback(err || null, memo);
 676 |         });
 677 |     };
 678 | 
 679 |     async.foldr =
 680 |     async.reduceRight = function (arr, memo, iterator, callback) {
 681 |         var reversed = _map(arr, identity).reverse();
 682 |         async.reduce(reversed, memo, iterator, callback);
 683 |     };
 684 | 
 685 |     function _filter(eachfn, arr, iterator, callback) {
 686 |         var results = [];
 687 |         eachfn(arr, function (x, index, callback) {
 688 |             iterator(x, function (v) {
 689 |                 if (v) {
 690 |                     results.push({index: index, value: x});
 691 |                 }
 692 |                 callback();
 693 |             });
 694 |         }, function () {
 695 |             callback(_map(results.sort(function (a, b) {
 696 |                 return a.index - b.index;
 697 |             }), function (x) {
 698 |                 return x.value;
 699 |             }));
 700 |         });
 701 |     }
 702 | 
 703 |     async.select =
 704 |     async.filter = doParallel(_filter);
 705 | 
 706 |     async.selectLimit =
 707 |     async.filterLimit = doParallelLimit(_filter);
 708 | 
 709 |     async.selectSeries =
 710 |     async.filterSeries = doSeries(_filter);
 711 | 
 712 |     function _reject(eachfn, arr, iterator, callback) {
 713 |         _filter(eachfn, arr, function(value, cb) {
 714 |             iterator(value, function(v) {
 715 |                 cb(!v);
 716 |             });
 717 |         }, callback);
 718 |     }
 719 |     async.reject = doParallel(_reject);
 720 |     async.rejectLimit = doParallelLimit(_reject);
 721 |     async.rejectSeries = doSeries(_reject);
 722 | 
 723 |     function _createTester(eachfn, check, getResult) {
 724 |         return function(arr, limit, iterator, cb) {
 725 |             function done() {
 726 |                 if (cb) cb(getResult(false, void 0));
 727 |             }
 728 |             function iteratee(x, _, callback) {
 729 |                 if (!cb) return callback();
 730 |                 iterator(x, function (v) {
 731 |                     if (cb && check(v)) {
 732 |                         cb(getResult(true, x));
 733 |                         cb = iterator = false;
 734 |                     }
 735 |                     callback();
 736 |                 });
 737 |             }
 738 |             if (arguments.length > 3) {
 739 |                 eachfn(arr, limit, iteratee, done);
 740 |             } else {
 741 |                 cb = iterator;
 742 |                 iterator = limit;
 743 |                 eachfn(arr, iteratee, done);
 744 |             }
 745 |         };
 746 |     }
 747 | 
 748 |     async.any =
 749 |     async.some = _createTester(async.eachOf, toBool, identity);
 750 | 
 751 |     async.someLimit = _createTester(async.eachOfLimit, toBool, identity);
 752 | 
 753 |     async.all =
 754 |     async.every = _createTester(async.eachOf, notId, notId);
 755 | 
 756 |     async.everyLimit = _createTester(async.eachOfLimit, notId, notId);
 757 | 
 758 |     function _findGetResult(v, x) {
 759 |         return x;
 760 |     }
 761 |     async.detect = _createTester(async.eachOf, identity, _findGetResult);
 762 |     async.detectSeries = _createTester(async.eachOfSeries, identity, _findGetResult);
 763 |     async.detectLimit = _createTester(async.eachOfLimit, identity, _findGetResult);
 764 | 
 765 |     async.sortBy = function (arr, iterator, callback) {
 766 |         async.map(arr, function (x, callback) {
 767 |             iterator(x, function (err, criteria) {
 768 |                 if (err) {
 769 |                     callback(err);
 770 |                 }
 771 |                 else {
 772 |                     callback(null, {value: x, criteria: criteria});
 773 |                 }
 774 |             });
 775 |         }, function (err, results) {
 776 |             if (err) {
 777 |                 return callback(err);
 778 |             }
 779 |             else {
 780 |                 callback(null, _map(results.sort(comparator), function (x) {
 781 |                     return x.value;
 782 |                 }));
 783 |             }
 784 | 
 785 |         });
 786 | 
 787 |         function comparator(left, right) {
 788 |             var a = left.criteria, b = right.criteria;
 789 |             return a < b ? -1 : a > b ? 1 : 0;
 790 |         }
 791 |     };
 792 | 
 793 |     async.auto = function (tasks, callback) {
 794 |         callback = _once(callback || noop);
 795 |         var keys = _keys(tasks);
 796 |         var remainingTasks = keys.length;
 797 |         if (!remainingTasks) {
 798 |             return callback(null);
 799 |         }
 800 | 
 801 |         var results = {};
 802 | 
 803 |         var listeners = [];
 804 |         function addListener(fn) {
 805 |             listeners.unshift(fn);
 806 |         }
 807 |         function removeListener(fn) {
 808 |             var idx = _indexOf(listeners, fn);
 809 |             if (idx >= 0) listeners.splice(idx, 1);
 810 |         }
 811 |         function taskComplete() {
 812 |             remainingTasks--;
 813 |             _arrayEach(listeners.slice(0), function (fn) {
 814 |                 fn();
 815 |             });
 816 |         }
 817 | 
 818 |         addListener(function () {
 819 |             if (!remainingTasks) {
 820 |                 callback(null, results);
 821 |             }
 822 |         });
 823 | 
 824 |         _arrayEach(keys, function (k) {
 825 |             var task = _isArray(tasks[k]) ? tasks[k]: [tasks[k]];
 826 |             var taskCallback = _restParam(function(err, args) {
 827 |                 if (args.length <= 1) {
 828 |                     args = args[0];
 829 |                 }
 830 |                 if (err) {
 831 |                     var safeResults = {};
 832 |                     _forEachOf(results, function(val, rkey) {
 833 |                         safeResults[rkey] = val;
 834 |                     });
 835 |                     safeResults[k] = args;
 836 |                     callback(err, safeResults);
 837 |                 }
 838 |                 else {
 839 |                     results[k] = args;
 840 |                     async.setImmediate(taskComplete);
 841 |                 }
 842 |             });
 843 |             var requires = task.slice(0, task.length - 1);
 844 |             // prevent dead-locks
 845 |             var len = requires.length;
 846 |             var dep;
 847 |             while (len--) {
 848 |                 if (!(dep = tasks[requires[len]])) {
 849 |                     throw new Error('Has inexistant dependency');
 850 |                 }
 851 |                 if (_isArray(dep) && _indexOf(dep, k) >= 0) {
 852 |                     throw new Error('Has cyclic dependencies');
 853 |                 }
 854 |             }
 855 |             function ready() {
 856 |                 return _reduce(requires, function (a, x) {
 857 |                     return (a && results.hasOwnProperty(x));
 858 |                 }, true) && !results.hasOwnProperty(k);
 859 |             }
 860 |             if (ready()) {
 861 |                 task[task.length - 1](taskCallback, results);
 862 |             }
 863 |             else {
 864 |                 addListener(listener);
 865 |             }
 866 |             function listener() {
 867 |                 if (ready()) {
 868 |                     removeListener(listener);
 869 |                     task[task.length - 1](taskCallback, results);
 870 |                 }
 871 |             }
 872 |         });
 873 |     };
 874 | 
 875 | 
 876 | 
 877 |     async.retry = function(times, task, callback) {
 878 |         var DEFAULT_TIMES = 5;
 879 |         var DEFAULT_INTERVAL = 0;
 880 | 
 881 |         var attempts = [];
 882 | 
 883 |         var opts = {
 884 |             times: DEFAULT_TIMES,
 885 |             interval: DEFAULT_INTERVAL
 886 |         };
 887 | 
 888 |         function parseTimes(acc, t){
 889 |             if(typeof t === 'number'){
 890 |                 acc.times = parseInt(t, 10) || DEFAULT_TIMES;
 891 |             } else if(typeof t === 'object'){
 892 |                 acc.times = parseInt(t.times, 10) || DEFAULT_TIMES;
 893 |                 acc.interval = parseInt(t.interval, 10) || DEFAULT_INTERVAL;
 894 |             } else {
 895 |                 throw new Error('Unsupported argument type for \'times\': ' + typeof t);
 896 |             }
 897 |         }
 898 | 
 899 |         var length = arguments.length;
 900 |         if (length < 1 || length > 3) {
 901 |             throw new Error('Invalid arguments - must be either (task), (task, callback), (times, task) or (times, task, callback)');
 902 |         } else if (length <= 2 && typeof times === 'function') {
 903 |             callback = task;
 904 |             task = times;
 905 |         }
 906 |         if (typeof times !== 'function') {
 907 |             parseTimes(opts, times);
 908 |         }
 909 |         opts.callback = callback;
 910 |         opts.task = task;
 911 | 
 912 |         function wrappedTask(wrappedCallback, wrappedResults) {
 913 |             function retryAttempt(task, finalAttempt) {
 914 |                 return function(seriesCallback) {
 915 |                     task(function(err, result){
 916 |                         seriesCallback(!err || finalAttempt, {err: err, result: result});
 917 |                     }, wrappedResults);
 918 |                 };
 919 |             }
 920 | 
 921 |             function retryInterval(interval){
 922 |                 return function(seriesCallback){
 923 |                     setTimeout(function(){
 924 |                         seriesCallback(null);
 925 |                     }, interval);
 926 |                 };
 927 |             }
 928 | 
 929 |             while (opts.times) {
 930 | 
 931 |                 var finalAttempt = !(opts.times-=1);
 932 |                 attempts.push(retryAttempt(opts.task, finalAttempt));
 933 |                 if(!finalAttempt && opts.interval > 0){
 934 |                     attempts.push(retryInterval(opts.interval));
 935 |                 }
 936 |             }
 937 | 
 938 |             async.series(attempts, function(done, data){
 939 |                 data = data[data.length - 1];
 940 |                 (wrappedCallback || opts.callback)(data.err, data.result);
 941 |             });
 942 |         }
 943 | 
 944 |         // If a callback is passed, run this as a controll flow
 945 |         return opts.callback ? wrappedTask() : wrappedTask;
 946 |     };
 947 | 
 948 |     async.waterfall = function (tasks, callback) {
 949 |         callback = _once(callback || noop);
 950 |         if (!_isArray(tasks)) {
 951 |             var err = new Error('First argument to waterfall must be an array of functions');
 952 |             return callback(err);
 953 |         }
 954 |         if (!tasks.length) {
 955 |             return callback();
 956 |         }
 957 |         function wrapIterator(iterator) {
 958 |             return _restParam(function (err, args) {
 959 |                 if (err) {
 960 |                     callback.apply(null, [err].concat(args));
 961 |                 }
 962 |                 else {
 963 |                     var next = iterator.next();
 964 |                     if (next) {
 965 |                         args.push(wrapIterator(next));
 966 |                     }
 967 |                     else {
 968 |                         args.push(callback);
 969 |                     }
 970 |                     ensureAsync(iterator).apply(null, args);
 971 |                 }
 972 |             });
 973 |         }
 974 |         wrapIterator(async.iterator(tasks))();
 975 |     };
 976 | 
 977 |     function _parallel(eachfn, tasks, callback) {
 978 |         callback = callback || noop;
 979 |         var results = _isArrayLike(tasks) ? [] : {};
 980 | 
 981 |         eachfn(tasks, function (task, key, callback) {
 982 |             task(_restParam(function (err, args) {
 983 |                 if (args.length <= 1) {
 984 |                     args = args[0];
 985 |                 }
 986 |                 results[key] = args;
 987 |                 callback(err);
 988 |             }));
 989 |         }, function (err) {
 990 |             callback(err, results);
 991 |         });
 992 |     }
 993 | 
 994 |     async.parallel = function (tasks, callback) {
 995 |         _parallel(async.eachOf, tasks, callback);
 996 |     };
 997 | 
 998 |     async.parallelLimit = function(tasks, limit, callback) {
 999 |         _parallel(_eachOfLimit(limit), tasks, callback);
1000 |     };
1001 | 
1002 |     async.series = function(tasks, callback) {
1003 |         _parallel(async.eachOfSeries, tasks, callback);
1004 |     };
1005 | 
1006 |     async.iterator = function (tasks) {
1007 |         function makeCallback(index) {
1008 |             function fn() {
1009 |                 if (tasks.length) {
1010 |                     tasks[index].apply(null, arguments);
1011 |                 }
1012 |                 return fn.next();
1013 |             }
1014 |             fn.next = function () {
1015 |                 return (index < tasks.length - 1) ? makeCallback(index + 1): null;
1016 |             };
1017 |             return fn;
1018 |         }
1019 |         return makeCallback(0);
1020 |     };
1021 | 
1022 |     async.apply = _restParam(function (fn, args) {
1023 |         return _restParam(function (callArgs) {
1024 |             return fn.apply(
1025 |                 null, args.concat(callArgs)
1026 |             );
1027 |         });
1028 |     });
1029 | 
1030 |     function _concat(eachfn, arr, fn, callback) {
1031 |         var result = [];
1032 |         eachfn(arr, function (x, index, cb) {
1033 |             fn(x, function (err, y) {
1034 |                 result = result.concat(y || []);
1035 |                 cb(err);
1036 |             });
1037 |         }, function (err) {
1038 |             callback(err, result);
1039 |         });
1040 |     }
1041 |     async.concat = doParallel(_concat);
1042 |     async.concatSeries = doSeries(_concat);
1043 | 
1044 |     async.whilst = function (test, iterator, callback) {
1045 |         callback = callback || noop;
1046 |         if (test()) {
1047 |             var next = _restParam(function(err, args) {
1048 |                 if (err) {
1049 |                     callback(err);
1050 |                 } else if (test.apply(this, args)) {
1051 |                     iterator(next);
1052 |                 } else {
1053 |                     callback(null);
1054 |                 }
1055 |             });
1056 |             iterator(next);
1057 |         } else {
1058 |             callback(null);
1059 |         }
1060 |     };
1061 | 
1062 |     async.doWhilst = function (iterator, test, callback) {
1063 |         var calls = 0;
1064 |         return async.whilst(function() {
1065 |             return ++calls <= 1 || test.apply(this, arguments);
1066 |         }, iterator, callback);
1067 |     };
1068 | 
1069 |     async.until = function (test, iterator, callback) {
1070 |         return async.whilst(function() {
1071 |             return !test.apply(this, arguments);
1072 |         }, iterator, callback);
1073 |     };
1074 | 
1075 |     async.doUntil = function (iterator, test, callback) {
1076 |         return async.doWhilst(iterator, function() {
1077 |             return !test.apply(this, arguments);
1078 |         }, callback);
1079 |     };
1080 | 
1081 |     async.during = function (test, iterator, callback) {
1082 |         callback = callback || noop;
1083 | 
1084 |         var next = _restParam(function(err, args) {
1085 |             if (err) {
1086 |                 callback(err);
1087 |             } else {
1088 |                 args.push(check);
1089 |                 test.apply(this, args);
1090 |             }
1091 |         });
1092 | 
1093 |         var check = function(err, truth) {
1094 |             if (err) {
1095 |                 callback(err);
1096 |             } else if (truth) {
1097 |                 iterator(next);
1098 |             } else {
1099 |                 callback(null);
1100 |             }
1101 |         };
1102 | 
1103 |         test(check);
1104 |     };
1105 | 
1106 |     async.doDuring = function (iterator, test, callback) {
1107 |         var calls = 0;
1108 |         async.during(function(next) {
1109 |             if (calls++ < 1) {
1110 |                 next(null, true);
1111 |             } else {
1112 |                 test.apply(this, arguments);
1113 |             }
1114 |         }, iterator, callback);
1115 |     };
1116 | 
1117 |     function _queue(worker, concurrency, payload) {
1118 |         if (concurrency == null) {
1119 |             concurrency = 1;
1120 |         }
1121 |         else if(concurrency === 0) {
1122 |             throw new Error('Concurrency must not be zero');
1123 |         }
1124 |         function _insert(q, data, pos, callback) {
1125 |             if (callback != null && typeof callback !== "function") {
1126 |                 throw new Error("task callback must be a function");
1127 |             }
1128 |             q.started = true;
1129 |             if (!_isArray(data)) {
1130 |                 data = [data];
1131 |             }
1132 |             if(data.length === 0 && q.idle()) {
1133 |                 // call drain immediately if there are no tasks
1134 |                 return async.setImmediate(function() {
1135 |                     q.drain();
1136 |                 });
1137 |             }
1138 |             _arrayEach(data, function(task) {
1139 |                 var item = {
1140 |                     data: task,
1141 |                     callback: callback || noop
1142 |                 };
1143 | 
1144 |                 if (pos) {
1145 |                     q.tasks.unshift(item);
1146 |                 } else {
1147 |                     q.tasks.push(item);
1148 |                 }
1149 | 
1150 |                 if (q.tasks.length === q.concurrency) {
1151 |                     q.saturated();
1152 |                 }
1153 |             });
1154 |             async.setImmediate(q.process);
1155 |         }
1156 |         function _next(q, tasks) {
1157 |             return function(){
1158 |                 workers -= 1;
1159 |                 var args = arguments;
1160 |                 _arrayEach(tasks, function (task) {
1161 |                     task.callback.apply(task, args);
1162 |                 });
1163 |                 if (q.tasks.length + workers === 0) {
1164 |                     q.drain();
1165 |                 }
1166 |                 q.process();
1167 |             };
1168 |         }
1169 | 
1170 |         var workers = 0;
1171 |         var q = {
1172 |             tasks: [],
1173 |             concurrency: concurrency,
1174 |             payload: payload,
1175 |             saturated: noop,
1176 |             empty: noop,
1177 |             drain: noop,
1178 |             started: false,
1179 |             paused: false,
1180 |             push: function (data, callback) {
1181 |                 _insert(q, data, false, callback);
1182 |             },
1183 |             kill: function () {
1184 |                 q.drain = noop;
1185 |                 q.tasks = [];
1186 |             },
1187 |             unshift: function (data, callback) {
1188 |                 _insert(q, data, true, callback);
1189 |             },
1190 |             process: function () {
1191 |                 if (!q.paused && workers < q.concurrency && q.tasks.length) {
1192 |                     while(workers < q.concurrency && q.tasks.length){
1193 |                         var tasks = q.payload ?
1194 |                             q.tasks.splice(0, q.payload) :
1195 |                             q.tasks.splice(0, q.tasks.length);
1196 | 
1197 |                         var data = _map(tasks, function (task) {
1198 |                             return task.data;
1199 |                         });
1200 | 
1201 |                         if (q.tasks.length === 0) {
1202 |                             q.empty();
1203 |                         }
1204 |                         workers += 1;
1205 |                         var cb = only_once(_next(q, tasks));
1206 |                         worker(data, cb);
1207 |                     }
1208 |                 }
1209 |             },
1210 |             length: function () {
1211 |                 return q.tasks.length;
1212 |             },
1213 |             running: function () {
1214 |                 return workers;
1215 |             },
1216 |             idle: function() {
1217 |                 return q.tasks.length + workers === 0;
1218 |             },
1219 |             pause: function () {
1220 |                 q.paused = true;
1221 |             },
1222 |             resume: function () {
1223 |                 if (q.paused === false) { return; }
1224 |                 q.paused = false;
1225 |                 var resumeCount = Math.min(q.concurrency, q.tasks.length);
1226 |                 // Need to call q.process once per concurrent
1227 |                 // worker to preserve full concurrency after pause
1228 |                 for (var w = 1; w <= resumeCount; w++) {
1229 |                     async.setImmediate(q.process);
1230 |                 }
1231 |             }
1232 |         };
1233 |         return q;
1234 |     }
1235 | 
1236 |     async.queue = function (worker, concurrency) {
1237 |         var q = _queue(function (items, cb) {
1238 |             worker(items[0], cb);
1239 |         }, concurrency, 1);
1240 | 
1241 |         return q;
1242 |     };
1243 | 
1244 |     async.priorityQueue = function (worker, concurrency) {
1245 | 
1246 |         function _compareTasks(a, b){
1247 |             return a.priority - b.priority;
1248 |         }
1249 | 
1250 |         function _binarySearch(sequence, item, compare) {
1251 |             var beg = -1,
1252 |                 end = sequence.length - 1;
1253 |             while (beg < end) {
1254 |                 var mid = beg + ((end - beg + 1) >>> 1);
1255 |                 if (compare(item, sequence[mid]) >= 0) {
1256 |                     beg = mid;
1257 |                 } else {
1258 |                     end = mid - 1;
1259 |                 }
1260 |             }
1261 |             return beg;
1262 |         }
1263 | 
1264 |         function _insert(q, data, priority, callback) {
1265 |             if (callback != null && typeof callback !== "function") {
1266 |                 throw new Error("task callback must be a function");
1267 |             }
1268 |             q.started = true;
1269 |             if (!_isArray(data)) {
1270 |                 data = [data];
1271 |             }
1272 |             if(data.length === 0) {
1273 |                 // call drain immediately if there are no tasks
1274 |                 return async.setImmediate(function() {
1275 |                     q.drain();
1276 |                 });
1277 |             }
1278 |             _arrayEach(data, function(task) {
1279 |                 var item = {
1280 |                     data: task,
1281 |                     priority: priority,
1282 |                     callback: typeof callback === 'function' ? callback : noop
1283 |                 };
1284 | 
1285 |                 q.tasks.splice(_binarySearch(q.tasks, item, _compareTasks) + 1, 0, item);
1286 | 
1287 |                 if (q.tasks.length === q.concurrency) {
1288 |                     q.saturated();
1289 |                 }
1290 |                 async.setImmediate(q.process);
1291 |             });
1292 |         }
1293 | 
1294 |         // Start with a normal queue
1295 |         var q = async.queue(worker, concurrency);
1296 | 
1297 |         // Override push to accept second parameter representing priority
1298 |         q.push = function (data, priority, callback) {
1299 |             _insert(q, data, priority, callback);
1300 |         };
1301 | 
1302 |         // Remove unshift function
1303 |         delete q.unshift;
1304 | 
1305 |         return q;
1306 |     };
1307 | 
1308 |     async.cargo = function (worker, payload) {
1309 |         return _queue(worker, 1, payload);
1310 |     };
1311 | 
1312 |     function _console_fn(name) {
1313 |         return _restParam(function (fn, args) {
1314 |             fn.apply(null, args.concat([_restParam(function (err, args) {
1315 |                 if (typeof console === 'object') {
1316 |                     if (err) {
1317 |                         if (console.error) {
1318 |                             console.error(err);
1319 |                         }
1320 |                     }
1321 |                     else if (console[name]) {
1322 |                         _arrayEach(args, function (x) {
1323 |                             console[name](x);
1324 |                         });
1325 |                     }
1326 |                 }
1327 |             })]));
1328 |         });
1329 |     }
1330 |     async.log = _console_fn('log');
1331 |     async.dir = _console_fn('dir');
1332 |     /*async.info = _console_fn('info');
1333 |     async.warn = _console_fn('warn');
1334 |     async.error = _console_fn('error');*/
1335 | 
1336 |     async.memoize = function (fn, hasher) {
1337 |         var memo = {};
1338 |         var queues = {};
1339 |         hasher = hasher || identity;
1340 |         var memoized = _restParam(function memoized(args) {
1341 |             var callback = args.pop();
1342 |             var key = hasher.apply(null, args);
1343 |             if (key in memo) {
1344 |                 async.nextTick(function () {
1345 |                     callback.apply(null, memo[key]);
1346 |                 });
1347 |             }
1348 |             else if (key in queues) {
1349 |                 queues[key].push(callback);
1350 |             }
1351 |             else {
1352 |                 queues[key] = [callback];
1353 |                 fn.apply(null, args.concat([_restParam(function (args) {
1354 |                     memo[key] = args;
1355 |                     var q = queues[key];
1356 |                     delete queues[key];
1357 |                     for (var i = 0, l = q.length; i < l; i++) {
1358 |                         q[i].apply(null, args);
1359 |                     }
1360 |                 })]));
1361 |             }
1362 |         });
1363 |         memoized.memo = memo;
1364 |         memoized.unmemoized = fn;
1365 |         return memoized;
1366 |     };
1367 | 
1368 |     async.unmemoize = function (fn) {
1369 |         return function () {
1370 |             return (fn.unmemoized || fn).apply(null, arguments);
1371 |         };
1372 |     };
1373 | 
1374 |     function _times(mapper) {
1375 |         return function (count, iterator, callback) {
1376 |             mapper(_range(count), iterator, callback);
1377 |         };
1378 |     }
1379 | 
1380 |     async.times = _times(async.map);
1381 |     async.timesSeries = _times(async.mapSeries);
1382 |     async.timesLimit = function (count, limit, iterator, callback) {
1383 |         return async.mapLimit(_range(count), limit, iterator, callback);
1384 |     };
1385 | 
1386 |     async.seq = function (/* functions... */) {
1387 |         var fns = arguments;
1388 |         return _restParam(function (args) {
1389 |             var that = this;
1390 | 
1391 |             var callback = args[args.length - 1];
1392 |             if (typeof callback == 'function') {
1393 |                 args.pop();
1394 |             } else {
1395 |                 callback = noop;
1396 |             }
1397 | 
1398 |             async.reduce(fns, args, function (newargs, fn, cb) {
1399 |                 fn.apply(that, newargs.concat([_restParam(function (err, nextargs) {
1400 |                     cb(err, nextargs);
1401 |                 })]));
1402 |             },
1403 |             function (err, results) {
1404 |                 callback.apply(that, [err].concat(results));
1405 |             });
1406 |         });
1407 |     };
1408 | 
1409 |     async.compose = function (/* functions... */) {
1410 |         return async.seq.apply(null, Array.prototype.reverse.call(arguments));
1411 |     };
1412 | 
1413 | 
1414 |     function _applyEach(eachfn) {
1415 |         return _restParam(function(fns, args) {
1416 |             var go = _restParam(function(args) {
1417 |                 var that = this;
1418 |                 var callback = args.pop();
1419 |                 return eachfn(fns, function (fn, _, cb) {
1420 |                     fn.apply(that, args.concat([cb]));
1421 |                 },
1422 |                 callback);
1423 |             });
1424 |             if (args.length) {
1425 |                 return go.apply(this, args);
1426 |             }
1427 |             else {
1428 |                 return go;
1429 |             }
1430 |         });
1431 |     }
1432 | 
1433 |     async.applyEach = _applyEach(async.eachOf);
1434 |     async.applyEachSeries = _applyEach(async.eachOfSeries);
1435 | 
1436 | 
1437 |     async.forever = function (fn, callback) {
1438 |         var done = only_once(callback || noop);
1439 |         var task = ensureAsync(fn);
1440 |         function next(err) {
1441 |             if (err) {
1442 |                 return done(err);
1443 |             }
1444 |             task(next);
1445 |         }
1446 |         next();
1447 |     };
1448 | 
1449 |     function ensureAsync(fn) {
1450 |         return _restParam(function (args) {
1451 |             var callback = args.pop();
1452 |             args.push(function () {
1453 |                 var innerArgs = arguments;
1454 |                 if (sync) {
1455 |                     async.setImmediate(function () {
1456 |                         callback.apply(null, innerArgs);
1457 |                     });
1458 |                 } else {
1459 |                     callback.apply(null, innerArgs);
1460 |                 }
1461 |             });
1462 |             var sync = true;
1463 |             fn.apply(this, args);
1464 |             sync = false;
1465 |         });
1466 |     }
1467 | 
1468 |     async.ensureAsync = ensureAsync;
1469 | 
1470 |     async.constant = _restParam(function(values) {
1471 |         var args = [null].concat(values);
1472 |         return function (callback) {
1473 |             return callback.apply(this, args);
1474 |         };
1475 |     });
1476 | 
1477 |     async.wrapSync =
1478 |     async.asyncify = function asyncify(func) {
1479 |         return _restParam(function (args) {
1480 |             var callback = args.pop();
1481 |             var result;
1482 |             try {
1483 |                 result = func.apply(this, args);
1484 |             } catch (e) {
1485 |                 return callback(e);
1486 |             }
1487 |             // if result is Promise object
1488 |             if (_isObject(result) && typeof result.then === "function") {
1489 |                 result.then(function(value) {
1490 |                     callback(null, value);
1491 |                 })["catch"](function(err) {
1492 |                     callback(err.message ? err : new Error(err));
1493 |                 });
1494 |             } else {
1495 |                 callback(null, result);
1496 |             }
1497 |         });
1498 |     };
1499 | 
1500 |     // Node.js
1501 |     if (typeof module === 'object' && module.exports) {
1502 |         module.exports = async;
1503 |     }
1504 |     // AMD / RequireJS
1505 |     else if (typeof define === 'function' && define.amd) {
1506 |         define([], function () {
1507 |             return async;
1508 |         });
1509 |     }
1510 |     // included directly via <script> tag
1511 |     else {
1512 |         root.async = async;
1513 |     }
1514 | 
1515 | }());
1516 | 
1517 | }).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
1518 | },{"_process":12}],6:[function(require,module,exports){
1519 | 
1520 | },{}],7:[function(require,module,exports){
1521 | (function (global){
1522 | 'use strict';
1523 | var Mutation = global.MutationObserver || global.WebKitMutationObserver;
1524 | 
1525 | var scheduleDrain;
1526 | 
1527 | {
1528 |   if (Mutation) {
1529 |     var called = 0;
1530 |     var observer = new Mutation(nextTick);
1531 |     var element = global.document.createTextNode('');
1532 |     observer.observe(element, {
1533 |       characterData: true
1534 |     });
1535 |     scheduleDrain = function () {
1536 |       element.data = (called = ++called % 2);
1537 |     };
1538 |   } else if (!global.setImmediate && typeof global.MessageChannel !== 'undefined') {
1539 |     var channel = new global.MessageChannel();
1540 |     channel.port1.onmessage = nextTick;
1541 |     scheduleDrain = function () {
1542 |       channel.port2.postMessage(0);
1543 |     };
1544 |   } else if ('document' in global && 'onreadystatechange' in global.document.createElement('script')) {
1545 |     scheduleDrain = function () {
1546 | 
1547 |       // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
1548 |       // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
1549 |       var scriptEl = global.document.createElement('script');
1550 |       scriptEl.onreadystatechange = function () {
1551 |         nextTick();
1552 | 
1553 |         scriptEl.onreadystatechange = null;
1554 |         scriptEl.parentNode.removeChild(scriptEl);
1555 |         scriptEl = null;
1556 |       };
1557 |       global.document.documentElement.appendChild(scriptEl);
1558 |     };
1559 |   } else {
1560 |     scheduleDrain = function () {
1561 |       setTimeout(nextTick, 0);
1562 |     };
1563 |   }
1564 | }
1565 | 
1566 | var draining;
1567 | var queue = [];
1568 | //named nextTick for less confusing stack traces
1569 | function nextTick() {
1570 |   draining = true;
1571 |   var i, oldQueue;
1572 |   var len = queue.length;
1573 |   while (len) {
1574 |     oldQueue = queue;
1575 |     queue = [];
1576 |     i = -1;
1577 |     while (++i < len) {
1578 |       oldQueue[i]();
1579 |     }
1580 |     len = queue.length;
1581 |   }
1582 |   draining = false;
1583 | }
1584 | 
1585 | module.exports = immediate;
1586 | function immediate(task) {
1587 |   if (queue.push(task) === 1 && !draining) {
1588 |     scheduleDrain();
1589 |   }
1590 | }
1591 | 
1592 | }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
1593 | },{}],8:[function(require,module,exports){
1594 | 'use strict';
1595 | var immediate = require('immediate');
1596 | 
1597 | /* istanbul ignore next */
1598 | function INTERNAL() {}
1599 | 
1600 | var handlers = {};
1601 | 
1602 | var REJECTED = ['REJECTED'];
1603 | var FULFILLED = ['FULFILLED'];
1604 | var PENDING = ['PENDING'];
1605 | var UNHANDLED;
1606 | 
1607 | module.exports = exports = Promise;
1608 | 
1609 | function Promise(resolver) {
1610 |   if (typeof resolver !== 'function') {
1611 |     throw new TypeError('resolver must be a function');
1612 |   }
1613 |   this.state = PENDING;
1614 |   this.queue = [];
1615 |   this.outcome = void 0;
1616 |   if (resolver !== INTERNAL) {
1617 |     safelyResolveThenable(this, resolver);
1618 |   }
1619 | }
1620 | 
1621 | Promise.prototype["catch"] = function (onRejected) {
1622 |   return this.then(null, onRejected);
1623 | };
1624 | Promise.prototype.then = function (onFulfilled, onRejected) {
1625 |   if (typeof onFulfilled !== 'function' && this.state === FULFILLED ||
1626 |     typeof onRejected !== 'function' && this.state === REJECTED) {
1627 |     return this;
1628 |   }
1629 |   var promise = new this.constructor(INTERNAL);
1630 |   if (this.state !== PENDING) {
1631 |     var resolver = this.state === FULFILLED ? onFulfilled : onRejected;
1632 |     unwrap(promise, resolver, this.outcome);
1633 |   } else {
1634 |     this.queue.push(new QueueItem(promise, onFulfilled, onRejected));
1635 |   }
1636 | 
1637 |   return promise;
1638 | };
1639 | function QueueItem(promise, onFulfilled, onRejected) {
1640 |   this.promise = promise;
1641 |   if (typeof onFulfilled === 'function') {
1642 |     this.onFulfilled = onFulfilled;
1643 |     this.callFulfilled = this.otherCallFulfilled;
1644 |   }
1645 |   if (typeof onRejected === 'function') {
1646 |     this.onRejected = onRejected;
1647 |     this.callRejected = this.otherCallRejected;
1648 |   }
1649 | }
1650 | QueueItem.prototype.callFulfilled = function (value) {
1651 |   handlers.resolve(this.promise, value);
1652 | };
1653 | QueueItem.prototype.otherCallFulfilled = function (value) {
1654 |   unwrap(this.promise, this.onFulfilled, value);
1655 | };
1656 | QueueItem.prototype.callRejected = function (value) {
1657 |   handlers.reject(this.promise, value);
1658 | };
1659 | QueueItem.prototype.otherCallRejected = function (value) {
1660 |   unwrap(this.promise, this.onRejected, value);
1661 | };
1662 | 
1663 | function unwrap(promise, func, value) {
1664 |   immediate(function () {
1665 |     var returnValue;
1666 |     try {
1667 |       returnValue = func(value);
1668 |     } catch (e) {
1669 |       return handlers.reject(promise, e);
1670 |     }
1671 |     if (returnValue === promise) {
1672 |       handlers.reject(promise, new TypeError('Cannot resolve promise with itself'));
1673 |     } else {
1674 |       handlers.resolve(promise, returnValue);
1675 |     }
1676 |   });
1677 | }
1678 | 
1679 | handlers.resolve = function (self, value) {
1680 |   var result = tryCatch(getThen, value);
1681 |   if (result.status === 'error') {
1682 |     return handlers.reject(self, result.value);
1683 |   }
1684 |   var thenable = result.value;
1685 | 
1686 |   if (thenable) {
1687 |     safelyResolveThenable(self, thenable);
1688 |   } else {
1689 |     self.state = FULFILLED;
1690 |     self.outcome = value;
1691 |     var i = -1;
1692 |     var len = self.queue.length;
1693 |     while (++i < len) {
1694 |       self.queue[i].callFulfilled(value);
1695 |     }
1696 |   }
1697 |   return self;
1698 | };
1699 | handlers.reject = function (self, error) {
1700 |   self.state = REJECTED;
1701 |   self.outcome = error;
1702 |   var i = -1;
1703 |   var len = self.queue.length;
1704 |   while (++i < len) {
1705 |     self.queue[i].callRejected(error);
1706 |   }
1707 |   return self;
1708 | };
1709 | 
1710 | function getThen(obj) {
1711 |   // Make sure we only access the accessor once as required by the spec
1712 |   var then = obj && obj.then;
1713 |   if (obj && typeof obj === 'object' && typeof then === 'function') {
1714 |     return function appyThen() {
1715 |       then.apply(obj, arguments);
1716 |     };
1717 |   }
1718 | }
1719 | 
1720 | function safelyResolveThenable(self, thenable) {
1721 |   // Either fulfill, reject or reject with error
1722 |   var called = false;
1723 |   function onError(value) {
1724 |     if (called) {
1725 |       return;
1726 |     }
1727 |     called = true;
1728 |     handlers.reject(self, value);
1729 |   }
1730 | 
1731 |   function onSuccess(value) {
1732 |     if (called) {
1733 |       return;
1734 |     }
1735 |     called = true;
1736 |     handlers.resolve(self, value);
1737 |   }
1738 | 
1739 |   function tryToUnwrap() {
1740 |     thenable(onSuccess, onError);
1741 |   }
1742 | 
1743 |   var result = tryCatch(tryToUnwrap);
1744 |   if (result.status === 'error') {
1745 |     onError(result.value);
1746 |   }
1747 | }
1748 | 
1749 | function tryCatch(func, value) {
1750 |   var out = {};
1751 |   try {
1752 |     out.value = func(value);
1753 |     out.status = 'success';
1754 |   } catch (e) {
1755 |     out.status = 'error';
1756 |     out.value = e;
1757 |   }
1758 |   return out;
1759 | }
1760 | 
1761 | exports.resolve = resolve;
1762 | function resolve(value) {
1763 |   if (value instanceof this) {
1764 |     return value;
1765 |   }
1766 |   return handlers.resolve(new this(INTERNAL), value);
1767 | }
1768 | 
1769 | exports.reject = reject;
1770 | function reject(reason) {
1771 |   var promise = new this(INTERNAL);
1772 |   return handlers.reject(promise, reason);
1773 | }
1774 | 
1775 | exports.all = all;
1776 | function all(iterable) {
1777 |   var self = this;
1778 |   if (Object.prototype.toString.call(iterable) !== '[object Array]') {
1779 |     return this.reject(new TypeError('must be an array'));
1780 |   }
1781 | 
1782 |   var len = iterable.length;
1783 |   var called = false;
1784 |   if (!len) {
1785 |     return this.resolve([]);
1786 |   }
1787 | 
1788 |   var values = new Array(len);
1789 |   var resolved = 0;
1790 |   var i = -1;
1791 |   var promise = new this(INTERNAL);
1792 | 
1793 |   while (++i < len) {
1794 |     allResolver(iterable[i], i);
1795 |   }
1796 |   return promise;
1797 |   function allResolver(value, i) {
1798 |     self.resolve(value).then(resolveFromAll, function (error) {
1799 |       if (!called) {
1800 |         called = true;
1801 |         handlers.reject(promise, error);
1802 |       }
1803 |     });
1804 |     function resolveFromAll(outValue) {
1805 |       values[i] = outValue;
1806 |       if (++resolved === len && !called) {
1807 |         called = true;
1808 |         handlers.resolve(promise, values);
1809 |       }
1810 |     }
1811 |   }
1812 | }
1813 | 
1814 | exports.race = race;
1815 | function race(iterable) {
1816 |   var self = this;
1817 |   if (Object.prototype.toString.call(iterable) !== '[object Array]') {
1818 |     return this.reject(new TypeError('must be an array'));
1819 |   }
1820 | 
1821 |   var len = iterable.length;
1822 |   var called = false;
1823 |   if (!len) {
1824 |     return this.resolve([]);
1825 |   }
1826 | 
1827 |   var i = -1;
1828 |   var promise = new this(INTERNAL);
1829 | 
1830 |   while (++i < len) {
1831 |     resolver(iterable[i]);
1832 |   }
1833 |   return promise;
1834 |   function resolver(value) {
1835 |     self.resolve(value).then(function (response) {
1836 |       if (!called) {
1837 |         called = true;
1838 |         handlers.resolve(promise, response);
1839 |       }
1840 |     }, function (error) {
1841 |       if (!called) {
1842 |         called = true;
1843 |         handlers.reject(promise, error);
1844 |       }
1845 |     });
1846 |   }
1847 | }
1848 | 
1849 | },{"immediate":7}],9:[function(require,module,exports){
1850 | "use strict";
1851 | 
1852 | // Extends method
1853 | // (taken from http://code.jquery.com/jquery-1.9.0.js)
1854 | // Populate the class2type map
1855 | var class2type = {};
1856 | 
1857 | var types = [
1858 |   "Boolean", "Number", "String", "Function", "Array",
1859 |   "Date", "RegExp", "Object", "Error"
1860 | ];
1861 | for (var i = 0; i < types.length; i++) {
1862 |   var typename = types[i];
1863 |   class2type["[object " + typename + "]"] = typename.toLowerCase();
1864 | }
1865 | 
1866 | var core_toString = class2type.toString;
1867 | var core_hasOwn = class2type.hasOwnProperty;
1868 | 
1869 | function type(obj) {
1870 |   if (obj === null) {
1871 |     return String(obj);
1872 |   }
1873 |   return typeof obj === "object" || typeof obj === "function" ?
1874 |     class2type[core_toString.call(obj)] || "object" :
1875 |     typeof obj;
1876 | }
1877 | 
1878 | function isWindow(obj) {
1879 |   return obj !== null && obj === obj.window;
1880 | }
1881 | 
1882 | function isPlainObject(obj) {
1883 |   // Must be an Object.
1884 |   // Because of IE, we also have to check the presence of
1885 |   // the constructor property.
1886 |   // Make sure that DOM nodes and window objects don't pass through, as well
1887 |   if (!obj || type(obj) !== "object" || obj.nodeType || isWindow(obj)) {
1888 |     return false;
1889 |   }
1890 | 
1891 |   try {
1892 |     // Not own constructor property must be Object
1893 |     if (obj.constructor &&
1894 |       !core_hasOwn.call(obj, "constructor") &&
1895 |       !core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) {
1896 |       return false;
1897 |     }
1898 |   } catch ( e ) {
1899 |     // IE8,9 Will throw exceptions on certain host objects #9897
1900 |     return false;
1901 |   }
1902 | 
1903 |   // Own properties are enumerated firstly, so to speed up,
1904 |   // if last one is own, then all properties are own.
1905 |   var key;
1906 |   for (key in obj) {}
1907 | 
1908 |   return key === undefined || core_hasOwn.call(obj, key);
1909 | }
1910 | 
1911 | 
1912 | function isFunction(obj) {
1913 |   return type(obj) === "function";
1914 | }
1915 | 
1916 | var isArray = Array.isArray || function (obj) {
1917 |   return type(obj) === "array";
1918 | };
1919 | 
1920 | function extend() {
1921 |   // originally extend() was recursive, but this ended up giving us
1922 |   // "call stack exceeded", so it's been unrolled to use a literal stack
1923 |   // (see https://github.com/pouchdb/pouchdb/issues/2543)
1924 |   var stack = [];
1925 |   var i = -1;
1926 |   var len = arguments.length;
1927 |   var args = new Array(len);
1928 |   while (++i < len) {
1929 |     args[i] = arguments[i];
1930 |   }
1931 |   var container = {};
1932 |   stack.push({args: args, result: {container: container, key: 'key'}});
1933 |   var next;
1934 |   while ((next = stack.pop())) {
1935 |     extendInner(stack, next.args, next.result);
1936 |   }
1937 |   return container.key;
1938 | }
1939 | 
1940 | function extendInner(stack, args, result) {
1941 |   var options, name, src, copy, copyIsArray, clone,
1942 |     target = args[0] || {},
1943 |     i = 1,
1944 |     length = args.length,
1945 |     deep = false,
1946 |     numericStringRegex = /\d+/,
1947 |     optionsIsArray;
1948 | 
1949 |   // Handle a deep copy situation
1950 |   if (typeof target === "boolean") {
1951 |     deep = target;
1952 |     target = args[1] || {};
1953 |     // skip the boolean and the target
1954 |     i = 2;
1955 |   }
1956 | 
1957 |   // Handle case when target is a string or something (possible in deep copy)
1958 |   if (typeof target !== "object" && !isFunction(target)) {
1959 |     target = {};
1960 |   }
1961 | 
1962 |   // extend jQuery itself if only one argument is passed
1963 |   if (length === i) {
1964 |     /* jshint validthis: true */
1965 |     target = this;
1966 |     --i;
1967 |   }
1968 | 
1969 |   for (; i < length; i++) {
1970 |     // Only deal with non-null/undefined values
1971 |     if ((options = args[i]) != null) {
1972 |       optionsIsArray = isArray(options);
1973 |       // Extend the base object
1974 |       for (name in options) {
1975 |         //if (options.hasOwnProperty(name)) {
1976 |         if (!(name in Object.prototype)) {
1977 |           if (optionsIsArray && !numericStringRegex.test(name)) {
1978 |             continue;
1979 |           }
1980 | 
1981 |           src = target[name];
1982 |           copy = options[name];
1983 | 
1984 |           // Prevent never-ending loop
1985 |           if (target === copy) {
1986 |             continue;
1987 |           }
1988 | 
1989 |           // Recurse if we're merging plain objects or arrays
1990 |           if (deep && copy && (isPlainObject(copy) ||
1991 |               (copyIsArray = isArray(copy)))) {
1992 |             if (copyIsArray) {
1993 |               copyIsArray = false;
1994 |               clone = src && isArray(src) ? src : [];
1995 | 
1996 |             } else {
1997 |               clone = src && isPlainObject(src) ? src : {};
1998 |             }
1999 | 
2000 |             // Never move original objects, clone them
2001 |             stack.push({
2002 |               args: [deep, clone, copy],
2003 |               result: {
2004 |                 container: target,
2005 |                 key: name
2006 |               }
2007 |             });
2008 | 
2009 |           // Don't bring in undefined values
2010 |           } else if (copy !== undefined) {
2011 |             if (!(isArray(options) && isFunction(copy))) {
2012 |               target[name] = copy;
2013 |             }
2014 |           }
2015 |         }
2016 |       }
2017 |     }
2018 |   }
2019 | 
2020 |   // "Return" the modified object by setting the key
2021 |   // on the given container
2022 |   result.container[result.key] = target;
2023 | }
2024 | 
2025 | 
2026 | module.exports = extend;
2027 | 
2028 | 
2029 | 
2030 | },{}],10:[function(require,module,exports){
2031 | 'use strict';
2032 | 
2033 | // allow external plugins to require('pouchdb/extras/promise')
2034 | module.exports = require('../lib/deps/promise');
2035 | },{"../lib/deps/promise":11}],11:[function(require,module,exports){
2036 | 'use strict';
2037 | /* istanbul ignore next */
2038 | module.exports = typeof Promise === 'function' ? Promise : require('lie');
2039 | 
2040 | },{"lie":8}],12:[function(require,module,exports){
2041 | // shim for using process in browser
2042 | 
2043 | var process = module.exports = {};
2044 | var queue = [];
2045 | var draining = false;
2046 | var currentQueue;
2047 | var queueIndex = -1;
2048 | 
2049 | function cleanUpNextTick() {
2050 |     draining = false;
2051 |     if (currentQueue.length) {
2052 |         queue = currentQueue.concat(queue);
2053 |     } else {
2054 |         queueIndex = -1;
2055 |     }
2056 |     if (queue.length) {
2057 |         drainQueue();
2058 |     }
2059 | }
2060 | 
2061 | function drainQueue() {
2062 |     if (draining) {
2063 |         return;
2064 |     }
2065 |     var timeout = setTimeout(cleanUpNextTick);
2066 |     draining = true;
2067 | 
2068 |     var len = queue.length;
2069 |     while(len) {
2070 |         currentQueue = queue;
2071 |         queue = [];
2072 |         while (++queueIndex < len) {
2073 |             if (currentQueue) {
2074 |                 currentQueue[queueIndex].run();
2075 |             }
2076 |         }
2077 |         queueIndex = -1;
2078 |         len = queue.length;
2079 |     }
2080 |     currentQueue = null;
2081 |     draining = false;
2082 |     clearTimeout(timeout);
2083 | }
2084 | 
2085 | process.nextTick = function (fun) {
2086 |     var args = new Array(arguments.length - 1);
2087 |     if (arguments.length > 1) {
2088 |         for (var i = 1; i < arguments.length; i++) {
2089 |             args[i - 1] = arguments[i];
2090 |         }
2091 |     }
2092 |     queue.push(new Item(fun, args));
2093 |     if (queue.length === 1 && !draining) {
2094 |         setTimeout(drainQueue, 0);
2095 |     }
2096 | };
2097 | 
2098 | // v8 likes predictible objects
2099 | function Item(fun, array) {
2100 |     this.fun = fun;
2101 |     this.array = array;
2102 | }
2103 | Item.prototype.run = function () {
2104 |     this.fun.apply(null, this.array);
2105 | };
2106 | process.title = 'browser';
2107 | process.browser = true;
2108 | process.env = {};
2109 | process.argv = [];
2110 | process.version = ''; // empty string to avoid regexp issues
2111 | process.versions = {};
2112 | 
2113 | function noop() {}
2114 | 
2115 | process.on = noop;
2116 | process.addListener = noop;
2117 | process.once = noop;
2118 | process.off = noop;
2119 | process.removeListener = noop;
2120 | process.removeAllListeners = noop;
2121 | process.emit = noop;
2122 | 
2123 | process.binding = function (name) {
2124 |     throw new Error('process.binding is not supported');
2125 | };
2126 | 
2127 | process.cwd = function () { return '/' };
2128 | process.chdir = function (dir) {
2129 |     throw new Error('process.chdir is not supported');
2130 | };
2131 | process.umask = function() { return 0; };
2132 | 
2133 | },{}],13:[function(require,module,exports){
2134 | /*jshint bitwise:false*/
2135 | /*global unescape*/
2136 | 
2137 | (function (factory) {
2138 |     if (typeof exports === 'object') {
2139 |         // Node/CommonJS
2140 |         module.exports = factory();
2141 |     } else if (typeof define === 'function' && define.amd) {
2142 |         // AMD
2143 |         define(factory);
2144 |     } else {
2145 |         // Browser globals (with support for web workers)
2146 |         var glob;
2147 |         try {
2148 |             glob = window;
2149 |         } catch (e) {
2150 |             glob = self;
2151 |         }
2152 | 
2153 |         glob.SparkMD5 = factory();
2154 |     }
2155 | }(function (undefined) {
2156 | 
2157 |     'use strict';
2158 | 
2159 |     ////////////////////////////////////////////////////////////////////////////
2160 | 
2161 |     /*
2162 |      * Fastest md5 implementation around (JKM md5)
2163 |      * Credits: Joseph Myers
2164 |      *
2165 |      * @see http://www.myersdaily.org/joseph/javascript/md5-text.html
2166 |      * @see http://jsperf.com/md5-shootout/7
2167 |      */
2168 | 
2169 |     /* this function is much faster,
2170 |       so if possible we use it. Some IEs
2171 |       are the only ones I know of that
2172 |       need the idiotic second function,
2173 |       generated by an if clause.  */
2174 |     var add32 = function (a, b) {
2175 |         return (a + b) & 0xFFFFFFFF;
2176 |     },
2177 | 
2178 |     cmn = function (q, a, b, x, s, t) {
2179 |         a = add32(add32(a, q), add32(x, t));
2180 |         return add32((a << s) | (a >>> (32 - s)), b);
2181 |     },
2182 | 
2183 |     ff = function (a, b, c, d, x, s, t) {
2184 |         return cmn((b & c) | ((~b) & d), a, b, x, s, t);
2185 |     },
2186 | 
2187 |     gg = function (a, b, c, d, x, s, t) {
2188 |         return cmn((b & d) | (c & (~d)), a, b, x, s, t);
2189 |     },
2190 | 
2191 |     hh = function (a, b, c, d, x, s, t) {
2192 |         return cmn(b ^ c ^ d, a, b, x, s, t);
2193 |     },
2194 | 
2195 |     ii = function (a, b, c, d, x, s, t) {
2196 |         return cmn(c ^ (b | (~d)), a, b, x, s, t);
2197 |     },
2198 | 
2199 |     md5cycle = function (x, k) {
2200 |         var a = x[0],
2201 |             b = x[1],
2202 |             c = x[2],
2203 |             d = x[3];
2204 | 
2205 |         a = ff(a, b, c, d, k[0], 7, -680876936);
2206 |         d = ff(d, a, b, c, k[1], 12, -389564586);
2207 |         c = ff(c, d, a, b, k[2], 17, 606105819);
2208 |         b = ff(b, c, d, a, k[3], 22, -1044525330);
2209 |         a = ff(a, b, c, d, k[4], 7, -176418897);
2210 |         d = ff(d, a, b, c, k[5], 12, 1200080426);
2211 |         c = ff(c, d, a, b, k[6], 17, -1473231341);
2212 |         b = ff(b, c, d, a, k[7], 22, -45705983);
2213 |         a = ff(a, b, c, d, k[8], 7, 1770035416);
2214 |         d = ff(d, a, b, c, k[9], 12, -1958414417);
2215 |         c = ff(c, d, a, b, k[10], 17, -42063);
2216 |         b = ff(b, c, d, a, k[11], 22, -1990404162);
2217 |         a = ff(a, b, c, d, k[12], 7, 1804603682);
2218 |         d = ff(d, a, b, c, k[13], 12, -40341101);
2219 |         c = ff(c, d, a, b, k[14], 17, -1502002290);
2220 |         b = ff(b, c, d, a, k[15], 22, 1236535329);
2221 | 
2222 |         a = gg(a, b, c, d, k[1], 5, -165796510);
2223 |         d = gg(d, a, b, c, k[6], 9, -1069501632);
2224 |         c = gg(c, d, a, b, k[11], 14, 643717713);
2225 |         b = gg(b, c, d, a, k[0], 20, -373897302);
2226 |         a = gg(a, b, c, d, k[5], 5, -701558691);
2227 |         d = gg(d, a, b, c, k[10], 9, 38016083);
2228 |         c = gg(c, d, a, b, k[15], 14, -660478335);
2229 |         b = gg(b, c, d, a, k[4], 20, -405537848);
2230 |         a = gg(a, b, c, d, k[9], 5, 568446438);
2231 |         d = gg(d, a, b, c, k[14], 9, -1019803690);
2232 |         c = gg(c, d, a, b, k[3], 14, -187363961);
2233 |         b = gg(b, c, d, a, k[8], 20, 1163531501);
2234 |         a = gg(a, b, c, d, k[13], 5, -1444681467);
2235 |         d = gg(d, a, b, c, k[2], 9, -51403784);
2236 |         c = gg(c, d, a, b, k[7], 14, 1735328473);
2237 |         b = gg(b, c, d, a, k[12], 20, -1926607734);
2238 | 
2239 |         a = hh(a, b, c, d, k[5], 4, -378558);
2240 |         d = hh(d, a, b, c, k[8], 11, -2022574463);
2241 |         c = hh(c, d, a, b, k[11], 16, 1839030562);
2242 |         b = hh(b, c, d, a, k[14], 23, -35309556);
2243 |         a = hh(a, b, c, d, k[1], 4, -1530992060);
2244 |         d = hh(d, a, b, c, k[4], 11, 1272893353);
2245 |         c = hh(c, d, a, b, k[7], 16, -155497632);
2246 |         b = hh(b, c, d, a, k[10], 23, -1094730640);
2247 |         a = hh(a, b, c, d, k[13], 4, 681279174);
2248 |         d = hh(d, a, b, c, k[0], 11, -358537222);
2249 |         c = hh(c, d, a, b, k[3], 16, -722521979);
2250 |         b = hh(b, c, d, a, k[6], 23, 76029189);
2251 |         a = hh(a, b, c, d, k[9], 4, -640364487);
2252 |         d = hh(d, a, b, c, k[12], 11, -421815835);
2253 |         c = hh(c, d, a, b, k[15], 16, 530742520);
2254 |         b = hh(b, c, d, a, k[2], 23, -995338651);
2255 | 
2256 |         a = ii(a, b, c, d, k[0], 6, -198630844);
2257 |         d = ii(d, a, b, c, k[7], 10, 1126891415);
2258 |         c = ii(c, d, a, b, k[14], 15, -1416354905);
2259 |         b = ii(b, c, d, a, k[5], 21, -57434055);
2260 |         a = ii(a, b, c, d, k[12], 6, 1700485571);
2261 |         d = ii(d, a, b, c, k[3], 10, -1894986606);
2262 |         c = ii(c, d, a, b, k[10], 15, -1051523);
2263 |         b = ii(b, c, d, a, k[1], 21, -2054922799);
2264 |         a = ii(a, b, c, d, k[8], 6, 1873313359);
2265 |         d = ii(d, a, b, c, k[15], 10, -30611744);
2266 |         c = ii(c, d, a, b, k[6], 15, -1560198380);
2267 |         b = ii(b, c, d, a, k[13], 21, 1309151649);
2268 |         a = ii(a, b, c, d, k[4], 6, -145523070);
2269 |         d = ii(d, a, b, c, k[11], 10, -1120210379);
2270 |         c = ii(c, d, a, b, k[2], 15, 718787259);
2271 |         b = ii(b, c, d, a, k[9], 21, -343485551);
2272 | 
2273 |         x[0] = add32(a, x[0]);
2274 |         x[1] = add32(b, x[1]);
2275 |         x[2] = add32(c, x[2]);
2276 |         x[3] = add32(d, x[3]);
2277 |     },
2278 | 
2279 |     /* there needs to be support for Unicode here,
2280 |        * unless we pretend that we can redefine the MD-5
2281 |        * algorithm for multi-byte characters (perhaps
2282 |        * by adding every four 16-bit characters and
2283 |        * shortening the sum to 32 bits). Otherwise
2284 |        * I suggest performing MD-5 as if every character
2285 |        * was two bytes--e.g., 0040 0025 = @%--but then
2286 |        * how will an ordinary MD-5 sum be matched?
2287 |        * There is no way to standardize text to something
2288 |        * like UTF-8 before transformation; speed cost is
2289 |        * utterly prohibitive. The JavaScript standard
2290 |        * itself needs to look at this: it should start
2291 |        * providing access to strings as preformed UTF-8
2292 |        * 8-bit unsigned value arrays.
2293 |        */
2294 |     md5blk = function (s) {
2295 |         var md5blks = [],
2296 |             i; /* Andy King said do it this way. */
2297 | 
2298 |         for (i = 0; i < 64; i += 4) {
2299 |             md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
2300 |         }
2301 |         return md5blks;
2302 |     },
2303 | 
2304 |     md5blk_array = function (a) {
2305 |         var md5blks = [],
2306 |             i; /* Andy King said do it this way. */
2307 | 
2308 |         for (i = 0; i < 64; i += 4) {
2309 |             md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
2310 |         }
2311 |         return md5blks;
2312 |     },
2313 | 
2314 |     md51 = function (s) {
2315 |         var n = s.length,
2316 |             state = [1732584193, -271733879, -1732584194, 271733878],
2317 |             i,
2318 |             length,
2319 |             tail,
2320 |             tmp,
2321 |             lo,
2322 |             hi;
2323 | 
2324 |         for (i = 64; i <= n; i += 64) {
2325 |             md5cycle(state, md5blk(s.substring(i - 64, i)));
2326 |         }
2327 |         s = s.substring(i - 64);
2328 |         length = s.length;
2329 |         tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
2330 |         for (i = 0; i < length; i += 1) {
2331 |             tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
2332 |         }
2333 |         tail[i >> 2] |= 0x80 << ((i % 4) << 3);
2334 |         if (i > 55) {
2335 |             md5cycle(state, tail);
2336 |             for (i = 0; i < 16; i += 1) {
2337 |                 tail[i] = 0;
2338 |             }
2339 |         }
2340 | 
2341 |         // Beware that the final length might not fit in 32 bits so we take care of that
2342 |         tmp = n * 8;
2343 |         tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
2344 |         lo = parseInt(tmp[2], 16);
2345 |         hi = parseInt(tmp[1], 16) || 0;
2346 | 
2347 |         tail[14] = lo;
2348 |         tail[15] = hi;
2349 | 
2350 |         md5cycle(state, tail);
2351 |         return state;
2352 |     },
2353 | 
2354 |     md51_array = function (a) {
2355 |         var n = a.length,
2356 |             state = [1732584193, -271733879, -1732584194, 271733878],
2357 |             i,
2358 |             length,
2359 |             tail,
2360 |             tmp,
2361 |             lo,
2362 |             hi;
2363 | 
2364 |         for (i = 64; i <= n; i += 64) {
2365 |             md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
2366 |         }
2367 | 
2368 |         // Not sure if it is a bug, however IE10 will always produce a sub array of length 1
2369 |         // containing the last element of the parent array if the sub array specified starts
2370 |         // beyond the length of the parent array - weird.
2371 |         // https://connect.microsoft.com/IE/feedback/details/771452/typed-array-subarray-issue
2372 |         a = (i - 64) < n ? a.subarray(i - 64) : new Uint8Array(0);
2373 | 
2374 |         length = a.length;
2375 |         tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
2376 |         for (i = 0; i < length; i += 1) {
2377 |             tail[i >> 2] |= a[i] << ((i % 4) << 3);
2378 |         }
2379 | 
2380 |         tail[i >> 2] |= 0x80 << ((i % 4) << 3);
2381 |         if (i > 55) {
2382 |             md5cycle(state, tail);
2383 |             for (i = 0; i < 16; i += 1) {
2384 |                 tail[i] = 0;
2385 |             }
2386 |         }
2387 | 
2388 |         // Beware that the final length might not fit in 32 bits so we take care of that
2389 |         tmp = n * 8;
2390 |         tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
2391 |         lo = parseInt(tmp[2], 16);
2392 |         hi = parseInt(tmp[1], 16) || 0;
2393 | 
2394 |         tail[14] = lo;
2395 |         tail[15] = hi;
2396 | 
2397 |         md5cycle(state, tail);
2398 | 
2399 |         return state;
2400 |     },
2401 | 
2402 |     hex_chr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'],
2403 | 
2404 |     rhex = function (n) {
2405 |         var s = '',
2406 |             j;
2407 |         for (j = 0; j < 4; j += 1) {
2408 |             s += hex_chr[(n >> (j * 8 + 4)) & 0x0F] + hex_chr[(n >> (j * 8)) & 0x0F];
2409 |         }
2410 |         return s;
2411 |     },
2412 | 
2413 |     hex = function (x) {
2414 |         var i;
2415 |         for (i = 0; i < x.length; i += 1) {
2416 |             x[i] = rhex(x[i]);
2417 |         }
2418 |         return x.join('');
2419 |     },
2420 | 
2421 |     md5 = function (s) {
2422 |         return hex(md51(s));
2423 |     },
2424 | 
2425 | 
2426 | 
2427 |     ////////////////////////////////////////////////////////////////////////////
2428 | 
2429 |     /**
2430 |      * SparkMD5 OOP implementation.
2431 |      *
2432 |      * Use this class to perform an incremental md5, otherwise use the
2433 |      * static methods instead.
2434 |      */
2435 |     SparkMD5 = function () {
2436 |         // call reset to init the instance
2437 |         this.reset();
2438 |     };
2439 | 
2440 | 
2441 |     // In some cases the fast add32 function cannot be used..
2442 |     if (md5('hello') !== '5d41402abc4b2a76b9719d911017c592') {
2443 |         add32 = function (x, y) {
2444 |             var lsw = (x & 0xFFFF) + (y & 0xFFFF),
2445 |                 msw = (x >> 16) + (y >> 16) + (lsw >> 16);
2446 |             return (msw << 16) | (lsw & 0xFFFF);
2447 |         };
2448 |     }
2449 | 
2450 | 
2451 |     /**
2452 |      * Appends a string.
2453 |      * A conversion will be applied if an utf8 string is detected.
2454 |      *
2455 |      * @param {String} str The string to be appended
2456 |      *
2457 |      * @return {SparkMD5} The instance itself
2458 |      */
2459 |     SparkMD5.prototype.append = function (str) {
2460 |         // converts the string to utf8 bytes if necessary
2461 |         if (/[\u0080-\uFFFF]/.test(str)) {
2462 |             str = unescape(encodeURIComponent(str));
2463 |         }
2464 | 
2465 |         // then append as binary
2466 |         this.appendBinary(str);
2467 | 
2468 |         return this;
2469 |     };
2470 | 
2471 |     /**
2472 |      * Appends a binary string.
2473 |      *
2474 |      * @param {String} contents The binary string to be appended
2475 |      *
2476 |      * @return {SparkMD5} The instance itself
2477 |      */
2478 |     SparkMD5.prototype.appendBinary = function (contents) {
2479 |         this._buff += contents;
2480 |         this._length += contents.length;
2481 | 
2482 |         var length = this._buff.length,
2483 |             i;
2484 | 
2485 |         for (i = 64; i <= length; i += 64) {
2486 |             md5cycle(this._state, md5blk(this._buff.substring(i - 64, i)));
2487 |         }
2488 | 
2489 |         this._buff = this._buff.substr(i - 64);
2490 | 
2491 |         return this;
2492 |     };
2493 | 
2494 |     /**
2495 |      * Finishes the incremental computation, reseting the internal state and
2496 |      * returning the result.
2497 |      * Use the raw parameter to obtain the raw result instead of the hex one.
2498 |      *
2499 |      * @param {Boolean} raw True to get the raw result, false to get the hex result
2500 |      *
2501 |      * @return {String|Array} The result
2502 |      */
2503 |     SparkMD5.prototype.end = function (raw) {
2504 |         var buff = this._buff,
2505 |             length = buff.length,
2506 |             i,
2507 |             tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
2508 |             ret;
2509 | 
2510 |         for (i = 0; i < length; i += 1) {
2511 |             tail[i >> 2] |= buff.charCodeAt(i) << ((i % 4) << 3);
2512 |         }
2513 | 
2514 |         this._finish(tail, length);
2515 |         ret = !!raw ? this._state : hex(this._state);
2516 | 
2517 |         this.reset();
2518 | 
2519 |         return ret;
2520 |     };
2521 | 
2522 |     /**
2523 |      * Finish the final calculation based on the tail.
2524 |      *
2525 |      * @param {Array}  tail   The tail (will be modified)
2526 |      * @param {Number} length The length of the remaining buffer
2527 |      */
2528 |     SparkMD5.prototype._finish = function (tail, length) {
2529 |         var i = length,
2530 |             tmp,
2531 |             lo,
2532 |             hi;
2533 | 
2534 |         tail[i >> 2] |= 0x80 << ((i % 4) << 3);
2535 |         if (i > 55) {
2536 |             md5cycle(this._state, tail);
2537 |             for (i = 0; i < 16; i += 1) {
2538 |                 tail[i] = 0;
2539 |             }
2540 |         }
2541 | 
2542 |         // Do the final computation based on the tail and length
2543 |         // Beware that the final length may not fit in 32 bits so we take care of that
2544 |         tmp = this._length * 8;
2545 |         tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
2546 |         lo = parseInt(tmp[2], 16);
2547 |         hi = parseInt(tmp[1], 16) || 0;
2548 | 
2549 |         tail[14] = lo;
2550 |         tail[15] = hi;
2551 |         md5cycle(this._state, tail);
2552 |     };
2553 | 
2554 |     /**
2555 |      * Resets the internal state of the computation.
2556 |      *
2557 |      * @return {SparkMD5} The instance itself
2558 |      */
2559 |     SparkMD5.prototype.reset = function () {
2560 |         this._buff = "";
2561 |         this._length = 0;
2562 |         this._state = [1732584193, -271733879, -1732584194, 271733878];
2563 | 
2564 |         return this;
2565 |     };
2566 | 
2567 |     /**
2568 |      * Releases memory used by the incremental buffer and other aditional
2569 |      * resources. If you plan to use the instance again, use reset instead.
2570 |      */
2571 |     SparkMD5.prototype.destroy = function () {
2572 |         delete this._state;
2573 |         delete this._buff;
2574 |         delete this._length;
2575 |     };
2576 | 
2577 | 
2578 |     /**
2579 |      * Performs the md5 hash on a string.
2580 |      * A conversion will be applied if utf8 string is detected.
2581 |      *
2582 |      * @param {String}  str The string
2583 |      * @param {Boolean} raw True to get the raw result, false to get the hex result
2584 |      *
2585 |      * @return {String|Array} The result
2586 |      */
2587 |     SparkMD5.hash = function (str, raw) {
2588 |         // converts the string to utf8 bytes if necessary
2589 |         if (/[\u0080-\uFFFF]/.test(str)) {
2590 |             str = unescape(encodeURIComponent(str));
2591 |         }
2592 | 
2593 |         var hash = md51(str);
2594 | 
2595 |         return !!raw ? hash : hex(hash);
2596 |     };
2597 | 
2598 |     /**
2599 |      * Performs the md5 hash on a binary string.
2600 |      *
2601 |      * @param {String}  content The binary string
2602 |      * @param {Boolean} raw     True to get the raw result, false to get the hex result
2603 |      *
2604 |      * @return {String|Array} The result
2605 |      */
2606 |     SparkMD5.hashBinary = function (content, raw) {
2607 |         var hash = md51(content);
2608 | 
2609 |         return !!raw ? hash : hex(hash);
2610 |     };
2611 | 
2612 |     /**
2613 |      * SparkMD5 OOP implementation for array buffers.
2614 |      *
2615 |      * Use this class to perform an incremental md5 ONLY for array buffers.
2616 |      */
2617 |     SparkMD5.ArrayBuffer = function () {
2618 |         // call reset to init the instance
2619 |         this.reset();
2620 |     };
2621 | 
2622 |     ////////////////////////////////////////////////////////////////////////////
2623 | 
2624 |     /**
2625 |      * Appends an array buffer.
2626 |      *
2627 |      * @param {ArrayBuffer} arr The array to be appended
2628 |      *
2629 |      * @return {SparkMD5.ArrayBuffer} The instance itself
2630 |      */
2631 |     SparkMD5.ArrayBuffer.prototype.append = function (arr) {
2632 |         // TODO: we could avoid the concatenation here but the algorithm would be more complex
2633 |         //       if you find yourself needing extra performance, please make a PR.
2634 |         var buff = this._concatArrayBuffer(this._buff, arr),
2635 |             length = buff.length,
2636 |             i;
2637 | 
2638 |         this._length += arr.byteLength;
2639 | 
2640 |         for (i = 64; i <= length; i += 64) {
2641 |             md5cycle(this._state, md5blk_array(buff.subarray(i - 64, i)));
2642 |         }
2643 | 
2644 |         // Avoids IE10 weirdness (documented above)
2645 |         this._buff = (i - 64) < length ? buff.subarray(i - 64) : new Uint8Array(0);
2646 | 
2647 |         return this;
2648 |     };
2649 | 
2650 |     /**
2651 |      * Finishes the incremental computation, reseting the internal state and
2652 |      * returning the result.
2653 |      * Use the raw parameter to obtain the raw result instead of the hex one.
2654 |      *
2655 |      * @param {Boolean} raw True to get the raw result, false to get the hex result
2656 |      *
2657 |      * @return {String|Array} The result
2658 |      */
2659 |     SparkMD5.ArrayBuffer.prototype.end = function (raw) {
2660 |         var buff = this._buff,
2661 |             length = buff.length,
2662 |             tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
2663 |             i,
2664 |             ret;
2665 | 
2666 |         for (i = 0; i < length; i += 1) {
2667 |             tail[i >> 2] |= buff[i] << ((i % 4) << 3);
2668 |         }
2669 | 
2670 |         this._finish(tail, length);
2671 |         ret = !!raw ? this._state : hex(this._state);
2672 | 
2673 |         this.reset();
2674 | 
2675 |         return ret;
2676 |     };
2677 | 
2678 |     SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;
2679 | 
2680 |     /**
2681 |      * Resets the internal state of the computation.
2682 |      *
2683 |      * @return {SparkMD5.ArrayBuffer} The instance itself
2684 |      */
2685 |     SparkMD5.ArrayBuffer.prototype.reset = function () {
2686 |         this._buff = new Uint8Array(0);
2687 |         this._length = 0;
2688 |         this._state = [1732584193, -271733879, -1732584194, 271733878];
2689 | 
2690 |         return this;
2691 |     };
2692 | 
2693 |     /**
2694 |      * Releases memory used by the incremental buffer and other aditional
2695 |      * resources. If you plan to use the instance again, use reset instead.
2696 |      */
2697 |     SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;
2698 | 
2699 |     /**
2700 |      * Concats two array buffers, returning a new one.
2701 |      *
2702 |      * @param  {ArrayBuffer} first  The first array buffer
2703 |      * @param  {ArrayBuffer} second The second array buffer
2704 |      *
2705 |      * @return {ArrayBuffer} The new array buffer
2706 |      */
2707 |     SparkMD5.ArrayBuffer.prototype._concatArrayBuffer = function (first, second) {
2708 |         var firstLength = first.length,
2709 |             result = new Uint8Array(firstLength + second.byteLength);
2710 | 
2711 |         result.set(first);
2712 |         result.set(new Uint8Array(second), firstLength);
2713 | 
2714 |         return result;
2715 |     };
2716 | 
2717 |     /**
2718 |      * Performs the md5 hash on an array buffer.
2719 |      *
2720 |      * @param {ArrayBuffer} arr The array buffer
2721 |      * @param {Boolean}     raw True to get the raw result, false to get the hex result
2722 |      *
2723 |      * @return {String|Array} The result
2724 |      */
2725 |     SparkMD5.ArrayBuffer.hash = function (arr, raw) {
2726 |         var hash = md51_array(new Uint8Array(arr));
2727 | 
2728 |         return !!raw ? hash : hex(hash);
2729 |     };
2730 | 
2731 |     return SparkMD5;
2732 | }));
2733 | 
2734 | },{}]},{},[1]);
2735 | 


--------------------------------------------------------------------------------
/dist/pouchdb.migrate.min.js:
--------------------------------------------------------------------------------
1 | !function n(t,e,r){function o(u,c){if(!e[u]){if(!t[u]){var f="function"==typeof require&&require;if(!c&&f)return f(u,!0);if(i)return i(u,!0);var a=new Error("Cannot find module '"+u+"'");throw a.code="MODULE_NOT_FOUND",a}var s=e[u]={exports:{}};t[u][0].call(s.exports,function(n){var e=t[u][1][n];return o(e?e:n)},s,s.exports,n,t,e,r)}return e[u].exports}for(var i="function"==typeof require&&require,u=0;u<r.length;u++)o(r[u]);return o}({1:[function(n,t,e){var r=n("pouchdb/extras/promise"),o=n("./lib/checkpointer"),i=n("./lib/migrate");e.migrate=function(n,t,e){var u=this;if(!n)throw new Error("no migration given");if("function"!=typeof n)throw new Error("migration must be a function");"function"==typeof t&&(e=t,t={}),"undefined"==typeof t&&(t={});var c=o(u,n).then(function(e){return i(u,e,n,t)});return"function"==typeof e?c.then(function(n){e(null,n)})["catch"](function(n){return e(n),r.reject(n)}):c},"undefined"!=typeof window&&window.PouchDB&&window.PouchDB.plugin(e)},{"./lib/checkpointer":2,"./lib/migrate":4,"pouchdb/extras/promise":10}],2:[function(n,t,e){var r=n("./md5"),o=n("pouchdb/extras/promise"),i=function(n){return new o(function(t,e){r(n,function(n,r){return n?e(n):void t(r)})})};t.exports=function(n,t){var e={last_seq:0};return i(t.toString()).then(function(n){e._id="_local/"+n}).then(function(){return{get:function(){return n.get(e._id).then(function(n){e._rev=n._rev,e.last_seq=n.last_seq})["catch"](function(n){return 404!==n.status?o.reject():void 0}).then(function(){return e.last_seq})},set:function(t){return e.last_seq=t,n.put(e).then(function(n){e._rev=n.rev})}}})}},{"./md5":3,"pouchdb/extras/promise":10}],3:[function(n,t,e){(function(e,r){"use strict";function o(n,t,e){if("function"==typeof n.slice)return t?e?n.slice(t,e):n.slice(t):n.slice();t=Math.floor(t||0),e=Math.floor(e||0);var r=n.byteLength;if(t=0>t?Math.max(t+r,0):Math.min(r,t),e=0>e?Math.max(e+r,0):Math.min(r,e),0>=e-t)return new ArrayBuffer(0);var o=new ArrayBuffer(e-t),i=new Uint8Array(o),u=new Uint8Array(n,t,e-t);return i.set(u),o}function i(n){var t=[255&n,n>>>8&255,n>>>16&255,n>>>24&255];return t.map(function(n){return String.fromCharCode(n)}).join("")}function u(n){for(var t="",e=0;e<n.length;e++)t+=i(n[e]);return r.btoa(t)}var c=n("crypto"),f=n("spark-md5"),a=r.setImmediate||r.setTimeout,s=32768;t.exports=function(n,t){function r(n,t,e,r){h?n.appendBinary(t.substring(e,r)):n.append(o(t,e,r))}function i(){var e=v*d,o=e+d;if(e+d>=n.size&&(o=n.size),v++,y>v)r(m,n,e,o),a(i);else{r(m,n,e,o);var c=m.end(!0),f=u(c);t(null,f),m.destroy()}}if(!e.browser){var l=c.createHash("md5").update(n).digest("base64");return void t(null,l)}var h="string"==typeof n,p=h?n.length:n.byteLength,d=Math.min(s,p),y=Math.ceil(p/d),v=0,m=h?new f:new f.ArrayBuffer;i()}}).call(this,n("_process"),"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{_process:12,crypto:6,"spark-md5":13}],4:[function(n,t,e){var r=n("pouchdb/extras/promise"),o=n("pouchdb-extend"),i=n("async");t.exports=function u(n,t,e,c){return t.get().then(function(f){return new r(function(r,a){var s=[],l=i.queue(function(e,r){return e?void n.bulkDocs({docs:e}).then(function(n){return t.set(change.seq)}).then(r.bind({},null))["catch"](r):t.set(change.seq).then(r.bind({},null))["catch"](r)},1),h=n.changes(o({},c,{include_docs:!0,since:f}));h.on("change",function(n){var t=e(n.doc);return c.live?void l.push(t):void(s=t?s.concat(t):s)}),h.on("complete",function(o){return c.live?r(o):void n.bulkDocs({docs:s}).then(function(n){return t.set(o.last_seq)}).then(function(){return n.info()}).then(function(r){return r.update_seq>o.last_seq?u(n,t,e,c):o}).then(r)}),h.on("error",a)})})}},{async:5,"pouchdb-extend":9,"pouchdb/extras/promise":10}],5:[function(n,t,e){(function(n,e){!function(){function r(){}function o(n){return n}function i(n){return!!n}function u(n){return!n}function c(n){return function(){if(null===n)throw new Error("Callback was already called.");n.apply(this,arguments),n=null}}function f(n){return function(){null!==n&&(n.apply(this,arguments),n=null)}}function a(n){return P(n)||"number"==typeof n.length&&n.length>=0&&n.length%1===0}function s(n,t){return a(n)?l(n,t):y(n,t)}function l(n,t){for(var e=-1,r=n.length;++e<r;)t(n[e],e,n)}function h(n,t){for(var e=-1,r=n.length,o=Array(r);++e<r;)o[e]=t(n[e],e,n);return o}function p(n){return h(Array(n),function(n,t){return t})}function d(n,t,e){return l(n,function(n,r,o){e=t(e,n,r,o)}),e}function y(n,t){l(N(n),function(e){t(n[e],e)})}function v(n,t){for(var e=0;e<n.length;e++)if(n[e]===t)return e;return-1}function m(n){var t,e,r=-1;return a(n)?(t=n.length,function(){return r++,t>r?r:null}):(e=N(n),t=e.length,function(){return r++,t>r?e[r]:null})}function g(n,t){return t=null==t?n.length-1:+t,function(){for(var e=Math.max(arguments.length-t,0),r=Array(e),o=0;e>o;o++)r[o]=arguments[o+t];switch(t){case 0:return n.call(this,r);case 1:return n.call(this,arguments[0],r)}}}function b(n){return function(t,e,r){return n(t,r)}}function w(n){return function(t,e,o){o=f(o||r),t=t||[];var i=m(t);if(0>=n)return o(null);var u=!1,a=0,s=!1;!function l(){if(u&&0>=a)return o(null);for(;n>a&&!s;){var r=i();if(null===r)return u=!0,void(0>=a&&o(null));a+=1,e(t[r],r,c(function(n){a-=1,n?(o(n),s=!0):l()}))}}()}}function k(n){return function(t,e,r){return n(U.eachOf,t,e,r)}}function _(n){return function(t,e,r,o){return n(w(e),t,r,o)}}function j(n){return function(t,e,r){return n(U.eachOfSeries,t,e,r)}}function x(n,t,e,o){o=f(o||r);var i=[];n(t,function(n,t,r){e(n,function(n,e){i[t]=e,r(n)})},function(n){o(n,i)})}function A(n,t,e,r){var o=[];n(t,function(n,t,r){e(n,function(e){e&&o.push({index:t,value:n}),r()})},function(){r(h(o.sort(function(n,t){return n.index-t.index}),function(n){return n.value}))})}function E(n,t,e,r){A(n,t,function(n,t){e(n,function(n){t(!n)})},r)}function O(n,t,e){return function(r,o,i,u){function c(){u&&u(e(!1,void 0))}function f(n,r,o){return u?void i(n,function(r){u&&t(r)&&(u(e(!0,n)),u=i=!1),o()}):o()}arguments.length>3?n(r,o,f,c):(u=i,i=o,n(r,f,c))}}function S(n,t){return t}function L(n,t,e){e=e||r;var o=a(t)?[]:{};n(t,function(n,t,e){n(g(function(n,r){r.length<=1&&(r=r[0]),o[t]=r,e(n)}))},function(n){e(n,o)})}function I(n,t,e,r){var o=[];n(t,function(n,t,r){e(n,function(n,t){o=o.concat(t||[]),r(n)})},function(n){r(n,o)})}function q(n,t,e){function o(n,t,e,o){if(null!=o&&"function"!=typeof o)throw new Error("task callback must be a function");return n.started=!0,P(t)||(t=[t]),0===t.length&&n.idle()?U.setImmediate(function(){n.drain()}):(l(t,function(t){var i={data:t,callback:o||r};e?n.tasks.unshift(i):n.tasks.push(i),n.tasks.length===n.concurrency&&n.saturated()}),void U.setImmediate(n.process))}function i(n,t){return function(){u-=1;var e=arguments;l(t,function(n){n.callback.apply(n,e)}),n.tasks.length+u===0&&n.drain(),n.process()}}if(null==t)t=1;else if(0===t)throw new Error("Concurrency must not be zero");var u=0,f={tasks:[],concurrency:t,payload:e,saturated:r,empty:r,drain:r,started:!1,paused:!1,push:function(n,t){o(f,n,!1,t)},kill:function(){f.drain=r,f.tasks=[]},unshift:function(n,t){o(f,n,!0,t)},process:function(){if(!f.paused&&u<f.concurrency&&f.tasks.length)for(;u<f.concurrency&&f.tasks.length;){var t=f.payload?f.tasks.splice(0,f.payload):f.tasks.splice(0,f.tasks.length),e=h(t,function(n){return n.data});0===f.tasks.length&&f.empty(),u+=1;var r=c(i(f,t));n(e,r)}},length:function(){return f.tasks.length},running:function(){return u},idle:function(){return f.tasks.length+u===0},pause:function(){f.paused=!0},resume:function(){if(f.paused!==!1){f.paused=!1;for(var n=Math.min(f.concurrency,f.tasks.length),t=1;n>=t;t++)U.setImmediate(f.process)}}};return f}function C(n){return g(function(t,e){t.apply(null,e.concat([g(function(t,e){"object"==typeof console&&(t?console.error&&console.error(t):console[n]&&l(e,function(t){console[n](t)}))})]))})}function T(n){return function(t,e,r){n(p(t),e,r)}}function B(n){return g(function(t,e){var r=g(function(e){var r=this,o=e.pop();return n(t,function(n,t,o){n.apply(r,e.concat([o]))},o)});return e.length?r.apply(this,e):r})}function F(n){return g(function(t){var e=t.pop();t.push(function(){var n=arguments;r?U.setImmediate(function(){e.apply(null,n)}):e.apply(null,n)});var r=!0;n.apply(this,t),r=!1})}var M,U={},D="object"==typeof self&&self.self===self&&self||"object"==typeof e&&e.global===e&&e||this;null!=D&&(M=D.async),U.noConflict=function(){return D.async=M,U};var R=Object.prototype.toString,P=Array.isArray||function(n){return"[object Array]"===R.call(n)},z=function(n){var t=typeof n;return"function"===t||"object"===t&&!!n},N=Object.keys||function(n){var t=[];for(var e in n)n.hasOwnProperty(e)&&t.push(e);return t},H="function"==typeof setImmediate&&setImmediate,W=H?function(n){H(n)}:function(n){setTimeout(n,0)};"object"==typeof n&&"function"==typeof n.nextTick?U.nextTick=n.nextTick:U.nextTick=W,U.setImmediate=H?W:U.nextTick,U.forEach=U.each=function(n,t,e){return U.eachOf(n,b(t),e)},U.forEachSeries=U.eachSeries=function(n,t,e){return U.eachOfSeries(n,b(t),e)},U.forEachLimit=U.eachLimit=function(n,t,e,r){return w(t)(n,b(e),r)},U.forEachOf=U.eachOf=function(n,t,e){function o(n){n?e(n):(u+=1,u>=i&&e(null))}e=f(e||r),n=n||[];var i=a(n)?n.length:N(n).length,u=0;return i?void s(n,function(e,r){t(n[r],r,c(o))}):e(null)},U.forEachOfSeries=U.eachOfSeries=function(n,t,e){function o(){var r=!0;return null===u?e(null):(t(n[u],u,c(function(n){if(n)e(n);else{if(u=i(),null===u)return e(null);r?U.nextTick(o):o()}})),void(r=!1))}e=f(e||r),n=n||[];var i=m(n),u=i();o()},U.forEachOfLimit=U.eachOfLimit=function(n,t,e,r){w(t)(n,e,r)},U.map=k(x),U.mapSeries=j(x),U.mapLimit=_(x),U.inject=U.foldl=U.reduce=function(n,t,e,r){U.eachOfSeries(n,function(n,r,o){e(t,n,function(n,e){t=e,o(n)})},function(n){r(n||null,t)})},U.foldr=U.reduceRight=function(n,t,e,r){var i=h(n,o).reverse();U.reduce(i,t,e,r)},U.select=U.filter=k(A),U.selectLimit=U.filterLimit=_(A),U.selectSeries=U.filterSeries=j(A),U.reject=k(E),U.rejectLimit=_(E),U.rejectSeries=j(E),U.any=U.some=O(U.eachOf,i,o),U.someLimit=O(U.eachOfLimit,i,o),U.all=U.every=O(U.eachOf,u,u),U.everyLimit=O(U.eachOfLimit,u,u),U.detect=O(U.eachOf,o,S),U.detectSeries=O(U.eachOfSeries,o,S),U.detectLimit=O(U.eachOfLimit,o,S),U.sortBy=function(n,t,e){function r(n,t){var e=n.criteria,r=t.criteria;return r>e?-1:e>r?1:0}U.map(n,function(n,e){t(n,function(t,r){t?e(t):e(null,{value:n,criteria:r})})},function(n,t){return n?e(n):void e(null,h(t.sort(r),function(n){return n.value}))})},U.auto=function(n,t){function e(n){s.unshift(n)}function o(n){var t=v(s,n);t>=0&&s.splice(t,1)}function i(){c--,l(s.slice(0),function(n){n()})}t=f(t||r);var u=N(n),c=u.length;if(!c)return t(null);var a={},s=[];e(function(){c||t(null,a)}),l(u,function(r){function u(){return d(h,function(n,t){return n&&a.hasOwnProperty(t)},!0)&&!a.hasOwnProperty(r)}function c(){u()&&(o(c),s[s.length-1](l,a))}for(var f,s=P(n[r])?n[r]:[n[r]],l=g(function(n,e){if(e.length<=1&&(e=e[0]),n){var o={};y(a,function(n,t){o[t]=n}),o[r]=e,t(n,o)}else a[r]=e,U.setImmediate(i)}),h=s.slice(0,s.length-1),p=h.length;p--;){if(!(f=n[h[p]]))throw new Error("Has inexistant dependency");if(P(f)&&v(f,r)>=0)throw new Error("Has cyclic dependencies")}u()?s[s.length-1](l,a):e(c)})},U.retry=function(n,t,e){function r(n,t){if("number"==typeof t)n.times=parseInt(t,10)||i;else{if("object"!=typeof t)throw new Error("Unsupported argument type for 'times': "+typeof t);n.times=parseInt(t.times,10)||i,n.interval=parseInt(t.interval,10)||u}}function o(n,t){function e(n,e){return function(r){n(function(n,t){r(!n||e,{err:n,result:t})},t)}}function r(n){return function(t){setTimeout(function(){t(null)},n)}}for(;f.times;){var o=!(f.times-=1);c.push(e(f.task,o)),!o&&f.interval>0&&c.push(r(f.interval))}U.series(c,function(t,e){e=e[e.length-1],(n||f.callback)(e.err,e.result)})}var i=5,u=0,c=[],f={times:i,interval:u},a=arguments.length;if(1>a||a>3)throw new Error("Invalid arguments - must be either (task), (task, callback), (times, task) or (times, task, callback)");return 2>=a&&"function"==typeof n&&(e=t,t=n),"function"!=typeof n&&r(f,n),f.callback=e,f.task=t,f.callback?o():o},U.waterfall=function(n,t){function e(n){return g(function(r,o){if(r)t.apply(null,[r].concat(o));else{var i=n.next();i?o.push(e(i)):o.push(t),F(n).apply(null,o)}})}if(t=f(t||r),!P(n)){var o=new Error("First argument to waterfall must be an array of functions");return t(o)}return n.length?void e(U.iterator(n))():t()},U.parallel=function(n,t){L(U.eachOf,n,t)},U.parallelLimit=function(n,t,e){L(w(t),n,e)},U.series=function(n,t){L(U.eachOfSeries,n,t)},U.iterator=function(n){function t(e){function r(){return n.length&&n[e].apply(null,arguments),r.next()}return r.next=function(){return e<n.length-1?t(e+1):null},r}return t(0)},U.apply=g(function(n,t){return g(function(e){return n.apply(null,t.concat(e))})}),U.concat=k(I),U.concatSeries=j(I),U.whilst=function(n,t,e){if(e=e||r,n()){var o=g(function(r,i){r?e(r):n.apply(this,i)?t(o):e(null)});t(o)}else e(null)},U.doWhilst=function(n,t,e){var r=0;return U.whilst(function(){return++r<=1||t.apply(this,arguments)},n,e)},U.until=function(n,t,e){return U.whilst(function(){return!n.apply(this,arguments)},t,e)},U.doUntil=function(n,t,e){return U.doWhilst(n,function(){return!t.apply(this,arguments)},e)},U.during=function(n,t,e){e=e||r;var o=g(function(t,r){t?e(t):(r.push(i),n.apply(this,r))}),i=function(n,r){n?e(n):r?t(o):e(null)};n(i)},U.doDuring=function(n,t,e){var r=0;U.during(function(n){r++<1?n(null,!0):t.apply(this,arguments)},n,e)},U.queue=function(n,t){var e=q(function(t,e){n(t[0],e)},t,1);return e},U.priorityQueue=function(n,t){function e(n,t){return n.priority-t.priority}function o(n,t,e){for(var r=-1,o=n.length-1;o>r;){var i=r+(o-r+1>>>1);e(t,n[i])>=0?r=i:o=i-1}return r}function i(n,t,i,u){if(null!=u&&"function"!=typeof u)throw new Error("task callback must be a function");return n.started=!0,P(t)||(t=[t]),0===t.length?U.setImmediate(function(){n.drain()}):void l(t,function(t){var c={data:t,priority:i,callback:"function"==typeof u?u:r};n.tasks.splice(o(n.tasks,c,e)+1,0,c),n.tasks.length===n.concurrency&&n.saturated(),U.setImmediate(n.process)})}var u=U.queue(n,t);return u.push=function(n,t,e){i(u,n,t,e)},delete u.unshift,u},U.cargo=function(n,t){return q(n,1,t)},U.log=C("log"),U.dir=C("dir"),U.memoize=function(n,t){var e={},r={};t=t||o;var i=g(function(o){var i=o.pop(),u=t.apply(null,o);u in e?U.nextTick(function(){i.apply(null,e[u])}):u in r?r[u].push(i):(r[u]=[i],n.apply(null,o.concat([g(function(n){e[u]=n;var t=r[u];delete r[u];for(var o=0,i=t.length;i>o;o++)t[o].apply(null,n)})])))});return i.memo=e,i.unmemoized=n,i},U.unmemoize=function(n){return function(){return(n.unmemoized||n).apply(null,arguments)}},U.times=T(U.map),U.timesSeries=T(U.mapSeries),U.timesLimit=function(n,t,e,r){return U.mapLimit(p(n),t,e,r)},U.seq=function(){var n=arguments;return g(function(t){var e=this,o=t[t.length-1];"function"==typeof o?t.pop():o=r,U.reduce(n,t,function(n,t,r){t.apply(e,n.concat([g(function(n,t){r(n,t)})]))},function(n,t){o.apply(e,[n].concat(t))})})},U.compose=function(){return U.seq.apply(null,Array.prototype.reverse.call(arguments))},U.applyEach=B(U.eachOf),U.applyEachSeries=B(U.eachOfSeries),U.forever=function(n,t){function e(n){return n?o(n):void i(e)}var o=c(t||r),i=F(n);e()},U.ensureAsync=F,U.constant=g(function(n){var t=[null].concat(n);return function(n){return n.apply(this,t)}}),U.wrapSync=U.asyncify=function(n){return g(function(t){var e,r=t.pop();try{e=n.apply(this,t)}catch(o){return r(o)}z(e)&&"function"==typeof e.then?e.then(function(n){r(null,n)})["catch"](function(n){r(n.message?n:new Error(n))}):r(null,e)})},"object"==typeof t&&t.exports?t.exports=U:"function"==typeof define&&define.amd?define([],function(){return U}):D.async=U}()}).call(this,n("_process"),"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{_process:12}],6:[function(n,t,e){},{}],7:[function(n,t,e){(function(n){"use strict";function e(){s=!0;for(var n,t,e=l.length;e;){for(t=l,l=[],n=-1;++n<e;)t[n]();e=l.length}s=!1}function r(n){1!==l.push(n)||s||o()}var o,i=n.MutationObserver||n.WebKitMutationObserver;if(i){var u=0,c=new i(e),f=n.document.createTextNode("");c.observe(f,{characterData:!0}),o=function(){f.data=u=++u%2}}else if(n.setImmediate||"undefined"==typeof n.MessageChannel)o="document"in n&&"onreadystatechange"in n.document.createElement("script")?function(){var t=n.document.createElement("script");t.onreadystatechange=function(){e(),t.onreadystatechange=null,t.parentNode.removeChild(t),t=null},n.document.documentElement.appendChild(t)}:function(){setTimeout(e,0)};else{var a=new n.MessageChannel;a.port1.onmessage=e,o=function(){a.port2.postMessage(0)}}var s,l=[];t.exports=r}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],8:[function(n,t,e){"use strict";function r(){}function o(n){if("function"!=typeof n)throw new TypeError("resolver must be a function");this.state=g,this.queue=[],this.outcome=void 0,n!==r&&f(this,n)}function i(n,t,e){this.promise=n,"function"==typeof t&&(this.onFulfilled=t,this.callFulfilled=this.otherCallFulfilled),"function"==typeof e&&(this.onRejected=e,this.callRejected=this.otherCallRejected)}function u(n,t,e){d(function(){var r;try{r=t(e)}catch(o){return y.reject(n,o)}r===n?y.reject(n,new TypeError("Cannot resolve promise with itself")):y.resolve(n,r)})}function c(n){var t=n&&n.then;return n&&"object"==typeof n&&"function"==typeof t?function(){t.apply(n,arguments)}:void 0}function f(n,t){function e(t){i||(i=!0,y.reject(n,t))}function r(t){i||(i=!0,y.resolve(n,t))}function o(){t(r,e)}var i=!1,u=a(o);"error"===u.status&&e(u.value)}function a(n,t){var e={};try{e.value=n(t),e.status="success"}catch(r){e.status="error",e.value=r}return e}function s(n){return n instanceof this?n:y.resolve(new this(r),n)}function l(n){var t=new this(r);return y.reject(t,n)}function h(n){function t(n,t){function r(n){u[t]=n,++c!==o||i||(i=!0,y.resolve(a,u))}e.resolve(n).then(r,function(n){i||(i=!0,y.reject(a,n))})}var e=this;if("[object Array]"!==Object.prototype.toString.call(n))return this.reject(new TypeError("must be an array"));var o=n.length,i=!1;if(!o)return this.resolve([]);for(var u=new Array(o),c=0,f=-1,a=new this(r);++f<o;)t(n[f],f);return a}function p(n){function t(n){e.resolve(n).then(function(n){i||(i=!0,y.resolve(c,n))},function(n){i||(i=!0,y.reject(c,n))})}var e=this;if("[object Array]"!==Object.prototype.toString.call(n))return this.reject(new TypeError("must be an array"));var o=n.length,i=!1;if(!o)return this.resolve([]);for(var u=-1,c=new this(r);++u<o;)t(n[u]);return c}var d=n("immediate"),y={},v=["REJECTED"],m=["FULFILLED"],g=["PENDING"];t.exports=e=o,o.prototype["catch"]=function(n){return this.then(null,n)},o.prototype.then=function(n,t){if("function"!=typeof n&&this.state===m||"function"!=typeof t&&this.state===v)return this;var e=new this.constructor(r);if(this.state!==g){var o=this.state===m?n:t;u(e,o,this.outcome)}else this.queue.push(new i(e,n,t));return e},i.prototype.callFulfilled=function(n){y.resolve(this.promise,n)},i.prototype.otherCallFulfilled=function(n){u(this.promise,this.onFulfilled,n)},i.prototype.callRejected=function(n){y.reject(this.promise,n)},i.prototype.otherCallRejected=function(n){u(this.promise,this.onRejected,n)},y.resolve=function(n,t){var e=a(c,t);if("error"===e.status)return y.reject(n,e.value);var r=e.value;if(r)f(n,r);else{n.state=m,n.outcome=t;for(var o=-1,i=n.queue.length;++o<i;)n.queue[o].callFulfilled(t)}return n},y.reject=function(n,t){n.state=v,n.outcome=t;for(var e=-1,r=n.queue.length;++e<r;)n.queue[e].callRejected(t);return n},e.resolve=s,e.reject=l,e.all=h,e.race=p},{immediate:7}],9:[function(n,t,e){"use strict";function r(n){return null===n?String(n):"object"==typeof n||"function"==typeof n?a[p.call(n)]||"object":typeof n}function o(n){return null!==n&&n===n.window}function i(n){if(!n||"object"!==r(n)||n.nodeType||o(n))return!1;try{if(n.constructor&&!d.call(n,"constructor")&&!d.call(n.constructor.prototype,"isPrototypeOf"))return!1}catch(t){return!1}var e;for(e in n);return void 0===e||d.call(n,e)}function u(n){return"function"===r(n)}function c(){for(var n=[],t=-1,e=arguments.length,r=new Array(e);++t<e;)r[t]=arguments[t];var o={};n.push({args:r,result:{container:o,key:"key"}});for(var i;i=n.pop();)f(n,i.args,i.result);return o.key}function f(n,t,e){var r,o,c,f,a,s,l,h=t[0]||{},p=1,d=t.length,v=!1,m=/\d+/;for("boolean"==typeof h&&(v=h,h=t[1]||{},p=2),"object"==typeof h||u(h)||(h={}),d===p&&(h=this,--p);d>p;p++)if(null!=(r=t[p])){l=y(r);for(o in r)if(!(o in Object.prototype)){if(l&&!m.test(o))continue;if(c=h[o],f=r[o],h===f)continue;v&&f&&(i(f)||(a=y(f)))?(a?(a=!1,s=c&&y(c)?c:[]):s=c&&i(c)?c:{},n.push({args:[v,s,f],result:{container:h,key:o}})):void 0!==f&&(y(r)&&u(f)||(h[o]=f))}}e.container[e.key]=h}for(var a={},s=["Boolean","Number","String","Function","Array","Date","RegExp","Object","Error"],l=0;l<s.length;l++){var h=s[l];a["[object "+h+"]"]=h.toLowerCase()}var p=a.toString,d=a.hasOwnProperty,y=Array.isArray||function(n){return"array"===r(n)};t.exports=c},{}],10:[function(n,t,e){"use strict";t.exports=n("../lib/deps/promise")},{"../lib/deps/promise":11}],11:[function(n,t,e){"use strict";t.exports="function"==typeof Promise?Promise:n("lie")},{lie:8}],12:[function(n,t,e){function r(){s=!1,c.length?a=c.concat(a):l=-1,a.length&&o()}function o(){if(!s){var n=setTimeout(r);s=!0;for(var t=a.length;t;){for(c=a,a=[];++l<t;)c&&c[l].run();l=-1,t=a.length}c=null,s=!1,clearTimeout(n)}}function i(n,t){this.fun=n,this.array=t}function u(){}var c,f=t.exports={},a=[],s=!1,l=-1;f.nextTick=function(n){var t=new Array(arguments.length-1);if(arguments.length>1)for(var e=1;e<arguments.length;e++)t[e-1]=arguments[e];a.push(new i(n,t)),1!==a.length||s||setTimeout(o,0)},i.prototype.run=function(){this.fun.apply(null,this.array)},f.title="browser",f.browser=!0,f.env={},f.argv=[],f.version="",f.versions={},f.on=u,f.addListener=u,f.once=u,f.off=u,f.removeListener=u,f.removeAllListeners=u,f.emit=u,f.binding=function(n){throw new Error("process.binding is not supported")},f.cwd=function(){return"/"},f.chdir=function(n){throw new Error("process.chdir is not supported")},f.umask=function(){return 0}},{}],13:[function(n,t,e){!function(n){if("object"==typeof e)t.exports=n();else if("function"==typeof define&&define.amd)define(n);else{var r;try{r=window}catch(o){r=self}r.SparkMD5=n()}}(function(n){"use strict";var t=function(n,t){return n+t&4294967295},e=function(n,e,r,o,i,u){return e=t(t(e,n),t(o,u)),t(e<<i|e>>>32-i,r)},r=function(n,t,r,o,i,u,c){return e(t&r|~t&o,n,t,i,u,c)},o=function(n,t,r,o,i,u,c){return e(t&o|r&~o,n,t,i,u,c)},i=function(n,t,r,o,i,u,c){return e(t^r^o,n,t,i,u,c)},u=function(n,t,r,o,i,u,c){return e(r^(t|~o),n,t,i,u,c)},c=function(n,e){var c=n[0],f=n[1],a=n[2],s=n[3];c=r(c,f,a,s,e[0],7,-680876936),s=r(s,c,f,a,e[1],12,-389564586),a=r(a,s,c,f,e[2],17,606105819),f=r(f,a,s,c,e[3],22,-1044525330),c=r(c,f,a,s,e[4],7,-176418897),s=r(s,c,f,a,e[5],12,1200080426),a=r(a,s,c,f,e[6],17,-1473231341),f=r(f,a,s,c,e[7],22,-45705983),c=r(c,f,a,s,e[8],7,1770035416),s=r(s,c,f,a,e[9],12,-1958414417),a=r(a,s,c,f,e[10],17,-42063),f=r(f,a,s,c,e[11],22,-1990404162),c=r(c,f,a,s,e[12],7,1804603682),s=r(s,c,f,a,e[13],12,-40341101),a=r(a,s,c,f,e[14],17,-1502002290),f=r(f,a,s,c,e[15],22,1236535329),c=o(c,f,a,s,e[1],5,-165796510),s=o(s,c,f,a,e[6],9,-1069501632),a=o(a,s,c,f,e[11],14,643717713),f=o(f,a,s,c,e[0],20,-373897302),c=o(c,f,a,s,e[5],5,-701558691),s=o(s,c,f,a,e[10],9,38016083),a=o(a,s,c,f,e[15],14,-660478335),f=o(f,a,s,c,e[4],20,-405537848),c=o(c,f,a,s,e[9],5,568446438),s=o(s,c,f,a,e[14],9,-1019803690),a=o(a,s,c,f,e[3],14,-187363961),f=o(f,a,s,c,e[8],20,1163531501),c=o(c,f,a,s,e[13],5,-1444681467),s=o(s,c,f,a,e[2],9,-51403784),a=o(a,s,c,f,e[7],14,1735328473),f=o(f,a,s,c,e[12],20,-1926607734),c=i(c,f,a,s,e[5],4,-378558),s=i(s,c,f,a,e[8],11,-2022574463),a=i(a,s,c,f,e[11],16,1839030562),f=i(f,a,s,c,e[14],23,-35309556),c=i(c,f,a,s,e[1],4,-1530992060),s=i(s,c,f,a,e[4],11,1272893353),a=i(a,s,c,f,e[7],16,-155497632),f=i(f,a,s,c,e[10],23,-1094730640),c=i(c,f,a,s,e[13],4,681279174),s=i(s,c,f,a,e[0],11,-358537222),a=i(a,s,c,f,e[3],16,-722521979),f=i(f,a,s,c,e[6],23,76029189),c=i(c,f,a,s,e[9],4,-640364487),s=i(s,c,f,a,e[12],11,-421815835),a=i(a,s,c,f,e[15],16,530742520),f=i(f,a,s,c,e[2],23,-995338651),c=u(c,f,a,s,e[0],6,-198630844),s=u(s,c,f,a,e[7],10,1126891415),a=u(a,s,c,f,e[14],15,-1416354905),f=u(f,a,s,c,e[5],21,-57434055),c=u(c,f,a,s,e[12],6,1700485571),s=u(s,c,f,a,e[3],10,-1894986606),a=u(a,s,c,f,e[10],15,-1051523),f=u(f,a,s,c,e[1],21,-2054922799),c=u(c,f,a,s,e[8],6,1873313359),s=u(s,c,f,a,e[15],10,-30611744),a=u(a,s,c,f,e[6],15,-1560198380),f=u(f,a,s,c,e[13],21,1309151649),c=u(c,f,a,s,e[4],6,-145523070),s=u(s,c,f,a,e[11],10,-1120210379),a=u(a,s,c,f,e[2],15,718787259),f=u(f,a,s,c,e[9],21,-343485551),n[0]=t(c,n[0]),n[1]=t(f,n[1]),n[2]=t(a,n[2]),n[3]=t(s,n[3])},f=function(n){var t,e=[];for(t=0;64>t;t+=4)e[t>>2]=n.charCodeAt(t)+(n.charCodeAt(t+1)<<8)+(n.charCodeAt(t+2)<<16)+(n.charCodeAt(t+3)<<24);return e},a=function(n){var t,e=[];for(t=0;64>t;t+=4)e[t>>2]=n[t]+(n[t+1]<<8)+(n[t+2]<<16)+(n[t+3]<<24);return e},s=function(n){var t,e,r,o,i,u,a=n.length,s=[1732584193,-271733879,-1732584194,271733878];for(t=64;a>=t;t+=64)c(s,f(n.substring(t-64,t)));for(n=n.substring(t-64),e=n.length,r=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],t=0;e>t;t+=1)r[t>>2]|=n.charCodeAt(t)<<(t%4<<3);if(r[t>>2]|=128<<(t%4<<3),t>55)for(c(s,r),t=0;16>t;t+=1)r[t]=0;return o=8*a,o=o.toString(16).match(/(.*?)(.{0,8})$/),i=parseInt(o[2],16),u=parseInt(o[1],16)||0,r[14]=i,r[15]=u,c(s,r),s},l=function(n){var t,e,r,o,i,u,f=n.length,s=[1732584193,-271733879,-1732584194,271733878];for(t=64;f>=t;t+=64)c(s,a(n.subarray(t-64,t)));for(n=f>t-64?n.subarray(t-64):new Uint8Array(0),e=n.length,r=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],t=0;e>t;t+=1)r[t>>2]|=n[t]<<(t%4<<3);if(r[t>>2]|=128<<(t%4<<3),t>55)for(c(s,r),t=0;16>t;t+=1)r[t]=0;return o=8*f,o=o.toString(16).match(/(.*?)(.{0,8})$/),i=parseInt(o[2],16),u=parseInt(o[1],16)||0,r[14]=i,r[15]=u,c(s,r),s},h=["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"],p=function(n){var t,e="";for(t=0;4>t;t+=1)e+=h[n>>8*t+4&15]+h[n>>8*t&15];return e},d=function(n){var t;for(t=0;t<n.length;t+=1)n[t]=p(n[t]);return n.join("")},y=function(n){return d(s(n))},v=function(){this.reset()};return"5d41402abc4b2a76b9719d911017c592"!==y("hello")&&(t=function(n,t){var e=(65535&n)+(65535&t),r=(n>>16)+(t>>16)+(e>>16);return r<<16|65535&e}),v.prototype.append=function(n){return/[\u0080-\uFFFF]/.test(n)&&(n=unescape(encodeURIComponent(n))),this.appendBinary(n),this},v.prototype.appendBinary=function(n){this._buff+=n,this._length+=n.length;var t,e=this._buff.length;for(t=64;e>=t;t+=64)c(this._state,f(this._buff.substring(t-64,t)));return this._buff=this._buff.substr(t-64),this},v.prototype.end=function(n){var t,e,r=this._buff,o=r.length,i=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];for(t=0;o>t;t+=1)i[t>>2]|=r.charCodeAt(t)<<(t%4<<3);return this._finish(i,o),e=n?this._state:d(this._state),this.reset(),e},v.prototype._finish=function(n,t){var e,r,o,i=t;if(n[i>>2]|=128<<(i%4<<3),i>55)for(c(this._state,n),i=0;16>i;i+=1)n[i]=0;e=8*this._length,e=e.toString(16).match(/(.*?)(.{0,8})$/),r=parseInt(e[2],16),o=parseInt(e[1],16)||0,n[14]=r,n[15]=o,c(this._state,n)},v.prototype.reset=function(){return this._buff="",this._length=0,this._state=[1732584193,-271733879,-1732584194,271733878],this},v.prototype.destroy=function(){delete this._state,delete this._buff,delete this._length},v.hash=function(n,t){/[\u0080-\uFFFF]/.test(n)&&(n=unescape(encodeURIComponent(n)));var e=s(n);return t?e:d(e)},v.hashBinary=function(n,t){var e=s(n);return t?e:d(e)},v.ArrayBuffer=function(){this.reset()},v.ArrayBuffer.prototype.append=function(n){var t,e=this._concatArrayBuffer(this._buff,n),r=e.length;for(this._length+=n.byteLength,t=64;r>=t;t+=64)c(this._state,a(e.subarray(t-64,t)));return this._buff=r>t-64?e.subarray(t-64):new Uint8Array(0),this},v.ArrayBuffer.prototype.end=function(n){var t,e,r=this._buff,o=r.length,i=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];for(t=0;o>t;t+=1)i[t>>2]|=r[t]<<(t%4<<3);return this._finish(i,o),e=n?this._state:d(this._state),this.reset(),e},v.ArrayBuffer.prototype._finish=v.prototype._finish,v.ArrayBuffer.prototype.reset=function(){return this._buff=new Uint8Array(0),this._length=0,this._state=[1732584193,-271733879,-1732584194,271733878],this},v.ArrayBuffer.prototype.destroy=v.prototype.destroy,v.ArrayBuffer.prototype._concatArrayBuffer=function(n,t){var e=n.length,r=new Uint8Array(e+t.byteLength);return r.set(n),r.set(new Uint8Array(t),e),r},v.ArrayBuffer.hash=function(n,t){var e=l(new Uint8Array(n));return t?e:d(e)},v})},{}]},{},[1]);
2 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
 1 | var Promise = require('pouchdb/extras/promise')
 2 | var checkpointer = require('./lib/checkpointer')
 3 | var migrate = require('./lib/migrate')
 4 | 
 5 | exports.migrate = function(migration, options, callback) {
 6 |   var db = this
 7 | 
 8 |   if (!migration) {
 9 |     throw(new Error('no migration given'))
10 |   }
11 |   if (typeof migration !== 'function') {
12 |     throw(new Error('migration must be a function'))
13 |   }
14 | 
15 |   if (typeof options === 'function') {
16 |     callback = options
17 |     options = {}
18 |   }
19 |   if (typeof options === 'undefined') {
20 |     options = {}
21 |   }
22 | 
23 |   var promise = checkpointer(db, migration)
24 |     .then(function(cp) {
25 |       return migrate(db, cp, migration, options)
26 |     })
27 | 
28 |   if (typeof callback === 'function') {
29 |     return promise
30 |       .then(function(result) {
31 |         callback(null, result)
32 |       })
33 |       .catch(function(error) {
34 |         callback(error)
35 |         return Promise.reject(error)
36 |       })
37 |   }
38 | 
39 |   return promise
40 | }
41 | 
42 | if (typeof window !== 'undefined' && window.PouchDB) {
43 |   window.PouchDB.plugin(exports)
44 | }
45 | 


--------------------------------------------------------------------------------
/lib/checkpointer.js:
--------------------------------------------------------------------------------
 1 | var MD5 = require('./md5')
 2 | var Promise = require('pouchdb/extras/promise')
 3 | 
 4 | var md5Promise = function(data) {
 5 |   return new Promise(function(resolve, reject) {
 6 |     MD5(data, function(error, result) {
 7 |       if (error) { return reject(error) }
 8 | 
 9 |       resolve(result)
10 |     })
11 |   })
12 | }
13 | 
14 | module.exports = function(db, migration) {
15 |   var doc = {
16 |     last_seq: 0
17 |   }
18 | 
19 |   return md5Promise(migration.toString())
20 |     .then(function(md5sum) {
21 |       doc._id = '_local/' + md5sum
22 |     })
23 |     .then(function() {
24 |       return {
25 |         get: function() {
26 |           return db.get(doc._id)
27 |             .then(function(response) {
28 |               doc._rev = response._rev
29 |               doc.last_seq = response.last_seq
30 |             })
31 |             .catch(function(error) {
32 |               if (error.status !== 404) return Promise.reject()
33 |             })
34 |             .then(function() {
35 |               return doc.last_seq
36 |             })
37 |         },
38 |         set: function(seq) {
39 |           doc.last_seq = seq
40 | 
41 |           return db.put(doc)
42 |             .then(function(response) {
43 |               doc._rev = response.rev
44 |             })
45 |         }
46 |       }
47 |     })
48 | }
49 | 


--------------------------------------------------------------------------------
/lib/md5.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | /* istanbul ignore next */
  3 | var crypto = require('crypto');
  4 | /* istanbul ignore next */
  5 | var Md5 = require('spark-md5');
  6 | /* istanbul ignore next */
  7 | var setImmediateShim = global.setImmediate || global.setTimeout;
  8 | /* istanbul ignore next */
  9 | var MD5_CHUNK_SIZE = 32768;
 10 | 
 11 | /* istanbul ignore next */
 12 | function sliceShim(arrayBuffer, begin, end) {
 13 |   if (typeof arrayBuffer.slice === 'function') {
 14 |     if (!begin) {
 15 |       return arrayBuffer.slice();
 16 |     } else if (!end) {
 17 |       return arrayBuffer.slice(begin);
 18 |     } else {
 19 |       return arrayBuffer.slice(begin, end);
 20 |     }
 21 |   }
 22 |   //
 23 |   // shim for IE courtesy of http://stackoverflow.com/a/21440217
 24 |   //
 25 | 
 26 |   //If `begin`/`end` is unspecified, Chrome assumes 0, so we do the same
 27 |   //Chrome also converts the values to integers via flooring
 28 |   begin = Math.floor(begin || 0);
 29 |   end = Math.floor(end || 0);
 30 | 
 31 |   var len = arrayBuffer.byteLength;
 32 | 
 33 |   //If either `begin` or `end` is negative, it refers to an
 34 |   //index from the end of the array, as opposed to from the beginning.
 35 |   //The range specified by the `begin` and `end` values is clamped to the
 36 |   //valid index range for the current array.
 37 |   begin = begin < 0 ? Math.max(begin + len, 0) : Math.min(len, begin);
 38 |   end = end < 0 ? Math.max(end + len, 0) : Math.min(len, end);
 39 | 
 40 |   //If the computed length of the new ArrayBuffer would be negative, it
 41 |   //is clamped to zero.
 42 |   if (end - begin <= 0) {
 43 |     return new ArrayBuffer(0);
 44 |   }
 45 | 
 46 |   var result = new ArrayBuffer(end - begin);
 47 |   var resultBytes = new Uint8Array(result);
 48 |   var sourceBytes = new Uint8Array(arrayBuffer, begin, end - begin);
 49 | 
 50 |   resultBytes.set(sourceBytes);
 51 | 
 52 |   return result;
 53 | }
 54 | 
 55 | // convert a 64-bit int to a binary string
 56 | /* istanbul ignore next */
 57 | function intToString(int) {
 58 |   var bytes = [
 59 |     (int & 0xff),
 60 |     ((int >>> 8) & 0xff),
 61 |     ((int >>> 16) & 0xff),
 62 |     ((int >>> 24) & 0xff)
 63 |   ];
 64 |   return bytes.map(function (byte) {
 65 |     return String.fromCharCode(byte);
 66 |   }).join('');
 67 | }
 68 | 
 69 | // convert an array of 64-bit ints into
 70 | // a base64-encoded string
 71 | /* istanbul ignore next */
 72 | function rawToBase64(raw) {
 73 |   var res = '';
 74 |   for (var i = 0; i < raw.length; i++) {
 75 |     res += intToString(raw[i]);
 76 |   }
 77 |   return global.btoa(res);
 78 | }
 79 | 
 80 | /* istanbul ignore next */
 81 | module.exports = function (data, callback) {
 82 |   if (!process.browser) {
 83 |     var base64 = crypto.createHash('md5').update(data).digest('base64');
 84 |     callback(null, base64);
 85 |     return;
 86 |   }
 87 |   var inputIsString = typeof data === 'string';
 88 |   var len = inputIsString ? data.length : data.byteLength;
 89 |   var chunkSize = Math.min(MD5_CHUNK_SIZE, len);
 90 |   var chunks = Math.ceil(len / chunkSize);
 91 |   var currentChunk = 0;
 92 |   var buffer = inputIsString ? new Md5() : new Md5.ArrayBuffer();
 93 | 
 94 |   function append(buffer, data, start, end) {
 95 |     if (inputIsString) {
 96 |       buffer.appendBinary(data.substring(start, end));
 97 |     } else {
 98 |       buffer.append(sliceShim(data, start, end));
 99 |     }
100 |   }
101 | 
102 |   function loadNextChunk() {
103 |     var start = currentChunk * chunkSize;
104 |     var end = start + chunkSize;
105 |     if ((start + chunkSize) >= data.size) {
106 |       end = data.size;
107 |     }
108 |     currentChunk++;
109 |     if (currentChunk < chunks) {
110 |       append(buffer, data, start, end);
111 |       setImmediateShim(loadNextChunk);
112 |     } else {
113 |       append(buffer, data, start, end);
114 |       var raw = buffer.end(true);
115 |       var base64 = rawToBase64(raw);
116 |       callback(null, base64);
117 |       buffer.destroy();
118 |     }
119 |   }
120 |   loadNextChunk();
121 | };
122 | 


--------------------------------------------------------------------------------
/lib/migrate.js:
--------------------------------------------------------------------------------
 1 | var Promise = require('pouchdb/extras/promise')
 2 | var extend = require('pouchdb-extend')
 3 | var async = require('async')
 4 | 
 5 | module.exports = function migrate(db, checkpointer, migration, options) {
 6 |   return checkpointer.get()
 7 |     .then(function(since) {
 8 |       return new Promise(function(resolve, reject) {
 9 |         var docs = []
10 |   
11 |         var queue = async.queue(function(result, next) {
12 |           if (!result) {
13 |             return checkpointer
14 |               .set(change.seq)
15 |               .then(next.bind({}, null))
16 |               .catch(next)
17 |           }
18 |             
19 |           db
20 |             .bulkDocs({ docs: result })
21 |             .then(function(response) {
22 |               return checkpointer.set(change.seq)
23 |             })
24 |             .then(next.bind({}, null))
25 |             .catch(next)
26 |         }, 1)
27 | 
28 |         
29 |         var feed = db.changes(extend({}, options, {
30 |           include_docs: true,
31 |           since: since
32 |         }))
33 |         
34 |         feed.on('change', function(change) {
35 |           var result = migration(change.doc)
36 | 
37 |           if (!options.live) {
38 |             docs = result ? docs.concat(result) : docs
39 |             return
40 |           }
41 |           
42 |           queue.push(result)
43 |         })
44 |         
45 |         feed.on('complete', function(info) {
46 |           if (options.live) { return resolve(info) }
47 | 
48 |           db
49 |             .bulkDocs({ docs: docs })
50 |             .then(function(response) {
51 |               return checkpointer.set(info.last_seq)
52 |             })
53 |             .then(function() {
54 |               return db.info()
55 |             })
56 |             .then(function(dbinfo) {
57 |               if (dbinfo.update_seq > info.last_seq) {
58 |                 return migrate(db, checkpointer, migration, options)
59 |               }
60 |               return info
61 |             })
62 |             .then(resolve)
63 |         })
64 | 
65 |         feed.on('error', reject)
66 |       })
67 |     })
68 | }
69 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "pouchdb-migrate",
 3 |   "description": "PouchDB plugin for running migrations.",
 4 |   "main": "index.js",
 5 |   "scripts": {
 6 |     "test": "tape test.js | tap-spec",
 7 |     "build": "mkdir -p dist && browserify index.js -o dist/pouchdb.migrate.js && npm run min",
 8 |     "min": "uglifyjs dist/pouchdb.migrate.js -mc > dist/pouchdb.migrate.min.js",
 9 |     "semantic-release": "semantic-release pre && npm publish && semantic-release post"
10 |   },
11 |   "repository": {
12 |     "type": "git",
13 |     "url": "https://github.com/eHealthAfrica/pouchdb-migrate.git"
14 |   },
15 |   "keywords": [
16 |     "couchdb",
17 |     "migrate",
18 |     "migrator",
19 |     "pouchdb",
20 |     "plugin"
21 |   ],
22 |   "author": "Johannes J. Schmidt <schmidt@netzmerk.com> (http://die-tf.de/)",
23 |   "license": "Apache-2.0",
24 |   "bugs": {
25 |     "url": "https://github.com/eHealthAfrica/pouchdb-migrate/issues"
26 |   },
27 |   "homepage": "https://github.com/eHealthAfrica/pouchdb-migrate#readme",
28 |   "dependencies": {
29 |     "async": "^1.5.1",
30 |     "pouchdb": "^5.0.0",
31 |     "pouchdb-extend": "^0.1.2",
32 |     "spark-md5": "^2.0.0"
33 |   },
34 |   "devDependencies": {
35 |     "browserify": "^13.0.0",
36 |     "memdown": "^1.1.0",
37 |     "tap-spec": "^4.1.0",
38 |     "tape": "^4.2.1",
39 |     "uglify-js": "^2.5.0",
40 |     "semantic-release": "^6.0.3"
41 |   },
42 |   "browser": {
43 |     "crypto": false
44 |   }
45 | }
46 | 


--------------------------------------------------------------------------------
/test.js:
--------------------------------------------------------------------------------
 1 | var test = require('tape')
 2 | var PouchDB = require('pouchdb')
 3 | var memdown = require('memdown')
 4 | 
 5 | PouchDB.plugin(require('./'))
 6 | 
 7 | 
 8 | test('basic migration', function(t) {
 9 |   var db = new PouchDB('test', { db: memdown })
10 |   var docs = [
11 |     { _id: 'mydoc' },
12 |     { _id: 'otherdoc' }
13 |   ]
14 |   var migration = function(doc) {
15 |     if ('foo' in doc) return
16 | 
17 |     doc.foo = 'bar'
18 |     return [doc]
19 |   }
20 | 
21 |   db
22 |     .bulkDocs(docs)
23 |     .then(function() {
24 |       return db.migrate(migration, { limit: docs.length })
25 |     })
26 |     .then(function() {
27 |       return db.allDocs({ include_docs: true })
28 |     })
29 |     .then(function(result) {
30 |       result.rows.forEach(function(row) {
31 |         t.equal(row.doc.foo, 'bar', row.id + ' has foo')
32 |       })
33 |     })
34 |     .then(t.end)
35 | })
36 | 


--------------------------------------------------------------------------------