{"version":3,"file":"chunks/15.0477960062a1196a5c6a.js","mappings":"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","sources":["webpack://core/../../node_modules/argsarray/index.js","webpack://core/../../node_modules/events/events.js","webpack://core/../../node_modules/immediate/lib/index.js","webpack://core/../../node_modules/immediate/lib/messageChannel.js","webpack://core/../../node_modules/immediate/lib/mutation.js","webpack://core/../../node_modules/immediate/lib/queueMicrotask.js","webpack://core/../../node_modules/immediate/lib/stateChange.js","webpack://core/../../node_modules/immediate/lib/timeout.js","webpack://core/../../node_modules/inherits/inherits_browser.js","webpack://core/../../node_modules/pouchdb-errors/lib/index.es.js","webpack://core/../../node_modules/pouchdb-fetch/lib/index-browser.es.js","webpack://core/../../node_modules/pouchdb-collections/lib/index.es.js","webpack://core/../../node_modules/pouchdb-binary-utils/lib/index-browser.es.js","webpack://core/../../node_modules/pouchdb-collate/lib/index.es.js","webpack://core/../../node_modules/pouchdb-md5/lib/index-browser.es.js","webpack://core/../../node_modules/pouchdb-utils/lib/index-browser.es.js","webpack://core/../../node_modules/pouchdb-mapreduce-utils/lib/index.es.js","webpack://core/../../node_modules/pouchdb-abstract-mapreduce/lib/index.es.js","webpack://core/../../node_modules/pouchdb-selector-core/lib/index.es.js","webpack://core/../../node_modules/pouchdb-find/lib/index-browser.es.js","webpack://core/../../node_modules/pouchdb/lib/index-browser.es.js","webpack://core/../../node_modules/spark-md5/spark-md5.js","webpack://core/../../node_modules/uuid/dist/esm-browser/rng.js","webpack://core/../../node_modules/uuid/dist/esm-browser/regex.js","webpack://core/../../node_modules/uuid/dist/esm-browser/stringify.js","webpack://core/../../node_modules/uuid/dist/esm-browser/validate.js","webpack://core/../../node_modules/uuid/dist/esm-browser/v4.js","webpack://core/../../node_modules/vuvuzela/index.js"],"sourcesContent":["'use strict';\n\nmodule.exports = argsArray;\n\nfunction argsArray(fun) {\n  return function () {\n    var len = arguments.length;\n    if (len) {\n      var args = [];\n      var i = -1;\n      while (++i < len) {\n        args[i] = arguments[i];\n      }\n      return fun.call(this, args);\n    } else {\n      return fun.call(this, []);\n    }\n  };\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function errorListener(err) {\n      emitter.removeListener(name, resolver);\n      reject(err);\n    }\n\n    function resolver() {\n      if (typeof emitter.removeListener === 'function') {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n\n    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n    if (name !== 'error') {\n      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n    }\n  });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n  if (typeof emitter.on === 'function') {\n    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n  }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n  if (typeof emitter.on === 'function') {\n    if (flags.once) {\n      emitter.once(name, listener);\n    } else {\n      emitter.on(name, listener);\n    }\n  } else if (typeof emitter.addEventListener === 'function') {\n    // EventTarget does not have `error` event semantics like Node\n    // EventEmitters, we do not listen for `error` events here.\n    emitter.addEventListener(name, function wrapListener(arg) {\n      // IE does not have builtin `{ once: true }` support so we\n      // have to do it manually.\n      if (flags.once) {\n        emitter.removeEventListener(name, wrapListener);\n      }\n      listener(arg);\n    });\n  } else {\n    throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n  }\n}\n","'use strict';\nvar types = [\n  require('./nextTick'),\n  require('./queueMicrotask'),\n  require('./mutation.js'),\n  require('./messageChannel'),\n  require('./stateChange'),\n  require('./timeout')\n];\nvar draining;\nvar currentQueue;\nvar queueIndex = -1;\nvar queue = [];\nvar scheduled = false;\nfunction cleanUpNextTick() {\n  if (!draining || !currentQueue) {\n    return;\n  }\n  draining = false;\n  if (currentQueue.length) {\n    queue = currentQueue.concat(queue);\n  } else {\n    queueIndex = -1;\n  }\n  if (queue.length) {\n    nextTick();\n  }\n}\n\n//named nextTick for less confusing stack traces\nfunction nextTick() {\n  if (draining) {\n    return;\n  }\n  scheduled = false;\n  draining = true;\n  var len = queue.length;\n  var timeout = setTimeout(cleanUpNextTick);\n  while (len) {\n    currentQueue = queue;\n    queue = [];\n    while (currentQueue && ++queueIndex < len) {\n      currentQueue[queueIndex].run();\n    }\n    queueIndex = -1;\n    len = queue.length;\n  }\n  currentQueue = null;\n  queueIndex = -1;\n  draining = false;\n  clearTimeout(timeout);\n}\nvar scheduleDrain;\nvar i = -1;\nvar len = types.length;\nwhile (++i < len) {\n  if (types[i] && types[i].test && types[i].test()) {\n    scheduleDrain = types[i].install(nextTick);\n    break;\n  }\n}\n// v8 likes predictible objects\nfunction Item(fun, array) {\n  this.fun = fun;\n  this.array = array;\n}\nItem.prototype.run = function () {\n  var fun = this.fun;\n  var array = this.array;\n  switch (array.length) {\n  case 0:\n    return fun();\n  case 1:\n    return fun(array[0]);\n  case 2:\n    return fun(array[0], array[1]);\n  case 3:\n    return fun(array[0], array[1], array[2]);\n  default:\n    return fun.apply(null, array);\n  }\n\n};\nmodule.exports = immediate;\nfunction immediate(task) {\n  var args = new Array(arguments.length - 1);\n  if (arguments.length > 1) {\n    for (var i = 1; i < arguments.length; i++) {\n      args[i - 1] = arguments[i];\n    }\n  }\n  queue.push(new Item(task, args));\n  if (!scheduled && !draining) {\n    scheduled = true;\n    scheduleDrain();\n  }\n}\n","'use strict';\n\nexports.test = function () {\n  if (global.setImmediate) {\n    // we can only get here in IE10\n    // which doesn't handel postMessage well\n    return false;\n  }\n  return typeof global.MessageChannel !== 'undefined';\n};\n\nexports.install = function (func) {\n  var channel = new global.MessageChannel();\n  channel.port1.onmessage = func;\n  return function () {\n    channel.port2.postMessage(0);\n  };\n};","'use strict';\n//based off rsvp https://github.com/tildeio/rsvp.js\n//license https://github.com/tildeio/rsvp.js/blob/master/LICENSE\n//https://github.com/tildeio/rsvp.js/blob/master/lib/rsvp/asap.js\n\nvar Mutation = global.MutationObserver || global.WebKitMutationObserver;\n\nexports.test = function () {\n  return Mutation;\n};\n\nexports.install = function (handle) {\n  var called = 0;\n  var observer = new Mutation(handle);\n  var element = global.document.createTextNode('');\n  observer.observe(element, {\n    characterData: true\n  });\n  return function () {\n    element.data = (called = ++called % 2);\n  };\n};","'use strict';\nexports.test = function () {\n  return typeof global.queueMicrotask === 'function';\n};\n\nexports.install = function (func) {\n  return function () {\n    global.queueMicrotask(func);\n  };\n};\n","'use strict';\n\nexports.test = function () {\n  return 'document' in global && 'onreadystatechange' in global.document.createElement('script');\n};\n\nexports.install = function (handle) {\n  return function () {\n\n    // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n    // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n    var scriptEl = global.document.createElement('script');\n    scriptEl.onreadystatechange = function () {\n      handle();\n\n      scriptEl.onreadystatechange = null;\n      scriptEl.parentNode.removeChild(scriptEl);\n      scriptEl = null;\n    };\n    global.document.documentElement.appendChild(scriptEl);\n\n    return handle;\n  };\n};","'use strict';\nexports.test = function () {\n  return true;\n};\n\nexports.install = function (t) {\n  return function () {\n    setTimeout(t, 0);\n  };\n};","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      var TempCtor = function () {}\n      TempCtor.prototype = superCtor.prototype\n      ctor.prototype = new TempCtor()\n      ctor.prototype.constructor = ctor\n    }\n  }\n}\n","import inherits from 'inherits';\n\ninherits(PouchError, Error);\n\nfunction PouchError(status, error, reason) {\n  Error.call(this, reason);\n  this.status = status;\n  this.name = error;\n  this.message = reason;\n  this.error = true;\n}\n\nPouchError.prototype.toString = function () {\n  return JSON.stringify({\n    status: this.status,\n    name: this.name,\n    message: this.message,\n    reason: this.reason\n  });\n};\n\nvar UNAUTHORIZED = new PouchError(401, 'unauthorized', \"Name or password is incorrect.\");\nvar MISSING_BULK_DOCS = new PouchError(400, 'bad_request', \"Missing JSON list of 'docs'\");\nvar MISSING_DOC = new PouchError(404, 'not_found', 'missing');\nvar REV_CONFLICT = new PouchError(409, 'conflict', 'Document update conflict');\nvar INVALID_ID = new PouchError(400, 'bad_request', '_id field must contain a string');\nvar MISSING_ID = new PouchError(412, 'missing_id', '_id is required for puts');\nvar RESERVED_ID = new PouchError(400, 'bad_request', 'Only reserved document ids may start with underscore.');\nvar NOT_OPEN = new PouchError(412, 'precondition_failed', 'Database not open');\nvar UNKNOWN_ERROR = new PouchError(500, 'unknown_error', 'Database encountered an unknown error');\nvar BAD_ARG = new PouchError(500, 'badarg', 'Some query argument is invalid');\nvar INVALID_REQUEST = new PouchError(400, 'invalid_request', 'Request was invalid');\nvar QUERY_PARSE_ERROR = new PouchError(400, 'query_parse_error', 'Some query parameter is invalid');\nvar DOC_VALIDATION = new PouchError(500, 'doc_validation', 'Bad special document member');\nvar BAD_REQUEST = new PouchError(400, 'bad_request', 'Something wrong with the request');\nvar NOT_AN_OBJECT = new PouchError(400, 'bad_request', 'Document must be a JSON object');\nvar DB_MISSING = new PouchError(404, 'not_found', 'Database not found');\nvar IDB_ERROR = new PouchError(500, 'indexed_db_went_bad', 'unknown');\nvar WSQ_ERROR = new PouchError(500, 'web_sql_went_bad', 'unknown');\nvar LDB_ERROR = new PouchError(500, 'levelDB_went_went_bad', 'unknown');\nvar FORBIDDEN = new PouchError(403, 'forbidden', 'Forbidden by design doc validate_doc_update function');\nvar INVALID_REV = new PouchError(400, 'bad_request', 'Invalid rev format');\nvar FILE_EXISTS = new PouchError(412, 'file_exists', 'The database could not be created, the file already exists.');\nvar MISSING_STUB = new PouchError(412, 'missing_stub', 'A pre-existing attachment stub wasn\\'t found');\nvar INVALID_URL = new PouchError(413, 'invalid_url', 'Provided URL is invalid');\n\nfunction createError(error, reason) {\n  function CustomPouchError(reason) {\n    // inherit error properties from our parent error manually\n    // so as to allow proper JSON parsing.\n    /* jshint ignore:start */\n    var names = Object.getOwnPropertyNames(error);\n    for (var i = 0, len = names.length; i < len; i++) {\n      if (typeof error[names[i]] !== 'function') {\n        this[names[i]] = error[names[i]];\n      }\n    }\n\n    if (this.stack === undefined) {\n      this.stack = (new Error()).stack;\n    }\n\n    /* jshint ignore:end */\n    if (reason !== undefined) {\n      this.reason = reason;\n    }\n  }\n  CustomPouchError.prototype = PouchError.prototype;\n  return new CustomPouchError(reason);\n}\n\nfunction generateErrorFromResponse(err) {\n\n  if (typeof err !== 'object') {\n    var data = err;\n    err = UNKNOWN_ERROR;\n    err.data = data;\n  }\n\n  if ('error' in err && err.error === 'conflict') {\n    err.name = 'conflict';\n    err.status = 409;\n  }\n\n  if (!('name' in err)) {\n    err.name = err.error || 'unknown';\n  }\n\n  if (!('status' in err)) {\n    err.status = 500;\n  }\n\n  if (!('message' in err)) {\n    err.message = err.message || err.reason;\n  }\n\n  if (!('stack' in err)) {\n    err.stack = (new Error()).stack;\n  }\n\n  return err;\n}\n\nexport { UNAUTHORIZED, MISSING_BULK_DOCS, MISSING_DOC, REV_CONFLICT, INVALID_ID, MISSING_ID, RESERVED_ID, NOT_OPEN, UNKNOWN_ERROR, BAD_ARG, INVALID_REQUEST, QUERY_PARSE_ERROR, DOC_VALIDATION, BAD_REQUEST, NOT_AN_OBJECT, DB_MISSING, WSQ_ERROR, LDB_ERROR, FORBIDDEN, INVALID_REV, FILE_EXISTS, MISSING_STUB, IDB_ERROR, INVALID_URL, createError, generateErrorFromResponse };\n","// AbortController was introduced quite a while after fetch and\n// isnt required for PouchDB to function so polyfill if needed\nvar a = (typeof AbortController !== 'undefined')\n    ? AbortController\n    : function () { return {abort: function () {}}; };\n\nvar f = fetch;\nvar h = Headers;\n\nexport { f as fetch, h as Headers, a as AbortController };\n","function mangle(key) {\n  return '$' + key;\n}\nfunction unmangle(key) {\n  return key.substring(1);\n}\nfunction Map$1() {\n  this._store = {};\n}\nMap$1.prototype.get = function (key) {\n  var mangled = mangle(key);\n  return this._store[mangled];\n};\nMap$1.prototype.set = function (key, value) {\n  var mangled = mangle(key);\n  this._store[mangled] = value;\n  return true;\n};\nMap$1.prototype.has = function (key) {\n  var mangled = mangle(key);\n  return mangled in this._store;\n};\nMap$1.prototype.keys = function () {\n  return Object.keys(this._store).map(k => unmangle(k));\n};\nMap$1.prototype.delete = function (key) {\n  var mangled = mangle(key);\n  var res = mangled in this._store;\n  delete this._store[mangled];\n  return res;\n};\nMap$1.prototype.forEach = function (cb) {\n  var keys = Object.keys(this._store);\n  for (var i = 0, len = keys.length; i < len; i++) {\n    var key = keys[i];\n    var value = this._store[key];\n    key = unmangle(key);\n    cb(value, key);\n  }\n};\nObject.defineProperty(Map$1.prototype, 'size', {\n  get: function () {\n    return Object.keys(this._store).length;\n  }\n});\n\nfunction Set$1(array) {\n  this._store = new Map$1();\n\n  // init with an array\n  if (array && Array.isArray(array)) {\n    for (var i = 0, len = array.length; i < len; i++) {\n      this.add(array[i]);\n    }\n  }\n}\nSet$1.prototype.add = function (key) {\n  return this._store.set(key, true);\n};\nSet$1.prototype.has = function (key) {\n  return this._store.has(key);\n};\nSet$1.prototype.forEach = function (cb) {\n  this._store.forEach(function (value, key) {\n    cb(key);\n  });\n};\nObject.defineProperty(Set$1.prototype, 'size', {\n  get: function () {\n    return this._store.size;\n  }\n});\n\n// Based on https://kangax.github.io/compat-table/es6/ we can sniff out\n// incomplete Map/Set implementations which would otherwise cause our tests to fail.\n// Notably they fail in IE11 and iOS 8.4, which this prevents.\nfunction supportsMapAndSet() {\n  if (typeof Symbol === 'undefined' || typeof Map === 'undefined' || typeof Set === 'undefined') {\n    return false;\n  }\n  var prop = Object.getOwnPropertyDescriptor(Map, Symbol.species);\n  return prop && 'get' in prop && Map[Symbol.species] === Map;\n}\n\n// based on https://github.com/montagejs/collections\n\nvar ExportedSet;\nvar ExportedMap;\n\n{\n  if (supportsMapAndSet()) { // prefer built-in Map/Set\n    ExportedSet = Set;\n    ExportedMap = Map;\n  } else { // fall back to our polyfill\n    ExportedSet = Set$1;\n    ExportedMap = Map$1;\n  }\n}\n\nexport { ExportedSet as Set, ExportedMap as Map };\n","var thisAtob = function (str) {\n  return atob(str);\n};\n\nvar thisBtoa = function (str) {\n  return btoa(str);\n};\n\n// Abstracts constructing a Blob object, so it also works in older\n// browsers that don't support the native Blob constructor (e.g.\n// old QtWebKit versions, Android < 4.4).\nfunction createBlob(parts, properties) {\n  /* global BlobBuilder,MSBlobBuilder,MozBlobBuilder,WebKitBlobBuilder */\n  parts = parts || [];\n  properties = properties || {};\n  try {\n    return new Blob(parts, properties);\n  } catch (e) {\n    if (e.name !== \"TypeError\") {\n      throw e;\n    }\n    var Builder = typeof BlobBuilder !== 'undefined' ? BlobBuilder :\n                  typeof MSBlobBuilder !== 'undefined' ? MSBlobBuilder :\n                  typeof MozBlobBuilder !== 'undefined' ? MozBlobBuilder :\n                  WebKitBlobBuilder;\n    var builder = new Builder();\n    for (var i = 0; i < parts.length; i += 1) {\n      builder.append(parts[i]);\n    }\n    return builder.getBlob(properties.type);\n  }\n}\n\n// From http://stackoverflow.com/questions/14967647/ (continues on next line)\n// encode-decode-image-with-base64-breaks-image (2013-04-21)\nfunction binaryStringToArrayBuffer(bin) {\n  var length = bin.length;\n  var buf = new ArrayBuffer(length);\n  var arr = new Uint8Array(buf);\n  for (var i = 0; i < length; i++) {\n    arr[i] = bin.charCodeAt(i);\n  }\n  return buf;\n}\n\nfunction binStringToBluffer(binString, type) {\n  return createBlob([binaryStringToArrayBuffer(binString)], {type: type});\n}\n\nfunction b64ToBluffer(b64, type) {\n  return binStringToBluffer(thisAtob(b64), type);\n}\n\n//Can't find original post, but this is close\n//http://stackoverflow.com/questions/6965107/ (continues on next line)\n//converting-between-strings-and-arraybuffers\nfunction arrayBufferToBinaryString(buffer) {\n  var binary = '';\n  var bytes = new Uint8Array(buffer);\n  var length = bytes.byteLength;\n  for (var i = 0; i < length; i++) {\n    binary += String.fromCharCode(bytes[i]);\n  }\n  return binary;\n}\n\n// shim for browsers that don't support it\nfunction readAsBinaryString(blob, callback) {\n  var reader = new FileReader();\n  var hasBinaryString = typeof reader.readAsBinaryString === 'function';\n  reader.onloadend = function (e) {\n    var result = e.target.result || '';\n    if (hasBinaryString) {\n      return callback(result);\n    }\n    callback(arrayBufferToBinaryString(result));\n  };\n  if (hasBinaryString) {\n    reader.readAsBinaryString(blob);\n  } else {\n    reader.readAsArrayBuffer(blob);\n  }\n}\n\nfunction blobToBinaryString(blobOrBuffer, callback) {\n  readAsBinaryString(blobOrBuffer, function (bin) {\n    callback(bin);\n  });\n}\n\nfunction blobToBase64(blobOrBuffer, callback) {\n  blobToBinaryString(blobOrBuffer, function (base64) {\n    callback(thisBtoa(base64));\n  });\n}\n\n// simplified API. universal browser support is assumed\nfunction readAsArrayBuffer(blob, callback) {\n  var reader = new FileReader();\n  reader.onloadend = function (e) {\n    var result = e.target.result || new ArrayBuffer(0);\n    callback(result);\n  };\n  reader.readAsArrayBuffer(blob);\n}\n\n// this is not used in the browser\nfunction typedBuffer() {\n}\n\nexport { thisAtob as atob, thisBtoa as btoa, b64ToBluffer as base64StringToBlobOrBuffer, binaryStringToArrayBuffer, binStringToBluffer as binaryStringToBlobOrBuffer, createBlob as blob, blobToBase64 as blobOrBufferToBase64, blobToBinaryString as blobOrBufferToBinaryString, readAsArrayBuffer, readAsBinaryString, typedBuffer };\n","function pad(str, padWith, upToLength) {\n  var padding = '';\n  var targetLength = upToLength - str.length;\n  /* istanbul ignore next */\n  while (padding.length < targetLength) {\n    padding += padWith;\n  }\n  return padding;\n}\n\nfunction padLeft(str, padWith, upToLength) {\n  var padding = pad(str, padWith, upToLength);\n  return padding + str;\n}\n\nvar MIN_MAGNITUDE = -324; // verified by -Number.MIN_VALUE\nvar MAGNITUDE_DIGITS = 3; // ditto\nvar SEP = ''; // set to '_' for easier debugging\n\nfunction collate(a, b) {\n\n  if (a === b) {\n    return 0;\n  }\n\n  a = normalizeKey(a);\n  b = normalizeKey(b);\n\n  var ai = collationIndex(a);\n  var bi = collationIndex(b);\n  if ((ai - bi) !== 0) {\n    return ai - bi;\n  }\n  switch (typeof a) {\n    case 'number':\n      return a - b;\n    case 'boolean':\n      return a < b ? -1 : 1;\n    case 'string':\n      return stringCollate(a, b);\n  }\n  return Array.isArray(a) ? arrayCollate(a, b) : objectCollate(a, b);\n}\n\n// couch considers null/NaN/Infinity/-Infinity === undefined,\n// for the purposes of mapreduce indexes. also, dates get stringified.\nfunction normalizeKey(key) {\n  switch (typeof key) {\n    case 'undefined':\n      return null;\n    case 'number':\n      if (key === Infinity || key === -Infinity || isNaN(key)) {\n        return null;\n      }\n      return key;\n    case 'object':\n      var origKey = key;\n      if (Array.isArray(key)) {\n        var len = key.length;\n        key = new Array(len);\n        for (var i = 0; i < len; i++) {\n          key[i] = normalizeKey(origKey[i]);\n        }\n      /* istanbul ignore next */\n      } else if (key instanceof Date) {\n        return key.toJSON();\n      } else if (key !== null) { // generic object\n        key = {};\n        for (var k in origKey) {\n          if (Object.prototype.hasOwnProperty.call(origKey, k)) {\n            var val = origKey[k];\n            if (typeof val !== 'undefined') {\n              key[k] = normalizeKey(val);\n            }\n          }\n        }\n      }\n  }\n  return key;\n}\n\nfunction indexify(key) {\n  if (key !== null) {\n    switch (typeof key) {\n      case 'boolean':\n        return key ? 1 : 0;\n      case 'number':\n        return numToIndexableString(key);\n      case 'string':\n        // We've to be sure that key does not contain \\u0000\n        // Do order-preserving replacements:\n        // 0 -> 1, 1\n        // 1 -> 1, 2\n        // 2 -> 2, 2\n        /* eslint-disable no-control-regex */\n        return key\n          .replace(/\\u0002/g, '\\u0002\\u0002')\n          .replace(/\\u0001/g, '\\u0001\\u0002')\n          .replace(/\\u0000/g, '\\u0001\\u0001');\n        /* eslint-enable no-control-regex */\n      case 'object':\n        var isArray = Array.isArray(key);\n        var arr = isArray ? key : Object.keys(key);\n        var i = -1;\n        var len = arr.length;\n        var result = '';\n        if (isArray) {\n          while (++i < len) {\n            result += toIndexableString(arr[i]);\n          }\n        } else {\n          while (++i < len) {\n            var objKey = arr[i];\n            result += toIndexableString(objKey) +\n                toIndexableString(key[objKey]);\n          }\n        }\n        return result;\n    }\n  }\n  return '';\n}\n\n// convert the given key to a string that would be appropriate\n// for lexical sorting, e.g. within a database, where the\n// sorting is the same given by the collate() function.\nfunction toIndexableString(key) {\n  var zero = '\\u0000';\n  key = normalizeKey(key);\n  return collationIndex(key) + SEP + indexify(key) + zero;\n}\n\nfunction parseNumber(str, i) {\n  var originalIdx = i;\n  var num;\n  var zero = str[i] === '1';\n  if (zero) {\n    num = 0;\n    i++;\n  } else {\n    var neg = str[i] === '0';\n    i++;\n    var numAsString = '';\n    var magAsString = str.substring(i, i + MAGNITUDE_DIGITS);\n    var magnitude = parseInt(magAsString, 10) + MIN_MAGNITUDE;\n    /* istanbul ignore next */\n    if (neg) {\n      magnitude = -magnitude;\n    }\n    i += MAGNITUDE_DIGITS;\n    while (true) {\n      var ch = str[i];\n      if (ch === '\\u0000') {\n        break;\n      } else {\n        numAsString += ch;\n      }\n      i++;\n    }\n    numAsString = numAsString.split('.');\n    if (numAsString.length === 1) {\n      num = parseInt(numAsString, 10);\n    } else {\n      /* istanbul ignore next */\n      num = parseFloat(numAsString[0] + '.' + numAsString[1]);\n    }\n    /* istanbul ignore next */\n    if (neg) {\n      num = num - 10;\n    }\n    /* istanbul ignore next */\n    if (magnitude !== 0) {\n      // parseFloat is more reliable than pow due to rounding errors\n      // e.g. Number.MAX_VALUE would return Infinity if we did\n      // num * Math.pow(10, magnitude);\n      num = parseFloat(num + 'e' + magnitude);\n    }\n  }\n  return {num: num, length : i - originalIdx};\n}\n\n// move up the stack while parsing\n// this function moved outside of parseIndexableString for performance\nfunction pop(stack, metaStack) {\n  var obj = stack.pop();\n\n  if (metaStack.length) {\n    var lastMetaElement = metaStack[metaStack.length - 1];\n    if (obj === lastMetaElement.element) {\n      // popping a meta-element, e.g. an object whose value is another object\n      metaStack.pop();\n      lastMetaElement = metaStack[metaStack.length - 1];\n    }\n    var element = lastMetaElement.element;\n    var lastElementIndex = lastMetaElement.index;\n    if (Array.isArray(element)) {\n      element.push(obj);\n    } else if (lastElementIndex === stack.length - 2) { // obj with key+value\n      var key = stack.pop();\n      element[key] = obj;\n    } else {\n      stack.push(obj); // obj with key only\n    }\n  }\n}\n\nfunction parseIndexableString(str) {\n  var stack = [];\n  var metaStack = []; // stack for arrays and objects\n  var i = 0;\n\n  /*eslint no-constant-condition: [\"error\", { \"checkLoops\": false }]*/\n  while (true) {\n    var collationIndex = str[i++];\n    if (collationIndex === '\\u0000') {\n      if (stack.length === 1) {\n        return stack.pop();\n      } else {\n        pop(stack, metaStack);\n        continue;\n      }\n    }\n    switch (collationIndex) {\n      case '1':\n        stack.push(null);\n        break;\n      case '2':\n        stack.push(str[i] === '1');\n        i++;\n        break;\n      case '3':\n        var parsedNum = parseNumber(str, i);\n        stack.push(parsedNum.num);\n        i += parsedNum.length;\n        break;\n      case '4':\n        var parsedStr = '';\n        /*eslint no-constant-condition: [\"error\", { \"checkLoops\": false }]*/\n        while (true) {\n          var ch = str[i];\n          if (ch === '\\u0000') {\n            break;\n          }\n          parsedStr += ch;\n          i++;\n        }\n        // perform the reverse of the order-preserving replacement\n        // algorithm (see above)\n        /* eslint-disable no-control-regex */\n        parsedStr = parsedStr.replace(/\\u0001\\u0001/g, '\\u0000')\n          .replace(/\\u0001\\u0002/g, '\\u0001')\n          .replace(/\\u0002\\u0002/g, '\\u0002');\n        /* eslint-enable no-control-regex */\n        stack.push(parsedStr);\n        break;\n      case '5':\n        var arrayElement = { element: [], index: stack.length };\n        stack.push(arrayElement.element);\n        metaStack.push(arrayElement);\n        break;\n      case '6':\n        var objElement = { element: {}, index: stack.length };\n        stack.push(objElement.element);\n        metaStack.push(objElement);\n        break;\n      /* istanbul ignore next */\n      default:\n        throw new Error(\n          'bad collationIndex or unexpectedly reached end of input: ' +\n            collationIndex);\n    }\n  }\n}\n\nfunction arrayCollate(a, b) {\n  var len = Math.min(a.length, b.length);\n  for (var i = 0; i < len; i++) {\n    var sort = collate(a[i], b[i]);\n    if (sort !== 0) {\n      return sort;\n    }\n  }\n  return (a.length === b.length) ? 0 :\n    (a.length > b.length) ? 1 : -1;\n}\nfunction stringCollate(a, b) {\n  // See: https://github.com/daleharvey/pouchdb/issues/40\n  // This is incompatible with the CouchDB implementation, but its the\n  // best we can do for now\n  return (a === b) ? 0 : ((a > b) ? 1 : -1);\n}\nfunction objectCollate(a, b) {\n  var ak = Object.keys(a), bk = Object.keys(b);\n  var len = Math.min(ak.length, bk.length);\n  for (var i = 0; i < len; i++) {\n    // First sort the keys\n    var sort = collate(ak[i], bk[i]);\n    if (sort !== 0) {\n      return sort;\n    }\n    // if the keys are equal sort the values\n    sort = collate(a[ak[i]], b[bk[i]]);\n    if (sort !== 0) {\n      return sort;\n    }\n\n  }\n  return (ak.length === bk.length) ? 0 :\n    (ak.length > bk.length) ? 1 : -1;\n}\n// The collation is defined by erlangs ordered terms\n// the atoms null, true, false come first, then numbers, strings,\n// arrays, then objects\n// null/undefined/NaN/Infinity/-Infinity are all considered null\nfunction collationIndex(x) {\n  var id = ['boolean', 'number', 'string', 'object'];\n  var idx = id.indexOf(typeof x);\n  //false if -1 otherwise true, but fast!!!!1\n  if (~idx) {\n    if (x === null) {\n      return 1;\n    }\n    if (Array.isArray(x)) {\n      return 5;\n    }\n    return idx < 3 ? (idx + 2) : (idx + 3);\n  }\n  /* istanbul ignore next */\n  if (Array.isArray(x)) {\n    return 5;\n  }\n}\n\n// conversion:\n// x yyy zz...zz\n// x = 0 for negative, 1 for 0, 2 for positive\n// y = exponent (for negative numbers negated) moved so that it's >= 0\n// z = mantisse\nfunction numToIndexableString(num) {\n\n  if (num === 0) {\n    return '1';\n  }\n\n  // convert number to exponential format for easier and\n  // more succinct string sorting\n  var expFormat = num.toExponential().split(/e\\+?/);\n  var magnitude = parseInt(expFormat[1], 10);\n\n  var neg = num < 0;\n\n  var result = neg ? '0' : '2';\n\n  // first sort by magnitude\n  // it's easier if all magnitudes are positive\n  var magForComparison = ((neg ? -magnitude : magnitude) - MIN_MAGNITUDE);\n  var magString = padLeft((magForComparison).toString(), '0', MAGNITUDE_DIGITS);\n\n  result += SEP + magString;\n\n  // then sort by the factor\n  var factor = Math.abs(parseFloat(expFormat[0])); // [1..10)\n  /* istanbul ignore next */\n  if (neg) { // for negative reverse ordering\n    factor = 10 - factor;\n  }\n\n  var factorStr = factor.toFixed(20);\n\n  // strip zeros from the end\n  factorStr = factorStr.replace(/\\.?0+$/, '');\n\n  result += SEP + factorStr;\n\n  return result;\n}\n\nexport { collate, normalizeKey, toIndexableString, parseIndexableString };\n","import { btoa, readAsArrayBuffer } from 'pouchdb-binary-utils';\nimport Md5 from 'spark-md5';\n\nvar setImmediateShim = self.setImmediate || self.setTimeout;\nvar MD5_CHUNK_SIZE = 32768;\n\nfunction rawToBase64(raw) {\n  return btoa(raw);\n}\n\nfunction sliceBlob(blob, start, end) {\n  if (blob.webkitSlice) {\n    return blob.webkitSlice(start, end);\n  }\n  return blob.slice(start, end);\n}\n\nfunction appendBlob(buffer, blob, start, end, callback) {\n  if (start > 0 || end < blob.size) {\n    // only slice blob if we really need to\n    blob = sliceBlob(blob, start, end);\n  }\n  readAsArrayBuffer(blob, function (arrayBuffer) {\n    buffer.append(arrayBuffer);\n    callback();\n  });\n}\n\nfunction appendString(buffer, string, start, end, callback) {\n  if (start > 0 || end < string.length) {\n    // only create a substring if we really need to\n    string = string.substring(start, end);\n  }\n  buffer.appendBinary(string);\n  callback();\n}\n\nfunction binaryMd5(data, callback) {\n  var inputIsString = typeof data === 'string';\n  var len = inputIsString ? data.length : data.size;\n  var chunkSize = Math.min(MD5_CHUNK_SIZE, len);\n  var chunks = Math.ceil(len / chunkSize);\n  var currentChunk = 0;\n  var buffer = inputIsString ? new Md5() : new Md5.ArrayBuffer();\n\n  var append = inputIsString ? appendString : appendBlob;\n\n  function next() {\n    setImmediateShim(loadNextChunk);\n  }\n\n  function done() {\n    var raw = buffer.end(true);\n    var base64 = rawToBase64(raw);\n    callback(base64);\n    buffer.destroy();\n  }\n\n  function loadNextChunk() {\n    var start = currentChunk * chunkSize;\n    var end = start + chunkSize;\n    currentChunk++;\n    if (currentChunk < chunks) {\n      append(buffer, data, start, end, next);\n    } else {\n      append(buffer, data, start, end, done);\n    }\n  }\n  loadNextChunk();\n}\n\nfunction stringMd5(string) {\n  return Md5.hash(string);\n}\n\nexport { binaryMd5, stringMd5 };\n","import getArguments from 'argsarray';\nimport { Map } from 'pouchdb-collections';\nimport inherits from 'inherits';\nimport immediate from 'immediate';\nimport { createError, BAD_REQUEST, INVALID_ID, MISSING_ID, RESERVED_ID } from 'pouchdb-errors';\nimport EventEmitter from 'events';\nimport { assign } from 'pouchdb-utils';\nimport { v4 } from 'uuid';\nimport { stringMd5 } from 'pouchdb-md5';\n\nfunction isBinaryObject(object) {\n  return (typeof ArrayBuffer !== 'undefined' && object instanceof ArrayBuffer) ||\n    (typeof Blob !== 'undefined' && object instanceof Blob);\n}\n\nfunction cloneArrayBuffer(buff) {\n  if (typeof buff.slice === 'function') {\n    return buff.slice(0);\n  }\n  // IE10-11 slice() polyfill\n  var target = new ArrayBuffer(buff.byteLength);\n  var targetArray = new Uint8Array(target);\n  var sourceArray = new Uint8Array(buff);\n  targetArray.set(sourceArray);\n  return target;\n}\n\nfunction cloneBinaryObject(object) {\n  if (object instanceof ArrayBuffer) {\n    return cloneArrayBuffer(object);\n  }\n  var size = object.size;\n  var type = object.type;\n  // Blob\n  if (typeof object.slice === 'function') {\n    return object.slice(0, size, type);\n  }\n  // PhantomJS slice() replacement\n  return object.webkitSlice(0, size, type);\n}\n\n// most of this is borrowed from lodash.isPlainObject:\n// https://github.com/fis-components/lodash.isplainobject/\n// blob/29c358140a74f252aeb08c9eb28bef86f2217d4a/index.js\n\nvar funcToString = Function.prototype.toString;\nvar objectCtorString = funcToString.call(Object);\n\nfunction isPlainObject(value) {\n  var proto = Object.getPrototypeOf(value);\n  /* istanbul ignore if */\n  if (proto === null) { // not sure when this happens, but I guess it can\n    return true;\n  }\n  var Ctor = proto.constructor;\n  return (typeof Ctor == 'function' &&\n    Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString);\n}\n\nfunction clone(object) {\n  var newObject;\n  var i;\n  var len;\n\n  if (!object || typeof object !== 'object') {\n    return object;\n  }\n\n  if (Array.isArray(object)) {\n    newObject = [];\n    for (i = 0, len = object.length; i < len; i++) {\n      newObject[i] = clone(object[i]);\n    }\n    return newObject;\n  }\n\n  // special case: to avoid inconsistencies between IndexedDB\n  // and other backends, we automatically stringify Dates\n  if (object instanceof Date && isFinite(object)) {\n    return object.toISOString();\n  }\n\n  if (isBinaryObject(object)) {\n    return cloneBinaryObject(object);\n  }\n\n  if (!isPlainObject(object)) {\n    return object; // don't clone objects like Workers\n  }\n\n  newObject = {};\n  for (i in object) {\n    /* istanbul ignore else */\n    if (Object.prototype.hasOwnProperty.call(object, i)) {\n      var value = clone(object[i]);\n      if (typeof value !== 'undefined') {\n        newObject[i] = value;\n      }\n    }\n  }\n  return newObject;\n}\n\nfunction once(fun) {\n  var called = false;\n  return getArguments(function (args) {\n    /* istanbul ignore if */\n    if (called) {\n      // this is a smoke test and should never actually happen\n      throw new Error('once called more than once');\n    } else {\n      called = true;\n      fun.apply(this, args);\n    }\n  });\n}\n\nfunction toPromise(func) {\n  //create the function we will be returning\n  return getArguments(function (args) {\n    // Clone arguments\n    args = clone(args);\n    var self = this;\n    // if the last argument is a function, assume its a callback\n    var usedCB = (typeof args[args.length - 1] === 'function') ? args.pop() : false;\n    var promise = new Promise(function (fulfill, reject) {\n      var resp;\n      try {\n        var callback = once(function (err, mesg) {\n          if (err) {\n            reject(err);\n          } else {\n            fulfill(mesg);\n          }\n        });\n        // create a callback for this invocation\n        // apply the function in the orig context\n        args.push(callback);\n        resp = func.apply(self, args);\n        if (resp && typeof resp.then === 'function') {\n          fulfill(resp);\n        }\n      } catch (e) {\n        reject(e);\n      }\n    });\n    // if there is a callback, call it back\n    if (usedCB) {\n      promise.then(function (result) {\n        usedCB(null, result);\n      }, usedCB);\n    }\n    return promise;\n  });\n}\n\nfunction logApiCall(self, name, args) {\n  /* istanbul ignore if */\n  if (self.constructor.listeners('debug').length) {\n    var logArgs = ['api', self.name, name];\n    for (var i = 0; i < args.length - 1; i++) {\n      logArgs.push(args[i]);\n    }\n    self.constructor.emit('debug', logArgs);\n\n    // override the callback itself to log the response\n    var origCallback = args[args.length - 1];\n    args[args.length - 1] = function (err, res) {\n      var responseArgs = ['api', self.name, name];\n      responseArgs = responseArgs.concat(\n        err ? ['error', err] : ['success', res]\n      );\n      self.constructor.emit('debug', responseArgs);\n      origCallback(err, res);\n    };\n  }\n}\n\nfunction adapterFun(name, callback) {\n  return toPromise(getArguments(function (args) {\n    if (this._closed) {\n      return Promise.reject(new Error('database is closed'));\n    }\n    if (this._destroyed) {\n      return Promise.reject(new Error('database is destroyed'));\n    }\n    var self = this;\n    logApiCall(self, name, args);\n    if (!this.taskqueue.isReady) {\n      return new Promise(function (fulfill, reject) {\n        self.taskqueue.addTask(function (failed) {\n          if (failed) {\n            reject(failed);\n          } else {\n            fulfill(self[name].apply(self, args));\n          }\n        });\n      });\n    }\n    return callback.apply(this, args);\n  }));\n}\n\n// like underscore/lodash _.pick()\nfunction pick(obj, arr) {\n  var res = {};\n  for (var i = 0, len = arr.length; i < len; i++) {\n    var prop = arr[i];\n    if (prop in obj) {\n      res[prop] = obj[prop];\n    }\n  }\n  return res;\n}\n\n// Most browsers throttle concurrent requests at 6, so it's silly\n// to shim _bulk_get by trying to launch potentially hundreds of requests\n// and then letting the majority time out. We can handle this ourselves.\nvar MAX_NUM_CONCURRENT_REQUESTS = 6;\n\nfunction identityFunction(x) {\n  return x;\n}\n\nfunction formatResultForOpenRevsGet(result) {\n  return [{\n    ok: result\n  }];\n}\n\n// shim for P/CouchDB adapters that don't directly implement _bulk_get\nfunction bulkGet(db, opts, callback) {\n  var requests = opts.docs;\n\n  // consolidate into one request per doc if possible\n  var requestsById = new Map();\n  requests.forEach(function (request) {\n    if (requestsById.has(request.id)) {\n      requestsById.get(request.id).push(request);\n    } else {\n      requestsById.set(request.id, [request]);\n    }\n  });\n\n  var numDocs = requestsById.size;\n  var numDone = 0;\n  var perDocResults = new Array(numDocs);\n\n  function collapseResultsAndFinish() {\n    var results = [];\n    perDocResults.forEach(function (res) {\n      res.docs.forEach(function (info) {\n        results.push({\n          id: res.id,\n          docs: [info]\n        });\n      });\n    });\n    callback(null, {results: results});\n  }\n\n  function checkDone() {\n    if (++numDone === numDocs) {\n      collapseResultsAndFinish();\n    }\n  }\n\n  function gotResult(docIndex, id, docs) {\n    perDocResults[docIndex] = {id: id, docs: docs};\n    checkDone();\n  }\n\n  var allRequests = [];\n  requestsById.forEach(function (value, key) {\n    allRequests.push(key);\n  });\n\n  var i = 0;\n\n  function nextBatch() {\n\n    if (i >= allRequests.length) {\n      return;\n    }\n\n    var upTo = Math.min(i + MAX_NUM_CONCURRENT_REQUESTS, allRequests.length);\n    var batch = allRequests.slice(i, upTo);\n    processBatch(batch, i);\n    i += batch.length;\n  }\n\n  function processBatch(batch, offset) {\n    batch.forEach(function (docId, j) {\n      var docIdx = offset + j;\n      var docRequests = requestsById.get(docId);\n\n      // just use the first request as the \"template\"\n      // TODO: The _bulk_get API allows for more subtle use cases than this,\n      // but for now it is unlikely that there will be a mix of different\n      // \"atts_since\" or \"attachments\" in the same request, since it's just\n      // replicate.js that is using this for the moment.\n      // Also, atts_since is aspirational, since we don't support it yet.\n      var docOpts = pick(docRequests[0], ['atts_since', 'attachments']);\n      docOpts.open_revs = docRequests.map(function (request) {\n        // rev is optional, open_revs disallowed\n        return request.rev;\n      });\n\n      // remove falsey / undefined revisions\n      docOpts.open_revs = docOpts.open_revs.filter(identityFunction);\n\n      var formatResult = identityFunction;\n\n      if (docOpts.open_revs.length === 0) {\n        delete docOpts.open_revs;\n\n        // when fetching only the \"winning\" leaf,\n        // transform the result so it looks like an open_revs\n        // request\n        formatResult = formatResultForOpenRevsGet;\n      }\n\n      // globally-supplied options\n      ['revs', 'attachments', 'binary', 'ajax', 'latest'].forEach(function (param) {\n        if (param in opts) {\n          docOpts[param] = opts[param];\n        }\n      });\n      db.get(docId, docOpts, function (err, res) {\n        var result;\n        /* istanbul ignore if */\n        if (err) {\n          result = [{error: err}];\n        } else {\n          result = formatResult(res);\n        }\n        gotResult(docIdx, docId, result);\n        nextBatch();\n      });\n    });\n  }\n\n  nextBatch();\n\n}\n\nvar hasLocal;\n\ntry {\n  localStorage.setItem('_pouch_check_localstorage', 1);\n  hasLocal = !!localStorage.getItem('_pouch_check_localstorage');\n} catch (e) {\n  hasLocal = false;\n}\n\nfunction hasLocalStorage() {\n  return hasLocal;\n}\n\n// Custom nextTick() shim for browsers. In node, this will just be process.nextTick(). We\n\ninherits(Changes, EventEmitter);\n\n/* istanbul ignore next */\nfunction attachBrowserEvents(self) {\n  if (hasLocalStorage()) {\n    addEventListener(\"storage\", function (e) {\n      self.emit(e.key);\n    });\n  }\n}\n\nfunction Changes() {\n  EventEmitter.call(this);\n  this._listeners = {};\n\n  attachBrowserEvents(this);\n}\nChanges.prototype.addListener = function (dbName, id, db, opts) {\n  /* istanbul ignore if */\n  if (this._listeners[id]) {\n    return;\n  }\n  var self = this;\n  var inprogress = false;\n  function eventFunction() {\n    /* istanbul ignore if */\n    if (!self._listeners[id]) {\n      return;\n    }\n    if (inprogress) {\n      inprogress = 'waiting';\n      return;\n    }\n    inprogress = true;\n    var changesOpts = pick(opts, [\n      'style', 'include_docs', 'attachments', 'conflicts', 'filter',\n      'doc_ids', 'view', 'since', 'query_params', 'binary', 'return_docs'\n    ]);\n\n    /* istanbul ignore next */\n    function onError() {\n      inprogress = false;\n    }\n\n    db.changes(changesOpts).on('change', function (c) {\n      if (c.seq > opts.since && !opts.cancelled) {\n        opts.since = c.seq;\n        opts.onChange(c);\n      }\n    }).on('complete', function () {\n      if (inprogress === 'waiting') {\n        immediate(eventFunction);\n      }\n      inprogress = false;\n    }).on('error', onError);\n  }\n  this._listeners[id] = eventFunction;\n  this.on(dbName, eventFunction);\n};\n\nChanges.prototype.removeListener = function (dbName, id) {\n  /* istanbul ignore if */\n  if (!(id in this._listeners)) {\n    return;\n  }\n  EventEmitter.prototype.removeListener.call(this, dbName,\n    this._listeners[id]);\n  delete this._listeners[id];\n};\n\n\n/* istanbul ignore next */\nChanges.prototype.notifyLocalWindows = function (dbName) {\n  //do a useless change on a storage thing\n  //in order to get other windows's listeners to activate\n  if (hasLocalStorage()) {\n    localStorage[dbName] = (localStorage[dbName] === \"a\") ? \"b\" : \"a\";\n  }\n};\n\nChanges.prototype.notify = function (dbName) {\n  this.emit(dbName);\n  this.notifyLocalWindows(dbName);\n};\n\nfunction guardedConsole(method) {\n  /* istanbul ignore else */\n  if (typeof console !== 'undefined' && typeof console[method] === 'function') {\n    var args = Array.prototype.slice.call(arguments, 1);\n    console[method].apply(console, args);\n  }\n}\n\nfunction randomNumber(min, max) {\n  var maxTimeout = 600000; // Hard-coded default of 10 minutes\n  min = parseInt(min, 10) || 0;\n  max = parseInt(max, 10);\n  if (max !== max || max <= min) {\n    max = (min || 1) << 1; //doubling\n  } else {\n    max = max + 1;\n  }\n  // In order to not exceed maxTimeout, pick a random value between half of maxTimeout and maxTimeout\n  if (max > maxTimeout) {\n    min = maxTimeout >> 1; // divide by two\n    max = maxTimeout;\n  }\n  var ratio = Math.random();\n  var range = max - min;\n\n  return ~~(range * ratio + min); // ~~ coerces to an int, but fast.\n}\n\nfunction defaultBackOff(min) {\n  var max = 0;\n  if (!min) {\n    max = 2000;\n  }\n  return randomNumber(min, max);\n}\n\n// designed to give info to browser users, who are disturbed\n// when they see http errors in the console\nfunction explainError(status, str) {\n  guardedConsole('info', 'The above ' + status + ' is totally normal. ' + str);\n}\n\nvar assign$1;\n{\n  if (typeof Object.assign === 'function') {\n    assign$1 = Object.assign;\n  } else {\n    // lite Object.assign polyfill based on\n    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign\n    assign$1 = function (target) {\n      var to = Object(target);\n\n      for (var index = 1; index < arguments.length; index++) {\n        var nextSource = arguments[index];\n\n        if (nextSource != null) { // Skip over if undefined or null\n          for (var nextKey in nextSource) {\n            // Avoid bugs when hasOwnProperty is shadowed\n            if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {\n              to[nextKey] = nextSource[nextKey];\n            }\n          }\n        }\n      }\n      return to;\n    };\n  }\n}\n\nvar assign$2 = assign$1;\n\nfunction tryFilter(filter, doc, req) {\n  try {\n    return !filter(doc, req);\n  } catch (err) {\n    var msg = 'Filter function threw: ' + err.toString();\n    return createError(BAD_REQUEST, msg);\n  }\n}\n\nfunction filterChange(opts) {\n  var req = {};\n  var hasFilter = opts.filter && typeof opts.filter === 'function';\n  req.query = opts.query_params;\n\n  return function filter(change) {\n    if (!change.doc) {\n      // CSG sends events on the changes feed that don't have documents,\n      // this hack makes a whole lot of existing code robust.\n      change.doc = {};\n    }\n\n    var filterReturn = hasFilter && tryFilter(opts.filter, change.doc, req);\n\n    if (typeof filterReturn === 'object') {\n      return filterReturn;\n    }\n\n    if (filterReturn) {\n      return false;\n    }\n\n    if (!opts.include_docs) {\n      delete change.doc;\n    } else if (!opts.attachments) {\n      for (var att in change.doc._attachments) {\n        /* istanbul ignore else */\n        if (Object.prototype.hasOwnProperty.call(change.doc._attachments, att)) {\n          change.doc._attachments[att].stub = true;\n        }\n      }\n    }\n    return true;\n  };\n}\n\nfunction flatten(arrs) {\n  var res = [];\n  for (var i = 0, len = arrs.length; i < len; i++) {\n    res = res.concat(arrs[i]);\n  }\n  return res;\n}\n\n// shim for Function.prototype.name,\n// for browsers that don't support it like IE\n\n/* istanbul ignore next */\nfunction f() {}\n\nvar hasName = f.name;\nvar res;\n\n// We dont run coverage in IE\n/* istanbul ignore else */\nif (hasName) {\n  res = function (fun) {\n    return fun.name;\n  };\n} else {\n  res = function (fun) {\n    var match = fun.toString().match(/^\\s*function\\s*(?:(\\S+)\\s*)?\\(/);\n    if (match && match[1]) {\n      return match[1];\n    }\n    else {\n      return '';\n    }\n  };\n}\n\nvar res$1 = res;\n\n// Determine id an ID is valid\n//   - invalid IDs begin with an underescore that does not begin '_design' or\n//     '_local'\n//   - any other string value is a valid id\n// Returns the specific error object for each case\nfunction invalidIdError(id) {\n  var err;\n  if (!id) {\n    err = createError(MISSING_ID);\n  } else if (typeof id !== 'string') {\n    err = createError(INVALID_ID);\n  } else if (/^_/.test(id) && !(/^_(design|local)/).test(id)) {\n    err = createError(RESERVED_ID);\n  }\n  if (err) {\n    throw err;\n  }\n}\n\n// Checks if a PouchDB object is \"remote\" or not. This is\n\nfunction isRemote(db) {\n  if (typeof db._remote === 'boolean') {\n    return db._remote;\n  }\n  /* istanbul ignore next */\n  if (typeof db.type === 'function') {\n    guardedConsole('warn',\n      'db.type() is deprecated and will be removed in ' +\n      'a future version of PouchDB');\n    return db.type() === 'http';\n  }\n  /* istanbul ignore next */\n  return false;\n}\n\nfunction listenerCount(ee, type) {\n  return 'listenerCount' in ee ? ee.listenerCount(type) :\n                                 EventEmitter.listenerCount(ee, type);\n}\n\nfunction parseDesignDocFunctionName(s) {\n  if (!s) {\n    return null;\n  }\n  var parts = s.split('/');\n  if (parts.length === 2) {\n    return parts;\n  }\n  if (parts.length === 1) {\n    return [s, s];\n  }\n  return null;\n}\n\nfunction normalizeDesignDocFunctionName(s) {\n  var normalized = parseDesignDocFunctionName(s);\n  return normalized ? normalized.join('/') : null;\n}\n\n// originally parseUri 1.2.2, now patched by us\n// (c) Steven Levithan <stevenlevithan.com>\n// MIT License\nvar keys = [\"source\", \"protocol\", \"authority\", \"userInfo\", \"user\", \"password\",\n    \"host\", \"port\", \"relative\", \"path\", \"directory\", \"file\", \"query\", \"anchor\"];\nvar qName =\"queryKey\";\nvar qParser = /(?:^|&)([^&=]*)=?([^&]*)/g;\n\n// use the \"loose\" parser\n/* eslint no-useless-escape: 0 */\nvar parser = /^(?:(?![^:@]+:[^:@\\/]*@)([^:\\/?#.]+):)?(?:\\/\\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\\/?#]*)(?::(\\d*))?)(((\\/(?:[^?#](?![^?#\\/]*\\.[^?#\\/.]+(?:[?#]|$)))*\\/?)?([^?#\\/]*))(?:\\?([^#]*))?(?:#(.*))?)/;\n\nfunction parseUri(str) {\n  var m = parser.exec(str);\n  var uri = {};\n  var i = 14;\n\n  while (i--) {\n    var key = keys[i];\n    var value = m[i] || \"\";\n    var encoded = ['user', 'password'].indexOf(key) !== -1;\n    uri[key] = encoded ? decodeURIComponent(value) : value;\n  }\n\n  uri[qName] = {};\n  uri[keys[12]].replace(qParser, function ($0, $1, $2) {\n    if ($1) {\n      uri[qName][$1] = $2;\n    }\n  });\n\n  return uri;\n}\n\n// Based on https://github.com/alexdavid/scope-eval v0.0.3\n// (source: https://unpkg.com/scope-eval@0.0.3/scope_eval.js)\n// This is basically just a wrapper around new Function()\n\nfunction scopeEval(source, scope) {\n  var keys = [];\n  var values = [];\n  for (var key in scope) {\n    if (Object.prototype.hasOwnProperty.call(scope, key)) {\n      keys.push(key);\n      values.push(scope[key]);\n    }\n  }\n  keys.push(source);\n  return Function.apply(null, keys).apply(null, values);\n}\n\n// this is essentially the \"update sugar\" function from daleharvey/pouchdb#1388\n// the diffFun tells us what delta to apply to the doc.  it either returns\n// the doc, or false if it doesn't need to do an update after all\nfunction upsert(db, docId, diffFun) {\n  return db.get(docId)\n    .catch(function (err) {\n      /* istanbul ignore next */\n      if (err.status !== 404) {\n        throw err;\n      }\n      return {};\n    })\n    .then(function (doc) {\n      // the user might change the _rev, so save it for posterity\n      var docRev = doc._rev;\n      var newDoc = diffFun(doc);\n\n      if (!newDoc) {\n        // if the diffFun returns falsy, we short-circuit as\n        // an optimization\n        return {updated: false, rev: docRev};\n      }\n\n      // users aren't allowed to modify these values,\n      // so reset them here\n      newDoc._id = docId;\n      newDoc._rev = docRev;\n      return tryAndPut(db, newDoc, diffFun);\n    });\n}\n\nfunction tryAndPut(db, doc, diffFun) {\n  return db.put(doc).then(function (res) {\n    return {\n      updated: true,\n      rev: res.rev\n    };\n  }, function (err) {\n    /* istanbul ignore next */\n    if (err.status !== 409) {\n      throw err;\n    }\n    return upsert(db, doc._id, diffFun);\n  });\n}\n\n/**\n * Creates a new revision string that does NOT include the revision height\n * For example '56649f1b0506c6ca9fda0746eb0cacdf'\n */\nfunction rev(doc, deterministic_revs) {\n  if (!deterministic_revs) {\n    return v4().replace(/-/g, '').toLowerCase();\n  }\n\n  var mutateableDoc = assign({}, doc);\n  delete mutateableDoc._rev_tree;\n  return stringMd5(JSON.stringify(mutateableDoc));\n}\n\nvar uuid = v4; // mimic old import, only v4 is ever used elsewhere\n\nexport { adapterFun, assign$2 as assign, bulkGet as bulkGetShim, Changes as changesHandler, clone, defaultBackOff, explainError, filterChange, flatten, res$1 as functionName, guardedConsole, hasLocalStorage, invalidIdError, isRemote, listenerCount, immediate as nextTick, normalizeDesignDocFunctionName as normalizeDdocFunctionName, once, parseDesignDocFunctionName as parseDdocFunctionName, parseUri, pick, rev, scopeEval, toPromise, upsert, uuid };\n","import { Set } from 'pouchdb-collections';\nimport argsarray from 'argsarray';\nimport { nextTick } from 'pouchdb-utils';\nimport inherits from 'inherits';\n\nfunction QueryParseError(message) {\n  this.status = 400;\n  this.name = 'query_parse_error';\n  this.message = message;\n  this.error = true;\n  try {\n    Error.captureStackTrace(this, QueryParseError);\n  } catch (e) {}\n}\n\ninherits(QueryParseError, Error);\n\nfunction NotFoundError(message) {\n  this.status = 404;\n  this.name = 'not_found';\n  this.message = message;\n  this.error = true;\n  try {\n    Error.captureStackTrace(this, NotFoundError);\n  } catch (e) {}\n}\n\ninherits(NotFoundError, Error);\n\nfunction BuiltInError(message) {\n  this.status = 500;\n  this.name = 'invalid_value';\n  this.message = message;\n  this.error = true;\n  try {\n    Error.captureStackTrace(this, BuiltInError);\n  } catch (e) {}\n}\n\ninherits(BuiltInError, Error);\n\nfunction promisedCallback(promise, callback) {\n  if (callback) {\n    promise.then(function (res) {\n      nextTick(function () {\n        callback(null, res);\n      });\n    }, function (reason) {\n      nextTick(function () {\n        callback(reason);\n      });\n    });\n  }\n  return promise;\n}\n\nfunction callbackify(fun) {\n  return argsarray(function (args) {\n    var cb = args.pop();\n    var promise = fun.apply(this, args);\n    if (typeof cb === 'function') {\n      promisedCallback(promise, cb);\n    }\n    return promise;\n  });\n}\n\n// Promise finally util similar to Q.finally\nfunction fin(promise, finalPromiseFactory) {\n  return promise.then(function (res) {\n    return finalPromiseFactory().then(function () {\n      return res;\n    });\n  }, function (reason) {\n    return finalPromiseFactory().then(function () {\n      throw reason;\n    });\n  });\n}\n\nfunction sequentialize(queue, promiseFactory) {\n  return function () {\n    var args = arguments;\n    var that = this;\n    return queue.add(function () {\n      return promiseFactory.apply(that, args);\n    });\n  };\n}\n\n// uniq an array of strings, order not guaranteed\n// similar to underscore/lodash _.uniq\nfunction uniq(arr) {\n  var theSet = new Set(arr);\n  var result = new Array(theSet.size);\n  var index = -1;\n  theSet.forEach(function (value) {\n    result[++index] = value;\n  });\n  return result;\n}\n\nfunction mapToKeysArray(map) {\n  var result = new Array(map.size);\n  var index = -1;\n  map.forEach(function (value, key) {\n    result[++index] = key;\n  });\n  return result;\n}\n\nexport { uniq, sequentialize, fin, callbackify, promisedCallback, mapToKeysArray, QueryParseError, NotFoundError, BuiltInError };\n","import { Set, Map } from 'pouchdb-collections';\nimport { base64StringToBlobOrBuffer } from 'pouchdb-binary-utils';\nimport { collate, toIndexableString, normalizeKey, parseIndexableString } from 'pouchdb-collate';\nimport { generateErrorFromResponse } from 'pouchdb-errors';\nimport { Headers } from 'pouchdb-fetch';\nimport { upsert, flatten, guardedConsole, nextTick, isRemote } from 'pouchdb-utils';\nimport { stringMd5 } from 'pouchdb-md5';\nimport { callbackify, sequentialize, uniq, fin, promisedCallback, mapToKeysArray, QueryParseError, NotFoundError, BuiltInError } from 'pouchdb-mapreduce-utils';\n\n/*\n * Simple task queue to sequentialize actions. Assumes\n * callbacks will eventually fire (once).\n */\n\n\nfunction TaskQueue() {\n  this.promise = new Promise(function (fulfill) {fulfill(); });\n}\nTaskQueue.prototype.add = function (promiseFactory) {\n  this.promise = this.promise.catch(function () {\n    // just recover\n  }).then(function () {\n    return promiseFactory();\n  });\n  return this.promise;\n};\nTaskQueue.prototype.finish = function () {\n  return this.promise;\n};\n\nfunction stringify(input) {\n  if (!input) {\n    return 'undefined'; // backwards compat for empty reduce\n  }\n  // for backwards compat with mapreduce, functions/strings are stringified\n  // as-is. everything else is JSON-stringified.\n  switch (typeof input) {\n    case 'function':\n      // e.g. a mapreduce map\n      return input.toString();\n    case 'string':\n      // e.g. a mapreduce built-in _reduce function\n      return input.toString();\n    default:\n      // e.g. a JSON object in the case of mango queries\n      return JSON.stringify(input);\n  }\n}\n\n/* create a string signature for a view so we can cache it and uniq it */\nfunction createViewSignature(mapFun, reduceFun) {\n  // the \"undefined\" part is for backwards compatibility\n  return stringify(mapFun) + stringify(reduceFun) + 'undefined';\n}\n\nfunction createView(sourceDB, viewName, mapFun, reduceFun, temporary, localDocName) {\n  var viewSignature = createViewSignature(mapFun, reduceFun);\n\n  var cachedViews;\n  if (!temporary) {\n    // cache this to ensure we don't try to update the same view twice\n    cachedViews = sourceDB._cachedViews = sourceDB._cachedViews || {};\n    if (cachedViews[viewSignature]) {\n      return cachedViews[viewSignature];\n    }\n  }\n\n  var promiseForView = sourceDB.info().then(function (info) {\n\n    var depDbName = info.db_name + '-mrview-' +\n      (temporary ? 'temp' : stringMd5(viewSignature));\n\n    // save the view name in the source db so it can be cleaned up if necessary\n    // (e.g. when the _design doc is deleted, remove all associated view data)\n    function diffFunction(doc) {\n      doc.views = doc.views || {};\n      var fullViewName = viewName;\n      if (fullViewName.indexOf('/') === -1) {\n        fullViewName = viewName + '/' + viewName;\n      }\n      var depDbs = doc.views[fullViewName] = doc.views[fullViewName] || {};\n      /* istanbul ignore if */\n      if (depDbs[depDbName]) {\n        return; // no update necessary\n      }\n      depDbs[depDbName] = true;\n      return doc;\n    }\n    return upsert(sourceDB, '_local/' + localDocName, diffFunction).then(function () {\n      return sourceDB.registerDependentDatabase(depDbName).then(function (res) {\n        var db = res.db;\n        db.auto_compaction = true;\n        var view = {\n          name: depDbName,\n          db: db,\n          sourceDB: sourceDB,\n          adapter: sourceDB.adapter,\n          mapFun: mapFun,\n          reduceFun: reduceFun\n        };\n        return view.db.get('_local/lastSeq').catch(function (err) {\n          /* istanbul ignore if */\n          if (err.status !== 404) {\n            throw err;\n          }\n        }).then(function (lastSeqDoc) {\n          view.seq = lastSeqDoc ? lastSeqDoc.seq : 0;\n          if (cachedViews) {\n            view.db.once('destroyed', function () {\n              delete cachedViews[viewSignature];\n            });\n          }\n          return view;\n        });\n      });\n    });\n  });\n\n  if (cachedViews) {\n    cachedViews[viewSignature] = promiseForView;\n  }\n  return promiseForView;\n}\n\nvar persistentQueues = {};\nvar tempViewQueue = new TaskQueue();\nvar CHANGES_BATCH_SIZE = 50;\n\nfunction parseViewName(name) {\n  // can be either 'ddocname/viewname' or just 'viewname'\n  // (where the ddoc name is the same)\n  return name.indexOf('/') === -1 ? [name, name] : name.split('/');\n}\n\nfunction isGenOne(changes) {\n  // only return true if the current change is 1-\n  // and there are no other leafs\n  return changes.length === 1 && /^1-/.test(changes[0].rev);\n}\n\nfunction emitError(db, e, data) {\n  try {\n    db.emit('error', e);\n  } catch (err) {\n    guardedConsole('error',\n      'The user\\'s map/reduce function threw an uncaught error.\\n' +\n      'You can debug this error by doing:\\n' +\n      'myDatabase.on(\\'error\\', function (err) { debugger; });\\n' +\n      'Please double-check your map/reduce function.');\n    guardedConsole('error', e, data);\n  }\n}\n\n/**\n * Returns an \"abstract\" mapreduce object of the form:\n *\n *   {\n *     query: queryFun,\n *     viewCleanup: viewCleanupFun\n *   }\n *\n * Arguments are:\n *\n * localDoc: string\n *   This is for the local doc that gets saved in order to track the\n *   \"dependent\" DBs and clean them up for viewCleanup. It should be\n *   unique, so that indexer plugins don't collide with each other.\n * mapper: function (mapFunDef, emit)\n *   Returns a map function based on the mapFunDef, which in the case of\n *   normal map/reduce is just the de-stringified function, but may be\n *   something else, such as an object in the case of pouchdb-find.\n * reducer: function (reduceFunDef)\n *   Ditto, but for reducing. Modules don't have to support reducing\n *   (e.g. pouchdb-find).\n * ddocValidator: function (ddoc, viewName)\n *   Throws an error if the ddoc or viewName is not valid.\n *   This could be a way to communicate to the user that the configuration for the\n *   indexer is invalid.\n */\nfunction createAbstractMapReduce(localDocName, mapper, reducer, ddocValidator) {\n\n  function tryMap(db, fun, doc) {\n    // emit an event if there was an error thrown by a map function.\n    // putting try/catches in a single function also avoids deoptimizations.\n    try {\n      fun(doc);\n    } catch (e) {\n      emitError(db, e, {fun: fun, doc: doc});\n    }\n  }\n\n  function tryReduce(db, fun, keys, values, rereduce) {\n    // same as above, but returning the result or an error. there are two separate\n    // functions to avoid extra memory allocations since the tryCode() case is used\n    // for custom map functions (common) vs this function, which is only used for\n    // custom reduce functions (rare)\n    try {\n      return {output : fun(keys, values, rereduce)};\n    } catch (e) {\n      emitError(db, e, {fun: fun, keys: keys, values: values, rereduce: rereduce});\n      return {error: e};\n    }\n  }\n\n  function sortByKeyThenValue(x, y) {\n    var keyCompare = collate(x.key, y.key);\n    return keyCompare !== 0 ? keyCompare : collate(x.value, y.value);\n  }\n\n  function sliceResults(results, limit, skip) {\n    skip = skip || 0;\n    if (typeof limit === 'number') {\n      return results.slice(skip, limit + skip);\n    } else if (skip > 0) {\n      return results.slice(skip);\n    }\n    return results;\n  }\n\n  function rowToDocId(row) {\n    var val = row.value;\n    // Users can explicitly specify a joined doc _id, or it\n    // defaults to the doc _id that emitted the key/value.\n    var docId = (val && typeof val === 'object' && val._id) || row.id;\n    return docId;\n  }\n\n  function readAttachmentsAsBlobOrBuffer(res) {\n    res.rows.forEach(function (row) {\n      var atts = row.doc && row.doc._attachments;\n      if (!atts) {\n        return;\n      }\n      Object.keys(atts).forEach(function (filename) {\n        var att = atts[filename];\n        atts[filename].data = base64StringToBlobOrBuffer(att.data, att.content_type);\n      });\n    });\n  }\n\n  function postprocessAttachments(opts) {\n    return function (res) {\n      if (opts.include_docs && opts.attachments && opts.binary) {\n        readAttachmentsAsBlobOrBuffer(res);\n      }\n      return res;\n    };\n  }\n\n  function addHttpParam(paramName, opts, params, asJson) {\n    // add an http param from opts to params, optionally json-encoded\n    var val = opts[paramName];\n    if (typeof val !== 'undefined') {\n      if (asJson) {\n        val = encodeURIComponent(JSON.stringify(val));\n      }\n      params.push(paramName + '=' + val);\n    }\n  }\n\n  function coerceInteger(integerCandidate) {\n    if (typeof integerCandidate !== 'undefined') {\n      var asNumber = Number(integerCandidate);\n      // prevents e.g. '1foo' or '1.1' being coerced to 1\n      if (!isNaN(asNumber) && asNumber === parseInt(integerCandidate, 10)) {\n        return asNumber;\n      } else {\n        return integerCandidate;\n      }\n    }\n  }\n\n  function coerceOptions(opts) {\n    opts.group_level = coerceInteger(opts.group_level);\n    opts.limit = coerceInteger(opts.limit);\n    opts.skip = coerceInteger(opts.skip);\n    return opts;\n  }\n\n  function checkPositiveInteger(number) {\n    if (number) {\n      if (typeof number !== 'number') {\n        return  new QueryParseError('Invalid value for integer: \"' +\n          number + '\"');\n      }\n      if (number < 0) {\n        return new QueryParseError('Invalid value for positive integer: ' +\n          '\"' + number + '\"');\n      }\n    }\n  }\n\n  function checkQueryParseError(options, fun) {\n    var startkeyName = options.descending ? 'endkey' : 'startkey';\n    var endkeyName = options.descending ? 'startkey' : 'endkey';\n\n    if (typeof options[startkeyName] !== 'undefined' &&\n      typeof options[endkeyName] !== 'undefined' &&\n      collate(options[startkeyName], options[endkeyName]) > 0) {\n      throw new QueryParseError('No rows can match your key range, ' +\n        'reverse your start_key and end_key or set {descending : true}');\n    } else if (fun.reduce && options.reduce !== false) {\n      if (options.include_docs) {\n        throw new QueryParseError('{include_docs:true} is invalid for reduce');\n      } else if (options.keys && options.keys.length > 1 &&\n        !options.group && !options.group_level) {\n        throw new QueryParseError('Multi-key fetches for reduce views must use ' +\n          '{group: true}');\n      }\n    }\n    ['group_level', 'limit', 'skip'].forEach(function (optionName) {\n      var error = checkPositiveInteger(options[optionName]);\n      if (error) {\n        throw error;\n      }\n    });\n  }\n\n  function httpQuery(db, fun, opts) {\n    // List of parameters to add to the PUT request\n    var params = [];\n    var body;\n    var method = 'GET';\n    var ok, status;\n\n    // If opts.reduce exists and is defined, then add it to the list\n    // of parameters.\n    // If reduce=false then the results are that of only the map function\n    // not the final result of map and reduce.\n    addHttpParam('reduce', opts, params);\n    addHttpParam('include_docs', opts, params);\n    addHttpParam('attachments', opts, params);\n    addHttpParam('limit', opts, params);\n    addHttpParam('descending', opts, params);\n    addHttpParam('group', opts, params);\n    addHttpParam('group_level', opts, params);\n    addHttpParam('skip', opts, params);\n    addHttpParam('stale', opts, params);\n    addHttpParam('conflicts', opts, params);\n    addHttpParam('startkey', opts, params, true);\n    addHttpParam('start_key', opts, params, true);\n    addHttpParam('endkey', opts, params, true);\n    addHttpParam('end_key', opts, params, true);\n    addHttpParam('inclusive_end', opts, params);\n    addHttpParam('key', opts, params, true);\n    addHttpParam('update_seq', opts, params);\n\n    // Format the list of parameters into a valid URI query string\n    params = params.join('&');\n    params = params === '' ? '' : '?' + params;\n\n    // If keys are supplied, issue a POST to circumvent GET query string limits\n    // see http://wiki.apache.org/couchdb/HTTP_view_API#Querying_Options\n    if (typeof opts.keys !== 'undefined') {\n      var MAX_URL_LENGTH = 2000;\n      // according to http://stackoverflow.com/a/417184/680742,\n      // the de facto URL length limit is 2000 characters\n\n      var keysAsString =\n        'keys=' + encodeURIComponent(JSON.stringify(opts.keys));\n      if (keysAsString.length + params.length + 1 <= MAX_URL_LENGTH) {\n        // If the keys are short enough, do a GET. we do this to work around\n        // Safari not understanding 304s on POSTs (see pouchdb/pouchdb#1239)\n        params += (params[0] === '?' ? '&' : '?') + keysAsString;\n      } else {\n        method = 'POST';\n        if (typeof fun === 'string') {\n          body = {keys: opts.keys};\n        } else { // fun is {map : mapfun}, so append to this\n          fun.keys = opts.keys;\n        }\n      }\n    }\n\n    // We are referencing a query defined in the design doc\n    if (typeof fun === 'string') {\n      var parts = parseViewName(fun);\n      return db.fetch('_design/' + parts[0] + '/_view/' + parts[1] + params, {\n        headers: new Headers({'Content-Type': 'application/json'}),\n        method: method,\n        body: JSON.stringify(body)\n      }).then(function (response) {\n        ok = response.ok;\n        status = response.status;\n        return response.json();\n      }).then(function (result) {\n        if (!ok) {\n          result.status = status;\n          throw generateErrorFromResponse(result);\n        }\n        // fail the entire request if the result contains an error\n        result.rows.forEach(function (row) {\n          /* istanbul ignore if */\n          if (row.value && row.value.error && row.value.error === \"builtin_reduce_error\") {\n            throw new Error(row.reason);\n          }\n        });\n        return result;\n      }).then(postprocessAttachments(opts));\n    }\n\n    // We are using a temporary view, terrible for performance, good for testing\n    body = body || {};\n    Object.keys(fun).forEach(function (key) {\n      if (Array.isArray(fun[key])) {\n        body[key] = fun[key];\n      } else {\n        body[key] = fun[key].toString();\n      }\n    });\n\n    return db.fetch('_temp_view' + params, {\n      headers: new Headers({'Content-Type': 'application/json'}),\n      method: 'POST',\n      body: JSON.stringify(body)\n    }).then(function (response) {\n        ok = response.ok;\n        status = response.status;\n      return response.json();\n    }).then(function (result) {\n      if (!ok) {\n        result.status = status;\n        throw generateErrorFromResponse(result);\n      }\n      return result;\n    }).then(postprocessAttachments(opts));\n  }\n\n  // custom adapters can define their own api._query\n  // and override the default behavior\n  /* istanbul ignore next */\n  function customQuery(db, fun, opts) {\n    return new Promise(function (resolve, reject) {\n      db._query(fun, opts, function (err, res) {\n        if (err) {\n          return reject(err);\n        }\n        resolve(res);\n      });\n    });\n  }\n\n  // custom adapters can define their own api._viewCleanup\n  // and override the default behavior\n  /* istanbul ignore next */\n  function customViewCleanup(db) {\n    return new Promise(function (resolve, reject) {\n      db._viewCleanup(function (err, res) {\n        if (err) {\n          return reject(err);\n        }\n        resolve(res);\n      });\n    });\n  }\n\n  function defaultsTo(value) {\n    return function (reason) {\n      /* istanbul ignore else */\n      if (reason.status === 404) {\n        return value;\n      } else {\n        throw reason;\n      }\n    };\n  }\n\n  // returns a promise for a list of docs to update, based on the input docId.\n  // the order doesn't matter, because post-3.2.0, bulkDocs\n  // is an atomic operation in all three adapters.\n  function getDocsToPersist(docId, view, docIdsToChangesAndEmits) {\n    var metaDocId = '_local/doc_' + docId;\n    var defaultMetaDoc = {_id: metaDocId, keys: []};\n    var docData = docIdsToChangesAndEmits.get(docId);\n    var indexableKeysToKeyValues = docData[0];\n    var changes = docData[1];\n\n    function getMetaDoc() {\n      if (isGenOne(changes)) {\n        // generation 1, so we can safely assume initial state\n        // for performance reasons (avoids unnecessary GETs)\n        return Promise.resolve(defaultMetaDoc);\n      }\n      return view.db.get(metaDocId).catch(defaultsTo(defaultMetaDoc));\n    }\n\n    function getKeyValueDocs(metaDoc) {\n      if (!metaDoc.keys.length) {\n        // no keys, no need for a lookup\n        return Promise.resolve({rows: []});\n      }\n      return view.db.allDocs({\n        keys: metaDoc.keys,\n        include_docs: true\n      });\n    }\n\n    function processKeyValueDocs(metaDoc, kvDocsRes) {\n      var kvDocs = [];\n      var oldKeys = new Set();\n\n      for (var i = 0, len = kvDocsRes.rows.length; i < len; i++) {\n        var row = kvDocsRes.rows[i];\n        var doc = row.doc;\n        if (!doc) { // deleted\n          continue;\n        }\n        kvDocs.push(doc);\n        oldKeys.add(doc._id);\n        doc._deleted = !indexableKeysToKeyValues.has(doc._id);\n        if (!doc._deleted) {\n          var keyValue = indexableKeysToKeyValues.get(doc._id);\n          if ('value' in keyValue) {\n            doc.value = keyValue.value;\n          }\n        }\n      }\n      var newKeys = mapToKeysArray(indexableKeysToKeyValues);\n      newKeys.forEach(function (key) {\n        if (!oldKeys.has(key)) {\n          // new doc\n          var kvDoc = {\n            _id: key\n          };\n          var keyValue = indexableKeysToKeyValues.get(key);\n          if ('value' in keyValue) {\n            kvDoc.value = keyValue.value;\n          }\n          kvDocs.push(kvDoc);\n        }\n      });\n      metaDoc.keys = uniq(newKeys.concat(metaDoc.keys));\n      kvDocs.push(metaDoc);\n\n      return kvDocs;\n    }\n\n    return getMetaDoc().then(function (metaDoc) {\n      return getKeyValueDocs(metaDoc).then(function (kvDocsRes) {\n        return processKeyValueDocs(metaDoc, kvDocsRes);\n      });\n    });\n  }\n\n  // updates all emitted key/value docs and metaDocs in the mrview database\n  // for the given batch of documents from the source database\n  function saveKeyValues(view, docIdsToChangesAndEmits, seq) {\n    var seqDocId = '_local/lastSeq';\n    return view.db.get(seqDocId)\n      .catch(defaultsTo({_id: seqDocId, seq: 0}))\n      .then(function (lastSeqDoc) {\n        var docIds = mapToKeysArray(docIdsToChangesAndEmits);\n        return Promise.all(docIds.map(function (docId) {\n          return getDocsToPersist(docId, view, docIdsToChangesAndEmits);\n        })).then(function (listOfDocsToPersist) {\n          var docsToPersist = flatten(listOfDocsToPersist);\n          lastSeqDoc.seq = seq;\n          docsToPersist.push(lastSeqDoc);\n          // write all docs in a single operation, update the seq once\n          return view.db.bulkDocs({docs : docsToPersist});\n        });\n      });\n  }\n\n  function getQueue(view) {\n    var viewName = typeof view === 'string' ? view : view.name;\n    var queue = persistentQueues[viewName];\n    if (!queue) {\n      queue = persistentQueues[viewName] = new TaskQueue();\n    }\n    return queue;\n  }\n\n  function updateView(view, opts) {\n    return sequentialize(getQueue(view), function () {\n      return updateViewInQueue(view, opts);\n    })();\n  }\n\n  function updateViewInQueue(view, opts) {\n    // bind the emit function once\n    var mapResults;\n    var doc;\n\n    function emit(key, value) {\n      var output = {id: doc._id, key: normalizeKey(key)};\n      // Don't explicitly store the value unless it's defined and non-null.\n      // This saves on storage space, because often people don't use it.\n      if (typeof value !== 'undefined' && value !== null) {\n        output.value = normalizeKey(value);\n      }\n      mapResults.push(output);\n    }\n\n    var mapFun = mapper(view.mapFun, emit);\n\n    var currentSeq = view.seq || 0;\n\n    function processChange(docIdsToChangesAndEmits, seq) {\n      return function () {\n        return saveKeyValues(view, docIdsToChangesAndEmits, seq);\n      };\n    }\n\n    let indexed_docs = 0;\n    let progress = {\n      view: view.name,\n      indexed_docs: indexed_docs\n    };\n    view.sourceDB.emit('indexing', progress);\n\n    var queue = new TaskQueue();\n\n    function processNextBatch() {\n      return view.sourceDB.changes({\n        return_docs: true,\n        conflicts: true,\n        include_docs: true,\n        style: 'all_docs',\n        since: currentSeq,\n        limit: opts.changes_batch_size\n      }).then(processBatch);\n    }\n\n    function processBatch(response) {\n      var results = response.results;\n      if (!results.length) {\n        return;\n      }\n      var docIdsToChangesAndEmits = createDocIdsToChangesAndEmits(results);\n      queue.add(processChange(docIdsToChangesAndEmits, currentSeq));\n\n      indexed_docs = indexed_docs + results.length;\n      let progress = {\n        view: view.name,\n        last_seq: response.last_seq,\n        results_count: results.length,\n        indexed_docs: indexed_docs\n      };\n      view.sourceDB.emit('indexing', progress);\n      \n      if (results.length < opts.changes_batch_size) {\n        return;\n      }\n      return processNextBatch();\n    }\n\n    function createDocIdsToChangesAndEmits(results) {\n      var docIdsToChangesAndEmits = new Map();\n      for (var i = 0, len = results.length; i < len; i++) {\n        var change = results[i];\n        if (change.doc._id[0] !== '_') {\n          mapResults = [];\n          doc = change.doc;\n\n          if (!doc._deleted) {\n            tryMap(view.sourceDB, mapFun, doc);\n          }\n          mapResults.sort(sortByKeyThenValue);\n\n          var indexableKeysToKeyValues = createIndexableKeysToKeyValues(mapResults);\n          docIdsToChangesAndEmits.set(change.doc._id, [\n            indexableKeysToKeyValues,\n            change.changes\n          ]);\n        }\n        currentSeq = change.seq;\n      }\n      return docIdsToChangesAndEmits;\n    }\n\n    function createIndexableKeysToKeyValues(mapResults) {\n      var indexableKeysToKeyValues = new Map();\n      var lastKey;\n      for (var i = 0, len = mapResults.length; i < len; i++) {\n        var emittedKeyValue = mapResults[i];\n        var complexKey = [emittedKeyValue.key, emittedKeyValue.id];\n        if (i > 0 && collate(emittedKeyValue.key, lastKey) === 0) {\n          complexKey.push(i); // dup key+id, so make it unique\n        }\n        indexableKeysToKeyValues.set(toIndexableString(complexKey), emittedKeyValue);\n        lastKey = emittedKeyValue.key;\n      }\n      return indexableKeysToKeyValues;\n    }\n\n    return processNextBatch().then(function () {\n      return queue.finish();\n    }).then(function () {\n      view.seq = currentSeq;\n    });\n  }\n\n  function reduceView(view, results, options) {\n    if (options.group_level === 0) {\n      delete options.group_level;\n    }\n\n    var shouldGroup = options.group || options.group_level;\n\n    var reduceFun = reducer(view.reduceFun);\n\n    var groups = [];\n    var lvl = isNaN(options.group_level) ? Number.POSITIVE_INFINITY :\n      options.group_level;\n    results.forEach(function (e) {\n      var last = groups[groups.length - 1];\n      var groupKey = shouldGroup ? e.key : null;\n\n      // only set group_level for array keys\n      if (shouldGroup && Array.isArray(groupKey)) {\n        groupKey = groupKey.slice(0, lvl);\n      }\n\n      if (last && collate(last.groupKey, groupKey) === 0) {\n        last.keys.push([e.key, e.id]);\n        last.values.push(e.value);\n        return;\n      }\n      groups.push({\n        keys: [[e.key, e.id]],\n        values: [e.value],\n        groupKey: groupKey\n      });\n    });\n    results = [];\n    for (var i = 0, len = groups.length; i < len; i++) {\n      var e = groups[i];\n      var reduceTry = tryReduce(view.sourceDB, reduceFun, e.keys, e.values, false);\n      if (reduceTry.error && reduceTry.error instanceof BuiltInError) {\n        // CouchDB returns an error if a built-in errors out\n        throw reduceTry.error;\n      }\n      results.push({\n        // CouchDB just sets the value to null if a non-built-in errors out\n        value: reduceTry.error ? null : reduceTry.output,\n        key: e.groupKey\n      });\n    }\n    // no total_rows/offset when reducing\n    return {rows: sliceResults(results, options.limit, options.skip)};\n  }\n\n  function queryView(view, opts) {\n    return sequentialize(getQueue(view), function () {\n      return queryViewInQueue(view, opts);\n    })();\n  }\n\n  function queryViewInQueue(view, opts) {\n    var totalRows;\n    var shouldReduce = view.reduceFun && opts.reduce !== false;\n    var skip = opts.skip || 0;\n    if (typeof opts.keys !== 'undefined' && !opts.keys.length) {\n      // equivalent query\n      opts.limit = 0;\n      delete opts.keys;\n    }\n\n    function fetchFromView(viewOpts) {\n      viewOpts.include_docs = true;\n      return view.db.allDocs(viewOpts).then(function (res) {\n        totalRows = res.total_rows;\n        return res.rows.map(function (result) {\n\n          // implicit migration - in older versions of PouchDB,\n          // we explicitly stored the doc as {id: ..., key: ..., value: ...}\n          // this is tested in a migration test\n          /* istanbul ignore next */\n          if ('value' in result.doc && typeof result.doc.value === 'object' &&\n            result.doc.value !== null) {\n            var keys = Object.keys(result.doc.value).sort();\n            // this detection method is not perfect, but it's unlikely the user\n            // emitted a value which was an object with these 3 exact keys\n            var expectedKeys = ['id', 'key', 'value'];\n            if (!(keys < expectedKeys || keys > expectedKeys)) {\n              return result.doc.value;\n            }\n          }\n\n          var parsedKeyAndDocId = parseIndexableString(result.doc._id);\n          return {\n            key: parsedKeyAndDocId[0],\n            id: parsedKeyAndDocId[1],\n            value: ('value' in result.doc ? result.doc.value : null)\n          };\n        });\n      });\n    }\n\n    function onMapResultsReady(rows) {\n      var finalResults;\n      if (shouldReduce) {\n        finalResults = reduceView(view, rows, opts);\n      } else if (typeof opts.keys === 'undefined') {\n        finalResults = {\n          total_rows: totalRows,\n          offset: skip,\n          rows: rows\n        };\n      } else {\n        // support limit, skip for keys query\n        finalResults = {\n          total_rows: totalRows,\n          offset: skip,\n          rows: sliceResults(rows,opts.limit,opts.skip)\n        };\n      }\n      /* istanbul ignore if */\n      if (opts.update_seq) {\n        finalResults.update_seq = view.seq;\n      }\n      if (opts.include_docs) {\n        var docIds = uniq(rows.map(rowToDocId));\n\n        return view.sourceDB.allDocs({\n          keys: docIds,\n          include_docs: true,\n          conflicts: opts.conflicts,\n          attachments: opts.attachments,\n          binary: opts.binary\n        }).then(function (allDocsRes) {\n          var docIdsToDocs = new Map();\n          allDocsRes.rows.forEach(function (row) {\n            docIdsToDocs.set(row.id, row.doc);\n          });\n          rows.forEach(function (row) {\n            var docId = rowToDocId(row);\n            var doc = docIdsToDocs.get(docId);\n            if (doc) {\n              row.doc = doc;\n            }\n          });\n          return finalResults;\n        });\n      } else {\n        return finalResults;\n      }\n    }\n\n    if (typeof opts.keys !== 'undefined') {\n      var keys = opts.keys;\n      var fetchPromises = keys.map(function (key) {\n        var viewOpts = {\n          startkey : toIndexableString([key]),\n          endkey   : toIndexableString([key, {}])\n        };\n        /* istanbul ignore if */\n        if (opts.update_seq) {\n          viewOpts.update_seq = true;\n        }\n        return fetchFromView(viewOpts);\n      });\n      return Promise.all(fetchPromises).then(flatten).then(onMapResultsReady);\n    } else { // normal query, no 'keys'\n      var viewOpts = {\n        descending : opts.descending\n      };\n      /* istanbul ignore if */\n      if (opts.update_seq) {\n        viewOpts.update_seq = true;\n      }\n      var startkey;\n      var endkey;\n      if ('start_key' in opts) {\n        startkey = opts.start_key;\n      }\n      if ('startkey' in opts) {\n        startkey = opts.startkey;\n      }\n      if ('end_key' in opts) {\n        endkey = opts.end_key;\n      }\n      if ('endkey' in opts) {\n        endkey = opts.endkey;\n      }\n      if (typeof startkey !== 'undefined') {\n        viewOpts.startkey = opts.descending ?\n          toIndexableString([startkey, {}]) :\n          toIndexableString([startkey]);\n      }\n      if (typeof endkey !== 'undefined') {\n        var inclusiveEnd = opts.inclusive_end !== false;\n        if (opts.descending) {\n          inclusiveEnd = !inclusiveEnd;\n        }\n\n        viewOpts.endkey = toIndexableString(\n          inclusiveEnd ? [endkey, {}] : [endkey]);\n      }\n      if (typeof opts.key !== 'undefined') {\n        var keyStart = toIndexableString([opts.key]);\n        var keyEnd = toIndexableString([opts.key, {}]);\n        if (viewOpts.descending) {\n          viewOpts.endkey = keyStart;\n          viewOpts.startkey = keyEnd;\n        } else {\n          viewOpts.startkey = keyStart;\n          viewOpts.endkey = keyEnd;\n        }\n      }\n      if (!shouldReduce) {\n        if (typeof opts.limit === 'number') {\n          viewOpts.limit = opts.limit;\n        }\n        viewOpts.skip = skip;\n      }\n      return fetchFromView(viewOpts).then(onMapResultsReady);\n    }\n  }\n\n  function httpViewCleanup(db) {\n    return db.fetch('_view_cleanup', {\n      headers: new Headers({'Content-Type': 'application/json'}),\n      method: 'POST'\n    }).then(function (response) {\n      return response.json();\n    });\n  }\n\n  function localViewCleanup(db) {\n    return db.get('_local/' + localDocName).then(function (metaDoc) {\n      var docsToViews = new Map();\n      Object.keys(metaDoc.views).forEach(function (fullViewName) {\n        var parts = parseViewName(fullViewName);\n        var designDocName = '_design/' + parts[0];\n        var viewName = parts[1];\n        var views = docsToViews.get(designDocName);\n        if (!views) {\n          views = new Set();\n          docsToViews.set(designDocName, views);\n        }\n        views.add(viewName);\n      });\n      var opts = {\n        keys : mapToKeysArray(docsToViews),\n        include_docs : true\n      };\n      return db.allDocs(opts).then(function (res) {\n        var viewsToStatus = {};\n        res.rows.forEach(function (row) {\n          var ddocName = row.key.substring(8); // cuts off '_design/'\n          docsToViews.get(row.key).forEach(function (viewName) {\n            var fullViewName = ddocName + '/' + viewName;\n            /* istanbul ignore if */\n            if (!metaDoc.views[fullViewName]) {\n              // new format, without slashes, to support PouchDB 2.2.0\n              // migration test in pouchdb's browser.migration.js verifies this\n              fullViewName = viewName;\n            }\n            var viewDBNames = Object.keys(metaDoc.views[fullViewName]);\n            // design doc deleted, or view function nonexistent\n            var statusIsGood = row.doc && row.doc.views &&\n              row.doc.views[viewName];\n            viewDBNames.forEach(function (viewDBName) {\n              viewsToStatus[viewDBName] =\n                viewsToStatus[viewDBName] || statusIsGood;\n            });\n          });\n        });\n        var dbsToDelete = Object.keys(viewsToStatus).filter(\n          function (viewDBName) { return !viewsToStatus[viewDBName]; });\n        var destroyPromises = dbsToDelete.map(function (viewDBName) {\n          return sequentialize(getQueue(viewDBName), function () {\n            return new db.constructor(viewDBName, db.__opts).destroy();\n          })();\n        });\n        return Promise.all(destroyPromises).then(function () {\n          return {ok: true};\n        });\n      });\n    }, defaultsTo({ok: true}));\n  }\n\n  function queryPromised(db, fun, opts) {\n    /* istanbul ignore next */\n    if (typeof db._query === 'function') {\n      return customQuery(db, fun, opts);\n    }\n    if (isRemote(db)) {\n      return httpQuery(db, fun, opts);\n    }\n\n    var updateViewOpts = {\n      changes_batch_size: db.__opts.view_update_changes_batch_size || CHANGES_BATCH_SIZE\n    };\n\n    if (typeof fun !== 'string') {\n      // temp_view\n      checkQueryParseError(opts, fun);\n\n      tempViewQueue.add(function () {\n        var createViewPromise = createView(\n          /* sourceDB */ db,\n          /* viewName */ 'temp_view/temp_view',\n          /* mapFun */ fun.map,\n          /* reduceFun */ fun.reduce,\n          /* temporary */ true,\n          /* localDocName */ localDocName);\n        return createViewPromise.then(function (view) {\n          return fin(updateView(view, updateViewOpts).then(function () {\n            return queryView(view, opts);\n          }), function () {\n            return view.db.destroy();\n          });\n        });\n      });\n      return tempViewQueue.finish();\n    } else {\n      // persistent view\n      var fullViewName = fun;\n      var parts = parseViewName(fullViewName);\n      var designDocName = parts[0];\n      var viewName = parts[1];\n      return db.get('_design/' + designDocName).then(function (doc) {\n        var fun = doc.views && doc.views[viewName];\n\n        if (!fun) {\n          // basic validator; it's assumed that every subclass would want this\n          throw new NotFoundError('ddoc ' + doc._id + ' has no view named ' +\n            viewName);\n        }\n\n        ddocValidator(doc, viewName);\n        checkQueryParseError(opts, fun);\n\n        var createViewPromise = createView(\n          /* sourceDB */ db,\n          /* viewName */ fullViewName,\n          /* mapFun */ fun.map,\n          /* reduceFun */ fun.reduce,\n          /* temporary */ false,\n          /* localDocName */ localDocName);\n        return createViewPromise.then(function (view) {\n          if (opts.stale === 'ok' || opts.stale === 'update_after') {\n            if (opts.stale === 'update_after') {\n              nextTick(function () {\n                updateView(view, updateViewOpts);\n              });\n            }\n            return queryView(view, opts);\n          } else { // stale not ok\n            return updateView(view, updateViewOpts).then(function () {\n              return queryView(view, opts);\n            });\n          }\n        });\n      });\n    }\n  }\n\n  function abstractQuery(fun, opts, callback) {\n    var db = this;\n    if (typeof opts === 'function') {\n      callback = opts;\n      opts = {};\n    }\n    opts = opts ? coerceOptions(opts) : {};\n\n    if (typeof fun === 'function') {\n      fun = {map : fun};\n    }\n\n    var promise = Promise.resolve().then(function () {\n      return queryPromised(db, fun, opts);\n    });\n    promisedCallback(promise, callback);\n    return promise;\n  }\n\n  var abstractViewCleanup = callbackify(function () {\n    var db = this;\n    /* istanbul ignore next */\n    if (typeof db._viewCleanup === 'function') {\n      return customViewCleanup(db);\n    }\n    if (isRemote(db)) {\n      return httpViewCleanup(db);\n    }\n    return localViewCleanup(db);\n  });\n\n  return {\n    query: abstractQuery,\n    viewCleanup: abstractViewCleanup\n  };\n}\n\nexport default createAbstractMapReduce;\n","import { clone } from 'pouchdb-utils';\nimport { collate } from 'pouchdb-collate';\n\n// this would just be \"return doc[field]\", but fields\n// can be \"deep\" due to dot notation\nfunction getFieldFromDoc(doc, parsedField) {\n  var value = doc;\n  for (var i = 0, len = parsedField.length; i < len; i++) {\n    var key = parsedField[i];\n    value = value[key];\n    if (!value) {\n      break;\n    }\n  }\n  return value;\n}\n\nfunction setFieldInDoc(doc, parsedField, value) {\n  for (var i = 0, len = parsedField.length; i < len-1; i++) {\n    var elem = parsedField[i];\n    doc = doc[elem] = doc[elem] || {};\n  }\n  doc[parsedField[len-1]] = value;\n}\n\nfunction compare(left, right) {\n  return left < right ? -1 : left > right ? 1 : 0;\n}\n\n// Converts a string in dot notation to an array of its components, with backslash escaping\nfunction parseField(fieldName) {\n  // fields may be deep (e.g. \"foo.bar.baz\"), so parse\n  var fields = [];\n  var current = '';\n  for (var i = 0, len = fieldName.length; i < len; i++) {\n    var ch = fieldName[i];\n    if (i > 0 && fieldName[i - 1] === '\\\\' && (ch === '$' || ch === '.')) {\n      // escaped delimiter\n      current = current.substring(0, current.length - 1) + ch;\n    } else if (ch === '.') {\n      // When `.` is not escaped (above), it is a field delimiter\n      fields.push(current);\n      current = '';\n    } else { // normal character\n      current += ch;\n    }\n  }\n  fields.push(current);\n  return fields;\n}\n\nvar combinationFields = ['$or', '$nor', '$not'];\nfunction isCombinationalField(field) {\n  return combinationFields.indexOf(field) > -1;\n}\n\nfunction getKey(obj) {\n  return Object.keys(obj)[0];\n}\n\nfunction getValue(obj) {\n  return obj[getKey(obj)];\n}\n\n\n// flatten an array of selectors joined by an $and operator\nfunction mergeAndedSelectors(selectors) {\n\n  // sort to ensure that e.g. if the user specified\n  // $and: [{$gt: 'a'}, {$gt: 'b'}], then it's collapsed into\n  // just {$gt: 'b'}\n  var res = {};\n  var first = {$or: true, $nor: true};\n\n  selectors.forEach(function (selector) {\n    Object.keys(selector).forEach(function (field) {\n      var matcher = selector[field];\n      if (typeof matcher !== 'object') {\n        matcher = {$eq: matcher};\n      }\n\n      if (isCombinationalField(field)) {\n        // or, nor\n        if (matcher instanceof Array) {\n          if (first[field]) {\n            first[field] = false;\n            res[field] = matcher;\n            return;\n          }\n\n          var entries = [];\n          res[field].forEach(function (existing) {\n            Object.keys(matcher).forEach(function (key) {\n              var m = matcher[key];\n              var longest = Math.max(Object.keys(existing).length, Object.keys(m).length);\n              var merged = mergeAndedSelectors([existing, m]);\n              if (Object.keys(merged).length <= longest) {\n                // we have a situation like: (a :{$eq :1} || ...) && (a {$eq: 2} || ...)\n                // merging would produce a $eq 2 when actually we shouldn't ever match against these merged conditions\n                // merged should always contain more values to be valid\n                return;\n              }\n              entries.push(merged);\n            });\n          });\n          res[field] = entries;\n        } else {\n          // not\n          res[field] = mergeAndedSelectors([matcher]);\n        }\n      } else {\n        var fieldMatchers = res[field] = res[field] || {};\n        Object.keys(matcher).forEach(function (operator) {\n          var value = matcher[operator];\n\n          if (operator === '$gt' || operator === '$gte') {\n            return mergeGtGte(operator, value, fieldMatchers);\n          } else if (operator === '$lt' || operator === '$lte') {\n            return mergeLtLte(operator, value, fieldMatchers);\n          } else if (operator === '$ne') {\n            return mergeNe(value, fieldMatchers);\n          } else if (operator === '$eq') {\n            return mergeEq(value, fieldMatchers);\n          } else if (operator === \"$regex\") {\n            return mergeRegex(value, fieldMatchers);\n          }\n          fieldMatchers[operator] = value;\n        });\n      }\n    });\n  });\n\n  return res;\n}\n\n\n\n// collapse logically equivalent gt/gte values\nfunction mergeGtGte(operator, value, fieldMatchers) {\n  if (typeof fieldMatchers.$eq !== 'undefined') {\n    return; // do nothing\n  }\n  if (typeof fieldMatchers.$gte !== 'undefined') {\n    if (operator === '$gte') {\n      if (value > fieldMatchers.$gte) { // more specificity\n        fieldMatchers.$gte = value;\n      }\n    } else { // operator === '$gt'\n      if (value >= fieldMatchers.$gte) { // more specificity\n        delete fieldMatchers.$gte;\n        fieldMatchers.$gt = value;\n      }\n    }\n  } else if (typeof fieldMatchers.$gt !== 'undefined') {\n    if (operator === '$gte') {\n      if (value > fieldMatchers.$gt) { // more specificity\n        delete fieldMatchers.$gt;\n        fieldMatchers.$gte = value;\n      }\n    } else { // operator === '$gt'\n      if (value > fieldMatchers.$gt) { // more specificity\n        fieldMatchers.$gt = value;\n      }\n    }\n  } else {\n    fieldMatchers[operator] = value;\n  }\n}\n\n// collapse logically equivalent lt/lte values\nfunction mergeLtLte(operator, value, fieldMatchers) {\n  if (typeof fieldMatchers.$eq !== 'undefined') {\n    return; // do nothing\n  }\n  if (typeof fieldMatchers.$lte !== 'undefined') {\n    if (operator === '$lte') {\n      if (value < fieldMatchers.$lte) { // more specificity\n        fieldMatchers.$lte = value;\n      }\n    } else { // operator === '$gt'\n      if (value <= fieldMatchers.$lte) { // more specificity\n        delete fieldMatchers.$lte;\n        fieldMatchers.$lt = value;\n      }\n    }\n  } else if (typeof fieldMatchers.$lt !== 'undefined') {\n    if (operator === '$lte') {\n      if (value < fieldMatchers.$lt) { // more specificity\n        delete fieldMatchers.$lt;\n        fieldMatchers.$lte = value;\n      }\n    } else { // operator === '$gt'\n      if (value < fieldMatchers.$lt) { // more specificity\n        fieldMatchers.$lt = value;\n      }\n    }\n  } else {\n    fieldMatchers[operator] = value;\n  }\n}\n\n// combine $ne values into one array\nfunction mergeNe(value, fieldMatchers) {\n  if ('$ne' in fieldMatchers) {\n    // there are many things this could \"not\" be\n    fieldMatchers.$ne.push(value);\n  } else { // doesn't exist yet\n    fieldMatchers.$ne = [value];\n  }\n}\n\n// add $eq into the mix\nfunction mergeEq(value, fieldMatchers) {\n  // these all have less specificity than the $eq\n  // TODO: check for user errors here\n  delete fieldMatchers.$gt;\n  delete fieldMatchers.$gte;\n  delete fieldMatchers.$lt;\n  delete fieldMatchers.$lte;\n  delete fieldMatchers.$ne;\n  fieldMatchers.$eq = value;\n}\n\n// combine $regex values into one array\nfunction mergeRegex(value, fieldMatchers) {\n  if ('$regex' in fieldMatchers) {\n    // a value could match multiple regexes\n    fieldMatchers.$regex.push(value);\n  } else { // doesn't exist yet\n    fieldMatchers.$regex = [value];\n  }\n}\n\n//#7458: execute function mergeAndedSelectors on nested $and\nfunction mergeAndedSelectorsNested(obj) {\n    for (var prop in obj) {\n        if (Array.isArray(obj)) {\n            for (var i in obj) {\n                if (obj[i]['$and']) {\n                    obj[i] = mergeAndedSelectors(obj[i]['$and']);\n                }\n            }\n        }\n        var value = obj[prop];\n        if (typeof value === 'object') {\n            mergeAndedSelectorsNested(value); // <- recursive call\n        }\n    }\n    return obj;\n}\n\n//#7458: determine id $and is present in selector (at any level)\nfunction isAndInSelector(obj, isAnd) {\n    for (var prop in obj) {\n        if (prop === '$and') {\n            isAnd = true;\n        }\n        var value = obj[prop];\n        if (typeof value === 'object') {\n            isAnd = isAndInSelector(value, isAnd); // <- recursive call\n        }\n    }\n    return isAnd;\n}\n\n//\n// normalize the selector\n//\nfunction massageSelector(input) {\n  var result = clone(input);\n  var wasAnded = false;\n    //#7458: if $and is present in selector (at any level) merge nested $and\n    if (isAndInSelector(result, false)) {\n        result = mergeAndedSelectorsNested(result);\n        if ('$and' in result) {\n            result = mergeAndedSelectors(result['$and']);\n        }\n        wasAnded = true;\n    }\n\n  ['$or', '$nor'].forEach(function (orOrNor) {\n    if (orOrNor in result) {\n      // message each individual selector\n      // e.g. {foo: 'bar'} becomes {foo: {$eq: 'bar'}}\n      result[orOrNor].forEach(function (subSelector) {\n        var fields = Object.keys(subSelector);\n        for (var i = 0; i < fields.length; i++) {\n          var field = fields[i];\n          var matcher = subSelector[field];\n          if (typeof matcher !== 'object' || matcher === null) {\n            subSelector[field] = {$eq: matcher};\n          }\n        }\n      });\n    }\n  });\n\n  if ('$not' in result) {\n    //This feels a little like forcing, but it will work for now,\n    //I would like to come back to this and make the merging of selectors a little more generic\n    result['$not'] = mergeAndedSelectors([result['$not']]);\n  }\n\n  var fields = Object.keys(result);\n\n  for (var i = 0; i < fields.length; i++) {\n    var field = fields[i];\n    var matcher = result[field];\n\n    if (typeof matcher !== 'object' || matcher === null) {\n      matcher = {$eq: matcher};\n    } else if (!wasAnded) {\n      // These values must be placed in an array because these operators can be used multiple times on the same field\n      // when $and is used, mergeAndedSelectors takes care of putting them into arrays, otherwise it's done here:\n      if ('$ne' in matcher) {\n        matcher.$ne = [matcher.$ne];\n      }\n      if ('$regex' in matcher) {\n        matcher.$regex = [matcher.$regex];\n      }\n    }\n    result[field] = matcher;\n  }\n\n  return result;\n}\n\n// create a comparator based on the sort object\nfunction createFieldSorter(sort) {\n\n  function getFieldValuesAsArray(doc) {\n    return sort.map(function (sorting) {\n      var fieldName = getKey(sorting);\n      var parsedField = parseField(fieldName);\n      var docFieldValue = getFieldFromDoc(doc, parsedField);\n      return docFieldValue;\n    });\n  }\n\n  return function (aRow, bRow) {\n    var aFieldValues = getFieldValuesAsArray(aRow.doc);\n    var bFieldValues = getFieldValuesAsArray(bRow.doc);\n    var collation = collate(aFieldValues, bFieldValues);\n    if (collation !== 0) {\n      return collation;\n    }\n    // this is what mango seems to do\n    return compare(aRow.doc._id, bRow.doc._id);\n  };\n}\n\nfunction filterInMemoryFields(rows, requestDef, inMemoryFields) {\n  rows = rows.filter(function (row) {\n    return rowFilter(row.doc, requestDef.selector, inMemoryFields);\n  });\n\n  if (requestDef.sort) {\n    // in-memory sort\n    var fieldSorter = createFieldSorter(requestDef.sort);\n    rows = rows.sort(fieldSorter);\n    if (typeof requestDef.sort[0] !== 'string' &&\n        getValue(requestDef.sort[0]) === 'desc') {\n      rows = rows.reverse();\n    }\n  }\n\n  if ('limit' in requestDef || 'skip' in requestDef) {\n    // have to do the limit in-memory\n    var skip = requestDef.skip || 0;\n    var limit = ('limit' in requestDef ? requestDef.limit : rows.length) + skip;\n    rows = rows.slice(skip, limit);\n  }\n  return rows;\n}\n\nfunction rowFilter(doc, selector, inMemoryFields) {\n  return inMemoryFields.every(function (field) {\n    var matcher = selector[field];\n    var parsedField = parseField(field);\n    var docFieldValue = getFieldFromDoc(doc, parsedField);\n    if (isCombinationalField(field)) {\n      return matchCominationalSelector(field, matcher, doc);\n    }\n\n    return matchSelector(matcher, doc, parsedField, docFieldValue);\n  });\n}\n\nfunction matchSelector(matcher, doc, parsedField, docFieldValue) {\n  if (!matcher) {\n    // no filtering necessary; this field is just needed for sorting\n    return true;\n  }\n\n  // is matcher an object, if so continue recursion\n  if (typeof matcher === 'object') {\n    return Object.keys(matcher).every(function (maybeUserOperator) {\n      var userValue = matcher[ maybeUserOperator ];\n      // explicit operator\n      if (maybeUserOperator.indexOf(\"$\") === 0) {\n        return match(maybeUserOperator, doc, userValue, parsedField, docFieldValue);\n      } else {\n        var subParsedField = parseField(maybeUserOperator);\n\n        if (\n          docFieldValue === undefined &&\n          typeof userValue !== \"object\" &&\n          subParsedField.length > 0\n        ) {\n          // the field does not exist, return or getFieldFromDoc will throw\n          return false;\n        }\n\n        var subDocFieldValue = getFieldFromDoc(docFieldValue, subParsedField);\n\n        if (typeof userValue === \"object\") {\n          // field value is an object that might contain more operators\n          return matchSelector(userValue, doc, parsedField, subDocFieldValue);\n        }\n\n        // implicit operator\n        return match(\"$eq\", doc, userValue, subParsedField, subDocFieldValue);\n      }\n    });\n  }\n\n  // no more depth, No need to recurse further\n  return matcher === docFieldValue;\n}\n\nfunction matchCominationalSelector(field, matcher, doc) {\n\n  if (field === '$or') {\n    return matcher.some(function (orMatchers) {\n      return rowFilter(doc, orMatchers, Object.keys(orMatchers));\n    });\n  }\n\n  if (field === '$not') {\n    return !rowFilter(doc, matcher, Object.keys(matcher));\n  }\n\n  //`$nor`\n  return !matcher.find(function (orMatchers) {\n    return rowFilter(doc, orMatchers, Object.keys(orMatchers));\n  });\n\n}\n\nfunction match(userOperator, doc, userValue, parsedField, docFieldValue) {\n  if (!matchers[userOperator]) {\n    /* istanbul ignore next */\n    throw new Error('unknown operator \"' + userOperator +\n      '\" - should be one of $eq, $lte, $lt, $gt, $gte, $exists, $ne, $in, ' +\n      '$nin, $size, $mod, $regex, $elemMatch, $type, $allMatch or $all');\n  }\n  return matchers[userOperator](doc, userValue, parsedField, docFieldValue);\n}\n\nfunction fieldExists(docFieldValue) {\n  return typeof docFieldValue !== 'undefined' && docFieldValue !== null;\n}\n\nfunction fieldIsNotUndefined(docFieldValue) {\n  return typeof docFieldValue !== 'undefined';\n}\n\nfunction modField(docFieldValue, userValue) {\n  if (typeof docFieldValue !== \"number\" ||\n    parseInt(docFieldValue, 10) !== docFieldValue) {\n    return false;\n  }\n\n  var divisor = userValue[0];\n  var mod = userValue[1];\n\n  return docFieldValue % divisor === mod;\n}\n\nfunction arrayContainsValue(docFieldValue, userValue) {\n  return userValue.some(function (val) {\n    if (docFieldValue instanceof Array) {\n      return docFieldValue.some(function (docFieldValueItem) {\n        return collate(val, docFieldValueItem) === 0;\n      });\n    }\n\n    return collate(val, docFieldValue) === 0;\n  });\n}\n\nfunction arrayContainsAllValues(docFieldValue, userValue) {\n  return userValue.every(function (val) {\n    return docFieldValue.some(function (docFieldValueItem) {\n      return collate(val, docFieldValueItem) === 0;\n    });\n  });\n}\n\nfunction arraySize(docFieldValue, userValue) {\n  return docFieldValue.length === userValue;\n}\n\nfunction regexMatch(docFieldValue, userValue) {\n  var re = new RegExp(userValue);\n\n  return re.test(docFieldValue);\n}\n\nfunction typeMatch(docFieldValue, userValue) {\n\n  switch (userValue) {\n    case 'null':\n      return docFieldValue === null;\n    case 'boolean':\n      return typeof (docFieldValue) === 'boolean';\n    case 'number':\n      return typeof (docFieldValue) === 'number';\n    case 'string':\n      return typeof (docFieldValue) === 'string';\n    case 'array':\n      return docFieldValue instanceof Array;\n    case 'object':\n      return ({}).toString.call(docFieldValue) === '[object Object]';\n  }\n}\n\nvar matchers = {\n\n  '$elemMatch': function (doc, userValue, parsedField, docFieldValue) {\n    if (!Array.isArray(docFieldValue)) {\n      return false;\n    }\n\n    if (docFieldValue.length === 0) {\n      return false;\n    }\n\n    if (typeof docFieldValue[0] === 'object' &&  docFieldValue[0] !== null) {\n      return docFieldValue.some(function (val) {\n        return rowFilter(val, userValue, Object.keys(userValue));\n      });\n    }\n\n    return docFieldValue.some(function (val) {\n      return matchSelector(userValue, doc, parsedField, val);\n    });\n  },\n\n  '$allMatch': function (doc, userValue, parsedField, docFieldValue) {\n    if (!Array.isArray(docFieldValue)) {\n      return false;\n    }\n\n    /* istanbul ignore next */\n    if (docFieldValue.length === 0) {\n      return false;\n    }\n\n    if (typeof docFieldValue[0] === 'object' &&  docFieldValue[0] !== null) {\n      return docFieldValue.every(function (val) {\n        return rowFilter(val, userValue, Object.keys(userValue));\n      });\n    }\n\n    return docFieldValue.every(function (val) {\n      return matchSelector(userValue, doc, parsedField, val);\n    });\n  },\n\n  '$eq': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldIsNotUndefined(docFieldValue) && collate(docFieldValue, userValue) === 0;\n  },\n\n  '$gte': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldIsNotUndefined(docFieldValue) && collate(docFieldValue, userValue) >= 0;\n  },\n\n  '$gt': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldIsNotUndefined(docFieldValue) && collate(docFieldValue, userValue) > 0;\n  },\n\n  '$lte': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldIsNotUndefined(docFieldValue) && collate(docFieldValue, userValue) <= 0;\n  },\n\n  '$lt': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldIsNotUndefined(docFieldValue) && collate(docFieldValue, userValue) < 0;\n  },\n\n  '$exists': function (doc, userValue, parsedField, docFieldValue) {\n    //a field that is null is still considered to exist\n    if (userValue) {\n      return fieldIsNotUndefined(docFieldValue);\n    }\n\n    return !fieldIsNotUndefined(docFieldValue);\n  },\n\n  '$mod': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldExists(docFieldValue) && modField(docFieldValue, userValue);\n  },\n\n  '$ne': function (doc, userValue, parsedField, docFieldValue) {\n    return userValue.every(function (neValue) {\n      return collate(docFieldValue, neValue) !== 0;\n    });\n  },\n  '$in': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldExists(docFieldValue) && arrayContainsValue(docFieldValue, userValue);\n  },\n\n  '$nin': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldExists(docFieldValue) && !arrayContainsValue(docFieldValue, userValue);\n  },\n\n  '$size': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldExists(docFieldValue) &&\n      Array.isArray(docFieldValue) &&\n      arraySize(docFieldValue, userValue);\n  },\n\n  '$all': function (doc, userValue, parsedField, docFieldValue) {\n    return Array.isArray(docFieldValue) && arrayContainsAllValues(docFieldValue, userValue);\n  },\n\n  '$regex': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldExists(docFieldValue) &&\n      typeof docFieldValue == \"string\" &&\n      userValue.every(function (regexValue) {\n        return regexMatch(docFieldValue, regexValue);\n      });\n  },\n\n  '$type': function (doc, userValue, parsedField, docFieldValue) {\n    return typeMatch(docFieldValue, userValue);\n  }\n};\n\n// return true if the given doc matches the supplied selector\nfunction matchesSelector(doc, selector) {\n  /* istanbul ignore if */\n  if (typeof selector !== 'object') {\n    // match the CouchDB error message\n    throw new Error('Selector error: expected a JSON object');\n  }\n\n  selector = massageSelector(selector);\n  var row = {\n    'doc': doc\n  };\n\n  var rowsMatched = filterInMemoryFields([row], { 'selector': selector }, Object.keys(selector));\n  return rowsMatched && rowsMatched.length === 1;\n}\n\nexport { massageSelector, matchesSelector, filterInMemoryFields, createFieldSorter, rowFilter, isCombinationalField, getKey, getValue, getFieldFromDoc, setFieldInDoc, compare, parseField };\n","import { generateErrorFromResponse } from 'pouchdb-errors';\nimport { Headers } from 'pouchdb-fetch';\nimport abstractMapReduce from 'pouchdb-abstract-mapreduce';\nimport { stringMd5 } from 'pouchdb-md5';\nimport { collate } from 'pouchdb-collate';\nimport { getFieldFromDoc, setFieldInDoc, parseField, matchesSelector, getKey, getValue, compare, massageSelector, filterInMemoryFields } from 'pouchdb-selector-core';\nimport { clone, assign, nextTick, upsert, toPromise, isRemote } from 'pouchdb-utils';\n\n// we restucture the supplied JSON considerably, because the official\n// Mango API is very particular about a lot of this stuff, but we like\n// to be liberal with what we accept in order to prevent mental\n// breakdowns in our users\nfunction massageCreateIndexRequest(requestDef) {\n  requestDef = clone(requestDef);\n\n  if (!requestDef.index) {\n    requestDef.index = {};\n  }\n\n  ['type', 'name', 'ddoc'].forEach(function (key) {\n    if (requestDef.index[key]) {\n      requestDef[key] = requestDef.index[key];\n      delete requestDef.index[key];\n    }\n  });\n\n  if (requestDef.fields) {\n    requestDef.index.fields = requestDef.fields;\n    delete requestDef.fields;\n  }\n\n  if (!requestDef.type) {\n    requestDef.type = 'json';\n  }\n  return requestDef;\n}\n\n// throws if the user is using the wrong query field value type\nfunction checkFieldValueType(name, value, isHttp) {\n\tvar message = '';\n\tvar received = value;\n\tvar addReceived = true;\n\tif ([ '$in', '$nin', '$or', '$and', '$mod', '$nor', '$all' ].indexOf(name) !== -1) {\n\t\tif (!Array.isArray(value)) {\n\t\t\tmessage = 'Query operator ' + name + ' must be an array.';\n\n\t\t}\n\t}\n\n\tif ([ '$not', '$elemMatch', '$allMatch' ].indexOf(name) !== -1) {\n\t\tif (!(!Array.isArray(value) && typeof value === 'object' && value !== null)) {\n\t\t\tmessage = 'Query operator ' + name + ' must be an object.';\n\t\t}\n\t}\n\n\tif (name === '$mod' && Array.isArray(value)) {\n\t\tif (value.length !== 2) {\n\t\t\tmessage = 'Query operator $mod must be in the format [divisor, remainder], ' +\n\t\t\t\t'where divisor and remainder are both integers.';\n\t\t} else {\n\t\t\tvar divisor = value[0];\n\t\t\tvar mod = value[1];\n\t\t\tif (divisor === 0) {\n\t\t\t\tmessage = 'Query operator $mod\\'s divisor cannot be 0, cannot divide by zero.';\n\t\t\t\taddReceived = false;\n\t\t\t}\n\t\t\tif (typeof divisor !== 'number' || parseInt(divisor, 10) !== divisor) {\n\t\t\t\tmessage = 'Query operator $mod\\'s divisor is not an integer.';\n\t\t\t\treceived = divisor;\n\t\t\t}\n\t\t\tif (parseInt(mod, 10) !== mod) {\n\t\t\t\tmessage = 'Query operator $mod\\'s remainder is not an integer.';\n\t\t\t\treceived = mod;\n\t\t\t}\n\t\t}\n\t}\n\tif (name === '$exists') {\n\t\tif (typeof value !== 'boolean') {\n\t\t\tmessage = 'Query operator $exists must be a boolean.';\n\t\t}\n\t}\n\n\tif (name === '$type') {\n\t\tvar allowed = [ 'null', 'boolean', 'number', 'string', 'array', 'object' ];\n\t\tvar allowedStr = '\"' + allowed.slice(0, allowed.length - 1).join('\", \"') + '\", or \"' + allowed[allowed.length - 1] + '\"';\n\t\tif (typeof value !== 'string') {\n\t\t\tmessage = 'Query operator $type must be a string. Supported values: ' + allowedStr + '.';\n\t\t} else if (allowed.indexOf(value) == -1) {\n\t\t\tmessage = 'Query operator $type must be a string. Supported values: ' + allowedStr + '.';\n\t\t}\n\t}\n\n\tif (name === '$size') {\n\t\tif (parseInt(value, 10) !== value) {\n\t\t\tmessage = 'Query operator $size must be a integer.';\n\t\t}\n\t}\n\n\tif (name === '$regex') {\n\t\tif (typeof value !== 'string') {\n\t\t\tconsole.log(\"here\", isHttp);\n\t\t\tif (isHttp) {\n\t\t\t\tmessage = 'Query operator $regex must be a string.';\n\t\t\t} else if (!(value instanceof RegExp)) {\n\t\t\t\tmessage = 'Query operator $regex must be a string or an instance ' +\n\t\t\t\t\t'of a javascript regular expression.';\n\t\t\t}\n\t\t}\n\t}\n\n\tif (message) {\n\t\tif (addReceived) {\n\n\t\t\tvar type = received === null\n\t\t\t? ' '\n\t\t\t: Array.isArray(received)\n\t\t\t? ' array'\n\t\t\t: ' ' + typeof received;\n\t\t\tvar receivedStr = typeof received === 'object' && received !== null\n\t\t\t?  JSON.stringify(received, null, '\\t')\n\t\t\t: received;\n\n\t\t\tmessage += ' Received' + type + ': ' + receivedStr;\n\t\t}\n\t\tthrow new Error(message);\n\t}\n}\n\n\nvar requireValidation = [ '$all', '$allMatch', '$and', '$elemMatch', '$exists', '$in', '$mod', '$nin', '$nor', '$not', '$or', '$regex', '$size', '$type' ];\n\nvar arrayTypeComparisonOperators = [ '$in', '$nin', '$mod', '$all'];\n\nvar equalityOperators = [ '$eq', '$gt', '$gte', '$lt', '$lte' ];\n\n// recursively walks down the a query selector validating any operators\nfunction validateSelector(input, isHttp) {\n\tif (Array.isArray(input)) {\n\t\tfor (var entry of input) {\n\t\t\tif (typeof entry === 'object' && value !== null) {\n\t\t\t\tvalidateSelector(entry, isHttp);\n\t\t\t}\n\t\t}\n\t} else {\n\t\tvar fields = Object.keys(input);\n\n\t\tfor (var i = 0; i < fields.length; i++) {\n\t\t\tvar key = fields[i];\n\t\t\tvar value = input[key];\n\n\t\t\tif (requireValidation.indexOf(key) !== -1) {\n\t\t\t\tcheckFieldValueType(key, value, isHttp);\n\t\t\t}\n\t\t\tif (equalityOperators.indexOf(key) !== -1) {\n\t\t\t\t// skip, explicit comparison operators can be anything\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (arrayTypeComparisonOperators.indexOf(key) !== -1) {\n\t\t\t\t// skip, their values are already valid\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (typeof value === 'object' && value !== null) {\n\t\t\t\tvalidateSelector(value, isHttp);\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunction dbFetch(db, path, opts, callback) {\n  var status, ok;\n  opts.headers = new Headers({'Content-type': 'application/json'});\n  db.fetch(path, opts).then(function (response) {\n    status = response.status;\n    ok = response.ok;\n    return response.json();\n  }).then(function (json) {\n    if (!ok) {\n      json.status = status;\n      var err = generateErrorFromResponse(json);\n      callback(err);\n    } else {\n      callback(null, json);\n    }\n  }).catch(callback);\n}\n\nfunction createIndex(db, requestDef, callback) {\n  requestDef = massageCreateIndexRequest(requestDef);\n  dbFetch(db, '_index', {\n    method: 'POST',\n    body: JSON.stringify(requestDef)\n  }, callback);\n}\n\nfunction find(db, requestDef, callback) {\n  validateSelector(requestDef.selector, true);\n  dbFetch(db, '_find', {\n    method: 'POST',\n    body: JSON.stringify(requestDef)\n  }, callback);\n}\n\nfunction explain(db, requestDef, callback) {\n  dbFetch(db, '_explain', {\n    method: 'POST',\n    body: JSON.stringify(requestDef)\n  }, callback);\n}\n\nfunction getIndexes(db, callback) {\n  dbFetch(db, '_index', {\n    method: 'GET'\n  }, callback);\n}\n\nfunction deleteIndex(db, indexDef, callback) {\n\n\n  var ddoc = indexDef.ddoc;\n  var type = indexDef.type || 'json';\n  var name = indexDef.name;\n\n  if (!ddoc) {\n    return callback(new Error('you must provide an index\\'s ddoc'));\n  }\n\n  if (!name) {\n    return callback(new Error('you must provide an index\\'s name'));\n  }\n\n  var url = '_index/' + [ddoc, type, name].map(encodeURIComponent).join('/');\n\n  dbFetch(db, url, {method: 'DELETE'}, callback);\n}\n\nfunction getArguments(fun) {\n  return function () {\n    var len = arguments.length;\n    var args = new Array(len);\n    var i = -1;\n    while (++i < len) {\n      args[i] = arguments[i];\n    }\n    return fun.call(this, args);\n  };\n}\n\nfunction callbackify(fun) {\n  return getArguments(function (args) {\n    var cb = args.pop();\n    var promise = fun.apply(this, args);\n    promisedCallback(promise, cb);\n    return promise;\n  });\n}\n\nfunction promisedCallback(promise, callback) {\n  promise.then(function (res) {\n    nextTick(function () {\n      callback(null, res);\n    });\n  }, function (reason) {\n    nextTick(function () {\n      callback(reason);\n    });\n  });\n  return promise;\n}\n\nvar flatten = getArguments(function (args) {\n  var res = [];\n  for (var i = 0, len = args.length; i < len; i++) {\n    var subArr = args[i];\n    if (Array.isArray(subArr)) {\n      res = res.concat(flatten.apply(null, subArr));\n    } else {\n      res.push(subArr);\n    }\n  }\n  return res;\n});\n\nfunction mergeObjects(arr) {\n  var res = {};\n  for (var i = 0, len = arr.length; i < len; i++) {\n    res = assign(res, arr[i]);\n  }\n  return res;\n}\n\n// Selects a list of fields defined in dot notation from one doc\n// and copies them to a new doc. Like underscore _.pick but supports nesting.\nfunction pick(obj, arr) {\n  var res = {};\n  for (var i = 0, len = arr.length; i < len; i++) {\n    var parsedField = parseField(arr[i]);\n    var value = getFieldFromDoc(obj, parsedField);\n    if (typeof value !== 'undefined') {\n      setFieldInDoc(res, parsedField, value);\n    }\n  }\n  return res;\n}\n\n// e.g. ['a'], ['a', 'b'] is true, but ['b'], ['a', 'b'] is false\nfunction oneArrayIsSubArrayOfOther(left, right) {\n\n  for (var i = 0, len = Math.min(left.length, right.length); i < len; i++) {\n    if (left[i] !== right[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n// e.g.['a', 'b', 'c'], ['a', 'b'] is false\nfunction oneArrayIsStrictSubArrayOfOther(left, right) {\n\n  if (left.length > right.length) {\n    return false;\n  }\n\n  return oneArrayIsSubArrayOfOther(left, right);\n}\n\n// same as above, but treat the left array as an unordered set\n// e.g. ['b', 'a'], ['a', 'b', 'c'] is true, but ['c'], ['a', 'b', 'c'] is false\nfunction oneSetIsSubArrayOfOther(left, right) {\n  left = left.slice();\n  for (var i = 0, len = right.length; i < len; i++) {\n    var field = right[i];\n    if (!left.length) {\n      break;\n    }\n    var leftIdx = left.indexOf(field);\n    if (leftIdx === -1) {\n      return false;\n    } else {\n      left.splice(leftIdx, 1);\n    }\n  }\n  return true;\n}\n\nfunction arrayToObject(arr) {\n  var res = {};\n  for (var i = 0, len = arr.length; i < len; i++) {\n    res[arr[i]] = true;\n  }\n  return res;\n}\n\nfunction max(arr, fun) {\n  var max = null;\n  var maxScore = -1;\n  for (var i = 0, len = arr.length; i < len; i++) {\n    var element = arr[i];\n    var score = fun(element);\n    if (score > maxScore) {\n      maxScore = score;\n      max = element;\n    }\n  }\n  return max;\n}\n\nfunction arrayEquals(arr1, arr2) {\n  if (arr1.length !== arr2.length) {\n    return false;\n  }\n  for (var i = 0, len = arr1.length; i < len; i++) {\n    if (arr1[i] !== arr2[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction uniq(arr) {\n  var obj = {};\n  for (var i = 0; i < arr.length; i++) {\n    obj['$' + arr[i]] = true;\n  }\n  return Object.keys(obj).map(function (key) {\n    return key.substring(1);\n  });\n}\n\n//\n// One thing about these mappers:\n//\n// Per the advice of John-David Dalton (http://youtu.be/NthmeLEhDDM),\n// what you want to do in this case is optimize for the smallest possible\n// function, since that's the thing that gets run over and over again.\n//\n// This code would be a lot simpler if all the if/elses were inside\n// the function, but it would also be a lot less performant.\n//\n\n\nfunction createDeepMultiMapper(fields, emit, selector) {\n  return function (doc) {\n    if (selector && !matchesSelector(doc, selector)) { return; }\n    var toEmit = [];\n    for (var i = 0, iLen = fields.length; i < iLen; i++) {\n      var parsedField = parseField(fields[i]);\n      var value = doc;\n      for (var j = 0, jLen = parsedField.length; j < jLen; j++) {\n        var key = parsedField[j];\n        value = value[key];\n        if (typeof value === 'undefined') {\n          return; // don't emit\n        }\n      }\n      toEmit.push(value);\n    }\n    emit(toEmit);\n  };\n}\n\nfunction createDeepSingleMapper(field, emit, selector) {\n  var parsedField = parseField(field);\n  return function (doc) {\n    if (selector && !matchesSelector(doc, selector)) { return; }\n    var value = doc;\n    for (var i = 0, len = parsedField.length; i < len; i++) {\n      var key = parsedField[i];\n      value = value[key];\n      if (typeof value === 'undefined') {\n        return; // do nothing\n      }\n    }\n    emit(value);\n  };\n}\n\nfunction createShallowSingleMapper(field, emit, selector) {\n  return function (doc) {\n    if (selector && !matchesSelector(doc, selector)) { return; }\n    emit(doc[field]);\n  };\n}\n\nfunction createShallowMultiMapper(fields, emit, selector) {\n  return function (doc) {\n    if (selector && !matchesSelector(doc, selector)) { return; }\n    var toEmit = [];\n    for (var i = 0, len = fields.length; i < len; i++) {\n      toEmit.push(doc[fields[i]]);\n    }\n    emit(toEmit);\n  };\n}\n\nfunction checkShallow(fields) {\n  for (var i = 0, len = fields.length; i < len; i++) {\n    var field = fields[i];\n    if (field.indexOf('.') !== -1) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction createMapper(fields, emit, selector) {\n  var isShallow = checkShallow(fields);\n  var isSingle = fields.length === 1;\n\n  // notice we try to optimize for the most common case,\n  // i.e. single shallow indexes\n  if (isShallow) {\n    if (isSingle) {\n      return createShallowSingleMapper(fields[0], emit, selector);\n    } else { // multi\n      return createShallowMultiMapper(fields, emit, selector);\n    }\n  } else { // deep\n    if (isSingle) {\n      return createDeepSingleMapper(fields[0], emit, selector);\n    } else { // multi\n      return createDeepMultiMapper(fields, emit, selector);\n    }\n  }\n}\n\nfunction mapper(mapFunDef, emit) {\n  // mapFunDef is a list of fields\n\n  const fields = Object.keys(mapFunDef.fields);\n  const partialSelector = mapFunDef.partial_filter_selector;\n\n  return createMapper(fields, emit, partialSelector);\n}\n\n/* istanbul ignore next */\nfunction reducer(/*reduceFunDef*/) {\n  throw new Error('reduce not supported');\n}\n\nfunction ddocValidator(ddoc, viewName) {\n  var view = ddoc.views[viewName];\n  // This doesn't actually need to be here apparently, but\n  // I feel safer keeping it.\n  /* istanbul ignore if */\n  if (!view.map || !view.map.fields) {\n    throw new Error('ddoc ' + ddoc._id +' with view ' + viewName +\n      ' doesn\\'t have map.fields defined. ' +\n      'maybe it wasn\\'t created by this plugin?');\n  }\n}\n\nvar abstractMapper = abstractMapReduce(\n  /* localDocName */ 'indexes',\n  mapper,\n  reducer,\n  ddocValidator\n);\n\nfunction abstractMapper$1 (db) {\n  return db._customFindAbstractMapper || abstractMapper;\n}\n\n// normalize the \"sort\" value\nfunction massageSort(sort) {\n  if (!Array.isArray(sort)) {\n    throw new Error('invalid sort json - should be an array');\n  }\n  return sort.map(function (sorting) {\n    if (typeof sorting === 'string') {\n      var obj = {};\n      obj[sorting] = 'asc';\n      return obj;\n    } else {\n      return sorting;\n    }\n  });\n}\n\nfunction massageUseIndex(useIndex) {\n  var cleanedUseIndex = [];\n  if (typeof useIndex === 'string') {\n    cleanedUseIndex.push(useIndex);\n  } else {\n    cleanedUseIndex = useIndex;\n  }\n\n  return cleanedUseIndex.map(function (name) {\n    return name.replace('_design/', '');\n  });\n}\n\nfunction massageIndexDef(indexDef) {\n  indexDef.fields = indexDef.fields.map(function (field) {\n    if (typeof field === 'string') {\n      var obj = {};\n      obj[field] = 'asc';\n      return obj;\n    }\n    return field;\n  });\n  return indexDef;\n}\n\nfunction getKeyFromDoc(doc, index) {\n  var res = [];\n  for (var i = 0; i < index.def.fields.length; i++) {\n    var field = getKey(index.def.fields[i]);\n    res.push(doc[field]);\n  }\n  return res;\n}\n\n// have to do this manually because REASONS. I don't know why\n// CouchDB didn't implement inclusive_start\nfunction filterInclusiveStart(rows, targetValue, index) {\n  var indexFields = index.def.fields;\n  for (var i = 0, len = rows.length; i < len; i++) {\n    var row = rows[i];\n\n    // shave off any docs at the beginning that are <= the\n    // target value\n\n    var docKey = getKeyFromDoc(row.doc, index);\n    if (indexFields.length === 1) {\n      docKey = docKey[0]; // only one field, not multi-field\n    } else { // more than one field in index\n      // in the case where e.g. the user is searching {$gt: {a: 1}}\n      // but the index is [a, b], then we need to shorten the doc key\n      while (docKey.length > targetValue.length) {\n        docKey.pop();\n      }\n    }\n    //ABS as we just looking for values that don't match\n    if (Math.abs(collate(docKey, targetValue)) > 0) {\n      // no need to filter any further; we're past the key\n      break;\n    }\n  }\n  return i > 0 ? rows.slice(i) : rows;\n}\n\nfunction reverseOptions(opts) {\n  var newOpts = clone(opts);\n  delete newOpts.startkey;\n  delete newOpts.endkey;\n  delete newOpts.inclusive_start;\n  delete newOpts.inclusive_end;\n\n  if ('endkey' in opts) {\n    newOpts.startkey = opts.endkey;\n  }\n  if ('startkey' in opts) {\n    newOpts.endkey = opts.startkey;\n  }\n  if ('inclusive_start' in opts) {\n    newOpts.inclusive_end = opts.inclusive_start;\n  }\n  if ('inclusive_end' in opts) {\n    newOpts.inclusive_start = opts.inclusive_end;\n  }\n  return newOpts;\n}\n\nfunction validateIndex(index) {\n  var ascFields = index.fields.filter(function (field) {\n    return getValue(field) === 'asc';\n  });\n  if (ascFields.length !== 0 && ascFields.length !== index.fields.length) {\n    throw new Error('unsupported mixed sorting');\n  }\n}\n\nfunction validateSort(requestDef, index) {\n  if (index.defaultUsed && requestDef.sort) {\n    var noneIdSorts = requestDef.sort.filter(function (sortItem) {\n      return Object.keys(sortItem)[0] !== '_id';\n    }).map(function (sortItem) {\n      return Object.keys(sortItem)[0];\n    });\n\n    if (noneIdSorts.length > 0) {\n      throw new Error('Cannot sort on field(s) \"' + noneIdSorts.join(',') +\n      '\" when using the default index');\n    }\n  }\n\n  if (index.defaultUsed) {\n    return;\n  }\n}\n\nfunction validateFindRequest(requestDef) {\n  if (typeof requestDef.selector !== 'object') {\n    throw new Error('you must provide a selector when you find()');\n  }\n\n  /*var selectors = requestDef.selector['$and'] || [requestDef.selector];\n  for (var i = 0; i < selectors.length; i++) {\n    var selector = selectors[i];\n    var keys = Object.keys(selector);\n    if (keys.length === 0) {\n      throw new Error('invalid empty selector');\n    }\n    //var selection = selector[keys[0]];\n    /*if (Object.keys(selection).length !== 1) {\n      throw new Error('invalid selector: ' + JSON.stringify(selection) +\n        ' - it must have exactly one key/value');\n    }\n  }*/\n}\n\n// determine the maximum number of fields\n// we're going to need to query, e.g. if the user\n// has selection ['a'] and sorting ['a', 'b'], then we\n// need to use the longer of the two: ['a', 'b']\nfunction getUserFields(selector, sort) {\n  var selectorFields = Object.keys(selector);\n  var sortFields = sort? sort.map(getKey) : [];\n  var userFields;\n  if (selectorFields.length >= sortFields.length) {\n    userFields = selectorFields;\n  } else {\n    userFields = sortFields;\n  }\n\n  if (sortFields.length === 0) {\n    return {\n      fields: userFields\n    };\n  }\n\n  // sort according to the user's preferred sorting\n  userFields = userFields.sort(function (left, right) {\n    var leftIdx = sortFields.indexOf(left);\n    if (leftIdx === -1) {\n      leftIdx = Number.MAX_VALUE;\n    }\n    var rightIdx = sortFields.indexOf(right);\n    if (rightIdx === -1) {\n      rightIdx = Number.MAX_VALUE;\n    }\n    return leftIdx < rightIdx ? -1 : leftIdx > rightIdx ? 1 : 0;\n  });\n\n  return {\n    fields: userFields,\n    sortOrder: sort.map(getKey)\n  };\n}\n\nfunction createIndex$1(db, requestDef) {\n  requestDef = massageCreateIndexRequest(requestDef);\n  var originalIndexDef = clone(requestDef.index);\n  requestDef.index = massageIndexDef(requestDef.index);\n\n  validateIndex(requestDef.index);\n\n  // calculating md5 is expensive - memoize and only\n  // run if required\n  var md5;\n  function getMd5() {\n    return md5 || (md5 = stringMd5(JSON.stringify(requestDef)));\n  }\n\n  var viewName = requestDef.name || ('idx-' + getMd5());\n\n  var ddocName = requestDef.ddoc || ('idx-' + getMd5());\n  var ddocId = '_design/' + ddocName;\n\n  var hasInvalidLanguage = false;\n  var viewExists = false;\n\n  function updateDdoc(doc) {\n    if (doc._rev && doc.language !== 'query') {\n      hasInvalidLanguage = true;\n    }\n    doc.language = 'query';\n    doc.views = doc.views || {};\n\n    viewExists = !!doc.views[viewName];\n\n    if (viewExists) {\n      return false;\n    }\n\n    doc.views[viewName] = {\n      map: {\n        fields: mergeObjects(requestDef.index.fields)\n      },\n      reduce: '_count',\n      options: {\n        def: originalIndexDef\n      }\n    };\n\n    return doc;\n  }\n\n  db.constructor.emit('debug', ['find', 'creating index', ddocId]);\n\n  return upsert(db, ddocId, updateDdoc).then(function () {\n    if (hasInvalidLanguage) {\n      throw new Error('invalid language for ddoc with id \"' +\n      ddocId +\n      '\" (should be \"query\")');\n    }\n  }).then(function () {\n    // kick off a build\n    // TODO: abstract-pouchdb-mapreduce should support auto-updating\n    // TODO: should also use update_after, but pouchdb/pouchdb#3415 blocks me\n    var signature = ddocName + '/' + viewName;\n    return abstractMapper$1(db).query.call(db, signature, {\n      limit: 0,\n      reduce: false\n    }).then(function () {\n      return {\n        id: ddocId,\n        name: viewName,\n        result: viewExists ? 'exists' : 'created'\n      };\n    });\n  });\n}\n\nfunction getIndexes$1(db) {\n  // just search through all the design docs and filter in-memory.\n  // hopefully there aren't that many ddocs.\n  return db.allDocs({\n    startkey: '_design/',\n    endkey: '_design/\\uffff',\n    include_docs: true\n  }).then(function (allDocsRes) {\n    var res = {\n      indexes: [{\n        ddoc: null,\n        name: '_all_docs',\n        type: 'special',\n        def: {\n          fields: [{_id: 'asc'}]\n        }\n      }]\n    };\n\n    res.indexes = flatten(res.indexes, allDocsRes.rows.filter(function (row) {\n      return row.doc.language === 'query';\n    }).map(function (row) {\n      var viewNames = row.doc.views !== undefined ? Object.keys(row.doc.views) : [];\n\n      return viewNames.map(function (viewName) {\n        var view = row.doc.views[viewName];\n        return {\n          ddoc: row.id,\n          name: viewName,\n          type: 'json',\n          def: massageIndexDef(view.options.def)\n        };\n      });\n    }));\n\n    // these are sorted by view name for some reason\n    res.indexes.sort(function (left, right) {\n      return compare(left.name, right.name);\n    });\n    res.total_rows = res.indexes.length;\n    return res;\n  });\n}\n\n// couchdb lowest collation value\nvar COLLATE_LO = null;\n\n// couchdb highest collation value (TODO: well not really, but close enough amirite)\nvar COLLATE_HI = {\"\\uffff\": {}};\n\nconst SHORT_CIRCUIT_QUERY = {\n  queryOpts: { limit: 0, startkey: COLLATE_HI, endkey: COLLATE_LO },\n  inMemoryFields: [],\n};\n\n// couchdb second-lowest collation value\n\nfunction checkFieldInIndex(index, field) {\n  var indexFields = index.def.fields.map(getKey);\n  for (var i = 0, len = indexFields.length; i < len; i++) {\n    var indexField = indexFields[i];\n    if (field === indexField) {\n      return true;\n    }\n  }\n  return false;\n}\n\n// so when you do e.g. $eq/$eq, we can do it entirely in the database.\n// but when you do e.g. $gt/$eq, the first part can be done\n// in the database, but the second part has to be done in-memory,\n// because $gt has forced us to lose precision.\n// so that's what this determines\nfunction userOperatorLosesPrecision(selector, field) {\n  var matcher = selector[field];\n  var userOperator = getKey(matcher);\n\n  return userOperator !== '$eq';\n}\n\n// sort the user fields by their position in the index,\n// if they're in the index\nfunction sortFieldsByIndex(userFields, index) {\n  var indexFields = index.def.fields.map(getKey);\n\n  return userFields.slice().sort(function (a, b) {\n    var aIdx = indexFields.indexOf(a);\n    var bIdx = indexFields.indexOf(b);\n    if (aIdx === -1) {\n      aIdx = Number.MAX_VALUE;\n    }\n    if (bIdx === -1) {\n      bIdx = Number.MAX_VALUE;\n    }\n    return compare(aIdx, bIdx);\n  });\n}\n\n// first pass to try to find fields that will need to be sorted in-memory\nfunction getBasicInMemoryFields(index, selector, userFields) {\n\n  userFields = sortFieldsByIndex(userFields, index);\n\n  // check if any of the user selectors lose precision\n  var needToFilterInMemory = false;\n  for (var i = 0, len = userFields.length; i < len; i++) {\n    var field = userFields[i];\n    if (needToFilterInMemory || !checkFieldInIndex(index, field)) {\n      return userFields.slice(i);\n    }\n    if (i < len - 1 && userOperatorLosesPrecision(selector, field)) {\n      needToFilterInMemory = true;\n    }\n  }\n  return [];\n}\n\nfunction getInMemoryFieldsFromNe(selector) {\n  var fields = [];\n  Object.keys(selector).forEach(function (field) {\n    var matcher = selector[field];\n    Object.keys(matcher).forEach(function (operator) {\n      if (operator === '$ne') {\n        fields.push(field);\n      }\n    });\n  });\n  return fields;\n}\n\nfunction getInMemoryFields(coreInMemoryFields, index, selector, userFields) {\n  var result = flatten(\n    // in-memory fields reported as necessary by the query planner\n    coreInMemoryFields,\n    // combine with another pass that checks for any we may have missed\n    getBasicInMemoryFields(index, selector, userFields),\n    // combine with another pass that checks for $ne's\n    getInMemoryFieldsFromNe(selector)\n  );\n\n  return sortFieldsByIndex(uniq(result), index);\n}\n\n// check that at least one field in the user's query is represented\n// in the index. order matters in the case of sorts\nfunction checkIndexFieldsMatch(indexFields, sortOrder, fields) {\n  if (sortOrder) {\n    // array has to be a strict subarray of index array. furthermore,\n    // the sortOrder fields need to all be represented in the index\n    var sortMatches = oneArrayIsStrictSubArrayOfOther(sortOrder, indexFields);\n    var selectorMatches = oneArrayIsSubArrayOfOther(fields, indexFields);\n\n    return sortMatches && selectorMatches;\n  }\n\n  // all of the user's specified fields still need to be\n  // on the left side of the index array, although the order\n  // doesn't matter\n  return oneSetIsSubArrayOfOther(fields, indexFields);\n}\n\nvar logicalMatchers = ['$eq', '$gt', '$gte', '$lt', '$lte'];\nfunction isNonLogicalMatcher(matcher) {\n  return logicalMatchers.indexOf(matcher) === -1;\n}\n\n// check all the index fields for usages of '$ne'\n// e.g. if the user queries {foo: {$ne: 'foo'}, bar: {$eq: 'bar'}},\n// then we can neither use an index on ['foo'] nor an index on\n// ['foo', 'bar'], but we can use an index on ['bar'] or ['bar', 'foo']\nfunction checkFieldsLogicallySound(indexFields, selector) {\n  var firstField = indexFields[0];\n  var matcher = selector[firstField];\n\n  if (typeof matcher === 'undefined') {\n    /* istanbul ignore next */\n    return true;\n  }\n\n  var isInvalidNe = Object.keys(matcher).length === 1 &&\n    getKey(matcher) === '$ne';\n\n  return !isInvalidNe;\n}\n\nfunction checkIndexMatches(index, sortOrder, fields, selector) {\n\n  var indexFields = index.def.fields.map(getKey);\n\n  var fieldsMatch = checkIndexFieldsMatch(indexFields, sortOrder, fields);\n\n  if (!fieldsMatch) {\n    return false;\n  }\n\n  return checkFieldsLogicallySound(indexFields, selector);\n}\n\n//\n// the algorithm is very simple:\n// take all the fields the user supplies, and if those fields\n// are a strict subset of the fields in some index,\n// then use that index\n//\n//\nfunction findMatchingIndexes(selector, userFields, sortOrder, indexes) {\n  return indexes.filter(function (index) {\n    return checkIndexMatches(index, sortOrder, userFields, selector);\n  });\n}\n\n// find the best index, i.e. the one that matches the most fields\n// in the user's query\nfunction findBestMatchingIndex(selector, userFields, sortOrder, indexes, useIndex) {\n\n  var matchingIndexes = findMatchingIndexes(selector, userFields, sortOrder, indexes);\n\n  if (matchingIndexes.length === 0) {\n    if (useIndex) {\n      throw {\n        error: \"no_usable_index\",\n        message: \"There is no index available for this selector.\"\n      };\n    }\n    //return `all_docs` as a default index;\n    //I'm assuming that _all_docs is always first\n    var defaultIndex = indexes[0];\n    defaultIndex.defaultUsed = true;\n    return defaultIndex;\n  }\n  if (matchingIndexes.length === 1 && !useIndex) {\n    return matchingIndexes[0];\n  }\n\n  var userFieldsMap = arrayToObject(userFields);\n\n  function scoreIndex(index) {\n    var indexFields = index.def.fields.map(getKey);\n    var score = 0;\n    for (var i = 0, len = indexFields.length; i < len; i++) {\n      var indexField = indexFields[i];\n      if (userFieldsMap[indexField]) {\n        score++;\n      }\n    }\n    return score;\n  }\n\n  if (useIndex) {\n    var useIndexDdoc = '_design/' + useIndex[0];\n    var useIndexName = useIndex.length === 2 ? useIndex[1] : false;\n    var index = matchingIndexes.find(function (index) {\n      if (useIndexName && index.ddoc === useIndexDdoc && useIndexName === index.name) {\n        return true;\n      }\n\n      if (index.ddoc === useIndexDdoc) {\n        /* istanbul ignore next */\n        return true;\n      }\n\n      return false;\n    });\n\n    if (!index) {\n      throw {\n        error: \"unknown_error\",\n        message: \"Could not find that index or could not use that index for the query\"\n      };\n    }\n    return index;\n  }\n\n  return max(matchingIndexes, scoreIndex);\n}\n\nfunction getSingleFieldQueryOptsFor(userOperator, userValue) {\n  switch (userOperator) {\n    case '$eq':\n      return {key: userValue};\n    case '$lte':\n      return {endkey: userValue};\n    case '$gte':\n      return {startkey: userValue};\n    case '$lt':\n      return {\n        endkey: userValue,\n        inclusive_end: false\n      };\n    case '$gt':\n      return {\n        startkey: userValue,\n        inclusive_start: false\n      };\n  }\n\n  return {\n    startkey: COLLATE_LO\n  };\n}\n\nfunction getSingleFieldCoreQueryPlan(selector, index) {\n  var field = getKey(index.def.fields[0]);\n  //ignoring this because the test to exercise the branch is skipped at the moment\n  /* istanbul ignore next */\n  var matcher = selector[field] || {};\n  var inMemoryFields = [];\n\n  var userOperators = Object.keys(matcher);\n\n  var combinedOpts;\n\n  userOperators.forEach(function (userOperator) {\n\n    if (isNonLogicalMatcher(userOperator)) {\n      inMemoryFields.push(field);\n    }\n\n    var userValue = matcher[userOperator];\n\n    var newQueryOpts = getSingleFieldQueryOptsFor(userOperator, userValue);\n\n    if (combinedOpts) {\n      combinedOpts = mergeObjects([combinedOpts, newQueryOpts]);\n    } else {\n      combinedOpts = newQueryOpts;\n    }\n  });\n\n  return {\n    queryOpts: combinedOpts,\n    inMemoryFields: inMemoryFields\n  };\n}\n\nfunction getMultiFieldCoreQueryPlan(userOperator, userValue) {\n  switch (userOperator) {\n    case '$eq':\n      return {\n        startkey: userValue,\n        endkey: userValue\n      };\n    case '$lte':\n      return {\n        endkey: userValue\n      };\n    case '$gte':\n      return {\n        startkey: userValue\n      };\n    case '$lt':\n      return {\n        endkey: userValue,\n        inclusive_end: false\n      };\n    case '$gt':\n      return {\n        startkey: userValue,\n        inclusive_start: false\n      };\n  }\n}\n\nfunction getMultiFieldQueryOpts(selector, index) {\n\n  var indexFields = index.def.fields.map(getKey);\n\n  var inMemoryFields = [];\n  var startkey = [];\n  var endkey = [];\n  var inclusiveStart;\n  var inclusiveEnd;\n\n\n  function finish(i) {\n\n    if (inclusiveStart !== false) {\n      startkey.push(COLLATE_LO);\n    }\n    if (inclusiveEnd !== false) {\n      endkey.push(COLLATE_HI);\n    }\n    // keep track of the fields where we lost specificity,\n    // and therefore need to filter in-memory\n    inMemoryFields = indexFields.slice(i);\n  }\n\n  for (var i = 0, len = indexFields.length; i < len; i++) {\n    var indexField = indexFields[i];\n\n    var matcher = selector[indexField];\n\n    if (!matcher || !Object.keys(matcher).length) { // fewer fields in user query than in index\n      finish(i);\n      break;\n    } else if (Object.keys(matcher).some(isNonLogicalMatcher)) { // non-logical are ignored\n      finish(i);\n      break;\n    } else if (i > 0) {\n      var usingGtlt = (\n        '$gt' in matcher || '$gte' in matcher ||\n        '$lt' in matcher || '$lte' in matcher);\n      var previousKeys = Object.keys(selector[indexFields[i - 1]]);\n      var previousWasEq = arrayEquals(previousKeys, ['$eq']);\n      var previousWasSame = arrayEquals(previousKeys, Object.keys(matcher));\n      var gtltLostSpecificity = usingGtlt && !previousWasEq && !previousWasSame;\n      if (gtltLostSpecificity) {\n        finish(i);\n        break;\n      }\n    }\n\n    var userOperators = Object.keys(matcher);\n\n    var combinedOpts = null;\n\n    for (var j = 0; j < userOperators.length; j++) {\n      var userOperator = userOperators[j];\n      var userValue = matcher[userOperator];\n\n      var newOpts = getMultiFieldCoreQueryPlan(userOperator, userValue);\n\n      if (combinedOpts) {\n        combinedOpts = mergeObjects([combinedOpts, newOpts]);\n      } else {\n        combinedOpts = newOpts;\n      }\n    }\n\n    startkey.push('startkey' in combinedOpts ? combinedOpts.startkey : COLLATE_LO);\n    endkey.push('endkey' in combinedOpts ? combinedOpts.endkey : COLLATE_HI);\n    if ('inclusive_start' in combinedOpts) {\n      inclusiveStart = combinedOpts.inclusive_start;\n    }\n    if ('inclusive_end' in combinedOpts) {\n      inclusiveEnd = combinedOpts.inclusive_end;\n    }\n  }\n\n  var res = {\n    startkey: startkey,\n    endkey: endkey\n  };\n\n  if (typeof inclusiveStart !== 'undefined') {\n    res.inclusive_start = inclusiveStart;\n  }\n  if (typeof inclusiveEnd !== 'undefined') {\n    res.inclusive_end = inclusiveEnd;\n  }\n\n  return {\n    queryOpts: res,\n    inMemoryFields: inMemoryFields\n  };\n}\n\nfunction shouldShortCircuit(selector) {\n  // We have a field to select from, but not a valid value\n  // this should result in a short circuited query \n  // just like the http adapter (couchdb) and mongodb\n  // see tests for issue #7810\n  \n  // @todo Use 'Object.values' when Node.js v6 support is dropped.\n  const values = Object.keys(selector).map(function (key) {\n    return selector[key];\n  });\n  return values.some(function (val) { \n    return typeof val === 'object' && Object.keys(val).length === 0;\n});\n}\n\nfunction getDefaultQueryPlan(selector) {\n  //using default index, so all fields need to be done in memory\n  return {\n    queryOpts: {startkey: null},\n    inMemoryFields: [Object.keys(selector)]\n  };\n}\n\nfunction getCoreQueryPlan(selector, index) {\n  if (index.defaultUsed) {\n    return getDefaultQueryPlan(selector, index);\n  }\n\n  if (index.def.fields.length === 1) {\n    // one field in index, so the value was indexed as a singleton\n    return getSingleFieldCoreQueryPlan(selector, index);\n  }\n  // else index has multiple fields, so the value was indexed as an array\n  return getMultiFieldQueryOpts(selector, index);\n}\n\nfunction planQuery(request, indexes) {\n\n  var selector = request.selector;\n  var sort = request.sort;\n\n  if (shouldShortCircuit(selector)) {\n    return assign({}, SHORT_CIRCUIT_QUERY, { index: indexes[0] });\n  }\n\n  var userFieldsRes = getUserFields(selector, sort);\n\n  var userFields = userFieldsRes.fields;\n  var sortOrder = userFieldsRes.sortOrder;\n  var index = findBestMatchingIndex(selector, userFields, sortOrder, indexes, request.use_index);\n\n  var coreQueryPlan = getCoreQueryPlan(selector, index);\n  var queryOpts = coreQueryPlan.queryOpts;\n  var coreInMemoryFields = coreQueryPlan.inMemoryFields;\n\n  var inMemoryFields = getInMemoryFields(coreInMemoryFields, index, selector, userFields);\n\n  var res = {\n    queryOpts: queryOpts,\n    index: index,\n    inMemoryFields: inMemoryFields\n  };\n  return res;\n}\n\nfunction indexToSignature(index) {\n  // remove '_design/'\n  return index.ddoc.substring(8) + '/' + index.name;\n}\n\nfunction doAllDocs(db, originalOpts) {\n  var opts = clone(originalOpts);\n\n  // CouchDB responds in weird ways when you provide a non-string to _id;\n  // we mimic the behavior for consistency. See issue66 tests for details.\n  if (opts.descending) {\n    if ('endkey' in opts && typeof opts.endkey !== 'string') {\n      opts.endkey = '';\n    }\n    if ('startkey' in opts && typeof opts.startkey !== 'string') {\n      opts.limit = 0;\n    }\n  } else {\n    if ('startkey' in opts && typeof opts.startkey !== 'string') {\n      opts.startkey = '';\n    }\n    if ('endkey' in opts && typeof opts.endkey !== 'string') {\n      opts.limit = 0;\n    }\n  }\n  if ('key' in opts && typeof opts.key !== 'string') {\n    opts.limit = 0;\n  }\n\n  if (opts.limit > 0 && opts.indexes_count) {\n    // brute force and quite naive impl.\n    // amp up the limit with the amount of (indexes) design docs\n    // or is this too naive? How about skip?\n    opts.original_limit = opts.limit;\n    opts.limit += opts.indexes_count;\n  }\n\n  return db.allDocs(opts)\n    .then(function (res) {\n      // filter out any design docs that _all_docs might return\n      res.rows = res.rows.filter(function (row) {\n        return !/^_design\\//.test(row.id);\n      });\n      // put back original limit\n      if (opts.original_limit) {\n        opts.limit = opts.original_limit;\n      }\n      // enforce the rows to respect the given limit\n      res.rows = res.rows.slice(0, opts.limit);\n      return res;\n    });\n}\n\nfunction find$1(db, requestDef, explain) {\n  if (requestDef.selector) {\n    // must be validated before massaging\n    validateSelector(requestDef.selector, false);\n    requestDef.selector = massageSelector(requestDef.selector);\n  }\n\n  if (requestDef.sort) {\n    requestDef.sort = massageSort(requestDef.sort);\n  }\n\n  if (requestDef.use_index) {\n    requestDef.use_index = massageUseIndex(requestDef.use_index);\n  }\n\n  validateFindRequest(requestDef);\n\n  return getIndexes$1(db).then(function (getIndexesRes) {\n\n    db.constructor.emit('debug', ['find', 'planning query', requestDef]);\n    var queryPlan = planQuery(requestDef, getIndexesRes.indexes);\n    db.constructor.emit('debug', ['find', 'query plan', queryPlan]);\n\n    var indexToUse = queryPlan.index;\n\n    validateSort(requestDef, indexToUse);\n\n    var opts = assign({\n      include_docs: true,\n      reduce: false,\n      // Add amount of index for doAllDocs to use (related to issue #7810)\n      indexes_count: getIndexesRes.total_rows,\n    }, queryPlan.queryOpts);\n\n    if ('startkey' in opts && 'endkey' in opts &&\n        collate(opts.startkey, opts.endkey) > 0) {\n      // can't possibly return any results, startkey > endkey\n      /* istanbul ignore next */\n      return {docs: []};\n    }\n\n    var isDescending = requestDef.sort &&\n      typeof requestDef.sort[0] !== 'string' &&\n      getValue(requestDef.sort[0]) === 'desc';\n\n    if (isDescending) {\n      // either all descending or all ascending\n      opts.descending = true;\n      opts = reverseOptions(opts);\n    }\n\n    if (!queryPlan.inMemoryFields.length) {\n      // no in-memory filtering necessary, so we can let the\n      // database do the limit/skip for us\n      if ('limit' in requestDef) {\n        opts.limit = requestDef.limit;\n      }\n      if ('skip' in requestDef) {\n        opts.skip = requestDef.skip;\n      }\n    }\n\n    if (explain) {\n      return Promise.resolve(queryPlan, opts);\n    }\n\n    return Promise.resolve().then(function () {\n      if (indexToUse.name === '_all_docs') {\n        return doAllDocs(db, opts);\n      } else {\n        var signature = indexToSignature(indexToUse);\n        return abstractMapper$1(db).query.call(db, signature, opts);\n      }\n    }).then(function (res) {\n      if (opts.inclusive_start === false) {\n        // may have to manually filter the first one,\n        // since couchdb has no true inclusive_start option\n        res.rows = filterInclusiveStart(res.rows, opts.startkey, indexToUse);\n      }\n\n      if (queryPlan.inMemoryFields.length) {\n        // need to filter some stuff in-memory\n        res.rows = filterInMemoryFields(res.rows, requestDef, queryPlan.inMemoryFields);\n      }\n\n      var resp = {\n        docs: res.rows.map(function (row) {\n          var doc = row.doc;\n          if (requestDef.fields) {\n            return pick(doc, requestDef.fields);\n          }\n          return doc;\n        })\n      };\n\n      if (indexToUse.defaultUsed) {\n        resp.warning = 'No matching index found, create an index to optimize query time.';\n      }\n\n      return resp;\n    });\n  });\n}\n\nfunction explain$1(db, requestDef) {\n  return find$1(db, requestDef, true)\n  .then(function (queryPlan) {\n    return {\n      dbname: db.name,\n      index: queryPlan.index,\n      selector: requestDef.selector,\n      range: {\n        start_key: queryPlan.queryOpts.startkey,\n        end_key: queryPlan.queryOpts.endkey,\n      },\n      opts: {\n        use_index: requestDef.use_index || [],\n        bookmark: \"nil\", //hardcoded to match CouchDB since its not supported,\n        limit: requestDef.limit,\n        skip: requestDef.skip,\n        sort: requestDef.sort || {},\n        fields: requestDef.fields,\n        conflicts: false, //hardcoded to match CouchDB since its not supported,\n        r: [49], // hardcoded to match CouchDB since its not support\n      },\n      limit: requestDef.limit,\n      skip: requestDef.skip || 0,\n      fields: requestDef.fields,\n    };\n  });\n}\n\nfunction deleteIndex$1(db, index) {\n\n  if (!index.ddoc) {\n    throw new Error('you must supply an index.ddoc when deleting');\n  }\n\n  if (!index.name) {\n    throw new Error('you must supply an index.name when deleting');\n  }\n\n  var docId = index.ddoc;\n  var viewName = index.name;\n\n  function deltaFun(doc) {\n    if (Object.keys(doc.views).length === 1 && doc.views[viewName]) {\n      // only one view in this ddoc, delete the whole ddoc\n      return {_id: docId, _deleted: true};\n    }\n    // more than one view here, just remove the view\n    delete doc.views[viewName];\n    return doc;\n  }\n\n  return upsert(db, docId, deltaFun).then(function () {\n    return abstractMapper$1(db).viewCleanup.apply(db);\n  }).then(function () {\n    return {ok: true};\n  });\n}\n\nvar createIndexAsCallback = callbackify(createIndex$1);\nvar findAsCallback = callbackify(find$1);\nvar explainAsCallback = callbackify(explain$1);\nvar getIndexesAsCallback = callbackify(getIndexes$1);\nvar deleteIndexAsCallback = callbackify(deleteIndex$1);\n\nvar plugin = {};\nplugin.createIndex = toPromise(function (requestDef, callback) {\n\n  if (typeof requestDef !== 'object') {\n    return callback(new Error('you must provide an index to create'));\n  }\n\n  var createIndex$$1 = isRemote(this) ?\n    createIndex : createIndexAsCallback;\n  createIndex$$1(this, requestDef, callback);\n});\n\nplugin.find = toPromise(function (requestDef, callback) {\n\n  if (typeof callback === 'undefined') {\n    callback = requestDef;\n    requestDef = undefined;\n  }\n\n  if (typeof requestDef !== 'object') {\n    return callback(new Error('you must provide search parameters to find()'));\n  }\n\n  var find$$1 = isRemote(this) ? find : findAsCallback;\n  find$$1(this, requestDef, callback);\n});\n\nplugin.explain = toPromise(function (requestDef, callback) {\n\n  if (typeof callback === 'undefined') {\n    callback = requestDef;\n    requestDef = undefined;\n  }\n\n  if (typeof requestDef !== 'object') {\n    return callback(new Error('you must provide search parameters to explain()'));\n  }\n\n  var find$$1 = isRemote(this) ? explain : explainAsCallback;\n  find$$1(this, requestDef, callback);\n});\n\nplugin.getIndexes = toPromise(function (callback) {\n\n  var getIndexes$$1 = isRemote(this) ? getIndexes : getIndexesAsCallback;\n  getIndexes$$1(this, callback);\n});\n\nplugin.deleteIndex = toPromise(function (indexDef, callback) {\n\n  if (typeof indexDef !== 'object') {\n    return callback(new Error('you must provide an index to delete'));\n  }\n\n  var deleteIndex$$1 = isRemote(this) ?\n    deleteIndex : deleteIndexAsCallback;\n  deleteIndex$$1(this, indexDef, callback);\n});\n\nexport default plugin;\n","import immediate from 'immediate';\nimport { v4 } from 'uuid';\nimport Md5 from 'spark-md5';\nimport vuvuzela from 'vuvuzela';\nimport getArguments from 'argsarray';\nimport inherits from 'inherits';\nimport EE from 'events';\n\nfunction mangle(key) {\n  return '$' + key;\n}\nfunction unmangle(key) {\n  return key.substring(1);\n}\nfunction Map$1() {\n  this._store = {};\n}\nMap$1.prototype.get = function (key) {\n  var mangled = mangle(key);\n  return this._store[mangled];\n};\nMap$1.prototype.set = function (key, value) {\n  var mangled = mangle(key);\n  this._store[mangled] = value;\n  return true;\n};\nMap$1.prototype.has = function (key) {\n  var mangled = mangle(key);\n  return mangled in this._store;\n};\nMap$1.prototype.keys = function () {\n  return Object.keys(this._store).map(k => unmangle(k));\n};\nMap$1.prototype.delete = function (key) {\n  var mangled = mangle(key);\n  var res = mangled in this._store;\n  delete this._store[mangled];\n  return res;\n};\nMap$1.prototype.forEach = function (cb) {\n  var keys = Object.keys(this._store);\n  for (var i = 0, len = keys.length; i < len; i++) {\n    var key = keys[i];\n    var value = this._store[key];\n    key = unmangle(key);\n    cb(value, key);\n  }\n};\nObject.defineProperty(Map$1.prototype, 'size', {\n  get: function () {\n    return Object.keys(this._store).length;\n  }\n});\n\nfunction Set$1(array) {\n  this._store = new Map$1();\n\n  // init with an array\n  if (array && Array.isArray(array)) {\n    for (var i = 0, len = array.length; i < len; i++) {\n      this.add(array[i]);\n    }\n  }\n}\nSet$1.prototype.add = function (key) {\n  return this._store.set(key, true);\n};\nSet$1.prototype.has = function (key) {\n  return this._store.has(key);\n};\nSet$1.prototype.forEach = function (cb) {\n  this._store.forEach(function (value, key) {\n    cb(key);\n  });\n};\nObject.defineProperty(Set$1.prototype, 'size', {\n  get: function () {\n    return this._store.size;\n  }\n});\n\n// Based on https://kangax.github.io/compat-table/es6/ we can sniff out\n// incomplete Map/Set implementations which would otherwise cause our tests to fail.\n// Notably they fail in IE11 and iOS 8.4, which this prevents.\nfunction supportsMapAndSet() {\n  if (typeof Symbol === 'undefined' || typeof Map === 'undefined' || typeof Set === 'undefined') {\n    return false;\n  }\n  var prop = Object.getOwnPropertyDescriptor(Map, Symbol.species);\n  return prop && 'get' in prop && Map[Symbol.species] === Map;\n}\n\n// based on https://github.com/montagejs/collections\n\nvar ExportedSet;\nvar ExportedMap;\n\n{\n  if (supportsMapAndSet()) { // prefer built-in Map/Set\n    ExportedSet = Set;\n    ExportedMap = Map;\n  } else { // fall back to our polyfill\n    ExportedSet = Set$1;\n    ExportedMap = Map$1;\n  }\n}\n\nfunction isBinaryObject(object) {\n  return (typeof ArrayBuffer !== 'undefined' && object instanceof ArrayBuffer) ||\n    (typeof Blob !== 'undefined' && object instanceof Blob);\n}\n\nfunction cloneArrayBuffer(buff) {\n  if (typeof buff.slice === 'function') {\n    return buff.slice(0);\n  }\n  // IE10-11 slice() polyfill\n  var target = new ArrayBuffer(buff.byteLength);\n  var targetArray = new Uint8Array(target);\n  var sourceArray = new Uint8Array(buff);\n  targetArray.set(sourceArray);\n  return target;\n}\n\nfunction cloneBinaryObject(object) {\n  if (object instanceof ArrayBuffer) {\n    return cloneArrayBuffer(object);\n  }\n  var size = object.size;\n  var type = object.type;\n  // Blob\n  if (typeof object.slice === 'function') {\n    return object.slice(0, size, type);\n  }\n  // PhantomJS slice() replacement\n  return object.webkitSlice(0, size, type);\n}\n\n// most of this is borrowed from lodash.isPlainObject:\n// https://github.com/fis-components/lodash.isplainobject/\n// blob/29c358140a74f252aeb08c9eb28bef86f2217d4a/index.js\n\nvar funcToString = Function.prototype.toString;\nvar objectCtorString = funcToString.call(Object);\n\nfunction isPlainObject(value) {\n  var proto = Object.getPrototypeOf(value);\n  /* istanbul ignore if */\n  if (proto === null) { // not sure when this happens, but I guess it can\n    return true;\n  }\n  var Ctor = proto.constructor;\n  return (typeof Ctor == 'function' &&\n    Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString);\n}\n\nfunction clone(object) {\n  var newObject;\n  var i;\n  var len;\n\n  if (!object || typeof object !== 'object') {\n    return object;\n  }\n\n  if (Array.isArray(object)) {\n    newObject = [];\n    for (i = 0, len = object.length; i < len; i++) {\n      newObject[i] = clone(object[i]);\n    }\n    return newObject;\n  }\n\n  // special case: to avoid inconsistencies between IndexedDB\n  // and other backends, we automatically stringify Dates\n  if (object instanceof Date && isFinite(object)) {\n    return object.toISOString();\n  }\n\n  if (isBinaryObject(object)) {\n    return cloneBinaryObject(object);\n  }\n\n  if (!isPlainObject(object)) {\n    return object; // don't clone objects like Workers\n  }\n\n  newObject = {};\n  for (i in object) {\n    /* istanbul ignore else */\n    if (Object.prototype.hasOwnProperty.call(object, i)) {\n      var value = clone(object[i]);\n      if (typeof value !== 'undefined') {\n        newObject[i] = value;\n      }\n    }\n  }\n  return newObject;\n}\n\nfunction once(fun) {\n  var called = false;\n  return getArguments(function (args) {\n    /* istanbul ignore if */\n    if (called) {\n      // this is a smoke test and should never actually happen\n      throw new Error('once called more than once');\n    } else {\n      called = true;\n      fun.apply(this, args);\n    }\n  });\n}\n\nfunction toPromise(func) {\n  //create the function we will be returning\n  return getArguments(function (args) {\n    // Clone arguments\n    args = clone(args);\n    var self = this;\n    // if the last argument is a function, assume its a callback\n    var usedCB = (typeof args[args.length - 1] === 'function') ? args.pop() : false;\n    var promise = new Promise(function (fulfill, reject) {\n      var resp;\n      try {\n        var callback = once(function (err, mesg) {\n          if (err) {\n            reject(err);\n          } else {\n            fulfill(mesg);\n          }\n        });\n        // create a callback for this invocation\n        // apply the function in the orig context\n        args.push(callback);\n        resp = func.apply(self, args);\n        if (resp && typeof resp.then === 'function') {\n          fulfill(resp);\n        }\n      } catch (e) {\n        reject(e);\n      }\n    });\n    // if there is a callback, call it back\n    if (usedCB) {\n      promise.then(function (result) {\n        usedCB(null, result);\n      }, usedCB);\n    }\n    return promise;\n  });\n}\n\nfunction logApiCall(self, name, args) {\n  /* istanbul ignore if */\n  if (self.constructor.listeners('debug').length) {\n    var logArgs = ['api', self.name, name];\n    for (var i = 0; i < args.length - 1; i++) {\n      logArgs.push(args[i]);\n    }\n    self.constructor.emit('debug', logArgs);\n\n    // override the callback itself to log the response\n    var origCallback = args[args.length - 1];\n    args[args.length - 1] = function (err, res) {\n      var responseArgs = ['api', self.name, name];\n      responseArgs = responseArgs.concat(\n        err ? ['error', err] : ['success', res]\n      );\n      self.constructor.emit('debug', responseArgs);\n      origCallback(err, res);\n    };\n  }\n}\n\nfunction adapterFun(name, callback) {\n  return toPromise(getArguments(function (args) {\n    if (this._closed) {\n      return Promise.reject(new Error('database is closed'));\n    }\n    if (this._destroyed) {\n      return Promise.reject(new Error('database is destroyed'));\n    }\n    var self = this;\n    logApiCall(self, name, args);\n    if (!this.taskqueue.isReady) {\n      return new Promise(function (fulfill, reject) {\n        self.taskqueue.addTask(function (failed) {\n          if (failed) {\n            reject(failed);\n          } else {\n            fulfill(self[name].apply(self, args));\n          }\n        });\n      });\n    }\n    return callback.apply(this, args);\n  }));\n}\n\n// like underscore/lodash _.pick()\nfunction pick(obj, arr) {\n  var res = {};\n  for (var i = 0, len = arr.length; i < len; i++) {\n    var prop = arr[i];\n    if (prop in obj) {\n      res[prop] = obj[prop];\n    }\n  }\n  return res;\n}\n\n// Most browsers throttle concurrent requests at 6, so it's silly\n// to shim _bulk_get by trying to launch potentially hundreds of requests\n// and then letting the majority time out. We can handle this ourselves.\nvar MAX_NUM_CONCURRENT_REQUESTS = 6;\n\nfunction identityFunction(x) {\n  return x;\n}\n\nfunction formatResultForOpenRevsGet(result) {\n  return [{\n    ok: result\n  }];\n}\n\n// shim for P/CouchDB adapters that don't directly implement _bulk_get\nfunction bulkGet(db, opts, callback) {\n  var requests = opts.docs;\n\n  // consolidate into one request per doc if possible\n  var requestsById = new ExportedMap();\n  requests.forEach(function (request) {\n    if (requestsById.has(request.id)) {\n      requestsById.get(request.id).push(request);\n    } else {\n      requestsById.set(request.id, [request]);\n    }\n  });\n\n  var numDocs = requestsById.size;\n  var numDone = 0;\n  var perDocResults = new Array(numDocs);\n\n  function collapseResultsAndFinish() {\n    var results = [];\n    perDocResults.forEach(function (res) {\n      res.docs.forEach(function (info) {\n        results.push({\n          id: res.id,\n          docs: [info]\n        });\n      });\n    });\n    callback(null, {results: results});\n  }\n\n  function checkDone() {\n    if (++numDone === numDocs) {\n      collapseResultsAndFinish();\n    }\n  }\n\n  function gotResult(docIndex, id, docs) {\n    perDocResults[docIndex] = {id: id, docs: docs};\n    checkDone();\n  }\n\n  var allRequests = [];\n  requestsById.forEach(function (value, key) {\n    allRequests.push(key);\n  });\n\n  var i = 0;\n\n  function nextBatch() {\n\n    if (i >= allRequests.length) {\n      return;\n    }\n\n    var upTo = Math.min(i + MAX_NUM_CONCURRENT_REQUESTS, allRequests.length);\n    var batch = allRequests.slice(i, upTo);\n    processBatch(batch, i);\n    i += batch.length;\n  }\n\n  function processBatch(batch, offset) {\n    batch.forEach(function (docId, j) {\n      var docIdx = offset + j;\n      var docRequests = requestsById.get(docId);\n\n      // just use the first request as the \"template\"\n      // TODO: The _bulk_get API allows for more subtle use cases than this,\n      // but for now it is unlikely that there will be a mix of different\n      // \"atts_since\" or \"attachments\" in the same request, since it's just\n      // replicate.js that is using this for the moment.\n      // Also, atts_since is aspirational, since we don't support it yet.\n      var docOpts = pick(docRequests[0], ['atts_since', 'attachments']);\n      docOpts.open_revs = docRequests.map(function (request) {\n        // rev is optional, open_revs disallowed\n        return request.rev;\n      });\n\n      // remove falsey / undefined revisions\n      docOpts.open_revs = docOpts.open_revs.filter(identityFunction);\n\n      var formatResult = identityFunction;\n\n      if (docOpts.open_revs.length === 0) {\n        delete docOpts.open_revs;\n\n        // when fetching only the \"winning\" leaf,\n        // transform the result so it looks like an open_revs\n        // request\n        formatResult = formatResultForOpenRevsGet;\n      }\n\n      // globally-supplied options\n      ['revs', 'attachments', 'binary', 'ajax', 'latest'].forEach(function (param) {\n        if (param in opts) {\n          docOpts[param] = opts[param];\n        }\n      });\n      db.get(docId, docOpts, function (err, res) {\n        var result;\n        /* istanbul ignore if */\n        if (err) {\n          result = [{error: err}];\n        } else {\n          result = formatResult(res);\n        }\n        gotResult(docIdx, docId, result);\n        nextBatch();\n      });\n    });\n  }\n\n  nextBatch();\n\n}\n\nvar hasLocal;\n\ntry {\n  localStorage.setItem('_pouch_check_localstorage', 1);\n  hasLocal = !!localStorage.getItem('_pouch_check_localstorage');\n} catch (e) {\n  hasLocal = false;\n}\n\nfunction hasLocalStorage() {\n  return hasLocal;\n}\n\n// Custom nextTick() shim for browsers. In node, this will just be process.nextTick(). We\n\ninherits(Changes, EE);\n\n/* istanbul ignore next */\nfunction attachBrowserEvents(self) {\n  if (hasLocalStorage()) {\n    addEventListener(\"storage\", function (e) {\n      self.emit(e.key);\n    });\n  }\n}\n\nfunction Changes() {\n  EE.call(this);\n  this._listeners = {};\n\n  attachBrowserEvents(this);\n}\nChanges.prototype.addListener = function (dbName, id, db, opts) {\n  /* istanbul ignore if */\n  if (this._listeners[id]) {\n    return;\n  }\n  var self = this;\n  var inprogress = false;\n  function eventFunction() {\n    /* istanbul ignore if */\n    if (!self._listeners[id]) {\n      return;\n    }\n    if (inprogress) {\n      inprogress = 'waiting';\n      return;\n    }\n    inprogress = true;\n    var changesOpts = pick(opts, [\n      'style', 'include_docs', 'attachments', 'conflicts', 'filter',\n      'doc_ids', 'view', 'since', 'query_params', 'binary', 'return_docs'\n    ]);\n\n    /* istanbul ignore next */\n    function onError() {\n      inprogress = false;\n    }\n\n    db.changes(changesOpts).on('change', function (c) {\n      if (c.seq > opts.since && !opts.cancelled) {\n        opts.since = c.seq;\n        opts.onChange(c);\n      }\n    }).on('complete', function () {\n      if (inprogress === 'waiting') {\n        immediate(eventFunction);\n      }\n      inprogress = false;\n    }).on('error', onError);\n  }\n  this._listeners[id] = eventFunction;\n  this.on(dbName, eventFunction);\n};\n\nChanges.prototype.removeListener = function (dbName, id) {\n  /* istanbul ignore if */\n  if (!(id in this._listeners)) {\n    return;\n  }\n  EE.prototype.removeListener.call(this, dbName,\n    this._listeners[id]);\n  delete this._listeners[id];\n};\n\n\n/* istanbul ignore next */\nChanges.prototype.notifyLocalWindows = function (dbName) {\n  //do a useless change on a storage thing\n  //in order to get other windows's listeners to activate\n  if (hasLocalStorage()) {\n    localStorage[dbName] = (localStorage[dbName] === \"a\") ? \"b\" : \"a\";\n  }\n};\n\nChanges.prototype.notify = function (dbName) {\n  this.emit(dbName);\n  this.notifyLocalWindows(dbName);\n};\n\nfunction guardedConsole(method) {\n  /* istanbul ignore else */\n  if (typeof console !== 'undefined' && typeof console[method] === 'function') {\n    var args = Array.prototype.slice.call(arguments, 1);\n    console[method].apply(console, args);\n  }\n}\n\nfunction randomNumber(min, max) {\n  var maxTimeout = 600000; // Hard-coded default of 10 minutes\n  min = parseInt(min, 10) || 0;\n  max = parseInt(max, 10);\n  if (max !== max || max <= min) {\n    max = (min || 1) << 1; //doubling\n  } else {\n    max = max + 1;\n  }\n  // In order to not exceed maxTimeout, pick a random value between half of maxTimeout and maxTimeout\n  if (max > maxTimeout) {\n    min = maxTimeout >> 1; // divide by two\n    max = maxTimeout;\n  }\n  var ratio = Math.random();\n  var range = max - min;\n\n  return ~~(range * ratio + min); // ~~ coerces to an int, but fast.\n}\n\nfunction defaultBackOff(min) {\n  var max = 0;\n  if (!min) {\n    max = 2000;\n  }\n  return randomNumber(min, max);\n}\n\n// designed to give info to browser users, who are disturbed\n// when they see http errors in the console\nfunction explainError(status, str) {\n  guardedConsole('info', 'The above ' + status + ' is totally normal. ' + str);\n}\n\nvar assign;\n{\n  if (typeof Object.assign === 'function') {\n    assign = Object.assign;\n  } else {\n    // lite Object.assign polyfill based on\n    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign\n    assign = function (target) {\n      var to = Object(target);\n\n      for (var index = 1; index < arguments.length; index++) {\n        var nextSource = arguments[index];\n\n        if (nextSource != null) { // Skip over if undefined or null\n          for (var nextKey in nextSource) {\n            // Avoid bugs when hasOwnProperty is shadowed\n            if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {\n              to[nextKey] = nextSource[nextKey];\n            }\n          }\n        }\n      }\n      return to;\n    };\n  }\n}\n\nvar $inject_Object_assign = assign;\n\ninherits(PouchError, Error);\n\nfunction PouchError(status, error, reason) {\n  Error.call(this, reason);\n  this.status = status;\n  this.name = error;\n  this.message = reason;\n  this.error = true;\n}\n\nPouchError.prototype.toString = function () {\n  return JSON.stringify({\n    status: this.status,\n    name: this.name,\n    message: this.message,\n    reason: this.reason\n  });\n};\n\nvar UNAUTHORIZED = new PouchError(401, 'unauthorized', \"Name or password is incorrect.\");\nvar MISSING_BULK_DOCS = new PouchError(400, 'bad_request', \"Missing JSON list of 'docs'\");\nvar MISSING_DOC = new PouchError(404, 'not_found', 'missing');\nvar REV_CONFLICT = new PouchError(409, 'conflict', 'Document update conflict');\nvar INVALID_ID = new PouchError(400, 'bad_request', '_id field must contain a string');\nvar MISSING_ID = new PouchError(412, 'missing_id', '_id is required for puts');\nvar RESERVED_ID = new PouchError(400, 'bad_request', 'Only reserved document ids may start with underscore.');\nvar NOT_OPEN = new PouchError(412, 'precondition_failed', 'Database not open');\nvar UNKNOWN_ERROR = new PouchError(500, 'unknown_error', 'Database encountered an unknown error');\nvar BAD_ARG = new PouchError(500, 'badarg', 'Some query argument is invalid');\nvar INVALID_REQUEST = new PouchError(400, 'invalid_request', 'Request was invalid');\nvar QUERY_PARSE_ERROR = new PouchError(400, 'query_parse_error', 'Some query parameter is invalid');\nvar DOC_VALIDATION = new PouchError(500, 'doc_validation', 'Bad special document member');\nvar BAD_REQUEST = new PouchError(400, 'bad_request', 'Something wrong with the request');\nvar NOT_AN_OBJECT = new PouchError(400, 'bad_request', 'Document must be a JSON object');\nvar DB_MISSING = new PouchError(404, 'not_found', 'Database not found');\nvar IDB_ERROR = new PouchError(500, 'indexed_db_went_bad', 'unknown');\nvar WSQ_ERROR = new PouchError(500, 'web_sql_went_bad', 'unknown');\nvar LDB_ERROR = new PouchError(500, 'levelDB_went_went_bad', 'unknown');\nvar FORBIDDEN = new PouchError(403, 'forbidden', 'Forbidden by design doc validate_doc_update function');\nvar INVALID_REV = new PouchError(400, 'bad_request', 'Invalid rev format');\nvar FILE_EXISTS = new PouchError(412, 'file_exists', 'The database could not be created, the file already exists.');\nvar MISSING_STUB = new PouchError(412, 'missing_stub', 'A pre-existing attachment stub wasn\\'t found');\nvar INVALID_URL = new PouchError(413, 'invalid_url', 'Provided URL is invalid');\n\nfunction createError(error, reason) {\n  function CustomPouchError(reason) {\n    // inherit error properties from our parent error manually\n    // so as to allow proper JSON parsing.\n    /* jshint ignore:start */\n    var names = Object.getOwnPropertyNames(error);\n    for (var i = 0, len = names.length; i < len; i++) {\n      if (typeof error[names[i]] !== 'function') {\n        this[names[i]] = error[names[i]];\n      }\n    }\n\n    if (this.stack === undefined) {\n      this.stack = (new Error()).stack;\n    }\n\n    /* jshint ignore:end */\n    if (reason !== undefined) {\n      this.reason = reason;\n    }\n  }\n  CustomPouchError.prototype = PouchError.prototype;\n  return new CustomPouchError(reason);\n}\n\nfunction generateErrorFromResponse(err) {\n\n  if (typeof err !== 'object') {\n    var data = err;\n    err = UNKNOWN_ERROR;\n    err.data = data;\n  }\n\n  if ('error' in err && err.error === 'conflict') {\n    err.name = 'conflict';\n    err.status = 409;\n  }\n\n  if (!('name' in err)) {\n    err.name = err.error || 'unknown';\n  }\n\n  if (!('status' in err)) {\n    err.status = 500;\n  }\n\n  if (!('message' in err)) {\n    err.message = err.message || err.reason;\n  }\n\n  if (!('stack' in err)) {\n    err.stack = (new Error()).stack;\n  }\n\n  return err;\n}\n\nfunction tryFilter(filter, doc, req) {\n  try {\n    return !filter(doc, req);\n  } catch (err) {\n    var msg = 'Filter function threw: ' + err.toString();\n    return createError(BAD_REQUEST, msg);\n  }\n}\n\nfunction filterChange(opts) {\n  var req = {};\n  var hasFilter = opts.filter && typeof opts.filter === 'function';\n  req.query = opts.query_params;\n\n  return function filter(change) {\n    if (!change.doc) {\n      // CSG sends events on the changes feed that don't have documents,\n      // this hack makes a whole lot of existing code robust.\n      change.doc = {};\n    }\n\n    var filterReturn = hasFilter && tryFilter(opts.filter, change.doc, req);\n\n    if (typeof filterReturn === 'object') {\n      return filterReturn;\n    }\n\n    if (filterReturn) {\n      return false;\n    }\n\n    if (!opts.include_docs) {\n      delete change.doc;\n    } else if (!opts.attachments) {\n      for (var att in change.doc._attachments) {\n        /* istanbul ignore else */\n        if (Object.prototype.hasOwnProperty.call(change.doc._attachments, att)) {\n          change.doc._attachments[att].stub = true;\n        }\n      }\n    }\n    return true;\n  };\n}\n\nfunction flatten(arrs) {\n  var res = [];\n  for (var i = 0, len = arrs.length; i < len; i++) {\n    res = res.concat(arrs[i]);\n  }\n  return res;\n}\n\n// shim for Function.prototype.name,\n\n// Determine id an ID is valid\n//   - invalid IDs begin with an underescore that does not begin '_design' or\n//     '_local'\n//   - any other string value is a valid id\n// Returns the specific error object for each case\nfunction invalidIdError(id) {\n  var err;\n  if (!id) {\n    err = createError(MISSING_ID);\n  } else if (typeof id !== 'string') {\n    err = createError(INVALID_ID);\n  } else if (/^_/.test(id) && !(/^_(design|local)/).test(id)) {\n    err = createError(RESERVED_ID);\n  }\n  if (err) {\n    throw err;\n  }\n}\n\n// Checks if a PouchDB object is \"remote\" or not. This is\n\nfunction isRemote(db) {\n  if (typeof db._remote === 'boolean') {\n    return db._remote;\n  }\n  /* istanbul ignore next */\n  if (typeof db.type === 'function') {\n    guardedConsole('warn',\n      'db.type() is deprecated and will be removed in ' +\n      'a future version of PouchDB');\n    return db.type() === 'http';\n  }\n  /* istanbul ignore next */\n  return false;\n}\n\nfunction listenerCount(ee, type) {\n  return 'listenerCount' in ee ? ee.listenerCount(type) :\n                                 EE.listenerCount(ee, type);\n}\n\nfunction parseDesignDocFunctionName(s) {\n  if (!s) {\n    return null;\n  }\n  var parts = s.split('/');\n  if (parts.length === 2) {\n    return parts;\n  }\n  if (parts.length === 1) {\n    return [s, s];\n  }\n  return null;\n}\n\nfunction normalizeDesignDocFunctionName(s) {\n  var normalized = parseDesignDocFunctionName(s);\n  return normalized ? normalized.join('/') : null;\n}\n\n// originally parseUri 1.2.2, now patched by us\n// (c) Steven Levithan <stevenlevithan.com>\n// MIT License\nvar keys = [\"source\", \"protocol\", \"authority\", \"userInfo\", \"user\", \"password\",\n    \"host\", \"port\", \"relative\", \"path\", \"directory\", \"file\", \"query\", \"anchor\"];\nvar qName =\"queryKey\";\nvar qParser = /(?:^|&)([^&=]*)=?([^&]*)/g;\n\n// use the \"loose\" parser\n/* eslint no-useless-escape: 0 */\nvar parser = /^(?:(?![^:@]+:[^:@\\/]*@)([^:\\/?#.]+):)?(?:\\/\\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\\/?#]*)(?::(\\d*))?)(((\\/(?:[^?#](?![^?#\\/]*\\.[^?#\\/.]+(?:[?#]|$)))*\\/?)?([^?#\\/]*))(?:\\?([^#]*))?(?:#(.*))?)/;\n\nfunction parseUri(str) {\n  var m = parser.exec(str);\n  var uri = {};\n  var i = 14;\n\n  while (i--) {\n    var key = keys[i];\n    var value = m[i] || \"\";\n    var encoded = ['user', 'password'].indexOf(key) !== -1;\n    uri[key] = encoded ? decodeURIComponent(value) : value;\n  }\n\n  uri[qName] = {};\n  uri[keys[12]].replace(qParser, function ($0, $1, $2) {\n    if ($1) {\n      uri[qName][$1] = $2;\n    }\n  });\n\n  return uri;\n}\n\n// Based on https://github.com/alexdavid/scope-eval v0.0.3\n// (source: https://unpkg.com/scope-eval@0.0.3/scope_eval.js)\n// This is basically just a wrapper around new Function()\n\nfunction scopeEval(source, scope) {\n  var keys = [];\n  var values = [];\n  for (var key in scope) {\n    if (Object.prototype.hasOwnProperty.call(scope, key)) {\n      keys.push(key);\n      values.push(scope[key]);\n    }\n  }\n  keys.push(source);\n  return Function.apply(null, keys).apply(null, values);\n}\n\n// this is essentially the \"update sugar\" function from daleharvey/pouchdb#1388\n// the diffFun tells us what delta to apply to the doc.  it either returns\n// the doc, or false if it doesn't need to do an update after all\nfunction upsert(db, docId, diffFun) {\n  return db.get(docId)\n    .catch(function (err) {\n      /* istanbul ignore next */\n      if (err.status !== 404) {\n        throw err;\n      }\n      return {};\n    })\n    .then(function (doc) {\n      // the user might change the _rev, so save it for posterity\n      var docRev = doc._rev;\n      var newDoc = diffFun(doc);\n\n      if (!newDoc) {\n        // if the diffFun returns falsy, we short-circuit as\n        // an optimization\n        return {updated: false, rev: docRev};\n      }\n\n      // users aren't allowed to modify these values,\n      // so reset them here\n      newDoc._id = docId;\n      newDoc._rev = docRev;\n      return tryAndPut(db, newDoc, diffFun);\n    });\n}\n\nfunction tryAndPut(db, doc, diffFun) {\n  return db.put(doc).then(function (res) {\n    return {\n      updated: true,\n      rev: res.rev\n    };\n  }, function (err) {\n    /* istanbul ignore next */\n    if (err.status !== 409) {\n      throw err;\n    }\n    return upsert(db, doc._id, diffFun);\n  });\n}\n\nvar thisAtob = function (str) {\n  return atob(str);\n};\n\nvar thisBtoa = function (str) {\n  return btoa(str);\n};\n\n// Abstracts constructing a Blob object, so it also works in older\n// browsers that don't support the native Blob constructor (e.g.\n// old QtWebKit versions, Android < 4.4).\nfunction createBlob(parts, properties) {\n  /* global BlobBuilder,MSBlobBuilder,MozBlobBuilder,WebKitBlobBuilder */\n  parts = parts || [];\n  properties = properties || {};\n  try {\n    return new Blob(parts, properties);\n  } catch (e) {\n    if (e.name !== \"TypeError\") {\n      throw e;\n    }\n    var Builder = typeof BlobBuilder !== 'undefined' ? BlobBuilder :\n                  typeof MSBlobBuilder !== 'undefined' ? MSBlobBuilder :\n                  typeof MozBlobBuilder !== 'undefined' ? MozBlobBuilder :\n                  WebKitBlobBuilder;\n    var builder = new Builder();\n    for (var i = 0; i < parts.length; i += 1) {\n      builder.append(parts[i]);\n    }\n    return builder.getBlob(properties.type);\n  }\n}\n\n// From http://stackoverflow.com/questions/14967647/ (continues on next line)\n// encode-decode-image-with-base64-breaks-image (2013-04-21)\nfunction binaryStringToArrayBuffer(bin) {\n  var length = bin.length;\n  var buf = new ArrayBuffer(length);\n  var arr = new Uint8Array(buf);\n  for (var i = 0; i < length; i++) {\n    arr[i] = bin.charCodeAt(i);\n  }\n  return buf;\n}\n\nfunction binStringToBluffer(binString, type) {\n  return createBlob([binaryStringToArrayBuffer(binString)], {type: type});\n}\n\nfunction b64ToBluffer(b64, type) {\n  return binStringToBluffer(thisAtob(b64), type);\n}\n\n//Can't find original post, but this is close\n//http://stackoverflow.com/questions/6965107/ (continues on next line)\n//converting-between-strings-and-arraybuffers\nfunction arrayBufferToBinaryString(buffer) {\n  var binary = '';\n  var bytes = new Uint8Array(buffer);\n  var length = bytes.byteLength;\n  for (var i = 0; i < length; i++) {\n    binary += String.fromCharCode(bytes[i]);\n  }\n  return binary;\n}\n\n// shim for browsers that don't support it\nfunction readAsBinaryString(blob, callback) {\n  var reader = new FileReader();\n  var hasBinaryString = typeof reader.readAsBinaryString === 'function';\n  reader.onloadend = function (e) {\n    var result = e.target.result || '';\n    if (hasBinaryString) {\n      return callback(result);\n    }\n    callback(arrayBufferToBinaryString(result));\n  };\n  if (hasBinaryString) {\n    reader.readAsBinaryString(blob);\n  } else {\n    reader.readAsArrayBuffer(blob);\n  }\n}\n\nfunction blobToBinaryString(blobOrBuffer, callback) {\n  readAsBinaryString(blobOrBuffer, function (bin) {\n    callback(bin);\n  });\n}\n\nfunction blobToBase64(blobOrBuffer, callback) {\n  blobToBinaryString(blobOrBuffer, function (base64) {\n    callback(thisBtoa(base64));\n  });\n}\n\n// simplified API. universal browser support is assumed\nfunction readAsArrayBuffer(blob, callback) {\n  var reader = new FileReader();\n  reader.onloadend = function (e) {\n    var result = e.target.result || new ArrayBuffer(0);\n    callback(result);\n  };\n  reader.readAsArrayBuffer(blob);\n}\n\n// this is not used in the browser\n\nvar setImmediateShim = self.setImmediate || self.setTimeout;\nvar MD5_CHUNK_SIZE = 32768;\n\nfunction rawToBase64(raw) {\n  return thisBtoa(raw);\n}\n\nfunction sliceBlob(blob, start, end) {\n  if (blob.webkitSlice) {\n    return blob.webkitSlice(start, end);\n  }\n  return blob.slice(start, end);\n}\n\nfunction appendBlob(buffer, blob, start, end, callback) {\n  if (start > 0 || end < blob.size) {\n    // only slice blob if we really need to\n    blob = sliceBlob(blob, start, end);\n  }\n  readAsArrayBuffer(blob, function (arrayBuffer) {\n    buffer.append(arrayBuffer);\n    callback();\n  });\n}\n\nfunction appendString(buffer, string, start, end, callback) {\n  if (start > 0 || end < string.length) {\n    // only create a substring if we really need to\n    string = string.substring(start, end);\n  }\n  buffer.appendBinary(string);\n  callback();\n}\n\nfunction binaryMd5(data, callback) {\n  var inputIsString = typeof data === 'string';\n  var len = inputIsString ? data.length : data.size;\n  var chunkSize = Math.min(MD5_CHUNK_SIZE, len);\n  var chunks = Math.ceil(len / chunkSize);\n  var currentChunk = 0;\n  var buffer = inputIsString ? new Md5() : new Md5.ArrayBuffer();\n\n  var append = inputIsString ? appendString : appendBlob;\n\n  function next() {\n    setImmediateShim(loadNextChunk);\n  }\n\n  function done() {\n    var raw = buffer.end(true);\n    var base64 = rawToBase64(raw);\n    callback(base64);\n    buffer.destroy();\n  }\n\n  function loadNextChunk() {\n    var start = currentChunk * chunkSize;\n    var end = start + chunkSize;\n    currentChunk++;\n    if (currentChunk < chunks) {\n      append(buffer, data, start, end, next);\n    } else {\n      append(buffer, data, start, end, done);\n    }\n  }\n  loadNextChunk();\n}\n\nfunction stringMd5(string) {\n  return Md5.hash(string);\n}\n\n/**\n * Creates a new revision string that does NOT include the revision height\n * For example '56649f1b0506c6ca9fda0746eb0cacdf'\n */\nfunction rev$$1(doc, deterministic_revs) {\n  if (!deterministic_revs) {\n    return v4().replace(/-/g, '').toLowerCase();\n  }\n\n  var mutateableDoc = $inject_Object_assign({}, doc);\n  delete mutateableDoc._rev_tree;\n  return stringMd5(JSON.stringify(mutateableDoc));\n}\n\nvar uuid = v4; // mimic old import, only v4 is ever used elsewhere\n\n// We fetch all leafs of the revision tree, and sort them based on tree length\n// and whether they were deleted, undeleted documents with the longest revision\n// tree (most edits) win\n// The final sort algorithm is slightly documented in a sidebar here:\n// http://guide.couchdb.org/draft/conflicts.html\nfunction winningRev(metadata) {\n  var winningId;\n  var winningPos;\n  var winningDeleted;\n  var toVisit = metadata.rev_tree.slice();\n  var node;\n  while ((node = toVisit.pop())) {\n    var tree = node.ids;\n    var branches = tree[2];\n    var pos = node.pos;\n    if (branches.length) { // non-leaf\n      for (var i = 0, len = branches.length; i < len; i++) {\n        toVisit.push({pos: pos + 1, ids: branches[i]});\n      }\n      continue;\n    }\n    var deleted = !!tree[1].deleted;\n    var id = tree[0];\n    // sort by deleted, then pos, then id\n    if (!winningId || (winningDeleted !== deleted ? winningDeleted :\n        winningPos !== pos ? winningPos < pos : winningId < id)) {\n      winningId = id;\n      winningPos = pos;\n      winningDeleted = deleted;\n    }\n  }\n\n  return winningPos + '-' + winningId;\n}\n\n// Pretty much all below can be combined into a higher order function to\n// traverse revisions\n// The return value from the callback will be passed as context to all\n// children of that node\nfunction traverseRevTree(revs, callback) {\n  var toVisit = revs.slice();\n\n  var node;\n  while ((node = toVisit.pop())) {\n    var pos = node.pos;\n    var tree = node.ids;\n    var branches = tree[2];\n    var newCtx =\n      callback(branches.length === 0, pos, tree[0], node.ctx, tree[1]);\n    for (var i = 0, len = branches.length; i < len; i++) {\n      toVisit.push({pos: pos + 1, ids: branches[i], ctx: newCtx});\n    }\n  }\n}\n\nfunction sortByPos(a, b) {\n  return a.pos - b.pos;\n}\n\nfunction collectLeaves(revs) {\n  var leaves = [];\n  traverseRevTree(revs, function (isLeaf, pos, id, acc, opts) {\n    if (isLeaf) {\n      leaves.push({rev: pos + \"-\" + id, pos: pos, opts: opts});\n    }\n  });\n  leaves.sort(sortByPos).reverse();\n  for (var i = 0, len = leaves.length; i < len; i++) {\n    delete leaves[i].pos;\n  }\n  return leaves;\n}\n\n// returns revs of all conflicts that is leaves such that\n// 1. are not deleted and\n// 2. are different than winning revision\nfunction collectConflicts(metadata) {\n  var win = winningRev(metadata);\n  var leaves = collectLeaves(metadata.rev_tree);\n  var conflicts = [];\n  for (var i = 0, len = leaves.length; i < len; i++) {\n    var leaf = leaves[i];\n    if (leaf.rev !== win && !leaf.opts.deleted) {\n      conflicts.push(leaf.rev);\n    }\n  }\n  return conflicts;\n}\n\n// compact a tree by marking its non-leafs as missing,\n// and return a list of revs to delete\nfunction compactTree(metadata) {\n  var revs = [];\n  traverseRevTree(metadata.rev_tree, function (isLeaf, pos,\n                                               revHash, ctx, opts) {\n    if (opts.status === 'available' && !isLeaf) {\n      revs.push(pos + '-' + revHash);\n      opts.status = 'missing';\n    }\n  });\n  return revs;\n}\n\n// build up a list of all the paths to the leafs in this revision tree\nfunction rootToLeaf(revs) {\n  var paths = [];\n  var toVisit = revs.slice();\n  var node;\n  while ((node = toVisit.pop())) {\n    var pos = node.pos;\n    var tree = node.ids;\n    var id = tree[0];\n    var opts = tree[1];\n    var branches = tree[2];\n    var isLeaf = branches.length === 0;\n\n    var history = node.history ? node.history.slice() : [];\n    history.push({id: id, opts: opts});\n    if (isLeaf) {\n      paths.push({pos: (pos + 1 - history.length), ids: history});\n    }\n    for (var i = 0, len = branches.length; i < len; i++) {\n      toVisit.push({pos: pos + 1, ids: branches[i], history: history});\n    }\n  }\n  return paths.reverse();\n}\n\n// for a better overview of what this is doing, read:\n\nfunction sortByPos$1(a, b) {\n  return a.pos - b.pos;\n}\n\n// classic binary search\nfunction binarySearch(arr, item, comparator) {\n  var low = 0;\n  var high = arr.length;\n  var mid;\n  while (low < high) {\n    mid = (low + high) >>> 1;\n    if (comparator(arr[mid], item) < 0) {\n      low = mid + 1;\n    } else {\n      high = mid;\n    }\n  }\n  return low;\n}\n\n// assuming the arr is sorted, insert the item in the proper place\nfunction insertSorted(arr, item, comparator) {\n  var idx = binarySearch(arr, item, comparator);\n  arr.splice(idx, 0, item);\n}\n\n// Turn a path as a flat array into a tree with a single branch.\n// If any should be stemmed from the beginning of the array, that's passed\n// in as the second argument\nfunction pathToTree(path, numStemmed) {\n  var root;\n  var leaf;\n  for (var i = numStemmed, len = path.length; i < len; i++) {\n    var node = path[i];\n    var currentLeaf = [node.id, node.opts, []];\n    if (leaf) {\n      leaf[2].push(currentLeaf);\n      leaf = currentLeaf;\n    } else {\n      root = leaf = currentLeaf;\n    }\n  }\n  return root;\n}\n\n// compare the IDs of two trees\nfunction compareTree(a, b) {\n  return a[0] < b[0] ? -1 : 1;\n}\n\n// Merge two trees together\n// The roots of tree1 and tree2 must be the same revision\nfunction mergeTree(in_tree1, in_tree2) {\n  var queue = [{tree1: in_tree1, tree2: in_tree2}];\n  var conflicts = false;\n  while (queue.length > 0) {\n    var item = queue.pop();\n    var tree1 = item.tree1;\n    var tree2 = item.tree2;\n\n    if (tree1[1].status || tree2[1].status) {\n      tree1[1].status =\n        (tree1[1].status ===  'available' ||\n        tree2[1].status === 'available') ? 'available' : 'missing';\n    }\n\n    for (var i = 0; i < tree2[2].length; i++) {\n      if (!tree1[2][0]) {\n        conflicts = 'new_leaf';\n        tree1[2][0] = tree2[2][i];\n        continue;\n      }\n\n      var merged = false;\n      for (var j = 0; j < tree1[2].length; j++) {\n        if (tree1[2][j][0] === tree2[2][i][0]) {\n          queue.push({tree1: tree1[2][j], tree2: tree2[2][i]});\n          merged = true;\n        }\n      }\n      if (!merged) {\n        conflicts = 'new_branch';\n        insertSorted(tree1[2], tree2[2][i], compareTree);\n      }\n    }\n  }\n  return {conflicts: conflicts, tree: in_tree1};\n}\n\nfunction doMerge(tree, path, dontExpand) {\n  var restree = [];\n  var conflicts = false;\n  var merged = false;\n  var res;\n\n  if (!tree.length) {\n    return {tree: [path], conflicts: 'new_leaf'};\n  }\n\n  for (var i = 0, len = tree.length; i < len; i++) {\n    var branch = tree[i];\n    if (branch.pos === path.pos && branch.ids[0] === path.ids[0]) {\n      // Paths start at the same position and have the same root, so they need\n      // merged\n      res = mergeTree(branch.ids, path.ids);\n      restree.push({pos: branch.pos, ids: res.tree});\n      conflicts = conflicts || res.conflicts;\n      merged = true;\n    } else if (dontExpand !== true) {\n      // The paths start at a different position, take the earliest path and\n      // traverse up until it as at the same point from root as the path we\n      // want to merge.  If the keys match we return the longer path with the\n      // other merged After stemming we dont want to expand the trees\n\n      var t1 = branch.pos < path.pos ? branch : path;\n      var t2 = branch.pos < path.pos ? path : branch;\n      var diff = t2.pos - t1.pos;\n\n      var candidateParents = [];\n\n      var trees = [];\n      trees.push({ids: t1.ids, diff: diff, parent: null, parentIdx: null});\n      while (trees.length > 0) {\n        var item = trees.pop();\n        if (item.diff === 0) {\n          if (item.ids[0] === t2.ids[0]) {\n            candidateParents.push(item);\n          }\n          continue;\n        }\n        var elements = item.ids[2];\n        for (var j = 0, elementsLen = elements.length; j < elementsLen; j++) {\n          trees.push({\n            ids: elements[j],\n            diff: item.diff - 1,\n            parent: item.ids,\n            parentIdx: j\n          });\n        }\n      }\n\n      var el = candidateParents[0];\n\n      if (!el) {\n        restree.push(branch);\n      } else {\n        res = mergeTree(el.ids, t2.ids);\n        el.parent[2][el.parentIdx] = res.tree;\n        restree.push({pos: t1.pos, ids: t1.ids});\n        conflicts = conflicts || res.conflicts;\n        merged = true;\n      }\n    } else {\n      restree.push(branch);\n    }\n  }\n\n  // We didnt find\n  if (!merged) {\n    restree.push(path);\n  }\n\n  restree.sort(sortByPos$1);\n\n  return {\n    tree: restree,\n    conflicts: conflicts || 'internal_node'\n  };\n}\n\n// To ensure we dont grow the revision tree infinitely, we stem old revisions\nfunction stem(tree, depth) {\n  // First we break out the tree into a complete list of root to leaf paths\n  var paths = rootToLeaf(tree);\n  var stemmedRevs;\n\n  var result;\n  for (var i = 0, len = paths.length; i < len; i++) {\n    // Then for each path, we cut off the start of the path based on the\n    // `depth` to stem to, and generate a new set of flat trees\n    var path = paths[i];\n    var stemmed = path.ids;\n    var node;\n    if (stemmed.length > depth) {\n      // only do the stemming work if we actually need to stem\n      if (!stemmedRevs) {\n        stemmedRevs = {}; // avoid allocating this object unnecessarily\n      }\n      var numStemmed = stemmed.length - depth;\n      node = {\n        pos: path.pos + numStemmed,\n        ids: pathToTree(stemmed, numStemmed)\n      };\n\n      for (var s = 0; s < numStemmed; s++) {\n        var rev = (path.pos + s) + '-' + stemmed[s].id;\n        stemmedRevs[rev] = true;\n      }\n    } else { // no need to actually stem\n      node = {\n        pos: path.pos,\n        ids: pathToTree(stemmed, 0)\n      };\n    }\n\n    // Then we remerge all those flat trees together, ensuring that we dont\n    // connect trees that would go beyond the depth limit\n    if (result) {\n      result = doMerge(result, node, true).tree;\n    } else {\n      result = [node];\n    }\n  }\n\n  // this is memory-heavy per Chrome profiler, avoid unless we actually stemmed\n  if (stemmedRevs) {\n    traverseRevTree(result, function (isLeaf, pos, revHash) {\n      // some revisions may have been removed in a branch but not in another\n      delete stemmedRevs[pos + '-' + revHash];\n    });\n  }\n\n  return {\n    tree: result,\n    revs: stemmedRevs ? Object.keys(stemmedRevs) : []\n  };\n}\n\nfunction merge(tree, path, depth) {\n  var newTree = doMerge(tree, path);\n  var stemmed = stem(newTree.tree, depth);\n  return {\n    tree: stemmed.tree,\n    stemmedRevs: stemmed.revs,\n    conflicts: newTree.conflicts\n  };\n}\n\n// return true if a rev exists in the rev tree, false otherwise\nfunction revExists(revs, rev) {\n  var toVisit = revs.slice();\n  var splitRev = rev.split('-');\n  var targetPos = parseInt(splitRev[0], 10);\n  var targetId = splitRev[1];\n\n  var node;\n  while ((node = toVisit.pop())) {\n    if (node.pos === targetPos && node.ids[0] === targetId) {\n      return true;\n    }\n    var branches = node.ids[2];\n    for (var i = 0, len = branches.length; i < len; i++) {\n      toVisit.push({pos: node.pos + 1, ids: branches[i]});\n    }\n  }\n  return false;\n}\n\nfunction getTrees(node) {\n  return node.ids;\n}\n\n// check if a specific revision of a doc has been deleted\n//  - metadata: the metadata object from the doc store\n//  - rev: (optional) the revision to check. defaults to winning revision\nfunction isDeleted(metadata, rev) {\n  if (!rev) {\n    rev = winningRev(metadata);\n  }\n  var id = rev.substring(rev.indexOf('-') + 1);\n  var toVisit = metadata.rev_tree.map(getTrees);\n\n  var tree;\n  while ((tree = toVisit.pop())) {\n    if (tree[0] === id) {\n      return !!tree[1].deleted;\n    }\n    toVisit = toVisit.concat(tree[2]);\n  }\n}\n\nfunction isLocalId(id) {\n  return (/^_local/).test(id);\n}\n\n// returns the current leaf node for a given revision\nfunction latest(rev, metadata) {\n  var toVisit = metadata.rev_tree.slice();\n  var node;\n  while ((node = toVisit.pop())) {\n    var pos = node.pos;\n    var tree = node.ids;\n    var id = tree[0];\n    var opts = tree[1];\n    var branches = tree[2];\n    var isLeaf = branches.length === 0;\n\n    var history = node.history ? node.history.slice() : [];\n    history.push({id: id, pos: pos, opts: opts});\n\n    if (isLeaf) {\n      for (var i = 0, len = history.length; i < len; i++) {\n        var historyNode = history[i];\n        var historyRev = historyNode.pos + '-' + historyNode.id;\n\n        if (historyRev === rev) {\n          // return the rev of this leaf\n          return pos + '-' + id;\n        }\n      }\n    }\n\n    for (var j = 0, l = branches.length; j < l; j++) {\n      toVisit.push({pos: pos + 1, ids: branches[j], history: history});\n    }\n  }\n\n  /* istanbul ignore next */\n  throw new Error('Unable to resolve latest revision for id ' + metadata.id + ', rev ' + rev);\n}\n\ninherits(Changes$1, EE);\n\nfunction tryCatchInChangeListener(self, change, pending, lastSeq) {\n  // isolate try/catches to avoid V8 deoptimizations\n  try {\n    self.emit('change', change, pending, lastSeq);\n  } catch (e) {\n    guardedConsole('error', 'Error in .on(\"change\", function):', e);\n  }\n}\n\nfunction Changes$1(db, opts, callback) {\n  EE.call(this);\n  var self = this;\n  this.db = db;\n  opts = opts ? clone(opts) : {};\n  var complete = opts.complete = once(function (err, resp) {\n    if (err) {\n      if (listenerCount(self, 'error') > 0) {\n        self.emit('error', err);\n      }\n    } else {\n      self.emit('complete', resp);\n    }\n    self.removeAllListeners();\n    db.removeListener('destroyed', onDestroy);\n  });\n  if (callback) {\n    self.on('complete', function (resp) {\n      callback(null, resp);\n    });\n    self.on('error', callback);\n  }\n  function onDestroy() {\n    self.cancel();\n  }\n  db.once('destroyed', onDestroy);\n\n  opts.onChange = function (change, pending, lastSeq) {\n    /* istanbul ignore if */\n    if (self.isCancelled) {\n      return;\n    }\n    tryCatchInChangeListener(self, change, pending, lastSeq);\n  };\n\n  var promise = new Promise(function (fulfill, reject) {\n    opts.complete = function (err, res) {\n      if (err) {\n        reject(err);\n      } else {\n        fulfill(res);\n      }\n    };\n  });\n  self.once('cancel', function () {\n    db.removeListener('destroyed', onDestroy);\n    opts.complete(null, {status: 'cancelled'});\n  });\n  this.then = promise.then.bind(promise);\n  this['catch'] = promise['catch'].bind(promise);\n  this.then(function (result) {\n    complete(null, result);\n  }, complete);\n\n\n\n  if (!db.taskqueue.isReady) {\n    db.taskqueue.addTask(function (failed) {\n      if (failed) {\n        opts.complete(failed);\n      } else if (self.isCancelled) {\n        self.emit('cancel');\n      } else {\n        self.validateChanges(opts);\n      }\n    });\n  } else {\n    self.validateChanges(opts);\n  }\n}\nChanges$1.prototype.cancel = function () {\n  this.isCancelled = true;\n  if (this.db.taskqueue.isReady) {\n    this.emit('cancel');\n  }\n};\nfunction processChange(doc, metadata, opts) {\n  var changeList = [{rev: doc._rev}];\n  if (opts.style === 'all_docs') {\n    changeList = collectLeaves(metadata.rev_tree)\n    .map(function (x) { return {rev: x.rev}; });\n  }\n  var change = {\n    id: metadata.id,\n    changes: changeList,\n    doc: doc\n  };\n\n  if (isDeleted(metadata, doc._rev)) {\n    change.deleted = true;\n  }\n  if (opts.conflicts) {\n    change.doc._conflicts = collectConflicts(metadata);\n    if (!change.doc._conflicts.length) {\n      delete change.doc._conflicts;\n    }\n  }\n  return change;\n}\n\nChanges$1.prototype.validateChanges = function (opts) {\n  var callback = opts.complete;\n  var self = this;\n\n  /* istanbul ignore else */\n  if (PouchDB._changesFilterPlugin) {\n    PouchDB._changesFilterPlugin.validate(opts, function (err) {\n      if (err) {\n        return callback(err);\n      }\n      self.doChanges(opts);\n    });\n  } else {\n    self.doChanges(opts);\n  }\n};\n\nChanges$1.prototype.doChanges = function (opts) {\n  var self = this;\n  var callback = opts.complete;\n\n  opts = clone(opts);\n  if ('live' in opts && !('continuous' in opts)) {\n    opts.continuous = opts.live;\n  }\n  opts.processChange = processChange;\n\n  if (opts.since === 'latest') {\n    opts.since = 'now';\n  }\n  if (!opts.since) {\n    opts.since = 0;\n  }\n  if (opts.since === 'now') {\n    this.db.info().then(function (info) {\n      /* istanbul ignore if */\n      if (self.isCancelled) {\n        callback(null, {status: 'cancelled'});\n        return;\n      }\n      opts.since = info.update_seq;\n      self.doChanges(opts);\n    }, callback);\n    return;\n  }\n\n  /* istanbul ignore else */\n  if (PouchDB._changesFilterPlugin) {\n    PouchDB._changesFilterPlugin.normalize(opts);\n    if (PouchDB._changesFilterPlugin.shouldFilter(this, opts)) {\n      return PouchDB._changesFilterPlugin.filter(this, opts);\n    }\n  } else {\n    ['doc_ids', 'filter', 'selector', 'view'].forEach(function (key) {\n      if (key in opts) {\n        guardedConsole('warn',\n          'The \"' + key + '\" option was passed in to changes/replicate, ' +\n          'but pouchdb-changes-filter plugin is not installed, so it ' +\n          'was ignored. Please install the plugin to enable filtering.'\n        );\n      }\n    });\n  }\n\n  if (!('descending' in opts)) {\n    opts.descending = false;\n  }\n\n  // 0 and 1 should return 1 document\n  opts.limit = opts.limit === 0 ? 1 : opts.limit;\n  opts.complete = callback;\n  var newPromise = this.db._changes(opts);\n  /* istanbul ignore else */\n  if (newPromise && typeof newPromise.cancel === 'function') {\n    var cancel = self.cancel;\n    self.cancel = getArguments(function (args) {\n      newPromise.cancel();\n      cancel.apply(this, args);\n    });\n  }\n};\n\n/*\n * A generic pouch adapter\n */\n\nfunction compare(left, right) {\n  return left < right ? -1 : left > right ? 1 : 0;\n}\n\n// Wrapper for functions that call the bulkdocs api with a single doc,\n// if the first result is an error, return an error\nfunction yankError(callback, docId) {\n  return function (err, results) {\n    if (err || (results[0] && results[0].error)) {\n      err = err || results[0];\n      err.docId = docId;\n      callback(err);\n    } else {\n      callback(null, results.length ? results[0]  : results);\n    }\n  };\n}\n\n// clean docs given to us by the user\nfunction cleanDocs(docs) {\n  for (var i = 0; i < docs.length; i++) {\n    var doc = docs[i];\n    if (doc._deleted) {\n      delete doc._attachments; // ignore atts for deleted docs\n    } else if (doc._attachments) {\n      // filter out extraneous keys from _attachments\n      var atts = Object.keys(doc._attachments);\n      for (var j = 0; j < atts.length; j++) {\n        var att = atts[j];\n        doc._attachments[att] = pick(doc._attachments[att],\n          ['data', 'digest', 'content_type', 'length', 'revpos', 'stub']);\n      }\n    }\n  }\n}\n\n// compare two docs, first by _id then by _rev\nfunction compareByIdThenRev(a, b) {\n  var idCompare = compare(a._id, b._id);\n  if (idCompare !== 0) {\n    return idCompare;\n  }\n  var aStart = a._revisions ? a._revisions.start : 0;\n  var bStart = b._revisions ? b._revisions.start : 0;\n  return compare(aStart, bStart);\n}\n\n// for every node in a revision tree computes its distance from the closest\n// leaf\nfunction computeHeight(revs) {\n  var height = {};\n  var edges = [];\n  traverseRevTree(revs, function (isLeaf, pos, id, prnt) {\n    var rev = pos + \"-\" + id;\n    if (isLeaf) {\n      height[rev] = 0;\n    }\n    if (prnt !== undefined) {\n      edges.push({from: prnt, to: rev});\n    }\n    return rev;\n  });\n\n  edges.reverse();\n  edges.forEach(function (edge) {\n    if (height[edge.from] === undefined) {\n      height[edge.from] = 1 + height[edge.to];\n    } else {\n      height[edge.from] = Math.min(height[edge.from], 1 + height[edge.to]);\n    }\n  });\n  return height;\n}\n\nfunction allDocsKeysParse(opts) {\n  var keys =  ('limit' in opts) ?\n    opts.keys.slice(opts.skip, opts.limit + opts.skip) :\n    (opts.skip > 0) ? opts.keys.slice(opts.skip) : opts.keys;\n  opts.keys = keys;\n  opts.skip = 0;\n  delete opts.limit;\n  if (opts.descending) {\n    keys.reverse();\n    opts.descending = false;\n  }\n}\n\n// all compaction is done in a queue, to avoid attaching\n// too many listeners at once\nfunction doNextCompaction(self) {\n  var task = self._compactionQueue[0];\n  var opts = task.opts;\n  var callback = task.callback;\n  self.get('_local/compaction').catch(function () {\n    return false;\n  }).then(function (doc) {\n    if (doc && doc.last_seq) {\n      opts.last_seq = doc.last_seq;\n    }\n    self._compact(opts, function (err, res) {\n      /* istanbul ignore if */\n      if (err) {\n        callback(err);\n      } else {\n        callback(null, res);\n      }\n      immediate(function () {\n        self._compactionQueue.shift();\n        if (self._compactionQueue.length) {\n          doNextCompaction(self);\n        }\n      });\n    });\n  });\n}\n\nfunction attachmentNameError(name) {\n  if (name.charAt(0) === '_') {\n    return name + ' is not a valid attachment name, attachment ' +\n      'names cannot start with \\'_\\'';\n  }\n  return false;\n}\n\ninherits(AbstractPouchDB, EE);\n\nfunction AbstractPouchDB() {\n  EE.call(this);\n\n  // re-bind prototyped methods\n  for (var p in AbstractPouchDB.prototype) {\n    if (typeof this[p] === 'function') {\n      this[p] = this[p].bind(this);\n    }\n  }\n}\n\nAbstractPouchDB.prototype.post =\n  adapterFun('post', function (doc, opts, callback) {\n  if (typeof opts === 'function') {\n    callback = opts;\n    opts = {};\n  }\n  if (typeof doc !== 'object' || Array.isArray(doc)) {\n    return callback(createError(NOT_AN_OBJECT));\n  }\n  this.bulkDocs({docs: [doc]}, opts, yankError(callback, doc._id));\n});\n\nAbstractPouchDB.prototype.put = adapterFun('put', function (doc, opts, cb) {\n  if (typeof opts === 'function') {\n    cb = opts;\n    opts = {};\n  }\n  if (typeof doc !== 'object' || Array.isArray(doc)) {\n    return cb(createError(NOT_AN_OBJECT));\n  }\n  invalidIdError(doc._id);\n  if (isLocalId(doc._id) && typeof this._putLocal === 'function') {\n    if (doc._deleted) {\n      return this._removeLocal(doc, cb);\n    } else {\n      return this._putLocal(doc, cb);\n    }\n  }\n  var self = this;\n  if (opts.force && doc._rev) {\n    transformForceOptionToNewEditsOption();\n    putDoc(function (err) {\n      var result = err ? null : {ok: true, id: doc._id, rev: doc._rev};\n      cb(err, result);\n    });\n  } else {\n    putDoc(cb);\n  }\n\n  function transformForceOptionToNewEditsOption() {\n    var parts = doc._rev.split('-');\n    var oldRevId = parts[1];\n    var oldRevNum = parseInt(parts[0], 10);\n\n    var newRevNum = oldRevNum + 1;\n    var newRevId = rev$$1();\n\n    doc._revisions = {\n      start: newRevNum,\n      ids: [newRevId, oldRevId]\n    };\n    doc._rev = newRevNum + '-' + newRevId;\n    opts.new_edits = false;\n  }\n  function putDoc(next) {\n    if (typeof self._put === 'function' && opts.new_edits !== false) {\n      self._put(doc, opts, next);\n    } else {\n      self.bulkDocs({docs: [doc]}, opts, yankError(next, doc._id));\n    }\n  }\n});\n\nAbstractPouchDB.prototype.putAttachment =\n  adapterFun('putAttachment', function (docId, attachmentId, rev,\n                                              blob, type) {\n  var api = this;\n  if (typeof type === 'function') {\n    type = blob;\n    blob = rev;\n    rev = null;\n  }\n  // Lets fix in https://github.com/pouchdb/pouchdb/issues/3267\n  /* istanbul ignore if */\n  if (typeof type === 'undefined') {\n    type = blob;\n    blob = rev;\n    rev = null;\n  }\n  if (!type) {\n    guardedConsole('warn', 'Attachment', attachmentId, 'on document', docId, 'is missing content_type');\n  }\n\n  function createAttachment(doc) {\n    var prevrevpos = '_rev' in doc ? parseInt(doc._rev, 10) : 0;\n    doc._attachments = doc._attachments || {};\n    doc._attachments[attachmentId] = {\n      content_type: type,\n      data: blob,\n      revpos: ++prevrevpos\n    };\n    return api.put(doc);\n  }\n\n  return api.get(docId).then(function (doc) {\n    if (doc._rev !== rev) {\n      throw createError(REV_CONFLICT);\n    }\n\n    return createAttachment(doc);\n  }, function (err) {\n     // create new doc\n    /* istanbul ignore else */\n    if (err.reason === MISSING_DOC.message) {\n      return createAttachment({_id: docId});\n    } else {\n      throw err;\n    }\n  });\n});\n\nAbstractPouchDB.prototype.removeAttachment =\n  adapterFun('removeAttachment', function (docId, attachmentId, rev,\n                                                 callback) {\n  var self = this;\n  self.get(docId, function (err, obj) {\n    /* istanbul ignore if */\n    if (err) {\n      callback(err);\n      return;\n    }\n    if (obj._rev !== rev) {\n      callback(createError(REV_CONFLICT));\n      return;\n    }\n    /* istanbul ignore if */\n    if (!obj._attachments) {\n      return callback();\n    }\n    delete obj._attachments[attachmentId];\n    if (Object.keys(obj._attachments).length === 0) {\n      delete obj._attachments;\n    }\n    self.put(obj, callback);\n  });\n});\n\nAbstractPouchDB.prototype.remove =\n  adapterFun('remove', function (docOrId, optsOrRev, opts, callback) {\n  var doc;\n  if (typeof optsOrRev === 'string') {\n    // id, rev, opts, callback style\n    doc = {\n      _id: docOrId,\n      _rev: optsOrRev\n    };\n    if (typeof opts === 'function') {\n      callback = opts;\n      opts = {};\n    }\n  } else {\n    // doc, opts, callback style\n    doc = docOrId;\n    if (typeof optsOrRev === 'function') {\n      callback = optsOrRev;\n      opts = {};\n    } else {\n      callback = opts;\n      opts = optsOrRev;\n    }\n  }\n  opts = opts || {};\n  opts.was_delete = true;\n  var newDoc = {_id: doc._id, _rev: (doc._rev || opts.rev)};\n  newDoc._deleted = true;\n  if (isLocalId(newDoc._id) && typeof this._removeLocal === 'function') {\n    return this._removeLocal(doc, callback);\n  }\n  this.bulkDocs({docs: [newDoc]}, opts, yankError(callback, newDoc._id));\n});\n\nAbstractPouchDB.prototype.revsDiff =\n  adapterFun('revsDiff', function (req, opts, callback) {\n  if (typeof opts === 'function') {\n    callback = opts;\n    opts = {};\n  }\n  var ids = Object.keys(req);\n\n  if (!ids.length) {\n    return callback(null, {});\n  }\n\n  var count = 0;\n  var missing = new ExportedMap();\n\n  function addToMissing(id, revId) {\n    if (!missing.has(id)) {\n      missing.set(id, {missing: []});\n    }\n    missing.get(id).missing.push(revId);\n  }\n\n  function processDoc(id, rev_tree) {\n    // Is this fast enough? Maybe we should switch to a set simulated by a map\n    var missingForId = req[id].slice(0);\n    traverseRevTree(rev_tree, function (isLeaf, pos, revHash, ctx,\n      opts) {\n        var rev = pos + '-' + revHash;\n        var idx = missingForId.indexOf(rev);\n        if (idx === -1) {\n          return;\n        }\n\n        missingForId.splice(idx, 1);\n        /* istanbul ignore if */\n        if (opts.status !== 'available') {\n          addToMissing(id, rev);\n        }\n      });\n\n    // Traversing the tree is synchronous, so now `missingForId` contains\n    // revisions that were not found in the tree\n    missingForId.forEach(function (rev) {\n      addToMissing(id, rev);\n    });\n  }\n\n  ids.map(function (id) {\n    this._getRevisionTree(id, function (err, rev_tree) {\n      if (err && err.status === 404 && err.message === 'missing') {\n        missing.set(id, {missing: req[id]});\n      } else if (err) {\n        /* istanbul ignore next */\n        return callback(err);\n      } else {\n        processDoc(id, rev_tree);\n      }\n\n      if (++count === ids.length) {\n        // convert LazyMap to object\n        var missingObj = {};\n        missing.forEach(function (value, key) {\n          missingObj[key] = value;\n        });\n        return callback(null, missingObj);\n      }\n    });\n  }, this);\n});\n\n// _bulk_get API for faster replication, as described in\n// https://github.com/apache/couchdb-chttpd/pull/33\n// At the \"abstract\" level, it will just run multiple get()s in\n// parallel, because this isn't much of a performance cost\n// for local databases (except the cost of multiple transactions, which is\n// small). The http adapter overrides this in order\n// to do a more efficient single HTTP request.\nAbstractPouchDB.prototype.bulkGet =\n  adapterFun('bulkGet', function (opts, callback) {\n  bulkGet(this, opts, callback);\n});\n\n// compact one document and fire callback\n// by compacting we mean removing all revisions which\n// are further from the leaf in revision tree than max_height\nAbstractPouchDB.prototype.compactDocument =\n  adapterFun('compactDocument', function (docId, maxHeight, callback) {\n  var self = this;\n  this._getRevisionTree(docId, function (err, revTree) {\n    /* istanbul ignore if */\n    if (err) {\n      return callback(err);\n    }\n    var height = computeHeight(revTree);\n    var candidates = [];\n    var revs = [];\n    Object.keys(height).forEach(function (rev) {\n      if (height[rev] > maxHeight) {\n        candidates.push(rev);\n      }\n    });\n\n    traverseRevTree(revTree, function (isLeaf, pos, revHash, ctx, opts) {\n      var rev = pos + '-' + revHash;\n      if (opts.status === 'available' && candidates.indexOf(rev) !== -1) {\n        revs.push(rev);\n      }\n    });\n    self._doCompaction(docId, revs, callback);\n  });\n});\n\n// compact the whole database using single document\n// compaction\nAbstractPouchDB.prototype.compact =\n  adapterFun('compact', function (opts, callback) {\n  if (typeof opts === 'function') {\n    callback = opts;\n    opts = {};\n  }\n\n  var self = this;\n  opts = opts || {};\n\n  self._compactionQueue = self._compactionQueue || [];\n  self._compactionQueue.push({opts: opts, callback: callback});\n  if (self._compactionQueue.length === 1) {\n    doNextCompaction(self);\n  }\n});\nAbstractPouchDB.prototype._compact = function (opts, callback) {\n  var self = this;\n  var changesOpts = {\n    return_docs: false,\n    last_seq: opts.last_seq || 0\n  };\n  var promises = [];\n\n  function onChange(row) {\n    promises.push(self.compactDocument(row.id, 0));\n  }\n  function onComplete(resp) {\n    var lastSeq = resp.last_seq;\n    Promise.all(promises).then(function () {\n      return upsert(self, '_local/compaction', function deltaFunc(doc) {\n        if (!doc.last_seq || doc.last_seq < lastSeq) {\n          doc.last_seq = lastSeq;\n          return doc;\n        }\n        return false; // somebody else got here first, don't update\n      });\n    }).then(function () {\n      callback(null, {ok: true});\n    }).catch(callback);\n  }\n  self.changes(changesOpts)\n    .on('change', onChange)\n    .on('complete', onComplete)\n    .on('error', callback);\n};\n\n/* Begin api wrappers. Specific functionality to storage belongs in the\n   _[method] */\nAbstractPouchDB.prototype.get = adapterFun('get', function (id, opts, cb) {\n  if (typeof opts === 'function') {\n    cb = opts;\n    opts = {};\n  }\n  if (typeof id !== 'string') {\n    return cb(createError(INVALID_ID));\n  }\n  if (isLocalId(id) && typeof this._getLocal === 'function') {\n    return this._getLocal(id, cb);\n  }\n  var leaves = [], self = this;\n\n  function finishOpenRevs() {\n    var result = [];\n    var count = leaves.length;\n    /* istanbul ignore if */\n    if (!count) {\n      return cb(null, result);\n    }\n\n    // order with open_revs is unspecified\n    leaves.forEach(function (leaf) {\n      self.get(id, {\n        rev: leaf,\n        revs: opts.revs,\n        latest: opts.latest,\n        attachments: opts.attachments,\n        binary: opts.binary\n      }, function (err, doc) {\n        if (!err) {\n          // using latest=true can produce duplicates\n          var existing;\n          for (var i = 0, l = result.length; i < l; i++) {\n            if (result[i].ok && result[i].ok._rev === doc._rev) {\n              existing = true;\n              break;\n            }\n          }\n          if (!existing) {\n            result.push({ok: doc});\n          }\n        } else {\n          result.push({missing: leaf});\n        }\n        count--;\n        if (!count) {\n          cb(null, result);\n        }\n      });\n    });\n  }\n\n  if (opts.open_revs) {\n    if (opts.open_revs === \"all\") {\n      this._getRevisionTree(id, function (err, rev_tree) {\n        /* istanbul ignore if */\n        if (err) {\n          return cb(err);\n        }\n        leaves = collectLeaves(rev_tree).map(function (leaf) {\n          return leaf.rev;\n        });\n        finishOpenRevs();\n      });\n    } else {\n      if (Array.isArray(opts.open_revs)) {\n        leaves = opts.open_revs;\n        for (var i = 0; i < leaves.length; i++) {\n          var l = leaves[i];\n          // looks like it's the only thing couchdb checks\n          if (!(typeof (l) === \"string\" && /^\\d+-/.test(l))) {\n            return cb(createError(INVALID_REV));\n          }\n        }\n        finishOpenRevs();\n      } else {\n        return cb(createError(UNKNOWN_ERROR, 'function_clause'));\n      }\n    }\n    return; // open_revs does not like other options\n  }\n\n  return this._get(id, opts, function (err, result) {\n    if (err) {\n      err.docId = id;\n      return cb(err);\n    }\n\n    var doc = result.doc;\n    var metadata = result.metadata;\n    var ctx = result.ctx;\n\n    if (opts.conflicts) {\n      var conflicts = collectConflicts(metadata);\n      if (conflicts.length) {\n        doc._conflicts = conflicts;\n      }\n    }\n\n    if (isDeleted(metadata, doc._rev)) {\n      doc._deleted = true;\n    }\n\n    if (opts.revs || opts.revs_info) {\n      var splittedRev = doc._rev.split('-');\n      var revNo       = parseInt(splittedRev[0], 10);\n      var revHash     = splittedRev[1];\n\n      var paths = rootToLeaf(metadata.rev_tree);\n      var path = null;\n\n      for (var i = 0; i < paths.length; i++) {\n        var currentPath = paths[i];\n        var hashIndex = currentPath.ids.map(function (x) { return x.id; })\n          .indexOf(revHash);\n        var hashFoundAtRevPos = hashIndex === (revNo - 1);\n\n        if (hashFoundAtRevPos || (!path && hashIndex !== -1)) {\n          path = currentPath;\n        }\n      }\n\n      /* istanbul ignore if */\n      if (!path) {\n        err = new Error('invalid rev tree');\n        err.docId = id;\n        return cb(err);\n      }\n\n      var indexOfRev = path.ids.map(function (x) { return x.id; })\n        .indexOf(doc._rev.split('-')[1]) + 1;\n      var howMany = path.ids.length - indexOfRev;\n      path.ids.splice(indexOfRev, howMany);\n      path.ids.reverse();\n\n      if (opts.revs) {\n        doc._revisions = {\n          start: (path.pos + path.ids.length) - 1,\n          ids: path.ids.map(function (rev) {\n            return rev.id;\n          })\n        };\n      }\n      if (opts.revs_info) {\n        var pos =  path.pos + path.ids.length;\n        doc._revs_info = path.ids.map(function (rev) {\n          pos--;\n          return {\n            rev: pos + '-' + rev.id,\n            status: rev.opts.status\n          };\n        });\n      }\n    }\n\n    if (opts.attachments && doc._attachments) {\n      var attachments = doc._attachments;\n      var count = Object.keys(attachments).length;\n      if (count === 0) {\n        return cb(null, doc);\n      }\n      Object.keys(attachments).forEach(function (key) {\n        this._getAttachment(doc._id, key, attachments[key], {\n          // Previously the revision handling was done in adapter.js\n          // getAttachment, however since idb-next doesnt we need to\n          // pass the rev through\n          rev: doc._rev,\n          binary: opts.binary,\n          ctx: ctx\n        }, function (err, data) {\n          var att = doc._attachments[key];\n          att.data = data;\n          delete att.stub;\n          delete att.length;\n          if (!--count) {\n            cb(null, doc);\n          }\n        });\n      }, self);\n    } else {\n      if (doc._attachments) {\n        for (var key in doc._attachments) {\n          /* istanbul ignore else */\n          if (Object.prototype.hasOwnProperty.call(doc._attachments, key)) {\n            doc._attachments[key].stub = true;\n          }\n        }\n      }\n      cb(null, doc);\n    }\n  });\n});\n\n// TODO: I dont like this, it forces an extra read for every\n// attachment read and enforces a confusing api between\n// adapter.js and the adapter implementation\nAbstractPouchDB.prototype.getAttachment =\n  adapterFun('getAttachment', function (docId, attachmentId, opts, callback) {\n  var self = this;\n  if (opts instanceof Function) {\n    callback = opts;\n    opts = {};\n  }\n  this._get(docId, opts, function (err, res) {\n    if (err) {\n      return callback(err);\n    }\n    if (res.doc._attachments && res.doc._attachments[attachmentId]) {\n      opts.ctx = res.ctx;\n      opts.binary = true;\n      self._getAttachment(docId, attachmentId,\n                          res.doc._attachments[attachmentId], opts, callback);\n    } else {\n      return callback(createError(MISSING_DOC));\n    }\n  });\n});\n\nAbstractPouchDB.prototype.allDocs =\n  adapterFun('allDocs', function (opts, callback) {\n  if (typeof opts === 'function') {\n    callback = opts;\n    opts = {};\n  }\n  opts.skip = typeof opts.skip !== 'undefined' ? opts.skip : 0;\n  if (opts.start_key) {\n    opts.startkey = opts.start_key;\n  }\n  if (opts.end_key) {\n    opts.endkey = opts.end_key;\n  }\n  if ('keys' in opts) {\n    if (!Array.isArray(opts.keys)) {\n      return callback(new TypeError('options.keys must be an array'));\n    }\n    var incompatibleOpt =\n      ['startkey', 'endkey', 'key'].filter(function (incompatibleOpt) {\n      return incompatibleOpt in opts;\n    })[0];\n    if (incompatibleOpt) {\n      callback(createError(QUERY_PARSE_ERROR,\n        'Query parameter `' + incompatibleOpt +\n        '` is not compatible with multi-get'\n      ));\n      return;\n    }\n    if (!isRemote(this)) {\n      allDocsKeysParse(opts);\n      if (opts.keys.length === 0) {\n        return this._allDocs({limit: 0}, callback);\n      }\n    }\n  }\n\n  return this._allDocs(opts, callback);\n});\n\nAbstractPouchDB.prototype.changes = function (opts, callback) {\n  if (typeof opts === 'function') {\n    callback = opts;\n    opts = {};\n  }\n\n  opts = opts || {};\n\n  // By default set return_docs to false if the caller has opts.live = true,\n  // this will prevent us from collecting the set of changes indefinitely\n  // resulting in growing memory\n  opts.return_docs = ('return_docs' in opts) ? opts.return_docs : !opts.live;\n\n  return new Changes$1(this, opts, callback);\n};\n\nAbstractPouchDB.prototype.close = adapterFun('close', function (callback) {\n  this._closed = true;\n  this.emit('closed');\n  return this._close(callback);\n});\n\nAbstractPouchDB.prototype.info = adapterFun('info', function (callback) {\n  var self = this;\n  this._info(function (err, info) {\n    if (err) {\n      return callback(err);\n    }\n    // assume we know better than the adapter, unless it informs us\n    info.db_name = info.db_name || self.name;\n    info.auto_compaction = !!(self.auto_compaction && !isRemote(self));\n    info.adapter = self.adapter;\n    callback(null, info);\n  });\n});\n\nAbstractPouchDB.prototype.id = adapterFun('id', function (callback) {\n  return this._id(callback);\n});\n\n/* istanbul ignore next */\nAbstractPouchDB.prototype.type = function () {\n  return (typeof this._type === 'function') ? this._type() : this.adapter;\n};\n\nAbstractPouchDB.prototype.bulkDocs =\n  adapterFun('bulkDocs', function (req, opts, callback) {\n  if (typeof opts === 'function') {\n    callback = opts;\n    opts = {};\n  }\n\n  opts = opts || {};\n\n  if (Array.isArray(req)) {\n    req = {\n      docs: req\n    };\n  }\n\n  if (!req || !req.docs || !Array.isArray(req.docs)) {\n    return callback(createError(MISSING_BULK_DOCS));\n  }\n\n  for (var i = 0; i < req.docs.length; ++i) {\n    if (typeof req.docs[i] !== 'object' || Array.isArray(req.docs[i])) {\n      return callback(createError(NOT_AN_OBJECT));\n    }\n  }\n\n  var attachmentError;\n  req.docs.forEach(function (doc) {\n    if (doc._attachments) {\n      Object.keys(doc._attachments).forEach(function (name) {\n        attachmentError = attachmentError || attachmentNameError(name);\n        if (!doc._attachments[name].content_type) {\n          guardedConsole('warn', 'Attachment', name, 'on document', doc._id, 'is missing content_type');\n        }\n      });\n    }\n  });\n\n  if (attachmentError) {\n    return callback(createError(BAD_REQUEST, attachmentError));\n  }\n\n  if (!('new_edits' in opts)) {\n    if ('new_edits' in req) {\n      opts.new_edits = req.new_edits;\n    } else {\n      opts.new_edits = true;\n    }\n  }\n\n  var adapter = this;\n  if (!opts.new_edits && !isRemote(adapter)) {\n    // ensure revisions of the same doc are sorted, so that\n    // the local adapter processes them correctly (#2935)\n    req.docs.sort(compareByIdThenRev);\n  }\n\n  cleanDocs(req.docs);\n\n  // in the case of conflicts, we want to return the _ids to the user\n  // however, the underlying adapter may destroy the docs array, so\n  // create a copy here\n  var ids = req.docs.map(function (doc) {\n    return doc._id;\n  });\n\n  return this._bulkDocs(req, opts, function (err, res) {\n    if (err) {\n      return callback(err);\n    }\n    if (!opts.new_edits) {\n      // this is what couch does when new_edits is false\n      res = res.filter(function (x) {\n        return x.error;\n      });\n    }\n    // add ids for error/conflict responses (not required for CouchDB)\n    if (!isRemote(adapter)) {\n      for (var i = 0, l = res.length; i < l; i++) {\n        res[i].id = res[i].id || ids[i];\n      }\n    }\n\n    callback(null, res);\n  });\n});\n\nAbstractPouchDB.prototype.registerDependentDatabase =\n  adapterFun('registerDependentDatabase', function (dependentDb,\n                                                          callback) {\n  var dbOptions = clone(this.__opts);\n  if (this.__opts.view_adapter) {\n    dbOptions.adapter = this.__opts.view_adapter;\n  }\n\n  var depDB = new this.constructor(dependentDb, dbOptions);\n\n  function diffFun(doc) {\n    doc.dependentDbs = doc.dependentDbs || {};\n    if (doc.dependentDbs[dependentDb]) {\n      return false; // no update required\n    }\n    doc.dependentDbs[dependentDb] = true;\n    return doc;\n  }\n  upsert(this, '_local/_pouch_dependentDbs', diffFun)\n    .then(function () {\n      callback(null, {db: depDB});\n    }).catch(callback);\n});\n\nAbstractPouchDB.prototype.destroy =\n  adapterFun('destroy', function (opts, callback) {\n\n  if (typeof opts === 'function') {\n    callback = opts;\n    opts = {};\n  }\n\n  var self = this;\n  var usePrefix = 'use_prefix' in self ? self.use_prefix : true;\n\n  function destroyDb() {\n    // call destroy method of the particular adaptor\n    self._destroy(opts, function (err, resp) {\n      if (err) {\n        return callback(err);\n      }\n      self._destroyed = true;\n      self.emit('destroyed');\n      callback(null, resp || { 'ok': true });\n    });\n  }\n\n  if (isRemote(self)) {\n    // no need to check for dependent DBs if it's a remote DB\n    return destroyDb();\n  }\n\n  self.get('_local/_pouch_dependentDbs', function (err, localDoc) {\n    if (err) {\n      /* istanbul ignore if */\n      if (err.status !== 404) {\n        return callback(err);\n      } else { // no dependencies\n        return destroyDb();\n      }\n    }\n    var dependentDbs = localDoc.dependentDbs;\n    var PouchDB = self.constructor;\n    var deletedMap = Object.keys(dependentDbs).map(function (name) {\n      // use_prefix is only false in the browser\n      /* istanbul ignore next */\n      var trueName = usePrefix ?\n        name.replace(new RegExp('^' + PouchDB.prefix), '') : name;\n      return new PouchDB(trueName, self.__opts).destroy();\n    });\n    Promise.all(deletedMap).then(destroyDb, callback);\n  });\n});\n\nfunction TaskQueue() {\n  this.isReady = false;\n  this.failed = false;\n  this.queue = [];\n}\n\nTaskQueue.prototype.execute = function () {\n  var fun;\n  if (this.failed) {\n    while ((fun = this.queue.shift())) {\n      fun(this.failed);\n    }\n  } else {\n    while ((fun = this.queue.shift())) {\n      fun();\n    }\n  }\n};\n\nTaskQueue.prototype.fail = function (err) {\n  this.failed = err;\n  this.execute();\n};\n\nTaskQueue.prototype.ready = function (db) {\n  this.isReady = true;\n  this.db = db;\n  this.execute();\n};\n\nTaskQueue.prototype.addTask = function (fun) {\n  this.queue.push(fun);\n  if (this.failed) {\n    this.execute();\n  }\n};\n\nfunction parseAdapter(name, opts) {\n  var match = name.match(/([a-z-]*):\\/\\/(.*)/);\n  if (match) {\n    // the http adapter expects the fully qualified name\n    return {\n      name: /https?/.test(match[1]) ? match[1] + '://' + match[2] : match[2],\n      adapter: match[1]\n    };\n  }\n\n  var adapters = PouchDB.adapters;\n  var preferredAdapters = PouchDB.preferredAdapters;\n  var prefix = PouchDB.prefix;\n  var adapterName = opts.adapter;\n\n  if (!adapterName) { // automatically determine adapter\n    for (var i = 0; i < preferredAdapters.length; ++i) {\n      adapterName = preferredAdapters[i];\n      // check for browsers that have been upgraded from websql-only to websql+idb\n      /* istanbul ignore if */\n      if (adapterName === 'idb' && 'websql' in adapters &&\n          hasLocalStorage() && localStorage['_pouch__websqldb_' + prefix + name]) {\n        // log it, because this can be confusing during development\n        guardedConsole('log', 'PouchDB is downgrading \"' + name + '\" to WebSQL to' +\n          ' avoid data loss, because it was already opened with WebSQL.');\n        continue; // keep using websql to avoid user data loss\n      }\n      break;\n    }\n  }\n\n  var adapter = adapters[adapterName];\n\n  // if adapter is invalid, then an error will be thrown later\n  var usePrefix = (adapter && 'use_prefix' in adapter) ?\n    adapter.use_prefix : true;\n\n  return {\n    name: usePrefix ? (prefix + name) : name,\n    adapter: adapterName\n  };\n}\n\n// OK, so here's the deal. Consider this code:\n//     var db1 = new PouchDB('foo');\n//     var db2 = new PouchDB('foo');\n//     db1.destroy();\n// ^ these two both need to emit 'destroyed' events,\n// as well as the PouchDB constructor itself.\n// So we have one db object (whichever one got destroy() called on it)\n// responsible for emitting the initial event, which then gets emitted\n// by the constructor, which then broadcasts it to any other dbs\n// that may have been created with the same name.\nfunction prepareForDestruction(self) {\n\n  function onDestroyed(from_constructor) {\n    self.removeListener('closed', onClosed);\n    if (!from_constructor) {\n      self.constructor.emit('destroyed', self.name);\n    }\n  }\n\n  function onClosed() {\n    self.removeListener('destroyed', onDestroyed);\n    self.constructor.emit('unref', self);\n  }\n\n  self.once('destroyed', onDestroyed);\n  self.once('closed', onClosed);\n  self.constructor.emit('ref', self);\n}\n\ninherits(PouchDB, AbstractPouchDB);\nfunction PouchDB(name, opts) {\n  // In Node our test suite only tests this for PouchAlt unfortunately\n  /* istanbul ignore if */\n  if (!(this instanceof PouchDB)) {\n    return new PouchDB(name, opts);\n  }\n\n  var self = this;\n  opts = opts || {};\n\n  if (name && typeof name === 'object') {\n    opts = name;\n    name = opts.name;\n    delete opts.name;\n  }\n\n  if (opts.deterministic_revs === undefined) {\n    opts.deterministic_revs = true;\n  }\n\n  this.__opts = opts = clone(opts);\n\n  self.auto_compaction = opts.auto_compaction;\n  self.prefix = PouchDB.prefix;\n\n  if (typeof name !== 'string') {\n    throw new Error('Missing/invalid DB name');\n  }\n\n  var prefixedName = (opts.prefix || '') + name;\n  var backend = parseAdapter(prefixedName, opts);\n\n  opts.name = backend.name;\n  opts.adapter = opts.adapter || backend.adapter;\n\n  self.name = name;\n  self._adapter = opts.adapter;\n  PouchDB.emit('debug', ['adapter', 'Picked adapter: ', opts.adapter]);\n\n  if (!PouchDB.adapters[opts.adapter] ||\n      !PouchDB.adapters[opts.adapter].valid()) {\n    throw new Error('Invalid Adapter: ' + opts.adapter);\n  }\n\n  if (opts.view_adapter) {\n    if (!PouchDB.adapters[opts.view_adapter] ||\n        !PouchDB.adapters[opts.view_adapter].valid()) {\n      throw new Error('Invalid View Adapter: ' + opts.view_adapter);\n    }\n  }\n\n  AbstractPouchDB.call(self);\n  self.taskqueue = new TaskQueue();\n\n  self.adapter = opts.adapter;\n\n  PouchDB.adapters[opts.adapter].call(self, opts, function (err) {\n    if (err) {\n      return self.taskqueue.fail(err);\n    }\n    prepareForDestruction(self);\n\n    self.emit('created', self);\n    PouchDB.emit('created', self.name);\n    self.taskqueue.ready(self);\n  });\n\n}\n\n// AbortController was introduced quite a while after fetch and\n// isnt required for PouchDB to function so polyfill if needed\nvar a = (typeof AbortController !== 'undefined')\n    ? AbortController\n    : function () { return {abort: function () {}}; };\n\nvar f$1 = fetch;\nvar h = Headers;\n\nPouchDB.adapters = {};\nPouchDB.preferredAdapters = [];\n\nPouchDB.prefix = '_pouch_';\n\nvar eventEmitter = new EE();\n\nfunction setUpEventEmitter(Pouch) {\n  Object.keys(EE.prototype).forEach(function (key) {\n    if (typeof EE.prototype[key] === 'function') {\n      Pouch[key] = eventEmitter[key].bind(eventEmitter);\n    }\n  });\n\n  // these are created in constructor.js, and allow us to notify each DB with\n  // the same name that it was destroyed, via the constructor object\n  var destructListeners = Pouch._destructionListeners = new ExportedMap();\n\n  Pouch.on('ref', function onConstructorRef(db) {\n    if (!destructListeners.has(db.name)) {\n      destructListeners.set(db.name, []);\n    }\n    destructListeners.get(db.name).push(db);\n  });\n\n  Pouch.on('unref', function onConstructorUnref(db) {\n    if (!destructListeners.has(db.name)) {\n      return;\n    }\n    var dbList = destructListeners.get(db.name);\n    var pos = dbList.indexOf(db);\n    if (pos < 0) {\n      /* istanbul ignore next */\n      return;\n    }\n    dbList.splice(pos, 1);\n    if (dbList.length > 1) {\n      /* istanbul ignore next */\n      destructListeners.set(db.name, dbList);\n    } else {\n      destructListeners.delete(db.name);\n    }\n  });\n\n  Pouch.on('destroyed', function onConstructorDestroyed(name) {\n    if (!destructListeners.has(name)) {\n      return;\n    }\n    var dbList = destructListeners.get(name);\n    destructListeners.delete(name);\n    dbList.forEach(function (db) {\n      db.emit('destroyed',true);\n    });\n  });\n}\n\nsetUpEventEmitter(PouchDB);\n\nPouchDB.adapter = function (id, obj, addToPreferredAdapters) {\n  /* istanbul ignore else */\n  if (obj.valid()) {\n    PouchDB.adapters[id] = obj;\n    if (addToPreferredAdapters) {\n      PouchDB.preferredAdapters.push(id);\n    }\n  }\n};\n\nPouchDB.plugin = function (obj) {\n  if (typeof obj === 'function') { // function style for plugins\n    obj(PouchDB);\n  } else if (typeof obj !== 'object' || Object.keys(obj).length === 0) {\n    throw new Error('Invalid plugin: got \"' + obj + '\", expected an object or a function');\n  } else {\n    Object.keys(obj).forEach(function (id) { // object style for plugins\n      PouchDB.prototype[id] = obj[id];\n    });\n  }\n  if (this.__defaults) {\n    PouchDB.__defaults = $inject_Object_assign({}, this.__defaults);\n  }\n  return PouchDB;\n};\n\nPouchDB.defaults = function (defaultOpts) {\n  function PouchAlt(name, opts) {\n    if (!(this instanceof PouchAlt)) {\n      return new PouchAlt(name, opts);\n    }\n\n    opts = opts || {};\n\n    if (name && typeof name === 'object') {\n      opts = name;\n      name = opts.name;\n      delete opts.name;\n    }\n\n    opts = $inject_Object_assign({}, PouchAlt.__defaults, opts);\n    PouchDB.call(this, name, opts);\n  }\n\n  inherits(PouchAlt, PouchDB);\n\n  PouchAlt.preferredAdapters = PouchDB.preferredAdapters.slice();\n  Object.keys(PouchDB).forEach(function (key) {\n    if (!(key in PouchAlt)) {\n      PouchAlt[key] = PouchDB[key];\n    }\n  });\n\n  // make default options transitive\n  // https://github.com/pouchdb/pouchdb/issues/5922\n  PouchAlt.__defaults = $inject_Object_assign({}, this.__defaults, defaultOpts);\n\n  return PouchAlt;\n};\n\nPouchDB.fetch = function (url, opts) {\n  return f$1(url, opts);\n};\n\n// managed automatically by set-version.js\nvar version = \"7.3.1\";\n\n// this would just be \"return doc[field]\", but fields\n// can be \"deep\" due to dot notation\nfunction getFieldFromDoc(doc, parsedField) {\n  var value = doc;\n  for (var i = 0, len = parsedField.length; i < len; i++) {\n    var key = parsedField[i];\n    value = value[key];\n    if (!value) {\n      break;\n    }\n  }\n  return value;\n}\n\nfunction compare$1(left, right) {\n  return left < right ? -1 : left > right ? 1 : 0;\n}\n\n// Converts a string in dot notation to an array of its components, with backslash escaping\nfunction parseField(fieldName) {\n  // fields may be deep (e.g. \"foo.bar.baz\"), so parse\n  var fields = [];\n  var current = '';\n  for (var i = 0, len = fieldName.length; i < len; i++) {\n    var ch = fieldName[i];\n    if (i > 0 && fieldName[i - 1] === '\\\\' && (ch === '$' || ch === '.')) {\n      // escaped delimiter\n      current = current.substring(0, current.length - 1) + ch;\n    } else if (ch === '.') {\n      // When `.` is not escaped (above), it is a field delimiter\n      fields.push(current);\n      current = '';\n    } else { // normal character\n      current += ch;\n    }\n  }\n  fields.push(current);\n  return fields;\n}\n\nvar combinationFields = ['$or', '$nor', '$not'];\nfunction isCombinationalField(field) {\n  return combinationFields.indexOf(field) > -1;\n}\n\nfunction getKey(obj) {\n  return Object.keys(obj)[0];\n}\n\nfunction getValue(obj) {\n  return obj[getKey(obj)];\n}\n\n\n// flatten an array of selectors joined by an $and operator\nfunction mergeAndedSelectors(selectors) {\n\n  // sort to ensure that e.g. if the user specified\n  // $and: [{$gt: 'a'}, {$gt: 'b'}], then it's collapsed into\n  // just {$gt: 'b'}\n  var res = {};\n  var first = {$or: true, $nor: true};\n\n  selectors.forEach(function (selector) {\n    Object.keys(selector).forEach(function (field) {\n      var matcher = selector[field];\n      if (typeof matcher !== 'object') {\n        matcher = {$eq: matcher};\n      }\n\n      if (isCombinationalField(field)) {\n        // or, nor\n        if (matcher instanceof Array) {\n          if (first[field]) {\n            first[field] = false;\n            res[field] = matcher;\n            return;\n          }\n\n          var entries = [];\n          res[field].forEach(function (existing) {\n            Object.keys(matcher).forEach(function (key) {\n              var m = matcher[key];\n              var longest = Math.max(Object.keys(existing).length, Object.keys(m).length);\n              var merged = mergeAndedSelectors([existing, m]);\n              if (Object.keys(merged).length <= longest) {\n                // we have a situation like: (a :{$eq :1} || ...) && (a {$eq: 2} || ...)\n                // merging would produce a $eq 2 when actually we shouldn't ever match against these merged conditions\n                // merged should always contain more values to be valid\n                return;\n              }\n              entries.push(merged);\n            });\n          });\n          res[field] = entries;\n        } else {\n          // not\n          res[field] = mergeAndedSelectors([matcher]);\n        }\n      } else {\n        var fieldMatchers = res[field] = res[field] || {};\n        Object.keys(matcher).forEach(function (operator) {\n          var value = matcher[operator];\n\n          if (operator === '$gt' || operator === '$gte') {\n            return mergeGtGte(operator, value, fieldMatchers);\n          } else if (operator === '$lt' || operator === '$lte') {\n            return mergeLtLte(operator, value, fieldMatchers);\n          } else if (operator === '$ne') {\n            return mergeNe(value, fieldMatchers);\n          } else if (operator === '$eq') {\n            return mergeEq(value, fieldMatchers);\n          } else if (operator === \"$regex\") {\n            return mergeRegex(value, fieldMatchers);\n          }\n          fieldMatchers[operator] = value;\n        });\n      }\n    });\n  });\n\n  return res;\n}\n\n\n\n// collapse logically equivalent gt/gte values\nfunction mergeGtGte(operator, value, fieldMatchers) {\n  if (typeof fieldMatchers.$eq !== 'undefined') {\n    return; // do nothing\n  }\n  if (typeof fieldMatchers.$gte !== 'undefined') {\n    if (operator === '$gte') {\n      if (value > fieldMatchers.$gte) { // more specificity\n        fieldMatchers.$gte = value;\n      }\n    } else { // operator === '$gt'\n      if (value >= fieldMatchers.$gte) { // more specificity\n        delete fieldMatchers.$gte;\n        fieldMatchers.$gt = value;\n      }\n    }\n  } else if (typeof fieldMatchers.$gt !== 'undefined') {\n    if (operator === '$gte') {\n      if (value > fieldMatchers.$gt) { // more specificity\n        delete fieldMatchers.$gt;\n        fieldMatchers.$gte = value;\n      }\n    } else { // operator === '$gt'\n      if (value > fieldMatchers.$gt) { // more specificity\n        fieldMatchers.$gt = value;\n      }\n    }\n  } else {\n    fieldMatchers[operator] = value;\n  }\n}\n\n// collapse logically equivalent lt/lte values\nfunction mergeLtLte(operator, value, fieldMatchers) {\n  if (typeof fieldMatchers.$eq !== 'undefined') {\n    return; // do nothing\n  }\n  if (typeof fieldMatchers.$lte !== 'undefined') {\n    if (operator === '$lte') {\n      if (value < fieldMatchers.$lte) { // more specificity\n        fieldMatchers.$lte = value;\n      }\n    } else { // operator === '$gt'\n      if (value <= fieldMatchers.$lte) { // more specificity\n        delete fieldMatchers.$lte;\n        fieldMatchers.$lt = value;\n      }\n    }\n  } else if (typeof fieldMatchers.$lt !== 'undefined') {\n    if (operator === '$lte') {\n      if (value < fieldMatchers.$lt) { // more specificity\n        delete fieldMatchers.$lt;\n        fieldMatchers.$lte = value;\n      }\n    } else { // operator === '$gt'\n      if (value < fieldMatchers.$lt) { // more specificity\n        fieldMatchers.$lt = value;\n      }\n    }\n  } else {\n    fieldMatchers[operator] = value;\n  }\n}\n\n// combine $ne values into one array\nfunction mergeNe(value, fieldMatchers) {\n  if ('$ne' in fieldMatchers) {\n    // there are many things this could \"not\" be\n    fieldMatchers.$ne.push(value);\n  } else { // doesn't exist yet\n    fieldMatchers.$ne = [value];\n  }\n}\n\n// add $eq into the mix\nfunction mergeEq(value, fieldMatchers) {\n  // these all have less specificity than the $eq\n  // TODO: check for user errors here\n  delete fieldMatchers.$gt;\n  delete fieldMatchers.$gte;\n  delete fieldMatchers.$lt;\n  delete fieldMatchers.$lte;\n  delete fieldMatchers.$ne;\n  fieldMatchers.$eq = value;\n}\n\n// combine $regex values into one array\nfunction mergeRegex(value, fieldMatchers) {\n  if ('$regex' in fieldMatchers) {\n    // a value could match multiple regexes\n    fieldMatchers.$regex.push(value);\n  } else { // doesn't exist yet\n    fieldMatchers.$regex = [value];\n  }\n}\n\n//#7458: execute function mergeAndedSelectors on nested $and\nfunction mergeAndedSelectorsNested(obj) {\n    for (var prop in obj) {\n        if (Array.isArray(obj)) {\n            for (var i in obj) {\n                if (obj[i]['$and']) {\n                    obj[i] = mergeAndedSelectors(obj[i]['$and']);\n                }\n            }\n        }\n        var value = obj[prop];\n        if (typeof value === 'object') {\n            mergeAndedSelectorsNested(value); // <- recursive call\n        }\n    }\n    return obj;\n}\n\n//#7458: determine id $and is present in selector (at any level)\nfunction isAndInSelector(obj, isAnd) {\n    for (var prop in obj) {\n        if (prop === '$and') {\n            isAnd = true;\n        }\n        var value = obj[prop];\n        if (typeof value === 'object') {\n            isAnd = isAndInSelector(value, isAnd); // <- recursive call\n        }\n    }\n    return isAnd;\n}\n\n//\n// normalize the selector\n//\nfunction massageSelector(input) {\n  var result = clone(input);\n  var wasAnded = false;\n    //#7458: if $and is present in selector (at any level) merge nested $and\n    if (isAndInSelector(result, false)) {\n        result = mergeAndedSelectorsNested(result);\n        if ('$and' in result) {\n            result = mergeAndedSelectors(result['$and']);\n        }\n        wasAnded = true;\n    }\n\n  ['$or', '$nor'].forEach(function (orOrNor) {\n    if (orOrNor in result) {\n      // message each individual selector\n      // e.g. {foo: 'bar'} becomes {foo: {$eq: 'bar'}}\n      result[orOrNor].forEach(function (subSelector) {\n        var fields = Object.keys(subSelector);\n        for (var i = 0; i < fields.length; i++) {\n          var field = fields[i];\n          var matcher = subSelector[field];\n          if (typeof matcher !== 'object' || matcher === null) {\n            subSelector[field] = {$eq: matcher};\n          }\n        }\n      });\n    }\n  });\n\n  if ('$not' in result) {\n    //This feels a little like forcing, but it will work for now,\n    //I would like to come back to this and make the merging of selectors a little more generic\n    result['$not'] = mergeAndedSelectors([result['$not']]);\n  }\n\n  var fields = Object.keys(result);\n\n  for (var i = 0; i < fields.length; i++) {\n    var field = fields[i];\n    var matcher = result[field];\n\n    if (typeof matcher !== 'object' || matcher === null) {\n      matcher = {$eq: matcher};\n    } else if (!wasAnded) {\n      // These values must be placed in an array because these operators can be used multiple times on the same field\n      // when $and is used, mergeAndedSelectors takes care of putting them into arrays, otherwise it's done here:\n      if ('$ne' in matcher) {\n        matcher.$ne = [matcher.$ne];\n      }\n      if ('$regex' in matcher) {\n        matcher.$regex = [matcher.$regex];\n      }\n    }\n    result[field] = matcher;\n  }\n\n  return result;\n}\n\nfunction pad(str, padWith, upToLength) {\n  var padding = '';\n  var targetLength = upToLength - str.length;\n  /* istanbul ignore next */\n  while (padding.length < targetLength) {\n    padding += padWith;\n  }\n  return padding;\n}\n\nfunction padLeft(str, padWith, upToLength) {\n  var padding = pad(str, padWith, upToLength);\n  return padding + str;\n}\n\nvar MIN_MAGNITUDE = -324; // verified by -Number.MIN_VALUE\nvar MAGNITUDE_DIGITS = 3; // ditto\nvar SEP = ''; // set to '_' for easier debugging\n\nfunction collate(a, b) {\n\n  if (a === b) {\n    return 0;\n  }\n\n  a = normalizeKey(a);\n  b = normalizeKey(b);\n\n  var ai = collationIndex(a);\n  var bi = collationIndex(b);\n  if ((ai - bi) !== 0) {\n    return ai - bi;\n  }\n  switch (typeof a) {\n    case 'number':\n      return a - b;\n    case 'boolean':\n      return a < b ? -1 : 1;\n    case 'string':\n      return stringCollate(a, b);\n  }\n  return Array.isArray(a) ? arrayCollate(a, b) : objectCollate(a, b);\n}\n\n// couch considers null/NaN/Infinity/-Infinity === undefined,\n// for the purposes of mapreduce indexes. also, dates get stringified.\nfunction normalizeKey(key) {\n  switch (typeof key) {\n    case 'undefined':\n      return null;\n    case 'number':\n      if (key === Infinity || key === -Infinity || isNaN(key)) {\n        return null;\n      }\n      return key;\n    case 'object':\n      var origKey = key;\n      if (Array.isArray(key)) {\n        var len = key.length;\n        key = new Array(len);\n        for (var i = 0; i < len; i++) {\n          key[i] = normalizeKey(origKey[i]);\n        }\n      /* istanbul ignore next */\n      } else if (key instanceof Date) {\n        return key.toJSON();\n      } else if (key !== null) { // generic object\n        key = {};\n        for (var k in origKey) {\n          if (Object.prototype.hasOwnProperty.call(origKey, k)) {\n            var val = origKey[k];\n            if (typeof val !== 'undefined') {\n              key[k] = normalizeKey(val);\n            }\n          }\n        }\n      }\n  }\n  return key;\n}\n\nfunction indexify(key) {\n  if (key !== null) {\n    switch (typeof key) {\n      case 'boolean':\n        return key ? 1 : 0;\n      case 'number':\n        return numToIndexableString(key);\n      case 'string':\n        // We've to be sure that key does not contain \\u0000\n        // Do order-preserving replacements:\n        // 0 -> 1, 1\n        // 1 -> 1, 2\n        // 2 -> 2, 2\n        /* eslint-disable no-control-regex */\n        return key\n          .replace(/\\u0002/g, '\\u0002\\u0002')\n          .replace(/\\u0001/g, '\\u0001\\u0002')\n          .replace(/\\u0000/g, '\\u0001\\u0001');\n        /* eslint-enable no-control-regex */\n      case 'object':\n        var isArray = Array.isArray(key);\n        var arr = isArray ? key : Object.keys(key);\n        var i = -1;\n        var len = arr.length;\n        var result = '';\n        if (isArray) {\n          while (++i < len) {\n            result += toIndexableString(arr[i]);\n          }\n        } else {\n          while (++i < len) {\n            var objKey = arr[i];\n            result += toIndexableString(objKey) +\n                toIndexableString(key[objKey]);\n          }\n        }\n        return result;\n    }\n  }\n  return '';\n}\n\n// convert the given key to a string that would be appropriate\n// for lexical sorting, e.g. within a database, where the\n// sorting is the same given by the collate() function.\nfunction toIndexableString(key) {\n  var zero = '\\u0000';\n  key = normalizeKey(key);\n  return collationIndex(key) + SEP + indexify(key) + zero;\n}\n\nfunction parseNumber(str, i) {\n  var originalIdx = i;\n  var num;\n  var zero = str[i] === '1';\n  if (zero) {\n    num = 0;\n    i++;\n  } else {\n    var neg = str[i] === '0';\n    i++;\n    var numAsString = '';\n    var magAsString = str.substring(i, i + MAGNITUDE_DIGITS);\n    var magnitude = parseInt(magAsString, 10) + MIN_MAGNITUDE;\n    /* istanbul ignore next */\n    if (neg) {\n      magnitude = -magnitude;\n    }\n    i += MAGNITUDE_DIGITS;\n    while (true) {\n      var ch = str[i];\n      if (ch === '\\u0000') {\n        break;\n      } else {\n        numAsString += ch;\n      }\n      i++;\n    }\n    numAsString = numAsString.split('.');\n    if (numAsString.length === 1) {\n      num = parseInt(numAsString, 10);\n    } else {\n      /* istanbul ignore next */\n      num = parseFloat(numAsString[0] + '.' + numAsString[1]);\n    }\n    /* istanbul ignore next */\n    if (neg) {\n      num = num - 10;\n    }\n    /* istanbul ignore next */\n    if (magnitude !== 0) {\n      // parseFloat is more reliable than pow due to rounding errors\n      // e.g. Number.MAX_VALUE would return Infinity if we did\n      // num * Math.pow(10, magnitude);\n      num = parseFloat(num + 'e' + magnitude);\n    }\n  }\n  return {num: num, length : i - originalIdx};\n}\n\n// move up the stack while parsing\n// this function moved outside of parseIndexableString for performance\nfunction pop(stack, metaStack) {\n  var obj = stack.pop();\n\n  if (metaStack.length) {\n    var lastMetaElement = metaStack[metaStack.length - 1];\n    if (obj === lastMetaElement.element) {\n      // popping a meta-element, e.g. an object whose value is another object\n      metaStack.pop();\n      lastMetaElement = metaStack[metaStack.length - 1];\n    }\n    var element = lastMetaElement.element;\n    var lastElementIndex = lastMetaElement.index;\n    if (Array.isArray(element)) {\n      element.push(obj);\n    } else if (lastElementIndex === stack.length - 2) { // obj with key+value\n      var key = stack.pop();\n      element[key] = obj;\n    } else {\n      stack.push(obj); // obj with key only\n    }\n  }\n}\n\nfunction parseIndexableString(str) {\n  var stack = [];\n  var metaStack = []; // stack for arrays and objects\n  var i = 0;\n\n  /*eslint no-constant-condition: [\"error\", { \"checkLoops\": false }]*/\n  while (true) {\n    var collationIndex = str[i++];\n    if (collationIndex === '\\u0000') {\n      if (stack.length === 1) {\n        return stack.pop();\n      } else {\n        pop(stack, metaStack);\n        continue;\n      }\n    }\n    switch (collationIndex) {\n      case '1':\n        stack.push(null);\n        break;\n      case '2':\n        stack.push(str[i] === '1');\n        i++;\n        break;\n      case '3':\n        var parsedNum = parseNumber(str, i);\n        stack.push(parsedNum.num);\n        i += parsedNum.length;\n        break;\n      case '4':\n        var parsedStr = '';\n        /*eslint no-constant-condition: [\"error\", { \"checkLoops\": false }]*/\n        while (true) {\n          var ch = str[i];\n          if (ch === '\\u0000') {\n            break;\n          }\n          parsedStr += ch;\n          i++;\n        }\n        // perform the reverse of the order-preserving replacement\n        // algorithm (see above)\n        /* eslint-disable no-control-regex */\n        parsedStr = parsedStr.replace(/\\u0001\\u0001/g, '\\u0000')\n          .replace(/\\u0001\\u0002/g, '\\u0001')\n          .replace(/\\u0002\\u0002/g, '\\u0002');\n        /* eslint-enable no-control-regex */\n        stack.push(parsedStr);\n        break;\n      case '5':\n        var arrayElement = { element: [], index: stack.length };\n        stack.push(arrayElement.element);\n        metaStack.push(arrayElement);\n        break;\n      case '6':\n        var objElement = { element: {}, index: stack.length };\n        stack.push(objElement.element);\n        metaStack.push(objElement);\n        break;\n      /* istanbul ignore next */\n      default:\n        throw new Error(\n          'bad collationIndex or unexpectedly reached end of input: ' +\n            collationIndex);\n    }\n  }\n}\n\nfunction arrayCollate(a, b) {\n  var len = Math.min(a.length, b.length);\n  for (var i = 0; i < len; i++) {\n    var sort = collate(a[i], b[i]);\n    if (sort !== 0) {\n      return sort;\n    }\n  }\n  return (a.length === b.length) ? 0 :\n    (a.length > b.length) ? 1 : -1;\n}\nfunction stringCollate(a, b) {\n  // See: https://github.com/daleharvey/pouchdb/issues/40\n  // This is incompatible with the CouchDB implementation, but its the\n  // best we can do for now\n  return (a === b) ? 0 : ((a > b) ? 1 : -1);\n}\nfunction objectCollate(a, b) {\n  var ak = Object.keys(a), bk = Object.keys(b);\n  var len = Math.min(ak.length, bk.length);\n  for (var i = 0; i < len; i++) {\n    // First sort the keys\n    var sort = collate(ak[i], bk[i]);\n    if (sort !== 0) {\n      return sort;\n    }\n    // if the keys are equal sort the values\n    sort = collate(a[ak[i]], b[bk[i]]);\n    if (sort !== 0) {\n      return sort;\n    }\n\n  }\n  return (ak.length === bk.length) ? 0 :\n    (ak.length > bk.length) ? 1 : -1;\n}\n// The collation is defined by erlangs ordered terms\n// the atoms null, true, false come first, then numbers, strings,\n// arrays, then objects\n// null/undefined/NaN/Infinity/-Infinity are all considered null\nfunction collationIndex(x) {\n  var id = ['boolean', 'number', 'string', 'object'];\n  var idx = id.indexOf(typeof x);\n  //false if -1 otherwise true, but fast!!!!1\n  if (~idx) {\n    if (x === null) {\n      return 1;\n    }\n    if (Array.isArray(x)) {\n      return 5;\n    }\n    return idx < 3 ? (idx + 2) : (idx + 3);\n  }\n  /* istanbul ignore next */\n  if (Array.isArray(x)) {\n    return 5;\n  }\n}\n\n// conversion:\n// x yyy zz...zz\n// x = 0 for negative, 1 for 0, 2 for positive\n// y = exponent (for negative numbers negated) moved so that it's >= 0\n// z = mantisse\nfunction numToIndexableString(num) {\n\n  if (num === 0) {\n    return '1';\n  }\n\n  // convert number to exponential format for easier and\n  // more succinct string sorting\n  var expFormat = num.toExponential().split(/e\\+?/);\n  var magnitude = parseInt(expFormat[1], 10);\n\n  var neg = num < 0;\n\n  var result = neg ? '0' : '2';\n\n  // first sort by magnitude\n  // it's easier if all magnitudes are positive\n  var magForComparison = ((neg ? -magnitude : magnitude) - MIN_MAGNITUDE);\n  var magString = padLeft((magForComparison).toString(), '0', MAGNITUDE_DIGITS);\n\n  result += SEP + magString;\n\n  // then sort by the factor\n  var factor = Math.abs(parseFloat(expFormat[0])); // [1..10)\n  /* istanbul ignore next */\n  if (neg) { // for negative reverse ordering\n    factor = 10 - factor;\n  }\n\n  var factorStr = factor.toFixed(20);\n\n  // strip zeros from the end\n  factorStr = factorStr.replace(/\\.?0+$/, '');\n\n  result += SEP + factorStr;\n\n  return result;\n}\n\n// create a comparator based on the sort object\nfunction createFieldSorter(sort) {\n\n  function getFieldValuesAsArray(doc) {\n    return sort.map(function (sorting) {\n      var fieldName = getKey(sorting);\n      var parsedField = parseField(fieldName);\n      var docFieldValue = getFieldFromDoc(doc, parsedField);\n      return docFieldValue;\n    });\n  }\n\n  return function (aRow, bRow) {\n    var aFieldValues = getFieldValuesAsArray(aRow.doc);\n    var bFieldValues = getFieldValuesAsArray(bRow.doc);\n    var collation = collate(aFieldValues, bFieldValues);\n    if (collation !== 0) {\n      return collation;\n    }\n    // this is what mango seems to do\n    return compare$1(aRow.doc._id, bRow.doc._id);\n  };\n}\n\nfunction filterInMemoryFields(rows, requestDef, inMemoryFields) {\n  rows = rows.filter(function (row) {\n    return rowFilter(row.doc, requestDef.selector, inMemoryFields);\n  });\n\n  if (requestDef.sort) {\n    // in-memory sort\n    var fieldSorter = createFieldSorter(requestDef.sort);\n    rows = rows.sort(fieldSorter);\n    if (typeof requestDef.sort[0] !== 'string' &&\n        getValue(requestDef.sort[0]) === 'desc') {\n      rows = rows.reverse();\n    }\n  }\n\n  if ('limit' in requestDef || 'skip' in requestDef) {\n    // have to do the limit in-memory\n    var skip = requestDef.skip || 0;\n    var limit = ('limit' in requestDef ? requestDef.limit : rows.length) + skip;\n    rows = rows.slice(skip, limit);\n  }\n  return rows;\n}\n\nfunction rowFilter(doc, selector, inMemoryFields) {\n  return inMemoryFields.every(function (field) {\n    var matcher = selector[field];\n    var parsedField = parseField(field);\n    var docFieldValue = getFieldFromDoc(doc, parsedField);\n    if (isCombinationalField(field)) {\n      return matchCominationalSelector(field, matcher, doc);\n    }\n\n    return matchSelector(matcher, doc, parsedField, docFieldValue);\n  });\n}\n\nfunction matchSelector(matcher, doc, parsedField, docFieldValue) {\n  if (!matcher) {\n    // no filtering necessary; this field is just needed for sorting\n    return true;\n  }\n\n  // is matcher an object, if so continue recursion\n  if (typeof matcher === 'object') {\n    return Object.keys(matcher).every(function (maybeUserOperator) {\n      var userValue = matcher[ maybeUserOperator ];\n      // explicit operator\n      if (maybeUserOperator.indexOf(\"$\") === 0) {\n        return match(maybeUserOperator, doc, userValue, parsedField, docFieldValue);\n      } else {\n        var subParsedField = parseField(maybeUserOperator);\n\n        if (\n          docFieldValue === undefined &&\n          typeof userValue !== \"object\" &&\n          subParsedField.length > 0\n        ) {\n          // the field does not exist, return or getFieldFromDoc will throw\n          return false;\n        }\n\n        var subDocFieldValue = getFieldFromDoc(docFieldValue, subParsedField);\n\n        if (typeof userValue === \"object\") {\n          // field value is an object that might contain more operators\n          return matchSelector(userValue, doc, parsedField, subDocFieldValue);\n        }\n\n        // implicit operator\n        return match(\"$eq\", doc, userValue, subParsedField, subDocFieldValue);\n      }\n    });\n  }\n\n  // no more depth, No need to recurse further\n  return matcher === docFieldValue;\n}\n\nfunction matchCominationalSelector(field, matcher, doc) {\n\n  if (field === '$or') {\n    return matcher.some(function (orMatchers) {\n      return rowFilter(doc, orMatchers, Object.keys(orMatchers));\n    });\n  }\n\n  if (field === '$not') {\n    return !rowFilter(doc, matcher, Object.keys(matcher));\n  }\n\n  //`$nor`\n  return !matcher.find(function (orMatchers) {\n    return rowFilter(doc, orMatchers, Object.keys(orMatchers));\n  });\n\n}\n\nfunction match(userOperator, doc, userValue, parsedField, docFieldValue) {\n  if (!matchers[userOperator]) {\n    /* istanbul ignore next */\n    throw new Error('unknown operator \"' + userOperator +\n      '\" - should be one of $eq, $lte, $lt, $gt, $gte, $exists, $ne, $in, ' +\n      '$nin, $size, $mod, $regex, $elemMatch, $type, $allMatch or $all');\n  }\n  return matchers[userOperator](doc, userValue, parsedField, docFieldValue);\n}\n\nfunction fieldExists(docFieldValue) {\n  return typeof docFieldValue !== 'undefined' && docFieldValue !== null;\n}\n\nfunction fieldIsNotUndefined(docFieldValue) {\n  return typeof docFieldValue !== 'undefined';\n}\n\nfunction modField(docFieldValue, userValue) {\n  if (typeof docFieldValue !== \"number\" ||\n    parseInt(docFieldValue, 10) !== docFieldValue) {\n    return false;\n  }\n\n  var divisor = userValue[0];\n  var mod = userValue[1];\n\n  return docFieldValue % divisor === mod;\n}\n\nfunction arrayContainsValue(docFieldValue, userValue) {\n  return userValue.some(function (val) {\n    if (docFieldValue instanceof Array) {\n      return docFieldValue.some(function (docFieldValueItem) {\n        return collate(val, docFieldValueItem) === 0;\n      });\n    }\n\n    return collate(val, docFieldValue) === 0;\n  });\n}\n\nfunction arrayContainsAllValues(docFieldValue, userValue) {\n  return userValue.every(function (val) {\n    return docFieldValue.some(function (docFieldValueItem) {\n      return collate(val, docFieldValueItem) === 0;\n    });\n  });\n}\n\nfunction arraySize(docFieldValue, userValue) {\n  return docFieldValue.length === userValue;\n}\n\nfunction regexMatch(docFieldValue, userValue) {\n  var re = new RegExp(userValue);\n\n  return re.test(docFieldValue);\n}\n\nfunction typeMatch(docFieldValue, userValue) {\n\n  switch (userValue) {\n    case 'null':\n      return docFieldValue === null;\n    case 'boolean':\n      return typeof (docFieldValue) === 'boolean';\n    case 'number':\n      return typeof (docFieldValue) === 'number';\n    case 'string':\n      return typeof (docFieldValue) === 'string';\n    case 'array':\n      return docFieldValue instanceof Array;\n    case 'object':\n      return ({}).toString.call(docFieldValue) === '[object Object]';\n  }\n}\n\nvar matchers = {\n\n  '$elemMatch': function (doc, userValue, parsedField, docFieldValue) {\n    if (!Array.isArray(docFieldValue)) {\n      return false;\n    }\n\n    if (docFieldValue.length === 0) {\n      return false;\n    }\n\n    if (typeof docFieldValue[0] === 'object' &&  docFieldValue[0] !== null) {\n      return docFieldValue.some(function (val) {\n        return rowFilter(val, userValue, Object.keys(userValue));\n      });\n    }\n\n    return docFieldValue.some(function (val) {\n      return matchSelector(userValue, doc, parsedField, val);\n    });\n  },\n\n  '$allMatch': function (doc, userValue, parsedField, docFieldValue) {\n    if (!Array.isArray(docFieldValue)) {\n      return false;\n    }\n\n    /* istanbul ignore next */\n    if (docFieldValue.length === 0) {\n      return false;\n    }\n\n    if (typeof docFieldValue[0] === 'object' &&  docFieldValue[0] !== null) {\n      return docFieldValue.every(function (val) {\n        return rowFilter(val, userValue, Object.keys(userValue));\n      });\n    }\n\n    return docFieldValue.every(function (val) {\n      return matchSelector(userValue, doc, parsedField, val);\n    });\n  },\n\n  '$eq': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldIsNotUndefined(docFieldValue) && collate(docFieldValue, userValue) === 0;\n  },\n\n  '$gte': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldIsNotUndefined(docFieldValue) && collate(docFieldValue, userValue) >= 0;\n  },\n\n  '$gt': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldIsNotUndefined(docFieldValue) && collate(docFieldValue, userValue) > 0;\n  },\n\n  '$lte': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldIsNotUndefined(docFieldValue) && collate(docFieldValue, userValue) <= 0;\n  },\n\n  '$lt': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldIsNotUndefined(docFieldValue) && collate(docFieldValue, userValue) < 0;\n  },\n\n  '$exists': function (doc, userValue, parsedField, docFieldValue) {\n    //a field that is null is still considered to exist\n    if (userValue) {\n      return fieldIsNotUndefined(docFieldValue);\n    }\n\n    return !fieldIsNotUndefined(docFieldValue);\n  },\n\n  '$mod': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldExists(docFieldValue) && modField(docFieldValue, userValue);\n  },\n\n  '$ne': function (doc, userValue, parsedField, docFieldValue) {\n    return userValue.every(function (neValue) {\n      return collate(docFieldValue, neValue) !== 0;\n    });\n  },\n  '$in': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldExists(docFieldValue) && arrayContainsValue(docFieldValue, userValue);\n  },\n\n  '$nin': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldExists(docFieldValue) && !arrayContainsValue(docFieldValue, userValue);\n  },\n\n  '$size': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldExists(docFieldValue) &&\n      Array.isArray(docFieldValue) &&\n      arraySize(docFieldValue, userValue);\n  },\n\n  '$all': function (doc, userValue, parsedField, docFieldValue) {\n    return Array.isArray(docFieldValue) && arrayContainsAllValues(docFieldValue, userValue);\n  },\n\n  '$regex': function (doc, userValue, parsedField, docFieldValue) {\n    return fieldExists(docFieldValue) &&\n      typeof docFieldValue == \"string\" &&\n      userValue.every(function (regexValue) {\n        return regexMatch(docFieldValue, regexValue);\n      });\n  },\n\n  '$type': function (doc, userValue, parsedField, docFieldValue) {\n    return typeMatch(docFieldValue, userValue);\n  }\n};\n\n// return true if the given doc matches the supplied selector\nfunction matchesSelector(doc, selector) {\n  /* istanbul ignore if */\n  if (typeof selector !== 'object') {\n    // match the CouchDB error message\n    throw new Error('Selector error: expected a JSON object');\n  }\n\n  selector = massageSelector(selector);\n  var row = {\n    'doc': doc\n  };\n\n  var rowsMatched = filterInMemoryFields([row], { 'selector': selector }, Object.keys(selector));\n  return rowsMatched && rowsMatched.length === 1;\n}\n\nfunction evalFilter(input) {\n  return scopeEval('\"use strict\";\\nreturn ' + input + ';', {});\n}\n\nfunction evalView(input) {\n  var code = [\n    'return function(doc) {',\n    '  \"use strict\";',\n    '  var emitted = false;',\n    '  var emit = function (a, b) {',\n    '    emitted = true;',\n    '  };',\n    '  var view = ' + input + ';',\n    '  view(doc);',\n    '  if (emitted) {',\n    '    return true;',\n    '  }',\n    '};'\n  ].join('\\n');\n\n  return scopeEval(code, {});\n}\n\nfunction validate(opts, callback) {\n  if (opts.selector) {\n    if (opts.filter && opts.filter !== '_selector') {\n      var filterName = typeof opts.filter === 'string' ?\n        opts.filter : 'function';\n      return callback(new Error('selector invalid for filter \"' + filterName + '\"'));\n    }\n  }\n  callback();\n}\n\nfunction normalize(opts) {\n  if (opts.view && !opts.filter) {\n    opts.filter = '_view';\n  }\n\n  if (opts.selector && !opts.filter) {\n    opts.filter = '_selector';\n  }\n\n  if (opts.filter && typeof opts.filter === 'string') {\n    if (opts.filter === '_view') {\n      opts.view = normalizeDesignDocFunctionName(opts.view);\n    } else {\n      opts.filter = normalizeDesignDocFunctionName(opts.filter);\n    }\n  }\n}\n\nfunction shouldFilter(changesHandler, opts) {\n  return opts.filter && typeof opts.filter === 'string' &&\n    !opts.doc_ids && !isRemote(changesHandler.db);\n}\n\nfunction filter(changesHandler, opts) {\n  var callback = opts.complete;\n  if (opts.filter === '_view') {\n    if (!opts.view || typeof opts.view !== 'string') {\n      var err = createError(BAD_REQUEST,\n        '`view` filter parameter not found or invalid.');\n      return callback(err);\n    }\n    // fetch a view from a design doc, make it behave like a filter\n    var viewName = parseDesignDocFunctionName(opts.view);\n    changesHandler.db.get('_design/' + viewName[0], function (err, ddoc) {\n      /* istanbul ignore if */\n      if (changesHandler.isCancelled) {\n        return callback(null, {status: 'cancelled'});\n      }\n      /* istanbul ignore next */\n      if (err) {\n        return callback(generateErrorFromResponse(err));\n      }\n      var mapFun = ddoc && ddoc.views && ddoc.views[viewName[1]] &&\n        ddoc.views[viewName[1]].map;\n      if (!mapFun) {\n        return callback(createError(MISSING_DOC,\n          (ddoc.views ? 'missing json key: ' + viewName[1] :\n            'missing json key: views')));\n      }\n      opts.filter = evalView(mapFun);\n      changesHandler.doChanges(opts);\n    });\n  } else if (opts.selector) {\n    opts.filter = function (doc) {\n      return matchesSelector(doc, opts.selector);\n    };\n    changesHandler.doChanges(opts);\n  } else {\n    // fetch a filter from a design doc\n    var filterName = parseDesignDocFunctionName(opts.filter);\n    changesHandler.db.get('_design/' + filterName[0], function (err, ddoc) {\n      /* istanbul ignore if */\n      if (changesHandler.isCancelled) {\n        return callback(null, {status: 'cancelled'});\n      }\n      /* istanbul ignore next */\n      if (err) {\n        return callback(generateErrorFromResponse(err));\n      }\n      var filterFun = ddoc && ddoc.filters && ddoc.filters[filterName[1]];\n      if (!filterFun) {\n        return callback(createError(MISSING_DOC,\n          ((ddoc && ddoc.filters) ? 'missing json key: ' + filterName[1]\n            : 'missing json key: filters')));\n      }\n      opts.filter = evalFilter(filterFun);\n      changesHandler.doChanges(opts);\n    });\n  }\n}\n\nfunction applyChangesFilterPlugin(PouchDB) {\n  PouchDB._changesFilterPlugin = {\n    validate: validate,\n    normalize: normalize,\n    shouldFilter: shouldFilter,\n    filter: filter\n  };\n}\n\n// TODO: remove from pouchdb-core (breaking)\nPouchDB.plugin(applyChangesFilterPlugin);\n\nPouchDB.version = version;\n\nfunction toObject(array) {\n  return array.reduce(function (obj, item) {\n    obj[item] = true;\n    return obj;\n  }, {});\n}\n// List of top level reserved words for doc\nvar reservedWords = toObject([\n  '_id',\n  '_rev',\n  '_access',\n  '_attachments',\n  '_deleted',\n  '_revisions',\n  '_revs_info',\n  '_conflicts',\n  '_deleted_conflicts',\n  '_local_seq',\n  '_rev_tree',\n  // replication documents\n  '_replication_id',\n  '_replication_state',\n  '_replication_state_time',\n  '_replication_state_reason',\n  '_replication_stats',\n  // Specific to Couchbase Sync Gateway\n  '_removed'\n]);\n\n// List of reserved words that should end up in the document\nvar dataWords = toObject([\n  '_access',\n  '_attachments',\n  // replication documents\n  '_replication_id',\n  '_replication_state',\n  '_replication_state_time',\n  '_replication_state_reason',\n  '_replication_stats'\n]);\n\nfunction parseRevisionInfo(rev) {\n  if (!/^\\d+-/.test(rev)) {\n    return createError(INVALID_REV);\n  }\n  var idx = rev.indexOf('-');\n  var left = rev.substring(0, idx);\n  var right = rev.substring(idx + 1);\n  return {\n    prefix: parseInt(left, 10),\n    id: right\n  };\n}\n\nfunction makeRevTreeFromRevisions(revisions, opts) {\n  var pos = revisions.start - revisions.ids.length + 1;\n\n  var revisionIds = revisions.ids;\n  var ids = [revisionIds[0], opts, []];\n\n  for (var i = 1, len = revisionIds.length; i < len; i++) {\n    ids = [revisionIds[i], {status: 'missing'}, [ids]];\n  }\n\n  return [{\n    pos: pos,\n    ids: ids\n  }];\n}\n\n// Preprocess documents, parse their revisions, assign an id and a\n// revision for new writes that are missing them, etc\nfunction parseDoc(doc, newEdits, dbOpts) {\n  if (!dbOpts) {\n    dbOpts = {\n      deterministic_revs: true\n    };\n  }\n\n  var nRevNum;\n  var newRevId;\n  var revInfo;\n  var opts = {status: 'available'};\n  if (doc._deleted) {\n    opts.deleted = true;\n  }\n\n  if (newEdits) {\n    if (!doc._id) {\n      doc._id = uuid();\n    }\n    newRevId = rev$$1(doc, dbOpts.deterministic_revs);\n    if (doc._rev) {\n      revInfo = parseRevisionInfo(doc._rev);\n      if (revInfo.error) {\n        return revInfo;\n      }\n      doc._rev_tree = [{\n        pos: revInfo.prefix,\n        ids: [revInfo.id, {status: 'missing'}, [[newRevId, opts, []]]]\n      }];\n      nRevNum = revInfo.prefix + 1;\n    } else {\n      doc._rev_tree = [{\n        pos: 1,\n        ids : [newRevId, opts, []]\n      }];\n      nRevNum = 1;\n    }\n  } else {\n    if (doc._revisions) {\n      doc._rev_tree = makeRevTreeFromRevisions(doc._revisions, opts);\n      nRevNum = doc._revisions.start;\n      newRevId = doc._revisions.ids[0];\n    }\n    if (!doc._rev_tree) {\n      revInfo = parseRevisionInfo(doc._rev);\n      if (revInfo.error) {\n        return revInfo;\n      }\n      nRevNum = revInfo.prefix;\n      newRevId = revInfo.id;\n      doc._rev_tree = [{\n        pos: nRevNum,\n        ids: [newRevId, opts, []]\n      }];\n    }\n  }\n\n  invalidIdError(doc._id);\n\n  doc._rev = nRevNum + '-' + newRevId;\n\n  var result = {metadata : {}, data : {}};\n  for (var key in doc) {\n    /* istanbul ignore else */\n    if (Object.prototype.hasOwnProperty.call(doc, key)) {\n      var specialKey = key[0] === '_';\n      if (specialKey && !reservedWords[key]) {\n        var error = createError(DOC_VALIDATION, key);\n        error.message = DOC_VALIDATION.message + ': ' + key;\n        throw error;\n      } else if (specialKey && !dataWords[key]) {\n        result.metadata[key.slice(1)] = doc[key];\n      } else {\n        result.data[key] = doc[key];\n      }\n    }\n  }\n  return result;\n}\n\nfunction parseBase64(data) {\n  try {\n    return thisAtob(data);\n  } catch (e) {\n    var err = createError(BAD_ARG,\n      'Attachment is not a valid base64 string');\n    return {error: err};\n  }\n}\n\nfunction preprocessString(att, blobType, callback) {\n  var asBinary = parseBase64(att.data);\n  if (asBinary.error) {\n    return callback(asBinary.error);\n  }\n\n  att.length = asBinary.length;\n  if (blobType === 'blob') {\n    att.data = binStringToBluffer(asBinary, att.content_type);\n  } else if (blobType === 'base64') {\n    att.data = thisBtoa(asBinary);\n  } else { // binary\n    att.data = asBinary;\n  }\n  binaryMd5(asBinary, function (result) {\n    att.digest = 'md5-' + result;\n    callback();\n  });\n}\n\nfunction preprocessBlob(att, blobType, callback) {\n  binaryMd5(att.data, function (md5) {\n    att.digest = 'md5-' + md5;\n    // size is for blobs (browser), length is for buffers (node)\n    att.length = att.data.size || att.data.length || 0;\n    if (blobType === 'binary') {\n      blobToBinaryString(att.data, function (binString) {\n        att.data = binString;\n        callback();\n      });\n    } else if (blobType === 'base64') {\n      blobToBase64(att.data, function (b64) {\n        att.data = b64;\n        callback();\n      });\n    } else {\n      callback();\n    }\n  });\n}\n\nfunction preprocessAttachment(att, blobType, callback) {\n  if (att.stub) {\n    return callback();\n  }\n  if (typeof att.data === 'string') { // input is a base64 string\n    preprocessString(att, blobType, callback);\n  } else { // input is a blob\n    preprocessBlob(att, blobType, callback);\n  }\n}\n\nfunction preprocessAttachments(docInfos, blobType, callback) {\n\n  if (!docInfos.length) {\n    return callback();\n  }\n\n  var docv = 0;\n  var overallErr;\n\n  docInfos.forEach(function (docInfo) {\n    var attachments = docInfo.data && docInfo.data._attachments ?\n      Object.keys(docInfo.data._attachments) : [];\n    var recv = 0;\n\n    if (!attachments.length) {\n      return done();\n    }\n\n    function processedAttachment(err) {\n      overallErr = err;\n      recv++;\n      if (recv === attachments.length) {\n        done();\n      }\n    }\n\n    for (var key in docInfo.data._attachments) {\n      if (Object.prototype.hasOwnProperty.call(docInfo.data._attachments, key)) {\n        preprocessAttachment(docInfo.data._attachments[key],\n          blobType, processedAttachment);\n      }\n    }\n  });\n\n  function done() {\n    docv++;\n    if (docInfos.length === docv) {\n      if (overallErr) {\n        callback(overallErr);\n      } else {\n        callback();\n      }\n    }\n  }\n}\n\nfunction updateDoc(revLimit, prev, docInfo, results,\n                   i, cb, writeDoc, newEdits) {\n\n  if (revExists(prev.rev_tree, docInfo.metadata.rev) && !newEdits) {\n    results[i] = docInfo;\n    return cb();\n  }\n\n  // sometimes this is pre-calculated. historically not always\n  var previousWinningRev = prev.winningRev || winningRev(prev);\n  var previouslyDeleted = 'deleted' in prev ? prev.deleted :\n    isDeleted(prev, previousWinningRev);\n  var deleted = 'deleted' in docInfo.metadata ? docInfo.metadata.deleted :\n    isDeleted(docInfo.metadata);\n  var isRoot = /^1-/.test(docInfo.metadata.rev);\n\n  if (previouslyDeleted && !deleted && newEdits && isRoot) {\n    var newDoc = docInfo.data;\n    newDoc._rev = previousWinningRev;\n    newDoc._id = docInfo.metadata.id;\n    docInfo = parseDoc(newDoc, newEdits);\n  }\n\n  var merged = merge(prev.rev_tree, docInfo.metadata.rev_tree[0], revLimit);\n\n  var inConflict = newEdits && ((\n    (previouslyDeleted && deleted && merged.conflicts !== 'new_leaf') ||\n    (!previouslyDeleted && merged.conflicts !== 'new_leaf') ||\n    (previouslyDeleted && !deleted && merged.conflicts === 'new_branch')));\n\n  if (inConflict) {\n    var err = createError(REV_CONFLICT);\n    results[i] = err;\n    return cb();\n  }\n\n  var newRev = docInfo.metadata.rev;\n  docInfo.metadata.rev_tree = merged.tree;\n  docInfo.stemmedRevs = merged.stemmedRevs || [];\n  /* istanbul ignore else */\n  if (prev.rev_map) {\n    docInfo.metadata.rev_map = prev.rev_map; // used only by leveldb\n  }\n\n  // recalculate\n  var winningRev$$1 = winningRev(docInfo.metadata);\n  var winningRevIsDeleted = isDeleted(docInfo.metadata, winningRev$$1);\n\n  // calculate the total number of documents that were added/removed,\n  // from the perspective of total_rows/doc_count\n  var delta = (previouslyDeleted === winningRevIsDeleted) ? 0 :\n    previouslyDeleted < winningRevIsDeleted ? -1 : 1;\n\n  var newRevIsDeleted;\n  if (newRev === winningRev$$1) {\n    // if the new rev is the same as the winning rev, we can reuse that value\n    newRevIsDeleted = winningRevIsDeleted;\n  } else {\n    // if they're not the same, then we need to recalculate\n    newRevIsDeleted = isDeleted(docInfo.metadata, newRev);\n  }\n\n  writeDoc(docInfo, winningRev$$1, winningRevIsDeleted, newRevIsDeleted,\n    true, delta, i, cb);\n}\n\nfunction rootIsMissing(docInfo) {\n  return docInfo.metadata.rev_tree[0].ids[1].status === 'missing';\n}\n\nfunction processDocs(revLimit, docInfos, api, fetchedDocs, tx, results,\n                     writeDoc, opts, overallCallback) {\n\n  // Default to 1000 locally\n  revLimit = revLimit || 1000;\n\n  function insertDoc(docInfo, resultsIdx, callback) {\n    // Cant insert new deleted documents\n    var winningRev$$1 = winningRev(docInfo.metadata);\n    var deleted = isDeleted(docInfo.metadata, winningRev$$1);\n    if ('was_delete' in opts && deleted) {\n      results[resultsIdx] = createError(MISSING_DOC, 'deleted');\n      return callback();\n    }\n\n    // 4712 - detect whether a new document was inserted with a _rev\n    var inConflict = newEdits && rootIsMissing(docInfo);\n\n    if (inConflict) {\n      var err = createError(REV_CONFLICT);\n      results[resultsIdx] = err;\n      return callback();\n    }\n\n    var delta = deleted ? 0 : 1;\n\n    writeDoc(docInfo, winningRev$$1, deleted, deleted, false,\n      delta, resultsIdx, callback);\n  }\n\n  var newEdits = opts.new_edits;\n  var idsToDocs = new ExportedMap();\n\n  var docsDone = 0;\n  var docsToDo = docInfos.length;\n\n  function checkAllDocsDone() {\n    if (++docsDone === docsToDo && overallCallback) {\n      overallCallback();\n    }\n  }\n\n  docInfos.forEach(function (currentDoc, resultsIdx) {\n\n    if (currentDoc._id && isLocalId(currentDoc._id)) {\n      var fun = currentDoc._deleted ? '_removeLocal' : '_putLocal';\n      api[fun](currentDoc, {ctx: tx}, function (err, res) {\n        results[resultsIdx] = err || res;\n        checkAllDocsDone();\n      });\n      return;\n    }\n\n    var id = currentDoc.metadata.id;\n    if (idsToDocs.has(id)) {\n      docsToDo--; // duplicate\n      idsToDocs.get(id).push([currentDoc, resultsIdx]);\n    } else {\n      idsToDocs.set(id, [[currentDoc, resultsIdx]]);\n    }\n  });\n\n  // in the case of new_edits, the user can provide multiple docs\n  // with the same id. these need to be processed sequentially\n  idsToDocs.forEach(function (docs, id) {\n    var numDone = 0;\n\n    function docWritten() {\n      if (++numDone < docs.length) {\n        nextDoc();\n      } else {\n        checkAllDocsDone();\n      }\n    }\n    function nextDoc() {\n      var value = docs[numDone];\n      var currentDoc = value[0];\n      var resultsIdx = value[1];\n\n      if (fetchedDocs.has(id)) {\n        updateDoc(revLimit, fetchedDocs.get(id), currentDoc, results,\n          resultsIdx, docWritten, writeDoc, newEdits);\n      } else {\n        // Ensure stemming applies to new writes as well\n        var merged = merge([], currentDoc.metadata.rev_tree[0], revLimit);\n        currentDoc.metadata.rev_tree = merged.tree;\n        currentDoc.stemmedRevs = merged.stemmedRevs || [];\n        insertDoc(currentDoc, resultsIdx, docWritten);\n      }\n    }\n    nextDoc();\n  });\n}\n\n// IndexedDB requires a versioned database structure, so we use the\n// version here to manage migrations.\nvar ADAPTER_VERSION = 5;\n\n// The object stores created for each database\n// DOC_STORE stores the document meta data, its revision history and state\n// Keyed by document id\nvar DOC_STORE = 'document-store';\n// BY_SEQ_STORE stores a particular version of a document, keyed by its\n// sequence id\nvar BY_SEQ_STORE = 'by-sequence';\n// Where we store attachments\nvar ATTACH_STORE = 'attach-store';\n// Where we store many-to-many relations\n// between attachment digests and seqs\nvar ATTACH_AND_SEQ_STORE = 'attach-seq-store';\n\n// Where we store database-wide meta data in a single record\n// keyed by id: META_STORE\nvar META_STORE = 'meta-store';\n// Where we store local documents\nvar LOCAL_STORE = 'local-store';\n// Where we detect blob support\nvar DETECT_BLOB_SUPPORT_STORE = 'detect-blob-support';\n\nfunction safeJsonParse(str) {\n  // This try/catch guards against stack overflow errors.\n  // JSON.parse() is faster than vuvuzela.parse() but vuvuzela\n  // cannot overflow.\n  try {\n    return JSON.parse(str);\n  } catch (e) {\n    /* istanbul ignore next */\n    return vuvuzela.parse(str);\n  }\n}\n\nfunction safeJsonStringify(json) {\n  try {\n    return JSON.stringify(json);\n  } catch (e) {\n    /* istanbul ignore next */\n    return vuvuzela.stringify(json);\n  }\n}\n\nfunction idbError(callback) {\n  return function (evt) {\n    var message = 'unknown_error';\n    if (evt.target && evt.target.error) {\n      message = evt.target.error.name || evt.target.error.message;\n    }\n    callback(createError(IDB_ERROR, message, evt.type));\n  };\n}\n\n// Unfortunately, the metadata has to be stringified\n// when it is put into the database, because otherwise\n// IndexedDB can throw errors for deeply-nested objects.\n// Originally we just used JSON.parse/JSON.stringify; now\n// we use this custom vuvuzela library that avoids recursion.\n// If we could do it all over again, we'd probably use a\n// format for the revision trees other than JSON.\nfunction encodeMetadata(metadata, winningRev, deleted) {\n  return {\n    data: safeJsonStringify(metadata),\n    winningRev: winningRev,\n    deletedOrLocal: deleted ? '1' : '0',\n    seq: metadata.seq, // highest seq for this doc\n    id: metadata.id\n  };\n}\n\nfunction decodeMetadata(storedObject) {\n  if (!storedObject) {\n    return null;\n  }\n  var metadata = safeJsonParse(storedObject.data);\n  metadata.winningRev = storedObject.winningRev;\n  metadata.deleted = storedObject.deletedOrLocal === '1';\n  metadata.seq = storedObject.seq;\n  return metadata;\n}\n\n// read the doc back out from the database. we don't store the\n// _id or _rev because we already have _doc_id_rev.\nfunction decodeDoc(doc) {\n  if (!doc) {\n    return doc;\n  }\n  var idx = doc._doc_id_rev.lastIndexOf(':');\n  doc._id = doc._doc_id_rev.substring(0, idx - 1);\n  doc._rev = doc._doc_id_rev.substring(idx + 1);\n  delete doc._doc_id_rev;\n  return doc;\n}\n\n// Read a blob from the database, encoding as necessary\n// and translating from base64 if the IDB doesn't support\n// native Blobs\nfunction readBlobData(body, type, asBlob, callback) {\n  if (asBlob) {\n    if (!body) {\n      callback(createBlob([''], {type: type}));\n    } else if (typeof body !== 'string') { // we have blob support\n      callback(body);\n    } else { // no blob support\n      callback(b64ToBluffer(body, type));\n    }\n  } else { // as base64 string\n    if (!body) {\n      callback('');\n    } else if (typeof body !== 'string') { // we have blob support\n      readAsBinaryString(body, function (binary) {\n        callback(thisBtoa(binary));\n      });\n    } else { // no blob support\n      callback(body);\n    }\n  }\n}\n\nfunction fetchAttachmentsIfNecessary(doc, opts, txn, cb) {\n  var attachments = Object.keys(doc._attachments || {});\n  if (!attachments.length) {\n    return cb && cb();\n  }\n  var numDone = 0;\n\n  function checkDone() {\n    if (++numDone === attachments.length && cb) {\n      cb();\n    }\n  }\n\n  function fetchAttachment(doc, att) {\n    var attObj = doc._attachments[att];\n    var digest = attObj.digest;\n    var req = txn.objectStore(ATTACH_STORE).get(digest);\n    req.onsuccess = function (e) {\n      attObj.body = e.target.result.body;\n      checkDone();\n    };\n  }\n\n  attachments.forEach(function (att) {\n    if (opts.attachments && opts.include_docs) {\n      fetchAttachment(doc, att);\n    } else {\n      doc._attachments[att].stub = true;\n      checkDone();\n    }\n  });\n}\n\n// IDB-specific postprocessing necessary because\n// we don't know whether we stored a true Blob or\n// a base64-encoded string, and if it's a Blob it\n// needs to be read outside of the transaction context\nfunction postProcessAttachments(results, asBlob) {\n  return Promise.all(results.map(function (row) {\n    if (row.doc && row.doc._attachments) {\n      var attNames = Object.keys(row.doc._attachments);\n      return Promise.all(attNames.map(function (att) {\n        var attObj = row.doc._attachments[att];\n        if (!('body' in attObj)) { // already processed\n          return;\n        }\n        var body = attObj.body;\n        var type = attObj.content_type;\n        return new Promise(function (resolve) {\n          readBlobData(body, type, asBlob, function (data) {\n            row.doc._attachments[att] = $inject_Object_assign(\n              pick(attObj, ['digest', 'content_type']),\n              {data: data}\n            );\n            resolve();\n          });\n        });\n      }));\n    }\n  }));\n}\n\nfunction compactRevs(revs, docId, txn) {\n\n  var possiblyOrphanedDigests = [];\n  var seqStore = txn.objectStore(BY_SEQ_STORE);\n  var attStore = txn.objectStore(ATTACH_STORE);\n  var attAndSeqStore = txn.objectStore(ATTACH_AND_SEQ_STORE);\n  var count = revs.length;\n\n  function checkDone() {\n    count--;\n    if (!count) { // done processing all revs\n      deleteOrphanedAttachments();\n    }\n  }\n\n  function deleteOrphanedAttachments() {\n    if (!possiblyOrphanedDigests.length) {\n      return;\n    }\n    possiblyOrphanedDigests.forEach(function (digest) {\n      var countReq = attAndSeqStore.index('digestSeq').count(\n        IDBKeyRange.bound(\n          digest + '::', digest + '::\\uffff', false, false));\n      countReq.onsuccess = function (e) {\n        var count = e.target.result;\n        if (!count) {\n          // orphaned\n          attStore.delete(digest);\n        }\n      };\n    });\n  }\n\n  revs.forEach(function (rev) {\n    var index = seqStore.index('_doc_id_rev');\n    var key = docId + \"::\" + rev;\n    index.getKey(key).onsuccess = function (e) {\n      var seq = e.target.result;\n      if (typeof seq !== 'number') {\n        return checkDone();\n      }\n      seqStore.delete(seq);\n\n      var cursor = attAndSeqStore.index('seq')\n        .openCursor(IDBKeyRange.only(seq));\n\n      cursor.onsuccess = function (event) {\n        var cursor = event.target.result;\n        if (cursor) {\n          var digest = cursor.value.digestSeq.split('::')[0];\n          possiblyOrphanedDigests.push(digest);\n          attAndSeqStore.delete(cursor.primaryKey);\n          cursor.continue();\n        } else { // done\n          checkDone();\n        }\n      };\n    };\n  });\n}\n\nfunction openTransactionSafely(idb, stores, mode) {\n  try {\n    return {\n      txn: idb.transaction(stores, mode)\n    };\n  } catch (err) {\n    return {\n      error: err\n    };\n  }\n}\n\nvar changesHandler = new Changes();\n\nfunction idbBulkDocs(dbOpts, req, opts, api, idb, callback) {\n  var docInfos = req.docs;\n  var txn;\n  var docStore;\n  var bySeqStore;\n  var attachStore;\n  var attachAndSeqStore;\n  var metaStore;\n  var docInfoError;\n  var metaDoc;\n\n  for (var i = 0, len = docInfos.length; i < len; i++) {\n    var doc = docInfos[i];\n    if (doc._id && isLocalId(doc._id)) {\n      continue;\n    }\n    doc = docInfos[i] = parseDoc(doc, opts.new_edits, dbOpts);\n    if (doc.error && !docInfoError) {\n      docInfoError = doc;\n    }\n  }\n\n  if (docInfoError) {\n    return callback(docInfoError);\n  }\n\n  var allDocsProcessed = false;\n  var docCountDelta = 0;\n  var results = new Array(docInfos.length);\n  var fetchedDocs = new ExportedMap();\n  var preconditionErrored = false;\n  var blobType = api._meta.blobSupport ? 'blob' : 'base64';\n\n  preprocessAttachments(docInfos, blobType, function (err) {\n    if (err) {\n      return callback(err);\n    }\n    startTransaction();\n  });\n\n  function startTransaction() {\n\n    var stores = [\n      DOC_STORE, BY_SEQ_STORE,\n      ATTACH_STORE,\n      LOCAL_STORE, ATTACH_AND_SEQ_STORE,\n      META_STORE\n    ];\n    var txnResult = openTransactionSafely(idb, stores, 'readwrite');\n    if (txnResult.error) {\n      return callback(txnResult.error);\n    }\n    txn = txnResult.txn;\n    txn.onabort = idbError(callback);\n    txn.ontimeout = idbError(callback);\n    txn.oncomplete = complete;\n    docStore = txn.objectStore(DOC_STORE);\n    bySeqStore = txn.objectStore(BY_SEQ_STORE);\n    attachStore = txn.objectStore(ATTACH_STORE);\n    attachAndSeqStore = txn.objectStore(ATTACH_AND_SEQ_STORE);\n    metaStore = txn.objectStore(META_STORE);\n\n    metaStore.get(META_STORE).onsuccess = function (e) {\n      metaDoc = e.target.result;\n      updateDocCountIfReady();\n    };\n\n    verifyAttachments(function (err) {\n      if (err) {\n        preconditionErrored = true;\n        return callback(err);\n      }\n      fetchExistingDocs();\n    });\n  }\n\n  function onAllDocsProcessed() {\n    allDocsProcessed = true;\n    updateDocCountIfReady();\n  }\n\n  function idbProcessDocs() {\n    processDocs(dbOpts.revs_limit, docInfos, api, fetchedDocs,\n                txn, results, writeDoc, opts, onAllDocsProcessed);\n  }\n\n  function updateDocCountIfReady() {\n    if (!metaDoc || !allDocsProcessed) {\n      return;\n    }\n    // caching the docCount saves a lot of time in allDocs() and\n    // info(), which is why we go to all the trouble of doing this\n    metaDoc.docCount += docCountDelta;\n    metaStore.put(metaDoc);\n  }\n\n  function fetchExistingDocs() {\n\n    if (!docInfos.length) {\n      return;\n    }\n\n    var numFetched = 0;\n\n    function checkDone() {\n      if (++numFetched === docInfos.length) {\n        idbProcessDocs();\n      }\n    }\n\n    function readMetadata(event) {\n      var metadata = decodeMetadata(event.target.result);\n\n      if (metadata) {\n        fetchedDocs.set(metadata.id, metadata);\n      }\n      checkDone();\n    }\n\n    for (var i = 0, len = docInfos.length; i < len; i++) {\n      var docInfo = docInfos[i];\n      if (docInfo._id && isLocalId(docInfo._id)) {\n        checkDone(); // skip local docs\n        continue;\n      }\n      var req = docStore.get(docInfo.metadata.id);\n      req.onsuccess = readMetadata;\n    }\n  }\n\n  function complete() {\n    if (preconditionErrored) {\n      return;\n    }\n\n    changesHandler.notify(api._meta.name);\n    callback(null, results);\n  }\n\n  function verifyAttachment(digest, callback) {\n\n    var req = attachStore.get(digest);\n    req.onsuccess = function (e) {\n      if (!e.target.result) {\n        var err = createError(MISSING_STUB,\n          'unknown stub attachment with digest ' +\n          digest);\n        err.status = 412;\n        callback(err);\n      } else {\n        callback();\n      }\n    };\n  }\n\n  function verifyAttachments(finish) {\n\n\n    var digests = [];\n    docInfos.forEach(function (docInfo) {\n      if (docInfo.data && docInfo.data._attachments) {\n        Object.keys(docInfo.data._attachments).forEach(function (filename) {\n          var att = docInfo.data._attachments[filename];\n          if (att.stub) {\n            digests.push(att.digest);\n          }\n        });\n      }\n    });\n    if (!digests.length) {\n      return finish();\n    }\n    var numDone = 0;\n    var err;\n\n    function checkDone() {\n      if (++numDone === digests.length) {\n        finish(err);\n      }\n    }\n    digests.forEach(function (digest) {\n      verifyAttachment(digest, function (attErr) {\n        if (attErr && !err) {\n          err = attErr;\n        }\n        checkDone();\n      });\n    });\n  }\n\n  function writeDoc(docInfo, winningRev$$1, winningRevIsDeleted, newRevIsDeleted,\n                    isUpdate, delta, resultsIdx, callback) {\n\n    docInfo.metadata.winningRev = winningRev$$1;\n    docInfo.metadata.deleted = winningRevIsDeleted;\n\n    var doc = docInfo.data;\n    doc._id = docInfo.metadata.id;\n    doc._rev = docInfo.metadata.rev;\n\n    if (newRevIsDeleted) {\n      doc._deleted = true;\n    }\n\n    var hasAttachments = doc._attachments &&\n      Object.keys(doc._attachments).length;\n    if (hasAttachments) {\n      return writeAttachments(docInfo, winningRev$$1, winningRevIsDeleted,\n        isUpdate, resultsIdx, callback);\n    }\n\n    docCountDelta += delta;\n    updateDocCountIfReady();\n\n    finishDoc(docInfo, winningRev$$1, winningRevIsDeleted,\n      isUpdate, resultsIdx, callback);\n  }\n\n  function finishDoc(docInfo, winningRev$$1, winningRevIsDeleted,\n                     isUpdate, resultsIdx, callback) {\n\n    var doc = docInfo.data;\n    var metadata = docInfo.metadata;\n\n    doc._doc_id_rev = metadata.id + '::' + metadata.rev;\n    delete doc._id;\n    delete doc._rev;\n\n    function afterPutDoc(e) {\n      var revsToDelete = docInfo.stemmedRevs || [];\n\n      if (isUpdate && api.auto_compaction) {\n        revsToDelete = revsToDelete.concat(compactTree(docInfo.metadata));\n      }\n\n      if (revsToDelete && revsToDelete.length) {\n        compactRevs(revsToDelete, docInfo.metadata.id, txn);\n      }\n\n      metadata.seq = e.target.result;\n      // Current _rev is calculated from _rev_tree on read\n      // delete metadata.rev;\n      var metadataToStore = encodeMetadata(metadata, winningRev$$1,\n        winningRevIsDeleted);\n      var metaDataReq = docStore.put(metadataToStore);\n      metaDataReq.onsuccess = afterPutMetadata;\n    }\n\n    function afterPutDocError(e) {\n      // ConstraintError, need to update, not put (see #1638 for details)\n      e.preventDefault(); // avoid transaction abort\n      e.stopPropagation(); // avoid transaction onerror\n      var index = bySeqStore.index('_doc_id_rev');\n      var getKeyReq = index.getKey(doc._doc_id_rev);\n      getKeyReq.onsuccess = function (e) {\n        var putReq = bySeqStore.put(doc, e.target.result);\n        putReq.onsuccess = afterPutDoc;\n      };\n    }\n\n    function afterPutMetadata() {\n      results[resultsIdx] = {\n        ok: true,\n        id: metadata.id,\n        rev: metadata.rev\n      };\n      fetchedDocs.set(docInfo.metadata.id, docInfo.metadata);\n      insertAttachmentMappings(docInfo, metadata.seq, callback);\n    }\n\n    var putReq = bySeqStore.put(doc);\n\n    putReq.onsuccess = afterPutDoc;\n    putReq.onerror = afterPutDocError;\n  }\n\n  function writeAttachments(docInfo, winningRev$$1, winningRevIsDeleted,\n                            isUpdate, resultsIdx, callback) {\n\n\n    var doc = docInfo.data;\n\n    var numDone = 0;\n    var attachments = Object.keys(doc._attachments);\n\n    function collectResults() {\n      if (numDone === attachments.length) {\n        finishDoc(docInfo, winningRev$$1, winningRevIsDeleted,\n          isUpdate, resultsIdx, callback);\n      }\n    }\n\n    function attachmentSaved() {\n      numDone++;\n      collectResults();\n    }\n\n    attachments.forEach(function (key) {\n      var att = docInfo.data._attachments[key];\n      if (!att.stub) {\n        var data = att.data;\n        delete att.data;\n        att.revpos = parseInt(winningRev$$1, 10);\n        var digest = att.digest;\n        saveAttachment(digest, data, attachmentSaved);\n      } else {\n        numDone++;\n        collectResults();\n      }\n    });\n  }\n\n  // map seqs to attachment digests, which\n  // we will need later during compaction\n  function insertAttachmentMappings(docInfo, seq, callback) {\n\n    var attsAdded = 0;\n    var attsToAdd = Object.keys(docInfo.data._attachments || {});\n\n    if (!attsToAdd.length) {\n      return callback();\n    }\n\n    function checkDone() {\n      if (++attsAdded === attsToAdd.length) {\n        callback();\n      }\n    }\n\n    function add(att) {\n      var digest = docInfo.data._attachments[att].digest;\n      var req = attachAndSeqStore.put({\n        seq: seq,\n        digestSeq: digest + '::' + seq\n      });\n\n      req.onsuccess = checkDone;\n      req.onerror = function (e) {\n        // this callback is for a constaint error, which we ignore\n        // because this docid/rev has already been associated with\n        // the digest (e.g. when new_edits == false)\n        e.preventDefault(); // avoid transaction abort\n        e.stopPropagation(); // avoid transaction onerror\n        checkDone();\n      };\n    }\n    for (var i = 0; i < attsToAdd.length; i++) {\n      add(attsToAdd[i]); // do in parallel\n    }\n  }\n\n  function saveAttachment(digest, data, callback) {\n\n\n    var getKeyReq = attachStore.count(digest);\n    getKeyReq.onsuccess = function (e) {\n      var count = e.target.result;\n      if (count) {\n        return callback(); // already exists\n      }\n      var newAtt = {\n        digest: digest,\n        body: data\n      };\n      var putReq = attachStore.put(newAtt);\n      putReq.onsuccess = callback;\n    };\n  }\n}\n\n// Abstraction over IDBCursor and getAll()/getAllKeys() that allows us to batch our operations\n// while falling back to a normal IDBCursor operation on browsers that don't support getAll() or\n// getAllKeys(). This allows for a much faster implementation than just straight-up cursors, because\n// we're not processing each document one-at-a-time.\nfunction runBatchedCursor(objectStore, keyRange, descending, batchSize, onBatch) {\n\n  if (batchSize === -1) {\n    batchSize = 1000;\n  }\n\n  // Bail out of getAll()/getAllKeys() in the following cases:\n  // 1) either method is unsupported - we need both\n  // 2) batchSize is 1 (might as well use IDBCursor)\n  // 3) descending – no real way to do this via getAll()/getAllKeys()\n\n  var useGetAll = typeof objectStore.getAll === 'function' &&\n    typeof objectStore.getAllKeys === 'function' &&\n    batchSize > 1 && !descending;\n\n  var keysBatch;\n  var valuesBatch;\n  var pseudoCursor;\n\n  function onGetAll(e) {\n    valuesBatch = e.target.result;\n    if (keysBatch) {\n      onBatch(keysBatch, valuesBatch, pseudoCursor);\n    }\n  }\n\n  function onGetAllKeys(e) {\n    keysBatch = e.target.result;\n    if (valuesBatch) {\n      onBatch(keysBatch, valuesBatch, pseudoCursor);\n    }\n  }\n\n  function continuePseudoCursor() {\n    if (!keysBatch.length) { // no more results\n      return onBatch();\n    }\n    // fetch next batch, exclusive start\n    var lastKey = keysBatch[keysBatch.length - 1];\n    var newKeyRange;\n    if (keyRange && keyRange.upper) {\n      try {\n        newKeyRange = IDBKeyRange.bound(lastKey, keyRange.upper,\n          true, keyRange.upperOpen);\n      } catch (e) {\n        if (e.name === \"DataError\" && e.code === 0) {\n          return onBatch(); // we're done, startkey and endkey are equal\n        }\n      }\n    } else {\n      newKeyRange = IDBKeyRange.lowerBound(lastKey, true);\n    }\n    keyRange = newKeyRange;\n    keysBatch = null;\n    valuesBatch = null;\n    objectStore.getAll(keyRange, batchSize).onsuccess = onGetAll;\n    objectStore.getAllKeys(keyRange, batchSize).onsuccess = onGetAllKeys;\n  }\n\n  function onCursor(e) {\n    var cursor = e.target.result;\n    if (!cursor) { // done\n      return onBatch();\n    }\n    // regular IDBCursor acts like a batch where batch size is always 1\n    onBatch([cursor.key], [cursor.value], cursor);\n  }\n\n  if (useGetAll) {\n    pseudoCursor = {\"continue\": continuePseudoCursor};\n    objectStore.getAll(keyRange, batchSize).onsuccess = onGetAll;\n    objectStore.getAllKeys(keyRange, batchSize).onsuccess = onGetAllKeys;\n  } else if (descending) {\n    objectStore.openCursor(keyRange, 'prev').onsuccess = onCursor;\n  } else {\n    objectStore.openCursor(keyRange).onsuccess = onCursor;\n  }\n}\n\n// simple shim for objectStore.getAll(), falling back to IDBCursor\nfunction getAll(objectStore, keyRange, onSuccess) {\n  if (typeof objectStore.getAll === 'function') {\n    // use native getAll\n    objectStore.getAll(keyRange).onsuccess = onSuccess;\n    return;\n  }\n  // fall back to cursors\n  var values = [];\n\n  function onCursor(e) {\n    var cursor = e.target.result;\n    if (cursor) {\n      values.push(cursor.value);\n      cursor.continue();\n    } else {\n      onSuccess({\n        target: {\n          result: values\n        }\n      });\n    }\n  }\n\n  objectStore.openCursor(keyRange).onsuccess = onCursor;\n}\n\nfunction allDocsKeys(keys, docStore, onBatch) {\n  // It's not guaranted to be returned in right order  \n  var valuesBatch = new Array(keys.length);\n  var count = 0;\n  keys.forEach(function (key, index) {\n    docStore.get(key).onsuccess = function (event) {\n      if (event.target.result) {\n        valuesBatch[index] = event.target.result;\n      } else {\n        valuesBatch[index] = {key: key, error: 'not_found'};\n      }\n      count++;\n      if (count === keys.length) {\n        onBatch(keys, valuesBatch, {});\n      }\n    };\n  });\n}\n\nfunction createKeyRange(start, end, inclusiveEnd, key, descending) {\n  try {\n    if (start && end) {\n      if (descending) {\n        return IDBKeyRange.bound(end, start, !inclusiveEnd, false);\n      } else {\n        return IDBKeyRange.bound(start, end, false, !inclusiveEnd);\n      }\n    } else if (start) {\n      if (descending) {\n        return IDBKeyRange.upperBound(start);\n      } else {\n        return IDBKeyRange.lowerBound(start);\n      }\n    } else if (end) {\n      if (descending) {\n        return IDBKeyRange.lowerBound(end, !inclusiveEnd);\n      } else {\n        return IDBKeyRange.upperBound(end, !inclusiveEnd);\n      }\n    } else if (key) {\n      return IDBKeyRange.only(key);\n    }\n  } catch (e) {\n    return {error: e};\n  }\n  return null;\n}\n\nfunction idbAllDocs(opts, idb, callback) {\n  var start = 'startkey' in opts ? opts.startkey : false;\n  var end = 'endkey' in opts ? opts.endkey : false;\n  var key = 'key' in opts ? opts.key : false;\n  var keys = 'keys' in opts ? opts.keys : false; \n  var skip = opts.skip || 0;\n  var limit = typeof opts.limit === 'number' ? opts.limit : -1;\n  var inclusiveEnd = opts.inclusive_end !== false;\n\n  var keyRange ; \n  var keyRangeError;\n  if (!keys) {\n    keyRange = createKeyRange(start, end, inclusiveEnd, key, opts.descending);\n    keyRangeError = keyRange && keyRange.error;\n    if (keyRangeError && \n      !(keyRangeError.name === \"DataError\" && keyRangeError.code === 0)) {\n      // DataError with error code 0 indicates start is less than end, so\n      // can just do an empty query. Else need to throw\n      return callback(createError(IDB_ERROR,\n        keyRangeError.name, keyRangeError.message));\n    }\n  }\n\n  var stores = [DOC_STORE, BY_SEQ_STORE, META_STORE];\n\n  if (opts.attachments) {\n    stores.push(ATTACH_STORE);\n  }\n  var txnResult = openTransactionSafely(idb, stores, 'readonly');\n  if (txnResult.error) {\n    return callback(txnResult.error);\n  }\n  var txn = txnResult.txn;\n  txn.oncomplete = onTxnComplete;\n  txn.onabort = idbError(callback);\n  var docStore = txn.objectStore(DOC_STORE);\n  var seqStore = txn.objectStore(BY_SEQ_STORE);\n  var metaStore = txn.objectStore(META_STORE);\n  var docIdRevIndex = seqStore.index('_doc_id_rev');\n  var results = [];\n  var docCount;\n  var updateSeq;\n\n  metaStore.get(META_STORE).onsuccess = function (e) {\n    docCount = e.target.result.docCount;\n  };\n\n  /* istanbul ignore if */\n  if (opts.update_seq) {\n    getMaxUpdateSeq(seqStore, function (e) { \n      if (e.target.result && e.target.result.length > 0) {\n        updateSeq = e.target.result[0];\n      }\n    });\n  }\n\n  function getMaxUpdateSeq(objectStore, onSuccess) {\n    function onCursor(e) {\n      var cursor = e.target.result;\n      var maxKey = undefined;\n      if (cursor && cursor.key) {\n        maxKey = cursor.key;\n      } \n      return onSuccess({\n        target: {\n          result: [maxKey]\n        }\n      });\n    }\n    objectStore.openCursor(null, 'prev').onsuccess = onCursor;\n  }\n\n  // if the user specifies include_docs=true, then we don't\n  // want to block the main cursor while we're fetching the doc\n  function fetchDocAsynchronously(metadata, row, winningRev$$1) {\n    var key = metadata.id + \"::\" + winningRev$$1;\n    docIdRevIndex.get(key).onsuccess =  function onGetDoc(e) {\n      row.doc = decodeDoc(e.target.result) || {};\n      if (opts.conflicts) {\n        var conflicts = collectConflicts(metadata);\n        if (conflicts.length) {\n          row.doc._conflicts = conflicts;\n        }\n      }\n      fetchAttachmentsIfNecessary(row.doc, opts, txn);\n    };\n  }\n\n  function allDocsInner(winningRev$$1, metadata) {\n    var row = {\n      id: metadata.id,\n      key: metadata.id,\n      value: {\n        rev: winningRev$$1\n      }\n    };\n    var deleted = metadata.deleted;\n    if (deleted) {\n      if (keys) {\n        results.push(row);\n        // deleted docs are okay with \"keys\" requests\n        row.value.deleted = true;\n        row.doc = null;\n      }\n    } else if (skip-- <= 0) {\n      results.push(row);\n      if (opts.include_docs) {\n        fetchDocAsynchronously(metadata, row, winningRev$$1);\n      }\n    }\n  }\n\n  function processBatch(batchValues) {\n    for (var i = 0, len = batchValues.length; i < len; i++) {\n      if (results.length === limit) {\n        break;\n      }\n      var batchValue = batchValues[i];\n      if (batchValue.error && keys) {\n        // key was not found with \"keys\" requests\n        results.push(batchValue);\n        continue;\n      }\n      var metadata = decodeMetadata(batchValue);\n      var winningRev$$1 = metadata.winningRev;\n      allDocsInner(winningRev$$1, metadata);\n    }\n  }\n\n  function onBatch(batchKeys, batchValues, cursor) {\n    if (!cursor) {\n      return;\n    }\n    processBatch(batchValues);\n    if (results.length < limit) {\n      cursor.continue();\n    }\n  }\n\n  function onGetAll(e) {\n    var values = e.target.result;\n    if (opts.descending) {\n      values = values.reverse();\n    }\n    processBatch(values);\n  }\n\n  function onResultsReady() {\n    var returnVal = {\n      total_rows: docCount,\n      offset: opts.skip,\n      rows: results\n    };\n    \n    /* istanbul ignore if */\n    if (opts.update_seq && updateSeq !== undefined) {\n      returnVal.update_seq = updateSeq;\n    }\n    callback(null, returnVal);\n  }\n\n  function onTxnComplete() {\n    if (opts.attachments) {\n      postProcessAttachments(results, opts.binary).then(onResultsReady);\n    } else {\n      onResultsReady();\n    }\n  }\n\n  // don't bother doing any requests if start > end or limit === 0\n  if (keyRangeError || limit === 0) {\n    return;\n  }\n  if (keys) {\n    return allDocsKeys(opts.keys, docStore, onBatch);\n  }\n  if (limit === -1) { // just fetch everything\n    return getAll(docStore, keyRange, onGetAll);\n  }\n  // else do a cursor\n  // choose a batch size based on the skip, since we'll need to skip that many\n  runBatchedCursor(docStore, keyRange, opts.descending, limit + skip, onBatch);\n}\n\n//\n// Blobs are not supported in all versions of IndexedDB, notably\n// Chrome <37 and Android <5. In those versions, storing a blob will throw.\n//\n// Various other blob bugs exist in Chrome v37-42 (inclusive).\n// Detecting them is expensive and confusing to users, and Chrome 37-42\n// is at very low usage worldwide, so we do a hacky userAgent check instead.\n//\n// content-type bug: https://code.google.com/p/chromium/issues/detail?id=408120\n// 404 bug: https://code.google.com/p/chromium/issues/detail?id=447916\n// FileReader bug: https://code.google.com/p/chromium/issues/detail?id=447836\n//\nfunction checkBlobSupport(txn) {\n  return new Promise(function (resolve) {\n    var blob$$1 = createBlob(['']);\n    var req = txn.objectStore(DETECT_BLOB_SUPPORT_STORE).put(blob$$1, 'key');\n\n    req.onsuccess = function () {\n      var matchedChrome = navigator.userAgent.match(/Chrome\\/(\\d+)/);\n      var matchedEdge = navigator.userAgent.match(/Edge\\//);\n      // MS Edge pretends to be Chrome 42:\n      // https://msdn.microsoft.com/en-us/library/hh869301%28v=vs.85%29.aspx\n      resolve(matchedEdge || !matchedChrome ||\n        parseInt(matchedChrome[1], 10) >= 43);\n    };\n\n    req.onerror = txn.onabort = function (e) {\n      // If the transaction aborts now its due to not being able to\n      // write to the database, likely due to the disk being full\n      e.preventDefault();\n      e.stopPropagation();\n      resolve(false);\n    };\n  }).catch(function () {\n    return false; // error, so assume unsupported\n  });\n}\n\nfunction countDocs(txn, cb) {\n  var index = txn.objectStore(DOC_STORE).index('deletedOrLocal');\n  index.count(IDBKeyRange.only('0')).onsuccess = function (e) {\n    cb(e.target.result);\n  };\n}\n\n// This task queue ensures that IDB open calls are done in their own tick\n\nvar running = false;\nvar queue = [];\n\nfunction tryCode(fun, err, res, PouchDB) {\n  try {\n    fun(err, res);\n  } catch (err) {\n    // Shouldn't happen, but in some odd cases\n    // IndexedDB implementations might throw a sync\n    // error, in which case this will at least log it.\n    PouchDB.emit('error', err);\n  }\n}\n\nfunction applyNext() {\n  if (running || !queue.length) {\n    return;\n  }\n  running = true;\n  queue.shift()();\n}\n\nfunction enqueueTask(action, callback, PouchDB) {\n  queue.push(function runAction() {\n    action(function runCallback(err, res) {\n      tryCode(callback, err, res, PouchDB);\n      running = false;\n      immediate(function runNext() {\n        applyNext(PouchDB);\n      });\n    });\n  });\n  applyNext();\n}\n\nfunction changes(opts, api, dbName, idb) {\n  opts = clone(opts);\n\n  if (opts.continuous) {\n    var id = dbName + ':' + uuid();\n    changesHandler.addListener(dbName, id, api, opts);\n    changesHandler.notify(dbName);\n    return {\n      cancel: function () {\n        changesHandler.removeListener(dbName, id);\n      }\n    };\n  }\n\n  var docIds = opts.doc_ids && new ExportedSet(opts.doc_ids);\n\n  opts.since = opts.since || 0;\n  var lastSeq = opts.since;\n\n  var limit = 'limit' in opts ? opts.limit : -1;\n  if (limit === 0) {\n    limit = 1; // per CouchDB _changes spec\n  }\n\n  var results = [];\n  var numResults = 0;\n  var filter = filterChange(opts);\n  var docIdsToMetadata = new ExportedMap();\n\n  var txn;\n  var bySeqStore;\n  var docStore;\n  var docIdRevIndex;\n\n  function onBatch(batchKeys, batchValues, cursor) {\n    if (!cursor || !batchKeys.length) { // done\n      return;\n    }\n\n    var winningDocs = new Array(batchKeys.length);\n    var metadatas = new Array(batchKeys.length);\n\n    function processMetadataAndWinningDoc(metadata, winningDoc) {\n      var change = opts.processChange(winningDoc, metadata, opts);\n      lastSeq = change.seq = metadata.seq;\n\n      var filtered = filter(change);\n      if (typeof filtered === 'object') { // anything but true/false indicates error\n        return Promise.reject(filtered);\n      }\n\n      if (!filtered) {\n        return Promise.resolve();\n      }\n      numResults++;\n      if (opts.return_docs) {\n        results.push(change);\n      }\n      // process the attachment immediately\n      // for the benefit of live listeners\n      if (opts.attachments && opts.include_docs) {\n        return new Promise(function (resolve) {\n          fetchAttachmentsIfNecessary(winningDoc, opts, txn, function () {\n            postProcessAttachments([change], opts.binary).then(function () {\n              resolve(change);\n            });\n          });\n        });\n      } else {\n        return Promise.resolve(change);\n      }\n    }\n\n    function onBatchDone() {\n      var promises = [];\n      for (var i = 0, len = winningDocs.length; i < len; i++) {\n        if (numResults === limit) {\n          break;\n        }\n        var winningDoc = winningDocs[i];\n        if (!winningDoc) {\n          continue;\n        }\n        var metadata = metadatas[i];\n        promises.push(processMetadataAndWinningDoc(metadata, winningDoc));\n      }\n\n      Promise.all(promises).then(function (changes) {\n        for (var i = 0, len = changes.length; i < len; i++) {\n          if (changes[i]) {\n            opts.onChange(changes[i]);\n          }\n        }\n      }).catch(opts.complete);\n\n      if (numResults !== limit) {\n        cursor.continue();\n      }\n    }\n\n    // Fetch all metadatas/winningdocs from this batch in parallel, then process\n    // them all only once all data has been collected. This is done in parallel\n    // because it's faster than doing it one-at-a-time.\n    var numDone = 0;\n    batchValues.forEach(function (value, i) {\n      var doc = decodeDoc(value);\n      var seq = batchKeys[i];\n      fetchWinningDocAndMetadata(doc, seq, function (metadata, winningDoc) {\n        metadatas[i] = metadata;\n        winningDocs[i] = winningDoc;\n        if (++numDone === batchKeys.length) {\n          onBatchDone();\n        }\n      });\n    });\n  }\n\n  function onGetMetadata(doc, seq, metadata, cb) {\n    if (metadata.seq !== seq) {\n      // some other seq is later\n      return cb();\n    }\n\n    if (metadata.winningRev === doc._rev) {\n      // this is the winning doc\n      return cb(metadata, doc);\n    }\n\n    // fetch winning doc in separate request\n    var docIdRev = doc._id + '::' + metadata.winningRev;\n    var req = docIdRevIndex.get(docIdRev);\n    req.onsuccess = function (e) {\n      cb(metadata, decodeDoc(e.target.result));\n    };\n  }\n\n  function fetchWinningDocAndMetadata(doc, seq, cb) {\n    if (docIds && !docIds.has(doc._id)) {\n      return cb();\n    }\n\n    var metadata = docIdsToMetadata.get(doc._id);\n    if (metadata) { // cached\n      return onGetMetadata(doc, seq, metadata, cb);\n    }\n    // metadata not cached, have to go fetch it\n    docStore.get(doc._id).onsuccess = function (e) {\n      metadata = decodeMetadata(e.target.result);\n      docIdsToMetadata.set(doc._id, metadata);\n      onGetMetadata(doc, seq, metadata, cb);\n    };\n  }\n\n  function finish() {\n    opts.complete(null, {\n      results: results,\n      last_seq: lastSeq\n    });\n  }\n\n  function onTxnComplete() {\n    if (!opts.continuous && opts.attachments) {\n      // cannot guarantee that postProcessing was already done,\n      // so do it again\n      postProcessAttachments(results).then(finish);\n    } else {\n      finish();\n    }\n  }\n\n  var objectStores = [DOC_STORE, BY_SEQ_STORE];\n  if (opts.attachments) {\n    objectStores.push(ATTACH_STORE);\n  }\n  var txnResult = openTransactionSafely(idb, objectStores, 'readonly');\n  if (txnResult.error) {\n    return opts.complete(txnResult.error);\n  }\n  txn = txnResult.txn;\n  txn.onabort = idbError(opts.complete);\n  txn.oncomplete = onTxnComplete;\n\n  bySeqStore = txn.objectStore(BY_SEQ_STORE);\n  docStore = txn.objectStore(DOC_STORE);\n  docIdRevIndex = bySeqStore.index('_doc_id_rev');\n\n  var keyRange = (opts.since && !opts.descending) ?\n    IDBKeyRange.lowerBound(opts.since, true) : null;\n\n  runBatchedCursor(bySeqStore, keyRange, opts.descending, limit, onBatch);\n}\n\nvar cachedDBs = new ExportedMap();\nvar blobSupportPromise;\nvar openReqList = new ExportedMap();\n\nfunction IdbPouch(opts, callback) {\n  var api = this;\n\n  enqueueTask(function (thisCallback) {\n    init(api, opts, thisCallback);\n  }, callback, api.constructor);\n}\n\nfunction init(api, opts, callback) {\n\n  var dbName = opts.name;\n\n  var idb = null;\n  var idbGlobalFailureError = null;\n  api._meta = null;\n\n  function enrichCallbackError(callback) {\n    return function (error, result) {\n      if (error && error instanceof Error && !error.reason) {\n        if (idbGlobalFailureError) {\n          error.reason = idbGlobalFailureError;\n        }\n      }\n\n      callback(error, result);\n    };\n  }\n\n  // called when creating a fresh new database\n  function createSchema(db) {\n    var docStore = db.createObjectStore(DOC_STORE, {keyPath : 'id'});\n    db.createObjectStore(BY_SEQ_STORE, {autoIncrement: true})\n      .createIndex('_doc_id_rev', '_doc_id_rev', {unique: true});\n    db.createObjectStore(ATTACH_STORE, {keyPath: 'digest'});\n    db.createObjectStore(META_STORE, {keyPath: 'id', autoIncrement: false});\n    db.createObjectStore(DETECT_BLOB_SUPPORT_STORE);\n\n    // added in v2\n    docStore.createIndex('deletedOrLocal', 'deletedOrLocal', {unique : false});\n\n    // added in v3\n    db.createObjectStore(LOCAL_STORE, {keyPath: '_id'});\n\n    // added in v4\n    var attAndSeqStore = db.createObjectStore(ATTACH_AND_SEQ_STORE,\n      {autoIncrement: true});\n    attAndSeqStore.createIndex('seq', 'seq');\n    attAndSeqStore.createIndex('digestSeq', 'digestSeq', {unique: true});\n  }\n\n  // migration to version 2\n  // unfortunately \"deletedOrLocal\" is a misnomer now that we no longer\n  // store local docs in the main doc-store, but whaddyagonnado\n  function addDeletedOrLocalIndex(txn, callback) {\n    var docStore = txn.objectStore(DOC_STORE);\n    docStore.createIndex('deletedOrLocal', 'deletedOrLocal', {unique : false});\n\n    docStore.openCursor().onsuccess = function (event) {\n      var cursor = event.target.result;\n      if (cursor) {\n        var metadata = cursor.value;\n        var deleted = isDeleted(metadata);\n        metadata.deletedOrLocal = deleted ? \"1\" : \"0\";\n        docStore.put(metadata);\n        cursor.continue();\n      } else {\n        callback();\n      }\n    };\n  }\n\n  // migration to version 3 (part 1)\n  function createLocalStoreSchema(db) {\n    db.createObjectStore(LOCAL_STORE, {keyPath: '_id'})\n      .createIndex('_doc_id_rev', '_doc_id_rev', {unique: true});\n  }\n\n  // migration to version 3 (part 2)\n  function migrateLocalStore(txn, cb) {\n    var localStore = txn.objectStore(LOCAL_STORE);\n    var docStore = txn.objectStore(DOC_STORE);\n    var seqStore = txn.objectStore(BY_SEQ_STORE);\n\n    var cursor = docStore.openCursor();\n    cursor.onsuccess = function (event) {\n      var cursor = event.target.result;\n      if (cursor) {\n        var metadata = cursor.value;\n        var docId = metadata.id;\n        var local = isLocalId(docId);\n        var rev = winningRev(metadata);\n        if (local) {\n          var docIdRev = docId + \"::\" + rev;\n          // remove all seq entries\n          // associated with this docId\n          var start = docId + \"::\";\n          var end = docId + \"::~\";\n          var index = seqStore.index('_doc_id_rev');\n          var range = IDBKeyRange.bound(start, end, false, false);\n          var seqCursor = index.openCursor(range);\n          seqCursor.onsuccess = function (e) {\n            seqCursor = e.target.result;\n            if (!seqCursor) {\n              // done\n              docStore.delete(cursor.primaryKey);\n              cursor.continue();\n            } else {\n              var data = seqCursor.value;\n              if (data._doc_id_rev === docIdRev) {\n                localStore.put(data);\n              }\n              seqStore.delete(seqCursor.primaryKey);\n              seqCursor.continue();\n            }\n          };\n        } else {\n          cursor.continue();\n        }\n      } else if (cb) {\n        cb();\n      }\n    };\n  }\n\n  // migration to version 4 (part 1)\n  function addAttachAndSeqStore(db) {\n    var attAndSeqStore = db.createObjectStore(ATTACH_AND_SEQ_STORE,\n      {autoIncrement: true});\n    attAndSeqStore.createIndex('seq', 'seq');\n    attAndSeqStore.createIndex('digestSeq', 'digestSeq', {unique: true});\n  }\n\n  // migration to version 4 (part 2)\n  function migrateAttsAndSeqs(txn, callback) {\n    var seqStore = txn.objectStore(BY_SEQ_STORE);\n    var attStore = txn.objectStore(ATTACH_STORE);\n    var attAndSeqStore = txn.objectStore(ATTACH_AND_SEQ_STORE);\n\n    // need to actually populate the table. this is the expensive part,\n    // so as an optimization, check first that this database even\n    // contains attachments\n    var req = attStore.count();\n    req.onsuccess = function (e) {\n      var count = e.target.result;\n      if (!count) {\n        return callback(); // done\n      }\n\n      seqStore.openCursor().onsuccess = function (e) {\n        var cursor = e.target.result;\n        if (!cursor) {\n          return callback(); // done\n        }\n        var doc = cursor.value;\n        var seq = cursor.primaryKey;\n        var atts = Object.keys(doc._attachments || {});\n        var digestMap = {};\n        for (var j = 0; j < atts.length; j++) {\n          var att = doc._attachments[atts[j]];\n          digestMap[att.digest] = true; // uniq digests, just in case\n        }\n        var digests = Object.keys(digestMap);\n        for (j = 0; j < digests.length; j++) {\n          var digest = digests[j];\n          attAndSeqStore.put({\n            seq: seq,\n            digestSeq: digest + '::' + seq\n          });\n        }\n        cursor.continue();\n      };\n    };\n  }\n\n  // migration to version 5\n  // Instead of relying on on-the-fly migration of metadata,\n  // this brings the doc-store to its modern form:\n  // - metadata.winningrev\n  // - metadata.seq\n  // - stringify the metadata when storing it\n  function migrateMetadata(txn) {\n\n    function decodeMetadataCompat(storedObject) {\n      if (!storedObject.data) {\n        // old format, when we didn't store it stringified\n        storedObject.deleted = storedObject.deletedOrLocal === '1';\n        return storedObject;\n      }\n      return decodeMetadata(storedObject);\n    }\n\n    // ensure that every metadata has a winningRev and seq,\n    // which was previously created on-the-fly but better to migrate\n    var bySeqStore = txn.objectStore(BY_SEQ_STORE);\n    var docStore = txn.objectStore(DOC_STORE);\n    var cursor = docStore.openCursor();\n    cursor.onsuccess = function (e) {\n      var cursor = e.target.result;\n      if (!cursor) {\n        return; // done\n      }\n      var metadata = decodeMetadataCompat(cursor.value);\n\n      metadata.winningRev = metadata.winningRev ||\n        winningRev(metadata);\n\n      function fetchMetadataSeq() {\n        // metadata.seq was added post-3.2.0, so if it's missing,\n        // we need to fetch it manually\n        var start = metadata.id + '::';\n        var end = metadata.id + '::\\uffff';\n        var req = bySeqStore.index('_doc_id_rev').openCursor(\n          IDBKeyRange.bound(start, end));\n\n        var metadataSeq = 0;\n        req.onsuccess = function (e) {\n          var cursor = e.target.result;\n          if (!cursor) {\n            metadata.seq = metadataSeq;\n            return onGetMetadataSeq();\n          }\n          var seq = cursor.primaryKey;\n          if (seq > metadataSeq) {\n            metadataSeq = seq;\n          }\n          cursor.continue();\n        };\n      }\n\n      function onGetMetadataSeq() {\n        var metadataToStore = encodeMetadata(metadata,\n          metadata.winningRev, metadata.deleted);\n\n        var req = docStore.put(metadataToStore);\n        req.onsuccess = function () {\n          cursor.continue();\n        };\n      }\n\n      if (metadata.seq) {\n        return onGetMetadataSeq();\n      }\n\n      fetchMetadataSeq();\n    };\n\n  }\n\n  api._remote = false;\n  api.type = function () {\n    return 'idb';\n  };\n\n  api._id = toPromise(function (callback) {\n    callback(null, api._meta.instanceId);\n  });\n\n  api._bulkDocs = function idb_bulkDocs(req, reqOpts, callback) {\n    idbBulkDocs(opts, req, reqOpts, api, idb, enrichCallbackError(callback));\n  };\n\n  // First we look up the metadata in the ids database, then we fetch the\n  // current revision(s) from the by sequence store\n  api._get = function idb_get(id, opts, callback) {\n    var doc;\n    var metadata;\n    var err;\n    var txn = opts.ctx;\n    if (!txn) {\n      var txnResult = openTransactionSafely(idb,\n        [DOC_STORE, BY_SEQ_STORE, ATTACH_STORE], 'readonly');\n      if (txnResult.error) {\n        return callback(txnResult.error);\n      }\n      txn = txnResult.txn;\n    }\n\n    function finish() {\n      callback(err, {doc: doc, metadata: metadata, ctx: txn});\n    }\n\n    txn.objectStore(DOC_STORE).get(id).onsuccess = function (e) {\n      metadata = decodeMetadata(e.target.result);\n      // we can determine the result here if:\n      // 1. there is no such document\n      // 2. the document is deleted and we don't ask about specific rev\n      // When we ask with opts.rev we expect the answer to be either\n      // doc (possibly with _deleted=true) or missing error\n      if (!metadata) {\n        err = createError(MISSING_DOC, 'missing');\n        return finish();\n      }\n\n      var rev;\n      if (!opts.rev) {\n        rev = metadata.winningRev;\n        var deleted = isDeleted(metadata);\n        if (deleted) {\n          err = createError(MISSING_DOC, \"deleted\");\n          return finish();\n        }\n      } else {\n        rev = opts.latest ? latest(opts.rev, metadata) : opts.rev;\n      }\n\n      var objectStore = txn.objectStore(BY_SEQ_STORE);\n      var key = metadata.id + '::' + rev;\n\n      objectStore.index('_doc_id_rev').get(key).onsuccess = function (e) {\n        doc = e.target.result;\n        if (doc) {\n          doc = decodeDoc(doc);\n        }\n        if (!doc) {\n          err = createError(MISSING_DOC, 'missing');\n          return finish();\n        }\n        finish();\n      };\n    };\n  };\n\n  api._getAttachment = function (docId, attachId, attachment, opts, callback) {\n    var txn;\n    if (opts.ctx) {\n      txn = opts.ctx;\n    } else {\n      var txnResult = openTransactionSafely(idb,\n        [DOC_STORE, BY_SEQ_STORE, ATTACH_STORE], 'readonly');\n      if (txnResult.error) {\n        return callback(txnResult.error);\n      }\n      txn = txnResult.txn;\n    }\n    var digest = attachment.digest;\n    var type = attachment.content_type;\n\n    txn.objectStore(ATTACH_STORE).get(digest).onsuccess = function (e) {\n      var body = e.target.result.body;\n      readBlobData(body, type, opts.binary, function (blobData) {\n        callback(null, blobData);\n      });\n    };\n  };\n\n  api._info = function idb_info(callback) {\n    var updateSeq;\n    var docCount;\n\n    var txnResult = openTransactionSafely(idb, [META_STORE, BY_SEQ_STORE], 'readonly');\n    if (txnResult.error) {\n      return callback(txnResult.error);\n    }\n    var txn = txnResult.txn;\n    txn.objectStore(META_STORE).get(META_STORE).onsuccess = function (e) {\n      docCount = e.target.result.docCount;\n    };\n    txn.objectStore(BY_SEQ_STORE).openCursor(null, 'prev').onsuccess = function (e) {\n      var cursor = e.target.result;\n      updateSeq = cursor ? cursor.key : 0;\n    };\n\n    txn.oncomplete = function () {\n      callback(null, {\n        doc_count: docCount,\n        update_seq: updateSeq,\n        // for debugging\n        idb_attachment_format: (api._meta.blobSupport ? 'binary' : 'base64')\n      });\n    };\n  };\n\n  api._allDocs = function idb_allDocs(opts, callback) {\n    idbAllDocs(opts, idb, enrichCallbackError(callback));\n  };\n\n  api._changes = function idbChanges(opts) {\n    return changes(opts, api, dbName, idb);\n  };\n\n  api._close = function (callback) {\n    // https://developer.mozilla.org/en-US/docs/IndexedDB/IDBDatabase#close\n    // \"Returns immediately and closes the connection in a separate thread...\"\n    idb.close();\n    cachedDBs.delete(dbName);\n    callback();\n  };\n\n  api._getRevisionTree = function (docId, callback) {\n    var txnResult = openTransactionSafely(idb, [DOC_STORE], 'readonly');\n    if (txnResult.error) {\n      return callback(txnResult.error);\n    }\n    var txn = txnResult.txn;\n    var req = txn.objectStore(DOC_STORE).get(docId);\n    req.onsuccess = function (event) {\n      var doc = decodeMetadata(event.target.result);\n      if (!doc) {\n        callback(createError(MISSING_DOC));\n      } else {\n        callback(null, doc.rev_tree);\n      }\n    };\n  };\n\n  // This function removes revisions of document docId\n  // which are listed in revs and sets this document\n  // revision to to rev_tree\n  api._doCompaction = function (docId, revs, callback) {\n    var stores = [\n      DOC_STORE,\n      BY_SEQ_STORE,\n      ATTACH_STORE,\n      ATTACH_AND_SEQ_STORE\n    ];\n    var txnResult = openTransactionSafely(idb, stores, 'readwrite');\n    if (txnResult.error) {\n      return callback(txnResult.error);\n    }\n    var txn = txnResult.txn;\n\n    var docStore = txn.objectStore(DOC_STORE);\n\n    docStore.get(docId).onsuccess = function (event) {\n      var metadata = decodeMetadata(event.target.result);\n      traverseRevTree(metadata.rev_tree, function (isLeaf, pos,\n                                                         revHash, ctx, opts) {\n        var rev = pos + '-' + revHash;\n        if (revs.indexOf(rev) !== -1) {\n          opts.status = 'missing';\n        }\n      });\n      compactRevs(revs, docId, txn);\n      var winningRev$$1 = metadata.winningRev;\n      var deleted = metadata.deleted;\n      txn.objectStore(DOC_STORE).put(\n        encodeMetadata(metadata, winningRev$$1, deleted));\n    };\n    txn.onabort = idbError(callback);\n    txn.oncomplete = function () {\n      callback();\n    };\n  };\n\n\n  api._getLocal = function (id, callback) {\n    var txnResult = openTransactionSafely(idb, [LOCAL_STORE], 'readonly');\n    if (txnResult.error) {\n      return callback(txnResult.error);\n    }\n    var tx = txnResult.txn;\n    var req = tx.objectStore(LOCAL_STORE).get(id);\n\n    req.onerror = idbError(callback);\n    req.onsuccess = function (e) {\n      var doc = e.target.result;\n      if (!doc) {\n        callback(createError(MISSING_DOC));\n      } else {\n        delete doc['_doc_id_rev']; // for backwards compat\n        callback(null, doc);\n      }\n    };\n  };\n\n  api._putLocal = function (doc, opts, callback) {\n    if (typeof opts === 'function') {\n      callback = opts;\n      opts = {};\n    }\n    delete doc._revisions; // ignore this, trust the rev\n    var oldRev = doc._rev;\n    var id = doc._id;\n    if (!oldRev) {\n      doc._rev = '0-1';\n    } else {\n      doc._rev = '0-' + (parseInt(oldRev.split('-')[1], 10) + 1);\n    }\n\n    var tx = opts.ctx;\n    var ret;\n    if (!tx) {\n      var txnResult = openTransactionSafely(idb, [LOCAL_STORE], 'readwrite');\n      if (txnResult.error) {\n        return callback(txnResult.error);\n      }\n      tx = txnResult.txn;\n      tx.onerror = idbError(callback);\n      tx.oncomplete = function () {\n        if (ret) {\n          callback(null, ret);\n        }\n      };\n    }\n\n    var oStore = tx.objectStore(LOCAL_STORE);\n    var req;\n    if (oldRev) {\n      req = oStore.get(id);\n      req.onsuccess = function (e) {\n        var oldDoc = e.target.result;\n        if (!oldDoc || oldDoc._rev !== oldRev) {\n          callback(createError(REV_CONFLICT));\n        } else { // update\n          var req = oStore.put(doc);\n          req.onsuccess = function () {\n            ret = {ok: true, id: doc._id, rev: doc._rev};\n            if (opts.ctx) { // return immediately\n              callback(null, ret);\n            }\n          };\n        }\n      };\n    } else { // new doc\n      req = oStore.add(doc);\n      req.onerror = function (e) {\n        // constraint error, already exists\n        callback(createError(REV_CONFLICT));\n        e.preventDefault(); // avoid transaction abort\n        e.stopPropagation(); // avoid transaction onerror\n      };\n      req.onsuccess = function () {\n        ret = {ok: true, id: doc._id, rev: doc._rev};\n        if (opts.ctx) { // return immediately\n          callback(null, ret);\n        }\n      };\n    }\n  };\n\n  api._removeLocal = function (doc, opts, callback) {\n    if (typeof opts === 'function') {\n      callback = opts;\n      opts = {};\n    }\n    var tx = opts.ctx;\n    if (!tx) {\n      var txnResult = openTransactionSafely(idb, [LOCAL_STORE], 'readwrite');\n      if (txnResult.error) {\n        return callback(txnResult.error);\n      }\n      tx = txnResult.txn;\n      tx.oncomplete = function () {\n        if (ret) {\n          callback(null, ret);\n        }\n      };\n    }\n    var ret;\n    var id = doc._id;\n    var oStore = tx.objectStore(LOCAL_STORE);\n    var req = oStore.get(id);\n\n    req.onerror = idbError(callback);\n    req.onsuccess = function (e) {\n      var oldDoc = e.target.result;\n      if (!oldDoc || oldDoc._rev !== doc._rev) {\n        callback(createError(MISSING_DOC));\n      } else {\n        oStore.delete(id);\n        ret = {ok: true, id: id, rev: '0-0'};\n        if (opts.ctx) { // return immediately\n          callback(null, ret);\n        }\n      }\n    };\n  };\n\n  api._destroy = function (opts, callback) {\n    changesHandler.removeAllListeners(dbName);\n\n    //Close open request for \"dbName\" database to fix ie delay.\n    var openReq = openReqList.get(dbName);\n    if (openReq && openReq.result) {\n      openReq.result.close();\n      cachedDBs.delete(dbName);\n    }\n    var req = indexedDB.deleteDatabase(dbName);\n\n    req.onsuccess = function () {\n      //Remove open request from the list.\n      openReqList.delete(dbName);\n      if (hasLocalStorage() && (dbName in localStorage)) {\n        delete localStorage[dbName];\n      }\n      callback(null, { 'ok': true });\n    };\n\n    req.onerror = idbError(callback);\n  };\n\n  var cached = cachedDBs.get(dbName);\n\n  if (cached) {\n    idb = cached.idb;\n    api._meta = cached.global;\n    return immediate(function () {\n      callback(null, api);\n    });\n  }\n\n  var req = indexedDB.open(dbName, ADAPTER_VERSION);\n  openReqList.set(dbName, req);\n\n  req.onupgradeneeded = function (e) {\n    var db = e.target.result;\n    if (e.oldVersion < 1) {\n      return createSchema(db); // new db, initial schema\n    }\n    // do migrations\n\n    var txn = e.currentTarget.transaction;\n    // these migrations have to be done in this function, before\n    // control is returned to the event loop, because IndexedDB\n\n    if (e.oldVersion < 3) {\n      createLocalStoreSchema(db); // v2 -> v3\n    }\n    if (e.oldVersion < 4) {\n      addAttachAndSeqStore(db); // v3 -> v4\n    }\n\n    var migrations = [\n      addDeletedOrLocalIndex, // v1 -> v2\n      migrateLocalStore,      // v2 -> v3\n      migrateAttsAndSeqs,     // v3 -> v4\n      migrateMetadata         // v4 -> v5\n    ];\n\n    var i = e.oldVersion;\n\n    function next() {\n      var migration = migrations[i - 1];\n      i++;\n      if (migration) {\n        migration(txn, next);\n      }\n    }\n\n    next();\n  };\n\n  req.onsuccess = function (e) {\n\n    idb = e.target.result;\n\n    idb.onversionchange = function () {\n      idb.close();\n      cachedDBs.delete(dbName);\n    };\n\n    idb.onabort = function (e) {\n      guardedConsole('error', 'Database has a global failure', e.target.error);\n      idbGlobalFailureError = e.target.error;\n      idb.close();\n      cachedDBs.delete(dbName);\n    };\n\n    // Do a few setup operations (in parallel as much as possible):\n    // 1. Fetch meta doc\n    // 2. Check blob support\n    // 3. Calculate docCount\n    // 4. Generate an instanceId if necessary\n    // 5. Store docCount and instanceId on meta doc\n\n    var txn = idb.transaction([\n      META_STORE,\n      DETECT_BLOB_SUPPORT_STORE,\n      DOC_STORE\n    ], 'readwrite');\n\n    var storedMetaDoc = false;\n    var metaDoc;\n    var docCount;\n    var blobSupport;\n    var instanceId;\n\n    function completeSetup() {\n      if (typeof blobSupport === 'undefined' || !storedMetaDoc) {\n        return;\n      }\n      api._meta = {\n        name: dbName,\n        instanceId: instanceId,\n        blobSupport: blobSupport\n      };\n\n      cachedDBs.set(dbName, {\n        idb: idb,\n        global: api._meta\n      });\n      callback(null, api);\n    }\n\n    function storeMetaDocIfReady() {\n      if (typeof docCount === 'undefined' || typeof metaDoc === 'undefined') {\n        return;\n      }\n      var instanceKey = dbName + '_id';\n      if (instanceKey in metaDoc) {\n        instanceId = metaDoc[instanceKey];\n      } else {\n        metaDoc[instanceKey] = instanceId = uuid();\n      }\n      metaDoc.docCount = docCount;\n      txn.objectStore(META_STORE).put(metaDoc);\n    }\n\n    //\n    // fetch or generate the instanceId\n    //\n    txn.objectStore(META_STORE).get(META_STORE).onsuccess = function (e) {\n      metaDoc = e.target.result || { id: META_STORE };\n      storeMetaDocIfReady();\n    };\n\n    //\n    // countDocs\n    //\n    countDocs(txn, function (count) {\n      docCount = count;\n      storeMetaDocIfReady();\n    });\n\n    //\n    // check blob support\n    //\n    if (!blobSupportPromise) {\n      // make sure blob support is only checked once\n      blobSupportPromise = checkBlobSupport(txn);\n    }\n\n    blobSupportPromise.then(function (val) {\n      blobSupport = val;\n      completeSetup();\n    });\n\n    // only when the metadata put transaction has completed,\n    // consider the setup done\n    txn.oncomplete = function () {\n      storedMetaDoc = true;\n      completeSetup();\n    };\n    txn.onabort = idbError(callback);\n  };\n\n  req.onerror = function (e) {\n    var msg = e.target.error && e.target.error.message;\n\n    if (!msg) {\n      msg = 'Failed to open indexedDB, are you in private browsing mode?';\n    } else if (msg.indexOf(\"stored database is a higher version\") !== -1) {\n      msg = new Error('This DB was created with the newer \"indexeddb\" adapter, but you are trying to open it with the older \"idb\" adapter');\n    }\n\n    guardedConsole('error', msg);\n    callback(createError(IDB_ERROR, msg));\n  };\n}\n\nIdbPouch.valid = function () {\n  // Following #7085 buggy idb versions (typically Safari < 10.1) are\n  // considered valid.\n\n  // On Firefox SecurityError is thrown while referencing indexedDB if cookies\n  // are not allowed. `typeof indexedDB` also triggers the error.\n  try {\n    // some outdated implementations of IDB that appear on Samsung\n    // and HTC Android devices <4.4 are missing IDBKeyRange\n    return typeof indexedDB !== 'undefined' && typeof IDBKeyRange !== 'undefined';\n  } catch (e) {\n    return false;\n  }\n};\n\nfunction IDBPouch (PouchDB) {\n  PouchDB.adapter('idb', IdbPouch, true);\n}\n\n// dead simple promise pool, inspired by https://github.com/timdp/es6-promise-pool\n// but much smaller in code size. limits the number of concurrent promises that are executed\n\n\nfunction pool(promiseFactories, limit) {\n  return new Promise(function (resolve, reject) {\n    var running = 0;\n    var current = 0;\n    var done = 0;\n    var len = promiseFactories.length;\n    var err;\n\n    function runNext() {\n      running++;\n      promiseFactories[current++]().then(onSuccess, onError);\n    }\n\n    function doNext() {\n      if (++done === len) {\n        /* istanbul ignore if */\n        if (err) {\n          reject(err);\n        } else {\n          resolve();\n        }\n      } else {\n        runNextBatch();\n      }\n    }\n\n    function onSuccess() {\n      running--;\n      doNext();\n    }\n\n    /* istanbul ignore next */\n    function onError(thisErr) {\n      running--;\n      err = err || thisErr;\n      doNext();\n    }\n\n    function runNextBatch() {\n      while (running < limit && current < len) {\n        runNext();\n      }\n    }\n\n    runNextBatch();\n  });\n}\n\nvar CHANGES_BATCH_SIZE = 25;\nvar MAX_SIMULTANEOUS_REVS = 50;\nvar CHANGES_TIMEOUT_BUFFER = 5000;\nvar DEFAULT_HEARTBEAT = 10000;\n\nvar supportsBulkGetMap = {};\n\nfunction readAttachmentsAsBlobOrBuffer(row) {\n  var doc = row.doc || row.ok;\n  var atts = doc && doc._attachments;\n  if (!atts) {\n    return;\n  }\n  Object.keys(atts).forEach(function (filename) {\n    var att = atts[filename];\n    att.data = b64ToBluffer(att.data, att.content_type);\n  });\n}\n\nfunction encodeDocId(id) {\n  if (/^_design/.test(id)) {\n    return '_design/' + encodeURIComponent(id.slice(8));\n  }\n  if (/^_local/.test(id)) {\n    return '_local/' + encodeURIComponent(id.slice(7));\n  }\n  return encodeURIComponent(id);\n}\n\nfunction preprocessAttachments$1(doc) {\n  if (!doc._attachments || !Object.keys(doc._attachments)) {\n    return Promise.resolve();\n  }\n\n  return Promise.all(Object.keys(doc._attachments).map(function (key) {\n    var attachment = doc._attachments[key];\n    if (attachment.data && typeof attachment.data !== 'string') {\n      return new Promise(function (resolve) {\n        blobToBase64(attachment.data, resolve);\n      }).then(function (b64) {\n        attachment.data = b64;\n      });\n    }\n  }));\n}\n\nfunction hasUrlPrefix(opts) {\n  if (!opts.prefix) {\n    return false;\n  }\n  var protocol = parseUri(opts.prefix).protocol;\n  return protocol === 'http' || protocol === 'https';\n}\n\n// Get all the information you possibly can about the URI given by name and\n// return it as a suitable object.\nfunction getHost(name, opts) {\n  // encode db name if opts.prefix is a url (#5574)\n  if (hasUrlPrefix(opts)) {\n    var dbName = opts.name.substr(opts.prefix.length);\n    // Ensure prefix has a trailing slash\n    var prefix = opts.prefix.replace(/\\/?$/, '/');\n    name = prefix + encodeURIComponent(dbName);\n  }\n\n  var uri = parseUri(name);\n  if (uri.user || uri.password) {\n    uri.auth = {username: uri.user, password: uri.password};\n  }\n\n  // Split the path part of the URI into parts using '/' as the delimiter\n  // after removing any leading '/' and any trailing '/'\n  var parts = uri.path.replace(/(^\\/|\\/$)/g, '').split('/');\n\n  uri.db = parts.pop();\n  // Prevent double encoding of URI component\n  if (uri.db.indexOf('%') === -1) {\n    uri.db = encodeURIComponent(uri.db);\n  }\n\n  uri.path = parts.join('/');\n\n  return uri;\n}\n\n// Generate a URL with the host data given by opts and the given path\nfunction genDBUrl(opts, path) {\n  return genUrl(opts, opts.db + '/' + path);\n}\n\n// Generate a URL with the host data given by opts and the given path\nfunction genUrl(opts, path) {\n  // If the host already has a path, then we need to have a path delimiter\n  // Otherwise, the path delimiter is the empty string\n  var pathDel = !opts.path ? '' : '/';\n\n  // If the host already has a path, then we need to have a path delimiter\n  // Otherwise, the path delimiter is the empty string\n  return opts.protocol + '://' + opts.host +\n         (opts.port ? (':' + opts.port) : '') +\n         '/' + opts.path + pathDel + path;\n}\n\nfunction paramsToStr(params) {\n  return '?' + Object.keys(params).map(function (k) {\n    return k + '=' + encodeURIComponent(params[k]);\n  }).join('&');\n}\n\nfunction shouldCacheBust(opts) {\n  var ua = (typeof navigator !== 'undefined' && navigator.userAgent) ?\n      navigator.userAgent.toLowerCase() : '';\n  var isIE = ua.indexOf('msie') !== -1;\n  var isTrident = ua.indexOf('trident') !== -1;\n  var isEdge = ua.indexOf('edge') !== -1;\n  var isGET = !('method' in opts) || opts.method === 'GET';\n  return (isIE || isTrident || isEdge) && isGET;\n}\n\n// Implements the PouchDB API for dealing with CouchDB instances over HTTP\nfunction HttpPouch(opts, callback) {\n\n  // The functions that will be publicly available for HttpPouch\n  var api = this;\n\n  var host = getHost(opts.name, opts);\n  var dbUrl = genDBUrl(host, '');\n\n  opts = clone(opts);\n\n  var ourFetch = function (url, options) {\n\n    options = options || {};\n    options.headers = options.headers || new h();\n\n    options.credentials = 'include';\n\n    if (opts.auth || host.auth) {\n      var nAuth = opts.auth || host.auth;\n      var str = nAuth.username + ':' + nAuth.password;\n      var token = thisBtoa(unescape(encodeURIComponent(str)));\n      options.headers.set('Authorization', 'Basic ' + token);\n    }\n\n    var headers = opts.headers || {};\n    Object.keys(headers).forEach(function (key) {\n      options.headers.append(key, headers[key]);\n    });\n\n    /* istanbul ignore if */\n    if (shouldCacheBust(options)) {\n      url += (url.indexOf('?') === -1 ? '?' : '&') + '_nonce=' + Date.now();\n    }\n\n    var fetchFun = opts.fetch || f$1;\n    return fetchFun(url, options);\n  };\n\n  function adapterFun$$1(name, fun) {\n    return adapterFun(name, getArguments(function (args) {\n      setup().then(function () {\n        return fun.apply(this, args);\n      }).catch(function (e) {\n        var callback = args.pop();\n        callback(e);\n      });\n    })).bind(api);\n  }\n\n  function fetchJSON(url, options, callback) {\n\n    var result = {};\n\n    options = options || {};\n    options.headers = options.headers || new h();\n\n    if (!options.headers.get('Content-Type')) {\n      options.headers.set('Content-Type', 'application/json');\n    }\n    if (!options.headers.get('Accept')) {\n      options.headers.set('Accept', 'application/json');\n    }\n\n    return ourFetch(url, options).then(function (response) {\n      result.ok = response.ok;\n      result.status = response.status;\n      return response.json();\n    }).then(function (json) {\n      result.data = json;\n      if (!result.ok) {\n        result.data.status = result.status;\n        var err = generateErrorFromResponse(result.data);\n        if (callback) {\n          return callback(err);\n        } else {\n          throw err;\n        }\n      }\n\n      if (Array.isArray(result.data)) {\n        result.data = result.data.map(function (v) {\n          if (v.error || v.missing) {\n            return generateErrorFromResponse(v);\n          } else {\n            return v;\n          }\n        });\n      }\n\n      if (callback) {\n        callback(null, result.data);\n      } else {\n        return result;\n      }\n    });\n  }\n\n  var setupPromise;\n\n  function setup() {\n    if (opts.skip_setup) {\n      return Promise.resolve();\n    }\n\n    // If there is a setup in process or previous successful setup\n    // done then we will use that\n    // If previous setups have been rejected we will try again\n    if (setupPromise) {\n      return setupPromise;\n    }\n\n    setupPromise = fetchJSON(dbUrl).catch(function (err) {\n      if (err && err.status && err.status === 404) {\n        // Doesnt exist, create it\n        explainError(404, 'PouchDB is just detecting if the remote exists.');\n        return fetchJSON(dbUrl, {method: 'PUT'});\n      } else {\n        return Promise.reject(err);\n      }\n    }).catch(function (err) {\n      // If we try to create a database that already exists, skipped in\n      // istanbul since its catching a race condition.\n      /* istanbul ignore if */\n      if (err && err.status && err.status === 412) {\n        return true;\n      }\n      return Promise.reject(err);\n    });\n\n    setupPromise.catch(function () {\n      setupPromise = null;\n    });\n\n    return setupPromise;\n  }\n\n  immediate(function () {\n    callback(null, api);\n  });\n\n  api._remote = true;\n\n  /* istanbul ignore next */\n  api.type = function () {\n    return 'http';\n  };\n\n  api.id = adapterFun$$1('id', function (callback) {\n    ourFetch(genUrl(host, '')).then(function (response) {\n      return response.json();\n    }).catch(function () {\n      return {};\n    }).then(function (result) {\n      // Bad response or missing `uuid` should not prevent ID generation.\n      var uuid$$1 = (result && result.uuid) ?\n          (result.uuid + host.db) : genDBUrl(host, '');\n      callback(null, uuid$$1);\n    });\n  });\n\n  // Sends a POST request to the host calling the couchdb _compact function\n  //    version: The version of CouchDB it is running\n  api.compact = adapterFun$$1('compact', function (opts, callback) {\n    if (typeof opts === 'function') {\n      callback = opts;\n      opts = {};\n    }\n    opts = clone(opts);\n\n    fetchJSON(genDBUrl(host, '_compact'), {method: 'POST'}).then(function () {\n      function ping() {\n        api.info(function (err, res) {\n          // CouchDB may send a \"compact_running:true\" if it's\n          // already compacting. PouchDB Server doesn't.\n          /* istanbul ignore else */\n          if (res && !res.compact_running) {\n            callback(null, {ok: true});\n          } else {\n            setTimeout(ping, opts.interval || 200);\n          }\n        });\n      }\n      // Ping the http if it's finished compaction\n      ping();\n    });\n  });\n\n  api.bulkGet = adapterFun('bulkGet', function (opts, callback) {\n    var self = this;\n\n    function doBulkGet(cb) {\n      var params = {};\n      if (opts.revs) {\n        params.revs = true;\n      }\n      if (opts.attachments) {\n        /* istanbul ignore next */\n        params.attachments = true;\n      }\n      if (opts.latest) {\n        params.latest = true;\n      }\n      fetchJSON(genDBUrl(host, '_bulk_get' + paramsToStr(params)), {\n        method: 'POST',\n        body: JSON.stringify({ docs: opts.docs})\n      }).then(function (result) {\n        if (opts.attachments && opts.binary) {\n          result.data.results.forEach(function (res) {\n            res.docs.forEach(readAttachmentsAsBlobOrBuffer);\n          });\n        }\n        cb(null, result.data);\n      }).catch(cb);\n    }\n\n    /* istanbul ignore next */\n    function doBulkGetShim() {\n      // avoid \"url too long error\" by splitting up into multiple requests\n      var batchSize = MAX_SIMULTANEOUS_REVS;\n      var numBatches = Math.ceil(opts.docs.length / batchSize);\n      var numDone = 0;\n      var results = new Array(numBatches);\n\n      function onResult(batchNum) {\n        return function (err, res) {\n          // err is impossible because shim returns a list of errs in that case\n          results[batchNum] = res.results;\n          if (++numDone === numBatches) {\n            callback(null, {results: flatten(results)});\n          }\n        };\n      }\n\n      for (var i = 0; i < numBatches; i++) {\n        var subOpts = pick(opts, ['revs', 'attachments', 'binary', 'latest']);\n        subOpts.docs = opts.docs.slice(i * batchSize,\n          Math.min(opts.docs.length, (i + 1) * batchSize));\n        bulkGet(self, subOpts, onResult(i));\n      }\n    }\n\n    // mark the whole database as either supporting or not supporting _bulk_get\n    var dbUrl = genUrl(host, '');\n    var supportsBulkGet = supportsBulkGetMap[dbUrl];\n\n    /* istanbul ignore next */\n    if (typeof supportsBulkGet !== 'boolean') {\n      // check if this database supports _bulk_get\n      doBulkGet(function (err, res) {\n        if (err) {\n          supportsBulkGetMap[dbUrl] = false;\n          explainError(\n            err.status,\n            'PouchDB is just detecting if the remote ' +\n            'supports the _bulk_get API.'\n          );\n          doBulkGetShim();\n        } else {\n          supportsBulkGetMap[dbUrl] = true;\n          callback(null, res);\n        }\n      });\n    } else if (supportsBulkGet) {\n      doBulkGet(callback);\n    } else {\n      doBulkGetShim();\n    }\n  });\n\n  // Calls GET on the host, which gets back a JSON string containing\n  //    couchdb: A welcome string\n  //    version: The version of CouchDB it is running\n  api._info = function (callback) {\n    setup().then(function () {\n      return ourFetch(genDBUrl(host, ''));\n    }).then(function (response) {\n      return response.json();\n    }).then(function (info) {\n      info.host = genDBUrl(host, '');\n      callback(null, info);\n    }).catch(callback);\n  };\n\n  api.fetch = function (path, options) {\n    return setup().then(function () {\n      var url = path.substring(0, 1) === '/' ?\n        genUrl(host, path.substring(1)) :\n        genDBUrl(host, path);\n      return ourFetch(url, options);\n    });\n  };\n\n  // Get the document with the given id from the database given by host.\n  // The id could be solely the _id in the database, or it may be a\n  // _design/ID or _local/ID path\n  api.get = adapterFun$$1('get', function (id, opts, callback) {\n    // If no options were given, set the callback to the second parameter\n    if (typeof opts === 'function') {\n      callback = opts;\n      opts = {};\n    }\n    opts = clone(opts);\n\n    // List of parameters to add to the GET request\n    var params = {};\n\n    if (opts.revs) {\n      params.revs = true;\n    }\n\n    if (opts.revs_info) {\n      params.revs_info = true;\n    }\n\n    if (opts.latest) {\n      params.latest = true;\n    }\n\n    if (opts.open_revs) {\n      if (opts.open_revs !== \"all\") {\n        opts.open_revs = JSON.stringify(opts.open_revs);\n      }\n      params.open_revs = opts.open_revs;\n    }\n\n    if (opts.rev) {\n      params.rev = opts.rev;\n    }\n\n    if (opts.conflicts) {\n      params.conflicts = opts.conflicts;\n    }\n\n    /* istanbul ignore if */\n    if (opts.update_seq) {\n      params.update_seq = opts.update_seq;\n    }\n\n    id = encodeDocId(id);\n\n    function fetchAttachments(doc) {\n      var atts = doc._attachments;\n      var filenames = atts && Object.keys(atts);\n      if (!atts || !filenames.length) {\n        return;\n      }\n      // we fetch these manually in separate XHRs, because\n      // Sync Gateway would normally send it back as multipart/mixed,\n      // which we cannot parse. Also, this is more efficient than\n      // receiving attachments as base64-encoded strings.\n      function fetchData(filename) {\n        var att = atts[filename];\n        var path = encodeDocId(doc._id) + '/' + encodeAttachmentId(filename) +\n            '?rev=' + doc._rev;\n        return ourFetch(genDBUrl(host, path)).then(function (response) {\n          if ('buffer' in response) {\n            return response.buffer();\n          } else {\n            /* istanbul ignore next */\n            return response.blob();\n          }\n        }).then(function (blob) {\n          if (opts.binary) {\n            var typeFieldDescriptor = Object.getOwnPropertyDescriptor(blob.__proto__, 'type');\n            if (!typeFieldDescriptor || typeFieldDescriptor.set) {\n              blob.type = att.content_type;\n            }\n            return blob;\n          }\n          return new Promise(function (resolve) {\n            blobToBase64(blob, resolve);\n          });\n        }).then(function (data) {\n          delete att.stub;\n          delete att.length;\n          att.data = data;\n        });\n      }\n\n      var promiseFactories = filenames.map(function (filename) {\n        return function () {\n          return fetchData(filename);\n        };\n      });\n\n      // This limits the number of parallel xhr requests to 5 any time\n      // to avoid issues with maximum browser request limits\n      return pool(promiseFactories, 5);\n    }\n\n    function fetchAllAttachments(docOrDocs) {\n      if (Array.isArray(docOrDocs)) {\n        return Promise.all(docOrDocs.map(function (doc) {\n          if (doc.ok) {\n            return fetchAttachments(doc.ok);\n          }\n        }));\n      }\n      return fetchAttachments(docOrDocs);\n    }\n\n    var url = genDBUrl(host, id + paramsToStr(params));\n    fetchJSON(url).then(function (res) {\n      return Promise.resolve().then(function () {\n        if (opts.attachments) {\n          return fetchAllAttachments(res.data);\n        }\n      }).then(function () {\n        callback(null, res.data);\n      });\n    }).catch(function (e) {\n      e.docId = id;\n      callback(e);\n    });\n  });\n\n\n  // Delete the document given by doc from the database given by host.\n  api.remove = adapterFun$$1('remove', function (docOrId, optsOrRev, opts, cb) {\n    var doc;\n    if (typeof optsOrRev === 'string') {\n      // id, rev, opts, callback style\n      doc = {\n        _id: docOrId,\n        _rev: optsOrRev\n      };\n      if (typeof opts === 'function') {\n        cb = opts;\n        opts = {};\n      }\n    } else {\n      // doc, opts, callback style\n      doc = docOrId;\n      if (typeof optsOrRev === 'function') {\n        cb = optsOrRev;\n        opts = {};\n      } else {\n        cb = opts;\n        opts = optsOrRev;\n      }\n    }\n\n    var rev = (doc._rev || opts.rev);\n    var url = genDBUrl(host, encodeDocId(doc._id)) + '?rev=' + rev;\n\n    fetchJSON(url, {method: 'DELETE'}, cb).catch(cb);\n  });\n\n  function encodeAttachmentId(attachmentId) {\n    return attachmentId.split(\"/\").map(encodeURIComponent).join(\"/\");\n  }\n\n  // Get the attachment\n  api.getAttachment = adapterFun$$1('getAttachment', function (docId, attachmentId,\n                                                            opts, callback) {\n    if (typeof opts === 'function') {\n      callback = opts;\n      opts = {};\n    }\n    var params = opts.rev ? ('?rev=' + opts.rev) : '';\n    var url = genDBUrl(host, encodeDocId(docId)) + '/' +\n        encodeAttachmentId(attachmentId) + params;\n    var contentType;\n    ourFetch(url, {method: 'GET'}).then(function (response) {\n      contentType = response.headers.get('content-type');\n      if (!response.ok) {\n        throw response;\n      } else {\n        if (typeof process !== 'undefined' && !process.browser && typeof response.buffer === 'function') {\n          return response.buffer();\n        } else {\n          /* istanbul ignore next */\n          return response.blob();\n        }\n      }\n    }).then(function (blob) {\n      // TODO: also remove\n      if (typeof process !== 'undefined' && !process.browser) {\n        var typeFieldDescriptor = Object.getOwnPropertyDescriptor(blob.__proto__, 'type');\n        if (!typeFieldDescriptor || typeFieldDescriptor.set) {\n          blob.type = contentType;\n        }\n      }\n      callback(null, blob);\n    }).catch(function (err) {\n      callback(err);\n    });\n  });\n\n  // Remove the attachment given by the id and rev\n  api.removeAttachment =  adapterFun$$1('removeAttachment', function (docId,\n                                                                   attachmentId,\n                                                                   rev,\n                                                                   callback) {\n    var url = genDBUrl(host, encodeDocId(docId) + '/' +\n                       encodeAttachmentId(attachmentId)) + '?rev=' + rev;\n    fetchJSON(url, {method: 'DELETE'}, callback).catch(callback);\n  });\n\n  // Add the attachment given by blob and its contentType property\n  // to the document with the given id, the revision given by rev, and\n  // add it to the database given by host.\n  api.putAttachment = adapterFun$$1('putAttachment', function (docId, attachmentId,\n                                                            rev, blob,\n                                                            type, callback) {\n    if (typeof type === 'function') {\n      callback = type;\n      type = blob;\n      blob = rev;\n      rev = null;\n    }\n    var id = encodeDocId(docId) + '/' + encodeAttachmentId(attachmentId);\n    var url = genDBUrl(host, id);\n    if (rev) {\n      url += '?rev=' + rev;\n    }\n\n    if (typeof blob === 'string') {\n      // input is assumed to be a base64 string\n      var binary;\n      try {\n        binary = thisAtob(blob);\n      } catch (err) {\n        return callback(createError(BAD_ARG,\n                        'Attachment is not a valid base64 string'));\n      }\n      blob = binary ? binStringToBluffer(binary, type) : '';\n    }\n\n    // Add the attachment\n    fetchJSON(url, {\n      headers: new h({'Content-Type': type}),\n      method: 'PUT',\n      body: blob\n    }, callback).catch(callback);\n  });\n\n  // Update/create multiple documents given by req in the database\n  // given by host.\n  api._bulkDocs = function (req, opts, callback) {\n    // If new_edits=false then it prevents the database from creating\n    // new revision numbers for the documents. Instead it just uses\n    // the old ones. This is used in database replication.\n    req.new_edits = opts.new_edits;\n\n    setup().then(function () {\n      return Promise.all(req.docs.map(preprocessAttachments$1));\n    }).then(function () {\n      // Update/create the documents\n      return fetchJSON(genDBUrl(host, '_bulk_docs'), {\n        method: 'POST',\n        body: JSON.stringify(req)\n      }, callback);\n    }).catch(callback);\n  };\n\n\n  // Update/create document\n  api._put = function (doc, opts, callback) {\n    setup().then(function () {\n      return preprocessAttachments$1(doc);\n    }).then(function () {\n      return fetchJSON(genDBUrl(host, encodeDocId(doc._id)), {\n        method: 'PUT',\n        body: JSON.stringify(doc)\n      });\n    }).then(function (result) {\n      callback(null, result.data);\n    }).catch(function (err) {\n      err.docId = doc && doc._id;\n      callback(err);\n    });\n  };\n\n\n  // Get a listing of the documents in the database given\n  // by host and ordered by increasing id.\n  api.allDocs = adapterFun$$1('allDocs', function (opts, callback) {\n    if (typeof opts === 'function') {\n      callback = opts;\n      opts = {};\n    }\n    opts = clone(opts);\n\n    // List of parameters to add to the GET request\n    var params = {};\n    var body;\n    var method = 'GET';\n\n    if (opts.conflicts) {\n      params.conflicts = true;\n    }\n\n    /* istanbul ignore if */\n    if (opts.update_seq) {\n      params.update_seq = true;\n    }\n\n    if (opts.descending) {\n      params.descending = true;\n    }\n\n    if (opts.include_docs) {\n      params.include_docs = true;\n    }\n\n    // added in CouchDB 1.6.0\n    if (opts.attachments) {\n      params.attachments = true;\n    }\n\n    if (opts.key) {\n      params.key = JSON.stringify(opts.key);\n    }\n\n    if (opts.start_key) {\n      opts.startkey = opts.start_key;\n    }\n\n    if (opts.startkey) {\n      params.startkey = JSON.stringify(opts.startkey);\n    }\n\n    if (opts.end_key) {\n      opts.endkey = opts.end_key;\n    }\n\n    if (opts.endkey) {\n      params.endkey = JSON.stringify(opts.endkey);\n    }\n\n    if (typeof opts.inclusive_end !== 'undefined') {\n      params.inclusive_end = !!opts.inclusive_end;\n    }\n\n    if (typeof opts.limit !== 'undefined') {\n      params.limit = opts.limit;\n    }\n\n    if (typeof opts.skip !== 'undefined') {\n      params.skip = opts.skip;\n    }\n\n    var paramStr = paramsToStr(params);\n\n    if (typeof opts.keys !== 'undefined') {\n      method = 'POST';\n      body = {keys: opts.keys};\n    }\n\n    fetchJSON(genDBUrl(host, '_all_docs' + paramStr), {\n       method: method,\n      body: JSON.stringify(body)\n    }).then(function (result) {\n      if (opts.include_docs && opts.attachments && opts.binary) {\n        result.data.rows.forEach(readAttachmentsAsBlobOrBuffer);\n      }\n      callback(null, result.data);\n    }).catch(callback);\n  });\n\n  // Get a list of changes made to documents in the database given by host.\n  // TODO According to the README, there should be two other methods here,\n  // api.changes.addListener and api.changes.removeListener.\n  api._changes = function (opts) {\n\n    // We internally page the results of a changes request, this means\n    // if there is a large set of changes to be returned we can start\n    // processing them quicker instead of waiting on the entire\n    // set of changes to return and attempting to process them at once\n    var batchSize = 'batch_size' in opts ? opts.batch_size : CHANGES_BATCH_SIZE;\n\n    opts = clone(opts);\n\n    if (opts.continuous && !('heartbeat' in opts)) {\n      opts.heartbeat = DEFAULT_HEARTBEAT;\n    }\n\n    var requestTimeout = ('timeout' in opts) ? opts.timeout : 30 * 1000;\n\n    // ensure CHANGES_TIMEOUT_BUFFER applies\n    if ('timeout' in opts && opts.timeout &&\n      (requestTimeout - opts.timeout) < CHANGES_TIMEOUT_BUFFER) {\n        requestTimeout = opts.timeout + CHANGES_TIMEOUT_BUFFER;\n    }\n\n    /* istanbul ignore if */\n    if ('heartbeat' in opts && opts.heartbeat &&\n       (requestTimeout - opts.heartbeat) < CHANGES_TIMEOUT_BUFFER) {\n        requestTimeout = opts.heartbeat + CHANGES_TIMEOUT_BUFFER;\n    }\n\n    var params = {};\n    if ('timeout' in opts && opts.timeout) {\n      params.timeout = opts.timeout;\n    }\n\n    var limit = (typeof opts.limit !== 'undefined') ? opts.limit : false;\n    var leftToFetch = limit;\n\n    if (opts.style) {\n      params.style = opts.style;\n    }\n\n    if (opts.include_docs || opts.filter && typeof opts.filter === 'function') {\n      params.include_docs = true;\n    }\n\n    if (opts.attachments) {\n      params.attachments = true;\n    }\n\n    if (opts.continuous) {\n      params.feed = 'longpoll';\n    }\n\n    if (opts.seq_interval) {\n      params.seq_interval = opts.seq_interval;\n    }\n\n    if (opts.conflicts) {\n      params.conflicts = true;\n    }\n\n    if (opts.descending) {\n      params.descending = true;\n    }\n\n    /* istanbul ignore if */\n    if (opts.update_seq) {\n      params.update_seq = true;\n    }\n\n    if ('heartbeat' in opts) {\n      // If the heartbeat value is false, it disables the default heartbeat\n      if (opts.heartbeat) {\n        params.heartbeat = opts.heartbeat;\n      }\n    }\n\n    if (opts.filter && typeof opts.filter === 'string') {\n      params.filter = opts.filter;\n    }\n\n    if (opts.view && typeof opts.view === 'string') {\n      params.filter = '_view';\n      params.view = opts.view;\n    }\n\n    // If opts.query_params exists, pass it through to the changes request.\n    // These parameters may be used by the filter on the source database.\n    if (opts.query_params && typeof opts.query_params === 'object') {\n      for (var param_name in opts.query_params) {\n        /* istanbul ignore else */\n        if (Object.prototype.hasOwnProperty.call(opts.query_params, param_name)) {\n          params[param_name] = opts.query_params[param_name];\n        }\n      }\n    }\n\n    var method = 'GET';\n    var body;\n\n    if (opts.doc_ids) {\n      // set this automagically for the user; it's annoying that couchdb\n      // requires both a \"filter\" and a \"doc_ids\" param.\n      params.filter = '_doc_ids';\n      method = 'POST';\n      body = {doc_ids: opts.doc_ids };\n    }\n    /* istanbul ignore next */\n    else if (opts.selector) {\n      // set this automagically for the user, similar to above\n      params.filter = '_selector';\n      method = 'POST';\n      body = {selector: opts.selector };\n    }\n\n    var controller = new a();\n    var lastFetchedSeq;\n\n    // Get all the changes starting wtih the one immediately after the\n    // sequence number given by since.\n    var fetchData = function (since, callback) {\n      if (opts.aborted) {\n        return;\n      }\n      params.since = since;\n      // \"since\" can be any kind of json object in Cloudant/CouchDB 2.x\n      /* istanbul ignore next */\n      if (typeof params.since === \"object\") {\n        params.since = JSON.stringify(params.since);\n      }\n\n      if (opts.descending) {\n        if (limit) {\n          params.limit = leftToFetch;\n        }\n      } else {\n        params.limit = (!limit || leftToFetch > batchSize) ?\n          batchSize : leftToFetch;\n      }\n\n      // Set the options for the ajax call\n      var url = genDBUrl(host, '_changes' + paramsToStr(params));\n      var fetchOpts = {\n        signal: controller.signal,\n        method: method,\n        body: JSON.stringify(body)\n      };\n      lastFetchedSeq = since;\n\n      /* istanbul ignore if */\n      if (opts.aborted) {\n        return;\n      }\n\n      // Get the changes\n      setup().then(function () {\n        return fetchJSON(url, fetchOpts, callback);\n      }).catch(callback);\n    };\n\n    // If opts.since exists, get all the changes from the sequence\n    // number given by opts.since. Otherwise, get all the changes\n    // from the sequence number 0.\n    var results = {results: []};\n\n    var fetched = function (err, res) {\n      if (opts.aborted) {\n        return;\n      }\n      var raw_results_length = 0;\n      // If the result of the ajax call (res) contains changes (res.results)\n      if (res && res.results) {\n        raw_results_length = res.results.length;\n        results.last_seq = res.last_seq;\n        var pending = null;\n        var lastSeq = null;\n        // Attach 'pending' property if server supports it (CouchDB 2.0+)\n        /* istanbul ignore if */\n        if (typeof res.pending === 'number') {\n          pending = res.pending;\n        }\n        if (typeof results.last_seq === 'string' || typeof results.last_seq === 'number') {\n          lastSeq = results.last_seq;\n        }\n        // For each change\n        var req = {};\n        req.query = opts.query_params;\n        res.results = res.results.filter(function (c) {\n          leftToFetch--;\n          var ret = filterChange(opts)(c);\n          if (ret) {\n            if (opts.include_docs && opts.attachments && opts.binary) {\n              readAttachmentsAsBlobOrBuffer(c);\n            }\n            if (opts.return_docs) {\n              results.results.push(c);\n            }\n            opts.onChange(c, pending, lastSeq);\n          }\n          return ret;\n        });\n      } else if (err) {\n        // In case of an error, stop listening for changes and call\n        // opts.complete\n        opts.aborted = true;\n        opts.complete(err);\n        return;\n      }\n\n      // The changes feed may have timed out with no results\n      // if so reuse last update sequence\n      if (res && res.last_seq) {\n        lastFetchedSeq = res.last_seq;\n      }\n\n      var finished = (limit && leftToFetch <= 0) ||\n        (res && raw_results_length < batchSize) ||\n        (opts.descending);\n\n      if ((opts.continuous && !(limit && leftToFetch <= 0)) || !finished) {\n        // Queue a call to fetch again with the newest sequence number\n        immediate(function () { fetchData(lastFetchedSeq, fetched); });\n      } else {\n        // We're done, call the callback\n        opts.complete(null, results);\n      }\n    };\n\n    fetchData(opts.since || 0, fetched);\n\n    // Return a method to cancel this method from processing any more\n    return {\n      cancel: function () {\n        opts.aborted = true;\n        controller.abort();\n      }\n    };\n  };\n\n  // Given a set of document/revision IDs (given by req), tets the subset of\n  // those that do NOT correspond to revisions stored in the database.\n  // See http://wiki.apache.org/couchdb/HttpPostRevsDiff\n  api.revsDiff = adapterFun$$1('revsDiff', function (req, opts, callback) {\n    // If no options were given, set the callback to be the second parameter\n    if (typeof opts === 'function') {\n      callback = opts;\n      opts = {};\n    }\n\n    // Get the missing document/revision IDs\n    fetchJSON(genDBUrl(host, '_revs_diff'), {\n      method: 'POST',\n      body: JSON.stringify(req)\n    }, callback).catch(callback);\n  });\n\n  api._close = function (callback) {\n    callback();\n  };\n\n  api._destroy = function (options, callback) {\n    fetchJSON(genDBUrl(host, ''), {method: 'DELETE'}).then(function (json) {\n      callback(null, json);\n    }).catch(function (err) {\n      /* istanbul ignore if */\n      if (err.status === 404) {\n        callback(null, {ok: true});\n      } else {\n        callback(err);\n      }\n    });\n  };\n}\n\n// HttpPouch is a valid adapter.\nHttpPouch.valid = function () {\n  return true;\n};\n\nfunction HttpPouch$1 (PouchDB) {\n  PouchDB.adapter('http', HttpPouch, false);\n  PouchDB.adapter('https', HttpPouch, false);\n}\n\nfunction QueryParseError(message) {\n  this.status = 400;\n  this.name = 'query_parse_error';\n  this.message = message;\n  this.error = true;\n  try {\n    Error.captureStackTrace(this, QueryParseError);\n  } catch (e) {}\n}\n\ninherits(QueryParseError, Error);\n\nfunction NotFoundError(message) {\n  this.status = 404;\n  this.name = 'not_found';\n  this.message = message;\n  this.error = true;\n  try {\n    Error.captureStackTrace(this, NotFoundError);\n  } catch (e) {}\n}\n\ninherits(NotFoundError, Error);\n\nfunction BuiltInError(message) {\n  this.status = 500;\n  this.name = 'invalid_value';\n  this.message = message;\n  this.error = true;\n  try {\n    Error.captureStackTrace(this, BuiltInError);\n  } catch (e) {}\n}\n\ninherits(BuiltInError, Error);\n\nfunction promisedCallback(promise, callback) {\n  if (callback) {\n    promise.then(function (res) {\n      immediate(function () {\n        callback(null, res);\n      });\n    }, function (reason) {\n      immediate(function () {\n        callback(reason);\n      });\n    });\n  }\n  return promise;\n}\n\nfunction callbackify(fun) {\n  return getArguments(function (args) {\n    var cb = args.pop();\n    var promise = fun.apply(this, args);\n    if (typeof cb === 'function') {\n      promisedCallback(promise, cb);\n    }\n    return promise;\n  });\n}\n\n// Promise finally util similar to Q.finally\nfunction fin(promise, finalPromiseFactory) {\n  return promise.then(function (res) {\n    return finalPromiseFactory().then(function () {\n      return res;\n    });\n  }, function (reason) {\n    return finalPromiseFactory().then(function () {\n      throw reason;\n    });\n  });\n}\n\nfunction sequentialize(queue, promiseFactory) {\n  return function () {\n    var args = arguments;\n    var that = this;\n    return queue.add(function () {\n      return promiseFactory.apply(that, args);\n    });\n  };\n}\n\n// uniq an array of strings, order not guaranteed\n// similar to underscore/lodash _.uniq\nfunction uniq(arr) {\n  var theSet = new ExportedSet(arr);\n  var result = new Array(theSet.size);\n  var index = -1;\n  theSet.forEach(function (value) {\n    result[++index] = value;\n  });\n  return result;\n}\n\nfunction mapToKeysArray(map) {\n  var result = new Array(map.size);\n  var index = -1;\n  map.forEach(function (value, key) {\n    result[++index] = key;\n  });\n  return result;\n}\n\nfunction createBuiltInError(name) {\n  var message = 'builtin ' + name +\n    ' function requires map values to be numbers' +\n    ' or number arrays';\n  return new BuiltInError(message);\n}\n\nfunction sum(values) {\n  var result = 0;\n  for (var i = 0, len = values.length; i < len; i++) {\n    var num = values[i];\n    if (typeof num !== 'number') {\n      if (Array.isArray(num)) {\n        // lists of numbers are also allowed, sum them separately\n        result = typeof result === 'number' ? [result] : result;\n        for (var j = 0, jLen = num.length; j < jLen; j++) {\n          var jNum = num[j];\n          if (typeof jNum !== 'number') {\n            throw createBuiltInError('_sum');\n          } else if (typeof result[j] === 'undefined') {\n            result.push(jNum);\n          } else {\n            result[j] += jNum;\n          }\n        }\n      } else { // not array/number\n        throw createBuiltInError('_sum');\n      }\n    } else if (typeof result === 'number') {\n      result += num;\n    } else { // add number to array\n      result[0] += num;\n    }\n  }\n  return result;\n}\n\nvar log = guardedConsole.bind(null, 'log');\nvar isArray = Array.isArray;\nvar toJSON = JSON.parse;\n\nfunction evalFunctionWithEval(func, emit) {\n  return scopeEval(\n    \"return (\" + func.replace(/;\\s*$/, \"\") + \");\",\n    {\n      emit: emit,\n      sum: sum,\n      log: log,\n      isArray: isArray,\n      toJSON: toJSON\n    }\n  );\n}\n\n/*\n * Simple task queue to sequentialize actions. Assumes\n * callbacks will eventually fire (once).\n */\n\n\nfunction TaskQueue$1() {\n  this.promise = new Promise(function (fulfill) {fulfill(); });\n}\nTaskQueue$1.prototype.add = function (promiseFactory) {\n  this.promise = this.promise.catch(function () {\n    // just recover\n  }).then(function () {\n    return promiseFactory();\n  });\n  return this.promise;\n};\nTaskQueue$1.prototype.finish = function () {\n  return this.promise;\n};\n\nfunction stringify(input) {\n  if (!input) {\n    return 'undefined'; // backwards compat for empty reduce\n  }\n  // for backwards compat with mapreduce, functions/strings are stringified\n  // as-is. everything else is JSON-stringified.\n  switch (typeof input) {\n    case 'function':\n      // e.g. a mapreduce map\n      return input.toString();\n    case 'string':\n      // e.g. a mapreduce built-in _reduce function\n      return input.toString();\n    default:\n      // e.g. a JSON object in the case of mango queries\n      return JSON.stringify(input);\n  }\n}\n\n/* create a string signature for a view so we can cache it and uniq it */\nfunction createViewSignature(mapFun, reduceFun) {\n  // the \"undefined\" part is for backwards compatibility\n  return stringify(mapFun) + stringify(reduceFun) + 'undefined';\n}\n\nfunction createView(sourceDB, viewName, mapFun, reduceFun, temporary, localDocName) {\n  var viewSignature = createViewSignature(mapFun, reduceFun);\n\n  var cachedViews;\n  if (!temporary) {\n    // cache this to ensure we don't try to update the same view twice\n    cachedViews = sourceDB._cachedViews = sourceDB._cachedViews || {};\n    if (cachedViews[viewSignature]) {\n      return cachedViews[viewSignature];\n    }\n  }\n\n  var promiseForView = sourceDB.info().then(function (info) {\n\n    var depDbName = info.db_name + '-mrview-' +\n      (temporary ? 'temp' : stringMd5(viewSignature));\n\n    // save the view name in the source db so it can be cleaned up if necessary\n    // (e.g. when the _design doc is deleted, remove all associated view data)\n    function diffFunction(doc) {\n      doc.views = doc.views || {};\n      var fullViewName = viewName;\n      if (fullViewName.indexOf('/') === -1) {\n        fullViewName = viewName + '/' + viewName;\n      }\n      var depDbs = doc.views[fullViewName] = doc.views[fullViewName] || {};\n      /* istanbul ignore if */\n      if (depDbs[depDbName]) {\n        return; // no update necessary\n      }\n      depDbs[depDbName] = true;\n      return doc;\n    }\n    return upsert(sourceDB, '_local/' + localDocName, diffFunction).then(function () {\n      return sourceDB.registerDependentDatabase(depDbName).then(function (res) {\n        var db = res.db;\n        db.auto_compaction = true;\n        var view = {\n          name: depDbName,\n          db: db,\n          sourceDB: sourceDB,\n          adapter: sourceDB.adapter,\n          mapFun: mapFun,\n          reduceFun: reduceFun\n        };\n        return view.db.get('_local/lastSeq').catch(function (err) {\n          /* istanbul ignore if */\n          if (err.status !== 404) {\n            throw err;\n          }\n        }).then(function (lastSeqDoc) {\n          view.seq = lastSeqDoc ? lastSeqDoc.seq : 0;\n          if (cachedViews) {\n            view.db.once('destroyed', function () {\n              delete cachedViews[viewSignature];\n            });\n          }\n          return view;\n        });\n      });\n    });\n  });\n\n  if (cachedViews) {\n    cachedViews[viewSignature] = promiseForView;\n  }\n  return promiseForView;\n}\n\nvar persistentQueues = {};\nvar tempViewQueue = new TaskQueue$1();\nvar CHANGES_BATCH_SIZE$1 = 50;\n\nfunction parseViewName(name) {\n  // can be either 'ddocname/viewname' or just 'viewname'\n  // (where the ddoc name is the same)\n  return name.indexOf('/') === -1 ? [name, name] : name.split('/');\n}\n\nfunction isGenOne(changes) {\n  // only return true if the current change is 1-\n  // and there are no other leafs\n  return changes.length === 1 && /^1-/.test(changes[0].rev);\n}\n\nfunction emitError(db, e, data) {\n  try {\n    db.emit('error', e);\n  } catch (err) {\n    guardedConsole('error',\n      'The user\\'s map/reduce function threw an uncaught error.\\n' +\n      'You can debug this error by doing:\\n' +\n      'myDatabase.on(\\'error\\', function (err) { debugger; });\\n' +\n      'Please double-check your map/reduce function.');\n    guardedConsole('error', e, data);\n  }\n}\n\n/**\n * Returns an \"abstract\" mapreduce object of the form:\n *\n *   {\n *     query: queryFun,\n *     viewCleanup: viewCleanupFun\n *   }\n *\n * Arguments are:\n *\n * localDoc: string\n *   This is for the local doc that gets saved in order to track the\n *   \"dependent\" DBs and clean them up for viewCleanup. It should be\n *   unique, so that indexer plugins don't collide with each other.\n * mapper: function (mapFunDef, emit)\n *   Returns a map function based on the mapFunDef, which in the case of\n *   normal map/reduce is just the de-stringified function, but may be\n *   something else, such as an object in the case of pouchdb-find.\n * reducer: function (reduceFunDef)\n *   Ditto, but for reducing. Modules don't have to support reducing\n *   (e.g. pouchdb-find).\n * ddocValidator: function (ddoc, viewName)\n *   Throws an error if the ddoc or viewName is not valid.\n *   This could be a way to communicate to the user that the configuration for the\n *   indexer is invalid.\n */\nfunction createAbstractMapReduce(localDocName, mapper, reducer, ddocValidator) {\n\n  function tryMap(db, fun, doc) {\n    // emit an event if there was an error thrown by a map function.\n    // putting try/catches in a single function also avoids deoptimizations.\n    try {\n      fun(doc);\n    } catch (e) {\n      emitError(db, e, {fun: fun, doc: doc});\n    }\n  }\n\n  function tryReduce(db, fun, keys, values, rereduce) {\n    // same as above, but returning the result or an error. there are two separate\n    // functions to avoid extra memory allocations since the tryCode() case is used\n    // for custom map functions (common) vs this function, which is only used for\n    // custom reduce functions (rare)\n    try {\n      return {output : fun(keys, values, rereduce)};\n    } catch (e) {\n      emitError(db, e, {fun: fun, keys: keys, values: values, rereduce: rereduce});\n      return {error: e};\n    }\n  }\n\n  function sortByKeyThenValue(x, y) {\n    var keyCompare = collate(x.key, y.key);\n    return keyCompare !== 0 ? keyCompare : collate(x.value, y.value);\n  }\n\n  function sliceResults(results, limit, skip) {\n    skip = skip || 0;\n    if (typeof limit === 'number') {\n      return results.slice(skip, limit + skip);\n    } else if (skip > 0) {\n      return results.slice(skip);\n    }\n    return results;\n  }\n\n  function rowToDocId(row) {\n    var val = row.value;\n    // Users can explicitly specify a joined doc _id, or it\n    // defaults to the doc _id that emitted the key/value.\n    var docId = (val && typeof val === 'object' && val._id) || row.id;\n    return docId;\n  }\n\n  function readAttachmentsAsBlobOrBuffer(res) {\n    res.rows.forEach(function (row) {\n      var atts = row.doc && row.doc._attachments;\n      if (!atts) {\n        return;\n      }\n      Object.keys(atts).forEach(function (filename) {\n        var att = atts[filename];\n        atts[filename].data = b64ToBluffer(att.data, att.content_type);\n      });\n    });\n  }\n\n  function postprocessAttachments(opts) {\n    return function (res) {\n      if (opts.include_docs && opts.attachments && opts.binary) {\n        readAttachmentsAsBlobOrBuffer(res);\n      }\n      return res;\n    };\n  }\n\n  function addHttpParam(paramName, opts, params, asJson) {\n    // add an http param from opts to params, optionally json-encoded\n    var val = opts[paramName];\n    if (typeof val !== 'undefined') {\n      if (asJson) {\n        val = encodeURIComponent(JSON.stringify(val));\n      }\n      params.push(paramName + '=' + val);\n    }\n  }\n\n  function coerceInteger(integerCandidate) {\n    if (typeof integerCandidate !== 'undefined') {\n      var asNumber = Number(integerCandidate);\n      // prevents e.g. '1foo' or '1.1' being coerced to 1\n      if (!isNaN(asNumber) && asNumber === parseInt(integerCandidate, 10)) {\n        return asNumber;\n      } else {\n        return integerCandidate;\n      }\n    }\n  }\n\n  function coerceOptions(opts) {\n    opts.group_level = coerceInteger(opts.group_level);\n    opts.limit = coerceInteger(opts.limit);\n    opts.skip = coerceInteger(opts.skip);\n    return opts;\n  }\n\n  function checkPositiveInteger(number) {\n    if (number) {\n      if (typeof number !== 'number') {\n        return  new QueryParseError('Invalid value for integer: \"' +\n          number + '\"');\n      }\n      if (number < 0) {\n        return new QueryParseError('Invalid value for positive integer: ' +\n          '\"' + number + '\"');\n      }\n    }\n  }\n\n  function checkQueryParseError(options, fun) {\n    var startkeyName = options.descending ? 'endkey' : 'startkey';\n    var endkeyName = options.descending ? 'startkey' : 'endkey';\n\n    if (typeof options[startkeyName] !== 'undefined' &&\n      typeof options[endkeyName] !== 'undefined' &&\n      collate(options[startkeyName], options[endkeyName]) > 0) {\n      throw new QueryParseError('No rows can match your key range, ' +\n        'reverse your start_key and end_key or set {descending : true}');\n    } else if (fun.reduce && options.reduce !== false) {\n      if (options.include_docs) {\n        throw new QueryParseError('{include_docs:true} is invalid for reduce');\n      } else if (options.keys && options.keys.length > 1 &&\n        !options.group && !options.group_level) {\n        throw new QueryParseError('Multi-key fetches for reduce views must use ' +\n          '{group: true}');\n      }\n    }\n    ['group_level', 'limit', 'skip'].forEach(function (optionName) {\n      var error = checkPositiveInteger(options[optionName]);\n      if (error) {\n        throw error;\n      }\n    });\n  }\n\n  function httpQuery(db, fun, opts) {\n    // List of parameters to add to the PUT request\n    var params = [];\n    var body;\n    var method = 'GET';\n    var ok, status;\n\n    // If opts.reduce exists and is defined, then add it to the list\n    // of parameters.\n    // If reduce=false then the results are that of only the map function\n    // not the final result of map and reduce.\n    addHttpParam('reduce', opts, params);\n    addHttpParam('include_docs', opts, params);\n    addHttpParam('attachments', opts, params);\n    addHttpParam('limit', opts, params);\n    addHttpParam('descending', opts, params);\n    addHttpParam('group', opts, params);\n    addHttpParam('group_level', opts, params);\n    addHttpParam('skip', opts, params);\n    addHttpParam('stale', opts, params);\n    addHttpParam('conflicts', opts, params);\n    addHttpParam('startkey', opts, params, true);\n    addHttpParam('start_key', opts, params, true);\n    addHttpParam('endkey', opts, params, true);\n    addHttpParam('end_key', opts, params, true);\n    addHttpParam('inclusive_end', opts, params);\n    addHttpParam('key', opts, params, true);\n    addHttpParam('update_seq', opts, params);\n\n    // Format the list of parameters into a valid URI query string\n    params = params.join('&');\n    params = params === '' ? '' : '?' + params;\n\n    // If keys are supplied, issue a POST to circumvent GET query string limits\n    // see http://wiki.apache.org/couchdb/HTTP_view_API#Querying_Options\n    if (typeof opts.keys !== 'undefined') {\n      var MAX_URL_LENGTH = 2000;\n      // according to http://stackoverflow.com/a/417184/680742,\n      // the de facto URL length limit is 2000 characters\n\n      var keysAsString =\n        'keys=' + encodeURIComponent(JSON.stringify(opts.keys));\n      if (keysAsString.length + params.length + 1 <= MAX_URL_LENGTH) {\n        // If the keys are short enough, do a GET. we do this to work around\n        // Safari not understanding 304s on POSTs (see pouchdb/pouchdb#1239)\n        params += (params[0] === '?' ? '&' : '?') + keysAsString;\n      } else {\n        method = 'POST';\n        if (typeof fun === 'string') {\n          body = {keys: opts.keys};\n        } else { // fun is {map : mapfun}, so append to this\n          fun.keys = opts.keys;\n        }\n      }\n    }\n\n    // We are referencing a query defined in the design doc\n    if (typeof fun === 'string') {\n      var parts = parseViewName(fun);\n      return db.fetch('_design/' + parts[0] + '/_view/' + parts[1] + params, {\n        headers: new h({'Content-Type': 'application/json'}),\n        method: method,\n        body: JSON.stringify(body)\n      }).then(function (response) {\n        ok = response.ok;\n        status = response.status;\n        return response.json();\n      }).then(function (result) {\n        if (!ok) {\n          result.status = status;\n          throw generateErrorFromResponse(result);\n        }\n        // fail the entire request if the result contains an error\n        result.rows.forEach(function (row) {\n          /* istanbul ignore if */\n          if (row.value && row.value.error && row.value.error === \"builtin_reduce_error\") {\n            throw new Error(row.reason);\n          }\n        });\n        return result;\n      }).then(postprocessAttachments(opts));\n    }\n\n    // We are using a temporary view, terrible for performance, good for testing\n    body = body || {};\n    Object.keys(fun).forEach(function (key) {\n      if (Array.isArray(fun[key])) {\n        body[key] = fun[key];\n      } else {\n        body[key] = fun[key].toString();\n      }\n    });\n\n    return db.fetch('_temp_view' + params, {\n      headers: new h({'Content-Type': 'application/json'}),\n      method: 'POST',\n      body: JSON.stringify(body)\n    }).then(function (response) {\n        ok = response.ok;\n        status = response.status;\n      return response.json();\n    }).then(function (result) {\n      if (!ok) {\n        result.status = status;\n        throw generateErrorFromResponse(result);\n      }\n      return result;\n    }).then(postprocessAttachments(opts));\n  }\n\n  // custom adapters can define their own api._query\n  // and override the default behavior\n  /* istanbul ignore next */\n  function customQuery(db, fun, opts) {\n    return new Promise(function (resolve, reject) {\n      db._query(fun, opts, function (err, res) {\n        if (err) {\n          return reject(err);\n        }\n        resolve(res);\n      });\n    });\n  }\n\n  // custom adapters can define their own api._viewCleanup\n  // and override the default behavior\n  /* istanbul ignore next */\n  function customViewCleanup(db) {\n    return new Promise(function (resolve, reject) {\n      db._viewCleanup(function (err, res) {\n        if (err) {\n          return reject(err);\n        }\n        resolve(res);\n      });\n    });\n  }\n\n  function defaultsTo(value) {\n    return function (reason) {\n      /* istanbul ignore else */\n      if (reason.status === 404) {\n        return value;\n      } else {\n        throw reason;\n      }\n    };\n  }\n\n  // returns a promise for a list of docs to update, based on the input docId.\n  // the order doesn't matter, because post-3.2.0, bulkDocs\n  // is an atomic operation in all three adapters.\n  function getDocsToPersist(docId, view, docIdsToChangesAndEmits) {\n    var metaDocId = '_local/doc_' + docId;\n    var defaultMetaDoc = {_id: metaDocId, keys: []};\n    var docData = docIdsToChangesAndEmits.get(docId);\n    var indexableKeysToKeyValues = docData[0];\n    var changes = docData[1];\n\n    function getMetaDoc() {\n      if (isGenOne(changes)) {\n        // generation 1, so we can safely assume initial state\n        // for performance reasons (avoids unnecessary GETs)\n        return Promise.resolve(defaultMetaDoc);\n      }\n      return view.db.get(metaDocId).catch(defaultsTo(defaultMetaDoc));\n    }\n\n    function getKeyValueDocs(metaDoc) {\n      if (!metaDoc.keys.length) {\n        // no keys, no need for a lookup\n        return Promise.resolve({rows: []});\n      }\n      return view.db.allDocs({\n        keys: metaDoc.keys,\n        include_docs: true\n      });\n    }\n\n    function processKeyValueDocs(metaDoc, kvDocsRes) {\n      var kvDocs = [];\n      var oldKeys = new ExportedSet();\n\n      for (var i = 0, len = kvDocsRes.rows.length; i < len; i++) {\n        var row = kvDocsRes.rows[i];\n        var doc = row.doc;\n        if (!doc) { // deleted\n          continue;\n        }\n        kvDocs.push(doc);\n        oldKeys.add(doc._id);\n        doc._deleted = !indexableKeysToKeyValues.has(doc._id);\n        if (!doc._deleted) {\n          var keyValue = indexableKeysToKeyValues.get(doc._id);\n          if ('value' in keyValue) {\n            doc.value = keyValue.value;\n          }\n        }\n      }\n      var newKeys = mapToKeysArray(indexableKeysToKeyValues);\n      newKeys.forEach(function (key) {\n        if (!oldKeys.has(key)) {\n          // new doc\n          var kvDoc = {\n            _id: key\n          };\n          var keyValue = indexableKeysToKeyValues.get(key);\n          if ('value' in keyValue) {\n            kvDoc.value = keyValue.value;\n          }\n          kvDocs.push(kvDoc);\n        }\n      });\n      metaDoc.keys = uniq(newKeys.concat(metaDoc.keys));\n      kvDocs.push(metaDoc);\n\n      return kvDocs;\n    }\n\n    return getMetaDoc().then(function (metaDoc) {\n      return getKeyValueDocs(metaDoc).then(function (kvDocsRes) {\n        return processKeyValueDocs(metaDoc, kvDocsRes);\n      });\n    });\n  }\n\n  // updates all emitted key/value docs and metaDocs in the mrview database\n  // for the given batch of documents from the source database\n  function saveKeyValues(view, docIdsToChangesAndEmits, seq) {\n    var seqDocId = '_local/lastSeq';\n    return view.db.get(seqDocId)\n      .catch(defaultsTo({_id: seqDocId, seq: 0}))\n      .then(function (lastSeqDoc) {\n        var docIds = mapToKeysArray(docIdsToChangesAndEmits);\n        return Promise.all(docIds.map(function (docId) {\n          return getDocsToPersist(docId, view, docIdsToChangesAndEmits);\n        })).then(function (listOfDocsToPersist) {\n          var docsToPersist = flatten(listOfDocsToPersist);\n          lastSeqDoc.seq = seq;\n          docsToPersist.push(lastSeqDoc);\n          // write all docs in a single operation, update the seq once\n          return view.db.bulkDocs({docs : docsToPersist});\n        });\n      });\n  }\n\n  function getQueue(view) {\n    var viewName = typeof view === 'string' ? view : view.name;\n    var queue = persistentQueues[viewName];\n    if (!queue) {\n      queue = persistentQueues[viewName] = new TaskQueue$1();\n    }\n    return queue;\n  }\n\n  function updateView(view, opts) {\n    return sequentialize(getQueue(view), function () {\n      return updateViewInQueue(view, opts);\n    })();\n  }\n\n  function updateViewInQueue(view, opts) {\n    // bind the emit function once\n    var mapResults;\n    var doc;\n\n    function emit(key, value) {\n      var output = {id: doc._id, key: normalizeKey(key)};\n      // Don't explicitly store the value unless it's defined and non-null.\n      // This saves on storage space, because often people don't use it.\n      if (typeof value !== 'undefined' && value !== null) {\n        output.value = normalizeKey(value);\n      }\n      mapResults.push(output);\n    }\n\n    var mapFun = mapper(view.mapFun, emit);\n\n    var currentSeq = view.seq || 0;\n\n    function processChange(docIdsToChangesAndEmits, seq) {\n      return function () {\n        return saveKeyValues(view, docIdsToChangesAndEmits, seq);\n      };\n    }\n\n    let indexed_docs = 0;\n    let progress = {\n      view: view.name,\n      indexed_docs: indexed_docs\n    };\n    view.sourceDB.emit('indexing', progress);\n\n    var queue = new TaskQueue$1();\n\n    function processNextBatch() {\n      return view.sourceDB.changes({\n        return_docs: true,\n        conflicts: true,\n        include_docs: true,\n        style: 'all_docs',\n        since: currentSeq,\n        limit: opts.changes_batch_size\n      }).then(processBatch);\n    }\n\n    function processBatch(response) {\n      var results = response.results;\n      if (!results.length) {\n        return;\n      }\n      var docIdsToChangesAndEmits = createDocIdsToChangesAndEmits(results);\n      queue.add(processChange(docIdsToChangesAndEmits, currentSeq));\n\n      indexed_docs = indexed_docs + results.length;\n      let progress = {\n        view: view.name,\n        last_seq: response.last_seq,\n        results_count: results.length,\n        indexed_docs: indexed_docs\n      };\n      view.sourceDB.emit('indexing', progress);\n      \n      if (results.length < opts.changes_batch_size) {\n        return;\n      }\n      return processNextBatch();\n    }\n\n    function createDocIdsToChangesAndEmits(results) {\n      var docIdsToChangesAndEmits = new ExportedMap();\n      for (var i = 0, len = results.length; i < len; i++) {\n        var change = results[i];\n        if (change.doc._id[0] !== '_') {\n          mapResults = [];\n          doc = change.doc;\n\n          if (!doc._deleted) {\n            tryMap(view.sourceDB, mapFun, doc);\n          }\n          mapResults.sort(sortByKeyThenValue);\n\n          var indexableKeysToKeyValues = createIndexableKeysToKeyValues(mapResults);\n          docIdsToChangesAndEmits.set(change.doc._id, [\n            indexableKeysToKeyValues,\n            change.changes\n          ]);\n        }\n        currentSeq = change.seq;\n      }\n      return docIdsToChangesAndEmits;\n    }\n\n    function createIndexableKeysToKeyValues(mapResults) {\n      var indexableKeysToKeyValues = new ExportedMap();\n      var lastKey;\n      for (var i = 0, len = mapResults.length; i < len; i++) {\n        var emittedKeyValue = mapResults[i];\n        var complexKey = [emittedKeyValue.key, emittedKeyValue.id];\n        if (i > 0 && collate(emittedKeyValue.key, lastKey) === 0) {\n          complexKey.push(i); // dup key+id, so make it unique\n        }\n        indexableKeysToKeyValues.set(toIndexableString(complexKey), emittedKeyValue);\n        lastKey = emittedKeyValue.key;\n      }\n      return indexableKeysToKeyValues;\n    }\n\n    return processNextBatch().then(function () {\n      return queue.finish();\n    }).then(function () {\n      view.seq = currentSeq;\n    });\n  }\n\n  function reduceView(view, results, options) {\n    if (options.group_level === 0) {\n      delete options.group_level;\n    }\n\n    var shouldGroup = options.group || options.group_level;\n\n    var reduceFun = reducer(view.reduceFun);\n\n    var groups = [];\n    var lvl = isNaN(options.group_level) ? Number.POSITIVE_INFINITY :\n      options.group_level;\n    results.forEach(function (e) {\n      var last = groups[groups.length - 1];\n      var groupKey = shouldGroup ? e.key : null;\n\n      // only set group_level for array keys\n      if (shouldGroup && Array.isArray(groupKey)) {\n        groupKey = groupKey.slice(0, lvl);\n      }\n\n      if (last && collate(last.groupKey, groupKey) === 0) {\n        last.keys.push([e.key, e.id]);\n        last.values.push(e.value);\n        return;\n      }\n      groups.push({\n        keys: [[e.key, e.id]],\n        values: [e.value],\n        groupKey: groupKey\n      });\n    });\n    results = [];\n    for (var i = 0, len = groups.length; i < len; i++) {\n      var e = groups[i];\n      var reduceTry = tryReduce(view.sourceDB, reduceFun, e.keys, e.values, false);\n      if (reduceTry.error && reduceTry.error instanceof BuiltInError) {\n        // CouchDB returns an error if a built-in errors out\n        throw reduceTry.error;\n      }\n      results.push({\n        // CouchDB just sets the value to null if a non-built-in errors out\n        value: reduceTry.error ? null : reduceTry.output,\n        key: e.groupKey\n      });\n    }\n    // no total_rows/offset when reducing\n    return {rows: sliceResults(results, options.limit, options.skip)};\n  }\n\n  function queryView(view, opts) {\n    return sequentialize(getQueue(view), function () {\n      return queryViewInQueue(view, opts);\n    })();\n  }\n\n  function queryViewInQueue(view, opts) {\n    var totalRows;\n    var shouldReduce = view.reduceFun && opts.reduce !== false;\n    var skip = opts.skip || 0;\n    if (typeof opts.keys !== 'undefined' && !opts.keys.length) {\n      // equivalent query\n      opts.limit = 0;\n      delete opts.keys;\n    }\n\n    function fetchFromView(viewOpts) {\n      viewOpts.include_docs = true;\n      return view.db.allDocs(viewOpts).then(function (res) {\n        totalRows = res.total_rows;\n        return res.rows.map(function (result) {\n\n          // implicit migration - in older versions of PouchDB,\n          // we explicitly stored the doc as {id: ..., key: ..., value: ...}\n          // this is tested in a migration test\n          /* istanbul ignore next */\n          if ('value' in result.doc && typeof result.doc.value === 'object' &&\n            result.doc.value !== null) {\n            var keys = Object.keys(result.doc.value).sort();\n            // this detection method is not perfect, but it's unlikely the user\n            // emitted a value which was an object with these 3 exact keys\n            var expectedKeys = ['id', 'key', 'value'];\n            if (!(keys < expectedKeys || keys > expectedKeys)) {\n              return result.doc.value;\n            }\n          }\n\n          var parsedKeyAndDocId = parseIndexableString(result.doc._id);\n          return {\n            key: parsedKeyAndDocId[0],\n            id: parsedKeyAndDocId[1],\n            value: ('value' in result.doc ? result.doc.value : null)\n          };\n        });\n      });\n    }\n\n    function onMapResultsReady(rows) {\n      var finalResults;\n      if (shouldReduce) {\n        finalResults = reduceView(view, rows, opts);\n      } else if (typeof opts.keys === 'undefined') {\n        finalResults = {\n          total_rows: totalRows,\n          offset: skip,\n          rows: rows\n        };\n      } else {\n        // support limit, skip for keys query\n        finalResults = {\n          total_rows: totalRows,\n          offset: skip,\n          rows: sliceResults(rows,opts.limit,opts.skip)\n        };\n      }\n      /* istanbul ignore if */\n      if (opts.update_seq) {\n        finalResults.update_seq = view.seq;\n      }\n      if (opts.include_docs) {\n        var docIds = uniq(rows.map(rowToDocId));\n\n        return view.sourceDB.allDocs({\n          keys: docIds,\n          include_docs: true,\n          conflicts: opts.conflicts,\n          attachments: opts.attachments,\n          binary: opts.binary\n        }).then(function (allDocsRes) {\n          var docIdsToDocs = new ExportedMap();\n          allDocsRes.rows.forEach(function (row) {\n            docIdsToDocs.set(row.id, row.doc);\n          });\n          rows.forEach(function (row) {\n            var docId = rowToDocId(row);\n            var doc = docIdsToDocs.get(docId);\n            if (doc) {\n              row.doc = doc;\n            }\n          });\n          return finalResults;\n        });\n      } else {\n        return finalResults;\n      }\n    }\n\n    if (typeof opts.keys !== 'undefined') {\n      var keys = opts.keys;\n      var fetchPromises = keys.map(function (key) {\n        var viewOpts = {\n          startkey : toIndexableString([key]),\n          endkey   : toIndexableString([key, {}])\n        };\n        /* istanbul ignore if */\n        if (opts.update_seq) {\n          viewOpts.update_seq = true;\n        }\n        return fetchFromView(viewOpts);\n      });\n      return Promise.all(fetchPromises).then(flatten).then(onMapResultsReady);\n    } else { // normal query, no 'keys'\n      var viewOpts = {\n        descending : opts.descending\n      };\n      /* istanbul ignore if */\n      if (opts.update_seq) {\n        viewOpts.update_seq = true;\n      }\n      var startkey;\n      var endkey;\n      if ('start_key' in opts) {\n        startkey = opts.start_key;\n      }\n      if ('startkey' in opts) {\n        startkey = opts.startkey;\n      }\n      if ('end_key' in opts) {\n        endkey = opts.end_key;\n      }\n      if ('endkey' in opts) {\n        endkey = opts.endkey;\n      }\n      if (typeof startkey !== 'undefined') {\n        viewOpts.startkey = opts.descending ?\n          toIndexableString([startkey, {}]) :\n          toIndexableString([startkey]);\n      }\n      if (typeof endkey !== 'undefined') {\n        var inclusiveEnd = opts.inclusive_end !== false;\n        if (opts.descending) {\n          inclusiveEnd = !inclusiveEnd;\n        }\n\n        viewOpts.endkey = toIndexableString(\n          inclusiveEnd ? [endkey, {}] : [endkey]);\n      }\n      if (typeof opts.key !== 'undefined') {\n        var keyStart = toIndexableString([opts.key]);\n        var keyEnd = toIndexableString([opts.key, {}]);\n        if (viewOpts.descending) {\n          viewOpts.endkey = keyStart;\n          viewOpts.startkey = keyEnd;\n        } else {\n          viewOpts.startkey = keyStart;\n          viewOpts.endkey = keyEnd;\n        }\n      }\n      if (!shouldReduce) {\n        if (typeof opts.limit === 'number') {\n          viewOpts.limit = opts.limit;\n        }\n        viewOpts.skip = skip;\n      }\n      return fetchFromView(viewOpts).then(onMapResultsReady);\n    }\n  }\n\n  function httpViewCleanup(db) {\n    return db.fetch('_view_cleanup', {\n      headers: new h({'Content-Type': 'application/json'}),\n      method: 'POST'\n    }).then(function (response) {\n      return response.json();\n    });\n  }\n\n  function localViewCleanup(db) {\n    return db.get('_local/' + localDocName).then(function (metaDoc) {\n      var docsToViews = new ExportedMap();\n      Object.keys(metaDoc.views).forEach(function (fullViewName) {\n        var parts = parseViewName(fullViewName);\n        var designDocName = '_design/' + parts[0];\n        var viewName = parts[1];\n        var views = docsToViews.get(designDocName);\n        if (!views) {\n          views = new ExportedSet();\n          docsToViews.set(designDocName, views);\n        }\n        views.add(viewName);\n      });\n      var opts = {\n        keys : mapToKeysArray(docsToViews),\n        include_docs : true\n      };\n      return db.allDocs(opts).then(function (res) {\n        var viewsToStatus = {};\n        res.rows.forEach(function (row) {\n          var ddocName = row.key.substring(8); // cuts off '_design/'\n          docsToViews.get(row.key).forEach(function (viewName) {\n            var fullViewName = ddocName + '/' + viewName;\n            /* istanbul ignore if */\n            if (!metaDoc.views[fullViewName]) {\n              // new format, without slashes, to support PouchDB 2.2.0\n              // migration test in pouchdb's browser.migration.js verifies this\n              fullViewName = viewName;\n            }\n            var viewDBNames = Object.keys(metaDoc.views[fullViewName]);\n            // design doc deleted, or view function nonexistent\n            var statusIsGood = row.doc && row.doc.views &&\n              row.doc.views[viewName];\n            viewDBNames.forEach(function (viewDBName) {\n              viewsToStatus[viewDBName] =\n                viewsToStatus[viewDBName] || statusIsGood;\n            });\n          });\n        });\n        var dbsToDelete = Object.keys(viewsToStatus).filter(\n          function (viewDBName) { return !viewsToStatus[viewDBName]; });\n        var destroyPromises = dbsToDelete.map(function (viewDBName) {\n          return sequentialize(getQueue(viewDBName), function () {\n            return new db.constructor(viewDBName, db.__opts).destroy();\n          })();\n        });\n        return Promise.all(destroyPromises).then(function () {\n          return {ok: true};\n        });\n      });\n    }, defaultsTo({ok: true}));\n  }\n\n  function queryPromised(db, fun, opts) {\n    /* istanbul ignore next */\n    if (typeof db._query === 'function') {\n      return customQuery(db, fun, opts);\n    }\n    if (isRemote(db)) {\n      return httpQuery(db, fun, opts);\n    }\n\n    var updateViewOpts = {\n      changes_batch_size: db.__opts.view_update_changes_batch_size || CHANGES_BATCH_SIZE$1\n    };\n\n    if (typeof fun !== 'string') {\n      // temp_view\n      checkQueryParseError(opts, fun);\n\n      tempViewQueue.add(function () {\n        var createViewPromise = createView(\n          /* sourceDB */ db,\n          /* viewName */ 'temp_view/temp_view',\n          /* mapFun */ fun.map,\n          /* reduceFun */ fun.reduce,\n          /* temporary */ true,\n          /* localDocName */ localDocName);\n        return createViewPromise.then(function (view) {\n          return fin(updateView(view, updateViewOpts).then(function () {\n            return queryView(view, opts);\n          }), function () {\n            return view.db.destroy();\n          });\n        });\n      });\n      return tempViewQueue.finish();\n    } else {\n      // persistent view\n      var fullViewName = fun;\n      var parts = parseViewName(fullViewName);\n      var designDocName = parts[0];\n      var viewName = parts[1];\n      return db.get('_design/' + designDocName).then(function (doc) {\n        var fun = doc.views && doc.views[viewName];\n\n        if (!fun) {\n          // basic validator; it's assumed that every subclass would want this\n          throw new NotFoundError('ddoc ' + doc._id + ' has no view named ' +\n            viewName);\n        }\n\n        ddocValidator(doc, viewName);\n        checkQueryParseError(opts, fun);\n\n        var createViewPromise = createView(\n          /* sourceDB */ db,\n          /* viewName */ fullViewName,\n          /* mapFun */ fun.map,\n          /* reduceFun */ fun.reduce,\n          /* temporary */ false,\n          /* localDocName */ localDocName);\n        return createViewPromise.then(function (view) {\n          if (opts.stale === 'ok' || opts.stale === 'update_after') {\n            if (opts.stale === 'update_after') {\n              immediate(function () {\n                updateView(view, updateViewOpts);\n              });\n            }\n            return queryView(view, opts);\n          } else { // stale not ok\n            return updateView(view, updateViewOpts).then(function () {\n              return queryView(view, opts);\n            });\n          }\n        });\n      });\n    }\n  }\n\n  function abstractQuery(fun, opts, callback) {\n    var db = this;\n    if (typeof opts === 'function') {\n      callback = opts;\n      opts = {};\n    }\n    opts = opts ? coerceOptions(opts) : {};\n\n    if (typeof fun === 'function') {\n      fun = {map : fun};\n    }\n\n    var promise = Promise.resolve().then(function () {\n      return queryPromised(db, fun, opts);\n    });\n    promisedCallback(promise, callback);\n    return promise;\n  }\n\n  var abstractViewCleanup = callbackify(function () {\n    var db = this;\n    /* istanbul ignore next */\n    if (typeof db._viewCleanup === 'function') {\n      return customViewCleanup(db);\n    }\n    if (isRemote(db)) {\n      return httpViewCleanup(db);\n    }\n    return localViewCleanup(db);\n  });\n\n  return {\n    query: abstractQuery,\n    viewCleanup: abstractViewCleanup\n  };\n}\n\nvar builtInReduce = {\n  _sum: function (keys, values) {\n    return sum(values);\n  },\n\n  _count: function (keys, values) {\n    return values.length;\n  },\n\n  _stats: function (keys, values) {\n    // no need to implement rereduce=true, because Pouch\n    // will never call it\n    function sumsqr(values) {\n      var _sumsqr = 0;\n      for (var i = 0, len = values.length; i < len; i++) {\n        var num = values[i];\n        _sumsqr += (num * num);\n      }\n      return _sumsqr;\n    }\n    return {\n      sum     : sum(values),\n      min     : Math.min.apply(null, values),\n      max     : Math.max.apply(null, values),\n      count   : values.length,\n      sumsqr : sumsqr(values)\n    };\n  }\n};\n\nfunction getBuiltIn(reduceFunString) {\n  if (/^_sum/.test(reduceFunString)) {\n    return builtInReduce._sum;\n  } else if (/^_count/.test(reduceFunString)) {\n    return builtInReduce._count;\n  } else if (/^_stats/.test(reduceFunString)) {\n    return builtInReduce._stats;\n  } else if (/^_/.test(reduceFunString)) {\n    throw new Error(reduceFunString + ' is not a supported reduce function.');\n  }\n}\n\nfunction mapper(mapFun, emit) {\n  // for temp_views one can use emit(doc, emit), see #38\n  if (typeof mapFun === \"function\" && mapFun.length === 2) {\n    var origMap = mapFun;\n    return function (doc) {\n      return origMap(doc, emit);\n    };\n  } else {\n    return evalFunctionWithEval(mapFun.toString(), emit);\n  }\n}\n\nfunction reducer(reduceFun) {\n  var reduceFunString = reduceFun.toString();\n  var builtIn = getBuiltIn(reduceFunString);\n  if (builtIn) {\n    return builtIn;\n  } else {\n    return evalFunctionWithEval(reduceFunString);\n  }\n}\n\nfunction ddocValidator(ddoc, viewName) {\n  var fun = ddoc.views && ddoc.views[viewName];\n  if (typeof fun.map !== 'string') {\n    throw new NotFoundError('ddoc ' + ddoc._id + ' has no string view named ' +\n      viewName + ', instead found object of type: ' + typeof fun.map);\n  }\n}\n\nvar localDocName = 'mrviews';\nvar abstract = createAbstractMapReduce(localDocName, mapper, reducer, ddocValidator);\n\nfunction query(fun, opts, callback) {\n  return abstract.query.call(this, fun, opts, callback);\n}\n\nfunction viewCleanup(callback) {\n  return abstract.viewCleanup.call(this, callback);\n}\n\nvar mapreduce = {\n  query: query,\n  viewCleanup: viewCleanup\n};\n\nfunction isGenOne$1(rev) {\n  return /^1-/.test(rev);\n}\n\nfunction fileHasChanged(localDoc, remoteDoc, filename) {\n  return !localDoc._attachments ||\n         !localDoc._attachments[filename] ||\n         localDoc._attachments[filename].digest !== remoteDoc._attachments[filename].digest;\n}\n\nfunction getDocAttachments(db, doc) {\n  var filenames = Object.keys(doc._attachments);\n  return Promise.all(filenames.map(function (filename) {\n    return db.getAttachment(doc._id, filename, {rev: doc._rev});\n  }));\n}\n\nfunction getDocAttachmentsFromTargetOrSource(target, src, doc) {\n  var doCheckForLocalAttachments = isRemote(src) && !isRemote(target);\n  var filenames = Object.keys(doc._attachments);\n\n  if (!doCheckForLocalAttachments) {\n    return getDocAttachments(src, doc);\n  }\n\n  return target.get(doc._id).then(function (localDoc) {\n    return Promise.all(filenames.map(function (filename) {\n      if (fileHasChanged(localDoc, doc, filename)) {\n        return src.getAttachment(doc._id, filename);\n      }\n\n      return target.getAttachment(localDoc._id, filename);\n    }));\n  }).catch(function (error) {\n    /* istanbul ignore if */\n    if (error.status !== 404) {\n      throw error;\n    }\n\n    return getDocAttachments(src, doc);\n  });\n}\n\nfunction createBulkGetOpts(diffs) {\n  var requests = [];\n  Object.keys(diffs).forEach(function (id) {\n    var missingRevs = diffs[id].missing;\n    missingRevs.forEach(function (missingRev) {\n      requests.push({\n        id: id,\n        rev: missingRev\n      });\n    });\n  });\n\n  return {\n    docs: requests,\n    revs: true,\n    latest: true\n  };\n}\n\n//\n// Fetch all the documents from the src as described in the \"diffs\",\n// which is a mapping of docs IDs to revisions. If the state ever\n// changes to \"cancelled\", then the returned promise will be rejected.\n// Else it will be resolved with a list of fetched documents.\n//\nfunction getDocs(src, target, diffs, state) {\n  diffs = clone(diffs); // we do not need to modify this\n\n  var resultDocs = [],\n      ok = true;\n\n  function getAllDocs() {\n\n    var bulkGetOpts = createBulkGetOpts(diffs);\n\n    if (!bulkGetOpts.docs.length) { // optimization: skip empty requests\n      return;\n    }\n\n    return src.bulkGet(bulkGetOpts).then(function (bulkGetResponse) {\n      /* istanbul ignore if */\n      if (state.cancelled) {\n        throw new Error('cancelled');\n      }\n      return Promise.all(bulkGetResponse.results.map(function (bulkGetInfo) {\n        return Promise.all(bulkGetInfo.docs.map(function (doc) {\n          var remoteDoc = doc.ok;\n\n          if (doc.error) {\n            // when AUTO_COMPACTION is set, docs can be returned which look\n            // like this: {\"missing\":\"1-7c3ac256b693c462af8442f992b83696\"}\n            ok = false;\n          }\n\n          if (!remoteDoc || !remoteDoc._attachments) {\n            return remoteDoc;\n          }\n\n          return getDocAttachmentsFromTargetOrSource(target, src, remoteDoc)\n                   .then(function (attachments) {\n                           var filenames = Object.keys(remoteDoc._attachments);\n                           attachments\n                             .forEach(function (attachment, i) {\n                                        var att = remoteDoc._attachments[filenames[i]];\n                                        delete att.stub;\n                                        delete att.length;\n                                        att.data = attachment;\n                                      });\n\n                                      return remoteDoc;\n                                    });\n        }));\n      }))\n\n      .then(function (results) {\n        resultDocs = resultDocs.concat(flatten(results).filter(Boolean));\n      });\n    });\n  }\n\n  function hasAttachments(doc) {\n    return doc._attachments && Object.keys(doc._attachments).length > 0;\n  }\n\n  function hasConflicts(doc) {\n    return doc._conflicts && doc._conflicts.length > 0;\n  }\n\n  function fetchRevisionOneDocs(ids) {\n    // Optimization: fetch gen-1 docs and attachments in\n    // a single request using _all_docs\n    return src.allDocs({\n      keys: ids,\n      include_docs: true,\n      conflicts: true\n    }).then(function (res) {\n      if (state.cancelled) {\n        throw new Error('cancelled');\n      }\n      res.rows.forEach(function (row) {\n        if (row.deleted || !row.doc || !isGenOne$1(row.value.rev) ||\n            hasAttachments(row.doc) || hasConflicts(row.doc)) {\n          // if any of these conditions apply, we need to fetch using get()\n          return;\n        }\n\n        // strip _conflicts array to appease CSG (#5793)\n        /* istanbul ignore if */\n        if (row.doc._conflicts) {\n          delete row.doc._conflicts;\n        }\n\n        // the doc we got back from allDocs() is sufficient\n        resultDocs.push(row.doc);\n        delete diffs[row.id];\n      });\n    });\n  }\n\n  function getRevisionOneDocs() {\n    // filter out the generation 1 docs and get them\n    // leaving the non-generation one docs to be got otherwise\n    var ids = Object.keys(diffs).filter(function (id) {\n      var missing = diffs[id].missing;\n      return missing.length === 1 && isGenOne$1(missing[0]);\n    });\n    if (ids.length > 0) {\n      return fetchRevisionOneDocs(ids);\n    }\n  }\n\n  function returnResult() {\n    return { ok:ok, docs:resultDocs };\n  }\n\n  return Promise.resolve()\n    .then(getRevisionOneDocs)\n    .then(getAllDocs)\n    .then(returnResult);\n}\n\nvar CHECKPOINT_VERSION = 1;\nvar REPLICATOR = \"pouchdb\";\n// This is an arbitrary number to limit the\n// amount of replication history we save in the checkpoint.\n// If we save too much, the checkpoing docs will become very big,\n// if we save fewer, we'll run a greater risk of having to\n// read all the changes from 0 when checkpoint PUTs fail\n// CouchDB 2.0 has a more involved history pruning,\n// but let's go for the simple version for now.\nvar CHECKPOINT_HISTORY_SIZE = 5;\nvar LOWEST_SEQ = 0;\n\nfunction updateCheckpoint(db, id, checkpoint, session, returnValue) {\n  return db.get(id).catch(function (err) {\n    if (err.status === 404) {\n      if (db.adapter === 'http' || db.adapter === 'https') {\n        explainError(\n          404, 'PouchDB is just checking if a remote checkpoint exists.'\n        );\n      }\n      return {\n        session_id: session,\n        _id: id,\n        history: [],\n        replicator: REPLICATOR,\n        version: CHECKPOINT_VERSION\n      };\n    }\n    throw err;\n  }).then(function (doc) {\n    if (returnValue.cancelled) {\n      return;\n    }\n\n    // if the checkpoint has not changed, do not update\n    if (doc.last_seq === checkpoint) {\n      return;\n    }\n\n    // Filter out current entry for this replication\n    doc.history = (doc.history || []).filter(function (item) {\n      return item.session_id !== session;\n    });\n\n    // Add the latest checkpoint to history\n    doc.history.unshift({\n      last_seq: checkpoint,\n      session_id: session\n    });\n\n    // Just take the last pieces in history, to\n    // avoid really big checkpoint docs.\n    // see comment on history size above\n    doc.history = doc.history.slice(0, CHECKPOINT_HISTORY_SIZE);\n\n    doc.version = CHECKPOINT_VERSION;\n    doc.replicator = REPLICATOR;\n\n    doc.session_id = session;\n    doc.last_seq = checkpoint;\n\n    return db.put(doc).catch(function (err) {\n      if (err.status === 409) {\n        // retry; someone is trying to write a checkpoint simultaneously\n        return updateCheckpoint(db, id, checkpoint, session, returnValue);\n      }\n      throw err;\n    });\n  });\n}\n\nfunction Checkpointer(src, target, id, returnValue, opts) {\n  this.src = src;\n  this.target = target;\n  this.id = id;\n  this.returnValue = returnValue;\n  this.opts = opts || {};\n}\n\nCheckpointer.prototype.writeCheckpoint = function (checkpoint, session) {\n  var self = this;\n  return this.updateTarget(checkpoint, session).then(function () {\n    return self.updateSource(checkpoint, session);\n  });\n};\n\nCheckpointer.prototype.updateTarget = function (checkpoint, session) {\n  if (this.opts.writeTargetCheckpoint) {\n    return updateCheckpoint(this.target, this.id, checkpoint,\n      session, this.returnValue);\n  } else {\n    return Promise.resolve(true);\n  }\n};\n\nCheckpointer.prototype.updateSource = function (checkpoint, session) {\n  if (this.opts.writeSourceCheckpoint) {\n    var self = this;\n    return updateCheckpoint(this.src, this.id, checkpoint,\n      session, this.returnValue)\n      .catch(function (err) {\n        if (isForbiddenError(err)) {\n          self.opts.writeSourceCheckpoint = false;\n          return true;\n        }\n        throw err;\n      });\n  } else {\n    return Promise.resolve(true);\n  }\n};\n\nvar comparisons = {\n  \"undefined\": function (targetDoc, sourceDoc) {\n    // This is the previous comparison function\n    if (collate(targetDoc.last_seq, sourceDoc.last_seq) === 0) {\n      return sourceDoc.last_seq;\n    }\n    /* istanbul ignore next */\n    return 0;\n  },\n  \"1\": function (targetDoc, sourceDoc) {\n    // This is the comparison function ported from CouchDB\n    return compareReplicationLogs(sourceDoc, targetDoc).last_seq;\n  }\n};\n\nCheckpointer.prototype.getCheckpoint = function () {\n  var self = this;\n\n  if (self.opts && self.opts.writeSourceCheckpoint && !self.opts.writeTargetCheckpoint) {\n    return self.src.get(self.id).then(function (sourceDoc) {\n      return sourceDoc.last_seq || LOWEST_SEQ;\n    }).catch(function (err) {\n      /* istanbul ignore if */\n      if (err.status !== 404) {\n        throw err;\n      }\n      return LOWEST_SEQ;\n    });\n  }\n\n  return self.target.get(self.id).then(function (targetDoc) {\n    if (self.opts && self.opts.writeTargetCheckpoint && !self.opts.writeSourceCheckpoint) {\n      return targetDoc.last_seq || LOWEST_SEQ;\n    }\n\n    return self.src.get(self.id).then(function (sourceDoc) {\n      // Since we can't migrate an old version doc to a new one\n      // (no session id), we just go with the lowest seq in this case\n      /* istanbul ignore if */\n      if (targetDoc.version !== sourceDoc.version) {\n        return LOWEST_SEQ;\n      }\n\n      var version;\n      if (targetDoc.version) {\n        version = targetDoc.version.toString();\n      } else {\n        version = \"undefined\";\n      }\n\n      if (version in comparisons) {\n        return comparisons[version](targetDoc, sourceDoc);\n      }\n      /* istanbul ignore next */\n      return LOWEST_SEQ;\n    }, function (err) {\n      if (err.status === 404 && targetDoc.last_seq) {\n        return self.src.put({\n          _id: self.id,\n          last_seq: LOWEST_SEQ\n        }).then(function () {\n          return LOWEST_SEQ;\n        }, function (err) {\n          if (isForbiddenError(err)) {\n            self.opts.writeSourceCheckpoint = false;\n            return targetDoc.last_seq;\n          }\n          /* istanbul ignore next */\n          return LOWEST_SEQ;\n        });\n      }\n      throw err;\n    });\n  }).catch(function (err) {\n    if (err.status !== 404) {\n      throw err;\n    }\n    return LOWEST_SEQ;\n  });\n};\n// This checkpoint comparison is ported from CouchDBs source\n// they come from here:\n// https://github.com/apache/couchdb-couch-replicator/blob/master/src/couch_replicator.erl#L863-L906\n\nfunction compareReplicationLogs(srcDoc, tgtDoc) {\n  if (srcDoc.session_id === tgtDoc.session_id) {\n    return {\n      last_seq: srcDoc.last_seq,\n      history: srcDoc.history\n    };\n  }\n\n  return compareReplicationHistory(srcDoc.history, tgtDoc.history);\n}\n\nfunction compareReplicationHistory(sourceHistory, targetHistory) {\n  // the erlang loop via function arguments is not so easy to repeat in JS\n  // therefore, doing this as recursion\n  var S = sourceHistory[0];\n  var sourceRest = sourceHistory.slice(1);\n  var T = targetHistory[0];\n  var targetRest = targetHistory.slice(1);\n\n  if (!S || targetHistory.length === 0) {\n    return {\n      last_seq: LOWEST_SEQ,\n      history: []\n    };\n  }\n\n  var sourceId = S.session_id;\n  /* istanbul ignore if */\n  if (hasSessionId(sourceId, targetHistory)) {\n    return {\n      last_seq: S.last_seq,\n      history: sourceHistory\n    };\n  }\n\n  var targetId = T.session_id;\n  if (hasSessionId(targetId, sourceRest)) {\n    return {\n      last_seq: T.last_seq,\n      history: targetRest\n    };\n  }\n\n  return compareReplicationHistory(sourceRest, targetRest);\n}\n\nfunction hasSessionId(sessionId, history) {\n  var props = history[0];\n  var rest = history.slice(1);\n\n  if (!sessionId || history.length === 0) {\n    return false;\n  }\n\n  if (sessionId === props.session_id) {\n    return true;\n  }\n\n  return hasSessionId(sessionId, rest);\n}\n\nfunction isForbiddenError(err) {\n  return typeof err.status === 'number' && Math.floor(err.status / 100) === 4;\n}\n\nvar STARTING_BACK_OFF = 0;\n\nfunction backOff(opts, returnValue, error, callback) {\n  if (opts.retry === false) {\n    returnValue.emit('error', error);\n    returnValue.removeAllListeners();\n    return;\n  }\n  /* istanbul ignore if */\n  if (typeof opts.back_off_function !== 'function') {\n    opts.back_off_function = defaultBackOff;\n  }\n  returnValue.emit('requestError', error);\n  if (returnValue.state === 'active' || returnValue.state === 'pending') {\n    returnValue.emit('paused', error);\n    returnValue.state = 'stopped';\n    var backOffSet = function backoffTimeSet() {\n      opts.current_back_off = STARTING_BACK_OFF;\n    };\n    var removeBackOffSetter = function removeBackOffTimeSet() {\n      returnValue.removeListener('active', backOffSet);\n    };\n    returnValue.once('paused', removeBackOffSetter);\n    returnValue.once('active', backOffSet);\n  }\n\n  opts.current_back_off = opts.current_back_off || STARTING_BACK_OFF;\n  opts.current_back_off = opts.back_off_function(opts.current_back_off);\n  setTimeout(callback, opts.current_back_off);\n}\n\nfunction sortObjectPropertiesByKey(queryParams) {\n  return Object.keys(queryParams).sort(collate).reduce(function (result, key) {\n    result[key] = queryParams[key];\n    return result;\n  }, {});\n}\n\n// Generate a unique id particular to this replication.\n// Not guaranteed to align perfectly with CouchDB's rep ids.\nfunction generateReplicationId(src, target, opts) {\n  var docIds = opts.doc_ids ? opts.doc_ids.sort(collate) : '';\n  var filterFun = opts.filter ? opts.filter.toString() : '';\n  var queryParams = '';\n  var filterViewName =  '';\n  var selector = '';\n\n  // possibility for checkpoints to be lost here as behaviour of\n  // JSON.stringify is not stable (see #6226)\n  /* istanbul ignore if */\n  if (opts.selector) {\n    selector = JSON.stringify(opts.selector);\n  }\n\n  if (opts.filter && opts.query_params) {\n    queryParams = JSON.stringify(sortObjectPropertiesByKey(opts.query_params));\n  }\n\n  if (opts.filter && opts.filter === '_view') {\n    filterViewName = opts.view.toString();\n  }\n\n  return Promise.all([src.id(), target.id()]).then(function (res) {\n    var queryData = res[0] + res[1] + filterFun + filterViewName +\n      queryParams + docIds + selector;\n    return new Promise(function (resolve) {\n      binaryMd5(queryData, resolve);\n    });\n  }).then(function (md5sum) {\n    // can't use straight-up md5 alphabet, because\n    // the char '/' is interpreted as being for attachments,\n    // and + is also not url-safe\n    md5sum = md5sum.replace(/\\//g, '.').replace(/\\+/g, '_');\n    return '_local/' + md5sum;\n  });\n}\n\nfunction replicate(src, target, opts, returnValue, result) {\n  var batches = [];               // list of batches to be processed\n  var currentBatch;               // the batch currently being processed\n  var pendingBatch = {\n    seq: 0,\n    changes: [],\n    docs: []\n  }; // next batch, not yet ready to be processed\n  var writingCheckpoint = false;  // true while checkpoint is being written\n  var changesCompleted = false;   // true when all changes received\n  var replicationCompleted = false; // true when replication has completed\n  var last_seq = 0;\n  var continuous = opts.continuous || opts.live || false;\n  var batch_size = opts.batch_size || 100;\n  var batches_limit = opts.batches_limit || 10;\n  var style = opts.style || 'all_docs';\n  var changesPending = false;     // true while src.changes is running\n  var doc_ids = opts.doc_ids;\n  var selector = opts.selector;\n  var repId;\n  var checkpointer;\n  var changedDocs = [];\n  // Like couchdb, every replication gets a unique session id\n  var session = uuid();\n\n  result = result || {\n    ok: true,\n    start_time: new Date().toISOString(),\n    docs_read: 0,\n    docs_written: 0,\n    doc_write_failures: 0,\n    errors: []\n  };\n\n  var changesOpts = {};\n  returnValue.ready(src, target);\n\n  function initCheckpointer() {\n    if (checkpointer) {\n      return Promise.resolve();\n    }\n    return generateReplicationId(src, target, opts).then(function (res) {\n      repId = res;\n\n      var checkpointOpts = {};\n      if (opts.checkpoint === false) {\n        checkpointOpts = { writeSourceCheckpoint: false, writeTargetCheckpoint: false };\n      } else if (opts.checkpoint === 'source') {\n        checkpointOpts = { writeSourceCheckpoint: true, writeTargetCheckpoint: false };\n      } else if (opts.checkpoint === 'target') {\n        checkpointOpts = { writeSourceCheckpoint: false, writeTargetCheckpoint: true };\n      } else {\n        checkpointOpts = { writeSourceCheckpoint: true, writeTargetCheckpoint: true };\n      }\n\n      checkpointer = new Checkpointer(src, target, repId, returnValue, checkpointOpts);\n    });\n  }\n\n  function writeDocs() {\n    changedDocs = [];\n\n    if (currentBatch.docs.length === 0) {\n      return;\n    }\n    var docs = currentBatch.docs;\n    var bulkOpts = {timeout: opts.timeout};\n    return target.bulkDocs({docs: docs, new_edits: false}, bulkOpts).then(function (res) {\n      /* istanbul ignore if */\n      if (returnValue.cancelled) {\n        completeReplication();\n        throw new Error('cancelled');\n      }\n\n      // `res` doesn't include full documents (which live in `docs`), so we create a map of\n      // (id -> error), and check for errors while iterating over `docs`\n      var errorsById = Object.create(null);\n      res.forEach(function (res) {\n        if (res.error) {\n          errorsById[res.id] = res;\n        }\n      });\n\n      var errorsNo = Object.keys(errorsById).length;\n      result.doc_write_failures += errorsNo;\n      result.docs_written += docs.length - errorsNo;\n\n      docs.forEach(function (doc) {\n        var error = errorsById[doc._id];\n        if (error) {\n          result.errors.push(error);\n          // Normalize error name. i.e. 'Unauthorized' -> 'unauthorized' (eg Sync Gateway)\n          var errorName = (error.name || '').toLowerCase();\n          if (errorName === 'unauthorized' || errorName === 'forbidden') {\n            returnValue.emit('denied', clone(error));\n          } else {\n            throw error;\n          }\n        } else {\n          changedDocs.push(doc);\n        }\n      });\n\n    }, function (err) {\n      result.doc_write_failures += docs.length;\n      throw err;\n    });\n  }\n\n  function finishBatch() {\n    if (currentBatch.error) {\n      throw new Error('There was a problem getting docs.');\n    }\n    result.last_seq = last_seq = currentBatch.seq;\n    var outResult = clone(result);\n    if (changedDocs.length) {\n      outResult.docs = changedDocs;\n      // Attach 'pending' property if server supports it (CouchDB 2.0+)\n      /* istanbul ignore if */\n      if (typeof currentBatch.pending === 'number') {\n        outResult.pending = currentBatch.pending;\n        delete currentBatch.pending;\n      }\n      returnValue.emit('change', outResult);\n    }\n    writingCheckpoint = true;\n    return checkpointer.writeCheckpoint(currentBatch.seq,\n        session).then(function () {\n      returnValue.emit('checkpoint', { 'checkpoint': currentBatch.seq });\n      writingCheckpoint = false;\n      /* istanbul ignore if */\n      if (returnValue.cancelled) {\n        completeReplication();\n        throw new Error('cancelled');\n      }\n      currentBatch = undefined;\n      getChanges();\n    }).catch(function (err) {\n      onCheckpointError(err);\n      throw err;\n    });\n  }\n\n  function getDiffs() {\n    var diff = {};\n    currentBatch.changes.forEach(function (change) {\n      returnValue.emit('checkpoint', { 'revs_diff': change });\n      // Couchbase Sync Gateway emits these, but we can ignore them\n      /* istanbul ignore if */\n      if (change.id === \"_user/\") {\n        return;\n      }\n      diff[change.id] = change.changes.map(function (x) {\n        return x.rev;\n      });\n    });\n    return target.revsDiff(diff).then(function (diffs) {\n      /* istanbul ignore if */\n      if (returnValue.cancelled) {\n        completeReplication();\n        throw new Error('cancelled');\n      }\n      // currentBatch.diffs elements are deleted as the documents are written\n      currentBatch.diffs = diffs;\n    });\n  }\n\n  function getBatchDocs() {\n    return getDocs(src, target, currentBatch.diffs, returnValue).then(function (got) {\n      currentBatch.error = !got.ok;\n      got.docs.forEach(function (doc) {\n        delete currentBatch.diffs[doc._id];\n        result.docs_read++;\n        currentBatch.docs.push(doc);\n      });\n    });\n  }\n\n  function startNextBatch() {\n    if (returnValue.cancelled || currentBatch) {\n      return;\n    }\n    if (batches.length === 0) {\n      processPendingBatch(true);\n      return;\n    }\n    currentBatch = batches.shift();\n    returnValue.emit('checkpoint', { 'start_next_batch': currentBatch.seq });\n    getDiffs()\n      .then(getBatchDocs)\n      .then(writeDocs)\n      .then(finishBatch)\n      .then(startNextBatch)\n      .catch(function (err) {\n        abortReplication('batch processing terminated with error', err);\n      });\n  }\n\n\n  function processPendingBatch(immediate$$1) {\n    if (pendingBatch.changes.length === 0) {\n      if (batches.length === 0 && !currentBatch) {\n        if ((continuous && changesOpts.live) || changesCompleted) {\n          returnValue.state = 'pending';\n          returnValue.emit('paused');\n        }\n        if (changesCompleted) {\n          completeReplication();\n        }\n      }\n      return;\n    }\n    if (\n      immediate$$1 ||\n      changesCompleted ||\n      pendingBatch.changes.length >= batch_size\n    ) {\n      batches.push(pendingBatch);\n      pendingBatch = {\n        seq: 0,\n        changes: [],\n        docs: []\n      };\n      if (returnValue.state === 'pending' || returnValue.state === 'stopped') {\n        returnValue.state = 'active';\n        returnValue.emit('active');\n      }\n      startNextBatch();\n    }\n  }\n\n\n  function abortReplication(reason, err) {\n    if (replicationCompleted) {\n      return;\n    }\n    if (!err.message) {\n      err.message = reason;\n    }\n    result.ok = false;\n    result.status = 'aborting';\n    batches = [];\n    pendingBatch = {\n      seq: 0,\n      changes: [],\n      docs: []\n    };\n    completeReplication(err);\n  }\n\n\n  function completeReplication(fatalError) {\n    if (replicationCompleted) {\n      return;\n    }\n    /* istanbul ignore if */\n    if (returnValue.cancelled) {\n      result.status = 'cancelled';\n      if (writingCheckpoint) {\n        return;\n      }\n    }\n    result.status = result.status || 'complete';\n    result.end_time = new Date().toISOString();\n    result.last_seq = last_seq;\n    replicationCompleted = true;\n\n    if (fatalError) {\n      // need to extend the error because Firefox considers \".result\" read-only\n      fatalError = createError(fatalError);\n      fatalError.result = result;\n\n      // Normalize error name. i.e. 'Unauthorized' -> 'unauthorized' (eg Sync Gateway)\n      var errorName = (fatalError.name || '').toLowerCase();\n      if (errorName === 'unauthorized' || errorName === 'forbidden') {\n        returnValue.emit('error', fatalError);\n        returnValue.removeAllListeners();\n      } else {\n        backOff(opts, returnValue, fatalError, function () {\n          replicate(src, target, opts, returnValue);\n        });\n      }\n    } else {\n      returnValue.emit('complete', result);\n      returnValue.removeAllListeners();\n    }\n  }\n\n\n  function onChange(change, pending, lastSeq) {\n    /* istanbul ignore if */\n    if (returnValue.cancelled) {\n      return completeReplication();\n    }\n    // Attach 'pending' property if server supports it (CouchDB 2.0+)\n    /* istanbul ignore if */\n    if (typeof pending === 'number') {\n      pendingBatch.pending = pending;\n    }\n\n    var filter = filterChange(opts)(change);\n    if (!filter) {\n      return;\n    }\n    pendingBatch.seq = change.seq || lastSeq;\n    pendingBatch.changes.push(change);\n    returnValue.emit('checkpoint', { 'pending_batch': pendingBatch.seq });\n    immediate(function () {\n      processPendingBatch(batches.length === 0 && changesOpts.live);\n    });\n  }\n\n\n  function onChangesComplete(changes) {\n    changesPending = false;\n    /* istanbul ignore if */\n    if (returnValue.cancelled) {\n      return completeReplication();\n    }\n\n    // if no results were returned then we're done,\n    // else fetch more\n    if (changes.results.length > 0) {\n      changesOpts.since = changes.results[changes.results.length - 1].seq;\n      getChanges();\n      processPendingBatch(true);\n    } else {\n\n      var complete = function () {\n        if (continuous) {\n          changesOpts.live = true;\n          getChanges();\n        } else {\n          changesCompleted = true;\n        }\n        processPendingBatch(true);\n      };\n\n      // update the checkpoint so we start from the right seq next time\n      if (!currentBatch && changes.results.length === 0) {\n        writingCheckpoint = true;\n        checkpointer.writeCheckpoint(changes.last_seq,\n            session).then(function () {\n          writingCheckpoint = false;\n          result.last_seq = last_seq = changes.last_seq;\n          complete();\n        })\n        .catch(onCheckpointError);\n      } else {\n        complete();\n      }\n    }\n  }\n\n\n  function onChangesError(err) {\n    changesPending = false;\n    /* istanbul ignore if */\n    if (returnValue.cancelled) {\n      return completeReplication();\n    }\n    abortReplication('changes rejected', err);\n  }\n\n\n  function getChanges() {\n    if (!(\n      !changesPending &&\n      !changesCompleted &&\n      batches.length < batches_limit\n      )) {\n      return;\n    }\n    changesPending = true;\n    function abortChanges() {\n      changes.cancel();\n    }\n    function removeListener() {\n      returnValue.removeListener('cancel', abortChanges);\n    }\n\n    if (returnValue._changes) { // remove old changes() and listeners\n      returnValue.removeListener('cancel', returnValue._abortChanges);\n      returnValue._changes.cancel();\n    }\n    returnValue.once('cancel', abortChanges);\n\n    var changes = src.changes(changesOpts)\n      .on('change', onChange);\n    changes.then(removeListener, removeListener);\n    changes.then(onChangesComplete)\n      .catch(onChangesError);\n\n    if (opts.retry) {\n      // save for later so we can cancel if necessary\n      returnValue._changes = changes;\n      returnValue._abortChanges = abortChanges;\n    }\n  }\n\n\n  function startChanges() {\n    initCheckpointer().then(function () {\n      /* istanbul ignore if */\n      if (returnValue.cancelled) {\n        completeReplication();\n        return;\n      }\n      return checkpointer.getCheckpoint().then(function (checkpoint) {\n        last_seq = checkpoint;\n        changesOpts = {\n          since: last_seq,\n          limit: batch_size,\n          batch_size: batch_size,\n          style: style,\n          doc_ids: doc_ids,\n          selector: selector,\n          return_docs: true // required so we know when we're done\n        };\n        if (opts.filter) {\n          if (typeof opts.filter !== 'string') {\n            // required for the client-side filter in onChange\n            changesOpts.include_docs = true;\n          } else { // ddoc filter\n            changesOpts.filter = opts.filter;\n          }\n        }\n        if ('heartbeat' in opts) {\n          changesOpts.heartbeat = opts.heartbeat;\n        }\n        if ('timeout' in opts) {\n          changesOpts.timeout = opts.timeout;\n        }\n        if (opts.query_params) {\n          changesOpts.query_params = opts.query_params;\n        }\n        if (opts.view) {\n          changesOpts.view = opts.view;\n        }\n        getChanges();\n      });\n    }).catch(function (err) {\n      abortReplication('getCheckpoint rejected with ', err);\n    });\n  }\n\n  /* istanbul ignore next */\n  function onCheckpointError(err) {\n    writingCheckpoint = false;\n    abortReplication('writeCheckpoint completed with error', err);\n  }\n\n  /* istanbul ignore if */\n  if (returnValue.cancelled) { // cancelled immediately\n    completeReplication();\n    return;\n  }\n\n  if (!returnValue._addedListeners) {\n    returnValue.once('cancel', completeReplication);\n\n    if (typeof opts.complete === 'function') {\n      returnValue.once('error', opts.complete);\n      returnValue.once('complete', function (result) {\n        opts.complete(null, result);\n      });\n    }\n    returnValue._addedListeners = true;\n  }\n\n  if (typeof opts.since === 'undefined') {\n    startChanges();\n  } else {\n    initCheckpointer().then(function () {\n      writingCheckpoint = true;\n      return checkpointer.writeCheckpoint(opts.since, session);\n    }).then(function () {\n      writingCheckpoint = false;\n      /* istanbul ignore if */\n      if (returnValue.cancelled) {\n        completeReplication();\n        return;\n      }\n      last_seq = opts.since;\n      startChanges();\n    }).catch(onCheckpointError);\n  }\n}\n\n// We create a basic promise so the caller can cancel the replication possibly\n// before we have actually started listening to changes etc\ninherits(Replication, EE);\nfunction Replication() {\n  EE.call(this);\n  this.cancelled = false;\n  this.state = 'pending';\n  var self = this;\n  var promise = new Promise(function (fulfill, reject) {\n    self.once('complete', fulfill);\n    self.once('error', reject);\n  });\n  self.then = function (resolve, reject) {\n    return promise.then(resolve, reject);\n  };\n  self.catch = function (reject) {\n    return promise.catch(reject);\n  };\n  // As we allow error handling via \"error\" event as well,\n  // put a stub in here so that rejecting never throws UnhandledError.\n  self.catch(function () {});\n}\n\nReplication.prototype.cancel = function () {\n  this.cancelled = true;\n  this.state = 'cancelled';\n  this.emit('cancel');\n};\n\nReplication.prototype.ready = function (src, target) {\n  var self = this;\n  if (self._readyCalled) {\n    return;\n  }\n  self._readyCalled = true;\n\n  function onDestroy() {\n    self.cancel();\n  }\n  src.once('destroyed', onDestroy);\n  target.once('destroyed', onDestroy);\n  function cleanup() {\n    src.removeListener('destroyed', onDestroy);\n    target.removeListener('destroyed', onDestroy);\n  }\n  self.once('complete', cleanup);\n  self.once('error', cleanup);\n};\n\nfunction toPouch(db, opts) {\n  var PouchConstructor = opts.PouchConstructor;\n  if (typeof db === 'string') {\n    return new PouchConstructor(db, opts);\n  } else {\n    return db;\n  }\n}\n\nfunction replicateWrapper(src, target, opts, callback) {\n\n  if (typeof opts === 'function') {\n    callback = opts;\n    opts = {};\n  }\n  if (typeof opts === 'undefined') {\n    opts = {};\n  }\n\n  if (opts.doc_ids && !Array.isArray(opts.doc_ids)) {\n    throw createError(BAD_REQUEST,\n                       \"`doc_ids` filter parameter is not a list.\");\n  }\n\n  opts.complete = callback;\n  opts = clone(opts);\n  opts.continuous = opts.continuous || opts.live;\n  opts.retry = ('retry' in opts) ? opts.retry : false;\n  /*jshint validthis:true */\n  opts.PouchConstructor = opts.PouchConstructor || this;\n  var replicateRet = new Replication(opts);\n  var srcPouch = toPouch(src, opts);\n  var targetPouch = toPouch(target, opts);\n  replicate(srcPouch, targetPouch, opts, replicateRet);\n  return replicateRet;\n}\n\ninherits(Sync, EE);\nfunction sync(src, target, opts, callback) {\n  if (typeof opts === 'function') {\n    callback = opts;\n    opts = {};\n  }\n  if (typeof opts === 'undefined') {\n    opts = {};\n  }\n  opts = clone(opts);\n  /*jshint validthis:true */\n  opts.PouchConstructor = opts.PouchConstructor || this;\n  src = toPouch(src, opts);\n  target = toPouch(target, opts);\n  return new Sync(src, target, opts, callback);\n}\n\nfunction Sync(src, target, opts, callback) {\n  var self = this;\n  this.canceled = false;\n\n  var optsPush = opts.push ? $inject_Object_assign({}, opts, opts.push) : opts;\n  var optsPull = opts.pull ? $inject_Object_assign({}, opts, opts.pull) : opts;\n\n  this.push = replicateWrapper(src, target, optsPush);\n  this.pull = replicateWrapper(target, src, optsPull);\n\n  this.pushPaused = true;\n  this.pullPaused = true;\n\n  function pullChange(change) {\n    self.emit('change', {\n      direction: 'pull',\n      change: change\n    });\n  }\n  function pushChange(change) {\n    self.emit('change', {\n      direction: 'push',\n      change: change\n    });\n  }\n  function pushDenied(doc) {\n    self.emit('denied', {\n      direction: 'push',\n      doc: doc\n    });\n  }\n  function pullDenied(doc) {\n    self.emit('denied', {\n      direction: 'pull',\n      doc: doc\n    });\n  }\n  function pushPaused() {\n    self.pushPaused = true;\n    /* istanbul ignore if */\n    if (self.pullPaused) {\n      self.emit('paused');\n    }\n  }\n  function pullPaused() {\n    self.pullPaused = true;\n    /* istanbul ignore if */\n    if (self.pushPaused) {\n      self.emit('paused');\n    }\n  }\n  function pushActive() {\n    self.pushPaused = false;\n    /* istanbul ignore if */\n    if (self.pullPaused) {\n      self.emit('active', {\n        direction: 'push'\n      });\n    }\n  }\n  function pullActive() {\n    self.pullPaused = false;\n    /* istanbul ignore if */\n    if (self.pushPaused) {\n      self.emit('active', {\n        direction: 'pull'\n      });\n    }\n  }\n\n  var removed = {};\n\n  function removeAll(type) { // type is 'push' or 'pull'\n    return function (event, func) {\n      var isChange = event === 'change' &&\n        (func === pullChange || func === pushChange);\n      var isDenied = event === 'denied' &&\n        (func === pullDenied || func === pushDenied);\n      var isPaused = event === 'paused' &&\n        (func === pullPaused || func === pushPaused);\n      var isActive = event === 'active' &&\n        (func === pullActive || func === pushActive);\n\n      if (isChange || isDenied || isPaused || isActive) {\n        if (!(event in removed)) {\n          removed[event] = {};\n        }\n        removed[event][type] = true;\n        if (Object.keys(removed[event]).length === 2) {\n          // both push and pull have asked to be removed\n          self.removeAllListeners(event);\n        }\n      }\n    };\n  }\n\n  if (opts.live) {\n    this.push.on('complete', self.pull.cancel.bind(self.pull));\n    this.pull.on('complete', self.push.cancel.bind(self.push));\n  }\n\n  function addOneListener(ee, event, listener) {\n    if (ee.listeners(event).indexOf(listener) == -1) {\n      ee.on(event, listener);\n    }\n  }\n\n  this.on('newListener', function (event) {\n    if (event === 'change') {\n      addOneListener(self.pull, 'change', pullChange);\n      addOneListener(self.push, 'change', pushChange);\n    } else if (event === 'denied') {\n      addOneListener(self.pull, 'denied', pullDenied);\n      addOneListener(self.push, 'denied', pushDenied);\n    } else if (event === 'active') {\n      addOneListener(self.pull, 'active', pullActive);\n      addOneListener(self.push, 'active', pushActive);\n    } else if (event === 'paused') {\n      addOneListener(self.pull, 'paused', pullPaused);\n      addOneListener(self.push, 'paused', pushPaused);\n    }\n  });\n\n  this.on('removeListener', function (event) {\n    if (event === 'change') {\n      self.pull.removeListener('change', pullChange);\n      self.push.removeListener('change', pushChange);\n    } else if (event === 'denied') {\n      self.pull.removeListener('denied', pullDenied);\n      self.push.removeListener('denied', pushDenied);\n    } else if (event === 'active') {\n      self.pull.removeListener('active', pullActive);\n      self.push.removeListener('active', pushActive);\n    } else if (event === 'paused') {\n      self.pull.removeListener('paused', pullPaused);\n      self.push.removeListener('paused', pushPaused);\n    }\n  });\n\n  this.pull.on('removeListener', removeAll('pull'));\n  this.push.on('removeListener', removeAll('push'));\n\n  var promise = Promise.all([\n    this.push,\n    this.pull\n  ]).then(function (resp) {\n    var out = {\n      push: resp[0],\n      pull: resp[1]\n    };\n    self.emit('complete', out);\n    if (callback) {\n      callback(null, out);\n    }\n    self.removeAllListeners();\n    return out;\n  }, function (err) {\n    self.cancel();\n    if (callback) {\n      // if there's a callback, then the callback can receive\n      // the error event\n      callback(err);\n    } else {\n      // if there's no callback, then we're safe to emit an error\n      // event, which would otherwise throw an unhandled error\n      // due to 'error' being a special event in EventEmitters\n      self.emit('error', err);\n    }\n    self.removeAllListeners();\n    if (callback) {\n      // no sense throwing if we're already emitting an 'error' event\n      throw err;\n    }\n  });\n\n  this.then = function (success, err) {\n    return promise.then(success, err);\n  };\n\n  this.catch = function (err) {\n    return promise.catch(err);\n  };\n}\n\nSync.prototype.cancel = function () {\n  if (!this.canceled) {\n    this.canceled = true;\n    this.push.cancel();\n    this.pull.cancel();\n  }\n};\n\nfunction replication(PouchDB) {\n  PouchDB.replicate = replicateWrapper;\n  PouchDB.sync = sync;\n\n  Object.defineProperty(PouchDB.prototype, 'replicate', {\n    get: function () {\n      var self = this;\n      if (typeof this.replicateMethods === 'undefined') {\n        this.replicateMethods = {\n          from: function (other, opts, callback) {\n            return self.constructor.replicate(other, self, opts, callback);\n          },\n          to: function (other, opts, callback) {\n            return self.constructor.replicate(self, other, opts, callback);\n          }\n        };\n      }\n      return this.replicateMethods;\n    }\n  });\n\n  PouchDB.prototype.sync = function (dbName, opts, callback) {\n    return this.constructor.sync(this, dbName, opts, callback);\n  };\n}\n\nPouchDB.plugin(IDBPouch)\n  .plugin(HttpPouch$1)\n  .plugin(mapreduce)\n  .plugin(replication);\n\n// Pull from src because pouchdb-node/pouchdb-browser themselves\n\nexport default PouchDB;\n","(function (factory) {\n    if (typeof exports === 'object') {\n        // Node/CommonJS\n        module.exports = factory();\n    } else if (typeof define === 'function' && define.amd) {\n        // AMD\n        define(factory);\n    } else {\n        // Browser globals (with support for web workers)\n        var glob;\n\n        try {\n            glob = window;\n        } catch (e) {\n            glob = self;\n        }\n\n        glob.SparkMD5 = factory();\n    }\n}(function (undefined) {\n\n    'use strict';\n\n    /*\n     * Fastest md5 implementation around (JKM md5).\n     * Credits: Joseph Myers\n     *\n     * @see http://www.myersdaily.org/joseph/javascript/md5-text.html\n     * @see http://jsperf.com/md5-shootout/7\n     */\n\n    /* this function is much faster,\n      so if possible we use it. Some IEs\n      are the only ones I know of that\n      need the idiotic second function,\n      generated by an if clause.  */\n    var add32 = function (a, b) {\n        return (a + b) & 0xFFFFFFFF;\n    },\n        hex_chr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];\n\n\n    function cmn(q, a, b, x, s, t) {\n        a = add32(add32(a, q), add32(x, t));\n        return add32((a << s) | (a >>> (32 - s)), b);\n    }\n\n    function md5cycle(x, k) {\n        var a = x[0],\n            b = x[1],\n            c = x[2],\n            d = x[3];\n\n        a += (b & c | ~b & d) + k[0] - 680876936 | 0;\n        a  = (a << 7 | a >>> 25) + b | 0;\n        d += (a & b | ~a & c) + k[1] - 389564586 | 0;\n        d  = (d << 12 | d >>> 20) + a | 0;\n        c += (d & a | ~d & b) + k[2] + 606105819 | 0;\n        c  = (c << 17 | c >>> 15) + d | 0;\n        b += (c & d | ~c & a) + k[3] - 1044525330 | 0;\n        b  = (b << 22 | b >>> 10) + c | 0;\n        a += (b & c | ~b & d) + k[4] - 176418897 | 0;\n        a  = (a << 7 | a >>> 25) + b | 0;\n        d += (a & b | ~a & c) + k[5] + 1200080426 | 0;\n        d  = (d << 12 | d >>> 20) + a | 0;\n        c += (d & a | ~d & b) + k[6] - 1473231341 | 0;\n        c  = (c << 17 | c >>> 15) + d | 0;\n        b += (c & d | ~c & a) + k[7] - 45705983 | 0;\n        b  = (b << 22 | b >>> 10) + c | 0;\n        a += (b & c | ~b & d) + k[8] + 1770035416 | 0;\n        a  = (a << 7 | a >>> 25) + b | 0;\n        d += (a & b | ~a & c) + k[9] - 1958414417 | 0;\n        d  = (d << 12 | d >>> 20) + a | 0;\n        c += (d & a | ~d & b) + k[10] - 42063 | 0;\n        c  = (c << 17 | c >>> 15) + d | 0;\n        b += (c & d | ~c & a) + k[11] - 1990404162 | 0;\n        b  = (b << 22 | b >>> 10) + c | 0;\n        a += (b & c | ~b & d) + k[12] + 1804603682 | 0;\n        a  = (a << 7 | a >>> 25) + b | 0;\n        d += (a & b | ~a & c) + k[13] - 40341101 | 0;\n        d  = (d << 12 | d >>> 20) + a | 0;\n        c += (d & a | ~d & b) + k[14] - 1502002290 | 0;\n        c  = (c << 17 | c >>> 15) + d | 0;\n        b += (c & d | ~c & a) + k[15] + 1236535329 | 0;\n        b  = (b << 22 | b >>> 10) + c | 0;\n\n        a += (b & d | c & ~d) + k[1] - 165796510 | 0;\n        a  = (a << 5 | a >>> 27) + b | 0;\n        d += (a & c | b & ~c) + k[6] - 1069501632 | 0;\n        d  = (d << 9 | d >>> 23) + a | 0;\n        c += (d & b | a & ~b) + k[11] + 643717713 | 0;\n        c  = (c << 14 | c >>> 18) + d | 0;\n        b += (c & a | d & ~a) + k[0] - 373897302 | 0;\n        b  = (b << 20 | b >>> 12) + c | 0;\n        a += (b & d | c & ~d) + k[5] - 701558691 | 0;\n        a  = (a << 5 | a >>> 27) + b | 0;\n        d += (a & c | b & ~c) + k[10] + 38016083 | 0;\n        d  = (d << 9 | d >>> 23) + a | 0;\n        c += (d & b | a & ~b) + k[15] - 660478335 | 0;\n        c  = (c << 14 | c >>> 18) + d | 0;\n        b += (c & a | d & ~a) + k[4] - 405537848 | 0;\n        b  = (b << 20 | b >>> 12) + c | 0;\n        a += (b & d | c & ~d) + k[9] + 568446438 | 0;\n        a  = (a << 5 | a >>> 27) + b | 0;\n        d += (a & c | b & ~c) + k[14] - 1019803690 | 0;\n        d  = (d << 9 | d >>> 23) + a | 0;\n        c += (d & b | a & ~b) + k[3] - 187363961 | 0;\n        c  = (c << 14 | c >>> 18) + d | 0;\n        b += (c & a | d & ~a) + k[8] + 1163531501 | 0;\n        b  = (b << 20 | b >>> 12) + c | 0;\n        a += (b & d | c & ~d) + k[13] - 1444681467 | 0;\n        a  = (a << 5 | a >>> 27) + b | 0;\n        d += (a & c | b & ~c) + k[2] - 51403784 | 0;\n        d  = (d << 9 | d >>> 23) + a | 0;\n        c += (d & b | a & ~b) + k[7] + 1735328473 | 0;\n        c  = (c << 14 | c >>> 18) + d | 0;\n        b += (c & a | d & ~a) + k[12] - 1926607734 | 0;\n        b  = (b << 20 | b >>> 12) + c | 0;\n\n        a += (b ^ c ^ d) + k[5] - 378558 | 0;\n        a  = (a << 4 | a >>> 28) + b | 0;\n        d += (a ^ b ^ c) + k[8] - 2022574463 | 0;\n        d  = (d << 11 | d >>> 21) + a | 0;\n        c += (d ^ a ^ b) + k[11] + 1839030562 | 0;\n        c  = (c << 16 | c >>> 16) + d | 0;\n        b += (c ^ d ^ a) + k[14] - 35309556 | 0;\n        b  = (b << 23 | b >>> 9) + c | 0;\n        a += (b ^ c ^ d) + k[1] - 1530992060 | 0;\n        a  = (a << 4 | a >>> 28) + b | 0;\n        d += (a ^ b ^ c) + k[4] + 1272893353 | 0;\n        d  = (d << 11 | d >>> 21) + a | 0;\n        c += (d ^ a ^ b) + k[7] - 155497632 | 0;\n        c  = (c << 16 | c >>> 16) + d | 0;\n        b += (c ^ d ^ a) + k[10] - 1094730640 | 0;\n        b  = (b << 23 | b >>> 9) + c | 0;\n        a += (b ^ c ^ d) + k[13] + 681279174 | 0;\n        a  = (a << 4 | a >>> 28) + b | 0;\n        d += (a ^ b ^ c) + k[0] - 358537222 | 0;\n        d  = (d << 11 | d >>> 21) + a | 0;\n        c += (d ^ a ^ b) + k[3] - 722521979 | 0;\n        c  = (c << 16 | c >>> 16) + d | 0;\n        b += (c ^ d ^ a) + k[6] + 76029189 | 0;\n        b  = (b << 23 | b >>> 9) + c | 0;\n        a += (b ^ c ^ d) + k[9] - 640364487 | 0;\n        a  = (a << 4 | a >>> 28) + b | 0;\n        d += (a ^ b ^ c) + k[12] - 421815835 | 0;\n        d  = (d << 11 | d >>> 21) + a | 0;\n        c += (d ^ a ^ b) + k[15] + 530742520 | 0;\n        c  = (c << 16 | c >>> 16) + d | 0;\n        b += (c ^ d ^ a) + k[2] - 995338651 | 0;\n        b  = (b << 23 | b >>> 9) + c | 0;\n\n        a += (c ^ (b | ~d)) + k[0] - 198630844 | 0;\n        a  = (a << 6 | a >>> 26) + b | 0;\n        d += (b ^ (a | ~c)) + k[7] + 1126891415 | 0;\n        d  = (d << 10 | d >>> 22) + a | 0;\n        c += (a ^ (d | ~b)) + k[14] - 1416354905 | 0;\n        c  = (c << 15 | c >>> 17) + d | 0;\n        b += (d ^ (c | ~a)) + k[5] - 57434055 | 0;\n        b  = (b << 21 |b >>> 11) + c | 0;\n        a += (c ^ (b | ~d)) + k[12] + 1700485571 | 0;\n        a  = (a << 6 | a >>> 26) + b | 0;\n        d += (b ^ (a | ~c)) + k[3] - 1894986606 | 0;\n        d  = (d << 10 | d >>> 22) + a | 0;\n        c += (a ^ (d | ~b)) + k[10] - 1051523 | 0;\n        c  = (c << 15 | c >>> 17) + d | 0;\n        b += (d ^ (c | ~a)) + k[1] - 2054922799 | 0;\n        b  = (b << 21 |b >>> 11) + c | 0;\n        a += (c ^ (b | ~d)) + k[8] + 1873313359 | 0;\n        a  = (a << 6 | a >>> 26) + b | 0;\n        d += (b ^ (a | ~c)) + k[15] - 30611744 | 0;\n        d  = (d << 10 | d >>> 22) + a | 0;\n        c += (a ^ (d | ~b)) + k[6] - 1560198380 | 0;\n        c  = (c << 15 | c >>> 17) + d | 0;\n        b += (d ^ (c | ~a)) + k[13] + 1309151649 | 0;\n        b  = (b << 21 |b >>> 11) + c | 0;\n        a += (c ^ (b | ~d)) + k[4] - 145523070 | 0;\n        a  = (a << 6 | a >>> 26) + b | 0;\n        d += (b ^ (a | ~c)) + k[11] - 1120210379 | 0;\n        d  = (d << 10 | d >>> 22) + a | 0;\n        c += (a ^ (d | ~b)) + k[2] + 718787259 | 0;\n        c  = (c << 15 | c >>> 17) + d | 0;\n        b += (d ^ (c | ~a)) + k[9] - 343485551 | 0;\n        b  = (b << 21 | b >>> 11) + c | 0;\n\n        x[0] = a + x[0] | 0;\n        x[1] = b + x[1] | 0;\n        x[2] = c + x[2] | 0;\n        x[3] = d + x[3] | 0;\n    }\n\n    function md5blk(s) {\n        var md5blks = [],\n            i; /* Andy King said do it this way. */\n\n        for (i = 0; i < 64; i += 4) {\n            md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);\n        }\n        return md5blks;\n    }\n\n    function md5blk_array(a) {\n        var md5blks = [],\n            i; /* Andy King said do it this way. */\n\n        for (i = 0; i < 64; i += 4) {\n            md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);\n        }\n        return md5blks;\n    }\n\n    function md51(s) {\n        var n = s.length,\n            state = [1732584193, -271733879, -1732584194, 271733878],\n            i,\n            length,\n            tail,\n            tmp,\n            lo,\n            hi;\n\n        for (i = 64; i <= n; i += 64) {\n            md5cycle(state, md5blk(s.substring(i - 64, i)));\n        }\n        s = s.substring(i - 64);\n        length = s.length;\n        tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n        for (i = 0; i < length; i += 1) {\n            tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);\n        }\n        tail[i >> 2] |= 0x80 << ((i % 4) << 3);\n        if (i > 55) {\n            md5cycle(state, tail);\n            for (i = 0; i < 16; i += 1) {\n                tail[i] = 0;\n            }\n        }\n\n        // Beware that the final length might not fit in 32 bits so we take care of that\n        tmp = n * 8;\n        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);\n        lo = parseInt(tmp[2], 16);\n        hi = parseInt(tmp[1], 16) || 0;\n\n        tail[14] = lo;\n        tail[15] = hi;\n\n        md5cycle(state, tail);\n        return state;\n    }\n\n    function md51_array(a) {\n        var n = a.length,\n            state = [1732584193, -271733879, -1732584194, 271733878],\n            i,\n            length,\n            tail,\n            tmp,\n            lo,\n            hi;\n\n        for (i = 64; i <= n; i += 64) {\n            md5cycle(state, md5blk_array(a.subarray(i - 64, i)));\n        }\n\n        // Not sure if it is a bug, however IE10 will always produce a sub array of length 1\n        // containing the last element of the parent array if the sub array specified starts\n        // beyond the length of the parent array - weird.\n        // https://connect.microsoft.com/IE/feedback/details/771452/typed-array-subarray-issue\n        a = (i - 64) < n ? a.subarray(i - 64) : new Uint8Array(0);\n\n        length = a.length;\n        tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n        for (i = 0; i < length; i += 1) {\n            tail[i >> 2] |= a[i] << ((i % 4) << 3);\n        }\n\n        tail[i >> 2] |= 0x80 << ((i % 4) << 3);\n        if (i > 55) {\n            md5cycle(state, tail);\n            for (i = 0; i < 16; i += 1) {\n                tail[i] = 0;\n            }\n        }\n\n        // Beware that the final length might not fit in 32 bits so we take care of that\n        tmp = n * 8;\n        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);\n        lo = parseInt(tmp[2], 16);\n        hi = parseInt(tmp[1], 16) || 0;\n\n        tail[14] = lo;\n        tail[15] = hi;\n\n        md5cycle(state, tail);\n\n        return state;\n    }\n\n    function rhex(n) {\n        var s = '',\n            j;\n        for (j = 0; j < 4; j += 1) {\n            s += hex_chr[(n >> (j * 8 + 4)) & 0x0F] + hex_chr[(n >> (j * 8)) & 0x0F];\n        }\n        return s;\n    }\n\n    function hex(x) {\n        var i;\n        for (i = 0; i < x.length; i += 1) {\n            x[i] = rhex(x[i]);\n        }\n        return x.join('');\n    }\n\n    // In some cases the fast add32 function cannot be used..\n    if (hex(md51('hello')) !== '5d41402abc4b2a76b9719d911017c592') {\n        add32 = function (x, y) {\n            var lsw = (x & 0xFFFF) + (y & 0xFFFF),\n                msw = (x >> 16) + (y >> 16) + (lsw >> 16);\n            return (msw << 16) | (lsw & 0xFFFF);\n        };\n    }\n\n    // ---------------------------------------------------\n\n    /**\n     * ArrayBuffer slice polyfill.\n     *\n     * @see https://github.com/ttaubert/node-arraybuffer-slice\n     */\n\n    if (typeof ArrayBuffer !== 'undefined' && !ArrayBuffer.prototype.slice) {\n        (function () {\n            function clamp(val, length) {\n                val = (val | 0) || 0;\n\n                if (val < 0) {\n                    return Math.max(val + length, 0);\n                }\n\n                return Math.min(val, length);\n            }\n\n            ArrayBuffer.prototype.slice = function (from, to) {\n                var length = this.byteLength,\n                    begin = clamp(from, length),\n                    end = length,\n                    num,\n                    target,\n                    targetArray,\n                    sourceArray;\n\n                if (to !== undefined) {\n                    end = clamp(to, length);\n                }\n\n                if (begin > end) {\n                    return new ArrayBuffer(0);\n                }\n\n                num = end - begin;\n                target = new ArrayBuffer(num);\n                targetArray = new Uint8Array(target);\n\n                sourceArray = new Uint8Array(this, begin, num);\n                targetArray.set(sourceArray);\n\n                return target;\n            };\n        })();\n    }\n\n    // ---------------------------------------------------\n\n    /**\n     * Helpers.\n     */\n\n    function toUtf8(str) {\n        if (/[\\u0080-\\uFFFF]/.test(str)) {\n            str = unescape(encodeURIComponent(str));\n        }\n\n        return str;\n    }\n\n    function utf8Str2ArrayBuffer(str, returnUInt8Array) {\n        var length = str.length,\n           buff = new ArrayBuffer(length),\n           arr = new Uint8Array(buff),\n           i;\n\n        for (i = 0; i < length; i += 1) {\n            arr[i] = str.charCodeAt(i);\n        }\n\n        return returnUInt8Array ? arr : buff;\n    }\n\n    function arrayBuffer2Utf8Str(buff) {\n        return String.fromCharCode.apply(null, new Uint8Array(buff));\n    }\n\n    function concatenateArrayBuffers(first, second, returnUInt8Array) {\n        var result = new Uint8Array(first.byteLength + second.byteLength);\n\n        result.set(new Uint8Array(first));\n        result.set(new Uint8Array(second), first.byteLength);\n\n        return returnUInt8Array ? result : result.buffer;\n    }\n\n    function hexToBinaryString(hex) {\n        var bytes = [],\n            length = hex.length,\n            x;\n\n        for (x = 0; x < length - 1; x += 2) {\n            bytes.push(parseInt(hex.substr(x, 2), 16));\n        }\n\n        return String.fromCharCode.apply(String, bytes);\n    }\n\n    // ---------------------------------------------------\n\n    /**\n     * SparkMD5 OOP implementation.\n     *\n     * Use this class to perform an incremental md5, otherwise use the\n     * static methods instead.\n     */\n\n    function SparkMD5() {\n        // call reset to init the instance\n        this.reset();\n    }\n\n    /**\n     * Appends a string.\n     * A conversion will be applied if an utf8 string is detected.\n     *\n     * @param {String} str The string to be appended\n     *\n     * @return {SparkMD5} The instance itself\n     */\n    SparkMD5.prototype.append = function (str) {\n        // Converts the string to utf8 bytes if necessary\n        // Then append as binary\n        this.appendBinary(toUtf8(str));\n\n        return this;\n    };\n\n    /**\n     * Appends a binary string.\n     *\n     * @param {String} contents The binary string to be appended\n     *\n     * @return {SparkMD5} The instance itself\n     */\n    SparkMD5.prototype.appendBinary = function (contents) {\n        this._buff += contents;\n        this._length += contents.length;\n\n        var length = this._buff.length,\n            i;\n\n        for (i = 64; i <= length; i += 64) {\n            md5cycle(this._hash, md5blk(this._buff.substring(i - 64, i)));\n        }\n\n        this._buff = this._buff.substring(i - 64);\n\n        return this;\n    };\n\n    /**\n     * Finishes the incremental computation, reseting the internal state and\n     * returning the result.\n     *\n     * @param {Boolean} raw True to get the raw string, false to get the hex string\n     *\n     * @return {String} The result\n     */\n    SparkMD5.prototype.end = function (raw) {\n        var buff = this._buff,\n            length = buff.length,\n            i,\n            tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n            ret;\n\n        for (i = 0; i < length; i += 1) {\n            tail[i >> 2] |= buff.charCodeAt(i) << ((i % 4) << 3);\n        }\n\n        this._finish(tail, length);\n        ret = hex(this._hash);\n\n        if (raw) {\n            ret = hexToBinaryString(ret);\n        }\n\n        this.reset();\n\n        return ret;\n    };\n\n    /**\n     * Resets the internal state of the computation.\n     *\n     * @return {SparkMD5} The instance itself\n     */\n    SparkMD5.prototype.reset = function () {\n        this._buff = '';\n        this._length = 0;\n        this._hash = [1732584193, -271733879, -1732584194, 271733878];\n\n        return this;\n    };\n\n    /**\n     * Gets the internal state of the computation.\n     *\n     * @return {Object} The state\n     */\n    SparkMD5.prototype.getState = function () {\n        return {\n            buff: this._buff,\n            length: this._length,\n            hash: this._hash.slice()\n        };\n    };\n\n    /**\n     * Gets the internal state of the computation.\n     *\n     * @param {Object} state The state\n     *\n     * @return {SparkMD5} The instance itself\n     */\n    SparkMD5.prototype.setState = function (state) {\n        this._buff = state.buff;\n        this._length = state.length;\n        this._hash = state.hash;\n\n        return this;\n    };\n\n    /**\n     * Releases memory used by the incremental buffer and other additional\n     * resources. If you plan to use the instance again, use reset instead.\n     */\n    SparkMD5.prototype.destroy = function () {\n        delete this._hash;\n        delete this._buff;\n        delete this._length;\n    };\n\n    /**\n     * Finish the final calculation based on the tail.\n     *\n     * @param {Array}  tail   The tail (will be modified)\n     * @param {Number} length The length of the remaining buffer\n     */\n    SparkMD5.prototype._finish = function (tail, length) {\n        var i = length,\n            tmp,\n            lo,\n            hi;\n\n        tail[i >> 2] |= 0x80 << ((i % 4) << 3);\n        if (i > 55) {\n            md5cycle(this._hash, tail);\n            for (i = 0; i < 16; i += 1) {\n                tail[i] = 0;\n            }\n        }\n\n        // Do the final computation based on the tail and length\n        // Beware that the final length may not fit in 32 bits so we take care of that\n        tmp = this._length * 8;\n        tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);\n        lo = parseInt(tmp[2], 16);\n        hi = parseInt(tmp[1], 16) || 0;\n\n        tail[14] = lo;\n        tail[15] = hi;\n        md5cycle(this._hash, tail);\n    };\n\n    /**\n     * Performs the md5 hash on a string.\n     * A conversion will be applied if utf8 string is detected.\n     *\n     * @param {String}  str The string\n     * @param {Boolean} [raw] True to get the raw string, false to get the hex string\n     *\n     * @return {String} The result\n     */\n    SparkMD5.hash = function (str, raw) {\n        // Converts the string to utf8 bytes if necessary\n        // Then compute it using the binary function\n        return SparkMD5.hashBinary(toUtf8(str), raw);\n    };\n\n    /**\n     * Performs the md5 hash on a binary string.\n     *\n     * @param {String}  content The binary string\n     * @param {Boolean} [raw]     True to get the raw string, false to get the hex string\n     *\n     * @return {String} The result\n     */\n    SparkMD5.hashBinary = function (content, raw) {\n        var hash = md51(content),\n            ret = hex(hash);\n\n        return raw ? hexToBinaryString(ret) : ret;\n    };\n\n    // ---------------------------------------------------\n\n    /**\n     * SparkMD5 OOP implementation for array buffers.\n     *\n     * Use this class to perform an incremental md5 ONLY for array buffers.\n     */\n    SparkMD5.ArrayBuffer = function () {\n        // call reset to init the instance\n        this.reset();\n    };\n\n    /**\n     * Appends an array buffer.\n     *\n     * @param {ArrayBuffer} arr The array to be appended\n     *\n     * @return {SparkMD5.ArrayBuffer} The instance itself\n     */\n    SparkMD5.ArrayBuffer.prototype.append = function (arr) {\n        var buff = concatenateArrayBuffers(this._buff.buffer, arr, true),\n            length = buff.length,\n            i;\n\n        this._length += arr.byteLength;\n\n        for (i = 64; i <= length; i += 64) {\n            md5cycle(this._hash, md5blk_array(buff.subarray(i - 64, i)));\n        }\n\n        this._buff = (i - 64) < length ? new Uint8Array(buff.buffer.slice(i - 64)) : new Uint8Array(0);\n\n        return this;\n    };\n\n    /**\n     * Finishes the incremental computation, reseting the internal state and\n     * returning the result.\n     *\n     * @param {Boolean} raw True to get the raw string, false to get the hex string\n     *\n     * @return {String} The result\n     */\n    SparkMD5.ArrayBuffer.prototype.end = function (raw) {\n        var buff = this._buff,\n            length = buff.length,\n            tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n            i,\n            ret;\n\n        for (i = 0; i < length; i += 1) {\n            tail[i >> 2] |= buff[i] << ((i % 4) << 3);\n        }\n\n        this._finish(tail, length);\n        ret = hex(this._hash);\n\n        if (raw) {\n            ret = hexToBinaryString(ret);\n        }\n\n        this.reset();\n\n        return ret;\n    };\n\n    /**\n     * Resets the internal state of the computation.\n     *\n     * @return {SparkMD5.ArrayBuffer} The instance itself\n     */\n    SparkMD5.ArrayBuffer.prototype.reset = function () {\n        this._buff = new Uint8Array(0);\n        this._length = 0;\n        this._hash = [1732584193, -271733879, -1732584194, 271733878];\n\n        return this;\n    };\n\n    /**\n     * Gets the internal state of the computation.\n     *\n     * @return {Object} The state\n     */\n    SparkMD5.ArrayBuffer.prototype.getState = function () {\n        var state = SparkMD5.prototype.getState.call(this);\n\n        // Convert buffer to a string\n        state.buff = arrayBuffer2Utf8Str(state.buff);\n\n        return state;\n    };\n\n    /**\n     * Gets the internal state of the computation.\n     *\n     * @param {Object} state The state\n     *\n     * @return {SparkMD5.ArrayBuffer} The instance itself\n     */\n    SparkMD5.ArrayBuffer.prototype.setState = function (state) {\n        // Convert string to buffer\n        state.buff = utf8Str2ArrayBuffer(state.buff, true);\n\n        return SparkMD5.prototype.setState.call(this, state);\n    };\n\n    SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;\n\n    SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;\n\n    /**\n     * Performs the md5 hash on an array buffer.\n     *\n     * @param {ArrayBuffer} arr The array buffer\n     * @param {Boolean}     [raw] True to get the raw string, false to get the hex one\n     *\n     * @return {String} The result\n     */\n    SparkMD5.ArrayBuffer.hash = function (arr, raw) {\n        var hash = md51_array(new Uint8Array(arr)),\n            ret = hex(hash);\n\n        return raw ? hexToBinaryString(ret) : ret;\n    };\n\n    return SparkMD5;\n}));\n","// Unique ID creation requires a high quality random # generator. In the browser we therefore\n// require the crypto API and do not support built-in fallback to lower quality random number\n// generators (like Math.random()).\nvar getRandomValues;\nvar rnds8 = new Uint8Array(16);\nexport default function rng() {\n  // lazy load so that environments that need to polyfill have a chance to do so\n  if (!getRandomValues) {\n    // getRandomValues needs to be invoked in a context where \"this\" is a Crypto implementation. Also,\n    // find the complete implementation of crypto (msCrypto) on IE11.\n    getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);\n\n    if (!getRandomValues) {\n      throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');\n    }\n  }\n\n  return getRandomValues(rnds8);\n}","export default /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;","import validate from './validate.js';\n/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\n\nvar byteToHex = [];\n\nfor (var i = 0; i < 256; ++i) {\n  byteToHex.push((i + 0x100).toString(16).substr(1));\n}\n\nfunction stringify(arr) {\n  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  // Note: Be careful editing this code!  It's been tuned for performance\n  // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434\n  var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID.  If this throws, it's likely due to one\n  // of the following:\n  // - One or more input array values don't map to a hex octet (leading to\n  // \"undefined\" in the uuid)\n  // - Invalid input values for the RFC `version` or `variant` fields\n\n  if (!validate(uuid)) {\n    throw TypeError('Stringified UUID is invalid');\n  }\n\n  return uuid;\n}\n\nexport default stringify;","import REGEX from './regex.js';\n\nfunction validate(uuid) {\n  return typeof uuid === 'string' && REGEX.test(uuid);\n}\n\nexport default validate;","import rng from './rng.js';\nimport stringify from './stringify.js';\n\nfunction v4(options, buf, offset) {\n  options = options || {};\n  var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n\n  rnds[6] = rnds[6] & 0x0f | 0x40;\n  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided\n\n  if (buf) {\n    offset = offset || 0;\n\n    for (var i = 0; i < 16; ++i) {\n      buf[offset + i] = rnds[i];\n    }\n\n    return buf;\n  }\n\n  return stringify(rnds);\n}\n\nexport default v4;","'use strict';\n\n/**\n * Stringify/parse functions that don't operate\n * recursively, so they avoid call stack exceeded\n * errors.\n */\nexports.stringify = function stringify(input) {\n  var queue = [];\n  queue.push({obj: input});\n\n  var res = '';\n  var next, obj, prefix, val, i, arrayPrefix, keys, k, key, value, objPrefix;\n  while ((next = queue.pop())) {\n    obj = next.obj;\n    prefix = next.prefix || '';\n    val = next.val || '';\n    res += prefix;\n    if (val) {\n      res += val;\n    } else if (typeof obj !== 'object') {\n      res += typeof obj === 'undefined' ? null : JSON.stringify(obj);\n    } else if (obj === null) {\n      res += 'null';\n    } else if (Array.isArray(obj)) {\n      queue.push({val: ']'});\n      for (i = obj.length - 1; i >= 0; i--) {\n        arrayPrefix = i === 0 ? '' : ',';\n        queue.push({obj: obj[i], prefix: arrayPrefix});\n      }\n      queue.push({val: '['});\n    } else { // object\n      keys = [];\n      for (k in obj) {\n        if (obj.hasOwnProperty(k)) {\n          keys.push(k);\n        }\n      }\n      queue.push({val: '}'});\n      for (i = keys.length - 1; i >= 0; i--) {\n        key = keys[i];\n        value = obj[key];\n        objPrefix = (i > 0 ? ',' : '');\n        objPrefix += JSON.stringify(key) + ':';\n        queue.push({obj: value, prefix: objPrefix});\n      }\n      queue.push({val: '{'});\n    }\n  }\n  return res;\n};\n\n// Convenience function for the parse function.\n// This pop function is basically copied from\n// pouchCollate.parseIndexableString\nfunction pop(obj, stack, metaStack) {\n  var lastMetaElement = metaStack[metaStack.length - 1];\n  if (obj === lastMetaElement.element) {\n    // popping a meta-element, e.g. an object whose value is another object\n    metaStack.pop();\n    lastMetaElement = metaStack[metaStack.length - 1];\n  }\n  var element = lastMetaElement.element;\n  var lastElementIndex = lastMetaElement.index;\n  if (Array.isArray(element)) {\n    element.push(obj);\n  } else if (lastElementIndex === stack.length - 2) { // obj with key+value\n    var key = stack.pop();\n    element[key] = obj;\n  } else {\n    stack.push(obj); // obj with key only\n  }\n}\n\nexports.parse = function (str) {\n  var stack = [];\n  var metaStack = []; // stack for arrays and objects\n  var i = 0;\n  var collationIndex,parsedNum,numChar;\n  var parsedString,lastCh,numConsecutiveSlashes,ch;\n  var arrayElement, objElement;\n  while (true) {\n    collationIndex = str[i++];\n    if (collationIndex === '}' ||\n        collationIndex === ']' ||\n        typeof collationIndex === 'undefined') {\n      if (stack.length === 1) {\n        return stack.pop();\n      } else {\n        pop(stack.pop(), stack, metaStack);\n        continue;\n      }\n    }\n    switch (collationIndex) {\n      case ' ':\n      case '\\t':\n      case '\\n':\n      case ':':\n      case ',':\n        break;\n      case 'n':\n        i += 3; // 'ull'\n        pop(null, stack, metaStack);\n        break;\n      case 't':\n        i += 3; // 'rue'\n        pop(true, stack, metaStack);\n        break;\n      case 'f':\n        i += 4; // 'alse'\n        pop(false, stack, metaStack);\n        break;\n      case '0':\n      case '1':\n      case '2':\n      case '3':\n      case '4':\n      case '5':\n      case '6':\n      case '7':\n      case '8':\n      case '9':\n      case '-':\n        parsedNum = '';\n        i--;\n        while (true) {\n          numChar = str[i++];\n          if (/[\\d\\.\\-e\\+]/.test(numChar)) {\n            parsedNum += numChar;\n          } else {\n            i--;\n            break;\n          }\n        }\n        pop(parseFloat(parsedNum), stack, metaStack);\n        break;\n      case '\"':\n        parsedString = '';\n        lastCh = void 0;\n        numConsecutiveSlashes = 0;\n        while (true) {\n          ch = str[i++];\n          if (ch !== '\"' || (lastCh === '\\\\' &&\n              numConsecutiveSlashes % 2 === 1)) {\n            parsedString += ch;\n            lastCh = ch;\n            if (lastCh === '\\\\') {\n              numConsecutiveSlashes++;\n            } else {\n              numConsecutiveSlashes = 0;\n            }\n          } else {\n            break;\n          }\n        }\n        pop(JSON.parse('\"' + parsedString + '\"'), stack, metaStack);\n        break;\n      case '[':\n        arrayElement = { element: [], index: stack.length };\n        stack.push(arrayElement.element);\n        metaStack.push(arrayElement);\n        break;\n      case '{':\n        objElement = { element: {}, index: stack.length };\n        stack.push(objElement.element);\n        metaStack.push(objElement);\n        break;\n      default:\n        throw new Error(\n          'unexpectedly reached end of input: ' + collationIndex);\n    }\n  }\n};\n"],"names":["module","exports","fun","len","arguments","length","args","i","call","this","ReflectOwnKeys","R","Reflect","ReflectApply","apply","target","receiver","Function","prototype","ownKeys","Object","getOwnPropertySymbols","getOwnPropertyNames","concat","NumberIsNaN","Number","isNaN","value","EventEmitter","init","once","emitter","name","Promise","resolve","reject","errorListener","err","removeListener","resolver","slice","eventTargetAgnosticAddListener","handler","flags","on","addErrorHandlerIfEventEmitter","_events","undefined","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","TypeError","_getMaxListeners","that","_addListener","type","prepend","m","events","existing","warning","create","newListener","emit","unshift","push","warned","w","Error","String","count","console","warn","onceWrapper","fired","wrapFn","_onceWrap","state","wrapped","bind","_listeners","unwrap","evlistener","arr","ret","Array","unwrapListeners","arrayClone","listenerCount","n","copy","addEventListener","wrapListener","arg","removeEventListener","defineProperty","enumerable","get","set","RangeError","getPrototypeOf","setMaxListeners","getMaxListeners","doError","error","er","message","context","listeners","addListener","prependListener","prependOnceListener","list","position","originalListener","shift","index","pop","spliceOne","off","removeAllListeners","key","keys","rawListeners","eventNames","draining","currentQueue","scheduleDrain","types","queueIndex","queue","scheduled","cleanUpNextTick","nextTick","timeout","setTimeout","run","clearTimeout","test","install","Item","array","task","g","setImmediate","MessageChannel","func","channel","port1","onmessage","port2","postMessage","Mutation","MutationObserver","WebKitMutationObserver","handle","called","observer","element","document","createTextNode","observe","characterData","data","queueMicrotask","createElement","scriptEl","onreadystatechange","parentNode","removeChild","documentElement","appendChild","t","ctor","superCtor","super_","constructor","writable","configurable","TempCtor","PouchError","status","reason","toString","JSON","stringify","UNKNOWN_ERROR","generateErrorFromResponse","stack","AbortController","fetch","ExportedSet","ExportedMap","h","Headers","mangle","unmangle","substring","Map$1","_store","Set$1","isArray","add","mangled","has","map","k","delete","res","forEach","cb","size","Symbol","Map","Set","prop","getOwnPropertyDescriptor","species","supportsMapAndSet","binaryStringToArrayBuffer","bin","buf","ArrayBuffer","Uint8Array","charCodeAt","MIN_MAGNITUDE","MAGNITUDE_DIGITS","SEP","collate","a","b","normalizeKey","ai","collationIndex","bi","stringCollate","Math","min","sort","arrayCollate","ak","bk","objectCollate","Infinity","origKey","Date","toJSON","hasOwnProperty","val","toIndexableString","num","str","expFormat","toExponential","split","magnitude","parseInt","neg","result","magString","padWith","upToLength","padding","targetLength","pad","factor","abs","parseFloat","factorStr","toFixed","replace","numToIndexableString","objKey","indexify","parseNumber","originalIdx","numAsString","magAsString","ch","metaStack","obj","lastMetaElement","lastElementIndex","x","idx","indexOf","stringMd5","string","self","hasLocal","funcToString","objectCtorString","clone","object","newObject","isFinite","toISOString","Blob","isBinaryObject","buff","byteLength","targetArray","sourceArray","cloneArrayBuffer","webkitSlice","cloneBinaryObject","proto","Ctor","isPlainObject","toPromise","usedCB","promise","fulfill","resp","callback","mesg","then","e","localStorage","setItem","getItem","hasLocalStorage","Changes","attachBrowserEvents","guardedConsole","method","dbName","id","db","opts","inprogress","eventFunction","changesOpts","pick","changes","c","seq","since","cancelled","onChange","notifyLocalWindows","notify","assign$2","assign","to","nextSource","nextKey","flatten","arrs","isRemote","_remote","upsert","docId","diffFun","catch","doc","docRev","_rev","newDoc","_id","put","updated","rev","tryAndPut","QueryParseError","captureStackTrace","NotFoundError","BuiltInError","promisedCallback","sequentialize","promiseFactory","uniq","theSet","mapToKeysArray","TaskQueue","input","createView","sourceDB","viewName","mapFun","reduceFun","temporary","localDocName","cachedViews","viewSignature","createViewSignature","_cachedViews","promiseForView","info","depDbName","db_name","views","fullViewName","depDbs","registerDependentDatabase","auto_compaction","view","adapter","lastSeqDoc","v4","finish","persistentQueues","tempViewQueue","parseViewName","emitError","getFieldFromDoc","parsedField","setFieldInDoc","elem","compare","left","right","parseField","fieldName","fields","current","combinationFields","isCombinationalField","field","getKey","getValue","mergeAndedSelectors","selectors","first","$or","$nor","selector","matcher","$eq","entries","longest","max","merged","fieldMatchers","operator","$gte","$gt","mergeGtGte","$lte","$lt","mergeLtLte","$ne","mergeNe","mergeEq","$regex","mergeRegex","mergeAndedSelectorsNested","isAndInSelector","isAnd","massageSelector","wasAnded","orOrNor","subSelector","filterInMemoryFields","rows","requestDef","inMemoryFields","filter","row","rowFilter","fieldSorter","getFieldValuesAsArray","sorting","aRow","bRow","collation","createFieldSorter","reverse","skip","limit","every","docFieldValue","some","orMatchers","find","matchCominationalSelector","matchSelector","maybeUserOperator","userValue","match","subParsedField","subDocFieldValue","userOperator","matchers","fieldExists","fieldIsNotUndefined","arrayContainsValue","docFieldValueItem","modField","neValue","arraySize","arrayContainsAllValues","regexValue","RegExp","regexMatch","typeMatch","matchesSelector","rowsMatched","massageCreateIndexRequest","checkFieldValueType","isHttp","received","addReceived","divisor","mod","allowed","allowedStr","join","log","requireValidation","arrayTypeComparisonOperators","equalityOperators","validateSelector","entry","dbFetch","path","ok","headers","response","json","createIndex","body","explain","getIndexes","deleteIndex","indexDef","ddoc","encodeURIComponent","getArguments","subArr","mergeObjects","oneArrayIsSubArrayOfOther","arrayEquals","arr1","arr2","abstractMapper","mapper","reducer","ddocValidator","tryMap","tryReduce","values","rereduce","output","sortByKeyThenValue","y","keyCompare","sliceResults","results","rowToDocId","readAttachmentsAsBlobOrBuffer","atts","_attachments","filename","b64","att","content_type","binString","parts","properties","builder","BlobBuilder","MSBlobBuilder","MozBlobBuilder","WebKitBlobBuilder","append","getBlob","createBlob","binStringToBluffer","atob","postprocessAttachments","include_docs","attachments","binary","addHttpParam","paramName","params","asJson","coerceInteger","integerCandidate","asNumber","checkQueryParseError","options","startkeyName","descending","endkeyName","reduce","group","group_level","optionName","number","checkPositiveInteger","defaultsTo","getQueue","updateView","mapResults","currentSeq","processChange","docIdsToChangesAndEmits","seqDocId","docIds","all","metaDocId","defaultMetaDoc","docData","indexableKeysToKeyValues","metaDoc","allDocs","getKeyValueDocs","kvDocsRes","kvDocs","oldKeys","_deleted","keyValue","newKeys","kvDoc","processKeyValueDocs","getDocsToPersist","listOfDocsToPersist","docsToPersist","bulkDocs","docs","saveKeyValues","indexed_docs","progress","processNextBatch","return_docs","conflicts","style","changes_batch_size","processBatch","change","createIndexableKeysToKeyValues","createDocIdsToChangesAndEmits","last_seq","results_count","lastKey","emittedKeyValue","complexKey","updateViewInQueue","queryView","totalRows","shouldReduce","fetchFromView","viewOpts","total_rows","expectedKeys","parsedKeyAndDocId","parsedNum","parsedStr","arrayElement","objElement","parseIndexableString","onMapResultsReady","finalResults","shouldGroup","groups","lvl","POSITIVE_INFINITY","last","groupKey","reduceTry","reduceView","offset","update_seq","allDocsRes","docIdsToDocs","fetchPromises","startkey","endkey","start_key","end_key","inclusiveEnd","inclusive_end","keyStart","keyEnd","queryViewInQueue","query","coerceOptions","_query","customQuery","keysAsString","httpQuery","updateViewOpts","__opts","view_update_changes_batch_size","finalPromiseFactory","destroy","designDocName","stale","queryPromised","viewCleanup","_viewCleanup","customViewCleanup","httpViewCleanup","docsToViews","viewsToStatus","ddocName","viewDBNames","statusIsGood","viewDBName","destroyPromises","localViewCleanup","mapFunDef","isShallow","checkShallow","isSingle","createShallowSingleMapper","toEmit","createShallowMultiMapper","createDeepSingleMapper","iLen","j","jLen","createDeepMultiMapper","createMapper","partial_filter_selector","abstractMapper$1","_customFindAbstractMapper","massageIndexDef","getKeyFromDoc","def","getIndexes$1","indexes","language","COLLATE_LO","COLLATE_HI","SHORT_CIRCUIT_QUERY","queryOpts","checkFieldInIndex","indexFields","userOperatorLosesPrecision","sortFieldsByIndex","userFields","aIdx","bIdx","MAX_VALUE","getInMemoryFields","coreInMemoryFields","needToFilterInMemory","getBasicInMemoryFields","getInMemoryFieldsFromNe","logicalMatchers","isNonLogicalMatcher","checkIndexMatches","sortOrder","sortMatches","selectorMatches","leftIdx","splice","oneSetIsSubArrayOfOther","checkIndexFieldsMatch","checkFieldsLogicallySound","getMultiFieldCoreQueryPlan","inclusive_start","getCoreQueryPlan","defaultUsed","getDefaultQueryPlan","combinedOpts","newQueryOpts","getSingleFieldQueryOptsFor","getSingleFieldCoreQueryPlan","inclusiveStart","usingGtlt","previousKeys","previousWasEq","previousWasSame","userOperators","newOpts","getMultiFieldQueryOpts","planQuery","request","shouldShortCircuit","userFieldsRes","selectorFields","sortFields","rightIdx","getUserFields","useIndex","matchingIndexes","findMatchingIndexes","defaultIndex","userFieldsMap","arrayToObject","useIndexDdoc","useIndexName","maxScore","score","indexField","findBestMatchingIndex","use_index","coreQueryPlan","find$1","cleanedUseIndex","massageSort","validateFindRequest","getIndexesRes","queryPlan","indexToUse","noneIdSorts","sortItem","validateSort","indexes_count","reverseOptions","originalOpts","original_limit","doAllDocs","signature","targetValue","docKey","filterInclusiveStart","createIndexAsCallback","md5","originalIndexDef","getMd5","ascFields","validateIndex","ddocId","hasInvalidLanguage","viewExists","findAsCallback","explainAsCallback","dbname","range","bookmark","r","getIndexesAsCallback","deleteIndexAsCallback","adapterFun","_closed","_destroyed","logArgs","origCallback","responseArgs","logApiCall","taskqueue","isReady","addTask","failed","MAX_NUM_CONCURRENT_REQUESTS","identityFunction","formatResultForOpenRevsGet","bulkGet","requests","requestsById","numDocs","numDone","perDocResults","allRequests","nextBatch","upTo","batch","docIdx","docRequests","docOpts","open_revs","formatResult","param","defaultBackOff","maxTimeout","random","randomNumber","explainError","$inject_Object_assign","MISSING_BULK_DOCS","MISSING_DOC","REV_CONFLICT","INVALID_ID","MISSING_ID","RESERVED_ID","BAD_ARG","QUERY_PARSE_ERROR","DOC_VALIDATION","BAD_REQUEST","NOT_AN_OBJECT","IDB_ERROR","INVALID_REV","MISSING_STUB","createError","CustomPouchError","names","filterChange","req","hasFilter","query_params","filterReturn","msg","tryFilter","stub","invalidIdError","parseDesignDocFunctionName","s","normalizeDesignDocFunctionName","normalized","qName","qParser","parser","parseUri","exec","uri","encoded","decodeURIComponent","$0","$1","$2","scopeEval","source","scope","thisAtob","thisBtoa","btoa","b64ToBluffer","readAsBinaryString","blob","reader","FileReader","hasBinaryString","onloadend","buffer","bytes","fromCharCode","arrayBufferToBinaryString","readAsArrayBuffer","blobToBinaryString","blobOrBuffer","blobToBase64","base64","setImmediateShim","MD5_CHUNK_SIZE","appendBlob","start","end","sliceBlob","arrayBuffer","appendString","appendBinary","binaryMd5","inputIsString","chunkSize","chunks","ceil","currentChunk","next","loadNextChunk","done","raw","rev$$1","deterministic_revs","toLowerCase","mutateableDoc","_rev_tree","uuid","winningRev","metadata","winningId","winningPos","winningDeleted","node","toVisit","rev_tree","tree","ids","branches","pos","deleted","traverseRevTree","revs","newCtx","ctx","sortByPos","collectLeaves","leaves","isLeaf","acc","collectConflicts","win","leaf","rootToLeaf","paths","history","sortByPos$1","insertSorted","item","comparator","mid","low","high","binarySearch","pathToTree","numStemmed","root","currentLeaf","compareTree","mergeTree","in_tree1","in_tree2","tree1","tree2","doMerge","dontExpand","restree","branch","t1","t2","diff","candidateParents","trees","parent","parentIdx","elements","elementsLen","el","merge","depth","newTree","stemmed","stemmedRevs","revHash","stem","getTrees","isDeleted","isLocalId","Changes$1","complete","ee","onDestroy","cancel","pending","lastSeq","isCancelled","tryCatchInChangeListener","validateChanges","changeList","_conflicts","yankError","compareByIdThenRev","idCompare","_revisions","doNextCompaction","_compactionQueue","_compact","AbstractPouchDB","p","PouchDB","prefix","backend","adapters","preferredAdapters","adapterName","use_prefix","parseAdapter","_adapter","valid","view_adapter","fail","onDestroyed","from_constructor","onClosed","prepareForDestruction","ready","_changesFilterPlugin","validate","doChanges","continuous","live","normalize","shouldFilter","newPromise","_changes","post","_putLocal","_removeLocal","oldRevId","newRevNum","newRevId","putDoc","_put","new_edits","force","putAttachment","attachmentId","api","createAttachment","prevrevpos","revpos","removeAttachment","remove","docOrId","optsOrRev","was_delete","revsDiff","missing","addToMissing","revId","_getRevisionTree","missingForId","processDoc","missingObj","compactDocument","maxHeight","revTree","height","edges","prnt","from","edge","computeHeight","candidates","_doCompaction","compact","promises","_getLocal","finishOpenRevs","latest","l","_get","revs_info","splittedRev","revNo","currentPath","hashIndex","indexOfRev","howMany","_revs_info","_getAttachment","getAttachment","incompatibleOpt","allDocsKeysParse","_allDocs","close","_close","_info","_type","attachmentError","charAt","attachmentNameError","cleanDocs","_bulkDocs","dependentDb","dbOptions","depDB","dependentDbs","usePrefix","destroyDb","_destroy","localDoc","deletedMap","trueName","execute","abort","f$1","eventEmitter","Pouch","destructListeners","_destructionListeners","dbList","setUpEventEmitter","addToPreferredAdapters","plugin","__defaults","defaults","defaultOpts","PouchAlt","url","filterName","changesHandler","doc_ids","filterFun","filters","toObject","version","reservedWords","dataWords","parseRevisionInfo","parseDoc","newEdits","dbOpts","nRevNum","revInfo","revisions","revisionIds","makeRevTreeFromRevisions","specialKey","preprocessAttachment","blobType","asBinary","parseBase64","digest","preprocessString","preprocessBlob","processDocs","revLimit","docInfos","fetchedDocs","tx","writeDoc","overallCallback","idsToDocs","docsDone","docsToDo","checkAllDocsDone","currentDoc","resultsIdx","docWritten","nextDoc","prev","docInfo","splitRev","targetPos","targetId","revExists","previousWinningRev","previouslyDeleted","isRoot","newRev","rev_map","winningRev$$1","winningRevIsDeleted","delta","updateDoc","rootIsMissing","insertDoc","DOC_STORE","BY_SEQ_STORE","ATTACH_STORE","ATTACH_AND_SEQ_STORE","META_STORE","LOCAL_STORE","DETECT_BLOB_SUPPORT_STORE","safeJsonStringify","idbError","evt","encodeMetadata","deletedOrLocal","decodeMetadata","storedObject","parse","safeJsonParse","decodeDoc","_doc_id_rev","lastIndexOf","readBlobData","asBlob","fetchAttachmentsIfNecessary","txn","checkDone","attObj","objectStore","onsuccess","fetchAttachment","postProcessAttachments","attNames","compactRevs","possiblyOrphanedDigests","seqStore","attStore","attAndSeqStore","IDBKeyRange","bound","openCursor","only","event","cursor","digestSeq","primaryKey","continue","openTransactionSafely","idb","stores","mode","transaction","idbBulkDocs","docStore","bySeqStore","attachStore","attachAndSeqStore","metaStore","docInfoError","allDocsProcessed","docCountDelta","preconditionErrored","_meta","blobSupport","onAllDocsProcessed","updateDocCountIfReady","docCount","newRevIsDeleted","isUpdate","collectResults","finishDoc","attachmentSaved","newAtt","saveAttachment","writeAttachments","afterPutDoc","revsToDelete","compactTree","metadataToStore","afterPutMetadata","attsAdded","attsToAdd","onerror","preventDefault","stopPropagation","insertAttachmentMappings","putReq","overallErr","docv","recv","processedAttachment","preprocessAttachments","txnResult","onabort","ontimeout","oncomplete","digests","verifyAttachment","attErr","verifyAttachments","numFetched","readMetadata","revs_limit","fetchExistingDocs","startTransaction","runBatchedCursor","keyRange","batchSize","onBatch","keysBatch","valuesBatch","pseudoCursor","onGetAll","onGetAllKeys","onCursor","getAll","getAllKeys","newKeyRange","upper","upperOpen","code","lowerBound","idbAllDocs","keyRangeError","upperBound","createKeyRange","onResultsReady","updateSeq","docIdRevIndex","allDocsInner","fetchDocAsynchronously","batchValues","batchValue","batchKeys","returnVal","maxKey","onSuccess","allDocsKeys","running","applyNext","blobSupportPromise","cachedDBs","openReqList","IdbPouch","action","thisCallback","tryCode","idbGlobalFailureError","enrichCallbackError","createSchema","createObjectStore","keyPath","autoIncrement","unique","addDeletedOrLocalIndex","createLocalStoreSchema","migrateLocalStore","localStore","local","docIdRev","seqCursor","addAttachAndSeqStore","migrateAttsAndSeqs","digestMap","migrateMetadata","decodeMetadataCompat","onGetMetadataSeq","fetchMetadataSeq","metadataSeq","instanceId","reqOpts","historyNode","attachId","attachment","blobData","doc_count","idb_attachment_format","numResults","docIdsToMetadata","onGetMetadata","objectStores","winningDocs","metadatas","fetchWinningDocAndMetadata","winningDoc","processMetadataAndWinningDoc","onBatchDone","filtered","oldRev","oStore","oldDoc","openReq","indexedDB","deleteDatabase","cached","global","open","onupgradeneeded","oldVersion","currentTarget","migrations","migration","onversionchange","storedMetaDoc","completeSetup","storeMetaDocIfReady","instanceKey","countDocs","blob$$1","matchedChrome","navigator","userAgent","matchedEdge","checkBlobSupport","enqueueTask","CHANGES_TIMEOUT_BUFFER","supportsBulkGetMap","encodeDocId","preprocessAttachments$1","genDBUrl","genUrl","pathDel","protocol","host","port","paramsToStr","HttpPouch","hasUrlPrefix","substr","user","password","auth","username","getHost","dbUrl","setupPromise","ourFetch","credentials","nAuth","token","unescape","ua","isIE","isTrident","isEdge","isGET","shouldCacheBust","now","adapterFun$$1","setup","fetchJSON","v","skip_setup","encodeAttachmentId","uuid$$1","ping","compact_running","interval","doBulkGet","doBulkGetShim","numBatches","onResult","batchNum","subOpts","supportsBulkGet","fetchAttachments","promiseFactories","filenames","typeFieldDescriptor","__proto__","fetchData","doNext","runNextBatch","onError","thisErr","docOrDocs","contentType","process","browser","paramStr","batch_size","heartbeat","requestTimeout","leftToFetch","feed","seq_interval","param_name","lastFetchedSeq","controller","aborted","fetchOpts","signal","fetched","raw_results_length","finished","createBuiltInError","sum","jNum","evalFunctionWithEval","TaskQueue$1","builtInReduce","sumsqr","_sumsqr","abstract","isGenOne","createAbstractMapReduce","origMap","reduceFunString","builtIn","getBuiltIn","mapreduce","isGenOne$1","getDocAttachments","getDocs","src","diffs","resultDocs","hasConflicts","fetchRevisionOneDocs","bulkGetOpts","missingRev","createBulkGetOpts","bulkGetResponse","bulkGetInfo","remoteDoc","doCheckForLocalAttachments","fileHasChanged","getDocAttachmentsFromTargetOrSource","Boolean","REPLICATOR","updateCheckpoint","checkpoint","session","returnValue","session_id","replicator","Checkpointer","writeCheckpoint","updateTarget","updateSource","writeTargetCheckpoint","writeSourceCheckpoint","isForbiddenError","comparisons","targetDoc","sourceDoc","srcDoc","tgtDoc","compareReplicationHistory","sourceHistory","targetHistory","S","sourceRest","T","targetRest","hasSessionId","sessionId","props","rest","floor","getCheckpoint","STARTING_BACK_OFF","replicate","currentBatch","repId","checkpointer","batches","pendingBatch","writingCheckpoint","changesCompleted","replicationCompleted","batches_limit","changesPending","changedDocs","start_time","docs_read","docs_written","doc_write_failures","errors","initCheckpointer","queryParams","filterViewName","sortObjectPropertiesByKey","queryData","md5sum","generateReplicationId","checkpointOpts","writeDocs","bulkOpts","completeReplication","errorsById","errorsNo","errorName","finishBatch","outResult","getChanges","onCheckpointError","getBatchDocs","got","startNextBatch","abortReplication","processPendingBatch","immediate$$1","fatalError","end_time","retry","back_off_function","backOffSet","current_back_off","backOff","onChangesComplete","onChangesError","_abortChanges","abortChanges","startChanges","_addedListeners","Replication","toPouch","PouchConstructor","replicateWrapper","replicateRet","sync","Sync","canceled","optsPush","optsPull","pull","pullChange","direction","pushChange","pushDenied","pullDenied","pushPaused","pullPaused","pushActive","pullActive","removed","removeAll","addOneListener","out","success","cleanup","_readyCalled","replicateMethods","other","hex_chr","md5cycle","d","md5blk","md5blks","md5blk_array","md51","tail","tmp","lo","hi","rhex","hex","toUtf8","hexToBinaryString","SparkMD5","reset","clamp","begin","factory","contents","_buff","_length","_hash","_finish","getState","hash","setState","hashBinary","content","second","returnUInt8Array","subarray","utf8Str2ArrayBuffer","md51_array","getRandomValues","rnds8","rng","crypto","msCrypto","byteToHex","rnds","arrayPrefix","objPrefix","numChar","parsedString","lastCh","numConsecutiveSlashes"],"sourceRoot":""}