build 3.0.1
diff --git a/bower.json b/bower.json
index a71465c..d246f54 100644
--- a/bower.json
+++ b/bower.json
@@ -1,6 +1,6 @@
{
"name": "pouchdb",
- "version": "3.0.1-prerelease",
+ "version": "3.0.1",
"description": "PouchDB is a pocket-sized database.",
"repo": "daleharvey/pouchdb",
"keywords": [
diff --git a/component.json b/component.json
index 6135e4d..1becb91 100644
--- a/component.json
+++ b/component.json
@@ -1,6 +1,6 @@
{
"name": "pouchdb",
- "version": "3.0.1-prerelease",
+ "version": "3.0.1",
"description": "PouchDB is a pocket-sized database.",
"repo": "daleharvey/pouchdb",
"keywords": [
diff --git a/dist/pouchdb.idb-alt.js b/dist/pouchdb.idb-alt.js
new file mode 100644
index 0000000..444773a
--- /dev/null
+++ b/dist/pouchdb.idb-alt.js
@@ -0,0 +1,15943 @@
+// PouchDB alternative IndexedDB plugin 3.0.1
+// Based on level.js: https://github.com/maxogden/level.js
+//
+// (c) 2012-2014 Dale Harvey and the PouchDB team
+// PouchDB may be freely distributed under the Apache license, version 2.0.
+// For all details and documentation:
+// http://pouchdb.com
+require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+(function (process,global,Buffer){
+'use strict';
+
+var levelup = require('levelup');
+var originalLeveldown = require('leveldown');
+var sublevel = require('level-sublevel');
+var through = require('through2').obj;
+
+var errors = require('../deps/errors');
+var merge = require('../merge');
+var utils = require('../utils');
+var migrate = require('../deps/migrate');
+
+var DOC_STORE = 'document-store';
+var BY_SEQ_STORE = 'by-sequence';
+var ATTACHMENT_STORE = 'attach-store';
+var BINARY_STORE = 'attach-binary-store';
+var LOCAL_STORE = 'local-store';
+var META_STORE = 'meta-store';
+var BATCH_SIZE = 50;
+
+// leveldb barks if we try to open a db multiple times
+// so we cache opened connections here for initstore()
+var dbStores = new utils.Map();
+
+// store the value of update_seq in the by-sequence store the key name will
+// never conflict, since the keys in the by-sequence store are integers
+var UPDATE_SEQ_KEY = '_local_last_update_seq';
+var DOC_COUNT_KEY = '_local_doc_count';
+var UUID_KEY = '_local_uuid';
+
+function LevelPouch(opts, callback) {
+ opts = utils.clone(opts);
+ var api = this;
+ var instanceId;
+ var stores = {};
+ var db;
+ var name = opts.name;
+ if (typeof opts.createIfMissing === 'undefined') {
+ opts.createIfMissing = true;
+ }
+
+ var leveldown = opts.db || originalLeveldown;
+ if (typeof leveldown.destroy !== 'function') {
+ leveldown.destroy = function (name, cb) { cb(); };
+ }
+ var dbStore;
+ if (dbStores.has(leveldown.name)) {
+ dbStore = dbStores.get(leveldown.name);
+ } else {
+ dbStore = new utils.Map();
+ dbStores.set(leveldown.name, dbStore);
+ }
+ if (dbStore.has(name)) {
+ db = dbStore.get(name);
+ afterDBCreated();
+ } else {
+ dbStore.set(name, sublevel(levelup(name, opts, function (err) {
+ if (err) {
+ dbStore["delete"](name);
+ return callback(err);
+ }
+ db = dbStore.get(name);
+ db._locks = db._locks || new utils.Set();
+ db._docCountQueue = {
+ queue : [],
+ running : false,
+ docCount : -1
+ };
+ if (opts.db || opts.noMigrate) {
+ afterDBCreated();
+ } else {
+ migrate.toSublevel(name, db, afterDBCreated);
+ }
+ })));
+ }
+
+ function afterDBCreated() {
+ stores.docStore = db.sublevel(DOC_STORE, {valueEncoding: 'json'});
+ stores.bySeqStore = db.sublevel(BY_SEQ_STORE, {valueEncoding: 'json'});
+ stores.attachmentStore =
+ db.sublevel(ATTACHMENT_STORE, {valueEncoding: 'json'});
+ stores.binaryStore = db.sublevel(BINARY_STORE, {valueEncoding: 'binary'});
+ stores.localStore = db.sublevel(LOCAL_STORE, {valueEncoding: 'json'});
+ stores.metaStore = db.sublevel(META_STORE, {valueEncoding: 'json'});
+ migrate.localAndMetaStores(db, stores, function () {
+ stores.metaStore.get(UPDATE_SEQ_KEY, function (err, value) {
+ if (typeof db._updateSeq === 'undefined') {
+ db._updateSeq = value || 0;
+ }
+ stores.metaStore.get(DOC_COUNT_KEY, function (err, value) {
+ db._docCountQueue.docCount = !err ? value : 0;
+ countDocs(function (err) { // notify queue that the docCount is ready
+ if (err) {
+ api.emit('error', err);
+ }
+ stores.metaStore.get(UUID_KEY, function (err, value) {
+ instanceId = !err ? value : utils.uuid();
+ stores.metaStore.put(UUID_KEY, instanceId, function (err, value) {
+ process.nextTick(function () {
+ callback(null, api);
+ });
+ });
+ });
+ });
+ });
+ });
+ });
+ }
+
+ function countDocs(callback) {
+ if (db._docCountQueue.running || !db._docCountQueue.queue.length ||
+ db._docCountQueue.docCount === -1) {
+ return incrementDocCount(0, callback); // wait for fresh data
+ }
+ return db._docCountQueue.docCount; // use cached value
+ }
+
+ function applyNextDocCountDelta() {
+ if (db._docCountQueue.running || !db._docCountQueue.queue.length ||
+ db._docCountQueue.docCount === -1) {
+ return;
+ }
+ db._docCountQueue.running = true;
+ var item = db._docCountQueue.queue.shift();
+ if (db.isClosed()) {
+ return item.callback(new Error('database is closed'));
+ }
+ stores.metaStore.get(DOC_COUNT_KEY, function (err, docCount) {
+ docCount = !err ? docCount : 0;
+
+ function complete(err) {
+ db._docCountQueue.docCount = docCount;
+ item.callback(err, docCount);
+ db._docCountQueue.running = false;
+ applyNextDocCountDelta();
+ }
+
+ if (item.delta === 0) {
+ complete();
+ } else {
+ stores.metaStore.put(DOC_COUNT_KEY, docCount + item.delta, complete);
+ }
+ });
+ }
+
+ function incrementDocCount(delta, callback) {
+ db._docCountQueue.queue.push({delta : delta, callback : callback});
+ applyNextDocCountDelta();
+ }
+
+ api.type = function () {
+ return 'leveldb';
+ };
+
+ api._id = function (callback) {
+ callback(null, instanceId);
+ };
+
+ api._info = function (callback) {
+ countDocs(function (err, docCount) {
+ if (err) {
+ return callback(err);
+ }
+ stores.metaStore.get(UPDATE_SEQ_KEY, function (err, otherUpdateSeq) {
+ if (err) {
+ otherUpdateSeq = db._updateSeq;
+ }
+
+ return callback(null, {
+ doc_count: docCount,
+ update_seq: otherUpdateSeq
+ });
+ });
+ });
+ };
+
+ function formatSeq(n) {
+ return ('0000000000000000' + n).slice(-16);
+ }
+
+ function parseSeq(s) {
+ return parseInt(s, 10);
+ }
+
+ function makeDoc(rawDoc, callback) {
+ var doc = rawDoc.data;
+ doc._id = rawDoc.metadata.id;
+ if ('_rev' in doc) {
+ if (doc._rev !== rawDoc.metadata.rev) {
+ return callback(new Error('wrong doc returned'));
+ }
+ } else {
+ // we didn't always store rev
+ doc._rev = rawDoc.metadata.rev;
+ }
+ callback(null, {doc: doc, metadata: rawDoc.metadata});
+ }
+
+ api._get = function (id, opts, callback) {
+ opts = utils.clone(opts);
+ var docChanged = [];
+
+ function didDocChange(doc) {
+ docChanged.push(doc);
+ }
+
+ db.on('pouchdb-id-' + id, didDocChange);
+
+ stores.docStore.get(id, function (err, metadata) {
+ db.removeListener('pouchdb-id-' + id, didDocChange);
+
+ if (err || !metadata) {
+ return callback(errors.MISSING_DOC);
+ }
+
+ if (utils.isDeleted(metadata) && !opts.rev) {
+ return callback(errors.error(errors.MISSING_DOC, "deleted"));
+ }
+
+ var updated;
+
+ function ifUpdate(doc) {
+ updated = doc;
+ }
+
+ var rev = merge.winningRev(metadata);
+ rev = opts.rev ? opts.rev : rev;
+
+ var seq = metadata.rev_map[rev];
+
+ var anyChanged = docChanged.filter(function (doc) {
+ return doc.metadata.seq === seq;
+ });
+
+ if (anyChanged.length) {
+ return makeDoc(anyChanged.pop(), callback);
+ }
+
+ db.on('pouchdb-' + seq, ifUpdate);
+
+ stores.bySeqStore.get(formatSeq(seq), function (err, doc) {
+ db.removeListener('pouchdb-' + seq, ifUpdate);
+ if (updated) {
+ return makeDoc(updated, callback);
+
+ }
+
+ if (!doc) {
+ return callback(errors.MISSING_DOC);
+ }
+ if ('_id' in doc && doc._id !== metadata.id) {
+ // this failing implies something very wrong
+ return callback(new Error('wrong doc returned'));
+ }
+ doc._id = metadata.id;
+ if ('_rev' in doc) {
+ if (doc._rev !== rev) {
+ // this failing implies something very wrong
+ return callback(new Error('wrong doc returned'));
+ }
+ } else {
+ // we didn't always store this
+ doc._rev = rev;
+ }
+ return callback(null, {doc: doc, metadata: metadata});
+ });
+ });
+ };
+
+ // not technically part of the spec, but if putAttachment has its own
+ // method...
+ api._getAttachment = function (attachment, opts, callback) {
+ var digest = attachment.digest;
+
+ stores.binaryStore.get(digest, function (err, attach) {
+ var data;
+
+ if (err && err.name === 'NotFoundError') {
+ // Empty attachment
+ data = opts.encode ? '' : process.browser ?
+ utils.createBlob([''], {type: attachment.content_type}) :
+ new Buffer('');
+ return callback(null, data);
+ }
+
+ if (err) {
+ return callback(err);
+ }
+
+ if (process.browser) {
+ if (opts.encode) {
+ data = utils.btoa(global.unescape(attach));
+ } else {
+ data = utils.createBlob([utils.fixBinary(global.unescape(attach))],
+ {type: attachment.content_type});
+ }
+ } else {
+ data = opts.encode ? utils.btoa(attach) : attach;
+ }
+ callback(null, data);
+ });
+ };
+ api.lock = function (id) {
+ if (db._locks.has(id)) {
+ return false;
+ } else {
+ db._locks.add(id);
+ return true;
+ }
+ };
+
+ api.unlock = function (id) {
+ if (db._locks.has(id)) {
+ db._locks["delete"](id);
+ return true;
+ }
+ return false;
+ };
+
+ api._bulkDocs = function (req, opts, callback) {
+ var newEdits = opts.new_edits;
+ var results = new Array(req.docs.length);
+
+ // parse the docs and give each a sequence number
+ var userDocs = req.docs;
+ var info = userDocs.map(function (doc, i) {
+ if (doc._id && utils.isLocalId(doc._id)) {
+ return doc;
+ }
+ var newDoc = utils.parseDoc(doc, newEdits);
+ newDoc._bulk_seq = i;
+
+ if (newDoc.metadata && !newDoc.metadata.rev_map) {
+ newDoc.metadata.rev_map = {};
+ }
+
+ return newDoc;
+ });
+ var current = 0;
+ var infoErrors = info.filter(function (doc) {
+ return doc.error;
+ });
+
+ if (infoErrors.length) {
+ return callback(infoErrors[0]);
+ }
+ var inProgress = 0;
+ function processDocs() {
+ var index = current;
+ if (inProgress > BATCH_SIZE) {
+ return;
+ }
+ if (index >= info.length) {
+ if (inProgress === 0) {
+ return complete();
+ } else {
+ return;
+ }
+ }
+ var currentDoc = info[index];
+ current++;
+ inProgress++;
+ if (currentDoc._id && utils.isLocalId(currentDoc._id)) {
+ api[currentDoc._deleted ? '_removeLocal' : '_putLocal'](
+ currentDoc, function (err, resp) {
+ if (err) {
+ results[index] = err;
+ } else {
+ results[index] = {};
+ }
+ inProgress--;
+ processDocs();
+ });
+ return;
+ }
+ stores.docStore.get(currentDoc.metadata.id, function (err, oldDoc) {
+ if (!api.lock(currentDoc.metadata.id)) {
+ results[index] = makeErr(errors.REV_CONFLICT,
+ 'someobody else is accessing this');
+ inProgress--;
+ return processDocs();
+ }
+ if (err) {
+ if (err.name === 'NotFoundError') {
+ insertDoc(currentDoc, index, function () {
+ api.unlock(currentDoc.metadata.id);
+ inProgress--;
+ processDocs();
+ });
+ } else {
+ err.error = true;
+ results[index] = err;
+ api.unlock(currentDoc.metadata.id);
+ inProgress--;
+ processDocs();
+ }
+ } else {
+ updateDoc(oldDoc, currentDoc, index, function () {
+ api.unlock(currentDoc.metadata.id);
+ inProgress--;
+ processDocs();
+ });
+ }
+ });
+ if (newEdits) {
+ processDocs();
+ }
+ }
+
+ function insertDoc(doc, index, callback) {
+ // Can't insert new deleted documents
+ if ('was_delete' in opts && utils.isDeleted(doc.metadata)) {
+ results[index] = makeErr(errors.MISSING_DOC, doc._bulk_seq);
+ return callback();
+ }
+ writeDoc(doc, index, function (err) {
+ if (err) {
+ return callback(err);
+ }
+ if (utils.isDeleted(doc.metadata)) {
+ return callback();
+ }
+ incrementDocCount(1, callback);
+ });
+ }
+
+ function updateDoc(oldDoc, docInfo, index, callback) {
+ var merged =
+ merge.merge(oldDoc.rev_tree, docInfo.metadata.rev_tree[0], 1000);
+
+ var conflict = (utils.isDeleted(oldDoc) &&
+ utils.isDeleted(docInfo.metadata) &&
+ newEdits) ||
+ (!utils.isDeleted(oldDoc) &&
+ newEdits && merged.conflicts !== 'new_leaf');
+
+
+ if (conflict) {
+ results[index] = makeErr(errors.REV_CONFLICT, docInfo._bulk_seq);
+ return callback();
+ }
+ docInfo.metadata.rev_tree = merged.tree;
+ docInfo.metadata.rev_map = oldDoc.rev_map;
+ var delta = 0;
+ var oldDeleted = utils.isDeleted(oldDoc);
+ var newDeleted = utils.isDeleted(docInfo.metadata);
+ delta = (oldDeleted === newDeleted) ? 0 :
+ oldDeleted < newDeleted ? -1 : 1;
+ incrementDocCount(delta, function (err) {
+ if (err) {
+ return callback(err);
+ }
+ writeDoc(docInfo, index, callback);
+ });
+
+ }
+
+ function writeDoc(doc, index, callback2) {
+ var err = null;
+ var recv = 0;
+
+ doc.data._id = doc.metadata.id;
+ doc.data._rev = doc.metadata.rev;
+
+ if (utils.isDeleted(doc.metadata)) {
+ doc.data._deleted = true;
+ }
+
+ var attachments = doc.data._attachments ?
+ Object.keys(doc.data._attachments) :
+ [];
+
+ function collectResults(attachmentErr) {
+ if (!err) {
+ if (attachmentErr) {
+ err = attachmentErr;
+ callback2(err);
+ } else if (recv === attachments.length) {
+ finish();
+ }
+ }
+ }
+
+ function attachmentSaved(err) {
+ recv++;
+ collectResults(err);
+ }
+
+ function onMD5Load(doc, prefix, key, data, attachmentSaved) {
+ return function (result) {
+ saveAttachment(doc, prefix + result, key, data, attachmentSaved);
+ };
+ }
+
+ function onLoadEnd(doc, prefix, key, attachmentSaved) {
+ return function (e) {
+ var data = global.escape(
+ utils.arrayBufferToBinaryString(e.target.result));
+ utils.MD5(data).then(
+ onMD5Load(doc, prefix, key, data, attachmentSaved)
+ );
+ };
+ }
+
+ for (var i = 0; i < attachments.length; i++) {
+ var key = attachments[i];
+
+ if (doc.data._attachments[key].stub) {
+ recv++;
+ collectResults();
+ continue;
+ }
+ var att = doc.data._attachments[key];
+ var data;
+ var prefix;
+ if (typeof att.data === 'string') {
+ try {
+ data = utils.atob(att.data);
+ if (process.browser) {
+ data = global.escape(data);
+ }
+ } catch (e) {
+ callback(utils.extend({}, errors.BAD_ARG,
+ {reason: "Attachments need to be base64 encoded"}));
+ return;
+ }
+ prefix = process.browser ? 'md5-' : '';
+ } else if (!process.browser) {
+ data = att.data;
+ prefix = '';
+ } else { // browser
+ var reader = new FileReader();
+ reader.onloadend = onLoadEnd(doc, 'md5-', key, attachmentSaved);
+ reader.readAsArrayBuffer(att.data);
+ return;
+ }
+ utils.MD5(data).then(
+ onMD5Load(doc, prefix, key, data, attachmentSaved)
+ );
+ }
+
+ function finish() {
+ var seq = doc.metadata.rev_map[doc.metadata.rev];
+ if (!seq) {
+ // check that there aren't any existing revisions with the same
+ // reivision id, else we shouldn't increment updateSeq
+ seq = ++db._updateSeq;
+ }
+ doc.metadata.rev_map[doc.metadata.rev] = doc.metadata.seq = seq;
+ var seqKey = formatSeq(seq);
+ db.emit('pouchdb-id-' + doc.metadata.id, doc);
+ db.emit('pouchdb-' + seqKey, doc);
+ db.batch([{
+ key: seqKey,
+ value: doc.data,
+ prefix: stores.bySeqStore,
+ type: 'put',
+ valueEncoding: 'json'
+ }, {
+ key: doc.metadata.id,
+ value: doc.metadata,
+ prefix: stores.docStore,
+ type: 'put',
+ valueEncoding: 'json'
+ }], function (err) {
+ if (!err) {
+ db.emit('pouchdb-id-' + doc.metadata.id, doc);
+ db.emit('pouchdb-' + seqKey, doc);
+ }
+ return stores.metaStore.put(UPDATE_SEQ_KEY, db._updateSeq,
+ function (err) {
+ if (err) {
+ results[index] = err;
+ } else {
+ results[index] = doc;
+ }
+ return callback2();
+ });
+ });
+ }
+
+ if (!attachments.length) {
+ finish();
+ }
+ }
+
+ function saveAttachment(docInfo, digest, key, data, callback) {
+ delete docInfo.data._attachments[key].data;
+ docInfo.data._attachments[key].digest = digest;
+ stores.attachmentStore.get(digest, function (err, oldAtt) {
+ if (err && err.name !== 'NotFoundError') {
+ return callback(err);
+ }
+
+ var ref = [docInfo.metadata.id, docInfo.metadata.rev].join('@');
+ var newAtt = {};
+
+ if (oldAtt) {
+ if (oldAtt.refs) {
+ // only update references if this attachment already has them
+ // since we cannot migrate old style attachments here without
+ // doing a full db scan for references
+ newAtt.refs = oldAtt.refs;
+ newAtt.refs[ref] = true;
+ }
+ } else {
+ newAtt.refs = {};
+ newAtt.refs[ref] = true;
+ }
+
+ stores.attachmentStore.put(digest, newAtt, function (err) {
+ // do not try to store empty attachments
+ if (data.length === 0) {
+ return callback(err);
+ }
+ // doing this in batch causes a test to fail, wtf?
+ stores.binaryStore.put(digest, data, function (err) {
+ callback(err);
+ });
+ });
+ });
+ }
+
+ function complete() {
+ results.sort(function (a, b) { return a._bulk_seq - b._bulk_seq; });
+ var aresults = results.map(function (result) {
+ if (result._bulk_seq) {
+ delete result._bulk_seq;
+ } else if (!Object.keys(result).length) {
+ return {
+ ok: true
+ };
+ }
+ if (result.error) {
+ return result;
+ }
+
+ var metadata = result.metadata;
+ var rev = merge.winningRev(metadata);
+
+ return {
+ ok: true,
+ id: metadata.id,
+ rev: rev
+ };
+ });
+ LevelPouch.Changes.notify(name);
+ process.nextTick(function () { callback(null, aresults); });
+ }
+
+ function makeErr(err, seq) {
+ err._bulk_seq = seq;
+ return err;
+ }
+
+ processDocs();
+ };
+
+ api._allDocs = function (opts, callback) {
+ opts = utils.clone(opts);
+ countDocs(function (err, docCount) {
+ if (err) {
+ return callback(err);
+ }
+ var readstreamOpts = {};
+ var skip = opts.skip || 0;
+ if (opts.startkey) {
+ readstreamOpts.start = opts.startkey;
+ }
+ if (opts.endkey) {
+ readstreamOpts.end = opts.endkey;
+ }
+ if (opts.key) {
+ readstreamOpts.start = readstreamOpts.end = opts.key;
+ }
+ if (opts.descending) {
+ readstreamOpts.reverse = true;
+ // switch start and ends
+ var tmp = readstreamOpts.start;
+ readstreamOpts.start = readstreamOpts.end;
+ readstreamOpts.end = tmp;
+ }
+ var limit;
+ if (typeof opts.limit === 'number') {
+ limit = opts.limit;
+ } else {
+ limit = -1;
+ }
+ if (limit === 0 ||
+ ('start' in readstreamOpts && 'end' in readstreamOpts &&
+ readstreamOpts.start > readstreamOpts.end)) {
+ // should return 0 results when start is greater than end.
+ // normally level would "fix" this for us by reversing the order,
+ // so short-circuit instead
+ return callback(null, {
+ total_rows: docCount,
+ offset: opts.skip,
+ rows: []
+ });
+ }
+ var results = [];
+ var docstream = stores.docStore.readStream(readstreamOpts);
+
+ var throughStream = through(function (entry, _, next) {
+ if (!utils.isDeleted(entry.value)) {
+ if (skip-- > 0) {
+ next();
+ return;
+ } else if (limit-- === 0) {
+ docstream.unpipe();
+ docstream.destroy();
+ next();
+ return;
+ }
+ } else if (opts.deleted !== 'ok') {
+ next();
+ return;
+ }
+ function allDocsInner(metadata, data) {
+ var doc = {
+ id: metadata.id,
+ key: metadata.id,
+ value: {
+ rev: merge.winningRev(metadata)
+ }
+ };
+ if (opts.include_docs) {
+ doc.doc = data;
+ doc.doc._rev = doc.value.rev;
+ if (opts.conflicts) {
+ doc.doc._conflicts = merge.collectConflicts(metadata);
+ }
+ for (var att in doc.doc._attachments) {
+ if (doc.doc._attachments.hasOwnProperty(att)) {
+ doc.doc._attachments[att].stub = true;
+ }
+ }
+ }
+ if (opts.inclusive_end === false && metadata.id === opts.endkey) {
+ return next();
+ } else if (utils.isDeleted(metadata)) {
+ if (opts.deleted === 'ok') {
+ doc.value.deleted = true;
+ doc.doc = null;
+ } else {
+ return next();
+ }
+ }
+ results.push(doc);
+ next();
+ }
+ var metadata = entry.value;
+ if (opts.include_docs) {
+ var seq = metadata.rev_map[merge.winningRev(metadata)];
+ stores.bySeqStore.get(formatSeq(seq), function (err, data) {
+ allDocsInner(metadata, data);
+ });
+ }
+ else {
+ allDocsInner(metadata);
+ }
+ }, function (next) {
+ callback(null, {
+ total_rows: docCount,
+ offset: opts.skip,
+ rows: results
+ });
+ next();
+ }).on('unpipe', function () {
+ throughStream.end();
+ });
+
+ docstream.on('error', callback);
+
+ docstream.pipe(throughStream);
+ });
+ };
+
+ api._changes = function (opts) {
+ opts = utils.clone(opts);
+
+ if (opts.continuous) {
+ var id = name + ':' + utils.uuid();
+ LevelPouch.Changes.addListener(name, id, api, opts);
+ LevelPouch.Changes.notify(name);
+ return {
+ cancel: function () {
+ LevelPouch.Changes.removeListener(name, id);
+ }
+ };
+ }
+
+ var descending = opts.descending;
+ var results = [];
+ var last_seq = 0;
+ var called = 0;
+ var streamOpts = {
+ reverse: descending
+ };
+ var limit;
+ if ('limit' in opts && opts.limit > 0) {
+ limit = opts.limit;
+ }
+ if (!streamOpts.reverse) {
+ streamOpts.start = formatSeq(opts.since ? opts.since + 1 : 0);
+ }
+ var filter = utils.filterChange(opts);
+ var returnDocs;
+ if ('returnDocs' in opts) {
+ returnDocs = opts.returnDocs;
+ } else {
+ returnDocs = true;
+ }
+
+ function complete() {
+ opts.done = true;
+ if (returnDocs && opts.limit) {
+ if (opts.limit < results.length) {
+ results.length = opts.limit;
+ }
+ }
+ changeStream.unpipe(throughStream);
+ changeStream.destroy();
+ if (!opts.continuous && !opts.cancelled) {
+ opts.complete(null, {results: results, last_seq: last_seq});
+ }
+ }
+ var changeStream = stores.bySeqStore.readStream(streamOpts);
+ var throughStream = through(function (data, _, next) {
+ if (limit && called >= limit) {
+ complete();
+ return next();
+ }
+ if (opts.cancelled || opts.done) {
+ return next();
+ }
+
+ stores.docStore.get(data.value._id, function (err, metadata) {
+ if (opts.cancelled || opts.done || db.isClosed() ||
+ utils.isLocalId(metadata.id)) {
+ return next();
+ }
+ var doc = data.value;
+ doc._rev = merge.winningRev(metadata);
+ var change = opts.processChange(doc, metadata, opts);
+ change.seq = metadata.seq;
+
+ if (last_seq < metadata.seq) {
+ last_seq = metadata.seq;
+ }
+
+ // Ensure duplicated dont overwrite winning rev
+ if (parseSeq(data.key) === metadata.rev_map[change.doc._rev] &&
+ filter(change)) {
+ called++;
+
+ utils.call(opts.onChange, change);
+
+ if (returnDocs) {
+ results.push(change);
+ }
+ }
+ next();
+ });
+ }, function (next) {
+ if (opts.cancelled) {
+ return next();
+ }
+ if (returnDocs && opts.limit) {
+ if (opts.limit < results.length) {
+ results.length = opts.limit;
+ }
+ }
+
+ next();
+ }).on('unpipe', function () {
+ throughStream.end();
+ complete();
+ });
+ changeStream.pipe(throughStream);
+ return {
+ cancel: function () {
+ opts.cancelled = true;
+ complete();
+ }
+ };
+ };
+
+ api._close = function (callback) {
+ if (db.isClosed()) {
+ return callback(errors.NOT_OPEN);
+ }
+ db.close(function (err) {
+ if (err) {
+ callback(err);
+ } else {
+ dbStore["delete"](name);
+ callback();
+ }
+ });
+ };
+
+ api._getRevisionTree = function (docId, callback) {
+ stores.docStore.get(docId, function (err, metadata) {
+ if (err) {
+ callback(errors.MISSING_DOC);
+ } else {
+ callback(null, metadata.rev_tree);
+ }
+ });
+ };
+
+ api._doCompaction = function (docId, rev_tree, revs, callback) {
+ stores.docStore.get(docId, function (err, metadata) {
+ if (err) {
+ return callback(err);
+ }
+ var seqs = metadata.rev_map; // map from rev to seq
+ metadata.rev_tree = rev_tree;
+ if (!revs.length) {
+ callback();
+ }
+ var batch = [];
+ batch.push({
+ key: metadata.id,
+ value: metadata,
+ type: 'put',
+ valueEncoding: 'json',
+ prefix: stores.docStore
+ });
+ revs.forEach(function (rev) {
+ var seq = seqs[rev];
+ if (!seq) {
+ return;
+ }
+ batch.push({
+ key: formatSeq(seq),
+ type: 'del',
+ prefix: stores.bySeqStore
+ });
+ });
+ db.batch(batch, callback);
+ });
+ };
+
+ api._getLocal = function (id, callback) {
+ stores.localStore.get(id, function (err, doc) {
+ if (err) {
+ callback(errors.MISSING_DOC);
+ } else {
+ callback(null, doc);
+ }
+ });
+ };
+
+ api._putLocal = function (doc, callback) {
+ var oldRev = doc._rev;
+ var id = doc._id;
+ stores.localStore.get(id, function (err, resp) {
+ if (err) {
+ if (oldRev) {
+ return callback(errors.REV_CONFLICT);
+ }
+ }
+ if (resp && resp._rev !== oldRev) {
+ return callback(errors.REV_CONFLICT);
+ }
+ if (!oldRev) {
+ doc._rev = '0-0';
+ } else {
+ doc._rev = '0-' + (parseInt(oldRev.split('-')[1], 10) + 1);
+ }
+ stores.localStore.put(id, doc, function (err) {
+ if (err) {
+ return callback(err);
+ }
+ var ret = {ok: true, id: doc._id, rev: doc._rev};
+ callback(null, ret);
+ });
+ });
+ };
+
+ api._removeLocal = function (doc, callback) {
+ stores.localStore.get(doc._id, function (err, resp) {
+ if (err) {
+ return callback(err);
+ }
+ if (resp._rev !== doc._rev) {
+ return callback(errors.REV_CONFLICT);
+ }
+ stores.localStore.del(doc._id, function (err) {
+ if (err) {
+ return callback(err);
+ }
+ var ret = {ok: true, id: doc._id, rev: '0-0'};
+ callback(null, ret);
+ });
+ });
+ };
+}
+
+LevelPouch.valid = function () {
+ return process && !process.browser;
+};
+
+// close and delete open leveldb stores
+LevelPouch.destroy = utils.toPromise(function (name, opts, callback) {
+ opts = utils.clone(opts);
+
+ var leveldown = opts.db || originalLeveldown;
+ function callDestroy(name, cb) {
+ if (typeof leveldown.destroy === 'function') {
+ leveldown.destroy(name, cb);
+ } else {
+ process.nextTick(callback);
+ }
+ }
+
+ var dbStore;
+ if (dbStores.has(leveldown.name)) {
+ dbStore = dbStores.get(leveldown.name);
+ } else {
+ return callDestroy(name, callback);
+ }
+
+ if (dbStore.has(name)) {
+
+ LevelPouch.Changes.removeAllListeners(name);
+
+ dbStore.get(name).close(function () {
+ dbStore["delete"](name);
+ callDestroy(name, callback);
+ });
+ } else {
+ callDestroy(name, callback);
+ }
+});
+
+LevelPouch.use_prefix = false;
+
+LevelPouch.Changes = new utils.Changes();
+
+module.exports = LevelPouch;
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer)
+},{"../deps/errors":5,"../deps/migrate":"JpIkFB","../merge":8,"../utils":15,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"level-sublevel":52,"leveldown":"A2RG/S","levelup":66,"through2":122}],2:[function(require,module,exports){
+"use strict";
+
+var createBlob = require('./blob.js');
+var errors = require('./errors');
+var utils = require("../utils");
+var hasUpload;
+
+function ajax(options, adapterCallback) {
+
+ var requestCompleted = false;
+ var callback = utils.getArguments(function (args) {
+ if (requestCompleted) {
+ return;
+ }
+ adapterCallback.apply(this, args);
+ requestCompleted = true;
+ });
+
+ if (typeof options === "function") {
+ callback = options;
+ options = {};
+ }
+
+ options = utils.clone(options);
+
+ var defaultOptions = {
+ method : "GET",
+ headers: {},
+ json: true,
+ processData: true,
+ timeout: 10000,
+ cache: false
+ };
+
+ options = utils.extend(true, defaultOptions, options);
+
+ // cache-buster, specifically designed to work around IE's aggressive caching
+ // see http://www.dashbay.com/2011/05/internet-explorer-caches-ajax/
+ if (options.method === 'GET' && !options.cache) {
+ var hasArgs = options.url.indexOf('?') !== -1;
+ options.url += (hasArgs ? '&' : '?') + '_nonce=' + utils.uuid(16);
+ }
+
+ function onSuccess(obj, resp, cb) {
+ if (!options.binary && !options.json && options.processData &&
+ typeof obj !== 'string') {
+ obj = JSON.stringify(obj);
+ } else if (!options.binary && options.json && typeof obj === 'string') {
+ try {
+ obj = JSON.parse(obj);
+ } catch (e) {
+ // Probably a malformed JSON from server
+ return cb(e);
+ }
+ }
+ if (Array.isArray(obj)) {
+ obj = obj.map(function (v) {
+ var obj;
+ if (v.ok) {
+ return v;
+ } else if (v.error && v.error === 'conflict') {
+ obj = errors.REV_CONFLICT;
+ obj.id = v.id;
+ return obj;
+ } else if (v.error && v.error === 'forbidden') {
+ obj = errors.FORBIDDEN;
+ obj.id = v.id;
+ obj.reason = v.reason;
+ return obj;
+ } else if (v.missing) {
+ obj = errors.MISSING_DOC;
+ obj.missing = v.missing;
+ return obj;
+ } else {
+ return v;
+ }
+ });
+ }
+ cb(null, obj, resp);
+ }
+
+ function onError(err, cb) {
+ var errParsed, errObj, errType, key;
+ try {
+ errParsed = JSON.parse(err.responseText);
+ //would prefer not to have a try/catch clause
+ for (key in errors) {
+ if (errors.hasOwnProperty(key) &&
+ errors[key].name === errParsed.error) {
+ errType = errors[key];
+ break;
+ }
+ }
+ if (!errType) {
+ errType = errors.UNKNOWN_ERROR;
+ if (err.status) {
+ errType.status = err.status;
+ }
+ if (err.statusText) {
+ err.name = err.statusText;
+ }
+ }
+ errObj = errors.error(errType, errParsed.reason);
+ } catch (e) {
+ for (var key in errors) {
+ if (errors.hasOwnProperty(key) && errors[key].status === err.status) {
+ errType = errors[key];
+ break;
+ }
+ }
+ if (!errType) {
+ errType = errors.UNKNOWN_ERROR;
+ if (err.status) {
+ errType.status = err.status;
+ }
+ if (err.statusText) {
+ err.name = err.statusText;
+ }
+ }
+ errObj = errors.error(errType);
+ }
+ if (err.withCredentials && err.status === 0) {
+ // apparently this is what we get when the method
+ // is reported as not allowed by CORS. so fudge it
+ errObj.status = 405;
+ errObj.statusText = "Method Not Allowed";
+ }
+ cb(errObj);
+ }
+
+ var timer;
+ var xhr;
+ if (options.xhr) {
+ xhr = new options.xhr();
+ } else {
+ xhr = new XMLHttpRequest();
+ }
+ xhr.open(options.method, options.url);
+ xhr.withCredentials = true;
+
+ if (options.json) {
+ options.headers.Accept = 'application/json';
+ options.headers['Content-Type'] = options.headers['Content-Type'] ||
+ 'application/json';
+ if (options.body &&
+ options.processData &&
+ typeof options.body !== "string") {
+ options.body = JSON.stringify(options.body);
+ }
+ }
+
+ if (options.binary) {
+ xhr.responseType = 'arraybuffer';
+ }
+
+ var createCookie = function (name, value, days) {
+ var expires = "";
+ if (days) {
+ var date = new Date();
+ date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+ expires = "; expires=" + date.toGMTString();
+ }
+ document.cookie = name + "=" + value + expires + "; path=/";
+ };
+
+ for (var key in options.headers) {
+ if (key === 'Cookie') {
+ var cookie = options.headers[key].split('=');
+ createCookie(cookie[0], cookie[1], 10);
+ } else {
+ xhr.setRequestHeader(key, options.headers[key]);
+ }
+ }
+
+ if (!("body" in options)) {
+ options.body = null;
+ }
+
+ var abortReq = function () {
+ if (requestCompleted) {
+ return;
+ }
+ xhr.abort();
+ onError(xhr, callback);
+ };
+
+ xhr.onreadystatechange = function () {
+ if (xhr.readyState !== 4 || requestCompleted) {
+ return;
+ }
+ clearTimeout(timer);
+ if (xhr.status >= 200 && xhr.status < 300) {
+ var data;
+ if (options.binary) {
+ data = createBlob([xhr.response || ''], {
+ type: xhr.getResponseHeader('Content-Type')
+ });
+ } else {
+ data = xhr.responseText;
+ }
+ onSuccess(data, xhr, callback);
+ } else {
+ onError(xhr, callback);
+ }
+ };
+
+ if (options.timeout > 0) {
+ timer = setTimeout(abortReq, options.timeout);
+ xhr.onprogress = function () {
+ clearTimeout(timer);
+ timer = setTimeout(abortReq, options.timeout);
+ };
+ if (typeof hasUpload === 'undefined') {
+ // IE throws an error if you try to access it directly
+ hasUpload = Object.keys(xhr).indexOf('upload') !== -1;
+ }
+ if (hasUpload) { // does not exist in ie9
+ xhr.upload.onprogress = xhr.onprogress;
+ }
+ }
+ if (options.body && (options.body instanceof Blob)) {
+ var reader = new FileReader();
+ reader.onloadend = function (e) {
+
+ var binary = "";
+ var bytes = new Uint8Array(this.result);
+ var length = bytes.byteLength;
+
+ for (var i = 0; i < length; i++) {
+ binary += String.fromCharCode(bytes[i]);
+ }
+
+ binary = utils.fixBinary(binary);
+ xhr.send(binary);
+ };
+ reader.readAsArrayBuffer(options.body);
+ } else {
+ xhr.send(options.body);
+ }
+ return {abort: abortReq};
+}
+
+module.exports = ajax;
+
+},{"../utils":15,"./blob.js":3,"./errors":5}],3:[function(require,module,exports){
+(function (global){
+"use strict";
+
+//Abstracts constructing a Blob object, so it also works in older
+//browsers that don't support the native Blob constructor. (i.e.
+//old QtWebKit versions, at least).
+function createBlob(parts, properties) {
+ parts = parts || [];
+ properties = properties || {};
+ try {
+ return new Blob(parts, properties);
+ } catch (e) {
+ if (e.name !== "TypeError") {
+ throw e;
+ }
+ var BlobBuilder = global.BlobBuilder ||
+ global.MSBlobBuilder ||
+ global.MozBlobBuilder ||
+ global.WebKitBlobBuilder;
+ var builder = new BlobBuilder();
+ for (var i = 0; i < parts.length; i += 1) {
+ builder.append(parts[i]);
+ }
+ return builder.getBlob(properties.type);
+ }
+}
+
+module.exports = createBlob;
+
+
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],4:[function(require,module,exports){
+'use strict';
+exports.Map = LazyMap; // TODO: use ES6 map
+exports.Set = LazySet; // TODO: use ES6 set
+// based on https://github.com/montagejs/collections
+function LazyMap() {
+ this.store = {};
+}
+LazyMap.prototype.mangle = function (key) {
+ if (typeof key !== "string") {
+ throw new TypeError("key must be a string but Got " + key);
+ }
+ return '$' + key;
+};
+LazyMap.prototype.unmangle = function (key) {
+ return key.substring(1);
+};
+LazyMap.prototype.get = function (key) {
+ var mangled = this.mangle(key);
+ if (mangled in this.store) {
+ return this.store[mangled];
+ } else {
+ return void 0;
+ }
+};
+LazyMap.prototype.set = function (key, value) {
+ var mangled = this.mangle(key);
+ this.store[mangled] = value;
+ return true;
+};
+LazyMap.prototype.has = function (key) {
+ var mangled = this.mangle(key);
+ return mangled in this.store;
+};
+LazyMap.prototype["delete"] = function (key) {
+ var mangled = this.mangle(key);
+ if (mangled in this.store) {
+ delete this.store[mangled];
+ return true;
+ }
+ return false;
+};
+LazyMap.prototype.forEach = function (cb) {
+ var self = this;
+ var keys = Object.keys(self.store);
+ keys.forEach(function (key) {
+ var value = self.store[key];
+ key = self.unmangle(key);
+ cb(value, key);
+ });
+};
+
+function LazySet() {
+ this.store = new LazyMap();
+}
+LazySet.prototype.add = function (key) {
+ return this.store.set(key, true);
+};
+LazySet.prototype.has = function (key) {
+ return this.store.has(key);
+};
+LazySet.prototype["delete"] = function (key) {
+ return this.store["delete"](key);
+};
+},{}],5:[function(require,module,exports){
+"use strict";
+
+function PouchError(opts) {
+ this.status = opts.status;
+ this.name = opts.error;
+ this.message = opts.reason;
+ this.error = true;
+}
+
+PouchError.prototype__proto__ = Error.prototype;
+
+PouchError.prototype.toString = function () {
+ return JSON.stringify({
+ status: this.status,
+ name: this.name,
+ message: this.message
+ });
+};
+
+exports.UNAUTHORIZED = new PouchError({
+ status: 401,
+ error: 'unauthorized',
+ reason: "Name or password is incorrect."
+});
+exports.MISSING_BULK_DOCS = new PouchError({
+ status: 400,
+ error: 'bad_request',
+ reason: "Missing JSON list of 'docs'"
+});
+exports.MISSING_DOC = new PouchError({
+ status: 404,
+ error: 'not_found',
+ reason: 'missing'
+});
+exports.REV_CONFLICT = new PouchError({
+ status: 409,
+ error: 'conflict',
+ reason: 'Document update conflict'
+});
+exports.INVALID_ID = new PouchError({
+ status: 400,
+ error: 'invalid_id',
+ reason: '_id field must contain a string'
+});
+exports.MISSING_ID = new PouchError({
+ status: 412,
+ error: 'missing_id',
+ reason: '_id is required for puts'
+});
+exports.RESERVED_ID = new PouchError({
+ status: 400,
+ error: 'bad_request',
+ reason: 'Only reserved document ids may start with underscore.'
+});
+exports.NOT_OPEN = new PouchError({
+ status: 412,
+ error: 'precondition_failed',
+ reason: 'Database not open'
+});
+exports.UNKNOWN_ERROR = new PouchError({
+ status: 500,
+ error: 'unknown_error',
+ reason: 'Database encountered an unknown error'
+});
+exports.BAD_ARG = new PouchError({
+ status: 500,
+ error: 'badarg',
+ reason: 'Some query argument is invalid'
+});
+exports.INVALID_REQUEST = new PouchError({
+ status: 400,
+ error: 'invalid_request',
+ reason: 'Request was invalid'
+});
+exports.QUERY_PARSE_ERROR = new PouchError({
+ status: 400,
+ error: 'query_parse_error',
+ reason: 'Some query parameter is invalid'
+});
+exports.DOC_VALIDATION = new PouchError({
+ status: 500,
+ error: 'doc_validation',
+ reason: 'Bad special document member'
+});
+exports.BAD_REQUEST = new PouchError({
+ status: 400,
+ error: 'bad_request',
+ reason: 'Something wrong with the request'
+});
+exports.NOT_AN_OBJECT = new PouchError({
+ status: 400,
+ error: 'bad_request',
+ reason: 'Document must be a JSON object'
+});
+exports.DB_MISSING = new PouchError({
+ status: 404,
+ error: 'not_found',
+ reason: 'Database not found'
+});
+exports.IDB_ERROR = new PouchError({
+ status: 500,
+ error: 'indexed_db_went_bad',
+ reason: 'unknown'
+});
+exports.WSQ_ERROR = new PouchError({
+ status: 500,
+ error: 'web_sql_went_bad',
+ reason: 'unknown'
+});
+exports.LDB_ERROR = new PouchError({
+ status: 500,
+ error: 'levelDB_went_went_bad',
+ reason: 'unknown'
+});
+exports.FORBIDDEN = new PouchError({
+ status: 403,
+ error: 'forbidden',
+ reason: 'Forbidden by design doc validate_doc_update function'
+});
+exports.error = function (error, reason, name) {
+ function CustomPouchError(msg) {
+ this.message = reason;
+ if (name) {
+ this.name = name;
+ }
+ }
+ CustomPouchError.prototype = error;
+ return new CustomPouchError(reason);
+};
+
+},{}],6:[function(require,module,exports){
+(function (process,global){
+'use strict';
+
+var crypto = require('crypto');
+var Md5 = require('spark-md5');
+var setImmediateShim = global.setImmediate || global.setTimeout;
+
+function sliceShim(arrayBuffer, begin, end) {
+ if (typeof arrayBuffer.slice === 'function') {
+ return arrayBuffer.slice(begin, end);
+ }
+ //
+ // shim for IE courtesy of http://stackoverflow.com/a/21440217
+ //
+
+ //If `begin`/`end` is unspecified, Chrome assumes 0, so we do the same
+ //Chrome also converts the values to integers via flooring
+ begin = Math.floor(begin || 0);
+ end = Math.floor(end || 0);
+
+ var len = arrayBuffer.byteLength;
+
+ //If either `begin` or `end` is negative, it refers to an
+ //index from the end of the array, as opposed to from the beginning.
+ //The range specified by the `begin` and `end` values is clamped to the
+ //valid index range for the current array.
+ begin = begin < 0 ? Math.max(begin + len, 0) : Math.min(len, begin);
+ end = end < 0 ? Math.max(end + len, 0) : Math.min(len, end);
+
+ //If the computed length of the new ArrayBuffer would be negative, it
+ //is clamped to zero.
+ if (end - begin <= 0) {
+ return new ArrayBuffer(0);
+ }
+
+ var result = new ArrayBuffer(end - begin);
+ var resultBytes = new Uint8Array(result);
+ var sourceBytes = new Uint8Array(arrayBuffer, begin, end - begin);
+
+ resultBytes.set(sourceBytes);
+
+ return result;
+}
+
+module.exports = function (data, callback) {
+ if (!process.browser) {
+ callback(null, crypto.createHash('md5').update(data).digest('hex'));
+ return;
+ }
+ var chunkSize = Math.min(524288, data.length);
+ var chunks = Math.ceil(data.length / chunkSize);
+ var currentChunk = 0;
+ var buffer = new Md5();
+ function loadNextChunk() {
+ var start = currentChunk * chunkSize;
+ var end = start + chunkSize;
+ if ((start + chunkSize) >= data.size) {
+ end = data.size;
+ }
+ currentChunk++;
+ if (currentChunk < chunks) {
+ buffer.append(sliceShim(data, start, end));
+ setImmediateShim(loadNextChunk);
+ } else {
+ buffer.append(sliceShim(data, start, end));
+ callback(null, buffer.end());
+ buffer.destroy();
+ }
+ }
+ loadNextChunk();
+};
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"crypto":17,"spark-md5":107}],7:[function(require,module,exports){
+"use strict";
+
+// BEGIN Math.uuid.js
+
+/*!
+Math.uuid.js (v1.4)
+http://www.broofa.com
+mailto:robert@broofa.com
+
+Copyright (c) 2010 Robert Kieffer
+Dual licensed under the MIT and GPL licenses.
+*/
+
+/*
+ * Generate a random uuid.
+ *
+ * USAGE: Math.uuid(length, radix)
+ * length - the desired number of characters
+ * radix - the number of allowable values for each character.
+ *
+ * EXAMPLES:
+ * // No arguments - returns RFC4122, version 4 ID
+ * >>> Math.uuid()
+ * "92329D39-6F5C-4520-ABFC-AAB64544E172"
+ *
+ * // One argument - returns ID of the specified length
+ * >>> Math.uuid(15) // 15 character ID (default base=62)
+ * "VcydxgltxrVZSTV"
+ *
+ * // Two arguments - returns ID of the specified length, and radix.
+ * // (Radix must be <= 62)
+ * >>> Math.uuid(8, 2) // 8 character ID (base=2)
+ * "01001010"
+ * >>> Math.uuid(8, 10) // 8 character ID (base=10)
+ * "47473046"
+ * >>> Math.uuid(8, 16) // 8 character ID (base=16)
+ * "098F4D35"
+ */
+var chars = (
+ '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ' +
+ 'abcdefghijklmnopqrstuvwxyz'
+).split('');
+function getValue(radix) {
+ return 0 | Math.random() * radix;
+}
+function uuid(len, radix) {
+ radix = radix || chars.length;
+ var out = '';
+ var i = -1;
+
+ if (len) {
+ // Compact form
+ while (++i < len) {
+ out += chars[getValue(radix)];
+ }
+ return out;
+ }
+ // rfc4122, version 4 form
+ // Fill in random data. At i==19 set the high bits of clock sequence as
+ // per rfc4122, sec. 4.1.5
+ while (++i < 36) {
+ switch (i) {
+ case 8:
+ case 13:
+ case 18:
+ case 23:
+ out += '-';
+ break;
+ case 19:
+ out += chars[(getValue(16) & 0x3) | 0x8];
+ break;
+ default:
+ out += chars[getValue(16)];
+ }
+ }
+
+ return out;
+}
+
+
+
+module.exports = uuid;
+
+
+},{}],8:[function(require,module,exports){
+'use strict';
+var extend = require('pouchdb-extend');
+
+
+// for a better overview of what this is doing, read:
+// https://github.com/apache/couchdb/blob/master/src/couchdb/couch_key_tree.erl
+//
+// But for a quick intro, CouchDB uses a revision tree to store a documents
+// history, A -> B -> C, when a document has conflicts, that is a branch in the
+// tree, A -> (B1 | B2 -> C), We store these as a nested array in the format
+//
+// KeyTree = [Path ... ]
+// Path = {pos: position_from_root, ids: Tree}
+// Tree = [Key, Opts, [Tree, ...]], in particular single node: [Key, []]
+
+// Turn a path as a flat array into a tree with a single branch
+function pathToTree(path) {
+ var doc = path.shift();
+ var root = [doc.id, doc.opts, []];
+ var leaf = root;
+ var nleaf;
+
+ while (path.length) {
+ doc = path.shift();
+ nleaf = [doc.id, doc.opts, []];
+ leaf[2].push(nleaf);
+ leaf = nleaf;
+ }
+ return root;
+}
+
+// Merge two trees together
+// The roots of tree1 and tree2 must be the same revision
+function mergeTree(in_tree1, in_tree2) {
+ var queue = [{tree1: in_tree1, tree2: in_tree2}];
+ var conflicts = false;
+ while (queue.length > 0) {
+ var item = queue.pop();
+ var tree1 = item.tree1;
+ var tree2 = item.tree2;
+
+ if (tree1[1].status || tree2[1].status) {
+ tree1[1].status =
+ (tree1[1].status === 'available' ||
+ tree2[1].status === 'available') ? 'available' : 'missing';
+ }
+
+ for (var i = 0; i < tree2[2].length; i++) {
+ if (!tree1[2][0]) {
+ conflicts = 'new_leaf';
+ tree1[2][0] = tree2[2][i];
+ continue;
+ }
+
+ var merged = false;
+ for (var j = 0; j < tree1[2].length; j++) {
+ if (tree1[2][j][0] === tree2[2][i][0]) {
+ queue.push({tree1: tree1[2][j], tree2: tree2[2][i]});
+ merged = true;
+ }
+ }
+ if (!merged) {
+ conflicts = 'new_branch';
+ tree1[2].push(tree2[2][i]);
+ tree1[2].sort();
+ }
+ }
+ }
+ return {conflicts: conflicts, tree: in_tree1};
+}
+
+function doMerge(tree, path, dontExpand) {
+ var restree = [];
+ var conflicts = false;
+ var merged = false;
+ var res;
+
+ if (!tree.length) {
+ return {tree: [path], conflicts: 'new_leaf'};
+ }
+
+ tree.forEach(function (branch) {
+ if (branch.pos === path.pos && branch.ids[0] === path.ids[0]) {
+ // Paths start at the same position and have the same root, so they need
+ // merged
+ res = mergeTree(branch.ids, path.ids);
+ restree.push({pos: branch.pos, ids: res.tree});
+ conflicts = conflicts || res.conflicts;
+ merged = true;
+ } else if (dontExpand !== true) {
+ // The paths start at a different position, take the earliest path and
+ // traverse up until it as at the same point from root as the path we
+ // want to merge. If the keys match we return the longer path with the
+ // other merged After stemming we dont want to expand the trees
+
+ var t1 = branch.pos < path.pos ? branch : path;
+ var t2 = branch.pos < path.pos ? path : branch;
+ var diff = t2.pos - t1.pos;
+
+ var candidateParents = [];
+
+ var trees = [];
+ trees.push({ids: t1.ids, diff: diff, parent: null, parentIdx: null});
+ while (trees.length > 0) {
+ var item = trees.pop();
+ if (item.diff === 0) {
+ if (item.ids[0] === t2.ids[0]) {
+ candidateParents.push(item);
+ }
+ continue;
+ }
+ if (!item.ids) {
+ continue;
+ }
+ /*jshint loopfunc:true */
+ item.ids[2].forEach(function (el, idx) {
+ trees.push(
+ {ids: el, diff: item.diff - 1, parent: item.ids, parentIdx: idx});
+ });
+ }
+
+ var el = candidateParents[0];
+
+ if (!el) {
+ restree.push(branch);
+ } else {
+ res = mergeTree(el.ids, t2.ids);
+ el.parent[2][el.parentIdx] = res.tree;
+ restree.push({pos: t1.pos, ids: t1.ids});
+ conflicts = conflicts || res.conflicts;
+ merged = true;
+ }
+ } else {
+ restree.push(branch);
+ }
+ });
+
+ // We didnt find
+ if (!merged) {
+ restree.push(path);
+ }
+
+ restree.sort(function (a, b) {
+ return a.pos - b.pos;
+ });
+
+ return {
+ tree: restree,
+ conflicts: conflicts || 'internal_node'
+ };
+}
+
+// To ensure we dont grow the revision tree infinitely, we stem old revisions
+function stem(tree, depth) {
+ // First we break out the tree into a complete list of root to leaf paths,
+ // we cut off the start of the path and generate a new set of flat trees
+ var stemmedPaths = PouchMerge.rootToLeaf(tree).map(function (path) {
+ var stemmed = path.ids.slice(-depth);
+ return {
+ pos: path.pos + (path.ids.length - stemmed.length),
+ ids: pathToTree(stemmed)
+ };
+ });
+ // Then we remerge all those flat trees together, ensuring that we dont
+ // connect trees that would go beyond the depth limit
+ return stemmedPaths.reduce(function (prev, current, i, arr) {
+ return doMerge(prev, current, true).tree;
+ }, [stemmedPaths.shift()]);
+}
+
+var PouchMerge = {};
+
+PouchMerge.merge = function (tree, path, depth) {
+ // Ugh, nicer way to not modify arguments in place?
+ tree = extend(true, [], tree);
+ path = extend(true, {}, path);
+ var newTree = doMerge(tree, path);
+ return {
+ tree: stem(newTree.tree, depth),
+ conflicts: newTree.conflicts
+ };
+};
+
+// We fetch all leafs of the revision tree, and sort them based on tree length
+// and whether they were deleted, undeleted documents with the longest revision
+// tree (most edits) win
+// The final sort algorithm is slightly documented in a sidebar here:
+// http://guide.couchdb.org/draft/conflicts.html
+PouchMerge.winningRev = function (metadata) {
+ var leafs = [];
+ PouchMerge.traverseRevTree(metadata.rev_tree,
+ function (isLeaf, pos, id, something, opts) {
+ if (isLeaf) {
+ leafs.push({pos: pos, id: id, deleted: !!opts.deleted});
+ }
+ });
+ leafs.sort(function (a, b) {
+ if (a.deleted !== b.deleted) {
+ return a.deleted > b.deleted ? 1 : -1;
+ }
+ if (a.pos !== b.pos) {
+ return b.pos - a.pos;
+ }
+ return a.id < b.id ? 1 : -1;
+ });
+
+ return leafs[0].pos + '-' + leafs[0].id;
+};
+
+// Pretty much all below can be combined into a higher order function to
+// traverse revisions
+// The return value from the callback will be passed as context to all
+// children of that node
+PouchMerge.traverseRevTree = function (revs, callback) {
+ var toVisit = revs.slice();
+
+ var node;
+ while ((node = toVisit.pop())) {
+ var pos = node.pos;
+ var tree = node.ids;
+ var branches = tree[2];
+ var newCtx =
+ callback(branches.length === 0, pos, tree[0], node.ctx, tree[1]);
+ for (var i = 0, len = branches.length; i < len; i++) {
+ toVisit.push({pos: pos + 1, ids: branches[i], ctx: newCtx});
+ }
+ }
+};
+
+PouchMerge.collectLeaves = function (revs) {
+ var leaves = [];
+ PouchMerge.traverseRevTree(revs, function (isLeaf, pos, id, acc, opts) {
+ if (isLeaf) {
+ leaves.unshift({rev: pos + "-" + id, pos: pos, opts: opts});
+ }
+ });
+ leaves.sort(function (a, b) {
+ return b.pos - a.pos;
+ });
+ leaves.map(function (leaf) { delete leaf.pos; });
+ return leaves;
+};
+
+// returns revs of all conflicts that is leaves such that
+// 1. are not deleted and
+// 2. are different than winning revision
+PouchMerge.collectConflicts = function (metadata) {
+ var win = PouchMerge.winningRev(metadata);
+ var leaves = PouchMerge.collectLeaves(metadata.rev_tree);
+ var conflicts = [];
+ leaves.forEach(function (leaf) {
+ if (leaf.rev !== win && !leaf.opts.deleted) {
+ conflicts.push(leaf.rev);
+ }
+ });
+ return conflicts;
+};
+
+PouchMerge.rootToLeaf = function (tree) {
+ var paths = [];
+ PouchMerge.traverseRevTree(tree, function (isLeaf, pos, id, history, opts) {
+ history = history ? history.slice(0) : [];
+ history.push({id: id, opts: opts});
+ if (isLeaf) {
+ var rootPos = pos + 1 - history.length;
+ paths.unshift({pos: rootPos, ids: history});
+ }
+ return history;
+ });
+ return paths;
+};
+
+
+module.exports = PouchMerge;
+
+},{"pouchdb-extend":106}],"adapter-config":[function(require,module,exports){
+module.exports=require('QLOuoD');
+},{}],"QLOuoD":[function(require,module,exports){
+'use strict';
+
+module.exports = {
+ name: 'idb-alt',
+ valid: function () {
+ return 'idb' in window.PouchDB.adapters &&
+ window.PouchDB.adapters.idb.valid();
+ },
+ use_prefix: true
+};
+},{}],11:[function(require,module,exports){
+"use strict";
+
+var adapterConfig = require('adapter-config');
+var adapterName = adapterConfig.name;
+var adapter = require('./levelalt');
+
+window.PouchDB.adapter(adapterName, adapter);
+window.PouchDB.preferredAdapters.push(adapterName);
+
+},{"./levelalt":12,"adapter-config":"QLOuoD"}],12:[function(require,module,exports){
+'use strict';
+
+var LevelPouch = require('../adapters/leveldb');
+var leveldown = require('leveldown');
+var adapterConfig = require('adapter-config');
+var utils = require('../utils');
+
+function LevelPouchAlt(opts, callback) {
+ var _opts = utils.extend({
+ db: leveldown
+ }, opts);
+
+ LevelPouch.call(this, _opts, callback);
+}
+
+// overrides for normal LevelDB behavior on Node
+LevelPouchAlt.valid = function () {
+ return adapterConfig.valid();
+};
+LevelPouchAlt.use_prefix = adapterConfig.use_prefix;
+
+LevelPouchAlt.destroy = utils.toPromise(function (name, opts, callback) {
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ var _opts = utils.extend({
+ db: leveldown
+ }, opts);
+
+ return LevelPouch.destroy(name, _opts, callback);
+});
+
+module.exports = LevelPouchAlt;
+
+},{"../adapters/leveldb":1,"../utils":15,"adapter-config":"QLOuoD","leveldown":"A2RG/S"}],"JpIkFB":[function(require,module,exports){
+(function (process){
+'use strict';
+// LevelAlt doesn't need the pre-2.2.0 LevelDB-specific migrations
+exports.toSublevel = function (name, db, callback) {
+ process.nextTick(function () {
+ callback();
+ });
+};
+
+exports.localAndMetaStores = function (db, stores, callback) {
+ process.nextTick(function () {
+ callback();
+ });
+};
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],"../adapters/../deps/migrate":[function(require,module,exports){
+module.exports=require('JpIkFB');
+},{}],15:[function(require,module,exports){
+(function (process,global){
+/*jshint strict: false */
+/*global chrome */
+var merge = require('./merge');
+exports.extend = require('pouchdb-extend');
+exports.ajax = require('./deps/ajax');
+exports.createBlob = require('./deps/blob');
+exports.uuid = require('./deps/uuid');
+exports.getArguments = require('argsarray');
+var buffer = require('./deps/buffer');
+var errors = require('./deps/errors');
+var EventEmitter = require('events').EventEmitter;
+var collections = require('./deps/collections');
+exports.Map = collections.Map;
+exports.Set = collections.Set;
+
+if (typeof global.Promise === 'function') {
+ exports.Promise = global.Promise;
+} else {
+ exports.Promise = require('bluebird');
+}
+var Promise = exports.Promise;
+
+function toObject(array) {
+ var obj = {};
+ array.forEach(function (item) { obj[item] = true; });
+ return obj;
+}
+// List of top level reserved words for doc
+var reservedWords = toObject([
+ '_id',
+ '_rev',
+ '_attachments',
+ '_deleted',
+ '_revisions',
+ '_revs_info',
+ '_conflicts',
+ '_deleted_conflicts',
+ '_local_seq',
+ '_rev_tree',
+ //replication documents
+ '_replication_id',
+ '_replication_state',
+ '_replication_state_time',
+ '_replication_state_reason',
+ '_replication_stats'
+]);
+exports.clone = function (obj) {
+ return exports.extend(true, {}, obj);
+};
+exports.inherits = require('inherits');
+// Determine id an ID is valid
+// - invalid IDs begin with an underescore that does not begin '_design' or
+// '_local'
+// - any other string value is a valid id
+// Returns the specific error object for each case
+exports.invalidIdError = function (id) {
+ var err;
+ if (!id) {
+ err = new TypeError(errors.MISSING_ID.message);
+ err.status = 412;
+ } else if (typeof id !== 'string') {
+ err = new TypeError(errors.INVALID_ID.message);
+ err.status = 400;
+ } else if (/^_/.test(id) && !(/^_(design|local)/).test(id)) {
+ err = new TypeError(errors.RESERVED_ID.message);
+ err.status = 400;
+ }
+ if (err) {
+ throw err;
+ }
+};
+
+function isChromeApp() {
+ return (typeof chrome !== "undefined" &&
+ typeof chrome.storage !== "undefined" &&
+ typeof chrome.storage.local !== "undefined");
+}
+
+// Pretty dumb name for a function, just wraps callback calls so we dont
+// to if (callback) callback() everywhere
+exports.call = exports.getArguments(function (args) {
+ if (!args.length) {
+ return;
+ }
+ var fun = args.shift();
+ if (typeof fun === 'function') {
+ fun.apply(this, args);
+ }
+});
+
+exports.isLocalId = function (id) {
+ return (/^_local/).test(id);
+};
+
+// check if a specific revision of a doc has been deleted
+// - metadata: the metadata object from the doc store
+// - rev: (optional) the revision to check. defaults to winning revision
+exports.isDeleted = function (metadata, rev) {
+ if (!rev) {
+ rev = merge.winningRev(metadata);
+ }
+ var dashIndex = rev.indexOf('-');
+ if (dashIndex !== -1) {
+ rev = rev.substring(dashIndex + 1);
+ }
+ var deleted = false;
+ merge.traverseRevTree(metadata.rev_tree,
+ function (isLeaf, pos, id, acc, opts) {
+ if (id === rev) {
+ deleted = !!opts.deleted;
+ }
+ });
+
+ return deleted;
+};
+
+exports.filterChange = function (opts) {
+ return function (change) {
+ var req = {};
+ var hasFilter = opts.filter && typeof opts.filter === 'function';
+
+ req.query = opts.query_params;
+ if (opts.filter && hasFilter && !opts.filter.call(this, change.doc, req)) {
+ return false;
+ }
+ if (opts.doc_ids && opts.doc_ids.indexOf(change.id) === -1) {
+ return false;
+ }
+ if (!opts.include_docs) {
+ delete change.doc;
+ } else {
+ for (var att in change.doc._attachments) {
+ if (change.doc._attachments.hasOwnProperty(att)) {
+ change.doc._attachments[att].stub = true;
+ }
+ }
+ }
+ return true;
+ };
+};
+
+// Preprocess documents, parse their revisions, assign an id and a
+// revision for new writes that are missing them, etc
+exports.parseDoc = function (doc, newEdits) {
+ var nRevNum;
+ var newRevId;
+ var revInfo;
+ var error;
+ var opts = {status: 'available'};
+ if (doc._deleted) {
+ opts.deleted = true;
+ }
+
+ if (newEdits) {
+ if (!doc._id) {
+ doc._id = exports.uuid();
+ }
+ newRevId = exports.uuid(32, 16).toLowerCase();
+ if (doc._rev) {
+ revInfo = /^(\d+)-(.+)$/.exec(doc._rev);
+ if (!revInfo) {
+ var err = new TypeError("invalid value for property '_rev'");
+ err.status = 400;
+ }
+ doc._rev_tree = [{
+ pos: parseInt(revInfo[1], 10),
+ ids: [revInfo[2], {status: 'missing'}, [[newRevId, opts, []]]]
+ }];
+ nRevNum = parseInt(revInfo[1], 10) + 1;
+ } else {
+ doc._rev_tree = [{
+ pos: 1,
+ ids : [newRevId, opts, []]
+ }];
+ nRevNum = 1;
+ }
+ } else {
+ if (doc._revisions) {
+ doc._rev_tree = [{
+ pos: doc._revisions.start - doc._revisions.ids.length + 1,
+ ids: doc._revisions.ids.reduce(function (acc, x) {
+ if (acc === null) {
+ return [x, opts, []];
+ } else {
+ return [x, {status: 'missing'}, [acc]];
+ }
+ }, null)
+ }];
+ nRevNum = doc._revisions.start;
+ newRevId = doc._revisions.ids[0];
+ }
+ if (!doc._rev_tree) {
+ revInfo = /^(\d+)-(.+)$/.exec(doc._rev);
+ if (!revInfo) {
+ error = new TypeError(errors.BAD_ARG.message);
+ error.status = errors.BAD_ARG.status;
+ throw error;
+ }
+ nRevNum = parseInt(revInfo[1], 10);
+ newRevId = revInfo[2];
+ doc._rev_tree = [{
+ pos: parseInt(revInfo[1], 10),
+ ids: [revInfo[2], opts, []]
+ }];
+ }
+ }
+
+ exports.invalidIdError(doc._id);
+
+ doc._id = decodeURIComponent(doc._id);
+ doc._rev = [nRevNum, newRevId].join('-');
+
+ var result = {metadata : {}, data : {}};
+ for (var key in doc) {
+ if (doc.hasOwnProperty(key)) {
+ var specialKey = key[0] === '_';
+ if (specialKey && !reservedWords[key]) {
+ error = new Error(errors.DOC_VALIDATION.message + ': ' + key);
+ error.status = errors.DOC_VALIDATION.status;
+ throw error;
+ } else if (specialKey && key !== '_attachments') {
+ result.metadata[key.slice(1)] = doc[key];
+ } else {
+ result.data[key] = doc[key];
+ }
+ }
+ }
+ return result;
+};
+
+exports.isCordova = function () {
+ return (typeof cordova !== "undefined" ||
+ typeof PhoneGap !== "undefined" ||
+ typeof phonegap !== "undefined");
+};
+
+exports.hasLocalStorage = function () {
+ if (isChromeApp()) {
+ return false;
+ }
+ try {
+ return global.localStorage;
+ } catch (e) {
+ return false;
+ }
+};
+exports.Changes = Changes;
+exports.inherits(Changes, EventEmitter);
+function Changes() {
+ if (!(this instanceof Changes)) {
+ return new Changes();
+ }
+ var self = this;
+ EventEmitter.call(this);
+ this.isChrome = isChromeApp();
+ this.listeners = {};
+ this.hasLocal = false;
+ if (!this.isChrome) {
+ this.hasLocal = exports.hasLocalStorage();
+ }
+ if (this.isChrome) {
+ chrome.storage.onChanged.addListener(function (e) {
+ // make sure it's event addressed to us
+ if (e.db_name != null) {
+ //object only has oldValue, newValue members
+ self.emit(e.dbName.newValue);
+ }
+ });
+ } else if (this.hasLocal) {
+ if (global.addEventListener) {
+ global.addEventListener("storage", function (e) {
+ self.emit(e.key);
+ });
+ } else {
+ global.attachEvent("storage", function (e) {
+ self.emit(e.key);
+ });
+ }
+ }
+
+}
+Changes.prototype.addListener = function (dbName, id, db, opts) {
+ if (this.listeners[id]) {
+ return;
+ }
+ function eventFunction() {
+ db.changes({
+ include_docs: opts.include_docs,
+ conflicts: opts.conflicts,
+ continuous: false,
+ descending: false,
+ filter: opts.filter,
+ view: opts.view,
+ since: opts.since,
+ query_params: opts.query_params,
+ onChange: function (c) {
+ if (c.seq > opts.since && !opts.cancelled) {
+ opts.since = c.seq;
+ exports.call(opts.onChange, c);
+ }
+ }
+ });
+ }
+ this.listeners[id] = eventFunction;
+ this.on(dbName, eventFunction);
+};
+
+Changes.prototype.removeListener = function (dbName, id) {
+ if (!(id in this.listeners)) {
+ return;
+ }
+ EventEmitter.prototype.removeListener.call(this, dbName,
+ this.listeners[id]);
+};
+
+
+Changes.prototype.notifyLocalWindows = function (dbName) {
+ //do a useless change on a storage thing
+ //in order to get other windows's listeners to activate
+ if (this.isChrome) {
+ chrome.storage.local.set({dbName: dbName});
+ } else if (this.hasLocal) {
+ localStorage[dbName] = (localStorage[dbName] === "a") ? "b" : "a";
+ }
+};
+
+Changes.prototype.notify = function (dbName) {
+ this.emit(dbName);
+ this.notifyLocalWindows(dbName);
+};
+
+if (!process.browser || !('atob' in global)) {
+ exports.atob = function (str) {
+ var base64 = new buffer(str, 'base64');
+ // Node.js will just skip the characters it can't encode instead of
+ // throwing and exception
+ if (base64.toString('base64') !== str) {
+ throw ("Cannot base64 encode full string");
+ }
+ return base64.toString('binary');
+ };
+} else {
+ exports.atob = function (str) {
+ return atob(str);
+ };
+}
+
+if (!process.browser || !('btoa' in global)) {
+ exports.btoa = function (str) {
+ return new buffer(str, 'binary').toString('base64');
+ };
+} else {
+ exports.btoa = function (str) {
+ return btoa(str);
+ };
+}
+
+// From http://stackoverflow.com/questions/14967647/ (continues on next line)
+// encode-decode-image-with-base64-breaks-image (2013-04-21)
+exports.fixBinary = function (bin) {
+ if (!process.browser) {
+ // don't need to do this in Node
+ return bin;
+ }
+
+ var length = bin.length;
+ var buf = new ArrayBuffer(length);
+ var arr = new Uint8Array(buf);
+ for (var i = 0; i < length; i++) {
+ arr[i] = bin.charCodeAt(i);
+ }
+ return buf;
+};
+
+exports.once = function (fun) {
+ var called = false;
+ return exports.getArguments(function (args) {
+ if (called) {
+ if (typeof console.trace === 'function') {
+ console.trace();
+ }
+ throw new Error('once called more than once');
+ } else {
+ called = true;
+ fun.apply(this, args);
+ }
+ });
+};
+
+exports.toPromise = function (func) {
+ //create the function we will be returning
+ return exports.getArguments(function (args) {
+ var self = this;
+ var tempCB =
+ (typeof args[args.length - 1] === 'function') ? args.pop() : false;
+ // if the last argument is a function, assume its a callback
+ var usedCB;
+ if (tempCB) {
+ // if it was a callback, create a new callback which calls it,
+ // but do so async so we don't trap any errors
+ usedCB = function (err, resp) {
+ process.nextTick(function () {
+ tempCB(err, resp);
+ });
+ };
+ }
+ var promise = new Promise(function (fulfill, reject) {
+ var resp;
+ try {
+ var callback = exports.once(function (err, mesg) {
+ if (err) {
+ reject(err);
+ } else {
+ fulfill(mesg);
+ }
+ });
+ // create a callback for this invocation
+ // apply the function in the orig context
+ args.push(callback);
+ resp = func.apply(self, args);
+ if (resp && typeof resp.then === 'function') {
+ fulfill(resp);
+ }
+ } catch (e) {
+ reject(e);
+ }
+ });
+ // if there is a callback, call it back
+ if (usedCB) {
+ promise.then(function (result) {
+ usedCB(null, result);
+ }, usedCB);
+ }
+ promise.cancel = function () {
+ return this;
+ };
+ return promise;
+ });
+};
+
+exports.adapterFun = function (name, callback) {
+ return exports.toPromise(exports.getArguments(function (args) {
+ if (this._closed) {
+ return Promise.reject(new Error('database is closed'));
+ }
+ var self = this;
+ if (!this.taskqueue.isReady) {
+ return new exports.Promise(function (fulfill, reject) {
+ self.taskqueue.addTask(function (failed) {
+ if (failed) {
+ reject(failed);
+ } else {
+ fulfill(self[name].apply(self, args));
+ }
+ });
+ });
+ }
+ return callback.apply(this, args);
+ }));
+};
+//Can't find original post, but this is close
+//http://stackoverflow.com/questions/6965107/ (continues on next line)
+//converting-between-strings-and-arraybuffers
+exports.arrayBufferToBinaryString = function (buffer) {
+ var binary = "";
+ var bytes = new Uint8Array(buffer);
+ var length = bytes.byteLength;
+ for (var i = 0; i < length; i++) {
+ binary += String.fromCharCode(bytes[i]);
+ }
+ return binary;
+};
+
+exports.cancellableFun = function (fun, self, opts) {
+
+ opts = opts ? exports.clone(true, {}, opts) : {};
+
+ var emitter = new EventEmitter();
+ var oldComplete = opts.complete || function () { };
+ var complete = opts.complete = exports.once(function (err, resp) {
+ if (err) {
+ oldComplete(err);
+ } else {
+ emitter.emit('end', resp);
+ oldComplete(null, resp);
+ }
+ emitter.removeAllListeners();
+ });
+ var oldOnChange = opts.onChange || function () {};
+ var lastChange = 0;
+ self.on('destroyed', function () {
+ emitter.removeAllListeners();
+ });
+ opts.onChange = function (change) {
+ oldOnChange(change);
+ if (change.seq <= lastChange) {
+ return;
+ }
+ lastChange = change.seq;
+ emitter.emit('change', change);
+ if (change.deleted) {
+ emitter.emit('delete', change);
+ } else if (change.changes.length === 1 &&
+ change.changes[0].rev.slice(0, 1) === '1-') {
+ emitter.emit('create', change);
+ } else {
+ emitter.emit('update', change);
+ }
+ };
+ var promise = new Promise(function (fulfill, reject) {
+ opts.complete = function (err, res) {
+ if (err) {
+ reject(err);
+ } else {
+ fulfill(res);
+ }
+ };
+ });
+
+ promise.then(function (result) {
+ complete(null, result);
+ }, complete);
+
+ // this needs to be overwridden by caller, dont fire complete until
+ // the task is ready
+ promise.cancel = function () {
+ promise.isCancelled = true;
+ if (self.taskqueue.isReady) {
+ opts.complete(null, {status: 'cancelled'});
+ }
+ };
+
+ if (!self.taskqueue.isReady) {
+ self.taskqueue.addTask(function () {
+ if (promise.isCancelled) {
+ opts.complete(null, {status: 'cancelled'});
+ } else {
+ fun(self, opts, promise);
+ }
+ });
+ } else {
+ fun(self, opts, promise);
+ }
+ promise.on = emitter.on.bind(emitter);
+ promise.once = emitter.once.bind(emitter);
+ promise.addListener = emitter.addListener.bind(emitter);
+ promise.removeListener = emitter.removeListener.bind(emitter);
+ promise.removeAllListeners = emitter.removeAllListeners.bind(emitter);
+ promise.setMaxListeners = emitter.setMaxListeners.bind(emitter);
+ promise.listeners = emitter.listeners.bind(emitter);
+ promise.emit = emitter.emit.bind(emitter);
+ return promise;
+};
+
+exports.MD5 = exports.toPromise(require('./deps/md5'));
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./deps/ajax":2,"./deps/blob":3,"./deps/buffer":17,"./deps/collections":4,"./deps/errors":5,"./deps/md5":6,"./deps/uuid":7,"./merge":8,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"argsarray":16,"bluebird":92,"events":18,"inherits":33,"pouchdb-extend":106}],16:[function(require,module,exports){
+'use strict';
+
+module.exports = argsArray;
+
+function argsArray(fun) {
+ return function () {
+ var len = arguments.length;
+ if (len) {
+ var args = [];
+ var i = -1;
+ while (++i < len) {
+ args[i] = arguments[i];
+ }
+ return fun.call(this, args);
+ } else {
+ return fun.call(this, []);
+ }
+ };
+}
+},{}],17:[function(require,module,exports){
+
+},{}],18:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+function EventEmitter() {
+ this._events = this._events || {};
+ this._maxListeners = this._maxListeners || undefined;
+}
+module.exports = EventEmitter;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+EventEmitter.defaultMaxListeners = 10;
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function(n) {
+ if (!isNumber(n) || n < 0 || isNaN(n))
+ throw TypeError('n must be a positive number');
+ this._maxListeners = n;
+ return this;
+};
+
+EventEmitter.prototype.emit = function(type) {
+ var er, handler, len, args, i, listeners;
+
+ if (!this._events)
+ this._events = {};
+
+ // If there is no 'error' event listener then throw.
+ if (type === 'error') {
+ if (!this._events.error ||
+ (isObject(this._events.error) && !this._events.error.length)) {
+ er = arguments[1];
+ if (er instanceof Error) {
+ throw er; // Unhandled 'error' event
+ } else {
+ throw TypeError('Uncaught, unspecified "error" event.');
+ }
+ return false;
+ }
+ }
+
+ handler = this._events[type];
+
+ if (isUndefined(handler))
+ return false;
+
+ if (isFunction(handler)) {
+ switch (arguments.length) {
+ // fast cases
+ case 1:
+ handler.call(this);
+ break;
+ case 2:
+ handler.call(this, arguments[1]);
+ break;
+ case 3:
+ handler.call(this, arguments[1], arguments[2]);
+ break;
+ // slower
+ default:
+ len = arguments.length;
+ args = new Array(len - 1);
+ for (i = 1; i < len; i++)
+ args[i - 1] = arguments[i];
+ handler.apply(this, args);
+ }
+ } else if (isObject(handler)) {
+ len = arguments.length;
+ args = new Array(len - 1);
+ for (i = 1; i < len; i++)
+ args[i - 1] = arguments[i];
+
+ listeners = handler.slice();
+ len = listeners.length;
+ for (i = 0; i < len; i++)
+ listeners[i].apply(this, args);
+ }
+
+ return true;
+};
+
+EventEmitter.prototype.addListener = function(type, listener) {
+ var m;
+
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ if (!this._events)
+ this._events = {};
+
+ // To avoid recursion in the case that type === "newListener"! Before
+ // adding it to the listeners, first emit "newListener".
+ if (this._events.newListener)
+ this.emit('newListener', type,
+ isFunction(listener.listener) ?
+ listener.listener : listener);
+
+ if (!this._events[type])
+ // Optimize the case of one listener. Don't need the extra array object.
+ this._events[type] = listener;
+ else if (isObject(this._events[type]))
+ // If we've already got an array, just append.
+ this._events[type].push(listener);
+ else
+ // Adding the second element, need to change to array.
+ this._events[type] = [this._events[type], listener];
+
+ // Check for listener leak
+ if (isObject(this._events[type]) && !this._events[type].warned) {
+ var m;
+ if (!isUndefined(this._maxListeners)) {
+ m = this._maxListeners;
+ } else {
+ m = EventEmitter.defaultMaxListeners;
+ }
+
+ if (m && m > 0 && this._events[type].length > m) {
+ this._events[type].warned = true;
+ console.error('(node) warning: possible EventEmitter memory ' +
+ 'leak detected. %d listeners added. ' +
+ 'Use emitter.setMaxListeners() to increase limit.',
+ this._events[type].length);
+ if (typeof console.trace === 'function') {
+ // not supported in IE 10
+ console.trace();
+ }
+ }
+ }
+
+ return this;
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.once = function(type, listener) {
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ var fired = false;
+
+ function g() {
+ this.removeListener(type, g);
+
+ if (!fired) {
+ fired = true;
+ listener.apply(this, arguments);
+ }
+ }
+
+ g.listener = listener;
+ this.on(type, g);
+
+ return this;
+};
+
+// emits a 'removeListener' event iff the listener was removed
+EventEmitter.prototype.removeListener = function(type, listener) {
+ var list, position, length, i;
+
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ if (!this._events || !this._events[type])
+ return this;
+
+ list = this._events[type];
+ length = list.length;
+ position = -1;
+
+ if (list === listener ||
+ (isFunction(list.listener) && list.listener === listener)) {
+ delete this._events[type];
+ if (this._events.removeListener)
+ this.emit('removeListener', type, listener);
+
+ } else if (isObject(list)) {
+ for (i = length; i-- > 0;) {
+ if (list[i] === listener ||
+ (list[i].listener && list[i].listener === listener)) {
+ position = i;
+ break;
+ }
+ }
+
+ if (position < 0)
+ return this;
+
+ if (list.length === 1) {
+ list.length = 0;
+ delete this._events[type];
+ } else {
+ list.splice(position, 1);
+ }
+
+ if (this._events.removeListener)
+ this.emit('removeListener', type, listener);
+ }
+
+ return this;
+};
+
+EventEmitter.prototype.removeAllListeners = function(type) {
+ var key, listeners;
+
+ if (!this._events)
+ return this;
+
+ // not listening for removeListener, no need to emit
+ if (!this._events.removeListener) {
+ if (arguments.length === 0)
+ this._events = {};
+ else if (this._events[type])
+ delete this._events[type];
+ return this;
+ }
+
+ // emit removeListener for all listeners on all events
+ if (arguments.length === 0) {
+ for (key in this._events) {
+ if (key === 'removeListener') continue;
+ this.removeAllListeners(key);
+ }
+ this.removeAllListeners('removeListener');
+ this._events = {};
+ return this;
+ }
+
+ listeners = this._events[type];
+
+ if (isFunction(listeners)) {
+ this.removeListener(type, listeners);
+ } else {
+ // LIFO order
+ while (listeners.length)
+ this.removeListener(type, listeners[listeners.length - 1]);
+ }
+ delete this._events[type];
+
+ return this;
+};
+
+EventEmitter.prototype.listeners = function(type) {
+ var ret;
+ if (!this._events || !this._events[type])
+ ret = [];
+ else if (isFunction(this._events[type]))
+ ret = [this._events[type]];
+ else
+ ret = this._events[type].slice();
+ return ret;
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+ var ret;
+ if (!emitter._events || !emitter._events[type])
+ ret = 0;
+ else if (isFunction(emitter._events[type]))
+ ret = 1;
+ else
+ ret = emitter._events[type].length;
+ return ret;
+};
+
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+
+function isUndefined(arg) {
+ return arg === void 0;
+}
+
+},{}],19:[function(require,module,exports){
+// shim for using process in browser
+
+var process = module.exports = {};
+
+process.nextTick = (function () {
+ var canSetImmediate = typeof window !== 'undefined'
+ && window.setImmediate;
+ var canPost = typeof window !== 'undefined'
+ && window.postMessage && window.addEventListener
+ ;
+
+ if (canSetImmediate) {
+ return function (f) { return window.setImmediate(f) };
+ }
+
+ if (canPost) {
+ var queue = [];
+ window.addEventListener('message', function (ev) {
+ var source = ev.source;
+ if ((source === window || source === null) && ev.data === 'process-tick') {
+ ev.stopPropagation();
+ if (queue.length > 0) {
+ var fn = queue.shift();
+ fn();
+ }
+ }
+ }, true);
+
+ return function nextTick(fn) {
+ queue.push(fn);
+ window.postMessage('process-tick', '*');
+ };
+ }
+
+ return function nextTick(fn) {
+ setTimeout(fn, 0);
+ };
+})();
+
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+
+process.binding = function (name) {
+ throw new Error('process.binding is not supported');
+}
+
+// TODO(shtylman)
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+ throw new Error('process.chdir is not supported');
+};
+
+},{}],20:[function(require,module,exports){
+var base64 = require('base64-js')
+var ieee754 = require('ieee754')
+
+exports.Buffer = Buffer
+exports.SlowBuffer = Buffer
+exports.INSPECT_MAX_BYTES = 50
+Buffer.poolSize = 8192
+
+/**
+ * If `Buffer._useTypedArrays`:
+ * === true Use Uint8Array implementation (fastest)
+ * === false Use Object implementation (compatible down to IE6)
+ */
+Buffer._useTypedArrays = (function () {
+ // Detect if browser supports Typed Arrays. Supported browsers are IE 10+,
+ // Firefox 4+, Chrome 7+, Safari 5.1+, Opera 11.6+, iOS 4.2+.
+ if (typeof Uint8Array === 'undefined' || typeof ArrayBuffer === 'undefined')
+ return false
+
+ // Does the browser support adding properties to `Uint8Array` instances? If
+ // not, then that's the same as no `Uint8Array` support. We need to be able to
+ // add all the node Buffer API methods.
+ // Relevant Firefox bug: https://bugzilla.mozilla.org/show_bug.cgi?id=695438
+ try {
+ var arr = new Uint8Array(0)
+ arr.foo = function () { return 42 }
+ return 42 === arr.foo() &&
+ typeof arr.subarray === 'function' // Chrome 9-10 lack `subarray`
+ } catch (e) {
+ return false
+ }
+})()
+
+/**
+ * Class: Buffer
+ * =============
+ *
+ * The Buffer constructor returns instances of `Uint8Array` that are augmented
+ * with function properties for all the node `Buffer` API functions. We use
+ * `Uint8Array` so that square bracket notation works as expected -- it returns
+ * a single octet.
+ *
+ * By augmenting the instances, we can avoid modifying the `Uint8Array`
+ * prototype.
+ */
+function Buffer (subject, encoding, noZero) {
+ if (!(this instanceof Buffer))
+ return new Buffer(subject, encoding, noZero)
+
+ var type = typeof subject
+
+ // Workaround: node's base64 implementation allows for non-padded strings
+ // while base64-js does not.
+ if (encoding === 'base64' && type === 'string') {
+ subject = stringtrim(subject)
+ while (subject.length % 4 !== 0) {
+ subject = subject + '='
+ }
+ }
+
+ // Find the length
+ var length
+ if (type === 'number')
+ length = coerce(subject)
+ else if (type === 'string')
+ length = Buffer.byteLength(subject, encoding)
+ else if (type === 'object')
+ length = coerce(subject.length) // Assume object is an array
+ else
+ throw new Error('First argument needs to be a number, array or string.')
+
+ var buf
+ if (Buffer._useTypedArrays) {
+ // Preferred: Return an augmented `Uint8Array` instance for best performance
+ buf = augment(new Uint8Array(length))
+ } else {
+ // Fallback: Return THIS instance of Buffer (created by `new`)
+ buf = this
+ buf.length = length
+ buf._isBuffer = true
+ }
+
+ var i
+ if (Buffer._useTypedArrays && typeof Uint8Array === 'function' &&
+ subject instanceof Uint8Array) {
+ // Speed optimization -- use set if we're copying from a Uint8Array
+ buf._set(subject)
+ } else if (isArrayish(subject)) {
+ // Treat array-ish objects as a byte array
+ for (i = 0; i < length; i++) {
+ if (Buffer.isBuffer(subject))
+ buf[i] = subject.readUInt8(i)
+ else
+ buf[i] = subject[i]
+ }
+ } else if (type === 'string') {
+ buf.write(subject, 0, encoding)
+ } else if (type === 'number' && !Buffer._useTypedArrays && !noZero) {
+ for (i = 0; i < length; i++) {
+ buf[i] = 0
+ }
+ }
+
+ return buf
+}
+
+// STATIC METHODS
+// ==============
+
+Buffer.isEncoding = function (encoding) {
+ switch (String(encoding).toLowerCase()) {
+ case 'hex':
+ case 'utf8':
+ case 'utf-8':
+ case 'ascii':
+ case 'binary':
+ case 'base64':
+ case 'raw':
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return true
+ default:
+ return false
+ }
+}
+
+Buffer.isBuffer = function (b) {
+ return !!(b !== null && b !== undefined && b._isBuffer)
+}
+
+Buffer.byteLength = function (str, encoding) {
+ var ret
+ str = str + ''
+ switch (encoding || 'utf8') {
+ case 'hex':
+ ret = str.length / 2
+ break
+ case 'utf8':
+ case 'utf-8':
+ ret = utf8ToBytes(str).length
+ break
+ case 'ascii':
+ case 'binary':
+ case 'raw':
+ ret = str.length
+ break
+ case 'base64':
+ ret = base64ToBytes(str).length
+ break
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ ret = str.length * 2
+ break
+ default:
+ throw new Error('Unknown encoding')
+ }
+ return ret
+}
+
+Buffer.concat = function (list, totalLength) {
+ assert(isArray(list), 'Usage: Buffer.concat(list, [totalLength])\n' +
+ 'list should be an Array.')
+
+ if (list.length === 0) {
+ return new Buffer(0)
+ } else if (list.length === 1) {
+ return list[0]
+ }
+
+ var i
+ if (typeof totalLength !== 'number') {
+ totalLength = 0
+ for (i = 0; i < list.length; i++) {
+ totalLength += list[i].length
+ }
+ }
+
+ var buf = new Buffer(totalLength)
+ var pos = 0
+ for (i = 0; i < list.length; i++) {
+ var item = list[i]
+ item.copy(buf, pos)
+ pos += item.length
+ }
+ return buf
+}
+
+// BUFFER INSTANCE METHODS
+// =======================
+
+function _hexWrite (buf, string, offset, length) {
+ offset = Number(offset) || 0
+ var remaining = buf.length - offset
+ if (!length) {
+ length = remaining
+ } else {
+ length = Number(length)
+ if (length > remaining) {
+ length = remaining
+ }
+ }
+
+ // must be an even number of digits
+ var strLen = string.length
+ assert(strLen % 2 === 0, 'Invalid hex string')
+
+ if (length > strLen / 2) {
+ length = strLen / 2
+ }
+ for (var i = 0; i < length; i++) {
+ var byte = parseInt(string.substr(i * 2, 2), 16)
+ assert(!isNaN(byte), 'Invalid hex string')
+ buf[offset + i] = byte
+ }
+ Buffer._charsWritten = i * 2
+ return i
+}
+
+function _utf8Write (buf, string, offset, length) {
+ var charsWritten = Buffer._charsWritten =
+ blitBuffer(utf8ToBytes(string), buf, offset, length)
+ return charsWritten
+}
+
+function _asciiWrite (buf, string, offset, length) {
+ var charsWritten = Buffer._charsWritten =
+ blitBuffer(asciiToBytes(string), buf, offset, length)
+ return charsWritten
+}
+
+function _binaryWrite (buf, string, offset, length) {
+ return _asciiWrite(buf, string, offset, length)
+}
+
+function _base64Write (buf, string, offset, length) {
+ var charsWritten = Buffer._charsWritten =
+ blitBuffer(base64ToBytes(string), buf, offset, length)
+ return charsWritten
+}
+
+Buffer.prototype.write = function (string, offset, length, encoding) {
+ // Support both (string, offset, length, encoding)
+ // and the legacy (string, encoding, offset, length)
+ if (isFinite(offset)) {
+ if (!isFinite(length)) {
+ encoding = length
+ length = undefined
+ }
+ } else { // legacy
+ var swap = encoding
+ encoding = offset
+ offset = length
+ length = swap
+ }
+
+ offset = Number(offset) || 0
+ var remaining = this.length - offset
+ if (!length) {
+ length = remaining
+ } else {
+ length = Number(length)
+ if (length > remaining) {
+ length = remaining
+ }
+ }
+ encoding = String(encoding || 'utf8').toLowerCase()
+
+ switch (encoding) {
+ case 'hex':
+ return _hexWrite(this, string, offset, length)
+ case 'utf8':
+ case 'utf-8':
+ case 'ucs2': // TODO: No support for ucs2 or utf16le encodings yet
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return _utf8Write(this, string, offset, length)
+ case 'ascii':
+ return _asciiWrite(this, string, offset, length)
+ case 'binary':
+ return _binaryWrite(this, string, offset, length)
+ case 'base64':
+ return _base64Write(this, string, offset, length)
+ default:
+ throw new Error('Unknown encoding')
+ }
+}
+
+Buffer.prototype.toString = function (encoding, start, end) {
+ var self = this
+
+ encoding = String(encoding || 'utf8').toLowerCase()
+ start = Number(start) || 0
+ end = (end !== undefined)
+ ? Number(end)
+ : end = self.length
+
+ // Fastpath empty strings
+ if (end === start)
+ return ''
+
+ switch (encoding) {
+ case 'hex':
+ return _hexSlice(self, start, end)
+ case 'utf8':
+ case 'utf-8':
+ case 'ucs2': // TODO: No support for ucs2 or utf16le encodings yet
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return _utf8Slice(self, start, end)
+ case 'ascii':
+ return _asciiSlice(self, start, end)
+ case 'binary':
+ return _binarySlice(self, start, end)
+ case 'base64':
+ return _base64Slice(self, start, end)
+ default:
+ throw new Error('Unknown encoding')
+ }
+}
+
+Buffer.prototype.toJSON = function () {
+ return {
+ type: 'Buffer',
+ data: Array.prototype.slice.call(this._arr || this, 0)
+ }
+}
+
+// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
+Buffer.prototype.copy = function (target, target_start, start, end) {
+ var source = this
+
+ if (!start) start = 0
+ if (!end && end !== 0) end = this.length
+ if (!target_start) target_start = 0
+
+ // Copy 0 bytes; we're done
+ if (end === start) return
+ if (target.length === 0 || source.length === 0) return
+
+ // Fatal error conditions
+ assert(end >= start, 'sourceEnd < sourceStart')
+ assert(target_start >= 0 && target_start < target.length,
+ 'targetStart out of bounds')
+ assert(start >= 0 && start < source.length, 'sourceStart out of bounds')
+ assert(end >= 0 && end <= source.length, 'sourceEnd out of bounds')
+
+ // Are we oob?
+ if (end > this.length)
+ end = this.length
+ if (target.length - target_start < end - start)
+ end = target.length - target_start + start
+
+ // copy!
+ for (var i = 0; i < end - start; i++)
+ target[i + target_start] = this[i + start]
+}
+
+function _base64Slice (buf, start, end) {
+ if (start === 0 && end === buf.length) {
+ return base64.fromByteArray(buf)
+ } else {
+ return base64.fromByteArray(buf.slice(start, end))
+ }
+}
+
+function _utf8Slice (buf, start, end) {
+ var res = ''
+ var tmp = ''
+ end = Math.min(buf.length, end)
+
+ for (var i = start; i < end; i++) {
+ if (buf[i] <= 0x7F) {
+ res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i])
+ tmp = ''
+ } else {
+ tmp += '%' + buf[i].toString(16)
+ }
+ }
+
+ return res + decodeUtf8Char(tmp)
+}
+
+function _asciiSlice (buf, start, end) {
+ var ret = ''
+ end = Math.min(buf.length, end)
+
+ for (var i = start; i < end; i++)
+ ret += String.fromCharCode(buf[i])
+ return ret
+}
+
+function _binarySlice (buf, start, end) {
+ return _asciiSlice(buf, start, end)
+}
+
+function _hexSlice (buf, start, end) {
+ var len = buf.length
+
+ if (!start || start < 0) start = 0
+ if (!end || end < 0 || end > len) end = len
+
+ var out = ''
+ for (var i = start; i < end; i++) {
+ out += toHex(buf[i])
+ }
+ return out
+}
+
+// http://nodejs.org/api/buffer.html#buffer_buf_slice_start_end
+Buffer.prototype.slice = function (start, end) {
+ var len = this.length
+ start = clamp(start, len, 0)
+ end = clamp(end, len, len)
+
+ if (Buffer._useTypedArrays) {
+ return augment(this.subarray(start, end))
+ } else {
+ var sliceLen = end - start
+ var newBuf = new Buffer(sliceLen, undefined, true)
+ for (var i = 0; i < sliceLen; i++) {
+ newBuf[i] = this[i + start]
+ }
+ return newBuf
+ }
+}
+
+// `get` will be removed in Node 0.13+
+Buffer.prototype.get = function (offset) {
+ console.log('.get() is deprecated. Access using array indexes instead.')
+ return this.readUInt8(offset)
+}
+
+// `set` will be removed in Node 0.13+
+Buffer.prototype.set = function (v, offset) {
+ console.log('.set() is deprecated. Access using array indexes instead.')
+ return this.writeUInt8(v, offset)
+}
+
+Buffer.prototype.readUInt8 = function (offset, noAssert) {
+ if (!noAssert) {
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset < this.length, 'Trying to read beyond buffer length')
+ }
+
+ if (offset >= this.length)
+ return
+
+ return this[offset]
+}
+
+function _readUInt16 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val
+ if (littleEndian) {
+ val = buf[offset]
+ if (offset + 1 < len)
+ val |= buf[offset + 1] << 8
+ } else {
+ val = buf[offset] << 8
+ if (offset + 1 < len)
+ val |= buf[offset + 1]
+ }
+ return val
+}
+
+Buffer.prototype.readUInt16LE = function (offset, noAssert) {
+ return _readUInt16(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readUInt16BE = function (offset, noAssert) {
+ return _readUInt16(this, offset, false, noAssert)
+}
+
+function _readUInt32 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val
+ if (littleEndian) {
+ if (offset + 2 < len)
+ val = buf[offset + 2] << 16
+ if (offset + 1 < len)
+ val |= buf[offset + 1] << 8
+ val |= buf[offset]
+ if (offset + 3 < len)
+ val = val + (buf[offset + 3] << 24 >>> 0)
+ } else {
+ if (offset + 1 < len)
+ val = buf[offset + 1] << 16
+ if (offset + 2 < len)
+ val |= buf[offset + 2] << 8
+ if (offset + 3 < len)
+ val |= buf[offset + 3]
+ val = val + (buf[offset] << 24 >>> 0)
+ }
+ return val
+}
+
+Buffer.prototype.readUInt32LE = function (offset, noAssert) {
+ return _readUInt32(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readUInt32BE = function (offset, noAssert) {
+ return _readUInt32(this, offset, false, noAssert)
+}
+
+Buffer.prototype.readInt8 = function (offset, noAssert) {
+ if (!noAssert) {
+ assert(offset !== undefined && offset !== null,
+ 'missing offset')
+ assert(offset < this.length, 'Trying to read beyond buffer length')
+ }
+
+ if (offset >= this.length)
+ return
+
+ var neg = this[offset] & 0x80
+ if (neg)
+ return (0xff - this[offset] + 1) * -1
+ else
+ return this[offset]
+}
+
+function _readInt16 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val = _readUInt16(buf, offset, littleEndian, true)
+ var neg = val & 0x8000
+ if (neg)
+ return (0xffff - val + 1) * -1
+ else
+ return val
+}
+
+Buffer.prototype.readInt16LE = function (offset, noAssert) {
+ return _readInt16(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readInt16BE = function (offset, noAssert) {
+ return _readInt16(this, offset, false, noAssert)
+}
+
+function _readInt32 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val = _readUInt32(buf, offset, littleEndian, true)
+ var neg = val & 0x80000000
+ if (neg)
+ return (0xffffffff - val + 1) * -1
+ else
+ return val
+}
+
+Buffer.prototype.readInt32LE = function (offset, noAssert) {
+ return _readInt32(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readInt32BE = function (offset, noAssert) {
+ return _readInt32(this, offset, false, noAssert)
+}
+
+function _readFloat (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ return ieee754.read(buf, offset, littleEndian, 23, 4)
+}
+
+Buffer.prototype.readFloatLE = function (offset, noAssert) {
+ return _readFloat(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readFloatBE = function (offset, noAssert) {
+ return _readFloat(this, offset, false, noAssert)
+}
+
+function _readDouble (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset + 7 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ return ieee754.read(buf, offset, littleEndian, 52, 8)
+}
+
+Buffer.prototype.readDoubleLE = function (offset, noAssert) {
+ return _readDouble(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readDoubleBE = function (offset, noAssert) {
+ return _readDouble(this, offset, false, noAssert)
+}
+
+Buffer.prototype.writeUInt8 = function (value, offset, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset < this.length, 'trying to write beyond buffer length')
+ verifuint(value, 0xff)
+ }
+
+ if (offset >= this.length) return
+
+ this[offset] = value
+}
+
+function _writeUInt16 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'trying to write beyond buffer length')
+ verifuint(value, 0xffff)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ for (var i = 0, j = Math.min(len - offset, 2); i < j; i++) {
+ buf[offset + i] =
+ (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
+ (littleEndian ? i : 1 - i) * 8
+ }
+}
+
+Buffer.prototype.writeUInt16LE = function (value, offset, noAssert) {
+ _writeUInt16(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeUInt16BE = function (value, offset, noAssert) {
+ _writeUInt16(this, value, offset, false, noAssert)
+}
+
+function _writeUInt32 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'trying to write beyond buffer length')
+ verifuint(value, 0xffffffff)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ for (var i = 0, j = Math.min(len - offset, 4); i < j; i++) {
+ buf[offset + i] =
+ (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
+ }
+}
+
+Buffer.prototype.writeUInt32LE = function (value, offset, noAssert) {
+ _writeUInt32(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeUInt32BE = function (value, offset, noAssert) {
+ _writeUInt32(this, value, offset, false, noAssert)
+}
+
+Buffer.prototype.writeInt8 = function (value, offset, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset < this.length, 'Trying to write beyond buffer length')
+ verifsint(value, 0x7f, -0x80)
+ }
+
+ if (offset >= this.length)
+ return
+
+ if (value >= 0)
+ this.writeUInt8(value, offset, noAssert)
+ else
+ this.writeUInt8(0xff + value + 1, offset, noAssert)
+}
+
+function _writeInt16 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'Trying to write beyond buffer length')
+ verifsint(value, 0x7fff, -0x8000)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ if (value >= 0)
+ _writeUInt16(buf, value, offset, littleEndian, noAssert)
+ else
+ _writeUInt16(buf, 0xffff + value + 1, offset, littleEndian, noAssert)
+}
+
+Buffer.prototype.writeInt16LE = function (value, offset, noAssert) {
+ _writeInt16(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeInt16BE = function (value, offset, noAssert) {
+ _writeInt16(this, value, offset, false, noAssert)
+}
+
+function _writeInt32 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')
+ verifsint(value, 0x7fffffff, -0x80000000)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ if (value >= 0)
+ _writeUInt32(buf, value, offset, littleEndian, noAssert)
+ else
+ _writeUInt32(buf, 0xffffffff + value + 1, offset, littleEndian, noAssert)
+}
+
+Buffer.prototype.writeInt32LE = function (value, offset, noAssert) {
+ _writeInt32(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeInt32BE = function (value, offset, noAssert) {
+ _writeInt32(this, value, offset, false, noAssert)
+}
+
+function _writeFloat (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')
+ verifIEEE754(value, 3.4028234663852886e+38, -3.4028234663852886e+38)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ ieee754.write(buf, value, offset, littleEndian, 23, 4)
+}
+
+Buffer.prototype.writeFloatLE = function (value, offset, noAssert) {
+ _writeFloat(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeFloatBE = function (value, offset, noAssert) {
+ _writeFloat(this, value, offset, false, noAssert)
+}
+
+function _writeDouble (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 7 < buf.length,
+ 'Trying to write beyond buffer length')
+ verifIEEE754(value, 1.7976931348623157E+308, -1.7976931348623157E+308)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ ieee754.write(buf, value, offset, littleEndian, 52, 8)
+}
+
+Buffer.prototype.writeDoubleLE = function (value, offset, noAssert) {
+ _writeDouble(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeDoubleBE = function (value, offset, noAssert) {
+ _writeDouble(this, value, offset, false, noAssert)
+}
+
+// fill(value, start=0, end=buffer.length)
+Buffer.prototype.fill = function (value, start, end) {
+ if (!value) value = 0
+ if (!start) start = 0
+ if (!end) end = this.length
+
+ if (typeof value === 'string') {
+ value = value.charCodeAt(0)
+ }
+
+ assert(typeof value === 'number' && !isNaN(value), 'value is not a number')
+ assert(end >= start, 'end < start')
+
+ // Fill 0 bytes; we're done
+ if (end === start) return
+ if (this.length === 0) return
+
+ assert(start >= 0 && start < this.length, 'start out of bounds')
+ assert(end >= 0 && end <= this.length, 'end out of bounds')
+
+ for (var i = start; i < end; i++) {
+ this[i] = value
+ }
+}
+
+Buffer.prototype.inspect = function () {
+ var out = []
+ var len = this.length
+ for (var i = 0; i < len; i++) {
+ out[i] = toHex(this[i])
+ if (i === exports.INSPECT_MAX_BYTES) {
+ out[i + 1] = '...'
+ break
+ }
+ }
+ return '<Buffer ' + out.join(' ') + '>'
+}
+
+/**
+ * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.
+ * Added in Node 0.12. Only available in browsers that support ArrayBuffer.
+ */
+Buffer.prototype.toArrayBuffer = function () {
+ if (typeof Uint8Array === 'function') {
+ if (Buffer._useTypedArrays) {
+ return (new Buffer(this)).buffer
+ } else {
+ var buf = new Uint8Array(this.length)
+ for (var i = 0, len = buf.length; i < len; i += 1)
+ buf[i] = this[i]
+ return buf.buffer
+ }
+ } else {
+ throw new Error('Buffer.toArrayBuffer not supported in this browser')
+ }
+}
+
+// HELPER FUNCTIONS
+// ================
+
+function stringtrim (str) {
+ if (str.trim) return str.trim()
+ return str.replace(/^\s+|\s+$/g, '')
+}
+
+var BP = Buffer.prototype
+
+/**
+ * Augment the Uint8Array *instance* (not the class!) with Buffer methods
+ */
+function augment (arr) {
+ arr._isBuffer = true
+
+ // save reference to original Uint8Array get/set methods before overwriting
+ arr._get = arr.get
+ arr._set = arr.set
+
+ // deprecated, will be removed in node 0.13+
+ arr.get = BP.get
+ arr.set = BP.set
+
+ arr.write = BP.write
+ arr.toString = BP.toString
+ arr.toLocaleString = BP.toString
+ arr.toJSON = BP.toJSON
+ arr.copy = BP.copy
+ arr.slice = BP.slice
+ arr.readUInt8 = BP.readUInt8
+ arr.readUInt16LE = BP.readUInt16LE
+ arr.readUInt16BE = BP.readUInt16BE
+ arr.readUInt32LE = BP.readUInt32LE
+ arr.readUInt32BE = BP.readUInt32BE
+ arr.readInt8 = BP.readInt8
+ arr.readInt16LE = BP.readInt16LE
+ arr.readInt16BE = BP.readInt16BE
+ arr.readInt32LE = BP.readInt32LE
+ arr.readInt32BE = BP.readInt32BE
+ arr.readFloatLE = BP.readFloatLE
+ arr.readFloatBE = BP.readFloatBE
+ arr.readDoubleLE = BP.readDoubleLE
+ arr.readDoubleBE = BP.readDoubleBE
+ arr.writeUInt8 = BP.writeUInt8
+ arr.writeUInt16LE = BP.writeUInt16LE
+ arr.writeUInt16BE = BP.writeUInt16BE
+ arr.writeUInt32LE = BP.writeUInt32LE
+ arr.writeUInt32BE = BP.writeUInt32BE
+ arr.writeInt8 = BP.writeInt8
+ arr.writeInt16LE = BP.writeInt16LE
+ arr.writeInt16BE = BP.writeInt16BE
+ arr.writeInt32LE = BP.writeInt32LE
+ arr.writeInt32BE = BP.writeInt32BE
+ arr.writeFloatLE = BP.writeFloatLE
+ arr.writeFloatBE = BP.writeFloatBE
+ arr.writeDoubleLE = BP.writeDoubleLE
+ arr.writeDoubleBE = BP.writeDoubleBE
+ arr.fill = BP.fill
+ arr.inspect = BP.inspect
+ arr.toArrayBuffer = BP.toArrayBuffer
+
+ return arr
+}
+
+// slice(start, end)
+function clamp (index, len, defaultValue) {
+ if (typeof index !== 'number') return defaultValue
+ index = ~~index; // Coerce to integer.
+ if (index >= len) return len
+ if (index >= 0) return index
+ index += len
+ if (index >= 0) return index
+ return 0
+}
+
+function coerce (length) {
+ // Coerce length to a number (possibly NaN), round up
+ // in case it's fractional (e.g. 123.456) then do a
+ // double negate to coerce a NaN to 0. Easy, right?
+ length = ~~Math.ceil(+length)
+ return length < 0 ? 0 : length
+}
+
+function isArray (subject) {
+ return (Array.isArray || function (subject) {
+ return Object.prototype.toString.call(subject) === '[object Array]'
+ })(subject)
+}
+
+function isArrayish (subject) {
+ return isArray(subject) || Buffer.isBuffer(subject) ||
+ subject && typeof subject === 'object' &&
+ typeof subject.length === 'number'
+}
+
+function toHex (n) {
+ if (n < 16) return '0' + n.toString(16)
+ return n.toString(16)
+}
+
+function utf8ToBytes (str) {
+ var byteArray = []
+ for (var i = 0; i < str.length; i++) {
+ var b = str.charCodeAt(i)
+ if (b <= 0x7F)
+ byteArray.push(str.charCodeAt(i))
+ else {
+ var start = i
+ if (b >= 0xD800 && b <= 0xDFFF) i++
+ var h = encodeURIComponent(str.slice(start, i+1)).substr(1).split('%')
+ for (var j = 0; j < h.length; j++)
+ byteArray.push(parseInt(h[j], 16))
+ }
+ }
+ return byteArray
+}
+
+function asciiToBytes (str) {
+ var byteArray = []
+ for (var i = 0; i < str.length; i++) {
+ // Node's code seems to be doing this and not & 0x7F..
+ byteArray.push(str.charCodeAt(i) & 0xFF)
+ }
+ return byteArray
+}
+
+function base64ToBytes (str) {
+ return base64.toByteArray(str)
+}
+
+function blitBuffer (src, dst, offset, length) {
+ var pos
+ for (var i = 0; i < length; i++) {
+ if ((i + offset >= dst.length) || (i >= src.length))
+ break
+ dst[i + offset] = src[i]
+ }
+ return i
+}
+
+function decodeUtf8Char (str) {
+ try {
+ return decodeURIComponent(str)
+ } catch (err) {
+ return String.fromCharCode(0xFFFD) // UTF 8 invalid char
+ }
+}
+
+/*
+ * We have to make sure that the value is a valid integer. This means that it
+ * is non-negative. It has no fractional component and that it does not
+ * exceed the maximum allowed value.
+ */
+function verifuint (value, max) {
+ assert(typeof value == 'number', 'cannot write a non-number as a number')
+ assert(value >= 0,
+ 'specified a negative value for writing an unsigned value')
+ assert(value <= max, 'value is larger than maximum value for type')
+ assert(Math.floor(value) === value, 'value has a fractional component')
+}
+
+function verifsint(value, max, min) {
+ assert(typeof value == 'number', 'cannot write a non-number as a number')
+ assert(value <= max, 'value larger than maximum allowed value')
+ assert(value >= min, 'value smaller than minimum allowed value')
+ assert(Math.floor(value) === value, 'value has a fractional component')
+}
+
+function verifIEEE754(value, max, min) {
+ assert(typeof value == 'number', 'cannot write a non-number as a number')
+ assert(value <= max, 'value larger than maximum allowed value')
+ assert(value >= min, 'value smaller than minimum allowed value')
+}
+
+function assert (test, message) {
+ if (!test) throw new Error(message || 'Failed assertion')
+}
+
+},{"base64-js":21,"ieee754":22}],21:[function(require,module,exports){
+var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+;(function (exports) {
+ 'use strict';
+
+ var Arr = (typeof Uint8Array !== 'undefined')
+ ? Uint8Array
+ : Array
+
+ var PLUS = '+'.charCodeAt(0)
+ var SLASH = '/'.charCodeAt(0)
+ var NUMBER = '0'.charCodeAt(0)
+ var LOWER = 'a'.charCodeAt(0)
+ var UPPER = 'A'.charCodeAt(0)
+
+ function decode (elt) {
+ var code = elt.charCodeAt(0)
+ if (code === PLUS)
+ return 62 // '+'
+ if (code === SLASH)
+ return 63 // '/'
+ if (code < NUMBER)
+ return -1 //no match
+ if (code < NUMBER + 10)
+ return code - NUMBER + 26 + 26
+ if (code < UPPER + 26)
+ return code - UPPER
+ if (code < LOWER + 26)
+ return code - LOWER + 26
+ }
+
+ function b64ToByteArray (b64) {
+ var i, j, l, tmp, placeHolders, arr
+
+ if (b64.length % 4 > 0) {
+ throw new Error('Invalid string. Length must be a multiple of 4')
+ }
+
+ // the number of equal signs (place holders)
+ // if there are two placeholders, than the two characters before it
+ // represent one byte
+ // if there is only one, then the three characters before it represent 2 bytes
+ // this is just a cheap hack to not do indexOf twice
+ var len = b64.length
+ placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0
+
+ // base64 is 4/3 + up to two characters of the original data
+ arr = new Arr(b64.length * 3 / 4 - placeHolders)
+
+ // if there are placeholders, only get up to the last complete 4 chars
+ l = placeHolders > 0 ? b64.length - 4 : b64.length
+
+ var L = 0
+
+ function push (v) {
+ arr[L++] = v
+ }
+
+ for (i = 0, j = 0; i < l; i += 4, j += 3) {
+ tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))
+ push((tmp & 0xFF0000) >> 16)
+ push((tmp & 0xFF00) >> 8)
+ push(tmp & 0xFF)
+ }
+
+ if (placeHolders === 2) {
+ tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)
+ push(tmp & 0xFF)
+ } else if (placeHolders === 1) {
+ tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)
+ push((tmp >> 8) & 0xFF)
+ push(tmp & 0xFF)
+ }
+
+ return arr
+ }
+
+ function uint8ToBase64 (uint8) {
+ var i,
+ extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
+ output = "",
+ temp, length
+
+ function encode (num) {
+ return lookup.charAt(num)
+ }
+
+ function tripletToBase64 (num) {
+ return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)
+ }
+
+ // go through the array every three bytes, we'll deal with trailing stuff later
+ for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
+ temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
+ output += tripletToBase64(temp)
+ }
+
+ // pad the end with zeros, but make sure to not forget the extra bytes
+ switch (extraBytes) {
+ case 1:
+ temp = uint8[uint8.length - 1]
+ output += encode(temp >> 2)
+ output += encode((temp << 4) & 0x3F)
+ output += '=='
+ break
+ case 2:
+ temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])
+ output += encode(temp >> 10)
+ output += encode((temp >> 4) & 0x3F)
+ output += encode((temp << 2) & 0x3F)
+ output += '='
+ break
+ }
+
+ return output
+ }
+
+ exports.toByteArray = b64ToByteArray
+ exports.fromByteArray = uint8ToBase64
+}(typeof exports === 'undefined' ? (this.base64js = {}) : exports))
+
+},{}],22:[function(require,module,exports){
+exports.read = function(buffer, offset, isLE, mLen, nBytes) {
+ var e, m,
+ eLen = nBytes * 8 - mLen - 1,
+ eMax = (1 << eLen) - 1,
+ eBias = eMax >> 1,
+ nBits = -7,
+ i = isLE ? (nBytes - 1) : 0,
+ d = isLE ? -1 : 1,
+ s = buffer[offset + i];
+
+ i += d;
+
+ e = s & ((1 << (-nBits)) - 1);
+ s >>= (-nBits);
+ nBits += eLen;
+ for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);
+
+ m = e & ((1 << (-nBits)) - 1);
+ e >>= (-nBits);
+ nBits += mLen;
+ for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);
+
+ if (e === 0) {
+ e = 1 - eBias;
+ } else if (e === eMax) {
+ return m ? NaN : ((s ? -1 : 1) * Infinity);
+ } else {
+ m = m + Math.pow(2, mLen);
+ e = e - eBias;
+ }
+ return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+};
+
+exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
+ var e, m, c,
+ eLen = nBytes * 8 - mLen - 1,
+ eMax = (1 << eLen) - 1,
+ eBias = eMax >> 1,
+ rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),
+ i = isLE ? 0 : (nBytes - 1),
+ d = isLE ? 1 : -1,
+ s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
+
+ value = Math.abs(value);
+
+ if (isNaN(value) || value === Infinity) {
+ m = isNaN(value) ? 1 : 0;
+ e = eMax;
+ } else {
+ e = Math.floor(Math.log(value) / Math.LN2);
+ if (value * (c = Math.pow(2, -e)) < 1) {
+ e--;
+ c *= 2;
+ }
+ if (e + eBias >= 1) {
+ value += rt / c;
+ } else {
+ value += rt * Math.pow(2, 1 - eBias);
+ }
+ if (value * c >= 2) {
+ e++;
+ c /= 2;
+ }
+
+ if (e + eBias >= eMax) {
+ m = 0;
+ e = eMax;
+ } else if (e + eBias >= 1) {
+ m = (value * c - 1) * Math.pow(2, mLen);
+ e = e + eBias;
+ } else {
+ m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+ e = 0;
+ }
+ }
+
+ for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8);
+
+ e = (e << mLen) | m;
+ eLen += mLen;
+ for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8);
+
+ buffer[offset + i - d] |= s * 128;
+};
+
+},{}],23:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototypal inheritance, this class
+// prototypally inherits from Readable, and then parasitically from
+// Writable.
+
+module.exports = Duplex;
+var inherits = require('inherits');
+var setImmediate = require('process/browser.js').nextTick;
+var Readable = require('./readable.js');
+var Writable = require('./writable.js');
+
+inherits(Duplex, Readable);
+
+Duplex.prototype.write = Writable.prototype.write;
+Duplex.prototype.end = Writable.prototype.end;
+Duplex.prototype._write = Writable.prototype._write;
+
+function Duplex(options) {
+ if (!(this instanceof Duplex))
+ return new Duplex(options);
+
+ Readable.call(this, options);
+ Writable.call(this, options);
+
+ if (options && options.readable === false)
+ this.readable = false;
+
+ if (options && options.writable === false)
+ this.writable = false;
+
+ this.allowHalfOpen = true;
+ if (options && options.allowHalfOpen === false)
+ this.allowHalfOpen = false;
+
+ this.once('end', onend);
+}
+
+// the no-half-open enforcer
+function onend() {
+ // if we allow half-open state, or if the writable side ended,
+ // then we're ok.
+ if (this.allowHalfOpen || this._writableState.ended)
+ return;
+
+ // no more data can be written.
+ // But allow more writes to happen in this tick.
+ var self = this;
+ setImmediate(function () {
+ self.end();
+ });
+}
+
+},{"./readable.js":27,"./writable.js":29,"inherits":33,"process/browser.js":25}],24:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module.exports = Stream;
+
+var EE = require('events').EventEmitter;
+var inherits = require('inherits');
+
+inherits(Stream, EE);
+Stream.Readable = require('./readable.js');
+Stream.Writable = require('./writable.js');
+Stream.Duplex = require('./duplex.js');
+Stream.Transform = require('./transform.js');
+Stream.PassThrough = require('./passthrough.js');
+
+// Backwards-compat with node 0.4.x
+Stream.Stream = Stream;
+
+
+
+// old-style streams. Note that the pipe method (the only relevant
+// part of this class) is overridden in the Readable class.
+
+function Stream() {
+ EE.call(this);
+}
+
+Stream.prototype.pipe = function(dest, options) {
+ var source = this;
+
+ function ondata(chunk) {
+ if (dest.writable) {
+ if (false === dest.write(chunk) && source.pause) {
+ source.pause();
+ }
+ }
+ }
+
+ source.on('data', ondata);
+
+ function ondrain() {
+ if (source.readable && source.resume) {
+ source.resume();
+ }
+ }
+
+ dest.on('drain', ondrain);
+
+ // If the 'end' option is not supplied, dest.end() will be called when
+ // source gets the 'end' or 'close' events. Only dest.end() once.
+ if (!dest._isStdio && (!options || options.end !== false)) {
+ source.on('end', onend);
+ source.on('close', onclose);
+ }
+
+ var didOnEnd = false;
+ function onend() {
+ if (didOnEnd) return;
+ didOnEnd = true;
+
+ dest.end();
+ }
+
+
+ function onclose() {
+ if (didOnEnd) return;
+ didOnEnd = true;
+
+ if (typeof dest.destroy === 'function') dest.destroy();
+ }
+
+ // don't leave dangling pipes when there are errors.
+ function onerror(er) {
+ cleanup();
+ if (EE.listenerCount(this, 'error') === 0) {
+ throw er; // Unhandled stream error in pipe.
+ }
+ }
+
+ source.on('error', onerror);
+ dest.on('error', onerror);
+
+ // remove all the event listeners that were added.
+ function cleanup() {
+ source.removeListener('data', ondata);
+ dest.removeListener('drain', ondrain);
+
+ source.removeListener('end', onend);
+ source.removeListener('close', onclose);
+
+ source.removeListener('error', onerror);
+ dest.removeListener('error', onerror);
+
+ source.removeListener('end', cleanup);
+ source.removeListener('close', cleanup);
+
+ dest.removeListener('close', cleanup);
+ }
+
+ source.on('end', cleanup);
+ source.on('close', cleanup);
+
+ dest.on('close', cleanup);
+
+ dest.emit('pipe', source);
+
+ // Allow for unix-like usage: A.pipe(B).pipe(C)
+ return dest;
+};
+
+},{"./duplex.js":23,"./passthrough.js":26,"./readable.js":27,"./transform.js":28,"./writable.js":29,"events":18,"inherits":33}],25:[function(require,module,exports){
+module.exports=require(19)
+},{}],26:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+
+module.exports = PassThrough;
+
+var Transform = require('./transform.js');
+var inherits = require('inherits');
+inherits(PassThrough, Transform);
+
+function PassThrough(options) {
+ if (!(this instanceof PassThrough))
+ return new PassThrough(options);
+
+ Transform.call(this, options);
+}
+
+PassThrough.prototype._transform = function(chunk, encoding, cb) {
+ cb(null, chunk);
+};
+
+},{"./transform.js":28,"inherits":33}],27:[function(require,module,exports){
+(function (process){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module.exports = Readable;
+Readable.ReadableState = ReadableState;
+
+var EE = require('events').EventEmitter;
+var Stream = require('./index.js');
+var Buffer = require('buffer').Buffer;
+var setImmediate = require('process/browser.js').nextTick;
+var StringDecoder;
+
+var inherits = require('inherits');
+inherits(Readable, Stream);
+
+function ReadableState(options, stream) {
+ options = options || {};
+
+ // the point at which it stops calling _read() to fill the buffer
+ // Note: 0 is a valid value, means "don't call _read preemptively ever"
+ var hwm = options.highWaterMark;
+ this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
+
+ // cast to ints.
+ this.highWaterMark = ~~this.highWaterMark;
+
+ this.buffer = [];
+ this.length = 0;
+ this.pipes = null;
+ this.pipesCount = 0;
+ this.flowing = false;
+ this.ended = false;
+ this.endEmitted = false;
+ this.reading = false;
+
+ // In streams that never have any data, and do push(null) right away,
+ // the consumer can miss the 'end' event if they do some I/O before
+ // consuming the stream. So, we don't emit('end') until some reading
+ // happens.
+ this.calledRead = false;
+
+ // a flag to be able to tell if the onwrite cb is called immediately,
+ // or on a later tick. We set this to true at first, becuase any
+ // actions that shouldn't happen until "later" should generally also
+ // not happen before the first write call.
+ this.sync = true;
+
+ // whenever we return null, then we set a flag to say
+ // that we're awaiting a 'readable' event emission.
+ this.needReadable = false;
+ this.emittedReadable = false;
+ this.readableListening = false;
+
+
+ // object stream flag. Used to make read(n) ignore n and to
+ // make all the buffer merging and length checks go away
+ this.objectMode = !!options.objectMode;
+
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+ // when piping, we only care about 'readable' events that happen
+ // after read()ing all the bytes and not getting any pushback.
+ this.ranOut = false;
+
+ // the number of writers that are awaiting a drain event in .pipe()s
+ this.awaitDrain = 0;
+
+ // if true, a maybeReadMore has been scheduled
+ this.readingMore = false;
+
+ this.decoder = null;
+ this.encoding = null;
+ if (options.encoding) {
+ if (!StringDecoder)
+ StringDecoder = require('string_decoder').StringDecoder;
+ this.decoder = new StringDecoder(options.encoding);
+ this.encoding = options.encoding;
+ }
+}
+
+function Readable(options) {
+ if (!(this instanceof Readable))
+ return new Readable(options);
+
+ this._readableState = new ReadableState(options, this);
+
+ // legacy
+ this.readable = true;
+
+ Stream.call(this);
+}
+
+// Manually shove something into the read() buffer.
+// This returns true if the highWaterMark has not been hit yet,
+// similar to how Writable.write() returns true if you should
+// write() some more.
+Readable.prototype.push = function(chunk, encoding) {
+ var state = this._readableState;
+
+ if (typeof chunk === 'string' && !state.objectMode) {
+ encoding = encoding || state.defaultEncoding;
+ if (encoding !== state.encoding) {
+ chunk = new Buffer(chunk, encoding);
+ encoding = '';
+ }
+ }
+
+ return readableAddChunk(this, state, chunk, encoding, false);
+};
+
+// Unshift should *always* be something directly out of read()
+Readable.prototype.unshift = function(chunk) {
+ var state = this._readableState;
+ return readableAddChunk(this, state, chunk, '', true);
+};
+
+function readableAddChunk(stream, state, chunk, encoding, addToFront) {
+ var er = chunkInvalid(state, chunk);
+ if (er) {
+ stream.emit('error', er);
+ } else if (chunk === null || chunk === undefined) {
+ state.reading = false;
+ if (!state.ended)
+ onEofChunk(stream, state);
+ } else if (state.objectMode || chunk && chunk.length > 0) {
+ if (state.ended && !addToFront) {
+ var e = new Error('stream.push() after EOF');
+ stream.emit('error', e);
+ } else if (state.endEmitted && addToFront) {
+ var e = new Error('stream.unshift() after end event');
+ stream.emit('error', e);
+ } else {
+ if (state.decoder && !addToFront && !encoding)
+ chunk = state.decoder.write(chunk);
+
+ // update the buffer info.
+ state.length += state.objectMode ? 1 : chunk.length;
+ if (addToFront) {
+ state.buffer.unshift(chunk);
+ } else {
+ state.reading = false;
+ state.buffer.push(chunk);
+ }
+
+ if (state.needReadable)
+ emitReadable(stream);
+
+ maybeReadMore(stream, state);
+ }
+ } else if (!addToFront) {
+ state.reading = false;
+ }
+
+ return needMoreData(state);
+}
+
+
+
+// if it's past the high water mark, we can push in some more.
+// Also, if we have no data yet, we can stand some
+// more bytes. This is to work around cases where hwm=0,
+// such as the repl. Also, if the push() triggered a
+// readable event, and the user called read(largeNumber) such that
+// needReadable was set, then we ought to push more, so that another
+// 'readable' event will be triggered.
+function needMoreData(state) {
+ return !state.ended &&
+ (state.needReadable ||
+ state.length < state.highWaterMark ||
+ state.length === 0);
+}
+
+// backwards compatibility.
+Readable.prototype.setEncoding = function(enc) {
+ if (!StringDecoder)
+ StringDecoder = require('string_decoder').StringDecoder;
+ this._readableState.decoder = new StringDecoder(enc);
+ this._readableState.encoding = enc;
+};
+
+// Don't raise the hwm > 128MB
+var MAX_HWM = 0x800000;
+function roundUpToNextPowerOf2(n) {
+ if (n >= MAX_HWM) {
+ n = MAX_HWM;
+ } else {
+ // Get the next highest power of 2
+ n--;
+ for (var p = 1; p < 32; p <<= 1) n |= n >> p;
+ n++;
+ }
+ return n;
+}
+
+function howMuchToRead(n, state) {
+ if (state.length === 0 && state.ended)
+ return 0;
+
+ if (state.objectMode)
+ return n === 0 ? 0 : 1;
+
+ if (isNaN(n) || n === null) {
+ // only flow one buffer at a time
+ if (state.flowing && state.buffer.length)
+ return state.buffer[0].length;
+ else
+ return state.length;
+ }
+
+ if (n <= 0)
+ return 0;
+
+ // If we're asking for more than the target buffer level,
+ // then raise the water mark. Bump up to the next highest
+ // power of 2, to prevent increasing it excessively in tiny
+ // amounts.
+ if (n > state.highWaterMark)
+ state.highWaterMark = roundUpToNextPowerOf2(n);
+
+ // don't have that much. return null, unless we've ended.
+ if (n > state.length) {
+ if (!state.ended) {
+ state.needReadable = true;
+ return 0;
+ } else
+ return state.length;
+ }
+
+ return n;
+}
+
+// you can override either this method, or the async _read(n) below.
+Readable.prototype.read = function(n) {
+ var state = this._readableState;
+ state.calledRead = true;
+ var nOrig = n;
+
+ if (typeof n !== 'number' || n > 0)
+ state.emittedReadable = false;
+
+ // if we're doing read(0) to trigger a readable event, but we
+ // already have a bunch of data in the buffer, then just trigger
+ // the 'readable' event and move on.
+ if (n === 0 &&
+ state.needReadable &&
+ (state.length >= state.highWaterMark || state.ended)) {
+ emitReadable(this);
+ return null;
+ }
+
+ n = howMuchToRead(n, state);
+
+ // if we've ended, and we're now clear, then finish it up.
+ if (n === 0 && state.ended) {
+ if (state.length === 0)
+ endReadable(this);
+ return null;
+ }
+
+ // All the actual chunk generation logic needs to be
+ // *below* the call to _read. The reason is that in certain
+ // synthetic stream cases, such as passthrough streams, _read
+ // may be a completely synchronous operation which may change
+ // the state of the read buffer, providing enough data when
+ // before there was *not* enough.
+ //
+ // So, the steps are:
+ // 1. Figure out what the state of things will be after we do
+ // a read from the buffer.
+ //
+ // 2. If that resulting state will trigger a _read, then call _read.
+ // Note that this may be asynchronous, or synchronous. Yes, it is
+ // deeply ugly to write APIs this way, but that still doesn't mean
+ // that the Readable class should behave improperly, as streams are
+ // designed to be sync/async agnostic.
+ // Take note if the _read call is sync or async (ie, if the read call
+ // has returned yet), so that we know whether or not it's safe to emit
+ // 'readable' etc.
+ //
+ // 3. Actually pull the requested chunks out of the buffer and return.
+
+ // if we need a readable event, then we need to do some reading.
+ var doRead = state.needReadable;
+
+ // if we currently have less than the highWaterMark, then also read some
+ if (state.length - n <= state.highWaterMark)
+ doRead = true;
+
+ // however, if we've ended, then there's no point, and if we're already
+ // reading, then it's unnecessary.
+ if (state.ended || state.reading)
+ doRead = false;
+
+ if (doRead) {
+ state.reading = true;
+ state.sync = true;
+ // if the length is currently zero, then we *need* a readable event.
+ if (state.length === 0)
+ state.needReadable = true;
+ // call internal read method
+ this._read(state.highWaterMark);
+ state.sync = false;
+ }
+
+ // If _read called its callback synchronously, then `reading`
+ // will be false, and we need to re-evaluate how much data we
+ // can return to the user.
+ if (doRead && !state.reading)
+ n = howMuchToRead(nOrig, state);
+
+ var ret;
+ if (n > 0)
+ ret = fromList(n, state);
+ else
+ ret = null;
+
+ if (ret === null) {
+ state.needReadable = true;
+ n = 0;
+ }
+
+ state.length -= n;
+
+ // If we have nothing in the buffer, then we want to know
+ // as soon as we *do* get something into the buffer.
+ if (state.length === 0 && !state.ended)
+ state.needReadable = true;
+
+ // If we happened to read() exactly the remaining amount in the
+ // buffer, and the EOF has been seen at this point, then make sure
+ // that we emit 'end' on the very next tick.
+ if (state.ended && !state.endEmitted && state.length === 0)
+ endReadable(this);
+
+ return ret;
+};
+
+function chunkInvalid(state, chunk) {
+ var er = null;
+ if (!Buffer.isBuffer(chunk) &&
+ 'string' !== typeof chunk &&
+ chunk !== null &&
+ chunk !== undefined &&
+ !state.objectMode &&
+ !er) {
+ er = new TypeError('Invalid non-string/buffer chunk');
+ }
+ return er;
+}
+
+
+function onEofChunk(stream, state) {
+ if (state.decoder && !state.ended) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length) {
+ state.buffer.push(chunk);
+ state.length += state.objectMode ? 1 : chunk.length;
+ }
+ }
+ state.ended = true;
+
+ // if we've ended and we have some data left, then emit
+ // 'readable' now to make sure it gets picked up.
+ if (state.length > 0)
+ emitReadable(stream);
+ else
+ endReadable(stream);
+}
+
+// Don't emit readable right away in sync mode, because this can trigger
+// another read() call => stack overflow. This way, it might trigger
+// a nextTick recursion warning, but that's not so bad.
+function emitReadable(stream) {
+ var state = stream._readableState;
+ state.needReadable = false;
+ if (state.emittedReadable)
+ return;
+
+ state.emittedReadable = true;
+ if (state.sync)
+ setImmediate(function() {
+ emitReadable_(stream);
+ });
+ else
+ emitReadable_(stream);
+}
+
+function emitReadable_(stream) {
+ stream.emit('readable');
+}
+
+
+// at this point, the user has presumably seen the 'readable' event,
+// and called read() to consume some data. that may have triggered
+// in turn another _read(n) call, in which case reading = true if
+// it's in progress.
+// However, if we're not ended, or reading, and the length < hwm,
+// then go ahead and try to read some more preemptively.
+function maybeReadMore(stream, state) {
+ if (!state.readingMore) {
+ state.readingMore = true;
+ setImmediate(function() {
+ maybeReadMore_(stream, state);
+ });
+ }
+}
+
+function maybeReadMore_(stream, state) {
+ var len = state.length;
+ while (!state.reading && !state.flowing && !state.ended &&
+ state.length < state.highWaterMark) {
+ stream.read(0);
+ if (len === state.length)
+ // didn't get any data, stop spinning.
+ break;
+ else
+ len = state.length;
+ }
+ state.readingMore = false;
+}
+
+// abstract method. to be overridden in specific implementation classes.
+// call cb(er, data) where data is <= n in length.
+// for virtual (non-string, non-buffer) streams, "length" is somewhat
+// arbitrary, and perhaps not very meaningful.
+Readable.prototype._read = function(n) {
+ this.emit('error', new Error('not implemented'));
+};
+
+Readable.prototype.pipe = function(dest, pipeOpts) {
+ var src = this;
+ var state = this._readableState;
+
+ switch (state.pipesCount) {
+ case 0:
+ state.pipes = dest;
+ break;
+ case 1:
+ state.pipes = [state.pipes, dest];
+ break;
+ default:
+ state.pipes.push(dest);
+ break;
+ }
+ state.pipesCount += 1;
+
+ var doEnd = (!pipeOpts || pipeOpts.end !== false) &&
+ dest !== process.stdout &&
+ dest !== process.stderr;
+
+ var endFn = doEnd ? onend : cleanup;
+ if (state.endEmitted)
+ setImmediate(endFn);
+ else
+ src.once('end', endFn);
+
+ dest.on('unpipe', onunpipe);
+ function onunpipe(readable) {
+ if (readable !== src) return;
+ cleanup();
+ }
+
+ function onend() {
+ dest.end();
+ }
+
+ // when the dest drains, it reduces the awaitDrain counter
+ // on the source. This would be more elegant with a .once()
+ // handler in flow(), but adding and removing repeatedly is
+ // too slow.
+ var ondrain = pipeOnDrain(src);
+ dest.on('drain', ondrain);
+
+ function cleanup() {
+ // cleanup event handlers once the pipe is broken
+ dest.removeListener('close', onclose);
+ dest.removeListener('finish', onfinish);
+ dest.removeListener('drain', ondrain);
+ dest.removeListener('error', onerror);
+ dest.removeListener('unpipe', onunpipe);
+ src.removeListener('end', onend);
+ src.removeListener('end', cleanup);
+
+ // if the reader is waiting for a drain event from this
+ // specific writer, then it would cause it to never start
+ // flowing again.
+ // So, if this is awaiting a drain, then we just call it now.
+ // If we don't know, then assume that we are waiting for one.
+ if (!dest._writableState || dest._writableState.needDrain)
+ ondrain();
+ }
+
+ // if the dest has an error, then stop piping into it.
+ // however, don't suppress the throwing behavior for this.
+ // check for listeners before emit removes one-time listeners.
+ var errListeners = EE.listenerCount(dest, 'error');
+ function onerror(er) {
+ unpipe();
+ if (errListeners === 0 && EE.listenerCount(dest, 'error') === 0)
+ dest.emit('error', er);
+ }
+ dest.once('error', onerror);
+
+ // Both close and finish should trigger unpipe, but only once.
+ function onclose() {
+ dest.removeListener('finish', onfinish);
+ unpipe();
+ }
+ dest.once('close', onclose);
+ function onfinish() {
+ dest.removeListener('close', onclose);
+ unpipe();
+ }
+ dest.once('finish', onfinish);
+
+ function unpipe() {
+ src.unpipe(dest);
+ }
+
+ // tell the dest that it's being piped to
+ dest.emit('pipe', src);
+
+ // start the flow if it hasn't been started already.
+ if (!state.flowing) {
+ // the handler that waits for readable events after all
+ // the data gets sucked out in flow.
+ // This would be easier to follow with a .once() handler
+ // in flow(), but that is too slow.
+ this.on('readable', pipeOnReadable);
+
+ state.flowing = true;
+ setImmediate(function() {
+ flow(src);
+ });
+ }
+
+ return dest;
+};
+
+function pipeOnDrain(src) {
+ return function() {
+ var dest = this;
+ var state = src._readableState;
+ state.awaitDrain--;
+ if (state.awaitDrain === 0)
+ flow(src);
+ };
+}
+
+function flow(src) {
+ var state = src._readableState;
+ var chunk;
+ state.awaitDrain = 0;
+
+ function write(dest, i, list) {
+ var written = dest.write(chunk);
+ if (false === written) {
+ state.awaitDrain++;
+ }
+ }
+
+ while (state.pipesCount && null !== (chunk = src.read())) {
+
+ if (state.pipesCount === 1)
+ write(state.pipes, 0, null);
+ else
+ forEach(state.pipes, write);
+
+ src.emit('data', chunk);
+
+ // if anyone needs a drain, then we have to wait for that.
+ if (state.awaitDrain > 0)
+ return;
+ }
+
+ // if every destination was unpiped, either before entering this
+ // function, or in the while loop, then stop flowing.
+ //
+ // NB: This is a pretty rare edge case.
+ if (state.pipesCount === 0) {
+ state.flowing = false;
+
+ // if there were data event listeners added, then switch to old mode.
+ if (EE.listenerCount(src, 'data') > 0)
+ emitDataEvents(src);
+ return;
+ }
+
+ // at this point, no one needed a drain, so we just ran out of data
+ // on the next readable event, start it over again.
+ state.ranOut = true;
+}
+
+function pipeOnReadable() {
+ if (this._readableState.ranOut) {
+ this._readableState.ranOut = false;
+ flow(this);
+ }
+}
+
+
+Readable.prototype.unpipe = function(dest) {
+ var state = this._readableState;
+
+ // if we're not piping anywhere, then do nothing.
+ if (state.pipesCount === 0)
+ return this;
+
+ // just one destination. most common case.
+ if (state.pipesCount === 1) {
+ // passed in one, but it's not the right one.
+ if (dest && dest !== state.pipes)
+ return this;
+
+ if (!dest)
+ dest = state.pipes;
+
+ // got a match.
+ state.pipes = null;
+ state.pipesCount = 0;
+ this.removeListener('readable', pipeOnReadable);
+ state.flowing = false;
+ if (dest)
+ dest.emit('unpipe', this);
+ return this;
+ }
+
+ // slow case. multiple pipe destinations.
+
+ if (!dest) {
+ // remove all.
+ var dests = state.pipes;
+ var len = state.pipesCount;
+ state.pipes = null;
+ state.pipesCount = 0;
+ this.removeListener('readable', pipeOnReadable);
+ state.flowing = false;
+
+ for (var i = 0; i < len; i++)
+ dests[i].emit('unpipe', this);
+ return this;
+ }
+
+ // try to find the right one.
+ var i = indexOf(state.pipes, dest);
+ if (i === -1)
+ return this;
+
+ state.pipes.splice(i, 1);
+ state.pipesCount -= 1;
+ if (state.pipesCount === 1)
+ state.pipes = state.pipes[0];
+
+ dest.emit('unpipe', this);
+
+ return this;
+};
+
+// set up data events if they are asked for
+// Ensure readable listeners eventually get something
+Readable.prototype.on = function(ev, fn) {
+ var res = Stream.prototype.on.call(this, ev, fn);
+
+ if (ev === 'data' && !this._readableState.flowing)
+ emitDataEvents(this);
+
+ if (ev === 'readable' && this.readable) {
+ var state = this._readableState;
+ if (!state.readableListening) {
+ state.readableListening = true;
+ state.emittedReadable = false;
+ state.needReadable = true;
+ if (!state.reading) {
+ this.read(0);
+ } else if (state.length) {
+ emitReadable(this, state);
+ }
+ }
+ }
+
+ return res;
+};
+Readable.prototype.addListener = Readable.prototype.on;
+
+// pause() and resume() are remnants of the legacy readable stream API
+// If the user uses them, then switch into old mode.
+Readable.prototype.resume = function() {
+ emitDataEvents(this);
+ this.read(0);
+ this.emit('resume');
+};
+
+Readable.prototype.pause = function() {
+ emitDataEvents(this, true);
+ this.emit('pause');
+};
+
+function emitDataEvents(stream, startPaused) {
+ var state = stream._readableState;
+
+ if (state.flowing) {
+ // https://github.com/isaacs/readable-stream/issues/16
+ throw new Error('Cannot switch to old mode now.');
+ }
+
+ var paused = startPaused || false;
+ var readable = false;
+
+ // convert to an old-style stream.
+ stream.readable = true;
+ stream.pipe = Stream.prototype.pipe;
+ stream.on = stream.addListener = Stream.prototype.on;
+
+ stream.on('readable', function() {
+ readable = true;
+
+ var c;
+ while (!paused && (null !== (c = stream.read())))
+ stream.emit('data', c);
+
+ if (c === null) {
+ readable = false;
+ stream._readableState.needReadable = true;
+ }
+ });
+
+ stream.pause = function() {
+ paused = true;
+ this.emit('pause');
+ };
+
+ stream.resume = function() {
+ paused = false;
+ if (readable)
+ setImmediate(function() {
+ stream.emit('readable');
+ });
+ else
+ this.read(0);
+ this.emit('resume');
+ };
+
+ // now make it start, just in case it hadn't already.
+ stream.emit('readable');
+}
+
+// wrap an old-style stream as the async data source.
+// This is *not* part of the readable stream interface.
+// It is an ugly unfortunate mess of history.
+Readable.prototype.wrap = function(stream) {
+ var state = this._readableState;
+ var paused = false;
+
+ var self = this;
+ stream.on('end', function() {
+ if (state.decoder && !state.ended) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length)
+ self.push(chunk);
+ }
+
+ self.push(null);
+ });
+
+ stream.on('data', function(chunk) {
+ if (state.decoder)
+ chunk = state.decoder.write(chunk);
+ if (!chunk || !state.objectMode && !chunk.length)
+ return;
+
+ var ret = self.push(chunk);
+ if (!ret) {
+ paused = true;
+ stream.pause();
+ }
+ });
+
+ // proxy all the other methods.
+ // important when wrapping filters and duplexes.
+ for (var i in stream) {
+ if (typeof stream[i] === 'function' &&
+ typeof this[i] === 'undefined') {
+ this[i] = function(method) { return function() {
+ return stream[method].apply(stream, arguments);
+ }}(i);
+ }
+ }
+
+ // proxy certain important events.
+ var events = ['error', 'close', 'destroy', 'pause', 'resume'];
+ forEach(events, function(ev) {
+ stream.on(ev, function (x) {
+ return self.emit.apply(self, ev, x);
+ });
+ });
+
+ // when we try to consume some more bytes, simply unpause the
+ // underlying stream.
+ self._read = function(n) {
+ if (paused) {
+ paused = false;
+ stream.resume();
+ }
+ };
+
+ return self;
+};
+
+
+
+// exposed for testing purposes only.
+Readable._fromList = fromList;
+
+// Pluck off n bytes from an array of buffers.
+// Length is the combined lengths of all the buffers in the list.
+function fromList(n, state) {
+ var list = state.buffer;
+ var length = state.length;
+ var stringMode = !!state.decoder;
+ var objectMode = !!state.objectMode;
+ var ret;
+
+ // nothing in the list, definitely empty.
+ if (list.length === 0)
+ return null;
+
+ if (length === 0)
+ ret = null;
+ else if (objectMode)
+ ret = list.shift();
+ else if (!n || n >= length) {
+ // read it all, truncate the array.
+ if (stringMode)
+ ret = list.join('');
+ else
+ ret = Buffer.concat(list, length);
+ list.length = 0;
+ } else {
+ // read just some of it.
+ if (n < list[0].length) {
+ // just take a part of the first list item.
+ // slice is the same for buffers and strings.
+ var buf = list[0];
+ ret = buf.slice(0, n);
+ list[0] = buf.slice(n);
+ } else if (n === list[0].length) {
+ // first list is a perfect match
+ ret = list.shift();
+ } else {
+ // complex case.
+ // we have enough to cover it, but it spans past the first buffer.
+ if (stringMode)
+ ret = '';
+ else
+ ret = new Buffer(n);
+
+ var c = 0;
+ for (var i = 0, l = list.length; i < l && c < n; i++) {
+ var buf = list[0];
+ var cpy = Math.min(n - c, buf.length);
+
+ if (stringMode)
+ ret += buf.slice(0, cpy);
+ else
+ buf.copy(ret, c, 0, cpy);
+
+ if (cpy < buf.length)
+ list[0] = buf.slice(cpy);
+ else
+ list.shift();
+
+ c += cpy;
+ }
+ }
+ }
+
+ return ret;
+}
+
+function endReadable(stream) {
+ var state = stream._readableState;
+
+ // If we get here before consuming all the bytes, then that is a
+ // bug in node. Should never happen.
+ if (state.length > 0)
+ throw new Error('endReadable called on non-empty stream');
+
+ if (!state.endEmitted && state.calledRead) {
+ state.ended = true;
+ setImmediate(function() {
+ // Check that we didn't get one last unshift.
+ if (!state.endEmitted && state.length === 0) {
+ state.endEmitted = true;
+ stream.readable = false;
+ stream.emit('end');
+ }
+ });
+ }
+}
+
+function forEach (xs, f) {
+ for (var i = 0, l = xs.length; i < l; i++) {
+ f(xs[i], i);
+ }
+}
+
+function indexOf (xs, x) {
+ for (var i = 0, l = xs.length; i < l; i++) {
+ if (xs[i] === x) return i;
+ }
+ return -1;
+}
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"./index.js":24,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"events":18,"inherits":33,"process/browser.js":25,"string_decoder":30}],28:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a transform stream is a readable/writable stream where you do
+// something with the data. Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored. (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation. For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes. When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up. When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer. When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks. If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk. However,
+// a pathological inflate type of transform can cause excessive buffering
+// here. For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output. In this case, you could write a very small
+// amount of input, and end up with a very large amount of output. In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform. A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
+
+module.exports = Transform;
+
+var Duplex = require('./duplex.js');
+var inherits = require('inherits');
+inherits(Transform, Duplex);
+
+
+function TransformState(options, stream) {
+ this.afterTransform = function(er, data) {
+ return afterTransform(stream, er, data);
+ };
+
+ this.needTransform = false;
+ this.transforming = false;
+ this.writecb = null;
+ this.writechunk = null;
+}
+
+function afterTransform(stream, er, data) {
+ var ts = stream._transformState;
+ ts.transforming = false;
+
+ var cb = ts.writecb;
+
+ if (!cb)
+ return stream.emit('error', new Error('no writecb in Transform class'));
+
+ ts.writechunk = null;
+ ts.writecb = null;
+
+ if (data !== null && data !== undefined)
+ stream.push(data);
+
+ if (cb)
+ cb(er);
+
+ var rs = stream._readableState;
+ rs.reading = false;
+ if (rs.needReadable || rs.length < rs.highWaterMark) {
+ stream._read(rs.highWaterMark);
+ }
+}
+
+
+function Transform(options) {
+ if (!(this instanceof Transform))
+ return new Transform(options);
+
+ Duplex.call(this, options);
+
+ var ts = this._transformState = new TransformState(options, this);
+
+ // when the writable side finishes, then flush out anything remaining.
+ var stream = this;
+
+ // start out asking for a readable event once data is transformed.
+ this._readableState.needReadable = true;
+
+ // we have implemented the _read method, and done the other things
+ // that Readable wants before the first _read call, so unset the
+ // sync guard flag.
+ this._readableState.sync = false;
+
+ this.once('finish', function() {
+ if ('function' === typeof this._flush)
+ this._flush(function(er) {
+ done(stream, er);
+ });
+ else
+ done(stream);
+ });
+}
+
+Transform.prototype.push = function(chunk, encoding) {
+ this._transformState.needTransform = false;
+ return Duplex.prototype.push.call(this, chunk, encoding);
+};
+
+// This is the part where you do stuff!
+// override this function in implementation classes.
+// 'chunk' is an input chunk.
+//
+// Call `push(newChunk)` to pass along transformed output
+// to the readable side. You may call 'push' zero or more times.
+//
+// Call `cb(err)` when you are done with this chunk. If you pass
+// an error, then that'll put the hurt on the whole operation. If you
+// never call cb(), then you'll never get another chunk.
+Transform.prototype._transform = function(chunk, encoding, cb) {
+ throw new Error('not implemented');
+};
+
+Transform.prototype._write = function(chunk, encoding, cb) {
+ var ts = this._transformState;
+ ts.writecb = cb;
+ ts.writechunk = chunk;
+ ts.writeencoding = encoding;
+ if (!ts.transforming) {
+ var rs = this._readableState;
+ if (ts.needTransform ||
+ rs.needReadable ||
+ rs.length < rs.highWaterMark)
+ this._read(rs.highWaterMark);
+ }
+};
+
+// Doesn't matter what the args are here.
+// _transform does all the work.
+// That we got here means that the readable side wants more data.
+Transform.prototype._read = function(n) {
+ var ts = this._transformState;
+
+ if (ts.writechunk && ts.writecb && !ts.transforming) {
+ ts.transforming = true;
+ this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+ } else {
+ // mark that we need a transform, so that any data that comes in
+ // will get processed, now that we've asked for it.
+ ts.needTransform = true;
+ }
+};
+
+
+function done(stream, er) {
+ if (er)
+ return stream.emit('error', er);
+
+ // if there's nothing in the write buffer, then that means
+ // that nothing more will ever be provided
+ var ws = stream._writableState;
+ var rs = stream._readableState;
+ var ts = stream._transformState;
+
+ if (ws.length)
+ throw new Error('calling transform done when ws.length != 0');
+
+ if (ts.transforming)
+ throw new Error('calling transform done when still transforming');
+
+ return stream.push(null);
+}
+
+},{"./duplex.js":23,"inherits":33}],29:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// A bit simpler than readable streams.
+// Implement an async ._write(chunk, cb), and it'll handle all
+// the drain event emission and buffering.
+
+module.exports = Writable;
+Writable.WritableState = WritableState;
+
+var isUint8Array = typeof Uint8Array !== 'undefined'
+ ? function (x) { return x instanceof Uint8Array }
+ : function (x) {
+ return x && x.constructor && x.constructor.name === 'Uint8Array'
+ }
+;
+var isArrayBuffer = typeof ArrayBuffer !== 'undefined'
+ ? function (x) { return x instanceof ArrayBuffer }
+ : function (x) {
+ return x && x.constructor && x.constructor.name === 'ArrayBuffer'
+ }
+;
+
+var inherits = require('inherits');
+var Stream = require('./index.js');
+var setImmediate = require('process/browser.js').nextTick;
+var Buffer = require('buffer').Buffer;
+
+inherits(Writable, Stream);
+
+function WriteReq(chunk, encoding, cb) {
+ this.chunk = chunk;
+ this.encoding = encoding;
+ this.callback = cb;
+}
+
+function WritableState(options, stream) {
+ options = options || {};
+
+ // the point at which write() starts returning false
+ // Note: 0 is a valid value, means that we always return false if
+ // the entire buffer is not flushed immediately on write()
+ var hwm = options.highWaterMark;
+ this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
+
+ // object stream flag to indicate whether or not this stream
+ // contains buffers or objects.
+ this.objectMode = !!options.objectMode;
+
+ // cast to ints.
+ this.highWaterMark = ~~this.highWaterMark;
+
+ this.needDrain = false;
+ // at the start of calling end()
+ this.ending = false;
+ // when end() has been called, and returned
+ this.ended = false;
+ // when 'finish' is emitted
+ this.finished = false;
+
+ // should we decode strings into buffers before passing to _write?
+ // this is here so that some node-core streams can optimize string
+ // handling at a lower level.
+ var noDecode = options.decodeStrings === false;
+ this.decodeStrings = !noDecode;
+
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+ // not an actual buffer we keep track of, but a measurement
+ // of how much we're waiting to get pushed to some underlying
+ // socket or file.
+ this.length = 0;
+
+ // a flag to see when we're in the middle of a write.
+ this.writing = false;
+
+ // a flag to be able to tell if the onwrite cb is called immediately,
+ // or on a later tick. We set this to true at first, becuase any
+ // actions that shouldn't happen until "later" should generally also
+ // not happen before the first write call.
+ this.sync = true;
+
+ // a flag to know if we're processing previously buffered items, which
+ // may call the _write() callback in the same tick, so that we don't
+ // end up in an overlapped onwrite situation.
+ this.bufferProcessing = false;
+
+ // the callback that's passed to _write(chunk,cb)
+ this.onwrite = function(er) {
+ onwrite(stream, er);
+ };
+
+ // the callback that the user supplies to write(chunk,encoding,cb)
+ this.writecb = null;
+
+ // the amount that is being written when _write is called.
+ this.writelen = 0;
+
+ this.buffer = [];
+}
+
+function Writable(options) {
+ // Writable ctor is applied to Duplexes, though they're not
+ // instanceof Writable, they're instanceof Readable.
+ if (!(this instanceof Writable) && !(this instanceof Stream.Duplex))
+ return new Writable(options);
+
+ this._writableState = new WritableState(options, this);
+
+ // legacy.
+ this.writable = true;
+
+ Stream.call(this);
+}
+
+// Otherwise people can pipe Writable streams, which is just wrong.
+Writable.prototype.pipe = function() {
+ this.emit('error', new Error('Cannot pipe. Not readable.'));
+};
+
+
+function writeAfterEnd(stream, state, cb) {
+ var er = new Error('write after end');
+ // TODO: defer error events consistently everywhere, not just the cb
+ stream.emit('error', er);
+ setImmediate(function() {
+ cb(er);
+ });
+}
+
+// If we get something that is not a buffer, string, null, or undefined,
+// and we're not in objectMode, then that's an error.
+// Otherwise stream chunks are all considered to be of length=1, and the
+// watermarks determine how many objects to keep in the buffer, rather than
+// how many bytes or characters.
+function validChunk(stream, state, chunk, cb) {
+ var valid = true;
+ if (!Buffer.isBuffer(chunk) &&
+ 'string' !== typeof chunk &&
+ chunk !== null &&
+ chunk !== undefined &&
+ !state.objectMode) {
+ var er = new TypeError('Invalid non-string/buffer chunk');
+ stream.emit('error', er);
+ setImmediate(function() {
+ cb(er);
+ });
+ valid = false;
+ }
+ return valid;
+}
+
+Writable.prototype.write = function(chunk, encoding, cb) {
+ var state = this._writableState;
+ var ret = false;
+
+ if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (!Buffer.isBuffer(chunk) && isUint8Array(chunk))
+ chunk = new Buffer(chunk);
+ if (isArrayBuffer(chunk) && typeof Uint8Array !== 'undefined')
+ chunk = new Buffer(new Uint8Array(chunk));
+
+ if (Buffer.isBuffer(chunk))
+ encoding = 'buffer';
+ else if (!encoding)
+ encoding = state.defaultEncoding;
+
+ if (typeof cb !== 'function')
+ cb = function() {};
+
+ if (state.ended)
+ writeAfterEnd(this, state, cb);
+ else if (validChunk(this, state, chunk, cb))
+ ret = writeOrBuffer(this, state, chunk, encoding, cb);
+
+ return ret;
+};
+
+function decodeChunk(state, chunk, encoding) {
+ if (!state.objectMode &&
+ state.decodeStrings !== false &&
+ typeof chunk === 'string') {
+ chunk = new Buffer(chunk, encoding);
+ }
+ return chunk;
+}
+
+// if we're already writing something, then just put this
+// in the queue, and wait our turn. Otherwise, call _write
+// If we return false, then we need a drain event, so set that flag.
+function writeOrBuffer(stream, state, chunk, encoding, cb) {
+ chunk = decodeChunk(state, chunk, encoding);
+ var len = state.objectMode ? 1 : chunk.length;
+
+ state.length += len;
+
+ var ret = state.length < state.highWaterMark;
+ state.needDrain = !ret;
+
+ if (state.writing)
+ state.buffer.push(new WriteReq(chunk, encoding, cb));
+ else
+ doWrite(stream, state, len, chunk, encoding, cb);
+
+ return ret;
+}
+
+function doWrite(stream, state, len, chunk, encoding, cb) {
+ state.writelen = len;
+ state.writecb = cb;
+ state.writing = true;
+ state.sync = true;
+ stream._write(chunk, encoding, state.onwrite);
+ state.sync = false;
+}
+
+function onwriteError(stream, state, sync, er, cb) {
+ if (sync)
+ setImmediate(function() {
+ cb(er);
+ });
+ else
+ cb(er);
+
+ stream.emit('error', er);
+}
+
+function onwriteStateUpdate(state) {
+ state.writing = false;
+ state.writecb = null;
+ state.length -= state.writelen;
+ state.writelen = 0;
+}
+
+function onwrite(stream, er) {
+ var state = stream._writableState;
+ var sync = state.sync;
+ var cb = state.writecb;
+
+ onwriteStateUpdate(state);
+
+ if (er)
+ onwriteError(stream, state, sync, er, cb);
+ else {
+ // Check if we're actually ready to finish, but don't emit yet
+ var finished = needFinish(stream, state);
+
+ if (!finished && !state.bufferProcessing && state.buffer.length)
+ clearBuffer(stream, state);
+
+ if (sync) {
+ setImmediate(function() {
+ afterWrite(stream, state, finished, cb);
+ });
+ } else {
+ afterWrite(stream, state, finished, cb);
+ }
+ }
+}
+
+function afterWrite(stream, state, finished, cb) {
+ if (!finished)
+ onwriteDrain(stream, state);
+ cb();
+ if (finished)
+ finishMaybe(stream, state);
+}
+
+// Must force callback to be called on nextTick, so that we don't
+// emit 'drain' before the write() consumer gets the 'false' return
+// value, and has a chance to attach a 'drain' listener.
+function onwriteDrain(stream, state) {
+ if (state.length === 0 && state.needDrain) {
+ state.needDrain = false;
+ stream.emit('drain');
+ }
+}
+
+
+// if there's something in the buffer waiting, then process it
+function clearBuffer(stream, state) {
+ state.bufferProcessing = true;
+
+ for (var c = 0; c < state.buffer.length; c++) {
+ var entry = state.buffer[c];
+ var chunk = entry.chunk;
+ var encoding = entry.encoding;
+ var cb = entry.callback;
+ var len = state.objectMode ? 1 : chunk.length;
+
+ doWrite(stream, state, len, chunk, encoding, cb);
+
+ // if we didn't call the onwrite immediately, then
+ // it means that we need to wait until it does.
+ // also, that means that the chunk and cb are currently
+ // being processed, so move the buffer counter past them.
+ if (state.writing) {
+ c++;
+ break;
+ }
+ }
+
+ state.bufferProcessing = false;
+ if (c < state.buffer.length)
+ state.buffer = state.buffer.slice(c);
+ else
+ state.buffer.length = 0;
+}
+
+Writable.prototype._write = function(chunk, encoding, cb) {
+ cb(new Error('not implemented'));
+};
+
+Writable.prototype.end = function(chunk, encoding, cb) {
+ var state = this._writableState;
+
+ if (typeof chunk === 'function') {
+ cb = chunk;
+ chunk = null;
+ encoding = null;
+ } else if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (typeof chunk !== 'undefined' && chunk !== null)
+ this.write(chunk, encoding);
+
+ // ignore unnecessary end() calls.
+ if (!state.ending && !state.finished)
+ endWritable(this, state, cb);
+};
+
+
+function needFinish(stream, state) {
+ return (state.ending &&
+ state.length === 0 &&
+ !state.finished &&
+ !state.writing);
+}
+
+function finishMaybe(stream, state) {
+ var need = needFinish(stream, state);
+ if (need) {
+ state.finished = true;
+ stream.emit('finish');
+ }
+ return need;
+}
+
+function endWritable(stream, state, cb) {
+ state.ending = true;
+ finishMaybe(stream, state);
+ if (cb) {
+ if (state.finished)
+ setImmediate(cb);
+ else
+ stream.once('finish', cb);
+ }
+ state.ended = true;
+}
+
+},{"./index.js":24,"buffer":20,"inherits":33,"process/browser.js":25}],30:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var Buffer = require('buffer').Buffer;
+
+function assertEncoding(encoding) {
+ if (encoding && !Buffer.isEncoding(encoding)) {
+ throw new Error('Unknown encoding: ' + encoding);
+ }
+}
+
+var StringDecoder = exports.StringDecoder = function(encoding) {
+ this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
+ assertEncoding(encoding);
+ switch (this.encoding) {
+ case 'utf8':
+ // CESU-8 represents each of Surrogate Pair by 3-bytes
+ this.surrogateSize = 3;
+ break;
+ case 'ucs2':
+ case 'utf16le':
+ // UTF-16 represents each of Surrogate Pair by 2-bytes
+ this.surrogateSize = 2;
+ this.detectIncompleteChar = utf16DetectIncompleteChar;
+ break;
+ case 'base64':
+ // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
+ this.surrogateSize = 3;
+ this.detectIncompleteChar = base64DetectIncompleteChar;
+ break;
+ default:
+ this.write = passThroughWrite;
+ return;
+ }
+
+ this.charBuffer = new Buffer(6);
+ this.charReceived = 0;
+ this.charLength = 0;
+};
+
+
+StringDecoder.prototype.write = function(buffer) {
+ var charStr = '';
+ var offset = 0;
+
+ // if our last write ended with an incomplete multibyte character
+ while (this.charLength) {
+ // determine how many remaining bytes this buffer has to offer for this char
+ var i = (buffer.length >= this.charLength - this.charReceived) ?
+ this.charLength - this.charReceived :
+ buffer.length;
+
+ // add the new bytes to the char buffer
+ buffer.copy(this.charBuffer, this.charReceived, offset, i);
+ this.charReceived += (i - offset);
+ offset = i;
+
+ if (this.charReceived < this.charLength) {
+ // still not enough chars in this buffer? wait for more ...
+ return '';
+ }
+
+ // get the character that was split
+ charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
+
+ // lead surrogate (D800-DBFF) is also the incomplete character
+ var charCode = charStr.charCodeAt(charStr.length - 1);
+ if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+ this.charLength += this.surrogateSize;
+ charStr = '';
+ continue;
+ }
+ this.charReceived = this.charLength = 0;
+
+ // if there are no more bytes in this buffer, just emit our char
+ if (i == buffer.length) return charStr;
+
+ // otherwise cut off the characters end from the beginning of this buffer
+ buffer = buffer.slice(i, buffer.length);
+ break;
+ }
+
+ var lenIncomplete = this.detectIncompleteChar(buffer);
+
+ var end = buffer.length;
+ if (this.charLength) {
+ // buffer the incomplete character bytes we got
+ buffer.copy(this.charBuffer, 0, buffer.length - lenIncomplete, end);
+ this.charReceived = lenIncomplete;
+ end -= lenIncomplete;
+ }
+
+ charStr += buffer.toString(this.encoding, 0, end);
+
+ var end = charStr.length - 1;
+ var charCode = charStr.charCodeAt(end);
+ // lead surrogate (D800-DBFF) is also the incomplete character
+ if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+ var size = this.surrogateSize;
+ this.charLength += size;
+ this.charReceived += size;
+ this.charBuffer.copy(this.charBuffer, size, 0, size);
+ this.charBuffer.write(charStr.charAt(charStr.length - 1), this.encoding);
+ return charStr.substring(0, end);
+ }
+
+ // or just emit the charStr
+ return charStr;
+};
+
+StringDecoder.prototype.detectIncompleteChar = function(buffer) {
+ // determine how many bytes we have to check at the end of this buffer
+ var i = (buffer.length >= 3) ? 3 : buffer.length;
+
+ // Figure out if one of the last i bytes of our buffer announces an
+ // incomplete char.
+ for (; i > 0; i--) {
+ var c = buffer[buffer.length - i];
+
+ // See http://en.wikipedia.org/wiki/UTF-8#Description
+
+ // 110XXXXX
+ if (i == 1 && c >> 5 == 0x06) {
+ this.charLength = 2;
+ break;
+ }
+
+ // 1110XXXX
+ if (i <= 2 && c >> 4 == 0x0E) {
+ this.charLength = 3;
+ break;
+ }
+
+ // 11110XXX
+ if (i <= 3 && c >> 3 == 0x1E) {
+ this.charLength = 4;
+ break;
+ }
+ }
+
+ return i;
+};
+
+StringDecoder.prototype.end = function(buffer) {
+ var res = '';
+ if (buffer && buffer.length)
+ res = this.write(buffer);
+
+ if (this.charReceived) {
+ var cr = this.charReceived;
+ var buf = this.charBuffer;
+ var enc = this.encoding;
+ res += buf.slice(0, cr).toString(enc);
+ }
+
+ return res;
+};
+
+function passThroughWrite(buffer) {
+ return buffer.toString(this.encoding);
+}
+
+function utf16DetectIncompleteChar(buffer) {
+ var incomplete = this.charReceived = buffer.length % 2;
+ this.charLength = incomplete ? 2 : 0;
+ return incomplete;
+}
+
+function base64DetectIncompleteChar(buffer) {
+ var incomplete = this.charReceived = buffer.length % 3;
+ this.charLength = incomplete ? 3 : 0;
+ return incomplete;
+}
+
+},{"buffer":20}],31:[function(require,module,exports){
+module.exports = function isBuffer(arg) {
+ return arg && typeof arg === 'object'
+ && typeof arg.copy === 'function'
+ && typeof arg.fill === 'function'
+ && typeof arg.readUInt8 === 'function';
+}
+},{}],32:[function(require,module,exports){
+(function (process,global){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var formatRegExp = /%[sdj%]/g;
+exports.format = function(f) {
+ if (!isString(f)) {
+ var objects = [];
+ for (var i = 0; i < arguments.length; i++) {
+ objects.push(inspect(arguments[i]));
+ }
+ return objects.join(' ');
+ }
+
+ var i = 1;
+ var args = arguments;
+ var len = args.length;
+ var str = String(f).replace(formatRegExp, function(x) {
+ if (x === '%%') return '%';
+ if (i >= len) return x;
+ switch (x) {
+ case '%s': return String(args[i++]);
+ case '%d': return Number(args[i++]);
+ case '%j':
+ try {
+ return JSON.stringify(args[i++]);
+ } catch (_) {
+ return '[Circular]';
+ }
+ default:
+ return x;
+ }
+ });
+ for (var x = args[i]; i < len; x = args[++i]) {
+ if (isNull(x) || !isObject(x)) {
+ str += ' ' + x;
+ } else {
+ str += ' ' + inspect(x);
+ }
+ }
+ return str;
+};
+
+
+// Mark that a method should not be used.
+// Returns a modified function which warns once by default.
+// If --no-deprecation is set, then it is a no-op.
+exports.deprecate = function(fn, msg) {
+ // Allow for deprecating things in the process of starting up.
+ if (isUndefined(global.process)) {
+ return function() {
+ return exports.deprecate(fn, msg).apply(this, arguments);
+ };
+ }
+
+ if (process.noDeprecation === true) {
+ return fn;
+ }
+
+ var warned = false;
+ function deprecated() {
+ if (!warned) {
+ if (process.throwDeprecation) {
+ throw new Error(msg);
+ } else if (process.traceDeprecation) {
+ console.trace(msg);
+ } else {
+ console.error(msg);
+ }
+ warned = true;
+ }
+ return fn.apply(this, arguments);
+ }
+
+ return deprecated;
+};
+
+
+var debugs = {};
+var debugEnviron;
+exports.debuglog = function(set) {
+ if (isUndefined(debugEnviron))
+ debugEnviron = process.env.NODE_DEBUG || '';
+ set = set.toUpperCase();
+ if (!debugs[set]) {
+ if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
+ var pid = process.pid;
+ debugs[set] = function() {
+ var msg = exports.format.apply(exports, arguments);
+ console.error('%s %d: %s', set, pid, msg);
+ };
+ } else {
+ debugs[set] = function() {};
+ }
+ }
+ return debugs[set];
+};
+
+
+/**
+ * Echos the value of a value. Trys to print the value out
+ * in the best way possible given the different types.
+ *
+ * @param {Object} obj The object to print out.
+ * @param {Object} opts Optional options object that alters the output.
+ */
+/* legacy: obj, showHidden, depth, colors*/
+function inspect(obj, opts) {
+ // default options
+ var ctx = {
+ seen: [],
+ stylize: stylizeNoColor
+ };
+ // legacy...
+ if (arguments.length >= 3) ctx.depth = arguments[2];
+ if (arguments.length >= 4) ctx.colors = arguments[3];
+ if (isBoolean(opts)) {
+ // legacy...
+ ctx.showHidden = opts;
+ } else if (opts) {
+ // got an "options" object
+ exports._extend(ctx, opts);
+ }
+ // set default options
+ if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+ if (isUndefined(ctx.depth)) ctx.depth = 2;
+ if (isUndefined(ctx.colors)) ctx.colors = false;
+ if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+ if (ctx.colors) ctx.stylize = stylizeWithColor;
+ return formatValue(ctx, obj, ctx.depth);
+}
+exports.inspect = inspect;
+
+
+// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+inspect.colors = {
+ 'bold' : [1, 22],
+ 'italic' : [3, 23],
+ 'underline' : [4, 24],
+ 'inverse' : [7, 27],
+ 'white' : [37, 39],
+ 'grey' : [90, 39],
+ 'black' : [30, 39],
+ 'blue' : [34, 39],
+ 'cyan' : [36, 39],
+ 'green' : [32, 39],
+ 'magenta' : [35, 39],
+ 'red' : [31, 39],
+ 'yellow' : [33, 39]
+};
+
+// Don't use 'blue' not visible on cmd.exe
+inspect.styles = {
+ 'special': 'cyan',
+ 'number': 'yellow',
+ 'boolean': 'yellow',
+ 'undefined': 'grey',
+ 'null': 'bold',
+ 'string': 'green',
+ 'date': 'magenta',
+ // "name": intentionally not styling
+ 'regexp': 'red'
+};
+
+
+function stylizeWithColor(str, styleType) {
+ var style = inspect.styles[styleType];
+
+ if (style) {
+ return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+ '\u001b[' + inspect.colors[style][1] + 'm';
+ } else {
+ return str;
+ }
+}
+
+
+function stylizeNoColor(str, styleType) {
+ return str;
+}
+
+
+function arrayToHash(array) {
+ var hash = {};
+
+ array.forEach(function(val, idx) {
+ hash[val] = true;
+ });
+
+ return hash;
+}
+
+
+function formatValue(ctx, value, recurseTimes) {
+ // Provide a hook for user-specified inspect functions.
+ // Check that value is an object with an inspect function on it
+ if (ctx.customInspect &&
+ value &&
+ isFunction(value.inspect) &&
+ // Filter out the util module, it's inspect function is special
+ value.inspect !== exports.inspect &&
+ // Also filter out any prototype objects using the circular check.
+ !(value.constructor && value.constructor.prototype === value)) {
+ var ret = value.inspect(recurseTimes, ctx);
+ if (!isString(ret)) {
+ ret = formatValue(ctx, ret, recurseTimes);
+ }
+ return ret;
+ }
+
+ // Primitive types cannot have properties
+ var primitive = formatPrimitive(ctx, value);
+ if (primitive) {
+ return primitive;
+ }
+
+ // Look up the keys of the object.
+ var keys = Object.keys(value);
+ var visibleKeys = arrayToHash(keys);
+
+ if (ctx.showHidden) {
+ keys = Object.getOwnPropertyNames(value);
+ }
+
+ // IE doesn't make error fields non-enumerable
+ // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
+ if (isError(value)
+ && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+ return formatError(value);
+ }
+
+ // Some type of object without properties can be shortcutted.
+ if (keys.length === 0) {
+ if (isFunction(value)) {
+ var name = value.name ? ': ' + value.name : '';
+ return ctx.stylize('[Function' + name + ']', 'special');
+ }
+ if (isRegExp(value)) {
+ return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+ }
+ if (isDate(value)) {
+ return ctx.stylize(Date.prototype.toString.call(value), 'date');
+ }
+ if (isError(value)) {
+ return formatError(value);
+ }
+ }
+
+ var base = '', array = false, braces = ['{', '}'];
+
+ // Make Array say that they are Array
+ if (isArray(value)) {
+ array = true;
+ braces = ['[', ']'];
+ }
+
+ // Make functions say that they are functions
+ if (isFunction(value)) {
+ var n = value.name ? ': ' + value.name : '';
+ base = ' [Function' + n + ']';
+ }
+
+ // Make RegExps say that they are RegExps
+ if (isRegExp(value)) {
+ base = ' ' + RegExp.prototype.toString.call(value);
+ }
+
+ // Make dates with properties first say the date
+ if (isDate(value)) {
+ base = ' ' + Date.prototype.toUTCString.call(value);
+ }
+
+ // Make error with message first say the error
+ if (isError(value)) {
+ base = ' ' + formatError(value);
+ }
+
+ if (keys.length === 0 && (!array || value.length == 0)) {
+ return braces[0] + base + braces[1];
+ }
+
+ if (recurseTimes < 0) {
+ if (isRegExp(value)) {
+ return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+ } else {
+ return ctx.stylize('[Object]', 'special');
+ }
+ }
+
+ ctx.seen.push(value);
+
+ var output;
+ if (array) {
+ output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+ } else {
+ output = keys.map(function(key) {
+ return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+ });
+ }
+
+ ctx.seen.pop();
+
+ return reduceToSingleString(output, base, braces);
+}
+
+
+function formatPrimitive(ctx, value) {
+ if (isUndefined(value))
+ return ctx.stylize('undefined', 'undefined');
+ if (isString(value)) {
+ var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+ .replace(/'/g, "\\'")
+ .replace(/\\"/g, '"') + '\'';
+ return ctx.stylize(simple, 'string');
+ }
+ if (isNumber(value))
+ return ctx.stylize('' + value, 'number');
+ if (isBoolean(value))
+ return ctx.stylize('' + value, 'boolean');
+ // For some reason typeof null is "object", so special case here.
+ if (isNull(value))
+ return ctx.stylize('null', 'null');
+}
+
+
+function formatError(value) {
+ return '[' + Error.prototype.toString.call(value) + ']';
+}
+
+
+function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+ var output = [];
+ for (var i = 0, l = value.length; i < l; ++i) {
+ if (hasOwnProperty(value, String(i))) {
+ output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+ String(i), true));
+ } else {
+ output.push('');
+ }
+ }
+ keys.forEach(function(key) {
+ if (!key.match(/^\d+$/)) {
+ output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+ key, true));
+ }
+ });
+ return output;
+}
+
+
+function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+ var name, str, desc;
+ desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+ if (desc.get) {
+ if (desc.set) {
+ str = ctx.stylize('[Getter/Setter]', 'special');
+ } else {
+ str = ctx.stylize('[Getter]', 'special');
+ }
+ } else {
+ if (desc.set) {
+ str = ctx.stylize('[Setter]', 'special');
+ }
+ }
+ if (!hasOwnProperty(visibleKeys, key)) {
+ name = '[' + key + ']';
+ }
+ if (!str) {
+ if (ctx.seen.indexOf(desc.value) < 0) {
+ if (isNull(recurseTimes)) {
+ str = formatValue(ctx, desc.value, null);
+ } else {
+ str = formatValue(ctx, desc.value, recurseTimes - 1);
+ }
+ if (str.indexOf('\n') > -1) {
+ if (array) {
+ str = str.split('\n').map(function(line) {
+ return ' ' + line;
+ }).join('\n').substr(2);
+ } else {
+ str = '\n' + str.split('\n').map(function(line) {
+ return ' ' + line;
+ }).join('\n');
+ }
+ }
+ } else {
+ str = ctx.stylize('[Circular]', 'special');
+ }
+ }
+ if (isUndefined(name)) {
+ if (array && key.match(/^\d+$/)) {
+ return str;
+ }
+ name = JSON.stringify('' + key);
+ if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+ name = name.substr(1, name.length - 2);
+ name = ctx.stylize(name, 'name');
+ } else {
+ name = name.replace(/'/g, "\\'")
+ .replace(/\\"/g, '"')
+ .replace(/(^"|"$)/g, "'");
+ name = ctx.stylize(name, 'string');
+ }
+ }
+
+ return name + ': ' + str;
+}
+
+
+function reduceToSingleString(output, base, braces) {
+ var numLinesEst = 0;
+ var length = output.reduce(function(prev, cur) {
+ numLinesEst++;
+ if (cur.indexOf('\n') >= 0) numLinesEst++;
+ return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+ }, 0);
+
+ if (length > 60) {
+ return braces[0] +
+ (base === '' ? '' : base + '\n ') +
+ ' ' +
+ output.join(',\n ') +
+ ' ' +
+ braces[1];
+ }
+
+ return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+}
+
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+function isArray(ar) {
+ return Array.isArray(ar);
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+ return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+ return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+ return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+ return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+ return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+ return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+ return isObject(re) && objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+ return isObject(d) && objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+ return isObject(e) &&
+ (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+ return arg === null ||
+ typeof arg === 'boolean' ||
+ typeof arg === 'number' ||
+ typeof arg === 'string' ||
+ typeof arg === 'symbol' || // ES6 symbol
+ typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+exports.isBuffer = require('./support/isBuffer');
+
+function objectToString(o) {
+ return Object.prototype.toString.call(o);
+}
+
+
+function pad(n) {
+ return n < 10 ? '0' + n.toString(10) : n.toString(10);
+}
+
+
+var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+ 'Oct', 'Nov', 'Dec'];
+
+// 26 Feb 16:19:34
+function timestamp() {
+ var d = new Date();
+ var time = [pad(d.getHours()),
+ pad(d.getMinutes()),
+ pad(d.getSeconds())].join(':');
+ return [d.getDate(), months[d.getMonth()], time].join(' ');
+}
+
+
+// log is just a thin wrapper to console.log that prepends a timestamp
+exports.log = function() {
+ console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+};
+
+
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * The Function.prototype.inherits from lang.js rewritten as a standalone
+ * function (not on Function.prototype). NOTE: If this file is to be loaded
+ * during bootstrapping this function needs to be rewritten using some native
+ * functions as prototype setup using normal JavaScript does not work as
+ * expected during bootstrapping (see mirror.js in r114903).
+ *
+ * @param {function} ctor Constructor function which needs to inherit the
+ * prototype.
+ * @param {function} superCtor Constructor function to inherit prototype from.
+ */
+exports.inherits = require('inherits');
+
+exports._extend = function(origin, add) {
+ // Don't do anything if add isn't an object
+ if (!add || !isObject(add)) return origin;
+
+ var keys = Object.keys(add);
+ var i = keys.length;
+ while (i--) {
+ origin[keys[i]] = add[keys[i]];
+ }
+ return origin;
+};
+
+function hasOwnProperty(obj, prop) {
+ return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./support/isBuffer":31,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"inherits":33}],33:[function(require,module,exports){
+if (typeof Object.create === 'function') {
+ // implementation from standard node.js 'util' module
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor
+ ctor.prototype = Object.create(superCtor.prototype, {
+ constructor: {
+ value: ctor,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ });
+ };
+} else {
+ // old school shim for old browsers
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor
+ var TempCtor = function () {}
+ TempCtor.prototype = superCtor.prototype
+ ctor.prototype = new TempCtor()
+ ctor.prototype.constructor = ctor
+ }
+}
+
+},{}],"leveldown":[function(require,module,exports){
+module.exports=require('A2RG/S');
+},{}],"A2RG/S":[function(require,module,exports){
+(function (Buffer){
+module.exports = Level
+
+var IDB = require('idb-wrapper')
+var AbstractLevelDOWN = require('abstract-leveldown').AbstractLevelDOWN
+var util = require('util')
+var Iterator = require('./iterator')
+var isBuffer = require('isbuffer')
+var xtend = require('xtend')
+var toBuffer = require('typedarray-to-buffer')
+
+function Level(location) {
+ if (!(this instanceof Level)) return new Level(location)
+ if (!location) throw new Error("constructor requires at least a location argument")
+ this.IDBOptions = {}
+ this.location = location
+}
+
+util.inherits(Level, AbstractLevelDOWN)
+
+Level.prototype._open = function(options, callback) {
+ var self = this
+
+ var idbOpts = {
+ storeName: this.location,
+ autoIncrement: false,
+ keyPath: null,
+ onStoreReady: function () {
+ callback && callback(null, self.idb)
+ },
+ onError: function(err) {
+ callback && callback(err)
+ }
+ }
+
+ xtend(idbOpts, options)
+ this.IDBOptions = idbOpts
+ this.idb = new IDB(idbOpts)
+}
+
+Level.prototype._get = function (key, options, callback) {
+ this.idb.get(key, function (value) {
+ if (value === undefined) {
+ // 'NotFound' error, consistent with LevelDOWN API
+ return callback(new Error('NotFound'))
+ }
+ // by default return buffers, unless explicitly told not to
+ var asBuffer = true
+ if (options.asBuffer === false) asBuffer = false
+ if (options.raw) asBuffer = false
+ if (asBuffer) {
+ if (value instanceof Uint8Array) value = toBuffer(value)
+ else value = new Buffer(String(value))
+ }
+ return callback(null, value, key)
+ }, callback)
+}
+
+Level.prototype._del = function(id, options, callback) {
+ this.idb.remove(id, callback, callback)
+}
+
+Level.prototype._put = function (key, value, options, callback) {
+ if (value instanceof ArrayBuffer) {
+ value = toBuffer(new Uint8Array(value))
+ }
+ var obj = this.convertEncoding(key, value, options)
+ if (Buffer.isBuffer(obj.value)) {
+ obj.value = new Uint8Array(value.toArrayBuffer())
+ }
+ this.idb.put(obj.key, obj.value, function() { callback() }, callback)
+}
+
+Level.prototype.convertEncoding = function(key, value, options) {
+ if (options.raw) return {key: key, value: value}
+ if (value) {
+ var stringed = value.toString()
+ if (stringed === 'NaN') value = 'NaN'
+ }
+ var valEnc = options.valueEncoding
+ var obj = {key: key, value: value}
+ if (value && (!valEnc || valEnc !== 'binary')) {
+ if (typeof obj.value !== 'object') {
+ obj.value = stringed
+ }
+ }
+ return obj
+}
+
+Level.prototype.iterator = function (options) {
+ if (typeof options !== 'object') options = {}
+ return new Iterator(this.idb, options)
+}
+
+Level.prototype._batch = function (array, options, callback) {
+ var op
+ var i
+ var k
+ var copiedOp
+ var currentOp
+ var modified = []
+
+ if (array.length === 0) return setTimeout(callback, 0)
+
+ for (i = 0; i < array.length; i++) {
+ copiedOp = {}
+ currentOp = array[i]
+ modified[i] = copiedOp
+
+ var converted = this.convertEncoding(currentOp.key, currentOp.value, options)
+ currentOp.key = converted.key
+ currentOp.value = converted.value
+
+ for (k in currentOp) {
+ if (k === 'type' && currentOp[k] == 'del') {
+ copiedOp[k] = 'remove'
+ } else {
+ copiedOp[k] = currentOp[k]
+ }
+ }
+ }
+
+ return this.idb.batch(modified, function(){ callback() }, callback)
+}
+
+Level.prototype._close = function (callback) {
+ this.idb.db.close()
+ callback()
+}
+
+Level.prototype._approximateSize = function (start, end, callback) {
+ var err = new Error('Not implemented')
+ if (callback)
+ return callback(err)
+
+ throw err
+}
+
+Level.prototype._isBuffer = function (obj) {
+ return Buffer.isBuffer(obj)
+}
+
+Level.destroy = function (db, callback) {
+ if (typeof db === 'object') {
+ var prefix = db.IDBOptions.storePrefix || 'IDBWrapper-'
+ var dbname = db.location
+ } else {
+ var prefix = 'IDBWrapper-'
+ var dbname = db
+ }
+ var request = indexedDB.deleteDatabase(prefix + dbname)
+ request.onsuccess = function() {
+ callback()
+ }
+ request.onerror = function(err) {
+ callback(err)
+ }
+}
+
+var checkKeyValue = Level.prototype._checkKeyValue = function (obj, type) {
+ if (obj === null || obj === undefined)
+ return new Error(type + ' cannot be `null` or `undefined`')
+ if (obj === null || obj === undefined)
+ return new Error(type + ' cannot be `null` or `undefined`')
+ if (isBuffer(obj) && obj.byteLength === 0)
+ return new Error(type + ' cannot be an empty ArrayBuffer')
+ if (String(obj) === '')
+ return new Error(type + ' cannot be an empty String')
+ if (obj.length === 0)
+ return new Error(type + ' cannot be an empty Array')
+}
+
+}).call(this,require("buffer").Buffer)
+},{"./iterator":36,"abstract-leveldown":39,"buffer":20,"idb-wrapper":41,"isbuffer":42,"typedarray-to-buffer":44,"util":32,"xtend":46}],36:[function(require,module,exports){
+var util = require('util')
+var AbstractIterator = require('abstract-leveldown').AbstractIterator
+var ltgt = require('ltgt')
+
+module.exports = Iterator
+
+function Iterator (db, options) {
+ if (!options) options = {}
+ this.options = options
+ AbstractIterator.call(this, db)
+ this._order = options.reverse ? 'DESC': 'ASC'
+ this._limit = options.limit
+ this._count = 0
+ this._done = false
+ var lower = ltgt.lowerBound(options)
+ var upper = ltgt.upperBound(options)
+ this._keyRange = lower || upper ? this.db.makeKeyRange({
+ lower: lower,
+ upper: upper,
+ excludeLower: ltgt.lowerBoundExclusive(options),
+ excludeUpper: ltgt.upperBoundExclusive(options)
+ }) : null
+ this.callback = null
+}
+
+util.inherits(Iterator, AbstractIterator)
+
+Iterator.prototype.createIterator = function() {
+ var self = this
+
+ self.iterator = self.db.iterate(function () {
+ self.onItem.apply(self, arguments)
+ }, {
+ keyRange: self._keyRange,
+ autoContinue: false,
+ order: self._order,
+ onError: function(err) { console.log('horrible error', err) },
+ })
+}
+
+// TODO the limit implementation here just ignores all reads after limit has been reached
+// it should cancel the iterator instead but I don't know how
+Iterator.prototype.onItem = function (value, cursor, cursorTransaction) {
+ if (!cursor && this.callback) {
+ this.callback()
+ this.callback = false
+ return
+ }
+ var shouldCall = true
+
+ if (!!this._limit && this._limit > 0 && this._count++ >= this._limit)
+ shouldCall = false
+
+ if (shouldCall) this.callback(false, cursor.key, cursor.value)
+ if (cursor) cursor['continue']()
+}
+
+Iterator.prototype._next = function (callback) {
+ if (!callback) return new Error('next() requires a callback argument')
+ if (!this._started) {
+ this.createIterator()
+ this._started = true
+ }
+ this.callback = callback
+}
+
+},{"abstract-leveldown":39,"ltgt":43,"util":32}],37:[function(require,module,exports){
+(function (process){
+/* Copyright (c) 2013 Rod Vagg, MIT License */
+
+function AbstractChainedBatch (db) {
+ this._db = db
+ this._operations = []
+ this._written = false
+}
+
+AbstractChainedBatch.prototype._checkWritten = function () {
+ if (this._written)
+ throw new Error('write() already called on this batch')
+}
+
+AbstractChainedBatch.prototype.put = function (key, value) {
+ this._checkWritten()
+
+ var err = this._db._checkKeyValue(key, 'key', this._db._isBuffer)
+ if (err) throw err
+ err = this._db._checkKeyValue(value, 'value', this._db._isBuffer)
+ if (err) throw err
+
+ if (!this._db._isBuffer(key)) key = String(key)
+ if (!this._db._isBuffer(value)) value = String(value)
+
+ if (typeof this._put == 'function' )
+ this._put(key, value)
+ else
+ this._operations.push({ type: 'put', key: key, value: value })
+
+ return this
+}
+
+AbstractChainedBatch.prototype.del = function (key) {
+ this._checkWritten()
+
+ var err = this._db._checkKeyValue(key, 'key', this._db._isBuffer)
+ if (err) throw err
+
+ if (!this._db._isBuffer(key)) key = String(key)
+
+ if (typeof this._del == 'function' )
+ this._del(key)
+ else
+ this._operations.push({ type: 'del', key: key })
+
+ return this
+}
+
+AbstractChainedBatch.prototype.clear = function () {
+ this._checkWritten()
+
+ this._operations = []
+
+ if (typeof this._clear == 'function' )
+ this._clear()
+
+ return this
+}
+
+AbstractChainedBatch.prototype.write = function (options, callback) {
+ this._checkWritten()
+
+ if (typeof options == 'function')
+ callback = options
+ if (typeof callback != 'function')
+ throw new Error('write() requires a callback argument')
+ if (typeof options != 'object')
+ options = {}
+
+ this._written = true
+
+ if (typeof this._write == 'function' )
+ return this._write(callback)
+
+ if (typeof this._db._batch == 'function')
+ return this._db._batch(this._operations, options, callback)
+
+ process.nextTick(callback)
+}
+
+module.exports = AbstractChainedBatch
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],38:[function(require,module,exports){
+(function (process){
+/* Copyright (c) 2013 Rod Vagg, MIT License */
+
+function AbstractIterator (db) {
+ this.db = db
+ this._ended = false
+ this._nexting = false
+}
+
+AbstractIterator.prototype.next = function (callback) {
+ var self = this
+
+ if (typeof callback != 'function')
+ throw new Error('next() requires a callback argument')
+
+ if (self._ended)
+ return callback(new Error('cannot call next() after end()'))
+ if (self._nexting)
+ return callback(new Error('cannot call next() before previous next() has completed'))
+
+ self._nexting = true
+ if (typeof self._next == 'function') {
+ return self._next(function () {
+ self._nexting = false
+ callback.apply(null, arguments)
+ })
+ }
+
+ process.nextTick(function () {
+ self._nexting = false
+ callback()
+ })
+}
+
+AbstractIterator.prototype.end = function (callback) {
+ if (typeof callback != 'function')
+ throw new Error('end() requires a callback argument')
+
+ if (this._ended)
+ return callback(new Error('end() already called on iterator'))
+
+ this._ended = true
+
+ if (typeof this._end == 'function')
+ return this._end(callback)
+
+ process.nextTick(callback)
+}
+
+module.exports = AbstractIterator
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],39:[function(require,module,exports){
+(function (process,Buffer){
+/* Copyright (c) 2013 Rod Vagg, MIT License */
+
+var xtend = require('xtend')
+ , AbstractIterator = require('./abstract-iterator')
+ , AbstractChainedBatch = require('./abstract-chained-batch')
+
+function AbstractLevelDOWN (location) {
+ if (!arguments.length || location === undefined)
+ throw new Error('constructor requires at least a location argument')
+
+ if (typeof location != 'string')
+ throw new Error('constructor requires a location string argument')
+
+ this.location = location
+}
+
+AbstractLevelDOWN.prototype.open = function (options, callback) {
+ if (typeof options == 'function')
+ callback = options
+
+ if (typeof callback != 'function')
+ throw new Error('open() requires a callback argument')
+
+ if (typeof options != 'object')
+ options = {}
+
+ if (typeof this._open == 'function')
+ return this._open(options, callback)
+
+ process.nextTick(callback)
+}
+
+AbstractLevelDOWN.prototype.close = function (callback) {
+ if (typeof callback != 'function')
+ throw new Error('close() requires a callback argument')
+
+ if (typeof this._close == 'function')
+ return this._close(callback)
+
+ process.nextTick(callback)
+}
+
+AbstractLevelDOWN.prototype.get = function (key, options, callback) {
+ var err
+
+ if (typeof options == 'function')
+ callback = options
+
+ if (typeof callback != 'function')
+ throw new Error('get() requires a callback argument')
+
+ if (err = this._checkKeyValue(key, 'key', this._isBuffer))
+ return callback(err)
+
+ if (!this._isBuffer(key))
+ key = String(key)
+
+ if (typeof options != 'object')
+ options = {}
+
+ if (typeof this._get == 'function')
+ return this._get(key, options, callback)
+
+ process.nextTick(function () { callback(new Error('NotFound')) })
+}
+
+AbstractLevelDOWN.prototype.put = function (key, value, options, callback) {
+ var err
+
+ if (typeof options == 'function')
+ callback = options
+
+ if (typeof callback != 'function')
+ throw new Error('put() requires a callback argument')
+
+ if (err = this._checkKeyValue(key, 'key', this._isBuffer))
+ return callback(err)
+
+ if (err = this._checkKeyValue(value, 'value', this._isBuffer))
+ return callback(err)
+
+ if (!this._isBuffer(key))
+ key = String(key)
+
+ // coerce value to string in node, don't touch it in browser
+ // (indexeddb can store any JS type)
+ if (!this._isBuffer(value) && !process.browser)
+ value = String(value)
+
+ if (typeof options != 'object')
+ options = {}
+
+ if (typeof this._put == 'function')
+ return this._put(key, value, options, callback)
+
+ process.nextTick(callback)
+}
+
+AbstractLevelDOWN.prototype.del = function (key, options, callback) {
+ var err
+
+ if (typeof options == 'function')
+ callback = options
+
+ if (typeof callback != 'function')
+ throw new Error('del() requires a callback argument')
+
+ if (err = this._checkKeyValue(key, 'key', this._isBuffer))
+ return callback(err)
+
+ if (!this._isBuffer(key))
+ key = String(key)
+
+ if (typeof options != 'object')
+ options = {}
+
+ if (typeof this._del == 'function')
+ return this._del(key, options, callback)
+
+ process.nextTick(callback)
+}
+
+AbstractLevelDOWN.prototype.batch = function (array, options, callback) {
+ if (!arguments.length)
+ return this._chainedBatch()
+
+ if (typeof options == 'function')
+ callback = options
+
+ if (typeof callback != 'function')
+ throw new Error('batch(array) requires a callback argument')
+
+ if (!Array.isArray(array))
+ return callback(new Error('batch(array) requires an array argument'))
+
+ if (typeof options != 'object')
+ options = {}
+
+ var i = 0
+ , l = array.length
+ , e
+ , err
+
+ for (; i < l; i++) {
+ e = array[i]
+ if (typeof e != 'object')
+ continue
+
+ if (err = this._checkKeyValue(e.type, 'type', this._isBuffer))
+ return callback(err)
+
+ if (err = this._checkKeyValue(e.key, 'key', this._isBuffer))
+ return callback(err)
+
+ if (e.type == 'put') {
+ if (err = this._checkKeyValue(e.value, 'value', this._isBuffer))
+ return callback(err)
+ }
+ }
+
+ if (typeof this._batch == 'function')
+ return this._batch(array, options, callback)
+
+ process.nextTick(callback)
+}
+
+//TODO: remove from here, not a necessary primitive
+AbstractLevelDOWN.prototype.approximateSize = function (start, end, callback) {
+ if ( start == null
+ || end == null
+ || typeof start == 'function'
+ || typeof end == 'function') {
+ throw new Error('approximateSize() requires valid `start`, `end` and `callback` arguments')
+ }
+
+ if (typeof callback != 'function')
+ throw new Error('approximateSize() requires a callback argument')
+
+ if (!this._isBuffer(start))
+ start = String(start)
+
+ if (!this._isBuffer(end))
+ end = String(end)
+
+ if (typeof this._approximateSize == 'function')
+ return this._approximateSize(start, end, callback)
+
+ process.nextTick(function () {
+ callback(null, 0)
+ })
+}
+
+AbstractLevelDOWN.prototype._setupIteratorOptions = function (options) {
+ var self = this
+
+ options = xtend(options)
+
+ ;[ 'start', 'end', 'gt', 'gte', 'lt', 'lte' ].forEach(function (o) {
+ if (options[o] && self._isBuffer(options[o]) && options[o].length === 0)
+ delete options[o]
+ })
+
+ options.reverse = !!options.reverse
+
+ // fix `start` so it takes into account gt, gte, lt, lte as appropriate
+ if (options.reverse && options.lt)
+ options.start = options.lt
+ if (options.reverse && options.lte)
+ options.start = options.lte
+ if (!options.reverse && options.gt)
+ options.start = options.gt
+ if (!options.reverse && options.gte)
+ options.start = options.gte
+
+ if ((options.reverse && options.lt && !options.lte)
+ || (!options.reverse && options.gt && !options.gte))
+ options.exclusiveStart = true // start should *not* include matching key
+
+ return options
+}
+
+AbstractLevelDOWN.prototype.iterator = function (options) {
+ if (typeof options != 'object')
+ options = {}
+
+ options = this._setupIteratorOptions(options)
+
+ if (typeof this._iterator == 'function')
+ return this._iterator(options)
+
+ return new AbstractIterator(this)
+}
+
+AbstractLevelDOWN.prototype._chainedBatch = function () {
+ return new AbstractChainedBatch(this)
+}
+
+AbstractLevelDOWN.prototype._isBuffer = function (obj) {
+ return Buffer.isBuffer(obj)
+}
+
+AbstractLevelDOWN.prototype._checkKeyValue = function (obj, type) {
+ if (obj === null || obj === undefined)
+ return new Error(type + ' cannot be `null` or `undefined`')
+
+ if (obj === null || obj === undefined)
+ return new Error(type + ' cannot be `null` or `undefined`')
+
+ if (this._isBuffer(obj)) {
+ if (obj.length === 0)
+ return new Error(type + ' cannot be an empty Buffer')
+ } else if (String(obj) === '')
+ return new Error(type + ' cannot be an empty String')
+}
+
+module.exports.AbstractLevelDOWN = AbstractLevelDOWN
+module.exports.AbstractIterator = AbstractIterator
+module.exports.AbstractChainedBatch = AbstractChainedBatch
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),require("buffer").Buffer)
+},{"./abstract-chained-batch":37,"./abstract-iterator":38,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"xtend":40}],40:[function(require,module,exports){
+module.exports = extend
+
+function extend() {
+ var target = {}
+
+ for (var i = 0; i < arguments.length; i++) {
+ var source = arguments[i]
+
+ for (var key in source) {
+ if (source.hasOwnProperty(key)) {
+ target[key] = source[key]
+ }
+ }
+ }
+
+ return target
+}
+
+},{}],41:[function(require,module,exports){
+/*global window:false, self:false, define:false, module:false */
+
+/**
+ * @license IDBWrapper - A cross-browser wrapper for IndexedDB
+ * Copyright (c) 2011 - 2013 Jens Arps
+ * http://jensarps.de/
+ *
+ * Licensed under the MIT (X11) license
+ */
+
+(function (name, definition, global) {
+ if (typeof define === 'function') {
+ define(definition);
+ } else if (typeof module !== 'undefined' && module.exports) {
+ module.exports = definition();
+ } else {
+ global[name] = definition();
+ }
+})('IDBStore', function () {
+
+ 'use strict';
+
+ var defaultErrorHandler = function (error) {
+ throw error;
+ };
+
+ var defaults = {
+ storeName: 'Store',
+ storePrefix: 'IDBWrapper-',
+ dbVersion: 1,
+ keyPath: 'id',
+ autoIncrement: true,
+ onStoreReady: function () {
+ },
+ onError: defaultErrorHandler,
+ indexes: []
+ };
+
+ /**
+ *
+ * The IDBStore constructor
+ *
+ * @constructor
+ * @name IDBStore
+ * @version 1.4.1
+ *
+ * @param {Object} [kwArgs] An options object used to configure the store and
+ * set callbacks
+ * @param {String} [kwArgs.storeName='Store'] The name of the store
+ * @param {String} [kwArgs.storePrefix='IDBWrapper-'] A prefix that is
+ * internally used to construct the name of the database, which will be
+ * kwArgs.storePrefix + kwArgs.storeName
+ * @param {Number} [kwArgs.dbVersion=1] The version of the store
+ * @param {String} [kwArgs.keyPath='id'] The key path to use. If you want to
+ * setup IDBWrapper to work with out-of-line keys, you need to set this to
+ * `null`
+ * @param {Boolean} [kwArgs.autoIncrement=true] If set to true, IDBStore will
+ * automatically make sure a unique keyPath value is present on each object
+ * that is stored.
+ * @param {Function} [kwArgs.onStoreReady] A callback to be called when the
+ * store is ready to be used.
+ * @param {Function} [kwArgs.onError=throw] A callback to be called when an
+ * error occurred during instantiation of the store.
+ * @param {Array} [kwArgs.indexes=[]] An array of indexData objects
+ * defining the indexes to use with the store. For every index to be used
+ * one indexData object needs to be passed in the array.
+ * An indexData object is defined as follows:
+ * @param {Object} [kwArgs.indexes.indexData] An object defining the index to
+ * use
+ * @param {String} kwArgs.indexes.indexData.name The name of the index
+ * @param {String} [kwArgs.indexes.indexData.keyPath] The key path of the index
+ * @param {Boolean} [kwArgs.indexes.indexData.unique] Whether the index is unique
+ * @param {Boolean} [kwArgs.indexes.indexData.multiEntry] Whether the index is multi entry
+ * @param {Function} [onStoreReady] A callback to be called when the store
+ * is ready to be used.
+ * @example
+ // create a store for customers with an additional index over the
+ // `lastname` property.
+ var myCustomerStore = new IDBStore({
+ dbVersion: 1,
+ storeName: 'customer-index',
+ keyPath: 'customerid',
+ autoIncrement: true,
+ onStoreReady: populateTable,
+ indexes: [
+ { name: 'lastname', keyPath: 'lastname', unique: false, multiEntry: false }
+ ]
+ });
+ * @example
+ // create a generic store
+ var myCustomerStore = new IDBStore({
+ storeName: 'my-data-store',
+ onStoreReady: function(){
+ // start working with the store.
+ }
+ });
+ */
+ var IDBStore = function (kwArgs, onStoreReady) {
+
+ if (typeof onStoreReady == 'undefined' && typeof kwArgs == 'function') {
+ onStoreReady = kwArgs;
+ }
+ if (Object.prototype.toString.call(kwArgs) != '[object Object]') {
+ kwArgs = {};
+ }
+
+ for (var key in defaults) {
+ this[key] = typeof kwArgs[key] != 'undefined' ? kwArgs[key] : defaults[key];
+ }
+
+ this.dbName = this.storePrefix + this.storeName;
+ this.dbVersion = parseInt(this.dbVersion, 10) || 1;
+
+ onStoreReady && (this.onStoreReady = onStoreReady);
+
+ var env = typeof window == 'object' ? window : self;
+ this.idb = env.indexedDB || env.webkitIndexedDB || env.mozIndexedDB;
+ this.keyRange = env.IDBKeyRange || env.webkitIDBKeyRange || env.mozIDBKeyRange;
+
+ this.features = {
+ hasAutoIncrement: !env.mozIndexedDB
+ };
+
+ this.consts = {
+ 'READ_ONLY': 'readonly',
+ 'READ_WRITE': 'readwrite',
+ 'VERSION_CHANGE': 'versionchange',
+ 'NEXT': 'next',
+ 'NEXT_NO_DUPLICATE': 'nextunique',
+ 'PREV': 'prev',
+ 'PREV_NO_DUPLICATE': 'prevunique'
+ };
+
+ this.openDB();
+ };
+
+ IDBStore.prototype = /** @lends IDBStore */ {
+
+ /**
+ * A pointer to the IDBStore ctor
+ *
+ * @type IDBStore
+ */
+ constructor: IDBStore,
+
+ /**
+ * The version of IDBStore
+ *
+ * @type String
+ */
+ version: '1.4.1',
+
+ /**
+ * A reference to the IndexedDB object
+ *
+ * @type Object
+ */
+ db: null,
+
+ /**
+ * The full name of the IndexedDB used by IDBStore, composed of
+ * this.storePrefix + this.storeName
+ *
+ * @type String
+ */
+ dbName: null,
+
+ /**
+ * The version of the IndexedDB used by IDBStore
+ *
+ * @type Number
+ */
+ dbVersion: null,
+
+ /**
+ * A reference to the objectStore used by IDBStore
+ *
+ * @type Object
+ */
+ store: null,
+
+ /**
+ * The store name
+ *
+ * @type String
+ */
+ storeName: null,
+
+ /**
+ * The key path
+ *
+ * @type String
+ */
+ keyPath: null,
+
+ /**
+ * Whether IDBStore uses autoIncrement
+ *
+ * @type Boolean
+ */
+ autoIncrement: null,
+
+ /**
+ * The indexes used by IDBStore
+ *
+ * @type Array
+ */
+ indexes: null,
+
+ /**
+ * A hashmap of features of the used IDB implementation
+ *
+ * @type Object
+ * @proprty {Boolean} autoIncrement If the implementation supports
+ * native auto increment
+ */
+ features: null,
+
+ /**
+ * The callback to be called when the store is ready to be used
+ *
+ * @type Function
+ */
+ onStoreReady: null,
+
+ /**
+ * The callback to be called if an error occurred during instantiation
+ * of the store
+ *
+ * @type Function
+ */
+ onError: null,
+
+ /**
+ * The internal insertID counter
+ *
+ * @type Number
+ * @private
+ */
+ _insertIdCount: 0,
+
+ /**
+ * Opens an IndexedDB; called by the constructor.
+ *
+ * Will check if versions match and compare provided index configuration
+ * with existing ones, and update indexes if necessary.
+ *
+ * Will call this.onStoreReady() if everything went well and the store
+ * is ready to use, and this.onError() is something went wrong.
+ *
+ * @private
+ *
+ */
+ openDB: function () {
+
+ var openRequest = this.idb.open(this.dbName, this.dbVersion);
+ var preventSuccessCallback = false;
+
+ openRequest.onerror = function (error) {
+
+ var gotVersionErr = false;
+ if ('error' in error.target) {
+ gotVersionErr = error.target.error.name == 'VersionError';
+ } else if ('errorCode' in error.target) {
+ gotVersionErr = error.target.errorCode == 12;
+ }
+
+ if (gotVersionErr) {
+ this.onError(new Error('The version number provided is lower than the existing one.'));
+ } else {
+ this.onError(error);
+ }
+ }.bind(this);
+
+ openRequest.onsuccess = function (event) {
+
+ if (preventSuccessCallback) {
+ return;
+ }
+
+ if(this.db){
+ this.onStoreReady();
+ return;
+ }
+
+ this.db = event.target.result;
+
+ if(typeof this.db.version == 'string'){
+ this.onError(new Error('The IndexedDB implementation in this browser is outdated. Please upgrade your browser.'));
+ return;
+ }
+
+ if(!this.db.objectStoreNames.contains(this.storeName)){
+ // We should never ever get here.
+ // Lets notify the user anyway.
+ this.onError(new Error('Something is wrong with the IndexedDB implementation in this browser. Please upgrade your browser.'));
+ return;
+ }
+
+ var emptyTransaction = this.db.transaction([this.storeName], this.consts.READ_ONLY);
+ this.store = emptyTransaction.objectStore(this.storeName);
+
+ // check indexes
+ var existingIndexes = Array.prototype.slice.call(this.getIndexList());
+ this.indexes.forEach(function(indexData){
+ var indexName = indexData.name;
+
+ if(!indexName){
+ preventSuccessCallback = true;
+ this.onError(new Error('Cannot create index: No index name given.'));
+ return;
+ }
+
+ this.normalizeIndexData(indexData);
+
+ if(this.hasIndex(indexName)){
+ // check if it complies
+ var actualIndex = this.store.index(indexName);
+ var complies = this.indexComplies(actualIndex, indexData);
+ if(!complies){
+ preventSuccessCallback = true;
+ this.onError(new Error('Cannot modify index "' + indexName + '" for current version. Please bump version number to ' + ( this.dbVersion + 1 ) + '.'));
+ }
+
+ existingIndexes.splice(existingIndexes.indexOf(indexName), 1);
+ } else {
+ preventSuccessCallback = true;
+ this.onError(new Error('Cannot create new index "' + indexName + '" for current version. Please bump version number to ' + ( this.dbVersion + 1 ) + '.'));
+ }
+
+ }, this);
+
+ if (existingIndexes.length) {
+ preventSuccessCallback = true;
+ this.onError(new Error('Cannot delete index(es) "' + existingIndexes.toString() + '" for current version. Please bump version number to ' + ( this.dbVersion + 1 ) + '.'));
+ }
+
+ preventSuccessCallback || this.onStoreReady();
+ }.bind(this);
+
+ openRequest.onupgradeneeded = function(/* IDBVersionChangeEvent */ event){
+
+ this.db = event.target.result;
+
+ if(this.db.objectStoreNames.contains(this.storeName)){
+ this.store = event.target.transaction.objectStore(this.storeName);
+ } else {
+ var optionalParameters = { autoIncrement: this.autoIncrement };
+ if (this.keyPath !== null) {
+ optionalParameters.keyPath = this.keyPath;
+ }
+ this.store = this.db.createObjectStore(this.storeName, optionalParameters);
+ }
+
+ var existingIndexes = Array.prototype.slice.call(this.getIndexList());
+ this.indexes.forEach(function(indexData){
+ var indexName = indexData.name;
+
+ if(!indexName){
+ preventSuccessCallback = true;
+ this.onError(new Error('Cannot create index: No index name given.'));
+ }
+
+ this.normalizeIndexData(indexData);
+
+ if(this.hasIndex(indexName)){
+ // check if it complies
+ var actualIndex = this.store.index(indexName);
+ var complies = this.indexComplies(actualIndex, indexData);
+ if(!complies){
+ // index differs, need to delete and re-create
+ this.store.deleteIndex(indexName);
+ this.store.createIndex(indexName, indexData.keyPath, { unique: indexData.unique, multiEntry: indexData.multiEntry });
+ }
+
+ existingIndexes.splice(existingIndexes.indexOf(indexName), 1);
+ } else {
+ this.store.createIndex(indexName, indexData.keyPath, { unique: indexData.unique, multiEntry: indexData.multiEntry });
+ }
+
+ }, this);
+
+ if (existingIndexes.length) {
+ existingIndexes.forEach(function(_indexName){
+ this.store.deleteIndex(_indexName);
+ }, this);
+ }
+
+ }.bind(this);
+ },
+
+ /**
+ * Deletes the database used for this store if the IDB implementations
+ * provides that functionality.
+ */
+ deleteDatabase: function () {
+ if (this.idb.deleteDatabase) {
+ this.idb.deleteDatabase(this.dbName);
+ }
+ },
+
+ /*********************
+ * data manipulation *
+ *********************/
+
+ /**
+ * Puts an object into the store. If an entry with the given id exists,
+ * it will be overwritten. This method has a different signature for inline
+ * keys and out-of-line keys; please see the examples below.
+ *
+ * @param {*} [key] The key to store. This is only needed if IDBWrapper
+ * is set to use out-of-line keys. For inline keys - the default scenario -
+ * this can be omitted.
+ * @param {Object} value The data object to store.
+ * @param {Function} [onSuccess] A callback that is called if insertion
+ * was successful.
+ * @param {Function} [onError] A callback that is called if insertion
+ * failed.
+ * @returns {IDBTransaction} The transaction used for this operation.
+ * @example
+ // Storing an object, using inline keys (the default scenario):
+ var myCustomer = {
+ customerid: 2346223,
+ lastname: 'Doe',
+ firstname: 'John'
+ };
+ myCustomerStore.put(myCustomer, mySuccessHandler, myErrorHandler);
+ // Note that passing success- and error-handlers is optional.
+ * @example
+ // Storing an object, using out-of-line keys:
+ var myCustomer = {
+ lastname: 'Doe',
+ firstname: 'John'
+ };
+ myCustomerStore.put(2346223, myCustomer, mySuccessHandler, myErrorHandler);
+ // Note that passing success- and error-handlers is optional.
+ */
+ put: function (key, value, onSuccess, onError) {
+ if (this.keyPath !== null) {
+ onError = onSuccess;
+ onSuccess = value;
+ value = key;
+ }
+ onError || (onError = defaultErrorHandler);
+ onSuccess || (onSuccess = noop);
+
+ var hasSuccess = false,
+ result = null,
+ putRequest;
+
+ var putTransaction = this.db.transaction([this.storeName], this.consts.READ_WRITE);
+ putTransaction.oncomplete = function () {
+ var callback = hasSuccess ? onSuccess : onError;
+ callback(result);
+ };
+ putTransaction.onabort = onError;
+ putTransaction.onerror = onError;
+
+ if (this.keyPath !== null) { // in-line keys
+ this._addIdPropertyIfNeeded(value);
+ putRequest = putTransaction.objectStore(this.storeName).put(value);
+ } else { // out-of-line keys
+ putRequest = putTransaction.objectStore(this.storeName).put(value, key);
+ }
+ putRequest.onsuccess = function (event) {
+ hasSuccess = true;
+ result = event.target.result;
+ };
+ putRequest.onerror = onError;
+
+ return putTransaction;
+ },
+
+ /**
+ * Retrieves an object from the store. If no entry exists with the given id,
+ * the success handler will be called with null as first and only argument.
+ *
+ * @param {*} key The id of the object to fetch.
+ * @param {Function} [onSuccess] A callback that is called if fetching
+ * was successful. Will receive the object as only argument.
+ * @param {Function} [onError] A callback that will be called if an error
+ * occurred during the operation.
+ * @returns {IDBTransaction} The transaction used for this operation.
+ */
+ get: function (key, onSuccess, onError) {
+ onError || (onError = defaultErrorHandler);
+ onSuccess || (onSuccess = noop);
+
+ var hasSuccess = false,
+ result = null;
+
+ var getTransaction = this.db.transaction([this.storeName], this.consts.READ_ONLY);
+ getTransaction.oncomplete = function () {
+ var callback = hasSuccess ? onSuccess : onError;
+ callback(result);
+ };
+ getTransaction.onabort = onError;
+ getTransaction.onerror = onError;
+ var getRequest = getTransaction.objectStore(this.storeName).get(key);
+ getRequest.onsuccess = function (event) {
+ hasSuccess = true;
+ result = event.target.result;
+ };
+ getRequest.onerror = onError;
+
+ return getTransaction;
+ },
+
+ /**
+ * Removes an object from the store.
+ *
+ * @param {*} key The id of the object to remove.
+ * @param {Function} [onSuccess] A callback that is called if the removal
+ * was successful.
+ * @param {Function} [onError] A callback that will be called if an error
+ * occurred during the operation.
+ * @returns {IDBTransaction} The transaction used for this operation.
+ */
+ remove: function (key, onSuccess, onError) {
+ onError || (onError = defaultErrorHandler);
+ onSuccess || (onSuccess = noop);
+
+ var hasSuccess = false,
+ result = null;
+
+ var removeTransaction = this.db.transaction([this.storeName], this.consts.READ_WRITE);
+ removeTransaction.oncomplete = function () {
+ var callback = hasSuccess ? onSuccess : onError;
+ callback(result);
+ };
+ removeTransaction.onabort = onError;
+ removeTransaction.onerror = onError;
+
+ var deleteRequest = removeTransaction.objectStore(this.storeName)['delete'](key);
+ deleteRequest.onsuccess = function (event) {
+ hasSuccess = true;
+ result = event.target.result;
+ };
+ deleteRequest.onerror = onError;
+
+ return removeTransaction;
+ },
+
+ /**
+ * Runs a batch of put and/or remove operations on the store.
+ *
+ * @param {Array} dataArray An array of objects containing the operation to run
+ * and the data object (for put operations).
+ * @param {Function} [onSuccess] A callback that is called if all operations
+ * were successful.
+ * @param {Function} [onError] A callback that is called if an error
+ * occurred during one of the operations.
+ * @returns {IDBTransaction} The transaction used for this operation.
+ */
+ batch: function (dataArray, onSuccess, onError) {
+ onError || (onError = defaultErrorHandler);
+ onSuccess || (onSuccess = noop);
+
+ if(Object.prototype.toString.call(dataArray) != '[object Array]'){
+ onError(new Error('dataArray argument must be of type Array.'));
+ }
+ var batchTransaction = this.db.transaction([this.storeName] , this.consts.READ_WRITE);
+ batchTransaction.oncomplete = function () {
+ var callback = hasSuccess ? onSuccess : onError;
+ callback(hasSuccess);
+ };
+ batchTransaction.onabort = onError;
+ batchTransaction.onerror = onError;
+
+ var count = dataArray.length;
+ var called = false;
+ var hasSuccess = false;
+
+ var onItemSuccess = function () {
+ count--;
+ if (count === 0 && !called) {
+ called = true;
+ hasSuccess = true;
+ }
+ };
+
+ dataArray.forEach(function (operation) {
+ var type = operation.type;
+ var key = operation.key;
+ var value = operation.value;
+
+ var onItemError = function (err) {
+ batchTransaction.abort();
+ if (!called) {
+ called = true;
+ onError(err, type, key);
+ }
+ };
+
+ if (type == 'remove') {
+ var deleteRequest = batchTransaction.objectStore(this.storeName)['delete'](key);
+ deleteRequest.onsuccess = onItemSuccess;
+ deleteRequest.onerror = onItemError;
+ } else if (type == 'put') {
+ var putRequest;
+ if (this.keyPath !== null) { // in-line keys
+ this._addIdPropertyIfNeeded(value);
+ putRequest = batchTransaction.objectStore(this.storeName).put(value);
+ } else { // out-of-line keys
+ putRequest = batchTransaction.objectStore(this.storeName).put(value, key);
+ }
+ putRequest.onsuccess = onItemSuccess;
+ putRequest.onerror = onItemError;
+ }
+ }, this);
+
+ return batchTransaction;
+ },
+
+ /**
+ * Takes an array of objects and stores them in a single transaction.
+ *
+ * @param {Array} dataArray An array of objects to store
+ * @param {Function} [onSuccess] A callback that is called if all operations
+ * were successful.
+ * @param {Function} [onError] A callback that is called if an error
+ * occurred during one of the operations.
+ * @returns {IDBTransaction} The transaction used for this operation.
+ */
+ putBatch: function (dataArray, onSuccess, onError) {
+ var batchData = dataArray.map(function(item){
+ return { type: 'put', value: item };
+ });
+
+ return this.batch(batchData, onSuccess, onError);
+ },
+
+ /**
+ * Takes an array of keys and removes matching objects in a single
+ * transaction.
+ *
+ * @param {Array} keyArray An array of keys to remove
+ * @param {Function} [onSuccess] A callback that is called if all operations
+ * were successful.
+ * @param {Function} [onError] A callback that is called if an error
+ * occurred during one of the operations.
+ * @returns {IDBTransaction} The transaction used for this operation.
+ */
+ removeBatch: function (keyArray, onSuccess, onError) {
+ var batchData = keyArray.map(function(key){
+ return { type: 'remove', key: key };
+ });
+
+ return this.batch(batchData, onSuccess, onError);
+ },
+
+ /**
+ * Takes an array of keys and fetches matching objects
+ *
+ * @param {Array} keyArray An array of keys identifying the objects to fetch
+ * @param {Function} [onSuccess] A callback that is called if all operations
+ * were successful.
+ * @param {Function} [onError] A callback that is called if an error
+ * occurred during one of the operations.
+ * @param {String} [arrayType='sparse'] The type of array to pass to the
+ * success handler. May be one of 'sparse', 'dense' or 'skip'. Defaults to
+ * 'sparse'. This parameter specifies how to handle the situation if a get
+ * operation did not throw an error, but there was no matching object in
+ * the database. In most cases, 'sparse' provides the most desired
+ * behavior. See the examples for details.
+ * @returns {IDBTransaction} The transaction used for this operation.
+ * @example
+ // given that there are two objects in the database with the keypath
+ // values 1 and 2, and the call looks like this:
+ myStore.getBatch([1, 5, 2], onError, function (data) { … }, arrayType);
+
+ // this is what the `data` array will be like:
+
+ // arrayType == 'sparse':
+ // data is a sparse array containing two entries and having a length of 3:
+ [Object, 2: Object]
+ 0: Object
+ 2: Object
+ length: 3
+ __proto__: Array[0]
+ // calling forEach on data will result in the callback being called two
+ // times, with the index parameter matching the index of the key in the
+ // keyArray.
+
+ // arrayType == 'dense':
+ // data is a dense array containing three entries and having a length of 3,
+ // where data[1] is of type undefined:
+ [Object, undefined, Object]
+ 0: Object
+ 1: undefined
+ 2: Object
+ length: 3
+ __proto__: Array[0]
+ // calling forEach on data will result in the callback being called three
+ // times, with the index parameter matching the index of the key in the
+ // keyArray, but the second call will have undefined as first argument.
+
+ // arrayType == 'skip':
+ // data is a dense array containing two entries and having a length of 2:
+ [Object, Object]
+ 0: Object
+ 1: Object
+ length: 2
+ __proto__: Array[0]
+ // calling forEach on data will result in the callback being called two
+ // times, with the index parameter not matching the index of the key in the
+ // keyArray.
+ */
+ getBatch: function (keyArray, onSuccess, onError, arrayType) {
+ onError || (onError = defaultErrorHandler);
+ onSuccess || (onSuccess = noop);
+ arrayType || (arrayType = 'sparse');
+
+ if(Object.prototype.toString.call(keyArray) != '[object Array]'){
+ onError(new Error('keyArray argument must be of type Array.'));
+ }
+ var batchTransaction = this.db.transaction([this.storeName] , this.consts.READ_ONLY);
+ batchTransaction.oncomplete = function () {
+ var callback = hasSuccess ? onSuccess : onError;
+ callback(result);
+ };
+ batchTransaction.onabort = onError;
+ batchTransaction.onerror = onError;
+
+ var data = [];
+ var count = keyArray.length;
+ var called = false;
+ var hasSuccess = false;
+ var result = null;
+
+ var onItemSuccess = function (event) {
+ if (event.target.result || arrayType == 'dense') {
+ data.push(event.target.result);
+ } else if (arrayType == 'sparse') {
+ data.length++;
+ }
+ count--;
+ if (count === 0) {
+ called = true;
+ hasSuccess = true;
+ result = data;
+ }
+ };
+
+ keyArray.forEach(function (key) {
+
+ var onItemError = function (err) {
+ called = true;
+ result = err;
+ onError(err);
+ batchTransaction.abort();
+ };
+
+ var getRequest = batchTransaction.objectStore(this.storeName).get(key);
+ getRequest.onsuccess = onItemSuccess;
+ getRequest.onerror = onItemError;
+
+ }, this);
+
+ return batchTransaction;
+ },
+
+ /**
+ * Fetches all entries in the store.
+ *
+ * @param {Function} [onSuccess] A callback that is called if the operation
+ * was successful. Will receive an array of objects.
+ * @param {Function} [onError] A callback that will be called if an error
+ * occurred during the operation.
+ * @returns {IDBTransaction} The transaction used for this operation.
+ */
+ getAll: function (onSuccess, onError) {
+ onError || (onError = defaultErrorHandler);
+ onSuccess || (onSuccess = noop);
+ var getAllTransaction = this.db.transaction([this.storeName], this.consts.READ_ONLY);
+ var store = getAllTransaction.objectStore(this.storeName);
+ if (store.getAll) {
+ this._getAllNative(getAllTransaction, store, onSuccess, onError);
+ } else {
+ this._getAllCursor(getAllTransaction, store, onSuccess, onError);
+ }
+
+ return getAllTransaction;
+ },
+
+ /**
+ * Implements getAll for IDB implementations that have a non-standard
+ * getAll() method.
+ *
+ * @param {Object} getAllTransaction An open READ transaction.
+ * @param {Object} store A reference to the store.
+ * @param {Function} onSuccess A callback that will be called if the
+ * operation was successful.
+ * @param {Function} onError A callback that will be called if an
+ * error occurred during the operation.
+ * @private
+ */
+ _getAllNative: function (getAllTransaction, store, onSuccess, onError) {
+ var hasSuccess = false,
+ result = null;
+
+ getAllTransaction.oncomplete = function () {
+ var callback = hasSuccess ? onSuccess : onError;
+ callback(result);
+ };
+ getAllTransaction.onabort = onError;
+ getAllTransaction.onerror = onError;
+
+ var getAllRequest = store.getAll();
+ getAllRequest.onsuccess = function (event) {
+ hasSuccess = true;
+ result = event.target.result;
+ };
+ getAllRequest.onerror = onError;
+ },
+
+ /**
+ * Implements getAll for IDB implementations that do not have a getAll()
+ * method.
+ *
+ * @param {Object} getAllTransaction An open READ transaction.
+ * @param {Object} store A reference to the store.
+ * @param {Function} onSuccess A callback that will be called if the
+ * operation was successful.
+ * @param {Function} onError A callback that will be called if an
+ * error occurred during the operation.
+ * @private
+ */
+ _getAllCursor: function (getAllTransaction, store, onSuccess, onError) {
+ var all = [],
+ hasSuccess = false,
+ result = null;
+
+ getAllTransaction.oncomplete = function () {
+ var callback = hasSuccess ? onSuccess : onError;
+ callback(result);
+ };
+ getAllTransaction.onabort = onError;
+ getAllTransaction.onerror = onError;
+
+ var cursorRequest = store.openCursor();
+ cursorRequest.onsuccess = function (event) {
+ var cursor = event.target.result;
+ if (cursor) {
+ all.push(cursor.value);
+ cursor['continue']();
+ }
+ else {
+ hasSuccess = true;
+ result = all;
+ }
+ };
+ cursorRequest.onError = onError;
+ },
+
+ /**
+ * Clears the store, i.e. deletes all entries in the store.
+ *
+ * @param {Function} [onSuccess] A callback that will be called if the
+ * operation was successful.
+ * @param {Function} [onError] A callback that will be called if an
+ * error occurred during the operation.
+ * @returns {IDBTransaction} The transaction used for this operation.
+ */
+ clear: function (onSuccess, onError) {
+ onError || (onError = defaultErrorHandler);
+ onSuccess || (onSuccess = noop);
+
+ var hasSuccess = false,
+ result = null;
+
+ var clearTransaction = this.db.transaction([this.storeName], this.consts.READ_WRITE);
+ clearTransaction.oncomplete = function () {
+ var callback = hasSuccess ? onSuccess : onError;
+ callback(result);
+ };
+ clearTransaction.onabort = onError;
+ clearTransaction.onerror = onError;
+
+ var clearRequest = clearTransaction.objectStore(this.storeName).clear();
+ clearRequest.onsuccess = function (event) {
+ hasSuccess = true;
+ result = event.target.result;
+ };
+ clearRequest.onerror = onError;
+
+ return clearTransaction;
+ },
+
+ /**
+ * Checks if an id property needs to present on a object and adds one if
+ * necessary.
+ *
+ * @param {Object} dataObj The data object that is about to be stored
+ * @private
+ */
+ _addIdPropertyIfNeeded: function (dataObj) {
+ if (!this.features.hasAutoIncrement && typeof dataObj[this.keyPath] == 'undefined') {
+ dataObj[this.keyPath] = this._insertIdCount++ + Date.now();
+ }
+ },
+
+ /************
+ * indexing *
+ ************/
+
+ /**
+ * Returns a DOMStringList of index names of the store.
+ *
+ * @return {DOMStringList} The list of index names
+ */
+ getIndexList: function () {
+ return this.store.indexNames;
+ },
+
+ /**
+ * Checks if an index with the given name exists in the store.
+ *
+ * @param {String} indexName The name of the index to look for
+ * @return {Boolean} Whether the store contains an index with the given name
+ */
+ hasIndex: function (indexName) {
+ return this.store.indexNames.contains(indexName);
+ },
+
+ /**
+ * Normalizes an object containing index data and assures that all
+ * properties are set.
+ *
+ * @param {Object} indexData The index data object to normalize
+ * @param {String} indexData.name The name of the index
+ * @param {String} [indexData.keyPath] The key path of the index
+ * @param {Boolean} [indexData.unique] Whether the index is unique
+ * @param {Boolean} [indexData.multiEntry] Whether the index is multi entry
+ */
+ normalizeIndexData: function (indexData) {
+ indexData.keyPath = indexData.keyPath || indexData.name;
+ indexData.unique = !!indexData.unique;
+ indexData.multiEntry = !!indexData.multiEntry;
+ },
+
+ /**
+ * Checks if an actual index complies with an expected index.
+ *
+ * @param {Object} actual The actual index found in the store
+ * @param {Object} expected An Object describing an expected index
+ * @return {Boolean} Whether both index definitions are identical
+ */
+ indexComplies: function (actual, expected) {
+ var complies = ['keyPath', 'unique', 'multiEntry'].every(function (key) {
+ // IE10 returns undefined for no multiEntry
+ if (key == 'multiEntry' && actual[key] === undefined && expected[key] === false) {
+ return true;
+ }
+ // Compound keys
+ if (key == 'keyPath' && Object.prototype.toString.call(expected[key]) == '[object Array]') {
+ var exp = expected.keyPath;
+ var act = actual.keyPath;
+
+ // IE10 can't handle keyPath sequences and stores them as a string.
+ // The index will be unusable there, but let's still return true if
+ // the keyPath sequence matches.
+ if (typeof act == 'string') {
+ return exp.toString() == act;
+ }
+
+ // Chrome/Opera stores keyPath squences as DOMStringList, Firefox
+ // as Array
+ if ( ! (typeof act.contains == 'function' || typeof act.indexOf == 'function') ) {
+ return false;
+ }
+
+ if (act.length !== exp.length) {
+ return false;
+ }
+
+ for (var i = 0, m = exp.length; i<m; i++) {
+ if ( ! ( (act.contains && act.contains(exp[i])) || act.indexOf(exp[i] !== -1) )) {
+ return false;
+ }
+ }
+ return true;
+ }
+ return expected[key] == actual[key];
+ });
+ return complies;
+ },
+
+ /**********
+ * cursor *
+ **********/
+
+ /**
+ * Iterates over the store using the given options and calling onItem
+ * for each entry matching the options.
+ *
+ * @param {Function} onItem A callback to be called for each match
+ * @param {Object} [options] An object defining specific options
+ * @param {Object} [options.index=null] An IDBIndex to operate on
+ * @param {String} [options.order=ASC] The order in which to provide the
+ * results, can be 'DESC' or 'ASC'
+ * @param {Boolean} [options.autoContinue=true] Whether to automatically
+ * iterate the cursor to the next result
+ * @param {Boolean} [options.filterDuplicates=false] Whether to exclude
+ * duplicate matches
+ * @param {Object} [options.keyRange=null] An IDBKeyRange to use
+ * @param {Boolean} [options.writeAccess=false] Whether grant write access
+ * to the store in the onItem callback
+ * @param {Function} [options.onEnd=null] A callback to be called after
+ * iteration has ended
+ * @param {Function} [options.onError=throw] A callback to be called
+ * if an error occurred during the operation.
+ * @returns {IDBTransaction} The transaction used for this operation.
+ */
+ iterate: function (onItem, options) {
+ options = mixin({
+ index: null,
+ order: 'ASC',
+ autoContinue: true,
+ filterDuplicates: false,
+ keyRange: null,
+ writeAccess: false,
+ onEnd: null,
+ onError: defaultErrorHandler
+ }, options || {});
+
+ var directionType = options.order.toLowerCase() == 'desc' ? 'PREV' : 'NEXT';
+ if (options.filterDuplicates) {
+ directionType += '_NO_DUPLICATE';
+ }
+
+ var hasSuccess = false;
+ var cursorTransaction = this.db.transaction([this.storeName], this.consts[options.writeAccess ? 'READ_WRITE' : 'READ_ONLY']);
+ var cursorTarget = cursorTransaction.objectStore(this.storeName);
+ if (options.index) {
+ cursorTarget = cursorTarget.index(options.index);
+ }
+
+ cursorTransaction.oncomplete = function () {
+ if (!hasSuccess) {
+ options.onError(null);
+ return;
+ }
+ if (options.onEnd) {
+ options.onEnd();
+ } else {
+ onItem(null);
+ }
+ };
+ cursorTransaction.onabort = options.onError;
+ cursorTransaction.onerror = options.onError;
+
+ var cursorRequest = cursorTarget.openCursor(options.keyRange, this.consts[directionType]);
+ cursorRequest.onerror = options.onError;
+ cursorRequest.onsuccess = function (event) {
+ var cursor = event.target.result;
+ if (cursor) {
+ onItem(cursor.value, cursor, cursorTransaction);
+ if (options.autoContinue) {
+ cursor['continue']();
+ }
+ } else {
+ hasSuccess = true;
+ }
+ };
+
+ return cursorTransaction;
+ },
+
+ /**
+ * Runs a query against the store and passes an array containing matched
+ * objects to the success handler.
+ *
+ * @param {Function} onSuccess A callback to be called when the operation
+ * was successful.
+ * @param {Object} [options] An object defining specific query options
+ * @param {Object} [options.index=null] An IDBIndex to operate on
+ * @param {String} [options.order=ASC] The order in which to provide the
+ * results, can be 'DESC' or 'ASC'
+ * @param {Boolean} [options.filterDuplicates=false] Whether to exclude
+ * duplicate matches
+ * @param {Object} [options.keyRange=null] An IDBKeyRange to use
+ * @param {Function} [options.onError=throw] A callback to be called if an error
+ * occurred during the operation.
+ * @returns {IDBTransaction} The transaction used for this operation.
+ */
+ query: function (onSuccess, options) {
+ var result = [];
+ options = options || {};
+ options.onEnd = function () {
+ onSuccess(result);
+ };
+ return this.iterate(function (item) {
+ result.push(item);
+ }, options);
+ },
+
+ /**
+ *
+ * Runs a query against the store, but only returns the number of matches
+ * instead of the matches itself.
+ *
+ * @param {Function} onSuccess A callback to be called if the opration
+ * was successful.
+ * @param {Object} [options] An object defining specific options
+ * @param {Object} [options.index=null] An IDBIndex to operate on
+ * @param {Object} [options.keyRange=null] An IDBKeyRange to use
+ * @param {Function} [options.onError=throw] A callback to be called if an error
+ * occurred during the operation.
+ * @returns {IDBTransaction} The transaction used for this operation.
+ */
+ count: function (onSuccess, options) {
+
+ options = mixin({
+ index: null,
+ keyRange: null
+ }, options || {});
+
+ var onError = options.onError || defaultErrorHandler;
+
+ var hasSuccess = false,
+ result = null;
+
+ var cursorTransaction = this.db.transaction([this.storeName], this.consts.READ_ONLY);
+ cursorTransaction.oncomplete = function () {
+ var callback = hasSuccess ? onSuccess : onError;
+ callback(result);
+ };
+ cursorTransaction.onabort = onError;
+ cursorTransaction.onerror = onError;
+
+ var cursorTarget = cursorTransaction.objectStore(this.storeName);
+ if (options.index) {
+ cursorTarget = cursorTarget.index(options.index);
+ }
+ var countRequest = cursorTarget.count(options.keyRange);
+ countRequest.onsuccess = function (evt) {
+ hasSuccess = true;
+ result = evt.target.result;
+ };
+ countRequest.onError = onError;
+
+ return cursorTransaction;
+ },
+
+ /**************/
+ /* key ranges */
+ /**************/
+
+ /**
+ * Creates a key range using specified options. This key range can be
+ * handed over to the count() and iterate() methods.
+ *
+ * Note: You must provide at least one or both of "lower" or "upper" value.
+ *
+ * @param {Object} options The options for the key range to create
+ * @param {*} [options.lower] The lower bound
+ * @param {Boolean} [options.excludeLower] Whether to exclude the lower
+ * bound passed in options.lower from the key range
+ * @param {*} [options.upper] The upper bound
+ * @param {Boolean} [options.excludeUpper] Whether to exclude the upper
+ * bound passed in options.upper from the key range
+ * @param {*} [options.only] A single key value. Use this if you need a key
+ * range that only includes one value for a key. Providing this
+ * property invalidates all other properties.
+ * @return {Object} The IDBKeyRange representing the specified options
+ */
+ makeKeyRange: function(options){
+ /*jshint onecase:true */
+ var keyRange,
+ hasLower = typeof options.lower != 'undefined',
+ hasUpper = typeof options.upper != 'undefined',
+ isOnly = typeof options.only != 'undefined';
+
+ switch(true){
+ case isOnly:
+ keyRange = this.keyRange.only(options.only);
+ break;
+ case hasLower && hasUpper:
+ keyRange = this.keyRange.bound(options.lower, options.upper, options.excludeLower, options.excludeUpper);
+ break;
+ case hasLower:
+ keyRange = this.keyRange.lowerBound(options.lower, options.excludeLower);
+ break;
+ case hasUpper:
+ keyRange = this.keyRange.upperBound(options.upper, options.excludeUpper);
+ break;
+ default:
+ throw new Error('Cannot create KeyRange. Provide one or both of "lower" or "upper" value, or an "only" value.');
+ }
+
+ return keyRange;
+
+ }
+
+ };
+
+ /** helpers **/
+
+ var noop = function () {
+ };
+ var empty = {};
+ var mixin = function (target, source) {
+ var name, s;
+ for (name in source) {
+ s = source[name];
+ if (s !== empty[name] && s !== target[name]) {
+ target[name] = s;
+ }
+ }
+ return target;
+ };
+
+ IDBStore.version = IDBStore.prototype.version;
+
+ return IDBStore;
+
+}, this);
+
+},{}],42:[function(require,module,exports){
+var Buffer = require('buffer').Buffer;
+
+module.exports = isBuffer;
+
+function isBuffer (o) {
+ return Buffer.isBuffer(o)
+ || /\[object (.+Array|Array.+)\]/.test(Object.prototype.toString.call(o));
+}
+
+},{"buffer":20}],43:[function(require,module,exports){
+(function (Buffer){
+
+exports.compare = function (a, b) {
+
+ if(Buffer.isBuffer(a)) {
+ var l = Math.min(a.length, b.length)
+ for(var i = 0; i < l; i++) {
+ var cmp = a[i] - b[i]
+ if(cmp) return cmp
+ }
+ return a.length - b.length
+ }
+
+ return a < b ? -1 : a > b ? 1 : 0
+}
+
+function has(obj, key) {
+ return Object.hasOwnProperty.call(obj, key)
+}
+
+// to be compatible with the current abstract-leveldown tests
+// nullish or empty strings.
+// I could use !!val but I want to permit numbers and booleans,
+// if possible.
+
+function isDef (val) {
+ return val != null && val !== ''
+}
+
+var lowerBound = exports.lowerBound = function (range) {
+ return (
+ isDef(range.gt) ? range.gt
+ : isDef(range.gte) ? range.gte
+ : isDef(range.min) ? range.min
+ : isDef(range.start) && !range.reverse ? range.start
+ : isDef(range.end) && range.reverse ? range.end
+ : undefined
+ )
+}
+
+exports.lowerBoundInclusive = function (range) {
+ return isDef(range.gt) ? false : true
+}
+
+exports.upperBoundInclusive =
+ function (range) {
+ return isDef(range.lt) ? false : true
+ }
+
+var lowerBoundExclusive = exports.lowerBoundExclusive =
+ function (range) {
+ return isDef(range.gt) ? true : false
+ }
+
+var upperBoundExclusive = exports.upperBoundExclusive =
+ function (range) {
+ return isDef(range.lt) ? true : false
+ }
+
+var upperBound = exports.upperBound = function (range) {
+ return (
+ isDef(range.lt) ? range.lt
+ : isDef(range.lte) ? range.lte
+ : isDef(range.max) ? range.max
+ : isDef(range.start) && range.reverse ? range.start
+ : isDef(range.end) && !range.reverse ? range.end
+ : undefined
+ )
+}
+
+
+exports.contains = function (range, key, compare) {
+ compare = compare || exports.compare
+
+ var lb = lowerBound(range)
+ if(isDef(lb)) {
+ var cmp = compare(key, lb)
+ if(cmp < 0 || (cmp === 0 && lowerBoundExclusive(range)))
+ return false
+ }
+
+ var ub = upperBound(range)
+ if(isDef(ub)) {
+ var cmp = compare(key, ub)
+ if(cmp > 0 || (cmp === 0) && upperBoundExclusive(range))
+ return false
+ }
+
+ return true
+}
+
+exports.filter = function (range, compare) {
+ return function (key) {
+ return exports.contains(range, key, compare)
+ }
+}
+
+}).call(this,require("buffer").Buffer)
+},{"buffer":20}],44:[function(require,module,exports){
+(function (Buffer){
+/**
+ * Convert a typed array to a Buffer without a copy
+ *
+ * Author: Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+ * License: MIT
+ *
+ * `npm install typedarray-to-buffer`
+ */
+
+module.exports = function (arr) {
+ if (typeof Buffer._augment === 'function' && Buffer._useTypedArrays) {
+ // If `Buffer` is from the `buffer` module and this browser supports typed arrays,
+ // then augment it with all the `Buffer` methods.
+ return Buffer._augment(arr)
+ } else {
+ // Otherwise, fallback to creating a `Buffer` with a copy.
+ return new Buffer(arr)
+ }
+}
+}).call(this,require("buffer").Buffer)
+},{"buffer":20}],45:[function(require,module,exports){
+module.exports = hasKeys
+
+function hasKeys(source) {
+ return source !== null &&
+ (typeof source === "object" ||
+ typeof source === "function")
+}
+
+},{}],46:[function(require,module,exports){
+var Keys = require("object-keys")
+var hasKeys = require("./has-keys")
+
+module.exports = extend
+
+function extend() {
+ var target = {}
+
+ for (var i = 0; i < arguments.length; i++) {
+ var source = arguments[i]
+
+ if (!hasKeys(source)) {
+ continue
+ }
+
+ var keys = Keys(source)
+
+ for (var j = 0; j < keys.length; j++) {
+ var name = keys[j]
+ target[name] = source[name]
+ }
+ }
+
+ return target
+}
+
+},{"./has-keys":45,"object-keys":48}],47:[function(require,module,exports){
+var hasOwn = Object.prototype.hasOwnProperty;
+var toString = Object.prototype.toString;
+
+var isFunction = function (fn) {
+ var isFunc = (typeof fn === 'function' && !(fn instanceof RegExp)) || toString.call(fn) === '[object Function]';
+ if (!isFunc && typeof window !== 'undefined') {
+ isFunc = fn === window.setTimeout || fn === window.alert || fn === window.confirm || fn === window.prompt;
+ }
+ return isFunc;
+};
+
+module.exports = function forEach(obj, fn) {
+ if (!isFunction(fn)) {
+ throw new TypeError('iterator must be a function');
+ }
+ var i, k,
+ isString = typeof obj === 'string',
+ l = obj.length,
+ context = arguments.length > 2 ? arguments[2] : null;
+ if (l === +l) {
+ for (i = 0; i < l; i++) {
+ if (context === null) {
+ fn(isString ? obj.charAt(i) : obj[i], i, obj);
+ } else {
+ fn.call(context, isString ? obj.charAt(i) : obj[i], i, obj);
+ }
+ }
+ } else {
+ for (k in obj) {
+ if (hasOwn.call(obj, k)) {
+ if (context === null) {
+ fn(obj[k], k, obj);
+ } else {
+ fn.call(context, obj[k], k, obj);
+ }
+ }
+ }
+ }
+};
+
+
+},{}],48:[function(require,module,exports){
+module.exports = Object.keys || require('./shim');
+
+
+},{"./shim":50}],49:[function(require,module,exports){
+var toString = Object.prototype.toString;
+
+module.exports = function isArguments(value) {
+ var str = toString.call(value);
+ var isArguments = str === '[object Arguments]';
+ if (!isArguments) {
+ isArguments = str !== '[object Array]'
+ && value !== null
+ && typeof value === 'object'
+ && typeof value.length === 'number'
+ && value.length >= 0
+ && toString.call(value.callee) === '[object Function]';
+ }
+ return isArguments;
+};
+
+
+},{}],50:[function(require,module,exports){
+(function () {
+ "use strict";
+
+ // modified from https://github.com/kriskowal/es5-shim
+ var has = Object.prototype.hasOwnProperty,
+ toString = Object.prototype.toString,
+ forEach = require('./foreach'),
+ isArgs = require('./isArguments'),
+ hasDontEnumBug = !({'toString': null}).propertyIsEnumerable('toString'),
+ hasProtoEnumBug = (function () {}).propertyIsEnumerable('prototype'),
+ dontEnums = [
+ "toString",
+ "toLocaleString",
+ "valueOf",
+ "hasOwnProperty",
+ "isPrototypeOf",
+ "propertyIsEnumerable",
+ "constructor"
+ ],
+ keysShim;
+
+ keysShim = function keys(object) {
+ var isObject = object !== null && typeof object === 'object',
+ isFunction = toString.call(object) === '[object Function]',
+ isArguments = isArgs(object),
+ theKeys = [];
+
+ if (!isObject && !isFunction && !isArguments) {
+ throw new TypeError("Object.keys called on a non-object");
+ }
+
+ if (isArguments) {
+ forEach(object, function (value) {
+ theKeys.push(value);
+ });
+ } else {
+ var name,
+ skipProto = hasProtoEnumBug && isFunction;
+
+ for (name in object) {
+ if (!(skipProto && name === 'prototype') && has.call(object, name)) {
+ theKeys.push(name);
+ }
+ }
+ }
+
+ if (hasDontEnumBug) {
+ var ctor = object.constructor,
+ skipConstructor = ctor && ctor.prototype === object;
+
+ forEach(dontEnums, function (dontEnum) {
+ if (!(skipConstructor && dontEnum === 'constructor') && has.call(object, dontEnum)) {
+ theKeys.push(dontEnum);
+ }
+ });
+ }
+ return theKeys;
+ };
+
+ module.exports = keysShim;
+}());
+
+
+},{"./foreach":47,"./isArguments":49}],51:[function(require,module,exports){
+function addOperation (type, key, value, options) {
+ var operation = {
+ type: type,
+ key: key,
+ value: value,
+ options: options
+ }
+
+ if (options && options.prefix) {
+ operation.prefix = options.prefix
+ delete options.prefix
+ }
+
+ this._operations.push(operation)
+
+ return this
+}
+
+function Batch(sdb) {
+ this._operations = []
+ this._sdb = sdb
+
+ this.put = addOperation.bind(this, 'put')
+ this.del = addOperation.bind(this, 'del')
+}
+
+var B = Batch.prototype
+
+
+B.clear = function () {
+ this._operations = []
+}
+
+B.write = function (cb) {
+ this._sdb.batch(this._operations, cb)
+}
+
+module.exports = Batch
+
+},{}],52:[function(require,module,exports){
+(function (process){
+var EventEmitter = require('events').EventEmitter
+var next = process.nextTick
+var SubDb = require('./sub')
+var Batch = require('./batch')
+var fixRange = require('level-fix-range')
+
+var Hooks = require('level-hooks')
+
+module.exports = function (_db, options) {
+ function DB () {}
+ DB.prototype = _db
+ var db = new DB()
+
+ if (db.sublevel) return db
+
+ options = options || {}
+
+ //use \xff (255) as the seperator,
+ //so that sections of the database will sort after the regular keys
+ var sep = options.sep = options.sep || '\xff'
+ db._options = options
+
+ Hooks(db)
+
+ db.sublevels = {}
+
+ db.sublevel = function (prefix, options) {
+ if(db.sublevels[prefix])
+ return db.sublevels[prefix]
+ return new SubDb(db, prefix, options || this._options)
+ }
+
+ db.methods = {}
+
+ db.prefix = function (key) {
+ return '' + (key || '')
+ }
+
+ db.pre = function (range, hook) {
+ if(!hook)
+ hook = range, range = {
+ max : sep
+ }
+ return db.hooks.pre(range, hook)
+ }
+
+ db.post = function (range, hook) {
+ if(!hook)
+ hook = range, range = {
+ max : sep
+ }
+ return db.hooks.post(range, hook)
+ }
+
+ function safeRange(fun) {
+ return function (opts) {
+ opts = opts || {}
+ opts = fixRange(opts)
+
+ if(opts.reverse) opts.start = opts.start || sep
+ else opts.end = opts.end || sep
+
+ return fun.call(db, opts)
+ }
+ }
+
+ db.readStream =
+ db.createReadStream = safeRange(db.createReadStream)
+ db.keyStream =
+ db.createKeyStream = safeRange(db.createKeyStream)
+ db.valuesStream =
+ db.createValueStream = safeRange(db.createValueStream)
+
+ var batch = db.batch
+ db.batch = function (changes, opts, cb) {
+ if(!Array.isArray(changes))
+ return new Batch(db)
+ changes.forEach(function (e) {
+ if(e.prefix) {
+ if('function' === typeof e.prefix.prefix)
+ e.key = e.prefix.prefix(e.key)
+ else if('string' === typeof e.prefix)
+ e.key = e.prefix + e.key
+ }
+ })
+ batch.call(db, changes, opts, cb)
+ }
+ return db
+}
+
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"./batch":51,"./sub":63,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"events":18,"level-fix-range":53,"level-hooks":55}],53:[function(require,module,exports){
+var clone = require('clone')
+
+module.exports =
+function fixRange(opts) {
+ opts = clone(opts)
+
+ var reverse = opts.reverse
+ var end = opts.max || opts.end
+ var start = opts.min || opts.start
+
+ var range = [start, end]
+ if(start != null && end != null)
+ range.sort()
+ if(reverse)
+ range = range.reverse()
+
+ opts.start = range[0]
+ opts.end = range[1]
+
+ delete opts.min
+ delete opts.max
+
+ return opts
+}
+
+},{"clone":54}],54:[function(require,module,exports){
+(function (Buffer){
+'use strict';
+
+function objectToString(o) {
+ return Object.prototype.toString.call(o);
+}
+
+// shim for Node's 'util' package
+// DO NOT REMOVE THIS! It is required for compatibility with EnderJS (http://enderjs.com/).
+var util = {
+ isArray: function (ar) {
+ return Array.isArray(ar) || (typeof ar === 'object' && objectToString(ar) === '[object Array]');
+ },
+ isDate: function (d) {
+ return typeof d === 'object' && objectToString(d) === '[object Date]';
+ },
+ isRegExp: function (re) {
+ return typeof re === 'object' && objectToString(re) === '[object RegExp]';
+ },
+ getRegExpFlags: function (re) {
+ var flags = '';
+ re.global && (flags += 'g');
+ re.ignoreCase && (flags += 'i');
+ re.multiline && (flags += 'm');
+ return flags;
+ }
+};
+
+
+if (typeof module === 'object')
+ module.exports = clone;
+
+/**
+ * Clones (copies) an Object using deep copying.
+ *
+ * This function supports circular references by default, but if you are certain
+ * there are no circular references in your object, you can save some CPU time
+ * by calling clone(obj, false).
+ *
+ * Caution: if `circular` is false and `parent` contains circular references,
+ * your program may enter an infinite loop and crash.
+ *
+ * @param `parent` - the object to be cloned
+ * @param `circular` - set to true if the object to be cloned may contain
+ * circular references. (optional - true by default)
+ * @param `depth` - set to a number if the object is only to be cloned to
+ * a particular depth. (optional - defaults to Infinity)
+ * @param `prototype` - sets the prototype to be used when cloning an object.
+ * (optional - defaults to parent prototype).
+*/
+
+function clone(parent, circular, depth, prototype) {
+ // maintain two arrays for circular references, where corresponding parents
+ // and children have the same index
+ var allParents = [];
+ var allChildren = [];
+
+ var useBuffer = typeof Buffer != 'undefined';
+
+ if (typeof circular == 'undefined')
+ circular = true;
+
+ if (typeof depth == 'undefined')
+ depth = Infinity;
+
+ // recurse this function so we don't reset allParents and allChildren
+ function _clone(parent, depth) {
+ // cloning null always returns null
+ if (parent === null)
+ return null;
+
+ if (depth == 0)
+ return parent;
+
+ var child;
+ if (typeof parent != 'object') {
+ return parent;
+ }
+
+ if (util.isArray(parent)) {
+ child = [];
+ } else if (util.isRegExp(parent)) {
+ child = new RegExp(parent.source, util.getRegExpFlags(parent));
+ if (parent.lastIndex) child.lastIndex = parent.lastIndex;
+ } else if (util.isDate(parent)) {
+ child = new Date(parent.getTime());
+ } else if (useBuffer && Buffer.isBuffer(parent)) {
+ child = new Buffer(parent.length);
+ parent.copy(child);
+ return child;
+ } else {
+ if (typeof prototype == 'undefined') child = Object.create(Object.getPrototypeOf(parent));
+ else child = Object.create(prototype);
+ }
+
+ if (circular) {
+ var index = allParents.indexOf(parent);
+
+ if (index != -1) {
+ return allChildren[index];
+ }
+ allParents.push(parent);
+ allChildren.push(child);
+ }
+
+ for (var i in parent) {
+ child[i] = _clone(parent[i], depth - 1);
+ }
+
+ return child;
+ }
+
+ return _clone(parent, depth);
+}
+
+/**
+ * Simple flat clone using prototype, accepts only objects, usefull for property
+ * override on FLAT configuration object (no nested props).
+ *
+ * USE WITH CAUTION! This may not behave as you wish if you do not know how this
+ * works.
+ */
+clone.clonePrototype = function(parent) {
+ if (parent === null)
+ return null;
+
+ var c = function () {};
+ c.prototype = parent;
+ return new c();
+};
+
+}).call(this,require("buffer").Buffer)
+},{"buffer":20}],55:[function(require,module,exports){
+var ranges = require('string-range')
+
+module.exports = function (db) {
+
+ if(db.hooks) {
+ return
+ }
+
+ var posthooks = []
+ var prehooks = []
+
+ function getPrefix (p) {
+ return p && (
+ 'string' === typeof p ? p
+ : 'string' === typeof p.prefix ? p.prefix
+ : 'function' === typeof p.prefix ? p.prefix()
+ : ''
+ )
+ }
+
+ function getKeyEncoding (db) {
+ if(db && db._getKeyEncoding)
+ return db._getKeyEncoding(db)
+ }
+
+ function getValueEncoding (db) {
+ if(db && db._getValueEncoding)
+ return db._getValueEncoding(db)
+ }
+
+ function remover (array, item) {
+ return function () {
+ var i = array.indexOf(item)
+ if(!~i) return false
+ array.splice(i, 1)
+ return true
+ }
+ }
+
+ db.hooks = {
+ post: function (prefix, hook) {
+ if(!hook) hook = prefix, prefix = ''
+ var h = {test: ranges.checker(prefix), hook: hook}
+ posthooks.push(h)
+ return remover(posthooks, h)
+ },
+ pre: function (prefix, hook) {
+ if(!hook) hook = prefix, prefix = ''
+ var h = {
+ test: ranges.checker(prefix),
+ hook: hook,
+ safe: false !== prefix.safe
+ }
+ prehooks.push(h)
+ return remover(prehooks, h)
+ },
+ posthooks: posthooks,
+ prehooks: prehooks
+ }
+
+ //POST HOOKS
+
+ function each (e) {
+ if(e && e.type) {
+ posthooks.forEach(function (h) {
+ if(h.test(e.key)) h.hook(e)
+ })
+ }
+ }
+
+ db.on('put', function (key, val) {
+ each({type: 'put', key: key, value: val})
+ })
+ db.on('del', function (key, val) {
+ each({type: 'del', key: key, value: val})
+ })
+ db.on('batch', function onBatch (ary) {
+ ary.forEach(each)
+ })
+
+ //PRE HOOKS
+
+ var put = db.put
+ var del = db.del
+ var batch = db.batch
+
+ function callHooks (isBatch, b, opts, cb) {
+ try {
+ b.forEach(function hook(e, i) {
+ prehooks.forEach(function (h) {
+ if(h.test(String(e.key))) {
+ //optimize this?
+ //maybe faster to not create a new object each time?
+ //have one object and expose scope to it?
+ var context = {
+ add: function (ch, db) {
+ if(typeof ch === 'undefined') {
+ return this
+ }
+ if(ch === false)
+ return delete b[i]
+ var prefix = (
+ getPrefix(ch.prefix) ||
+ getPrefix(db) ||
+ h.prefix || ''
+ )
+ //don't leave a circular json object there incase using multilevel.
+ if(prefix) ch.prefix = prefix
+ ch.key = prefix + ch.key
+ if(h.safe && h.test(String(ch.key))) {
+ //this usually means a stack overflow.
+ throw new Error('prehook cannot insert into own range')
+ }
+ var ke = ch.keyEncoding || getKeyEncoding(ch.prefix)
+ var ve = ch.valueEncoding || getValueEncoding(ch.prefix)
+ if(ke) ch.keyEncoding = ke
+ if(ve) ch.valueEncoding = ve
+
+ b.push(ch)
+ hook(ch, b.length - 1)
+ return this
+ },
+ put: function (ch, db) {
+ if('object' === typeof ch) ch.type = 'put'
+ return this.add(ch, db)
+ },
+ del: function (ch, db) {
+ if('object' === typeof ch) ch.type = 'del'
+ return this.add(ch, db)
+ },
+ veto: function () {
+ return this.add(false)
+ }
+ }
+ h.hook.call(context, e, context.add, b)
+ }
+ })
+ })
+ } catch (err) {
+ return (cb || opts)(err)
+ }
+ b = b.filter(function (e) {
+ return e && e.type //filter out empty items
+ })
+
+ if(b.length == 1 && !isBatch) {
+ var change = b[0]
+ return change.type == 'put'
+ ? put.call(db, change.key, change.value, opts, cb)
+ : del.call(db, change.key, opts, cb)
+ }
+ return batch.call(db, b, opts, cb)
+ }
+
+ db.put = function (key, value, opts, cb ) {
+ var batch = [{key: key, value: value, type: 'put'}]
+ return callHooks(false, batch, opts, cb)
+ }
+
+ db.del = function (key, opts, cb) {
+ var batch = [{key: key, type: 'del'}]
+ return callHooks(false, batch, opts, cb)
+ }
+
+ db.batch = function (batch, opts, cb) {
+ return callHooks(true, batch, opts, cb)
+ }
+}
+
+},{"string-range":56}],56:[function(require,module,exports){
+
+//force to a valid range
+var range = exports.range = function (obj) {
+ return null == obj ? {} : 'string' === typeof range ? {
+ min: range, max: range + '\xff'
+ } : obj
+}
+
+//turn into a sub range.
+var prefix = exports.prefix = function (range, within, term) {
+ range = exports.range(range)
+ var _range = {}
+ term = term || '\xff'
+ if(range instanceof RegExp || 'function' == typeof range) {
+ _range.min = within
+ _range.max = within + term,
+ _range.inner = function (k) {
+ var j = k.substring(within.length)
+ if(range.test)
+ return range.test(j)
+ return range(j)
+ }
+ }
+ else if('object' === typeof range) {
+ _range.min = within + (range.min || range.start || '')
+ _range.max = within + (range.max || range.end || (term || '~'))
+ _range.reverse = !!range.reverse
+ }
+ return _range
+}
+
+//return a function that checks a range
+var checker = exports.checker = function (range) {
+ if(!range) range = {}
+
+ if ('string' === typeof range)
+ return function (key) {
+ return key.indexOf(range) == 0
+ }
+ else if(range instanceof RegExp)
+ return function (key) {
+ return range.test(key)
+ }
+ else if('object' === typeof range)
+ return function (key) {
+ var min = range.min || range.start
+ var max = range.max || range.end
+
+ // fixes keys passed as ints from sublevels
+ key = String(key)
+
+ return (
+ !min || key >= min
+ ) && (
+ !max || key <= max
+ ) && (
+ !range.inner || (
+ range.inner.test
+ ? range.inner.test(key)
+ : range.inner(key)
+ )
+ )
+ }
+ else if('function' === typeof range)
+ return range
+}
+//check if a key is within a range.
+var satifies = exports.satisfies = function (key, range) {
+ return checker(range)(key)
+}
+
+
+
+},{}],57:[function(require,module,exports){
+module.exports=require(45)
+},{}],58:[function(require,module,exports){
+arguments[4][46][0].apply(exports,arguments)
+},{"./has-keys":57,"object-keys":59}],59:[function(require,module,exports){
+arguments[4][48][0].apply(exports,arguments)
+},{"./shim":62}],60:[function(require,module,exports){
+
+var hasOwn = Object.prototype.hasOwnProperty;
+var toString = Object.prototype.toString;
+
+module.exports = function forEach (obj, fn, ctx) {
+ if (toString.call(fn) !== '[object Function]') {
+ throw new TypeError('iterator must be a function');
+ }
+ var l = obj.length;
+ if (l === +l) {
+ for (var i = 0; i < l; i++) {
+ fn.call(ctx, obj[i], i, obj);
+ }
+ } else {
+ for (var k in obj) {
+ if (hasOwn.call(obj, k)) {
+ fn.call(ctx, obj[k], k, obj);
+ }
+ }
+ }
+};
+
+
+},{}],61:[function(require,module,exports){
+
+/**!
+ * is
+ * the definitive JavaScript type testing library
+ *
+ * @copyright 2013 Enrico Marino
+ * @license MIT
+ */
+
+var objProto = Object.prototype;
+var owns = objProto.hasOwnProperty;
+var toString = objProto.toString;
+var isActualNaN = function (value) {
+ return value !== value;
+};
+var NON_HOST_TYPES = {
+ "boolean": 1,
+ "number": 1,
+ "string": 1,
+ "undefined": 1
+};
+
+/**
+ * Expose `is`
+ */
+
+var is = module.exports = {};
+
+/**
+ * Test general.
+ */
+
+/**
+ * is.type
+ * Test if `value` is a type of `type`.
+ *
+ * @param {Mixed} value value to test
+ * @param {String} type type
+ * @return {Boolean} true if `value` is a type of `type`, false otherwise
+ * @api public
+ */
+
+is.a =
+is.type = function (value, type) {
+ return typeof value === type;
+};
+
+/**
+ * is.defined
+ * Test if `value` is defined.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if 'value' is defined, false otherwise
+ * @api public
+ */
+
+is.defined = function (value) {
+ return value !== undefined;
+};
+
+/**
+ * is.empty
+ * Test if `value` is empty.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is empty, false otherwise
+ * @api public
+ */
+
+is.empty = function (value) {
+ var type = toString.call(value);
+ var key;
+
+ if ('[object Array]' === type || '[object Arguments]' === type) {
+ return value.length === 0;
+ }
+
+ if ('[object Object]' === type) {
+ for (key in value) if (owns.call(value, key)) return false;
+ return true;
+ }
+
+ if ('[object String]' === type) {
+ return '' === value;
+ }
+
+ return false;
+};
+
+/**
+ * is.equal
+ * Test if `value` is equal to `other`.
+ *
+ * @param {Mixed} value value to test
+ * @param {Mixed} other value to compare with
+ * @return {Boolean} true if `value` is equal to `other`, false otherwise
+ */
+
+is.equal = function (value, other) {
+ var type = toString.call(value)
+ var key;
+
+ if (type !== toString.call(other)) {
+ return false;
+ }
+
+ if ('[object Object]' === type) {
+ for (key in value) {
+ if (!is.equal(value[key], other[key])) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ if ('[object Array]' === type) {
+ key = value.length;
+ if (key !== other.length) {
+ return false;
+ }
+ while (--key) {
+ if (!is.equal(value[key], other[key])) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ if ('[object Function]' === type) {
+ return value.prototype === other.prototype;
+ }
+
+ if ('[object Date]' === type) {
+ return value.getTime() === other.getTime();
+ }
+
+ return value === other;
+};
+
+/**
+ * is.hosted
+ * Test if `value` is hosted by `host`.
+ *
+ * @param {Mixed} value to test
+ * @param {Mixed} host host to test with
+ * @return {Boolean} true if `value` is hosted by `host`, false otherwise
+ * @api public
+ */
+
+is.hosted = function (value, host) {
+ var type = typeof host[value];
+ return type === 'object' ? !!host[value] : !NON_HOST_TYPES[type];
+};
+
+/**
+ * is.instance
+ * Test if `value` is an instance of `constructor`.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an instance of `constructor`
+ * @api public
+ */
+
+is.instance = is['instanceof'] = function (value, constructor) {
+ return value instanceof constructor;
+};
+
+/**
+ * is.null
+ * Test if `value` is null.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is null, false otherwise
+ * @api public
+ */
+
+is['null'] = function (value) {
+ return value === null;
+};
+
+/**
+ * is.undefined
+ * Test if `value` is undefined.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is undefined, false otherwise
+ * @api public
+ */
+
+is.undefined = function (value) {
+ return value === undefined;
+};
+
+/**
+ * Test arguments.
+ */
+
+/**
+ * is.arguments
+ * Test if `value` is an arguments object.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an arguments object, false otherwise
+ * @api public
+ */
+
+is.arguments = function (value) {
+ var isStandardArguments = '[object Arguments]' === toString.call(value);
+ var isOldArguments = !is.array(value) && is.arraylike(value) && is.object(value) && is.fn(value.callee);
+ return isStandardArguments || isOldArguments;
+};
+
+/**
+ * Test array.
+ */
+
+/**
+ * is.array
+ * Test if 'value' is an array.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an array, false otherwise
+ * @api public
+ */
+
+is.array = function (value) {
+ return '[object Array]' === toString.call(value);
+};
+
+/**
+ * is.arguments.empty
+ * Test if `value` is an empty arguments object.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an empty arguments object, false otherwise
+ * @api public
+ */
+is.arguments.empty = function (value) {
+ return is.arguments(value) && value.length === 0;
+};
+
+/**
+ * is.array.empty
+ * Test if `value` is an empty array.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an empty array, false otherwise
+ * @api public
+ */
+is.array.empty = function (value) {
+ return is.array(value) && value.length === 0;
+};
+
+/**
+ * is.arraylike
+ * Test if `value` is an arraylike object.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an arguments object, false otherwise
+ * @api public
+ */
+
+is.arraylike = function (value) {
+ return !!value && !is.boolean(value)
+ && owns.call(value, 'length')
+ && isFinite(value.length)
+ && is.number(value.length)
+ && value.length >= 0;
+};
+
+/**
+ * Test boolean.
+ */
+
+/**
+ * is.boolean
+ * Test if `value` is a boolean.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a boolean, false otherwise
+ * @api public
+ */
+
+is.boolean = function (value) {
+ return '[object Boolean]' === toString.call(value);
+};
+
+/**
+ * is.false
+ * Test if `value` is false.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is false, false otherwise
+ * @api public
+ */
+
+is['false'] = function (value) {
+ return is.boolean(value) && (value === false || value.valueOf() === false);
+};
+
+/**
+ * is.true
+ * Test if `value` is true.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is true, false otherwise
+ * @api public
+ */
+
+is['true'] = function (value) {
+ return is.boolean(value) && (value === true || value.valueOf() === true);
+};
+
+/**
+ * Test date.
+ */
+
+/**
+ * is.date
+ * Test if `value` is a date.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a date, false otherwise
+ * @api public
+ */
+
+is.date = function (value) {
+ return '[object Date]' === toString.call(value);
+};
+
+/**
+ * Test element.
+ */
+
+/**
+ * is.element
+ * Test if `value` is an html element.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an HTML Element, false otherwise
+ * @api public
+ */
+
+is.element = function (value) {
+ return value !== undefined
+ && typeof HTMLElement !== 'undefined'
+ && value instanceof HTMLElement
+ && value.nodeType === 1;
+};
+
+/**
+ * Test error.
+ */
+
+/**
+ * is.error
+ * Test if `value` is an error object.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an error object, false otherwise
+ * @api public
+ */
+
+is.error = function (value) {
+ return '[object Error]' === toString.call(value);
+};
+
+/**
+ * Test function.
+ */
+
+/**
+ * is.fn / is.function (deprecated)
+ * Test if `value` is a function.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a function, false otherwise
+ * @api public
+ */
+
+is.fn = is['function'] = function (value) {
+ var isAlert = typeof window !== 'undefined' && value === window.alert;
+ return isAlert || '[object Function]' === toString.call(value);
+};
+
+/**
+ * Test number.
+ */
+
+/**
+ * is.number
+ * Test if `value` is a number.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a number, false otherwise
+ * @api public
+ */
+
+is.number = function (value) {
+ return '[object Number]' === toString.call(value);
+};
+
+/**
+ * is.infinite
+ * Test if `value` is positive or negative infinity.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is positive or negative Infinity, false otherwise
+ * @api public
+ */
+is.infinite = function (value) {
+ return value === Infinity || value === -Infinity;
+};
+
+/**
+ * is.decimal
+ * Test if `value` is a decimal number.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a decimal number, false otherwise
+ * @api public
+ */
+
+is.decimal = function (value) {
+ return is.number(value) && !isActualNaN(value) && !is.infinite(value) && value % 1 !== 0;
+};
+
+/**
+ * is.divisibleBy
+ * Test if `value` is divisible by `n`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} n dividend
+ * @return {Boolean} true if `value` is divisible by `n`, false otherwise
+ * @api public
+ */
+
+is.divisibleBy = function (value, n) {
+ var isDividendInfinite = is.infinite(value);
+ var isDivisorInfinite = is.infinite(n);
+ var isNonZeroNumber = is.number(value) && !isActualNaN(value) && is.number(n) && !isActualNaN(n) && n !== 0;
+ return isDividendInfinite || isDivisorInfinite || (isNonZeroNumber && value % n === 0);
+};
+
+/**
+ * is.int
+ * Test if `value` is an integer.
+ *
+ * @param value to test
+ * @return {Boolean} true if `value` is an integer, false otherwise
+ * @api public
+ */
+
+is.int = function (value) {
+ return is.number(value) && !isActualNaN(value) && value % 1 === 0;
+};
+
+/**
+ * is.maximum
+ * Test if `value` is greater than 'others' values.
+ *
+ * @param {Number} value value to test
+ * @param {Array} others values to compare with
+ * @return {Boolean} true if `value` is greater than `others` values
+ * @api public
+ */
+
+is.maximum = function (value, others) {
+ if (isActualNaN(value)) {
+ throw new TypeError('NaN is not a valid value');
+ } else if (!is.arraylike(others)) {
+ throw new TypeError('second argument must be array-like');
+ }
+ var len = others.length;
+
+ while (--len >= 0) {
+ if (value < others[len]) {
+ return false;
+ }
+ }
+
+ return true;
+};
+
+/**
+ * is.minimum
+ * Test if `value` is less than `others` values.
+ *
+ * @param {Number} value value to test
+ * @param {Array} others values to compare with
+ * @return {Boolean} true if `value` is less than `others` values
+ * @api public
+ */
+
+is.minimum = function (value, others) {
+ if (isActualNaN(value)) {
+ throw new TypeError('NaN is not a valid value');
+ } else if (!is.arraylike(others)) {
+ throw new TypeError('second argument must be array-like');
+ }
+ var len = others.length;
+
+ while (--len >= 0) {
+ if (value > others[len]) {
+ return false;
+ }
+ }
+
+ return true;
+};
+
+/**
+ * is.nan
+ * Test if `value` is not a number.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is not a number, false otherwise
+ * @api public
+ */
+
+is.nan = function (value) {
+ return !is.number(value) || value !== value;
+};
+
+/**
+ * is.even
+ * Test if `value` is an even number.
+ *
+ * @param {Number} value value to test
+ * @return {Boolean} true if `value` is an even number, false otherwise
+ * @api public
+ */
+
+is.even = function (value) {
+ return is.infinite(value) || (is.number(value) && value === value && value % 2 === 0);
+};
+
+/**
+ * is.odd
+ * Test if `value` is an odd number.
+ *
+ * @param {Number} value value to test
+ * @return {Boolean} true if `value` is an odd number, false otherwise
+ * @api public
+ */
+
+is.odd = function (value) {
+ return is.infinite(value) || (is.number(value) && value === value && value % 2 !== 0);
+};
+
+/**
+ * is.ge
+ * Test if `value` is greater than or equal to `other`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} other value to compare with
+ * @return {Boolean}
+ * @api public
+ */
+
+is.ge = function (value, other) {
+ if (isActualNaN(value) || isActualNaN(other)) {
+ throw new TypeError('NaN is not a valid value');
+ }
+ return !is.infinite(value) && !is.infinite(other) && value >= other;
+};
+
+/**
+ * is.gt
+ * Test if `value` is greater than `other`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} other value to compare with
+ * @return {Boolean}
+ * @api public
+ */
+
+is.gt = function (value, other) {
+ if (isActualNaN(value) || isActualNaN(other)) {
+ throw new TypeError('NaN is not a valid value');
+ }
+ return !is.infinite(value) && !is.infinite(other) && value > other;
+};
+
+/**
+ * is.le
+ * Test if `value` is less than or equal to `other`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} other value to compare with
+ * @return {Boolean} if 'value' is less than or equal to 'other'
+ * @api public
+ */
+
+is.le = function (value, other) {
+ if (isActualNaN(value) || isActualNaN(other)) {
+ throw new TypeError('NaN is not a valid value');
+ }
+ return !is.infinite(value) && !is.infinite(other) && value <= other;
+};
+
+/**
+ * is.lt
+ * Test if `value` is less than `other`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} other value to compare with
+ * @return {Boolean} if `value` is less than `other`
+ * @api public
+ */
+
+is.lt = function (value, other) {
+ if (isActualNaN(value) || isActualNaN(other)) {
+ throw new TypeError('NaN is not a valid value');
+ }
+ return !is.infinite(value) && !is.infinite(other) && value < other;
+};
+
+/**
+ * is.within
+ * Test if `value` is within `start` and `finish`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} start lower bound
+ * @param {Number} finish upper bound
+ * @return {Boolean} true if 'value' is is within 'start' and 'finish'
+ * @api public
+ */
+is.within = function (value, start, finish) {
+ if (isActualNaN(value) || isActualNaN(start) || isActualNaN(finish)) {
+ throw new TypeError('NaN is not a valid value');
+ } else if (!is.number(value) || !is.number(start) || !is.number(finish)) {
+ throw new TypeError('all arguments must be numbers');
+ }
+ var isAnyInfinite = is.infinite(value) || is.infinite(start) || is.infinite(finish);
+ return isAnyInfinite || (value >= start && value <= finish);
+};
+
+/**
+ * Test object.
+ */
+
+/**
+ * is.object
+ * Test if `value` is an object.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an object, false otherwise
+ * @api public
+ */
+
+is.object = function (value) {
+ return value && '[object Object]' === toString.call(value);
+};
+
+/**
+ * is.hash
+ * Test if `value` is a hash - a plain object literal.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a hash, false otherwise
+ * @api public
+ */
+
+is.hash = function (value) {
+ return is.object(value) && value.constructor === Object && !value.nodeType && !value.setInterval;
+};
+
+/**
+ * Test regexp.
+ */
+
+/**
+ * is.regexp
+ * Test if `value` is a regular expression.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a regexp, false otherwise
+ * @api public
+ */
+
+is.regexp = function (value) {
+ return '[object RegExp]' === toString.call(value);
+};
+
+/**
+ * Test string.
+ */
+
+/**
+ * is.string
+ * Test if `value` is a string.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if 'value' is a string, false otherwise
+ * @api public
+ */
+
+is.string = function (value) {
+ return '[object String]' === toString.call(value);
+};
+
+
+},{}],62:[function(require,module,exports){
+(function () {
+ "use strict";
+
+ // modified from https://github.com/kriskowal/es5-shim
+ var has = Object.prototype.hasOwnProperty,
+ is = require('is'),
+ forEach = require('foreach'),
+ hasDontEnumBug = !({'toString': null}).propertyIsEnumerable('toString'),
+ dontEnums = [
+ "toString",
+ "toLocaleString",
+ "valueOf",
+ "hasOwnProperty",
+ "isPrototypeOf",
+ "propertyIsEnumerable",
+ "constructor"
+ ],
+ keysShim;
+
+ keysShim = function keys(object) {
+ if (!is.object(object) && !is.array(object)) {
+ throw new TypeError("Object.keys called on a non-object");
+ }
+
+ var name, theKeys = [];
+ for (name in object) {
+ if (has.call(object, name)) {
+ theKeys.push(name);
+ }
+ }
+
+ if (hasDontEnumBug) {
+ forEach(dontEnums, function (dontEnum) {
+ if (has.call(object, dontEnum)) {
+ theKeys.push(dontEnum);
+ }
+ });
+ }
+ return theKeys;
+ };
+
+ module.exports = keysShim;
+}());
+
+
+},{"foreach":60,"is":61}],63:[function(require,module,exports){
+var EventEmitter = require('events').EventEmitter
+var inherits = require('util').inherits
+var ranges = require('string-range')
+var fixRange = require('level-fix-range')
+var xtend = require('xtend')
+var Batch = require('./batch')
+
+inherits(SubDB, EventEmitter)
+
+function SubDB (db, prefix, options) {
+ if('string' === typeof options) {
+ console.error('db.sublevel(name, seperator<string>) is depreciated')
+ console.error('use db.sublevel(name, {sep: separator})) if you must')
+ options = {sep: options}
+ }
+ if(!(this instanceof SubDB)) return new SubDB(db, prefix, options)
+ if(!db) throw new Error('must provide db')
+ if(!prefix) throw new Error('must provide prefix')
+
+ options = options || {}
+ options.sep = options.sep || '\xff'
+
+ this._parent = db
+ this._options = options
+ this.options = options
+ this._prefix = prefix
+ this._root = root(this)
+ db.sublevels[prefix] = this
+ this.sublevels = {}
+ this.methods = {}
+ var self = this
+ this.hooks = {
+ pre: function () {
+ return self.pre.apply(self, arguments)
+ },
+ post: function () {
+ return self.post.apply(self, arguments)
+ }
+ }
+}
+
+var SDB = SubDB.prototype
+
+SDB._key = function (key) {
+ var sep = this._options.sep
+ return sep
+ + this._prefix
+ + sep
+ + key
+}
+
+SDB._getOptsAndCb = function (opts, cb) {
+ if (typeof opts == 'function') {
+ cb = opts
+ opts = {}
+ }
+ return { opts: xtend(opts, this._options), cb: cb }
+}
+
+SDB.sublevel = function (prefix, options) {
+ if(this.sublevels[prefix])
+ return this.sublevels[prefix]
+ return new SubDB(this, prefix, options || this._options)
+}
+
+SDB.put = function (key, value, opts, cb) {
+ var res = this._getOptsAndCb(opts, cb)
+ this._root.put(this.prefix(key), value, res.opts, res.cb)
+}
+
+SDB.get = function (key, opts, cb) {
+ var res = this._getOptsAndCb(opts, cb)
+ this._root.get(this.prefix(key), res.opts, res.cb)
+}
+
+SDB.del = function (key, opts, cb) {
+ var res = this._getOptsAndCb(opts, cb)
+ this._root.del(this.prefix(key), res.opts, res.cb)
+}
+
+SDB.batch = function (changes, opts, cb) {
+ if(!Array.isArray(changes))
+ return new Batch(this)
+ var self = this,
+ res = this._getOptsAndCb(opts, cb)
+ changes.forEach(function (ch) {
+
+ //OH YEAH, WE NEED TO VALIDATE THAT UPDATING THIS KEY/PREFIX IS ALLOWED
+ if('string' === typeof ch.prefix)
+ ch.key = ch.prefix + ch.key
+ else
+ ch.key = (ch.prefix || self).prefix(ch.key)
+
+ if(ch.prefix) ch.prefix = null
+ })
+ this._root.batch(changes, res.opts, res.cb)
+}
+
+SDB._getKeyEncoding = function () {
+ if(this.options.keyEncoding)
+ return this.options.keyEncoding
+ if(this._parent && this._parent._getKeyEncoding)
+ return this._parent._getKeyEncoding()
+}
+
+SDB._getValueEncoding = function () {
+ if(this.options.valueEncoding)
+ return this.options.valueEncoding
+ if(this._parent && this._parent._getValueEncoding)
+ return this._parent._getValueEncoding()
+}
+
+SDB.prefix = function (key) {
+ var sep = this._options.sep
+ return this._parent.prefix() + sep + this._prefix + sep + (key || '')
+}
+
+SDB.keyStream =
+SDB.createKeyStream = function (opts) {
+ opts = opts || {}
+ opts.keys = true
+ opts.values = false
+ return this.createReadStream(opts)
+}
+
+SDB.valueStream =
+SDB.createValueStream = function (opts) {
+ opts = opts || {}
+ opts.keys = false
+ opts.values = true
+ opts.keys = false
+ return this.createReadStream(opts)
+}
+
+function selectivelyMerge(_opts, opts) {
+ [ 'valueEncoding'
+ , 'encoding'
+ , 'keyEncoding'
+ , 'reverse'
+ , 'values'
+ , 'keys'
+ , 'limit'
+ , 'fillCache'
+ ]
+ .forEach(function (k) {
+ if (opts.hasOwnProperty(k)) _opts[k] = opts[k]
+ })
+}
+
+SDB.readStream =
+SDB.createReadStream = function (opts) {
+ opts = opts || {}
+ var r = root(this)
+ var p = this.prefix()
+
+ var _opts = ranges.prefix(opts, p)
+ selectivelyMerge(_opts, xtend(opts, this._options))
+
+ var s = r.createReadStream(_opts)
+
+ if(_opts.values === false) {
+ var read = s.read
+ if (read) {
+ s.read = function (size) {
+ var val = read.call(this, size)
+ if (val) val = val.substring(p.length)
+ return val
+ }
+ } else {
+ var emit = s.emit
+ s.emit = function (event, val) {
+ if(event === 'data') {
+ emit.call(this, 'data', val.substring(p.length))
+ } else
+ emit.call(this, event, val)
+ }
+ }
+ return s
+ } else if(_opts.keys === false)
+ return s
+ else {
+ var read = s.read
+ if (read) {
+ s.read = function (size) {
+ var d = read.call(this, size)
+ if (d) d.key = d.key.substring(p.length)
+ return d
+ }
+ } else {
+ s.on('data', function (d) {
+ //mutate the prefix!
+ //this doesn't work for createKeyStream admittedly.
+ d.key = d.key.substring(p.length)
+ })
+ }
+ return s
+ }
+}
+
+
+SDB.writeStream =
+SDB.createWriteStream = function () {
+ var r = root(this)
+ var p = this.prefix()
+ var ws = r.createWriteStream.apply(r, arguments)
+ var write = ws.write
+
+ var encoding = this._options.encoding
+ var valueEncoding = this._options.valueEncoding
+ var keyEncoding = this._options.keyEncoding
+
+ // slight optimization, if no encoding was specified at all,
+ // which will be the case most times, make write not check at all
+ var nocheck = !encoding && !valueEncoding && !keyEncoding
+
+ ws.write = nocheck
+ ? function (data) {
+ data.key = p + data.key
+ return write.call(ws, data)
+ }
+ : function (data) {
+ data.key = p + data.key
+
+ // not merging all options here since this happens on every write and things could get slowed down
+ // at this point we only consider encoding important to propagate
+ if (encoding && typeof data.encoding === 'undefined')
+ data.encoding = encoding
+ if (valueEncoding && typeof data.valueEncoding === 'undefined')
+ data.valueEncoding = valueEncoding
+ if (keyEncoding && typeof data.keyEncoding === 'undefined')
+ data.keyEncoding = keyEncoding
+
+ return write.call(ws, data)
+ }
+ return ws
+}
+
+SDB.approximateSize = function () {
+ var r = root(db)
+ return r.approximateSize.apply(r, arguments)
+}
+
+function root(db) {
+ if(!db._parent) return db
+ return root(db._parent)
+}
+
+SDB.pre = function (range, hook) {
+ if(!hook) hook = range, range = null
+ range = ranges.prefix(range, this.prefix(), this._options.sep)
+ var r = root(this._parent)
+ var p = this.prefix()
+ return r.hooks.pre(fixRange(range), function (ch, add, batch) {
+ hook({
+ key: ch.key.substring(p.length),
+ value: ch.value,
+ type: ch.type
+ }, function (ch, _p) {
+ //maybe remove the second add arg now
+ //that op can have prefix?
+ add(ch, ch.prefix ? _p : (_p || p))
+ }, batch)
+ })
+}
+
+SDB.post = function (range, hook) {
+ if(!hook) hook = range, range = null
+ var r = root(this._parent)
+ var p = this.prefix()
+ range = ranges.prefix(range, p, this._options.sep)
+ return r.hooks.post(fixRange(range), function (data) {
+ hook({key: data.key.substring(p.length), value: data.value, type: data.type})
+ })
+}
+
+var exports = module.exports = SubDB
+
+
+},{"./batch":51,"events":18,"level-fix-range":53,"string-range":56,"util":32,"xtend":58}],64:[function(require,module,exports){
+/* Copyright (c) 2012-2014 LevelUP contributors
+ * See list at <https://github.com/rvagg/node-levelup#contributing>
+ * MIT License
+ * <https://github.com/rvagg/node-levelup/blob/master/LICENSE.md>
+ */
+
+var util = require('./util')
+ , WriteError = require('./errors').WriteError
+
+ , getOptions = util.getOptions
+ , dispatchError = util.dispatchError
+
+function Batch (levelup) {
+ this._levelup = levelup
+ this.batch = levelup.db.batch()
+ this.ops = []
+}
+
+Batch.prototype.put = function (key_, value_, options) {
+ options = getOptions(this._levelup, options)
+
+ var key = util.encodeKey(key_, options)
+ , value = util.encodeValue(value_, options)
+
+ try {
+ this.batch.put(key, value)
+ } catch (e) {
+ throw new WriteError(e)
+ }
+ this.ops.push({ type : 'put', key : key, value : value })
+
+ return this
+}
+
+Batch.prototype.del = function (key_, options) {
+ options = getOptions(this._levelup, options)
+
+ var key = util.encodeKey(key_, options)
+
+ try {
+ this.batch.del(key)
+ } catch (err) {
+ throw new WriteError(err)
+ }
+ this.ops.push({ type : 'del', key : key })
+
+ return this
+}
+
+Batch.prototype.clear = function () {
+ try {
+ this.batch.clear()
+ } catch (err) {
+ throw new WriteError(err)
+ }
+
+ this.ops = []
+ return this
+}
+
+Batch.prototype.write = function (callback) {
+ var levelup = this._levelup
+ , ops = this.ops
+
+ try {
+ this.batch.write(function (err) {
+ if (err)
+ return dispatchError(levelup, new WriteError(err), callback)
+ levelup.emit('batch', ops)
+ if (callback)
+ callback()
+ })
+ } catch (err) {
+ throw new WriteError(err)
+ }
+}
+
+module.exports = Batch
+
+},{"./errors":65,"./util":68}],65:[function(require,module,exports){
+/* Copyright (c) 2012-2014 LevelUP contributors
+ * See list at <https://github.com/rvagg/node-levelup#contributing>
+ * MIT License
+ * <https://github.com/rvagg/node-levelup/blob/master/LICENSE.md>
+ */
+
+var createError = require('errno').create
+ , LevelUPError = createError('LevelUPError')
+ , NotFoundError = createError('NotFoundError', LevelUPError)
+
+NotFoundError.prototype.notFound = true
+NotFoundError.prototype.status = 404
+
+module.exports = {
+ LevelUPError : LevelUPError
+ , InitializationError : createError('InitializationError', LevelUPError)
+ , OpenError : createError('OpenError', LevelUPError)
+ , ReadError : createError('ReadError', LevelUPError)
+ , WriteError : createError('WriteError', LevelUPError)
+ , NotFoundError : NotFoundError
+ , EncodingError : createError('EncodingError', LevelUPError)
+}
+
+},{"errno":76}],66:[function(require,module,exports){
+(function (process){
+/* Copyright (c) 2012-2014 LevelUP contributors
+ * See list at <https://github.com/rvagg/node-levelup#contributing>
+ * MIT License
+ * <https://github.com/rvagg/node-levelup/blob/master/LICENSE.md>
+ */
+
+var EventEmitter = require('events').EventEmitter
+ , inherits = require('util').inherits
+ , extend = require('xtend')
+ , prr = require('prr')
+ , DeferredLevelDOWN = require('deferred-leveldown')
+
+ , WriteError = require('./errors').WriteError
+ , ReadError = require('./errors').ReadError
+ , NotFoundError = require('./errors').NotFoundError
+ , OpenError = require('./errors').OpenError
+ , EncodingError = require('./errors').EncodingError
+ , InitializationError = require('./errors').InitializationError
+
+ , ReadStream = require('./read-stream')
+ , WriteStream = require('./write-stream')
+ , util = require('./util')
+ , Batch = require('./batch')
+
+ , getOptions = util.getOptions
+ , defaultOptions = util.defaultOptions
+ , getLevelDOWN = util.getLevelDOWN
+ , dispatchError = util.dispatchError
+
+function getCallback (options, callback) {
+ return typeof options == 'function' ? options : callback
+}
+
+// Possible LevelUP#_status values:
+// - 'new' - newly created, not opened or closed
+// - 'opening' - waiting for the database to be opened, post open()
+// - 'open' - successfully opened the database, available for use
+// - 'closing' - waiting for the database to be closed, post close()
+// - 'closed' - database has been successfully closed, should not be
+// used except for another open() operation
+
+function LevelUP (location, options, callback) {
+ if (!(this instanceof LevelUP))
+ return new LevelUP(location, options, callback)
+
+ var error
+
+ EventEmitter.call(this)
+ this.setMaxListeners(Infinity)
+
+ if (typeof location == 'function') {
+ options = typeof options == 'object' ? options : {}
+ options.db = location
+ location = null
+ } else if (typeof location == 'object' && typeof location.db == 'function') {
+ options = location
+ location = null
+ }
+
+ if (typeof options == 'function') {
+ callback = options
+ options = {}
+ }
+
+ if ((!options || typeof options.db != 'function') && typeof location != 'string') {
+ error = new InitializationError(
+ 'Must provide a location for the database')
+ if (callback) {
+ return process.nextTick(function () {
+ callback(error)
+ })
+ }
+ throw error
+ }
+
+ options = getOptions(this, options)
+ this.options = extend(defaultOptions, options)
+ this._status = 'new'
+ // set this.location as enumerable but not configurable or writable
+ prr(this, 'location', location, 'e')
+
+ this.open(callback)
+}
+
+inherits(LevelUP, EventEmitter)
+
+LevelUP.prototype.open = function (callback) {
+ var self = this
+ , dbFactory
+ , db
+
+ if (this.isOpen()) {
+ if (callback)
+ process.nextTick(function () { callback(null, self) })
+ return this
+ }
+
+ if (this._isOpening()) {
+ return callback && this.once(
+ 'open'
+ , function () { callback(null, self) }
+ )
+ }
+
+ this.emit('opening')
+
+ this._status = 'opening'
+ this.db = new DeferredLevelDOWN(this.location)
+ dbFactory = this.options.db || getLevelDOWN()
+ db = dbFactory(this.location)
+
+ db.open(this.options, function (err) {
+ if (err) {
+ return dispatchError(self, new OpenError(err), callback)
+ } else {
+ self.db.setDb(db)
+ self.db = db
+ self._status = 'open'
+ if (callback)
+ callback(null, self)
+ self.emit('open')
+ self.emit('ready')
+ }
+ })
+}
+
+LevelUP.prototype.close = function (callback) {
+ var self = this
+
+ if (this.isOpen()) {
+ this._status = 'closing'
+ this.db.close(function () {
+ self._status = 'closed'
+ self.emit('closed')
+ if (callback)
+ callback.apply(null, arguments)
+ })
+ this.emit('closing')
+ this.db = null
+ } else if (this._status == 'closed' && callback) {
+ return process.nextTick(callback)
+ } else if (this._status == 'closing' && callback) {
+ this.once('closed', callback)
+ } else if (this._isOpening()) {
+ this.once('open', function () {
+ self.close(callback)
+ })
+ }
+}
+
+LevelUP.prototype.isOpen = function () {
+ return this._status == 'open'
+}
+
+LevelUP.prototype._isOpening = function () {
+ return this._status == 'opening'
+}
+
+LevelUP.prototype.isClosed = function () {
+ return (/^clos/).test(this._status)
+}
+
+LevelUP.prototype.get = function (key_, options, callback) {
+ var self = this
+ , key
+
+ callback = getCallback(options, callback)
+
+ if (typeof callback != 'function') {
+ return dispatchError(
+ this
+ , new ReadError('get() requires key and callback arguments')
+ )
+ }
+
+ if (!this._isOpening() && !this.isOpen()) {
+ return dispatchError(
+ this
+ , new ReadError('Database is not open')
+ , callback
+ )
+ }
+
+ options = util.getOptions(this, options)
+ key = util.encodeKey(key_, options)
+
+ options.asBuffer = util.isValueAsBuffer(options)
+
+ this.db.get(key, options, function (err, value) {
+ if (err) {
+ if ((/notfound/i).test(err)) {
+ err = new NotFoundError(
+ 'Key not found in database [' + key_ + ']', err)
+ } else {
+ err = new ReadError(err)
+ }
+ return dispatchError(self, err, callback)
+ }
+ if (callback) {
+ try {
+ value = util.decodeValue(value, options)
+ } catch (e) {
+ return callback(new EncodingError(e))
+ }
+ callback(null, value)
+ }
+ })
+}
+
+LevelUP.prototype.put = function (key_, value_, options, callback) {
+ var self = this
+ , key
+ , value
+
+ callback = getCallback(options, callback)
+
+ if (key_ === null || key_ === undefined
+ || value_ === null || value_ === undefined) {
+ return dispatchError(
+ this
+ , new WriteError('put() requires key and value arguments')
+ , callback
+ )
+ }
+
+ if (!this._isOpening() && !this.isOpen()) {
+ return dispatchError(
+ this
+ , new WriteError('Database is not open')
+ , callback
+ )
+ }
+
+ options = getOptions(this, options)
+ key = util.encodeKey(key_, options)
+ value = util.encodeValue(value_, options)
+
+ this.db.put(key, value, options, function (err) {
+ if (err) {
+ return dispatchError(self, new WriteError(err), callback)
+ } else {
+ self.emit('put', key_, value_)
+ if (callback)
+ callback()
+ }
+ })
+}
+
+LevelUP.prototype.del = function (key_, options, callback) {
+ var self = this
+ , key
+
+ callback = getCallback(options, callback)
+
+ if (key_ === null || key_ === undefined) {
+ return dispatchError(
+ this
+ , new WriteError('del() requires a key argument')
+ , callback
+ )
+ }
+
+ if (!this._isOpening() && !this.isOpen()) {
+ return dispatchError(
+ this
+ , new WriteError('Database is not open')
+ , callback
+ )
+ }
+
+ options = getOptions(this, options)
+ key = util.encodeKey(key_, options)
+
+ this.db.del(key, options, function (err) {
+ if (err) {
+ return dispatchError(self, new WriteError(err), callback)
+ } else {
+ self.emit('del', key_)
+ if (callback)
+ callback()
+ }
+ })
+}
+
+LevelUP.prototype.batch = function (arr_, options, callback) {
+ var self = this
+ , keyEnc
+ , valueEnc
+ , arr
+
+ if (!arguments.length)
+ return new Batch(this)
+
+ callback = getCallback(options, callback)
+
+ if (!Array.isArray(arr_)) {
+ return dispatchError(
+ this
+ , new WriteError('batch() requires an array argument')
+ , callback
+ )
+ }
+
+ if (!this._isOpening() && !this.isOpen()) {
+ return dispatchError(
+ this
+ , new WriteError('Database is not open')
+ , callback
+ )
+ }
+
+ options = getOptions(this, options)
+ keyEnc = options.keyEncoding
+ valueEnc = options.valueEncoding
+
+ arr = arr_.map(function (e) {
+ if (e.type === undefined || e.key === undefined)
+ return {}
+
+ // inherit encoding
+ var kEnc = e.keyEncoding || keyEnc
+ , vEnc = e.valueEncoding || e.encoding || valueEnc
+ , o
+
+ // If we're not dealing with plain utf8 strings or plain
+ // Buffers then we have to do some work on the array to
+ // encode the keys and/or values. This includes JSON types.
+
+ if (kEnc != 'utf8' && kEnc != 'binary'
+ || vEnc != 'utf8' && vEnc != 'binary') {
+ o = {
+ type: e.type
+ , key: util.encodeKey(e.key, options, e)
+ }
+
+ if (e.value !== undefined)
+ o.value = util.encodeValue(e.value, options, e)
+
+ return o
+ } else {
+ return e
+ }
+ })
+
+ this.db.batch(arr, options, function (err) {
+ if (err) {
+ return dispatchError(self, new WriteError(err), callback)
+ } else {
+ self.emit('batch', arr_)
+ if (callback)
+ callback()
+ }
+ })
+}
+
+// DEPRECATED: prefer accessing LevelDOWN for this: db.db.approximateSize()
+LevelUP.prototype.approximateSize = function (start_, end_, callback) {
+ var self = this
+ , start
+ , end
+
+ if (start_ === null || start_ === undefined
+ || end_ === null || end_ === undefined
+ || typeof callback != 'function') {
+ return dispatchError(
+ this
+ , new ReadError('approximateSize() requires start, end and callback arguments')
+ , callback
+ )
+ }
+
+ start = util.encodeKey(start_, this.options)
+ end = util.encodeKey(end_, this.options)
+
+ if (!this._isOpening() && !this.isOpen()) {
+ return dispatchError(
+ this
+ , new WriteError('Database is not open')
+ , callback
+ )
+ }
+
+ this.db.approximateSize(start, end, function (err, size) {
+ if (err) {
+ return dispatchError(self, new OpenError(err), callback)
+ } else if (callback) {
+ callback(null, size)
+ }
+ })
+}
+
+LevelUP.prototype.readStream =
+LevelUP.prototype.createReadStream = function (options) {
+ var self = this
+ options = extend(this.options, options)
+ return new ReadStream(
+ options
+ , this
+ , function (options) {
+ return self.db.iterator(options)
+ }
+ )
+}
+
+LevelUP.prototype.keyStream =
+LevelUP.prototype.createKeyStream = function (options) {
+ return this.createReadStream(extend(options, { keys: true, values: false }))
+}
+
+LevelUP.prototype.valueStream =
+LevelUP.prototype.createValueStream = function (options) {
+ return this.createReadStream(extend(options, { keys: false, values: true }))
+}
+
+LevelUP.prototype.writeStream =
+LevelUP.prototype.createWriteStream = function (options) {
+ return new WriteStream(extend(options), this)
+}
+
+LevelUP.prototype.toString = function () {
+ return 'LevelUP'
+}
+
+function utilStatic (name) {
+ return function (location, callback) {
+ getLevelDOWN()[name](location, callback || function () {})
+ }
+}
+
+module.exports = LevelUP
+module.exports.copy = util.copy
+// DEPRECATED: prefer accessing LevelDOWN for this: require('leveldown').destroy()
+module.exports.destroy = utilStatic('destroy')
+// DEPRECATED: prefer accessing LevelDOWN for this: require('leveldown').repair()
+module.exports.repair = utilStatic('repair')
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"./batch":64,"./errors":65,"./read-stream":67,"./util":68,"./write-stream":69,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"deferred-leveldown":71,"events":18,"prr":77,"util":32,"xtend":87}],67:[function(require,module,exports){
+/* Copyright (c) 2012-2014 LevelUP contributors
+ * See list at <https://github.com/rvagg/node-levelup#contributing>
+ * MIT License <https://github.com/rvagg/node-levelup/blob/master/LICENSE.md>
+ */
+
+// NOTE: we are fixed to readable-stream@1.0.x for now
+// for pure Streams2 across Node versions
+var Readable = require('readable-stream').Readable
+ , inherits = require('util').inherits
+ , extend = require('xtend')
+ , EncodingError = require('./errors').EncodingError
+ , util = require('./util')
+
+ , defaultOptions = { keys: true, values: true }
+
+ , makeKeyValueData = function (key, value) {
+ return {
+ key: util.decodeKey(key, this._options)
+ , value: util.decodeValue(value, this._options)
+ }
+ }
+ , makeKeyData = function (key) {
+ return util.decodeKey(key, this._options)
+ }
+ , makeValueData = function (_, value) {
+ return util.decodeValue(value, this._options)
+ }
+ , makeNoData = function () { return null }
+
+function ReadStream (options, db, iteratorFactory) {
+ if (!(this instanceof ReadStream))
+ return new ReadStream(options, db, iteratorFactory)
+
+ Readable.call(this, { objectMode: true, highWaterMark: options.highWaterMark })
+
+ // purely to keep `db` around until we're done so it's not GCed if the user doesn't keep a ref
+ this._db = db
+
+ options = this._options = extend(defaultOptions, options)
+
+ this._keyEncoding = options.keyEncoding || options.encoding
+ this._valueEncoding = options.valueEncoding || options.encoding
+
+ if (typeof this._options.start != 'undefined')
+ this._options.start = util.encodeKey(this._options.start, this._options)
+ if (typeof this._options.end != 'undefined')
+ this._options.end = util.encodeKey(this._options.end, this._options)
+ if (typeof this._options.limit != 'number')
+ this._options.limit = -1
+
+ this._options.keyAsBuffer = util.isKeyAsBuffer(this._options)
+
+ this._options.valueAsBuffer = util.isValueAsBuffer(this._options)
+
+ this._makeData = this._options.keys && this._options.values
+ ? makeKeyValueData : this._options.keys
+ ? makeKeyData : this._options.values
+ ? makeValueData : makeNoData
+
+ var self = this
+ if (!this._db.isOpen()) {
+ this._db.once('ready', function () {
+ if (!self._destroyed) {
+ self._iterator = iteratorFactory(self._options)
+ }
+ })
+ } else
+ this._iterator = iteratorFactory(this._options)
+}
+
+inherits(ReadStream, Readable)
+
+ReadStream.prototype._read = function read () {
+ var self = this
+ if (!self._db.isOpen()) {
+ return self._db.once('ready', function () { read.call(self) })
+ }
+ if (self._destroyed)
+ return
+
+ self._iterator.next(function(err, key, value) {
+ if (err || (key === undefined && value === undefined)) {
+ if (!err && !self._destroyed)
+ self.push(null)
+ return self._cleanup(err)
+ }
+
+ try {
+ value = self._makeData(key, value)
+ } catch (e) {
+ return self._cleanup(new EncodingError(e))
+ }
+ if (!self._destroyed)
+ self.push(value)
+ })
+}
+
+ReadStream.prototype._cleanup = function (err) {
+ if (this._destroyed)
+ return
+
+ this._destroyed = true
+
+ var self = this
+ if (err)
+ self.emit('error', err)
+
+ if (self._iterator) {
+ self._iterator.end(function () {
+ self._iterator = null
+ self.emit('close')
+ })
+ } else {
+ self.emit('close')
+ }
+}
+
+ReadStream.prototype.destroy = function () {
+ this._cleanup()
+}
+
+ReadStream.prototype.toString = function () {
+ return 'LevelUP.ReadStream'
+}
+
+module.exports = ReadStream
+
+},{"./errors":65,"./util":68,"readable-stream":86,"util":32,"xtend":87}],68:[function(require,module,exports){
+(function (process,Buffer){
+/* Copyright (c) 2012-2014 LevelUP contributors
+ * See list at <https://github.com/rvagg/node-levelup#contributing>
+ * MIT License
+ * <https://github.com/rvagg/node-levelup/blob/master/LICENSE.md>
+ */
+
+var extend = require('xtend')
+ , LevelUPError = require('./errors').LevelUPError
+
+ , encodingNames = [
+ 'hex'
+ , 'utf8'
+ , 'utf-8'
+ , 'ascii'
+ , 'binary'
+ , 'base64'
+ , 'ucs2'
+ , 'ucs-2'
+ , 'utf16le'
+ , 'utf-16le'
+ ]
+
+ , defaultOptions = {
+ createIfMissing : true
+ , errorIfExists : false
+ , keyEncoding : 'utf8'
+ , valueEncoding : 'utf8'
+ , compression : true
+ }
+
+ , leveldown
+
+ , encodings = (function () {
+ function isBinary (data) {
+ return data === undefined || data === null || Buffer.isBuffer(data)
+ }
+
+ var encodings = {}
+ encodings.utf8 = encodings['utf-8'] = {
+ encode : function (data) {
+ return isBinary(data) ? data : String(data)
+ }
+ , decode : function (data) {
+ return data
+ }
+ , buffer : false
+ , type : 'utf8'
+ }
+ encodings.json = {
+ encode : JSON.stringify
+ , decode : JSON.parse
+ , buffer : false
+ , type : 'json'
+ }
+ encodingNames.forEach(function (type) {
+ if (encodings[type])
+ return
+ encodings[type] = {
+ encode : function (data) {
+ return isBinary(data) ? data : new Buffer(data, type)
+ }
+ , decode : function (buffer) {
+ return process.browser ? buffer.toString(type) : buffer;
+ }
+ , buffer : true
+ , type : type // useful for debugging purposes
+ }
+ })
+ return encodings
+ })()
+
+ , encodingOpts = (function () {
+ var eo = {}
+ encodingNames.forEach(function (e) {
+ eo[e] = { valueEncoding : e }
+ })
+ return eo
+ }())
+
+function copy (srcdb, dstdb, callback) {
+ srcdb.readStream()
+ .pipe(dstdb.writeStream())
+ .on('close', callback ? callback : function () {})
+ .on('error', callback ? callback : function (err) { throw err })
+}
+
+function getOptions (levelup, options) {
+ var s = typeof options == 'string' // just an encoding
+ if (!s && options && options.encoding && !options.valueEncoding)
+ options.valueEncoding = options.encoding
+ return extend(
+ (levelup && levelup.options) || {}
+ , s ? encodingOpts[options] || encodingOpts[defaultOptions.valueEncoding]
+ : options
+ )
+}
+
+function getLevelDOWN () {
+ if (leveldown)
+ return leveldown
+
+ var requiredVersion = require('../package.json').devDependencies.leveldown
+ , missingLevelDOWNError = 'Could not locate LevelDOWN, try `npm install leveldown`'
+ , leveldownVersion
+
+ try {
+ leveldownVersion = require('leveldown/package').version
+ } catch (e) {
+ throw new LevelUPError(missingLevelDOWNError)
+ }
+
+ if (!require('semver').satisfies(leveldownVersion, requiredVersion)) {
+ throw new LevelUPError(
+ 'Installed version of LevelDOWN ('
+ + leveldownVersion
+ + ') does not match required version ('
+ + requiredVersion
+ + ')'
+ )
+ }
+
+ try {
+ return leveldown = require('leveldown')
+ } catch (e) {
+ throw new LevelUPError(missingLevelDOWNError)
+ }
+}
+
+function dispatchError (levelup, error, callback) {
+ return typeof callback == 'function'
+ ? callback(error)
+ : levelup.emit('error', error)
+}
+
+function getKeyEncoder (options, op) {
+ var type = ((op && op.keyEncoding) || options.keyEncoding) || 'utf8'
+ return encodings[type] || type
+}
+
+function getValueEncoder (options, op) {
+ var type = (((op && (op.valueEncoding || op.encoding))
+ || options.valueEncoding || options.encoding)) || 'utf8'
+ return encodings[type] || type
+}
+
+function encodeKey (key, options, op) {
+ return getKeyEncoder(options, op).encode(key)
+}
+
+function encodeValue (value, options, op) {
+ return getValueEncoder(options, op).encode(value)
+}
+
+function decodeKey (key, options) {
+ return getKeyEncoder(options).decode(key)
+}
+
+function decodeValue (value, options) {
+ return getValueEncoder(options).decode(value)
+}
+
+function isValueAsBuffer (options, op) {
+ return getValueEncoder(options, op).buffer
+}
+
+function isKeyAsBuffer (options, op) {
+ return getKeyEncoder(options, op).buffer
+}
+
+module.exports = {
+ defaultOptions : defaultOptions
+ , copy : copy
+ , getOptions : getOptions
+ , getLevelDOWN : getLevelDOWN
+ , dispatchError : dispatchError
+ , encodeKey : encodeKey
+ , encodeValue : encodeValue
+ , isValueAsBuffer : isValueAsBuffer
+ , isKeyAsBuffer : isKeyAsBuffer
+ , decodeValue : decodeValue
+ , decodeKey : decodeKey
+}
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),require("buffer").Buffer)
+},{"../package.json":88,"./errors":65,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"leveldown":"A2RG/S","leveldown/package":17,"semver":17,"xtend":87}],69:[function(require,module,exports){
+(function (process,global){
+/* Copyright (c) 2012-2014 LevelUP contributors
+ * See list at <https://github.com/rvagg/node-levelup#contributing>
+ * MIT License
+ * <https://github.com/rvagg/node-levelup/blob/master/LICENSE.md>
+ */
+
+var Stream = require('stream').Stream
+ , inherits = require('util').inherits
+ , extend = require('xtend')
+ , bl = require('bl')
+
+ , setImmediate = global.setImmediate || process.nextTick
+
+ , getOptions = require('./util').getOptions
+
+ , defaultOptions = { type: 'put' }
+
+function WriteStream (options, db) {
+ if (!(this instanceof WriteStream))
+ return new WriteStream(options, db)
+
+ Stream.call(this)
+ this._options = extend(defaultOptions, getOptions(db, options))
+ this._db = db
+ this._buffer = []
+ this._status = 'init'
+ this._end = false
+ this.writable = true
+ this.readable = false
+
+ var self = this
+ , ready = function () {
+ if (!self.writable)
+ return
+ self._status = 'ready'
+ self.emit('ready')
+ self._process()
+ }
+
+ if (db.isOpen())
+ setImmediate(ready)
+ else
+ db.once('ready', ready)
+}
+
+inherits(WriteStream, Stream)
+
+WriteStream.prototype.write = function (data) {
+ if (!this.writable)
+ return false
+ this._buffer.push(data)
+ if (this._status != 'init')
+ this._processDelayed()
+ if (this._options.maxBufferLength &&
+ this._buffer.length > this._options.maxBufferLength) {
+ this._writeBlock = true
+ return false
+ }
+ return true
+}
+
+WriteStream.prototype.end = function (data) {
+ var self = this
+ if (data)
+ this.write(data)
+ setImmediate(function () {
+ self._end = true
+ self._process()
+ })
+}
+
+WriteStream.prototype.destroy = function () {
+ this.writable = false
+ this.end()
+}
+
+WriteStream.prototype.destroySoon = function () {
+ this.end()
+}
+
+WriteStream.prototype.add = function (entry) {
+ if (!entry.props)
+ return
+ if (entry.props.Directory)
+ entry.pipe(this._db.writeStream(this._options))
+ else if (entry.props.File || entry.File || entry.type == 'File')
+ this._write(entry)
+ return true
+}
+
+WriteStream.prototype._processDelayed = function () {
+ var self = this
+ setImmediate(function () {
+ self._process()
+ })
+}
+
+WriteStream.prototype._process = function () {
+ var buffer
+ , self = this
+
+ , cb = function (err) {
+ if (!self.writable)
+ return
+ if (self._status != 'closed')
+ self._status = 'ready'
+ if (err) {
+ self.writable = false
+ return self.emit('error', err)
+ }
+ self._process()
+ }
+
+ if (self._status != 'ready' && self.writable) {
+ if (self._buffer.length && self._status != 'closed')
+ self._processDelayed()
+ return
+ }
+
+ if (self._buffer.length && self.writable) {
+ self._status = 'writing'
+ buffer = self._buffer
+ self._buffer = []
+
+ self._db.batch(buffer.map(function (d) {
+ return {
+ type : d.type || self._options.type
+ , key : d.key
+ , value : d.value
+ , keyEncoding : d.keyEncoding || self._options.keyEncoding
+ , valueEncoding : d.valueEncoding
+ || d.encoding
+ || self._options.valueEncoding
+ }
+ }), cb)
+
+ if (self._writeBlock) {
+ self._writeBlock = false
+ self.emit('drain')
+ }
+
+ // don't allow close until callback has returned
+ return
+ }
+
+ if (self._end && self._status != 'closed') {
+ self._status = 'closed'
+ self.writable = false
+ self.emit('close')
+ }
+}
+
+WriteStream.prototype._write = function (entry) {
+ var key = entry.path || entry.props.path
+ , self = this
+
+ if (!key)
+ return
+
+ entry.pipe(bl(function (err, data) {
+ if (err) {
+ self.writable = false
+ return self.emit('error', err)
+ }
+
+ if (self._options.fstreamRoot &&
+ key.indexOf(self._options.fstreamRoot) > -1)
+ key = key.substr(self._options.fstreamRoot.length + 1)
+
+ self.write({ key: key, value: data.slice(0) })
+ }))
+}
+
+WriteStream.prototype.toString = function () {
+ return 'LevelUP.WriteStream'
+}
+
+module.exports = WriteStream
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./util":68,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"bl":70,"stream":24,"util":32,"xtend":87}],70:[function(require,module,exports){
+(function (Buffer){
+var DuplexStream = require('readable-stream').Duplex
+ , util = require('util')
+
+function BufferList (callback) {
+ if (!(this instanceof BufferList))
+ return new BufferList(callback)
+
+ this._bufs = []
+ this.length = 0
+
+ if (typeof callback == 'function') {
+ this._callback = callback
+
+ var piper = function (err) {
+ if (this._callback) {
+ this._callback(err)
+ this._callback = null
+ }
+ }.bind(this)
+
+ this.on('pipe', function (src) {
+ src.on('error', piper)
+ })
+ this.on('unpipe', function (src) {
+ src.removeListener('error', piper)
+ })
+ }
+ else if (Buffer.isBuffer(callback))
+ this.append(callback)
+ else if (Array.isArray(callback)) {
+ callback.forEach(function (b) {
+ Buffer.isBuffer(b) && this.append(b)
+ }.bind(this))
+ }
+
+ DuplexStream.call(this)
+}
+
+util.inherits(BufferList, DuplexStream)
+
+BufferList.prototype._offset = function (offset) {
+ var tot = 0, i = 0, _t
+ for (; i < this._bufs.length; i++) {
+ _t = tot + this._bufs[i].length
+ if (offset < _t)
+ return [ i, offset - tot ]
+ tot = _t
+ }
+}
+
+BufferList.prototype.append = function (buf) {
+ this._bufs.push(Buffer.isBuffer(buf) ? buf : new Buffer(buf))
+ this.length += buf.length
+ return this
+}
+
+BufferList.prototype._write = function (buf, encoding, callback) {
+ this.append(buf)
+ if (callback)
+ callback()
+}
+
+BufferList.prototype._read = function (size) {
+ if (!this.length)
+ return this.push(null)
+ size = Math.min(size, this.length)
+ this.push(this.slice(0, size))
+ this.consume(size)
+}
+
+BufferList.prototype.end = function (chunk) {
+ DuplexStream.prototype.end.call(this, chunk)
+
+ if (this._callback) {
+ this._callback(null, this.slice())
+ this._callback = null
+ }
+}
+
+BufferList.prototype.get = function (index) {
+ return this.slice(index, index + 1)[0]
+}
+
+BufferList.prototype.slice = function (start, end) {
+ return this.copy(null, 0, start, end)
+}
+
+BufferList.prototype.copy = function (dst, dstStart, srcStart, srcEnd) {
+ if (typeof srcStart != 'number' || srcStart < 0)
+ srcStart = 0
+ if (typeof srcEnd != 'number' || srcEnd > this.length)
+ srcEnd = this.length
+ if (srcStart >= this.length)
+ return dst || new Buffer(0)
+ if (srcEnd <= 0)
+ return dst || new Buffer(0)
+
+ var copy = !!dst
+ , off = this._offset(srcStart)
+ , len = srcEnd - srcStart
+ , bytes = len
+ , bufoff = (copy && dstStart) || 0
+ , start = off[1]
+ , l
+ , i
+
+ // copy/slice everything
+ if (srcStart === 0 && srcEnd == this.length) {
+ if (!copy) // slice, just return a full concat
+ return Buffer.concat(this._bufs)
+
+ // copy, need to copy individual buffers
+ for (i = 0; i < this._bufs.length; i++) {
+ this._bufs[i].copy(dst, bufoff)
+ bufoff += this._bufs[i].length
+ }
+
+ return dst
+ }
+
+ // easy, cheap case where it's a subset of one of the buffers
+ if (bytes <= this._bufs[off[0]].length - start) {
+ return copy
+ ? this._bufs[off[0]].copy(dst, dstStart, start, start + bytes)
+ : this._bufs[off[0]].slice(start, start + bytes)
+ }
+
+ if (!copy) // a slice, we need something to copy in to
+ dst = new Buffer(len)
+
+ for (i = off[0]; i < this._bufs.length; i++) {
+ l = this._bufs[i].length - start
+
+ if (bytes > l) {
+ this._bufs[i].copy(dst, bufoff, start)
+ } else {
+ this._bufs[i].copy(dst, bufoff, start, start + bytes)
+ break
+ }
+
+ bufoff += l
+ bytes -= l
+
+ if (start)
+ start = 0
+ }
+
+ return dst
+}
+
+BufferList.prototype.toString = function (encoding, start, end) {
+ return this.slice(start, end).toString(encoding)
+}
+
+BufferList.prototype.consume = function (bytes) {
+ while (this._bufs.length) {
+ if (bytes > this._bufs[0].length) {
+ bytes -= this._bufs[0].length
+ this.length -= this._bufs[0].length
+ this._bufs.shift()
+ } else {
+ this._bufs[0] = this._bufs[0].slice(bytes)
+ this.length -= bytes
+ break
+ }
+ }
+ return this
+}
+
+BufferList.prototype.duplicate = function () {
+ var i = 0
+ , copy = new BufferList()
+
+ for (; i < this._bufs.length; i++)
+ copy.append(this._bufs[i])
+
+ return copy
+}
+
+BufferList.prototype.destroy = function () {
+ this._bufs.length = 0;
+ this.length = 0;
+ this.push(null);
+}
+
+;(function () {
+ var methods = {
+ 'readDoubleBE' : 8
+ , 'readDoubleLE' : 8
+ , 'readFloatBE' : 4
+ , 'readFloatLE' : 4
+ , 'readInt32BE' : 4
+ , 'readInt32LE' : 4
+ , 'readUInt32BE' : 4
+ , 'readUInt32LE' : 4
+ , 'readInt16BE' : 2
+ , 'readInt16LE' : 2
+ , 'readUInt16BE' : 2
+ , 'readUInt16LE' : 2
+ , 'readInt8' : 1
+ , 'readUInt8' : 1
+ }
+
+ for (var m in methods) {
+ (function (m) {
+ BufferList.prototype[m] = function (offset) {
+ return this.slice(offset, offset + methods[m])[m](0)
+ }
+ }(m))
+ }
+}())
+
+module.exports = BufferList
+
+}).call(this,require("buffer").Buffer)
+},{"buffer":20,"readable-stream":86,"util":32}],71:[function(require,module,exports){
+(function (process,Buffer){
+var util = require('util')
+ , AbstractLevelDOWN = require('abstract-leveldown').AbstractLevelDOWN
+
+function DeferredLevelDOWN (location) {
+ AbstractLevelDOWN.call(this, typeof location == 'string' ? location : '') // optional location, who cares?
+ this._db = undefined
+ this._operations = []
+}
+
+util.inherits(DeferredLevelDOWN, AbstractLevelDOWN)
+
+// called by LevelUP when we have a real DB to take its place
+DeferredLevelDOWN.prototype.setDb = function (db) {
+ this._db = db
+ this._operations.forEach(function (op) {
+ db[op.method].apply(db, op.args)
+ })
+}
+
+DeferredLevelDOWN.prototype._open = function (options, callback) {
+ return process.nextTick(callback)
+}
+
+// queue a new deferred operation
+DeferredLevelDOWN.prototype._operation = function (method, args) {
+ if (this._db)
+ return this._db[method].apply(this._db, args)
+ this._operations.push({ method: method, args: args })
+}
+
+// deferrables
+'put get del batch approximateSize'.split(' ').forEach(function (m) {
+ DeferredLevelDOWN.prototype['_' + m] = function () {
+ this._operation(m, arguments)
+ }
+})
+
+DeferredLevelDOWN.prototype._isBuffer = function (obj) {
+ return Buffer.isBuffer(obj)
+}
+
+// don't need to implement this as LevelUP's ReadStream checks for 'ready' state
+DeferredLevelDOWN.prototype._iterator = function () {
+ throw new TypeError('not implemented')
+}
+
+module.exports = DeferredLevelDOWN
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),require("buffer").Buffer)
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"abstract-leveldown":74,"buffer":20,"util":32}],72:[function(require,module,exports){
+module.exports=require(37)
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],73:[function(require,module,exports){
+module.exports=require(38)
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],74:[function(require,module,exports){
+module.exports=require(39)
+},{"./abstract-chained-batch":72,"./abstract-iterator":73,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"xtend":87}],75:[function(require,module,exports){
+var prr = require('prr')
+
+function init (type, message, cause) {
+ prr(this, {
+ type : type
+ , name : type
+ // can be passed just a 'cause'
+ , cause : typeof message != 'string' ? message : cause
+ , message : !!message && typeof message != 'string' ? message.message : message
+
+ }, 'ewr')
+}
+
+// generic prototype, not intended to be actually used - helpful for `instanceof`
+function CustomError (message, cause) {
+ Error.call(this)
+ if (Error.captureStackTrace)
+ Error.captureStackTrace(this, arguments.callee)
+ init.call(this, 'CustomError', message, cause)
+}
+
+CustomError.prototype = new Error()
+
+function createError (errno, type, proto) {
+ var err = function (message, cause) {
+ init.call(this, type, message, cause)
+ //TODO: the specificity here is stupid, errno should be available everywhere
+ if (type == 'FilesystemError') {
+ this.code = this.cause.code
+ this.path = this.cause.path
+ this.errno = this.cause.errno
+ this.message =
+ (errno.errno[this.cause.errno]
+ ? errno.errno[this.cause.errno].description
+ : this.cause.message)
+ + (this.cause.path ? ' [' + this.cause.path + ']' : '')
+ }
+ Error.call(this)
+ if (Error.captureStackTrace)
+ Error.captureStackTrace(this, arguments.callee)
+ }
+ err.prototype = !!proto ? new proto() : new CustomError()
+ return err
+}
+
+module.exports = function (errno) {
+ var ce = function (type, proto) {
+ return createError(errno, type, proto)
+ }
+ return {
+ CustomError : CustomError
+ , FilesystemError : ce('FilesystemError')
+ , createError : ce
+ }
+}
+
+},{"prr":77}],76:[function(require,module,exports){
+var all = module.exports.all = [
+ {
+ "errno": -1,
+ "code": "UNKNOWN",
+ "description": "unknown error"
+ },
+ {
+ "errno": 0,
+ "code": "OK",
+ "description": "success"
+ },
+ {
+ "errno": 1,
+ "code": "EOF",
+ "description": "end of file"
+ },
+ {
+ "errno": 2,
+ "code": "EADDRINFO",
+ "description": "getaddrinfo error"
+ },
+ {
+ "errno": 3,
+ "code": "EACCES",
+ "description": "permission denied"
+ },
+ {
+ "errno": 4,
+ "code": "EAGAIN",
+ "description": "resource temporarily unavailable"
+ },
+ {
+ "errno": 5,
+ "code": "EADDRINUSE",
+ "description": "address already in use"
+ },
+ {
+ "errno": 6,
+ "code": "EADDRNOTAVAIL",
+ "description": "address not available"
+ },
+ {
+ "errno": 7,
+ "code": "EAFNOSUPPORT",
+ "description": "address family not supported"
+ },
+ {
+ "errno": 8,
+ "code": "EALREADY",
+ "description": "connection already in progress"
+ },
+ {
+ "errno": 9,
+ "code": "EBADF",
+ "description": "bad file descriptor"
+ },
+ {
+ "errno": 10,
+ "code": "EBUSY",
+ "description": "resource busy or locked"
+ },
+ {
+ "errno": 11,
+ "code": "ECONNABORTED",
+ "description": "software caused connection abort"
+ },
+ {
+ "errno": 12,
+ "code": "ECONNREFUSED",
+ "description": "connection refused"
+ },
+ {
+ "errno": 13,
+ "code": "ECONNRESET",
+ "description": "connection reset by peer"
+ },
+ {
+ "errno": 14,
+ "code": "EDESTADDRREQ",
+ "description": "destination address required"
+ },
+ {
+ "errno": 15,
+ "code": "EFAULT",
+ "description": "bad address in system call argument"
+ },
+ {
+ "errno": 16,
+ "code": "EHOSTUNREACH",
+ "description": "host is unreachable"
+ },
+ {
+ "errno": 17,
+ "code": "EINTR",
+ "description": "interrupted system call"
+ },
+ {
+ "errno": 18,
+ "code": "EINVAL",
+ "description": "invalid argument"
+ },
+ {
+ "errno": 19,
+ "code": "EISCONN",
+ "description": "socket is already connected"
+ },
+ {
+ "errno": 20,
+ "code": "EMFILE",
+ "description": "too many open files"
+ },
+ {
+ "errno": 21,
+ "code": "EMSGSIZE",
+ "description": "message too long"
+ },
+ {
+ "errno": 22,
+ "code": "ENETDOWN",
+ "description": "network is down"
+ },
+ {
+ "errno": 23,
+ "code": "ENETUNREACH",
+ "description": "network is unreachable"
+ },
+ {
+ "errno": 24,
+ "code": "ENFILE",
+ "description": "file table overflow"
+ },
+ {
+ "errno": 25,
+ "code": "ENOBUFS",
+ "description": "no buffer space available"
+ },
+ {
+ "errno": 26,
+ "code": "ENOMEM",
+ "description": "not enough memory"
+ },
+ {
+ "errno": 27,
+ "code": "ENOTDIR",
+ "description": "not a directory"
+ },
+ {
+ "errno": 28,
+ "code": "EISDIR",
+ "description": "illegal operation on a directory"
+ },
+ {
+ "errno": 29,
+ "code": "ENONET",
+ "description": "machine is not on the network"
+ },
+ {
+ "errno": 31,
+ "code": "ENOTCONN",
+ "description": "socket is not connected"
+ },
+ {
+ "errno": 32,
+ "code": "ENOTSOCK",
+ "description": "socket operation on non-socket"
+ },
+ {
+ "errno": 33,
+ "code": "ENOTSUP",
+ "description": "operation not supported on socket"
+ },
+ {
+ "errno": 34,
+ "code": "ENOENT",
+ "description": "no such file or directory"
+ },
+ {
+ "errno": 35,
+ "code": "ENOSYS",
+ "description": "function not implemented"
+ },
+ {
+ "errno": 36,
+ "code": "EPIPE",
+ "description": "broken pipe"
+ },
+ {
+ "errno": 37,
+ "code": "EPROTO",
+ "description": "protocol error"
+ },
+ {
+ "errno": 38,
+ "code": "EPROTONOSUPPORT",
+ "description": "protocol not supported"
+ },
+ {
+ "errno": 39,
+ "code": "EPROTOTYPE",
+ "description": "protocol wrong type for socket"
+ },
+ {
+ "errno": 40,
+ "code": "ETIMEDOUT",
+ "description": "connection timed out"
+ },
+ {
+ "errno": 41,
+ "code": "ECHARSET",
+ "description": "invalid Unicode character"
+ },
+ {
+ "errno": 42,
+ "code": "EAIFAMNOSUPPORT",
+ "description": "address family for hostname not supported"
+ },
+ {
+ "errno": 44,
+ "code": "EAISERVICE",
+ "description": "servname not supported for ai_socktype"
+ },
+ {
+ "errno": 45,
+ "code": "EAISOCKTYPE",
+ "description": "ai_socktype not supported"
+ },
+ {
+ "errno": 46,
+ "code": "ESHUTDOWN",
+ "description": "cannot send after transport endpoint shutdown"
+ },
+ {
+ "errno": 47,
+ "code": "EEXIST",
+ "description": "file already exists"
+ },
+ {
+ "errno": 48,
+ "code": "ESRCH",
+ "description": "no such process"
+ },
+ {
+ "errno": 49,
+ "code": "ENAMETOOLONG",
+ "description": "name too long"
+ },
+ {
+ "errno": 50,
+ "code": "EPERM",
+ "description": "operation not permitted"
+ },
+ {
+ "errno": 51,
+ "code": "ELOOP",
+ "description": "too many symbolic links encountered"
+ },
+ {
+ "errno": 52,
+ "code": "EXDEV",
+ "description": "cross-device link not permitted"
+ },
+ {
+ "errno": 53,
+ "code": "ENOTEMPTY",
+ "description": "directory not empty"
+ },
+ {
+ "errno": 54,
+ "code": "ENOSPC",
+ "description": "no space left on device"
+ },
+ {
+ "errno": 55,
+ "code": "EIO",
+ "description": "i/o error"
+ },
+ {
+ "errno": 56,
+ "code": "EROFS",
+ "description": "read-only file system"
+ },
+ {
+ "errno": 57,
+ "code": "ENODEV",
+ "description": "no such device"
+ },
+ {
+ "errno": 58,
+ "code": "ESPIPE",
+ "description": "invalid seek"
+ },
+ {
+ "errno": 59,
+ "code": "ECANCELED",
+ "description": "operation canceled"
+ }
+]
+
+
+module.exports.errno = {
+ '-1': all[0]
+ , '0': all[1]
+ , '1': all[2]
+ , '2': all[3]
+ , '3': all[4]
+ , '4': all[5]
+ , '5': all[6]
+ , '6': all[7]
+ , '7': all[8]
+ , '8': all[9]
+ , '9': all[10]
+ , '10': all[11]
+ , '11': all[12]
+ , '12': all[13]
+ , '13': all[14]
+ , '14': all[15]
+ , '15': all[16]
+ , '16': all[17]
+ , '17': all[18]
+ , '18': all[19]
+ , '19': all[20]
+ , '20': all[21]
+ , '21': all[22]
+ , '22': all[23]
+ , '23': all[24]
+ , '24': all[25]
+ , '25': all[26]
+ , '26': all[27]
+ , '27': all[28]
+ , '28': all[29]
+ , '29': all[30]
+ , '31': all[31]
+ , '32': all[32]
+ , '33': all[33]
+ , '34': all[34]
+ , '35': all[35]
+ , '36': all[36]
+ , '37': all[37]
+ , '38': all[38]
+ , '39': all[39]
+ , '40': all[40]
+ , '41': all[41]
+ , '42': all[42]
+ , '44': all[43]
+ , '45': all[44]
+ , '46': all[45]
+ , '47': all[46]
+ , '48': all[47]
+ , '49': all[48]
+ , '50': all[49]
+ , '51': all[50]
+ , '52': all[51]
+ , '53': all[52]
+ , '54': all[53]
+ , '55': all[54]
+ , '56': all[55]
+ , '57': all[56]
+ , '58': all[57]
+ , '59': all[58]
+}
+
+
+module.exports.code = {
+ 'UNKNOWN': all[0]
+ , 'OK': all[1]
+ , 'EOF': all[2]
+ , 'EADDRINFO': all[3]
+ , 'EACCES': all[4]
+ , 'EAGAIN': all[5]
+ , 'EADDRINUSE': all[6]
+ , 'EADDRNOTAVAIL': all[7]
+ , 'EAFNOSUPPORT': all[8]
+ , 'EALREADY': all[9]
+ , 'EBADF': all[10]
+ , 'EBUSY': all[11]
+ , 'ECONNABORTED': all[12]
+ , 'ECONNREFUSED': all[13]
+ , 'ECONNRESET': all[14]
+ , 'EDESTADDRREQ': all[15]
+ , 'EFAULT': all[16]
+ , 'EHOSTUNREACH': all[17]
+ , 'EINTR': all[18]
+ , 'EINVAL': all[19]
+ , 'EISCONN': all[20]
+ , 'EMFILE': all[21]
+ , 'EMSGSIZE': all[22]
+ , 'ENETDOWN': all[23]
+ , 'ENETUNREACH': all[24]
+ , 'ENFILE': all[25]
+ , 'ENOBUFS': all[26]
+ , 'ENOMEM': all[27]
+ , 'ENOTDIR': all[28]
+ , 'EISDIR': all[29]
+ , 'ENONET': all[30]
+ , 'ENOTCONN': all[31]
+ , 'ENOTSOCK': all[32]
+ , 'ENOTSUP': all[33]
+ , 'ENOENT': all[34]
+ , 'ENOSYS': all[35]
+ , 'EPIPE': all[36]
+ , 'EPROTO': all[37]
+ , 'EPROTONOSUPPORT': all[38]
+ , 'EPROTOTYPE': all[39]
+ , 'ETIMEDOUT': all[40]
+ , 'ECHARSET': all[41]
+ , 'EAIFAMNOSUPPORT': all[42]
+ , 'EAISERVICE': all[43]
+ , 'EAISOCKTYPE': all[44]
+ , 'ESHUTDOWN': all[45]
+ , 'EEXIST': all[46]
+ , 'ESRCH': all[47]
+ , 'ENAMETOOLONG': all[48]
+ , 'EPERM': all[49]
+ , 'ELOOP': all[50]
+ , 'EXDEV': all[51]
+ , 'ENOTEMPTY': all[52]
+ , 'ENOSPC': all[53]
+ , 'EIO': all[54]
+ , 'EROFS': all[55]
+ , 'ENODEV': all[56]
+ , 'ESPIPE': all[57]
+ , 'ECANCELED': all[58]
+}
+
+
+module.exports.custom = require("./custom")(module.exports)
+module.exports.create = module.exports.custom.createError
+},{"./custom":75}],77:[function(require,module,exports){
+/*!
+ * prr
+ * (c) 2013 Rod Vagg <rod@vagg.org>
+ * https://github.com/rvagg/prr
+ * License: MIT
+ */
+
+(function (name, context, definition) {
+ if (typeof module != 'undefined' && module.exports)
+ module.exports = definition()
+ else
+ context[name] = definition()
+})('prr', this, function() {
+
+ var setProperty = typeof Object.defineProperty == 'function'
+ ? function (obj, key, options) {
+ Object.defineProperty(obj, key, options)
+ return obj
+ }
+ : function (obj, key, options) { // < es5
+ obj[key] = options.value
+ return obj
+ }
+
+ , makeOptions = function (value, options) {
+ var oo = typeof options == 'object'
+ , os = !oo && typeof options == 'string'
+ , op = function (p) {
+ return oo
+ ? !!options[p]
+ : os
+ ? options.indexOf(p[0]) > -1
+ : false
+ }
+
+ return {
+ enumerable : op('enumerable')
+ , configurable : op('configurable')
+ , writable : op('writable')
+ , value : value
+ }
+ }
+
+ , prr = function (obj, key, value, options) {
+ var k
+
+ options = makeOptions(value, options)
+
+ if (typeof key == 'object') {
+ for (k in key) {
+ if (Object.hasOwnProperty.call(key, k)) {
+ options.value = key[k]
+ setProperty(obj, k, options)
+ }
+ }
+ return obj
+ }
+
+ return setProperty(obj, key, options)
+ }
+
+ return prr
+})
+},{}],78:[function(require,module,exports){
+(function (process){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototypal inheritance, this class
+// prototypally inherits from Readable, and then parasitically from
+// Writable.
+
+module.exports = Duplex;
+
+/*<replacement>*/
+var objectKeys = Object.keys || function (obj) {
+ var keys = [];
+ for (var key in obj) keys.push(key);
+ return keys;
+}
+/*</replacement>*/
+
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+var Readable = require('./_stream_readable');
+var Writable = require('./_stream_writable');
+
+util.inherits(Duplex, Readable);
+
+forEach(objectKeys(Writable.prototype), function(method) {
+ if (!Duplex.prototype[method])
+ Duplex.prototype[method] = Writable.prototype[method];
+});
+
+function Duplex(options) {
+ if (!(this instanceof Duplex))
+ return new Duplex(options);
+
+ Readable.call(this, options);
+ Writable.call(this, options);
+
+ if (options && options.readable === false)
+ this.readable = false;
+
+ if (options && options.writable === false)
+ this.writable = false;
+
+ this.allowHalfOpen = true;
+ if (options && options.allowHalfOpen === false)
+ this.allowHalfOpen = false;
+
+ this.once('end', onend);
+}
+
+// the no-half-open enforcer
+function onend() {
+ // if we allow half-open state, or if the writable side ended,
+ // then we're ok.
+ if (this.allowHalfOpen || this._writableState.ended)
+ return;
+
+ // no more data can be written.
+ // But allow more writes to happen in this tick.
+ process.nextTick(this.end.bind(this));
+}
+
+function forEach (xs, f) {
+ for (var i = 0, l = xs.length; i < l; i++) {
+ f(xs[i], i);
+ }
+}
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"./_stream_readable":80,"./_stream_writable":82,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"core-util-is":83,"inherits":33}],79:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+
+module.exports = PassThrough;
+
+var Transform = require('./_stream_transform');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(PassThrough, Transform);
+
+function PassThrough(options) {
+ if (!(this instanceof PassThrough))
+ return new PassThrough(options);
+
+ Transform.call(this, options);
+}
+
+PassThrough.prototype._transform = function(chunk, encoding, cb) {
+ cb(null, chunk);
+};
+
+},{"./_stream_transform":81,"core-util-is":83,"inherits":33}],80:[function(require,module,exports){
+(function (process){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module.exports = Readable;
+
+/*<replacement>*/
+var isArray = require('isarray');
+/*</replacement>*/
+
+
+/*<replacement>*/
+var Buffer = require('buffer').Buffer;
+/*</replacement>*/
+
+Readable.ReadableState = ReadableState;
+
+var EE = require('events').EventEmitter;
+
+/*<replacement>*/
+if (!EE.listenerCount) EE.listenerCount = function(emitter, type) {
+ return emitter.listeners(type).length;
+};
+/*</replacement>*/
+
+var Stream = require('stream');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+var StringDecoder;
+
+util.inherits(Readable, Stream);
+
+function ReadableState(options, stream) {
+ options = options || {};
+
+ // the point at which it stops calling _read() to fill the buffer
+ // Note: 0 is a valid value, means "don't call _read preemptively ever"
+ var hwm = options.highWaterMark;
+ this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
+
+ // cast to ints.
+ this.highWaterMark = ~~this.highWaterMark;
+
+ this.buffer = [];
+ this.length = 0;
+ this.pipes = null;
+ this.pipesCount = 0;
+ this.flowing = false;
+ this.ended = false;
+ this.endEmitted = false;
+ this.reading = false;
+
+ // In streams that never have any data, and do push(null) right away,
+ // the consumer can miss the 'end' event if they do some I/O before
+ // consuming the stream. So, we don't emit('end') until some reading
+ // happens.
+ this.calledRead = false;
+
+ // a flag to be able to tell if the onwrite cb is called immediately,
+ // or on a later tick. We set this to true at first, becuase any
+ // actions that shouldn't happen until "later" should generally also
+ // not happen before the first write call.
+ this.sync = true;
+
+ // whenever we return null, then we set a flag to say
+ // that we're awaiting a 'readable' event emission.
+ this.needReadable = false;
+ this.emittedReadable = false;
+ this.readableListening = false;
+
+
+ // object stream flag. Used to make read(n) ignore n and to
+ // make all the buffer merging and length checks go away
+ this.objectMode = !!options.objectMode;
+
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+ // when piping, we only care about 'readable' events that happen
+ // after read()ing all the bytes and not getting any pushback.
+ this.ranOut = false;
+
+ // the number of writers that are awaiting a drain event in .pipe()s
+ this.awaitDrain = 0;
+
+ // if true, a maybeReadMore has been scheduled
+ this.readingMore = false;
+
+ this.decoder = null;
+ this.encoding = null;
+ if (options.encoding) {
+ if (!StringDecoder)
+ StringDecoder = require('string_decoder/').StringDecoder;
+ this.decoder = new StringDecoder(options.encoding);
+ this.encoding = options.encoding;
+ }
+}
+
+function Readable(options) {
+ if (!(this instanceof Readable))
+ return new Readable(options);
+
+ this._readableState = new ReadableState(options, this);
+
+ // legacy
+ this.readable = true;
+
+ Stream.call(this);
+}
+
+// Manually shove something into the read() buffer.
+// This returns true if the highWaterMark has not been hit yet,
+// similar to how Writable.write() returns true if you should
+// write() some more.
+Readable.prototype.push = function(chunk, encoding) {
+ var state = this._readableState;
+
+ if (typeof chunk === 'string' && !state.objectMode) {
+ encoding = encoding || state.defaultEncoding;
+ if (encoding !== state.encoding) {
+ chunk = new Buffer(chunk, encoding);
+ encoding = '';
+ }
+ }
+
+ return readableAddChunk(this, state, chunk, encoding, false);
+};
+
+// Unshift should *always* be something directly out of read()
+Readable.prototype.unshift = function(chunk) {
+ var state = this._readableState;
+ return readableAddChunk(this, state, chunk, '', true);
+};
+
+function readableAddChunk(stream, state, chunk, encoding, addToFront) {
+ var er = chunkInvalid(state, chunk);
+ if (er) {
+ stream.emit('error', er);
+ } else if (chunk === null || chunk === undefined) {
+ state.reading = false;
+ if (!state.ended)
+ onEofChunk(stream, state);
+ } else if (state.objectMode || chunk && chunk.length > 0) {
+ if (state.ended && !addToFront) {
+ var e = new Error('stream.push() after EOF');
+ stream.emit('error', e);
+ } else if (state.endEmitted && addToFront) {
+ var e = new Error('stream.unshift() after end event');
+ stream.emit('error', e);
+ } else {
+ if (state.decoder && !addToFront && !encoding)
+ chunk = state.decoder.write(chunk);
+
+ // update the buffer info.
+ state.length += state.objectMode ? 1 : chunk.length;
+ if (addToFront) {
+ state.buffer.unshift(chunk);
+ } else {
+ state.reading = false;
+ state.buffer.push(chunk);
+ }
+
+ if (state.needReadable)
+ emitReadable(stream);
+
+ maybeReadMore(stream, state);
+ }
+ } else if (!addToFront) {
+ state.reading = false;
+ }
+
+ return needMoreData(state);
+}
+
+
+
+// if it's past the high water mark, we can push in some more.
+// Also, if we have no data yet, we can stand some
+// more bytes. This is to work around cases where hwm=0,
+// such as the repl. Also, if the push() triggered a
+// readable event, and the user called read(largeNumber) such that
+// needReadable was set, then we ought to push more, so that another
+// 'readable' event will be triggered.
+function needMoreData(state) {
+ return !state.ended &&
+ (state.needReadable ||
+ state.length < state.highWaterMark ||
+ state.length === 0);
+}
+
+// backwards compatibility.
+Readable.prototype.setEncoding = function(enc) {
+ if (!StringDecoder)
+ StringDecoder = require('string_decoder/').StringDecoder;
+ this._readableState.decoder = new StringDecoder(enc);
+ this._readableState.encoding = enc;
+};
+
+// Don't raise the hwm > 128MB
+var MAX_HWM = 0x800000;
+function roundUpToNextPowerOf2(n) {
+ if (n >= MAX_HWM) {
+ n = MAX_HWM;
+ } else {
+ // Get the next highest power of 2
+ n--;
+ for (var p = 1; p < 32; p <<= 1) n |= n >> p;
+ n++;
+ }
+ return n;
+}
+
+function howMuchToRead(n, state) {
+ if (state.length === 0 && state.ended)
+ return 0;
+
+ if (state.objectMode)
+ return n === 0 ? 0 : 1;
+
+ if (isNaN(n) || n === null) {
+ // only flow one buffer at a time
+ if (state.flowing && state.buffer.length)
+ return state.buffer[0].length;
+ else
+ return state.length;
+ }
+
+ if (n <= 0)
+ return 0;
+
+ // If we're asking for more than the target buffer level,
+ // then raise the water mark. Bump up to the next highest
+ // power of 2, to prevent increasing it excessively in tiny
+ // amounts.
+ if (n > state.highWaterMark)
+ state.highWaterMark = roundUpToNextPowerOf2(n);
+
+ // don't have that much. return null, unless we've ended.
+ if (n > state.length) {
+ if (!state.ended) {
+ state.needReadable = true;
+ return 0;
+ } else
+ return state.length;
+ }
+
+ return n;
+}
+
+// you can override either this method, or the async _read(n) below.
+Readable.prototype.read = function(n) {
+ var state = this._readableState;
+ state.calledRead = true;
+ var nOrig = n;
+
+ if (typeof n !== 'number' || n > 0)
+ state.emittedReadable = false;
+
+ // if we're doing read(0) to trigger a readable event, but we
+ // already have a bunch of data in the buffer, then just trigger
+ // the 'readable' event and move on.
+ if (n === 0 &&
+ state.needReadable &&
+ (state.length >= state.highWaterMark || state.ended)) {
+ emitReadable(this);
+ return null;
+ }
+
+ n = howMuchToRead(n, state);
+
+ // if we've ended, and we're now clear, then finish it up.
+ if (n === 0 && state.ended) {
+ if (state.length === 0)
+ endReadable(this);
+ return null;
+ }
+
+ // All the actual chunk generation logic needs to be
+ // *below* the call to _read. The reason is that in certain
+ // synthetic stream cases, such as passthrough streams, _read
+ // may be a completely synchronous operation which may change
+ // the state of the read buffer, providing enough data when
+ // before there was *not* enough.
+ //
+ // So, the steps are:
+ // 1. Figure out what the state of things will be after we do
+ // a read from the buffer.
+ //
+ // 2. If that resulting state will trigger a _read, then call _read.
+ // Note that this may be asynchronous, or synchronous. Yes, it is
+ // deeply ugly to write APIs this way, but that still doesn't mean
+ // that the Readable class should behave improperly, as streams are
+ // designed to be sync/async agnostic.
+ // Take note if the _read call is sync or async (ie, if the read call
+ // has returned yet), so that we know whether or not it's safe to emit
+ // 'readable' etc.
+ //
+ // 3. Actually pull the requested chunks out of the buffer and return.
+
+ // if we need a readable event, then we need to do some reading.
+ var doRead = state.needReadable;
+
+ // if we currently have less than the highWaterMark, then also read some
+ if (state.length - n <= state.highWaterMark)
+ doRead = true;
+
+ // however, if we've ended, then there's no point, and if we're already
+ // reading, then it's unnecessary.
+ if (state.ended || state.reading)
+ doRead = false;
+
+ if (doRead) {
+ state.reading = true;
+ state.sync = true;
+ // if the length is currently zero, then we *need* a readable event.
+ if (state.length === 0)
+ state.needReadable = true;
+ // call internal read method
+ this._read(state.highWaterMark);
+ state.sync = false;
+ }
+
+ // If _read called its callback synchronously, then `reading`
+ // will be false, and we need to re-evaluate how much data we
+ // can return to the user.
+ if (doRead && !state.reading)
+ n = howMuchToRead(nOrig, state);
+
+ var ret;
+ if (n > 0)
+ ret = fromList(n, state);
+ else
+ ret = null;
+
+ if (ret === null) {
+ state.needReadable = true;
+ n = 0;
+ }
+
+ state.length -= n;
+
+ // If we have nothing in the buffer, then we want to know
+ // as soon as we *do* get something into the buffer.
+ if (state.length === 0 && !state.ended)
+ state.needReadable = true;
+
+ // If we happened to read() exactly the remaining amount in the
+ // buffer, and the EOF has been seen at this point, then make sure
+ // that we emit 'end' on the very next tick.
+ if (state.ended && !state.endEmitted && state.length === 0)
+ endReadable(this);
+
+ return ret;
+};
+
+function chunkInvalid(state, chunk) {
+ var er = null;
+ if (!Buffer.isBuffer(chunk) &&
+ 'string' !== typeof chunk &&
+ chunk !== null &&
+ chunk !== undefined &&
+ !state.objectMode &&
+ !er) {
+ er = new TypeError('Invalid non-string/buffer chunk');
+ }
+ return er;
+}
+
+
+function onEofChunk(stream, state) {
+ if (state.decoder && !state.ended) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length) {
+ state.buffer.push(chunk);
+ state.length += state.objectMode ? 1 : chunk.length;
+ }
+ }
+ state.ended = true;
+
+ // if we've ended and we have some data left, then emit
+ // 'readable' now to make sure it gets picked up.
+ if (state.length > 0)
+ emitReadable(stream);
+ else
+ endReadable(stream);
+}
+
+// Don't emit readable right away in sync mode, because this can trigger
+// another read() call => stack overflow. This way, it might trigger
+// a nextTick recursion warning, but that's not so bad.
+function emitReadable(stream) {
+ var state = stream._readableState;
+ state.needReadable = false;
+ if (state.emittedReadable)
+ return;
+
+ state.emittedReadable = true;
+ if (state.sync)
+ process.nextTick(function() {
+ emitReadable_(stream);
+ });
+ else
+ emitReadable_(stream);
+}
+
+function emitReadable_(stream) {
+ stream.emit('readable');
+}
+
+
+// at this point, the user has presumably seen the 'readable' event,
+// and called read() to consume some data. that may have triggered
+// in turn another _read(n) call, in which case reading = true if
+// it's in progress.
+// However, if we're not ended, or reading, and the length < hwm,
+// then go ahead and try to read some more preemptively.
+function maybeReadMore(stream, state) {
+ if (!state.readingMore) {
+ state.readingMore = true;
+ process.nextTick(function() {
+ maybeReadMore_(stream, state);
+ });
+ }
+}
+
+function maybeReadMore_(stream, state) {
+ var len = state.length;
+ while (!state.reading && !state.flowing && !state.ended &&
+ state.length < state.highWaterMark) {
+ stream.read(0);
+ if (len === state.length)
+ // didn't get any data, stop spinning.
+ break;
+ else
+ len = state.length;
+ }
+ state.readingMore = false;
+}
+
+// abstract method. to be overridden in specific implementation classes.
+// call cb(er, data) where data is <= n in length.
+// for virtual (non-string, non-buffer) streams, "length" is somewhat
+// arbitrary, and perhaps not very meaningful.
+Readable.prototype._read = function(n) {
+ this.emit('error', new Error('not implemented'));
+};
+
+Readable.prototype.pipe = function(dest, pipeOpts) {
+ var src = this;
+ var state = this._readableState;
+
+ switch (state.pipesCount) {
+ case 0:
+ state.pipes = dest;
+ break;
+ case 1:
+ state.pipes = [state.pipes, dest];
+ break;
+ default:
+ state.pipes.push(dest);
+ break;
+ }
+ state.pipesCount += 1;
+
+ var doEnd = (!pipeOpts || pipeOpts.end !== false) &&
+ dest !== process.stdout &&
+ dest !== process.stderr;
+
+ var endFn = doEnd ? onend : cleanup;
+ if (state.endEmitted)
+ process.nextTick(endFn);
+ else
+ src.once('end', endFn);
+
+ dest.on('unpipe', onunpipe);
+ function onunpipe(readable) {
+ if (readable !== src) return;
+ cleanup();
+ }
+
+ function onend() {
+ dest.end();
+ }
+
+ // when the dest drains, it reduces the awaitDrain counter
+ // on the source. This would be more elegant with a .once()
+ // handler in flow(), but adding and removing repeatedly is
+ // too slow.
+ var ondrain = pipeOnDrain(src);
+ dest.on('drain', ondrain);
+
+ function cleanup() {
+ // cleanup event handlers once the pipe is broken
+ dest.removeListener('close', onclose);
+ dest.removeListener('finish', onfinish);
+ dest.removeListener('drain', ondrain);
+ dest.removeListener('error', onerror);
+ dest.removeListener('unpipe', onunpipe);
+ src.removeListener('end', onend);
+ src.removeListener('end', cleanup);
+
+ // if the reader is waiting for a drain event from this
+ // specific writer, then it would cause it to never start
+ // flowing again.
+ // So, if this is awaiting a drain, then we just call it now.
+ // If we don't know, then assume that we are waiting for one.
+ if (!dest._writableState || dest._writableState.needDrain)
+ ondrain();
+ }
+
+ // if the dest has an error, then stop piping into it.
+ // however, don't suppress the throwing behavior for this.
+ function onerror(er) {
+ unpipe();
+ dest.removeListener('error', onerror);
+ if (EE.listenerCount(dest, 'error') === 0)
+ dest.emit('error', er);
+ }
+ // This is a brutally ugly hack to make sure that our error handler
+ // is attached before any userland ones. NEVER DO THIS.
+ if (!dest._events || !dest._events.error)
+ dest.on('error', onerror);
+ else if (isArray(dest._events.error))
+ dest._events.error.unshift(onerror);
+ else
+ dest._events.error = [onerror, dest._events.error];
+
+
+
+ // Both close and finish should trigger unpipe, but only once.
+ function onclose() {
+ dest.removeListener('finish', onfinish);
+ unpipe();
+ }
+ dest.once('close', onclose);
+ function onfinish() {
+ dest.removeListener('close', onclose);
+ unpipe();
+ }
+ dest.once('finish', onfinish);
+
+ function unpipe() {
+ src.unpipe(dest);
+ }
+
+ // tell the dest that it's being piped to
+ dest.emit('pipe', src);
+
+ // start the flow if it hasn't been started already.
+ if (!state.flowing) {
+ // the handler that waits for readable events after all
+ // the data gets sucked out in flow.
+ // This would be easier to follow with a .once() handler
+ // in flow(), but that is too slow.
+ this.on('readable', pipeOnReadable);
+
+ state.flowing = true;
+ process.nextTick(function() {
+ flow(src);
+ });
+ }
+
+ return dest;
+};
+
+function pipeOnDrain(src) {
+ return function() {
+ var dest = this;
+ var state = src._readableState;
+ state.awaitDrain--;
+ if (state.awaitDrain === 0)
+ flow(src);
+ };
+}
+
+function flow(src) {
+ var state = src._readableState;
+ var chunk;
+ state.awaitDrain = 0;
+
+ function write(dest, i, list) {
+ var written = dest.write(chunk);
+ if (false === written) {
+ state.awaitDrain++;
+ }
+ }
+
+ while (state.pipesCount && null !== (chunk = src.read())) {
+
+ if (state.pipesCount === 1)
+ write(state.pipes, 0, null);
+ else
+ forEach(state.pipes, write);
+
+ src.emit('data', chunk);
+
+ // if anyone needs a drain, then we have to wait for that.
+ if (state.awaitDrain > 0)
+ return;
+ }
+
+ // if every destination was unpiped, either before entering this
+ // function, or in the while loop, then stop flowing.
+ //
+ // NB: This is a pretty rare edge case.
+ if (state.pipesCount === 0) {
+ state.flowing = false;
+
+ // if there were data event listeners added, then switch to old mode.
+ if (EE.listenerCount(src, 'data') > 0)
+ emitDataEvents(src);
+ return;
+ }
+
+ // at this point, no one needed a drain, so we just ran out of data
+ // on the next readable event, start it over again.
+ state.ranOut = true;
+}
+
+function pipeOnReadable() {
+ if (this._readableState.ranOut) {
+ this._readableState.ranOut = false;
+ flow(this);
+ }
+}
+
+
+Readable.prototype.unpipe = function(dest) {
+ var state = this._readableState;
+
+ // if we're not piping anywhere, then do nothing.
+ if (state.pipesCount === 0)
+ return this;
+
+ // just one destination. most common case.
+ if (state.pipesCount === 1) {
+ // passed in one, but it's not the right one.
+ if (dest && dest !== state.pipes)
+ return this;
+
+ if (!dest)
+ dest = state.pipes;
+
+ // got a match.
+ state.pipes = null;
+ state.pipesCount = 0;
+ this.removeListener('readable', pipeOnReadable);
+ state.flowing = false;
+ if (dest)
+ dest.emit('unpipe', this);
+ return this;
+ }
+
+ // slow case. multiple pipe destinations.
+
+ if (!dest) {
+ // remove all.
+ var dests = state.pipes;
+ var len = state.pipesCount;
+ state.pipes = null;
+ state.pipesCount = 0;
+ this.removeListener('readable', pipeOnReadable);
+ state.flowing = false;
+
+ for (var i = 0; i < len; i++)
+ dests[i].emit('unpipe', this);
+ return this;
+ }
+
+ // try to find the right one.
+ var i = indexOf(state.pipes, dest);
+ if (i === -1)
+ return this;
+
+ state.pipes.splice(i, 1);
+ state.pipesCount -= 1;
+ if (state.pipesCount === 1)
+ state.pipes = state.pipes[0];
+
+ dest.emit('unpipe', this);
+
+ return this;
+};
+
+// set up data events if they are asked for
+// Ensure readable listeners eventually get something
+Readable.prototype.on = function(ev, fn) {
+ var res = Stream.prototype.on.call(this, ev, fn);
+
+ if (ev === 'data' && !this._readableState.flowing)
+ emitDataEvents(this);
+
+ if (ev === 'readable' && this.readable) {
+ var state = this._readableState;
+ if (!state.readableListening) {
+ state.readableListening = true;
+ state.emittedReadable = false;
+ state.needReadable = true;
+ if (!state.reading) {
+ this.read(0);
+ } else if (state.length) {
+ emitReadable(this, state);
+ }
+ }
+ }
+
+ return res;
+};
+Readable.prototype.addListener = Readable.prototype.on;
+
+// pause() and resume() are remnants of the legacy readable stream API
+// If the user uses them, then switch into old mode.
+Readable.prototype.resume = function() {
+ emitDataEvents(this);
+ this.read(0);
+ this.emit('resume');
+};
+
+Readable.prototype.pause = function() {
+ emitDataEvents(this, true);
+ this.emit('pause');
+};
+
+function emitDataEvents(stream, startPaused) {
+ var state = stream._readableState;
+
+ if (state.flowing) {
+ // https://github.com/isaacs/readable-stream/issues/16
+ throw new Error('Cannot switch to old mode now.');
+ }
+
+ var paused = startPaused || false;
+ var readable = false;
+
+ // convert to an old-style stream.
+ stream.readable = true;
+ stream.pipe = Stream.prototype.pipe;
+ stream.on = stream.addListener = Stream.prototype.on;
+
+ stream.on('readable', function() {
+ readable = true;
+
+ var c;
+ while (!paused && (null !== (c = stream.read())))
+ stream.emit('data', c);
+
+ if (c === null) {
+ readable = false;
+ stream._readableState.needReadable = true;
+ }
+ });
+
+ stream.pause = function() {
+ paused = true;
+ this.emit('pause');
+ };
+
+ stream.resume = function() {
+ paused = false;
+ if (readable)
+ process.nextTick(function() {
+ stream.emit('readable');
+ });
+ else
+ this.read(0);
+ this.emit('resume');
+ };
+
+ // now make it start, just in case it hadn't already.
+ stream.emit('readable');
+}
+
+// wrap an old-style stream as the async data source.
+// This is *not* part of the readable stream interface.
+// It is an ugly unfortunate mess of history.
+Readable.prototype.wrap = function(stream) {
+ var state = this._readableState;
+ var paused = false;
+
+ var self = this;
+ stream.on('end', function() {
+ if (state.decoder && !state.ended) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length)
+ self.push(chunk);
+ }
+
+ self.push(null);
+ });
+
+ stream.on('data', function(chunk) {
+ if (state.decoder)
+ chunk = state.decoder.write(chunk);
+ if (!chunk || !state.objectMode && !chunk.length)
+ return;
+
+ var ret = self.push(chunk);
+ if (!ret) {
+ paused = true;
+ stream.pause();
+ }
+ });
+
+ // proxy all the other methods.
+ // important when wrapping filters and duplexes.
+ for (var i in stream) {
+ if (typeof stream[i] === 'function' &&
+ typeof this[i] === 'undefined') {
+ this[i] = function(method) { return function() {
+ return stream[method].apply(stream, arguments);
+ }}(i);
+ }
+ }
+
+ // proxy certain important events.
+ var events = ['error', 'close', 'destroy', 'pause', 'resume'];
+ forEach(events, function(ev) {
+ stream.on(ev, self.emit.bind(self, ev));
+ });
+
+ // when we try to consume some more bytes, simply unpause the
+ // underlying stream.
+ self._read = function(n) {
+ if (paused) {
+ paused = false;
+ stream.resume();
+ }
+ };
+
+ return self;
+};
+
+
+
+// exposed for testing purposes only.
+Readable._fromList = fromList;
+
+// Pluck off n bytes from an array of buffers.
+// Length is the combined lengths of all the buffers in the list.
+function fromList(n, state) {
+ var list = state.buffer;
+ var length = state.length;
+ var stringMode = !!state.decoder;
+ var objectMode = !!state.objectMode;
+ var ret;
+
+ // nothing in the list, definitely empty.
+ if (list.length === 0)
+ return null;
+
+ if (length === 0)
+ ret = null;
+ else if (objectMode)
+ ret = list.shift();
+ else if (!n || n >= length) {
+ // read it all, truncate the array.
+ if (stringMode)
+ ret = list.join('');
+ else
+ ret = Buffer.concat(list, length);
+ list.length = 0;
+ } else {
+ // read just some of it.
+ if (n < list[0].length) {
+ // just take a part of the first list item.
+ // slice is the same for buffers and strings.
+ var buf = list[0];
+ ret = buf.slice(0, n);
+ list[0] = buf.slice(n);
+ } else if (n === list[0].length) {
+ // first list is a perfect match
+ ret = list.shift();
+ } else {
+ // complex case.
+ // we have enough to cover it, but it spans past the first buffer.
+ if (stringMode)
+ ret = '';
+ else
+ ret = new Buffer(n);
+
+ var c = 0;
+ for (var i = 0, l = list.length; i < l && c < n; i++) {
+ var buf = list[0];
+ var cpy = Math.min(n - c, buf.length);
+
+ if (stringMode)
+ ret += buf.slice(0, cpy);
+ else
+ buf.copy(ret, c, 0, cpy);
+
+ if (cpy < buf.length)
+ list[0] = buf.slice(cpy);
+ else
+ list.shift();
+
+ c += cpy;
+ }
+ }
+ }
+
+ return ret;
+}
+
+function endReadable(stream) {
+ var state = stream._readableState;
+
+ // If we get here before consuming all the bytes, then that is a
+ // bug in node. Should never happen.
+ if (state.length > 0)
+ throw new Error('endReadable called on non-empty stream');
+
+ if (!state.endEmitted && state.calledRead) {
+ state.ended = true;
+ process.nextTick(function() {
+ // Check that we didn't get one last unshift.
+ if (!state.endEmitted && state.length === 0) {
+ state.endEmitted = true;
+ stream.readable = false;
+ stream.emit('end');
+ }
+ });
+ }
+}
+
+function forEach (xs, f) {
+ for (var i = 0, l = xs.length; i < l; i++) {
+ f(xs[i], i);
+ }
+}
+
+function indexOf (xs, x) {
+ for (var i = 0, l = xs.length; i < l; i++) {
+ if (xs[i] === x) return i;
+ }
+ return -1;
+}
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"core-util-is":83,"events":18,"inherits":33,"isarray":84,"stream":24,"string_decoder/":85}],81:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+// a transform stream is a readable/writable stream where you do
+// something with the data. Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored. (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation. For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes. When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up. When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer. When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks. If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk. However,
+// a pathological inflate type of transform can cause excessive buffering
+// here. For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output. In this case, you could write a very small
+// amount of input, and end up with a very large amount of output. In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform. A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
+
+module.exports = Transform;
+
+var Duplex = require('./_stream_duplex');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(Transform, Duplex);
+
+
+function TransformState(options, stream) {
+ this.afterTransform = function(er, data) {
+ return afterTransform(stream, er, data);
+ };
+
+ this.needTransform = false;
+ this.transforming = false;
+ this.writecb = null;
+ this.writechunk = null;
+}
+
+function afterTransform(stream, er, data) {
+ var ts = stream._transformState;
+ ts.transforming = false;
+
+ var cb = ts.writecb;
+
+ if (!cb)
+ return stream.emit('error', new Error('no writecb in Transform class'));
+
+ ts.writechunk = null;
+ ts.writecb = null;
+
+ if (data !== null && data !== undefined)
+ stream.push(data);
+
+ if (cb)
+ cb(er);
+
+ var rs = stream._readableState;
+ rs.reading = false;
+ if (rs.needReadable || rs.length < rs.highWaterMark) {
+ stream._read(rs.highWaterMark);
+ }
+}
+
+
+function Transform(options) {
+ if (!(this instanceof Transform))
+ return new Transform(options);
+
+ Duplex.call(this, options);
+
+ var ts = this._transformState = new TransformState(options, this);
+
+ // when the writable side finishes, then flush out anything remaining.
+ var stream = this;
+
+ // start out asking for a readable event once data is transformed.
+ this._readableState.needReadable = true;
+
+ // we have implemented the _read method, and done the other things
+ // that Readable wants before the first _read call, so unset the
+ // sync guard flag.
+ this._readableState.sync = false;
+
+ this.once('finish', function() {
+ if ('function' === typeof this._flush)
+ this._flush(function(er) {
+ done(stream, er);
+ });
+ else
+ done(stream);
+ });
+}
+
+Transform.prototype.push = function(chunk, encoding) {
+ this._transformState.needTransform = false;
+ return Duplex.prototype.push.call(this, chunk, encoding);
+};
+
+// This is the part where you do stuff!
+// override this function in implementation classes.
+// 'chunk' is an input chunk.
+//
+// Call `push(newChunk)` to pass along transformed output
+// to the readable side. You may call 'push' zero or more times.
+//
+// Call `cb(err)` when you are done with this chunk. If you pass
+// an error, then that'll put the hurt on the whole operation. If you
+// never call cb(), then you'll never get another chunk.
+Transform.prototype._transform = function(chunk, encoding, cb) {
+ throw new Error('not implemented');
+};
+
+Transform.prototype._write = function(chunk, encoding, cb) {
+ var ts = this._transformState;
+ ts.writecb = cb;
+ ts.writechunk = chunk;
+ ts.writeencoding = encoding;
+ if (!ts.transforming) {
+ var rs = this._readableState;
+ if (ts.needTransform ||
+ rs.needReadable ||
+ rs.length < rs.highWaterMark)
+ this._read(rs.highWaterMark);
+ }
+};
+
+// Doesn't matter what the args are here.
+// _transform does all the work.
+// That we got here means that the readable side wants more data.
+Transform.prototype._read = function(n) {
+ var ts = this._transformState;
+
+ if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
+ ts.transforming = true;
+ this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+ } else {
+ // mark that we need a transform, so that any data that comes in
+ // will get processed, now that we've asked for it.
+ ts.needTransform = true;
+ }
+};
+
+
+function done(stream, er) {
+ if (er)
+ return stream.emit('error', er);
+
+ // if there's nothing in the write buffer, then that means
+ // that nothing more will ever be provided
+ var ws = stream._writableState;
+ var rs = stream._readableState;
+ var ts = stream._transformState;
+
+ if (ws.length)
+ throw new Error('calling transform done when ws.length != 0');
+
+ if (ts.transforming)
+ throw new Error('calling transform done when still transforming');
+
+ return stream.push(null);
+}
+
+},{"./_stream_duplex":78,"core-util-is":83,"inherits":33}],82:[function(require,module,exports){
+(function (process){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// A bit simpler than readable streams.
+// Implement an async ._write(chunk, cb), and it'll handle all
+// the drain event emission and buffering.
+
+module.exports = Writable;
+
+/*<replacement>*/
+var Buffer = require('buffer').Buffer;
+/*</replacement>*/
+
+Writable.WritableState = WritableState;
+
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+
+var Stream = require('stream');
+
+util.inherits(Writable, Stream);
+
+function WriteReq(chunk, encoding, cb) {
+ this.chunk = chunk;
+ this.encoding = encoding;
+ this.callback = cb;
+}
+
+function WritableState(options, stream) {
+ options = options || {};
+
+ // the point at which write() starts returning false
+ // Note: 0 is a valid value, means that we always return false if
+ // the entire buffer is not flushed immediately on write()
+ var hwm = options.highWaterMark;
+ this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
+
+ // object stream flag to indicate whether or not this stream
+ // contains buffers or objects.
+ this.objectMode = !!options.objectMode;
+
+ // cast to ints.
+ this.highWaterMark = ~~this.highWaterMark;
+
+ this.needDrain = false;
+ // at the start of calling end()
+ this.ending = false;
+ // when end() has been called, and returned
+ this.ended = false;
+ // when 'finish' is emitted
+ this.finished = false;
+
+ // should we decode strings into buffers before passing to _write?
+ // this is here so that some node-core streams can optimize string
+ // handling at a lower level.
+ var noDecode = options.decodeStrings === false;
+ this.decodeStrings = !noDecode;
+
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+ // not an actual buffer we keep track of, but a measurement
+ // of how much we're waiting to get pushed to some underlying
+ // socket or file.
+ this.length = 0;
+
+ // a flag to see when we're in the middle of a write.
+ this.writing = false;
+
+ // a flag to be able to tell if the onwrite cb is called immediately,
+ // or on a later tick. We set this to true at first, becuase any
+ // actions that shouldn't happen until "later" should generally also
+ // not happen before the first write call.
+ this.sync = true;
+
+ // a flag to know if we're processing previously buffered items, which
+ // may call the _write() callback in the same tick, so that we don't
+ // end up in an overlapped onwrite situation.
+ this.bufferProcessing = false;
+
+ // the callback that's passed to _write(chunk,cb)
+ this.onwrite = function(er) {
+ onwrite(stream, er);
+ };
+
+ // the callback that the user supplies to write(chunk,encoding,cb)
+ this.writecb = null;
+
+ // the amount that is being written when _write is called.
+ this.writelen = 0;
+
+ this.buffer = [];
+
+ // True if the error was already emitted and should not be thrown again
+ this.errorEmitted = false;
+}
+
+function Writable(options) {
+ var Duplex = require('./_stream_duplex');
+
+ // Writable ctor is applied to Duplexes, though they're not
+ // instanceof Writable, they're instanceof Readable.
+ if (!(this instanceof Writable) && !(this instanceof Duplex))
+ return new Writable(options);
+
+ this._writableState = new WritableState(options, this);
+
+ // legacy.
+ this.writable = true;
+
+ Stream.call(this);
+}
+
+// Otherwise people can pipe Writable streams, which is just wrong.
+Writable.prototype.pipe = function() {
+ this.emit('error', new Error('Cannot pipe. Not readable.'));
+};
+
+
+function writeAfterEnd(stream, state, cb) {
+ var er = new Error('write after end');
+ // TODO: defer error events consistently everywhere, not just the cb
+ stream.emit('error', er);
+ process.nextTick(function() {
+ cb(er);
+ });
+}
+
+// If we get something that is not a buffer, string, null, or undefined,
+// and we're not in objectMode, then that's an error.
+// Otherwise stream chunks are all considered to be of length=1, and the
+// watermarks determine how many objects to keep in the buffer, rather than
+// how many bytes or characters.
+function validChunk(stream, state, chunk, cb) {
+ var valid = true;
+ if (!Buffer.isBuffer(chunk) &&
+ 'string' !== typeof chunk &&
+ chunk !== null &&
+ chunk !== undefined &&
+ !state.objectMode) {
+ var er = new TypeError('Invalid non-string/buffer chunk');
+ stream.emit('error', er);
+ process.nextTick(function() {
+ cb(er);
+ });
+ valid = false;
+ }
+ return valid;
+}
+
+Writable.prototype.write = function(chunk, encoding, cb) {
+ var state = this._writableState;
+ var ret = false;
+
+ if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (Buffer.isBuffer(chunk))
+ encoding = 'buffer';
+ else if (!encoding)
+ encoding = state.defaultEncoding;
+
+ if (typeof cb !== 'function')
+ cb = function() {};
+
+ if (state.ended)
+ writeAfterEnd(this, state, cb);
+ else if (validChunk(this, state, chunk, cb))
+ ret = writeOrBuffer(this, state, chunk, encoding, cb);
+
+ return ret;
+};
+
+function decodeChunk(state, chunk, encoding) {
+ if (!state.objectMode &&
+ state.decodeStrings !== false &&
+ typeof chunk === 'string') {
+ chunk = new Buffer(chunk, encoding);
+ }
+ return chunk;
+}
+
+// if we're already writing something, then just put this
+// in the queue, and wait our turn. Otherwise, call _write
+// If we return false, then we need a drain event, so set that flag.
+function writeOrBuffer(stream, state, chunk, encoding, cb) {
+ chunk = decodeChunk(state, chunk, encoding);
+ if (Buffer.isBuffer(chunk))
+ encoding = 'buffer';
+ var len = state.objectMode ? 1 : chunk.length;
+
+ state.length += len;
+
+ var ret = state.length < state.highWaterMark;
+ // we must ensure that previous needDrain will not be reset to false.
+ if (!ret)
+ state.needDrain = true;
+
+ if (state.writing)
+ state.buffer.push(new WriteReq(chunk, encoding, cb));
+ else
+ doWrite(stream, state, len, chunk, encoding, cb);
+
+ return ret;
+}
+
+function doWrite(stream, state, len, chunk, encoding, cb) {
+ state.writelen = len;
+ state.writecb = cb;
+ state.writing = true;
+ state.sync = true;
+ stream._write(chunk, encoding, state.onwrite);
+ state.sync = false;
+}
+
+function onwriteError(stream, state, sync, er, cb) {
+ if (sync)
+ process.nextTick(function() {
+ cb(er);
+ });
+ else
+ cb(er);
+
+ stream._writableState.errorEmitted = true;
+ stream.emit('error', er);
+}
+
+function onwriteStateUpdate(state) {
+ state.writing = false;
+ state.writecb = null;
+ state.length -= state.writelen;
+ state.writelen = 0;
+}
+
+function onwrite(stream, er) {
+ var state = stream._writableState;
+ var sync = state.sync;
+ var cb = state.writecb;
+
+ onwriteStateUpdate(state);
+
+ if (er)
+ onwriteError(stream, state, sync, er, cb);
+ else {
+ // Check if we're actually ready to finish, but don't emit yet
+ var finished = needFinish(stream, state);
+
+ if (!finished && !state.bufferProcessing && state.buffer.length)
+ clearBuffer(stream, state);
+
+ if (sync) {
+ process.nextTick(function() {
+ afterWrite(stream, state, finished, cb);
+ });
+ } else {
+ afterWrite(stream, state, finished, cb);
+ }
+ }
+}
+
+function afterWrite(stream, state, finished, cb) {
+ if (!finished)
+ onwriteDrain(stream, state);
+ cb();
+ if (finished)
+ finishMaybe(stream, state);
+}
+
+// Must force callback to be called on nextTick, so that we don't
+// emit 'drain' before the write() consumer gets the 'false' return
+// value, and has a chance to attach a 'drain' listener.
+function onwriteDrain(stream, state) {
+ if (state.length === 0 && state.needDrain) {
+ state.needDrain = false;
+ stream.emit('drain');
+ }
+}
+
+
+// if there's something in the buffer waiting, then process it
+function clearBuffer(stream, state) {
+ state.bufferProcessing = true;
+
+ for (var c = 0; c < state.buffer.length; c++) {
+ var entry = state.buffer[c];
+ var chunk = entry.chunk;
+ var encoding = entry.encoding;
+ var cb = entry.callback;
+ var len = state.objectMode ? 1 : chunk.length;
+
+ doWrite(stream, state, len, chunk, encoding, cb);
+
+ // if we didn't call the onwrite immediately, then
+ // it means that we need to wait until it does.
+ // also, that means that the chunk and cb are currently
+ // being processed, so move the buffer counter past them.
+ if (state.writing) {
+ c++;
+ break;
+ }
+ }
+
+ state.bufferProcessing = false;
+ if (c < state.buffer.length)
+ state.buffer = state.buffer.slice(c);
+ else
+ state.buffer.length = 0;
+}
+
+Writable.prototype._write = function(chunk, encoding, cb) {
+ cb(new Error('not implemented'));
+};
+
+Writable.prototype.end = function(chunk, encoding, cb) {
+ var state = this._writableState;
+
+ if (typeof chunk === 'function') {
+ cb = chunk;
+ chunk = null;
+ encoding = null;
+ } else if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (typeof chunk !== 'undefined' && chunk !== null)
+ this.write(chunk, encoding);
+
+ // ignore unnecessary end() calls.
+ if (!state.ending && !state.finished)
+ endWritable(this, state, cb);
+};
+
+
+function needFinish(stream, state) {
+ return (state.ending &&
+ state.length === 0 &&
+ !state.finished &&
+ !state.writing);
+}
+
+function finishMaybe(stream, state) {
+ var need = needFinish(stream, state);
+ if (need) {
+ state.finished = true;
+ stream.emit('finish');
+ }
+ return need;
+}
+
+function endWritable(stream, state, cb) {
+ state.ending = true;
+ finishMaybe(stream, state);
+ if (cb) {
+ if (state.finished)
+ process.nextTick(cb);
+ else
+ stream.once('finish', cb);
+ }
+ state.ended = true;
+}
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"./_stream_duplex":78,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"core-util-is":83,"inherits":33,"stream":24}],83:[function(require,module,exports){
+(function (Buffer){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+function isArray(ar) {
+ return Array.isArray(ar);
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+ return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+ return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+ return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+ return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+ return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+ return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+ return isObject(re) && objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+ return isObject(d) && objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+ return isObject(e) &&
+ (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+ return arg === null ||
+ typeof arg === 'boolean' ||
+ typeof arg === 'number' ||
+ typeof arg === 'string' ||
+ typeof arg === 'symbol' || // ES6 symbol
+ typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+function isBuffer(arg) {
+ return Buffer.isBuffer(arg);
+}
+exports.isBuffer = isBuffer;
+
+function objectToString(o) {
+ return Object.prototype.toString.call(o);
+}
+}).call(this,require("buffer").Buffer)
+},{"buffer":20}],84:[function(require,module,exports){
+module.exports = Array.isArray || function (arr) {
+ return Object.prototype.toString.call(arr) == '[object Array]';
+};
+
+},{}],85:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var Buffer = require('buffer').Buffer;
+
+var isBufferEncoding = Buffer.isEncoding
+ || function(encoding) {
+ switch (encoding && encoding.toLowerCase()) {
+ case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;
+ default: return false;
+ }
+ }
+
+
+function assertEncoding(encoding) {
+ if (encoding && !isBufferEncoding(encoding)) {
+ throw new Error('Unknown encoding: ' + encoding);
+ }
+}
+
+var StringDecoder = exports.StringDecoder = function(encoding) {
+ this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
+ assertEncoding(encoding);
+ switch (this.encoding) {
+ case 'utf8':
+ // CESU-8 represents each of Surrogate Pair by 3-bytes
+ this.surrogateSize = 3;
+ break;
+ case 'ucs2':
+ case 'utf16le':
+ // UTF-16 represents each of Surrogate Pair by 2-bytes
+ this.surrogateSize = 2;
+ this.detectIncompleteChar = utf16DetectIncompleteChar;
+ break;
+ case 'base64':
+ // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
+ this.surrogateSize = 3;
+ this.detectIncompleteChar = base64DetectIncompleteChar;
+ break;
+ default:
+ this.write = passThroughWrite;
+ return;
+ }
+
+ this.charBuffer = new Buffer(6);
+ this.charReceived = 0;
+ this.charLength = 0;
+};
+
+
+StringDecoder.prototype.write = function(buffer) {
+ var charStr = '';
+ var offset = 0;
+
+ // if our last write ended with an incomplete multibyte character
+ while (this.charLength) {
+ // determine how many remaining bytes this buffer has to offer for this char
+ var i = (buffer.length >= this.charLength - this.charReceived) ?
+ this.charLength - this.charReceived :
+ buffer.length;
+
+ // add the new bytes to the char buffer
+ buffer.copy(this.charBuffer, this.charReceived, offset, i);
+ this.charReceived += (i - offset);
+ offset = i;
+
+ if (this.charReceived < this.charLength) {
+ // still not enough chars in this buffer? wait for more ...
+ return '';
+ }
+
+ // get the character that was split
+ charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
+
+ // lead surrogate (D800-DBFF) is also the incomplete character
+ var charCode = charStr.charCodeAt(charStr.length - 1);
+ if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+ this.charLength += this.surrogateSize;
+ charStr = '';
+ continue;
+ }
+ this.charReceived = this.charLength = 0;
+
+ // if there are no more bytes in this buffer, just emit our char
+ if (i == buffer.length) return charStr;
+
+ // otherwise cut off the characters end from the beginning of this buffer
+ buffer = buffer.slice(i, buffer.length);
+ break;
+ }
+
+ var lenIncomplete = this.detectIncompleteChar(buffer);
+
+ var end = buffer.length;
+ if (this.charLength) {
+ // buffer the incomplete character bytes we got
+ buffer.copy(this.charBuffer, 0, buffer.length - lenIncomplete, end);
+ this.charReceived = lenIncomplete;
+ end -= lenIncomplete;
+ }
+
+ charStr += buffer.toString(this.encoding, 0, end);
+
+ var end = charStr.length - 1;
+ var charCode = charStr.charCodeAt(end);
+ // lead surrogate (D800-DBFF) is also the incomplete character
+ if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+ var size = this.surrogateSize;
+ this.charLength += size;
+ this.charReceived += size;
+ this.charBuffer.copy(this.charBuffer, size, 0, size);
+ this.charBuffer.write(charStr.charAt(charStr.length - 1), this.encoding);
+ return charStr.substring(0, end);
+ }
+
+ // or just emit the charStr
+ return charStr;
+};
+
+StringDecoder.prototype.detectIncompleteChar = function(buffer) {
+ // determine how many bytes we have to check at the end of this buffer
+ var i = (buffer.length >= 3) ? 3 : buffer.length;
+
+ // Figure out if one of the last i bytes of our buffer announces an
+ // incomplete char.
+ for (; i > 0; i--) {
+ var c = buffer[buffer.length - i];
+
+ // See http://en.wikipedia.org/wiki/UTF-8#Description
+
+ // 110XXXXX
+ if (i == 1 && c >> 5 == 0x06) {
+ this.charLength = 2;
+ break;
+ }
+
+ // 1110XXXX
+ if (i <= 2 && c >> 4 == 0x0E) {
+ this.charLength = 3;
+ break;
+ }
+
+ // 11110XXX
+ if (i <= 3 && c >> 3 == 0x1E) {
+ this.charLength = 4;
+ break;
+ }
+ }
+
+ return i;
+};
+
+StringDecoder.prototype.end = function(buffer) {
+ var res = '';
+ if (buffer && buffer.length)
+ res = this.write(buffer);
+
+ if (this.charReceived) {
+ var cr = this.charReceived;
+ var buf = this.charBuffer;
+ var enc = this.encoding;
+ res += buf.slice(0, cr).toString(enc);
+ }
+
+ return res;
+};
+
+function passThroughWrite(buffer) {
+ return buffer.toString(this.encoding);
+}
+
+function utf16DetectIncompleteChar(buffer) {
+ var incomplete = this.charReceived = buffer.length % 2;
+ this.charLength = incomplete ? 2 : 0;
+ return incomplete;
+}
+
+function base64DetectIncompleteChar(buffer) {
+ var incomplete = this.charReceived = buffer.length % 3;
+ this.charLength = incomplete ? 3 : 0;
+ return incomplete;
+}
+
+},{"buffer":20}],86:[function(require,module,exports){
+exports = module.exports = require('./lib/_stream_readable.js');
+exports.Readable = exports;
+exports.Writable = require('./lib/_stream_writable.js');
+exports.Duplex = require('./lib/_stream_duplex.js');
+exports.Transform = require('./lib/_stream_transform.js');
+exports.PassThrough = require('./lib/_stream_passthrough.js');
+
+},{"./lib/_stream_duplex.js":78,"./lib/_stream_passthrough.js":79,"./lib/_stream_readable.js":80,"./lib/_stream_transform.js":81,"./lib/_stream_writable.js":82}],87:[function(require,module,exports){
+module.exports=require(40)
+},{}],88:[function(require,module,exports){
+module.exports={
+ "name": "levelup",
+ "description": "Fast & simple storage - a Node.js-style LevelDB wrapper",
+ "version": "0.18.6",
+ "contributors": [
+ {
+ "name": "Rod Vagg",
+ "email": "r@va.gg",
+ "url": "https://github.com/rvagg"
+ },
+ {
+ "name": "John Chesley",
+ "email": "john@chesl.es",
+ "url": "https://github.com/chesles/"
+ },
+ {
+ "name": "Jake Verbaten",
+ "email": "raynos2@gmail.com",
+ "url": "https://github.com/raynos"
+ },
+ {
+ "name": "Dominic Tarr",
+ "email": "dominic.tarr@gmail.com",
+ "url": "https://github.com/dominictarr"
+ },
+ {
+ "name": "Max Ogden",
+ "email": "max@maxogden.com",
+ "url": "https://github.com/maxogden"
+ },
+ {
+ "name": "Lars-Magnus Skog",
+ "email": "lars.magnus.skog@gmail.com",
+ "url": "https://github.com/ralphtheninja"
+ },
+ {
+ "name": "David Björklund",
+ "email": "david.bjorklund@gmail.com",
+ "url": "https://github.com/kesla"
+ },
+ {
+ "name": "Julian Gruber",
+ "email": "julian@juliangruber.com",
+ "url": "https://github.com/juliangruber"
+ },
+ {
+ "name": "Paolo Fragomeni",
+ "email": "paolo@async.ly",
+ "url": "https://github.com/hij1nx"
+ },
+ {
+ "name": "Anton Whalley",
+ "email": "anton.whalley@nearform.com",
+ "url": "https://github.com/No9"
+ },
+ {
+ "name": "Matteo Collina",
+ "email": "matteo.collina@gmail.com",
+ "url": "https://github.com/mcollina"
+ },
+ {
+ "name": "Pedro Teixeira",
+ "email": "pedro.teixeira@gmail.com",
+ "url": "https://github.com/pgte"
+ },
+ {
+ "name": "James Halliday",
+ "email": "mail@substack.net",
+ "url": "https://github.com/substack"
+ }
+ ],
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/rvagg/node-levelup.git"
+ },
+ "homepage": "https://github.com/rvagg/node-levelup",
+ "keywords": [
+ "leveldb",
+ "stream",
+ "database",
+ "db",
+ "store",
+ "storage",
+ "json"
+ ],
+ "main": "lib/levelup.js",
+ "dependencies": {
+ "bl": "~0.8.1",
+ "deferred-leveldown": "~0.2.0",
+ "errno": "~0.1.1",
+ "prr": "~0.0.0",
+ "readable-stream": "~1.0.26",
+ "semver": "~2.3.1",
+ "xtend": "~3.0.0"
+ },
+ "devDependencies": {
+ "leveldown": "~0.10.0",
+ "bustermove": "*",
+ "tap": "*",
+ "referee": "*",
+ "rimraf": "*",
+ "async": "*",
+ "fstream": "*",
+ "tar": "*",
+ "mkfiletree": "*",
+ "readfiletree": "*",
+ "slow-stream": ">=0.0.4",
+ "delayed": "*",
+ "boganipsum": "*",
+ "du": "*",
+ "memdown": "*",
+ "msgpack-js": "*"
+ },
+ "browser": {
+ "leveldown": false,
+ "leveldown/package": false,
+ "semver": false
+ },
+ "scripts": {
+ "test": "tap test/*-test.js --stderr",
+ "functionaltests": "node ./test/functional/fstream-test.js && node ./test/functional/binary-data-test.js && node ./test/functional/compat-test.js",
+ "alltests": "npm test && npm run-script functionaltests"
+ },
+ "license": "MIT",
+ "gitHead": "213e989e2b75273e2b44c23f84f95e35bff7ea11",
+ "bugs": {
+ "url": "https://github.com/rvagg/node-levelup/issues"
+ },
+ "_id": "levelup@0.18.6",
+ "_shasum": "e6a01cb089616c8ecc0291c2a9bd3f0c44e3e5eb",
+ "_from": "levelup@~0.18.4",
+ "_npmVersion": "1.4.14",
+ "_npmUser": {
+ "name": "rvagg",
+ "email": "rod@vagg.org"
+ },
+ "maintainers": [
+ {
+ "name": "rvagg",
+ "email": "rod@vagg.org"
+ }
+ ],
+ "dist": {
+ "shasum": "e6a01cb089616c8ecc0291c2a9bd3f0c44e3e5eb",
+ "tarball": "http://127.0.0.1:5080/tarballs/levelup/0.18.6.tgz"
+ },
+ "_resolved": "http://127.0.0.1:5080/tarballs/levelup/0.18.6.tgz",
+ "readme": "ERROR: No README data found!"
+}
+
+},{}],89:[function(require,module,exports){
+'use strict';
+
+module.exports = INTERNAL;
+
+function INTERNAL() {}
+},{}],90:[function(require,module,exports){
+'use strict';
+var Promise = require('./promise');
+var reject = require('./reject');
+var resolve = require('./resolve');
+var INTERNAL = require('./INTERNAL');
+var handlers = require('./handlers');
+var noArray = reject(new TypeError('must be an array'));
+module.exports = function all(iterable) {
+ if (Object.prototype.toString.call(iterable) !== '[object Array]') {
+ return noArray;
+ }
+
+ var len = iterable.length;
+ var called = false;
+ if (!len) {
+ return resolve([]);
+ }
+
+ var values = new Array(len);
+ var resolved = 0;
+ var i = -1;
+ var promise = new Promise(INTERNAL);
+
+ while (++i < len) {
+ allResolver(iterable[i], i);
+ }
+ return promise;
+ function allResolver(value, i) {
+ resolve(value).then(resolveFromAll, function (error) {
+ if (!called) {
+ called = true;
+ handlers.reject(promise, error);
+ }
+ });
+ function resolveFromAll(outValue) {
+ values[i] = outValue;
+ if (++resolved === len & !called) {
+ called = true;
+ handlers.resolve(promise, values);
+ }
+ }
+ }
+};
+},{"./INTERNAL":89,"./handlers":91,"./promise":93,"./reject":95,"./resolve":96}],91:[function(require,module,exports){
+'use strict';
+var tryCatch = require('./tryCatch');
+var resolveThenable = require('./resolveThenable');
+var states = require('./states');
+
+exports.resolve = function (self, value) {
+ var result = tryCatch(getThen, value);
+ if (result.status === 'error') {
+ return exports.reject(self, result.value);
+ }
+ var thenable = result.value;
+
+ if (thenable) {
+ resolveThenable.safely(self, thenable);
+ } else {
+ self.state = states.FULFILLED;
+ self.outcome = value;
+ var i = -1;
+ var len = self.queue.length;
+ while (++i < len) {
+ self.queue[i].callFulfilled(value);
+ }
+ }
+ return self;
+};
+exports.reject = function (self, error) {
+ self.state = states.REJECTED;
+ self.outcome = error;
+ var i = -1;
+ var len = self.queue.length;
+ while (++i < len) {
+ self.queue[i].callRejected(error);
+ }
+ return self;
+};
+
+function getThen(obj) {
+ // Make sure we only access the accessor once as required by the spec
+ var then = obj && obj.then;
+ if (obj && typeof obj === 'object' && typeof then === 'function') {
+ return function appyThen() {
+ then.apply(obj, arguments);
+ };
+ }
+}
+},{"./resolveThenable":97,"./states":98,"./tryCatch":99}],92:[function(require,module,exports){
+module.exports = exports = require('./promise');
+
+exports.resolve = require('./resolve');
+exports.reject = require('./reject');
+exports.all = require('./all');
+},{"./all":90,"./promise":93,"./reject":95,"./resolve":96}],93:[function(require,module,exports){
+'use strict';
+
+var unwrap = require('./unwrap');
+var INTERNAL = require('./INTERNAL');
+var resolveThenable = require('./resolveThenable');
+var states = require('./states');
+var QueueItem = require('./queueItem');
+
+module.exports = Promise;
+function Promise(resolver) {
+ if (!(this instanceof Promise)) {
+ return new Promise(resolver);
+ }
+ if (typeof resolver !== 'function') {
+ throw new TypeError('reslover must be a function');
+ }
+ this.state = states.PENDING;
+ this.queue = [];
+ this.outcome = void 0;
+ if (resolver !== INTERNAL) {
+ resolveThenable.safely(this, resolver);
+ }
+}
+
+Promise.prototype['catch'] = function (onRejected) {
+ return this.then(null, onRejected);
+};
+Promise.prototype.then = function (onFulfilled, onRejected) {
+ if (typeof onFulfilled !== 'function' && this.state === states.FULFILLED ||
+ typeof onRejected !== 'function' && this.state === states.REJECTED) {
+ return this;
+ }
+ var promise = new Promise(INTERNAL);
+
+
+ if (this.state !== states.PENDING) {
+ var resolver = this.state === states.FULFILLED ? onFulfilled: onRejected;
+ unwrap(promise, resolver, this.outcome);
+ } else {
+ this.queue.push(new QueueItem(promise, onFulfilled, onRejected));
+ }
+
+ return promise;
+};
+
+},{"./INTERNAL":89,"./queueItem":94,"./resolveThenable":97,"./states":98,"./unwrap":100}],94:[function(require,module,exports){
+'use strict';
+var handlers = require('./handlers');
+var unwrap = require('./unwrap');
+
+module.exports = QueueItem;
+function QueueItem(promise, onFulfilled, onRejected) {
+ this.promise = promise;
+ if (typeof onFulfilled === 'function') {
+ this.onFulfilled = onFulfilled;
+ this.callFulfilled = this.otherCallFulfilled;
+ }
+ if (typeof onRejected === 'function') {
+ this.onRejected = onRejected;
+ this.callRejected = this.otherCallRejected;
+ }
+}
+QueueItem.prototype.callFulfilled = function (value) {
+ handlers.resolve(this.promise, value);
+};
+QueueItem.prototype.otherCallFulfilled = function (value) {
+ unwrap(this.promise, this.onFulfilled, value);
+};
+QueueItem.prototype.callRejected = function (value) {
+ handlers.reject(this.promise, value);
+};
+QueueItem.prototype.otherCallRejected = function (value) {
+ unwrap(this.promise, this.onRejected, value);
+};
+},{"./handlers":91,"./unwrap":100}],95:[function(require,module,exports){
+'use strict';
+
+var Promise = require('./promise');
+var INTERNAL = require('./INTERNAL');
+var handlers = require('./handlers');
+module.exports = reject;
+
+function reject(reason) {
+ var promise = new Promise(INTERNAL);
+ return handlers.reject(promise, reason);
+}
+},{"./INTERNAL":89,"./handlers":91,"./promise":93}],96:[function(require,module,exports){
+'use strict';
+
+var Promise = require('./promise');
+var INTERNAL = require('./INTERNAL');
+var handlers = require('./handlers');
+module.exports = resolve;
+
+var FALSE = handlers.resolve(new Promise(INTERNAL), false);
+var NULL = handlers.resolve(new Promise(INTERNAL), null);
+var UNDEFINED = handlers.resolve(new Promise(INTERNAL), void 0);
+var ZERO = handlers.resolve(new Promise(INTERNAL), 0);
+var EMPTYSTRING = handlers.resolve(new Promise(INTERNAL), '');
+
+function resolve(value) {
+ if (value) {
+ if (value instanceof Promise) {
+ return value;
+ }
+ return handlers.resolve(new Promise(INTERNAL), value);
+ }
+ var valueType = typeof value;
+ switch (valueType) {
+ case 'boolean':
+ return FALSE;
+ case 'undefined':
+ return UNDEFINED;
+ case 'object':
+ return NULL;
+ case 'number':
+ return ZERO;
+ case 'string':
+ return EMPTYSTRING;
+ }
+}
+},{"./INTERNAL":89,"./handlers":91,"./promise":93}],97:[function(require,module,exports){
+'use strict';
+var handlers = require('./handlers');
+var tryCatch = require('./tryCatch');
+function safelyResolveThenable(self, thenable) {
+ // Either fulfill, reject or reject with error
+ var called = false;
+ function onError(value) {
+ if (called) {
+ return;
+ }
+ called = true;
+ handlers.reject(self, value);
+ }
+
+ function onSuccess(value) {
+ if (called) {
+ return;
+ }
+ called = true;
+ handlers.resolve(self, value);
+ }
+
+ function tryToUnwrap() {
+ thenable(onSuccess, onError);
+ }
+
+ var result = tryCatch(tryToUnwrap);
+ if (result.status === 'error') {
+ onError(result.value);
+ }
+}
+exports.safely = safelyResolveThenable;
+},{"./handlers":91,"./tryCatch":99}],98:[function(require,module,exports){
+// Lazy man's symbols for states
+
+exports.REJECTED = ['REJECTED'];
+exports.FULFILLED = ['FULFILLED'];
+exports.PENDING = ['PENDING'];
+},{}],99:[function(require,module,exports){
+'use strict';
+
+module.exports = tryCatch;
+
+function tryCatch(func, value) {
+ var out = {};
+ try {
+ out.value = func(value);
+ out.status = 'success';
+ } catch (e) {
+ out.status = 'error';
+ out.value = e;
+ }
+ return out;
+}
+},{}],100:[function(require,module,exports){
+'use strict';
+
+var immediate = require('immediate');
+var handlers = require('./handlers');
+module.exports = unwrap;
+
+function unwrap(promise, func, value) {
+ immediate(function () {
+ var returnValue;
+ try {
+ returnValue = func(value);
+ } catch (e) {
+ return handlers.reject(promise, e);
+ }
+ if (returnValue === promise) {
+ handlers.reject(promise, new TypeError('Cannot resolve promise with itself'));
+ } else {
+ handlers.resolve(promise, returnValue);
+ }
+ });
+}
+},{"./handlers":91,"immediate":101}],101:[function(require,module,exports){
+'use strict';
+var types = [
+ require('./nextTick'),
+ require('./mutation.js'),
+ require('./messageChannel'),
+ require('./stateChange'),
+ require('./timeout')
+];
+var draining;
+var queue = [];
+function drainQueue() {
+ draining = true;
+ var i, oldQueue;
+ var len = queue.length;
+ while (len) {
+ oldQueue = queue;
+ queue = [];
+ i = -1;
+ while (++i < len) {
+ oldQueue[i]();
+ }
+ len = queue.length;
+ }
+ draining = false;
+}
+var scheduleDrain;
+var i = -1;
+var len = types.length;
+while (++ i < len) {
+ if (types[i] && types[i].test && types[i].test()) {
+ scheduleDrain = types[i].install(drainQueue);
+ break;
+ }
+}
+module.exports = immediate;
+function immediate(task) {
+ if (queue.push(task) === 1 && !draining) {
+ scheduleDrain();
+ }
+}
+},{"./messageChannel":102,"./mutation.js":103,"./nextTick":17,"./stateChange":104,"./timeout":105}],102:[function(require,module,exports){
+(function (global){
+'use strict';
+
+exports.test = function () {
+ if (global.setImmediate) {
+ // we can only get here in IE10
+ // which doesn't handel postMessage well
+ return false;
+ }
+ return typeof global.MessageChannel !== 'undefined';
+};
+
+exports.install = function (func) {
+ var channel = new global.MessageChannel();
+ channel.port1.onmessage = func;
+ return function () {
+ channel.port2.postMessage(0);
+ };
+};
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],103:[function(require,module,exports){
+(function (global){
+'use strict';
+//based off rsvp https://github.com/tildeio/rsvp.js
+//license https://github.com/tildeio/rsvp.js/blob/master/LICENSE
+//https://github.com/tildeio/rsvp.js/blob/master/lib/rsvp/asap.js
+
+var Mutation = global.MutationObserver || global.WebKitMutationObserver;
+
+exports.test = function () {
+ return Mutation;
+};
+
+exports.install = function (handle) {
+ var called = 0;
+ var observer = new Mutation(handle);
+ var element = global.document.createTextNode('');
+ observer.observe(element, {
+ characterData: true
+ });
+ return function () {
+ element.data = (called = ++called % 2);
+ };
+};
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],104:[function(require,module,exports){
+(function (global){
+'use strict';
+
+exports.test = function () {
+ return 'document' in global && 'onreadystatechange' in global.document.createElement('script');
+};
+
+exports.install = function (handle) {
+ return function () {
+
+ // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
+ // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
+ var scriptEl = global.document.createElement('script');
+ scriptEl.onreadystatechange = function () {
+ handle();
+
+ scriptEl.onreadystatechange = null;
+ scriptEl.parentNode.removeChild(scriptEl);
+ scriptEl = null;
+ };
+ global.document.documentElement.appendChild(scriptEl);
+
+ return handle;
+ };
+};
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],105:[function(require,module,exports){
+'use strict';
+exports.test = function () {
+ return true;
+};
+
+exports.install = function (t) {
+ return function () {
+ setTimeout(t, 0);
+ };
+};
+},{}],106:[function(require,module,exports){
+"use strict";
+
+// Extends method
+// (taken from http://code.jquery.com/jquery-1.9.0.js)
+// Populate the class2type map
+var class2type = {};
+
+var types = [
+ "Boolean", "Number", "String", "Function", "Array",
+ "Date", "RegExp", "Object", "Error"
+];
+for (var i = 0; i < types.length; i++) {
+ var typename = types[i];
+ class2type["[object " + typename + "]"] = typename.toLowerCase();
+}
+
+var core_toString = class2type.toString;
+var core_hasOwn = class2type.hasOwnProperty;
+
+function type(obj) {
+ if (obj === null) {
+ return String(obj);
+ }
+ return typeof obj === "object" || typeof obj === "function" ?
+ class2type[core_toString.call(obj)] || "object" :
+ typeof obj;
+}
+
+function isWindow(obj) {
+ return obj !== null && obj === obj.window;
+}
+
+function isPlainObject(obj) {
+ // Must be an Object.
+ // Because of IE, we also have to check the presence of
+ // the constructor property.
+ // Make sure that DOM nodes and window objects don't pass through, as well
+ if (!obj || type(obj) !== "object" || obj.nodeType || isWindow(obj)) {
+ return false;
+ }
+
+ try {
+ // Not own constructor property must be Object
+ if (obj.constructor &&
+ !core_hasOwn.call(obj, "constructor") &&
+ !core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) {
+ return false;
+ }
+ } catch ( e ) {
+ // IE8,9 Will throw exceptions on certain host objects #9897
+ return false;
+ }
+
+ // Own properties are enumerated firstly, so to speed up,
+ // if last one is own, then all properties are own.
+ var key;
+ for (key in obj) {}
+
+ return key === undefined || core_hasOwn.call(obj, key);
+}
+
+
+function isFunction(obj) {
+ return type(obj) === "function";
+}
+
+var isArray = Array.isArray || function (obj) {
+ return type(obj) === "array";
+};
+
+function extend() {
+ var options, name, src, copy, copyIsArray, clone,
+ target = arguments[0] || {},
+ i = 1,
+ length = arguments.length,
+ deep = false;
+
+ // Handle a deep copy situation
+ if (typeof target === "boolean") {
+ deep = target;
+ target = arguments[1] || {};
+ // skip the boolean and the target
+ i = 2;
+ }
+
+ // Handle case when target is a string or something (possible in deep copy)
+ if (typeof target !== "object" && !isFunction(target)) {
+ target = {};
+ }
+
+ // extend jQuery itself if only one argument is passed
+ if (length === i) {
+ /* jshint validthis: true */
+ target = this;
+ --i;
+ }
+
+ for (; i < length; i++) {
+ // Only deal with non-null/undefined values
+ if ((options = arguments[i]) != null) {
+ // Extend the base object
+ for (name in options) {
+ //if (options.hasOwnProperty(name)) {
+ if (!(name in Object.prototype)) {
+
+ src = target[name];
+ copy = options[name];
+
+ // Prevent never-ending loop
+ if (target === copy) {
+ continue;
+ }
+
+ // Recurse if we're merging plain objects or arrays
+ if (deep && copy && (isPlainObject(copy) ||
+ (copyIsArray = isArray(copy)))) {
+ if (copyIsArray) {
+ copyIsArray = false;
+ clone = src && isArray(src) ? src : [];
+
+ } else {
+ clone = src && isPlainObject(src) ? src : {};
+ }
+
+ // Never move original objects, clone them
+ target[name] = extend(deep, clone, copy);
+
+ // Don't bring in undefined values
+ } else if (copy !== undefined) {
+ if (!(isArray(options) && isFunction(copy))) {
+ target[name] = copy;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Return the modified object
+ return target;
+}
+
+
+module.exports = extend;
+
+
+
+},{}],107:[function(require,module,exports){
+/*jshint bitwise:false*/
+/*global unescape*/
+
+(function (factory) {
+ if (typeof exports === 'object') {
+ // Node/CommonJS
+ module.exports = factory();
+ } else if (typeof define === 'function' && define.amd) {
+ // AMD
+ define(factory);
+ } else {
+ // Browser globals (with support for web workers)
+ var glob;
+ try {
+ glob = window;
+ } catch (e) {
+ glob = self;
+ }
+
+ glob.SparkMD5 = factory();
+ }
+}(function (undefined) {
+
+ 'use strict';
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ /*
+ * Fastest md5 implementation around (JKM md5)
+ * Credits: Joseph Myers
+ *
+ * @see http://www.myersdaily.org/joseph/javascript/md5-text.html
+ * @see http://jsperf.com/md5-shootout/7
+ */
+
+ /* this function is much faster,
+ so if possible we use it. Some IEs
+ are the only ones I know of that
+ need the idiotic second function,
+ generated by an if clause. */
+ var add32 = function (a, b) {
+ return (a + b) & 0xFFFFFFFF;
+ },
+
+ cmn = function (q, a, b, x, s, t) {
+ a = add32(add32(a, q), add32(x, t));
+ return add32((a << s) | (a >>> (32 - s)), b);
+ },
+
+ ff = function (a, b, c, d, x, s, t) {
+ return cmn((b & c) | ((~b) & d), a, b, x, s, t);
+ },
+
+ gg = function (a, b, c, d, x, s, t) {
+ return cmn((b & d) | (c & (~d)), a, b, x, s, t);
+ },
+
+ hh = function (a, b, c, d, x, s, t) {
+ return cmn(b ^ c ^ d, a, b, x, s, t);
+ },
+
+ ii = function (a, b, c, d, x, s, t) {
+ return cmn(c ^ (b | (~d)), a, b, x, s, t);
+ },
+
+ md5cycle = function (x, k) {
+ var a = x[0],
+ b = x[1],
+ c = x[2],
+ d = x[3];
+
+ a = ff(a, b, c, d, k[0], 7, -680876936);
+ d = ff(d, a, b, c, k[1], 12, -389564586);
+ c = ff(c, d, a, b, k[2], 17, 606105819);
+ b = ff(b, c, d, a, k[3], 22, -1044525330);
+ a = ff(a, b, c, d, k[4], 7, -176418897);
+ d = ff(d, a, b, c, k[5], 12, 1200080426);
+ c = ff(c, d, a, b, k[6], 17, -1473231341);
+ b = ff(b, c, d, a, k[7], 22, -45705983);
+ a = ff(a, b, c, d, k[8], 7, 1770035416);
+ d = ff(d, a, b, c, k[9], 12, -1958414417);
+ c = ff(c, d, a, b, k[10], 17, -42063);
+ b = ff(b, c, d, a, k[11], 22, -1990404162);
+ a = ff(a, b, c, d, k[12], 7, 1804603682);
+ d = ff(d, a, b, c, k[13], 12, -40341101);
+ c = ff(c, d, a, b, k[14], 17, -1502002290);
+ b = ff(b, c, d, a, k[15], 22, 1236535329);
+
+ a = gg(a, b, c, d, k[1], 5, -165796510);
+ d = gg(d, a, b, c, k[6], 9, -1069501632);
+ c = gg(c, d, a, b, k[11], 14, 643717713);
+ b = gg(b, c, d, a, k[0], 20, -373897302);
+ a = gg(a, b, c, d, k[5], 5, -701558691);
+ d = gg(d, a, b, c, k[10], 9, 38016083);
+ c = gg(c, d, a, b, k[15], 14, -660478335);
+ b = gg(b, c, d, a, k[4], 20, -405537848);
+ a = gg(a, b, c, d, k[9], 5, 568446438);
+ d = gg(d, a, b, c, k[14], 9, -1019803690);
+ c = gg(c, d, a, b, k[3], 14, -187363961);
+ b = gg(b, c, d, a, k[8], 20, 1163531501);
+ a = gg(a, b, c, d, k[13], 5, -1444681467);
+ d = gg(d, a, b, c, k[2], 9, -51403784);
+ c = gg(c, d, a, b, k[7], 14, 1735328473);
+ b = gg(b, c, d, a, k[12], 20, -1926607734);
+
+ a = hh(a, b, c, d, k[5], 4, -378558);
+ d = hh(d, a, b, c, k[8], 11, -2022574463);
+ c = hh(c, d, a, b, k[11], 16, 1839030562);
+ b = hh(b, c, d, a, k[14], 23, -35309556);
+ a = hh(a, b, c, d, k[1], 4, -1530992060);
+ d = hh(d, a, b, c, k[4], 11, 1272893353);
+ c = hh(c, d, a, b, k[7], 16, -155497632);
+ b = hh(b, c, d, a, k[10], 23, -1094730640);
+ a = hh(a, b, c, d, k[13], 4, 681279174);
+ d = hh(d, a, b, c, k[0], 11, -358537222);
+ c = hh(c, d, a, b, k[3], 16, -722521979);
+ b = hh(b, c, d, a, k[6], 23, 76029189);
+ a = hh(a, b, c, d, k[9], 4, -640364487);
+ d = hh(d, a, b, c, k[12], 11, -421815835);
+ c = hh(c, d, a, b, k[15], 16, 530742520);
+ b = hh(b, c, d, a, k[2], 23, -995338651);
+
+ a = ii(a, b, c, d, k[0], 6, -198630844);
+ d = ii(d, a, b, c, k[7], 10, 1126891415);
+ c = ii(c, d, a, b, k[14], 15, -1416354905);
+ b = ii(b, c, d, a, k[5], 21, -57434055);
+ a = ii(a, b, c, d, k[12], 6, 1700485571);
+ d = ii(d, a, b, c, k[3], 10, -1894986606);
+ c = ii(c, d, a, b, k[10], 15, -1051523);
+ b = ii(b, c, d, a, k[1], 21, -2054922799);
+ a = ii(a, b, c, d, k[8], 6, 1873313359);
+ d = ii(d, a, b, c, k[15], 10, -30611744);
+ c = ii(c, d, a, b, k[6], 15, -1560198380);
+ b = ii(b, c, d, a, k[13], 21, 1309151649);
+ a = ii(a, b, c, d, k[4], 6, -145523070);
+ d = ii(d, a, b, c, k[11], 10, -1120210379);
+ c = ii(c, d, a, b, k[2], 15, 718787259);
+ b = ii(b, c, d, a, k[9], 21, -343485551);
+
+ x[0] = add32(a, x[0]);
+ x[1] = add32(b, x[1]);
+ x[2] = add32(c, x[2]);
+ x[3] = add32(d, x[3]);
+ },
+
+ /* there needs to be support for Unicode here,
+ * unless we pretend that we can redefine the MD-5
+ * algorithm for multi-byte characters (perhaps
+ * by adding every four 16-bit characters and
+ * shortening the sum to 32 bits). Otherwise
+ * I suggest performing MD-5 as if every character
+ * was two bytes--e.g., 0040 0025 = @%--but then
+ * how will an ordinary MD-5 sum be matched?
+ * There is no way to standardize text to something
+ * like UTF-8 before transformation; speed cost is
+ * utterly prohibitive. The JavaScript standard
+ * itself needs to look at this: it should start
+ * providing access to strings as preformed UTF-8
+ * 8-bit unsigned value arrays.
+ */
+ md5blk = function (s) {
+ var md5blks = [],
+ i; /* Andy King said do it this way. */
+
+ for (i = 0; i < 64; i += 4) {
+ md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
+ }
+ return md5blks;
+ },
+
+ md5blk_array = function (a) {
+ var md5blks = [],
+ i; /* Andy King said do it this way. */
+
+ for (i = 0; i < 64; i += 4) {
+ md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
+ }
+ return md5blks;
+ },
+
+ md51 = function (s) {
+ var n = s.length,
+ state = [1732584193, -271733879, -1732584194, 271733878],
+ i,
+ length,
+ tail,
+ tmp,
+ lo,
+ hi;
+
+ for (i = 64; i <= n; i += 64) {
+ md5cycle(state, md5blk(s.substring(i - 64, i)));
+ }
+ s = s.substring(i - 64);
+ length = s.length;
+ tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+ for (i = 0; i < length; i += 1) {
+ tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
+ }
+ tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+ if (i > 55) {
+ md5cycle(state, tail);
+ for (i = 0; i < 16; i += 1) {
+ tail[i] = 0;
+ }
+ }
+
+ // Beware that the final length might not fit in 32 bits so we take care of that
+ tmp = n * 8;
+ tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+ lo = parseInt(tmp[2], 16);
+ hi = parseInt(tmp[1], 16) || 0;
+
+ tail[14] = lo;
+ tail[15] = hi;
+
+ md5cycle(state, tail);
+ return state;
+ },
+
+ md51_array = function (a) {
+ var n = a.length,
+ state = [1732584193, -271733879, -1732584194, 271733878],
+ i,
+ length,
+ tail,
+ tmp,
+ lo,
+ hi;
+
+ for (i = 64; i <= n; i += 64) {
+ md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
+ }
+
+ // Not sure if it is a bug, however IE10 will always produce a sub array of length 1
+ // containing the last element of the parent array if the sub array specified starts
+ // beyond the length of the parent array - weird.
+ // https://connect.microsoft.com/IE/feedback/details/771452/typed-array-subarray-issue
+ a = (i - 64) < n ? a.subarray(i - 64) : new Uint8Array(0);
+
+ length = a.length;
+ tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+ for (i = 0; i < length; i += 1) {
+ tail[i >> 2] |= a[i] << ((i % 4) << 3);
+ }
+
+ tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+ if (i > 55) {
+ md5cycle(state, tail);
+ for (i = 0; i < 16; i += 1) {
+ tail[i] = 0;
+ }
+ }
+
+ // Beware that the final length might not fit in 32 bits so we take care of that
+ tmp = n * 8;
+ tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+ lo = parseInt(tmp[2], 16);
+ hi = parseInt(tmp[1], 16) || 0;
+
+ tail[14] = lo;
+ tail[15] = hi;
+
+ md5cycle(state, tail);
+
+ return state;
+ },
+
+ hex_chr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'],
+
+ rhex = function (n) {
+ var s = '',
+ j;
+ for (j = 0; j < 4; j += 1) {
+ s += hex_chr[(n >> (j * 8 + 4)) & 0x0F] + hex_chr[(n >> (j * 8)) & 0x0F];
+ }
+ return s;
+ },
+
+ hex = function (x) {
+ var i;
+ for (i = 0; i < x.length; i += 1) {
+ x[i] = rhex(x[i]);
+ }
+ return x.join('');
+ },
+
+ md5 = function (s) {
+ return hex(md51(s));
+ },
+
+
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ /**
+ * SparkMD5 OOP implementation.
+ *
+ * Use this class to perform an incremental md5, otherwise use the
+ * static methods instead.
+ */
+ SparkMD5 = function () {
+ // call reset to init the instance
+ this.reset();
+ };
+
+
+ // In some cases the fast add32 function cannot be used..
+ if (md5('hello') !== '5d41402abc4b2a76b9719d911017c592') {
+ add32 = function (x, y) {
+ var lsw = (x & 0xFFFF) + (y & 0xFFFF),
+ msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+ return (msw << 16) | (lsw & 0xFFFF);
+ };
+ }
+
+
+ /**
+ * Appends a string.
+ * A conversion will be applied if an utf8 string is detected.
+ *
+ * @param {String} str The string to be appended
+ *
+ * @return {SparkMD5} The instance itself
+ */
+ SparkMD5.prototype.append = function (str) {
+ // converts the string to utf8 bytes if necessary
+ if (/[\u0080-\uFFFF]/.test(str)) {
+ str = unescape(encodeURIComponent(str));
+ }
+
+ // then append as binary
+ this.appendBinary(str);
+
+ return this;
+ };
+
+ /**
+ * Appends a binary string.
+ *
+ * @param {String} contents The binary string to be appended
+ *
+ * @return {SparkMD5} The instance itself
+ */
+ SparkMD5.prototype.appendBinary = function (contents) {
+ this._buff += contents;
+ this._length += contents.length;
+
+ var length = this._buff.length,
+ i;
+
+ for (i = 64; i <= length; i += 64) {
+ md5cycle(this._state, md5blk(this._buff.substring(i - 64, i)));
+ }
+
+ this._buff = this._buff.substr(i - 64);
+
+ return this;
+ };
+
+ /**
+ * Finishes the incremental computation, reseting the internal state and
+ * returning the result.
+ * Use the raw parameter to obtain the raw result instead of the hex one.
+ *
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.prototype.end = function (raw) {
+ var buff = this._buff,
+ length = buff.length,
+ i,
+ tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ ret;
+
+ for (i = 0; i < length; i += 1) {
+ tail[i >> 2] |= buff.charCodeAt(i) << ((i % 4) << 3);
+ }
+
+ this._finish(tail, length);
+ ret = !!raw ? this._state : hex(this._state);
+
+ this.reset();
+
+ return ret;
+ };
+
+ /**
+ * Finish the final calculation based on the tail.
+ *
+ * @param {Array} tail The tail (will be modified)
+ * @param {Number} length The length of the remaining buffer
+ */
+ SparkMD5.prototype._finish = function (tail, length) {
+ var i = length,
+ tmp,
+ lo,
+ hi;
+
+ tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+ if (i > 55) {
+ md5cycle(this._state, tail);
+ for (i = 0; i < 16; i += 1) {
+ tail[i] = 0;
+ }
+ }
+
+ // Do the final computation based on the tail and length
+ // Beware that the final length may not fit in 32 bits so we take care of that
+ tmp = this._length * 8;
+ tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+ lo = parseInt(tmp[2], 16);
+ hi = parseInt(tmp[1], 16) || 0;
+
+ tail[14] = lo;
+ tail[15] = hi;
+ md5cycle(this._state, tail);
+ };
+
+ /**
+ * Resets the internal state of the computation.
+ *
+ * @return {SparkMD5} The instance itself
+ */
+ SparkMD5.prototype.reset = function () {
+ this._buff = "";
+ this._length = 0;
+ this._state = [1732584193, -271733879, -1732584194, 271733878];
+
+ return this;
+ };
+
+ /**
+ * Releases memory used by the incremental buffer and other aditional
+ * resources. If you plan to use the instance again, use reset instead.
+ */
+ SparkMD5.prototype.destroy = function () {
+ delete this._state;
+ delete this._buff;
+ delete this._length;
+ };
+
+
+ /**
+ * Performs the md5 hash on a string.
+ * A conversion will be applied if utf8 string is detected.
+ *
+ * @param {String} str The string
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.hash = function (str, raw) {
+ // converts the string to utf8 bytes if necessary
+ if (/[\u0080-\uFFFF]/.test(str)) {
+ str = unescape(encodeURIComponent(str));
+ }
+
+ var hash = md51(str);
+
+ return !!raw ? hash : hex(hash);
+ };
+
+ /**
+ * Performs the md5 hash on a binary string.
+ *
+ * @param {String} content The binary string
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.hashBinary = function (content, raw) {
+ var hash = md51(content);
+
+ return !!raw ? hash : hex(hash);
+ };
+
+ /**
+ * SparkMD5 OOP implementation for array buffers.
+ *
+ * Use this class to perform an incremental md5 ONLY for array buffers.
+ */
+ SparkMD5.ArrayBuffer = function () {
+ // call reset to init the instance
+ this.reset();
+ };
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ /**
+ * Appends an array buffer.
+ *
+ * @param {ArrayBuffer} arr The array to be appended
+ *
+ * @return {SparkMD5.ArrayBuffer} The instance itself
+ */
+ SparkMD5.ArrayBuffer.prototype.append = function (arr) {
+ // TODO: we could avoid the concatenation here but the algorithm would be more complex
+ // if you find yourself needing extra performance, please make a PR.
+ var buff = this._concatArrayBuffer(this._buff, arr),
+ length = buff.length,
+ i;
+
+ this._length += arr.byteLength;
+
+ for (i = 64; i <= length; i += 64) {
+ md5cycle(this._state, md5blk_array(buff.subarray(i - 64, i)));
+ }
+
+ // Avoids IE10 weirdness (documented above)
+ this._buff = (i - 64) < length ? buff.subarray(i - 64) : new Uint8Array(0);
+
+ return this;
+ };
+
+ /**
+ * Finishes the incremental computation, reseting the internal state and
+ * returning the result.
+ * Use the raw parameter to obtain the raw result instead of the hex one.
+ *
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.ArrayBuffer.prototype.end = function (raw) {
+ var buff = this._buff,
+ length = buff.length,
+ tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ i,
+ ret;
+
+ for (i = 0; i < length; i += 1) {
+ tail[i >> 2] |= buff[i] << ((i % 4) << 3);
+ }
+
+ this._finish(tail, length);
+ ret = !!raw ? this._state : hex(this._state);
+
+ this.reset();
+
+ return ret;
+ };
+
+ SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;
+
+ /**
+ * Resets the internal state of the computation.
+ *
+ * @return {SparkMD5.ArrayBuffer} The instance itself
+ */
+ SparkMD5.ArrayBuffer.prototype.reset = function () {
+ this._buff = new Uint8Array(0);
+ this._length = 0;
+ this._state = [1732584193, -271733879, -1732584194, 271733878];
+
+ return this;
+ };
+
+ /**
+ * Releases memory used by the incremental buffer and other aditional
+ * resources. If you plan to use the instance again, use reset instead.
+ */
+ SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;
+
+ /**
+ * Concats two array buffers, returning a new one.
+ *
+ * @param {ArrayBuffer} first The first array buffer
+ * @param {ArrayBuffer} second The second array buffer
+ *
+ * @return {ArrayBuffer} The new array buffer
+ */
+ SparkMD5.ArrayBuffer.prototype._concatArrayBuffer = function (first, second) {
+ var firstLength = first.length,
+ result = new Uint8Array(firstLength + second.byteLength);
+
+ result.set(first);
+ result.set(new Uint8Array(second), firstLength);
+
+ return result;
+ };
+
+ /**
+ * Performs the md5 hash on an array buffer.
+ *
+ * @param {ArrayBuffer} arr The array buffer
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.ArrayBuffer.hash = function (arr, raw) {
+ var hash = md51_array(new Uint8Array(arr));
+
+ return !!raw ? hash : hex(hash);
+ };
+
+ return SparkMD5;
+}));
+
+},{}],108:[function(require,module,exports){
+arguments[4][78][0].apply(exports,arguments)
+},{"./_stream_readable":109,"./_stream_writable":111,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"core-util-is":112,"inherits":33}],109:[function(require,module,exports){
+module.exports=require(80)
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"core-util-is":112,"events":18,"inherits":33,"isarray":113,"stream":24,"string_decoder/":114}],110:[function(require,module,exports){
+arguments[4][81][0].apply(exports,arguments)
+},{"./_stream_duplex":108,"core-util-is":112,"inherits":33}],111:[function(require,module,exports){
+arguments[4][82][0].apply(exports,arguments)
+},{"./_stream_duplex":108,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"core-util-is":112,"inherits":33,"stream":24}],112:[function(require,module,exports){
+module.exports=require(83)
+},{"buffer":20}],113:[function(require,module,exports){
+module.exports=require(84)
+},{}],114:[function(require,module,exports){
+module.exports=require(85)
+},{"buffer":20}],115:[function(require,module,exports){
+module.exports = require("./lib/_stream_transform.js")
+
+},{"./lib/_stream_transform.js":110}],116:[function(require,module,exports){
+module.exports=require(45)
+},{}],117:[function(require,module,exports){
+arguments[4][46][0].apply(exports,arguments)
+},{"./has-keys":116,"object-keys":119}],118:[function(require,module,exports){
+module.exports=require(47)
+},{}],119:[function(require,module,exports){
+arguments[4][48][0].apply(exports,arguments)
+},{"./shim":121}],120:[function(require,module,exports){
+module.exports=require(49)
+},{}],121:[function(require,module,exports){
+module.exports=require(50)
+},{"./foreach":118,"./isArguments":120}],122:[function(require,module,exports){
+var Transform = require('readable-stream/transform')
+ , inherits = require('util').inherits
+ , xtend = require('xtend')
+
+
+// a noop _transform function
+function noop (chunk, enc, callback) {
+ callback(null, chunk)
+}
+
+
+// create a new export function, used by both the main export and
+// the .ctor export, contains common logic for dealing with arguments
+function through2 (construct) {
+ return function (options, transform, flush) {
+ if (typeof options == 'function') {
+ flush = transform
+ transform = options
+ options = {}
+ }
+
+ if (typeof transform != 'function')
+ transform = noop
+
+ if (typeof flush != 'function')
+ flush = null
+
+ return construct(options, transform, flush)
+ }
+}
+
+
+// main export, just make me a transform stream!
+module.exports = through2(function (options, transform, flush) {
+ var t2 = new Transform(options)
+
+ t2._transform = transform
+
+ if (flush)
+ t2._flush = flush
+
+ return t2
+})
+
+
+// make me a reusable prototype that I can `new`, or implicitly `new`
+// with a constructor call
+module.exports.ctor = through2(function (options, transform, flush) {
+ function Through2 (override) {
+ if (!(this instanceof Through2))
+ return new Through2(override)
+
+ this.options = xtend(options, override)
+
+ Transform.call(this, this.options)
+ }
+
+ inherits(Through2, Transform)
+
+ Through2.prototype._transform = transform
+
+ if (flush)
+ Through2.prototype._flush = flush
+
+ return Through2
+})
+
+
+module.exports.obj = through2(function (options, transform, flush) {
+ var t2 = new Transform(xtend({ objectMode: true }, options))
+
+ t2._transform = transform
+
+ if (flush)
+ t2._flush = flush
+
+ return t2
+})
+
+},{"readable-stream/transform":115,"util":32,"xtend":117}]},{},[11])
\ No newline at end of file
diff --git a/dist/pouchdb.idb-alt.min.js b/dist/pouchdb.idb-alt.min.js
new file mode 100644
index 0000000..8c78d0e
--- /dev/null
+++ b/dist/pouchdb.idb-alt.min.js
@@ -0,0 +1,13 @@
+// PouchDB alternative IndexedDB plugin 3.0.1
+// Based on level.js: https://github.com/maxogden/level.js
+//
+// (c) 2012-2014 Dale Harvey and the PouchDB team
+// PouchDB may be freely distributed under the Apache license, version 2.0.
+// For all details and documentation:
+// http://pouchdb.com
+require=function e(t,n,r){function o(s,a){if(!n[s]){if(!t[s]){var u="function"==typeof require&&require;if(!a&&u)return u(s,!0);if(i)return i(s,!0);throw new Error("Cannot find module '"+s+"'")}var c=n[s]={exports:{}};t[s][0].call(c.exports,function(e){var n=t[s][1][e];return o(n?n:e)},c,c.exports,e,t,n,r)}return n[s].exports}for(var i="function"==typeof require&&require,s=0;s<r.length;s++)o(r[s]);return o}({1:[function(e,t){(function(n,r,o){"use strict";function i(e,t){function x(){T.docStore=B.sublevel(p,{valueEncoding:"json"}),T.bySeqStore=B.sublevel(g,{valueEncoding:"json"}),T.attachmentStore=B.sublevel(v,{valueEncoding:"json"}),T.binaryStore=B.sublevel(b,{valueEncoding:"binary"}),T.localStore=B.sublevel(y,{valueEncoding:"json"}),T.metaStore=B.sublevel(m,{valueEncoding:"json"}),h.localAndMetaStores(B,T,function(){T.metaStore.get(E,function(e,r){"undefined"==typeof B._updateSeq&&(B._updateSeq=r||0),T.metaStore.get(k,function(e,r){B._docCountQueue.docCount=e?0:r,j(function(e){e&&C.emit("error",e),T.metaStore.get(S,function(e,r){L=e?d.uuid():r,T.metaStore.put(S,L,function(){n.nextTick(function(){t(null,C)})})})})})})})}function j(e){return B._docCountQueue.running||!B._docCountQueue.queue.length||-1===B._docCountQueue.docCount?A(0,e):B._docCountQueue.docCount}function O(){if(!B._docCountQueue.running&&B._docCountQueue.queue.length&&-1!==B._docCountQueue.docCount){B._docCountQueue.running=!0;var e=B._docCountQueue.queue.shift();return B.isClosed()?e.callback(new Error("database is closed")):void T.metaStore.get(k,function(t,n){function r(t){B._docCountQueue.docCount=n,e.callback(t,n),B._docCountQueue.running=!1,O()}n=t?0:n,0===e.delta?r():T.metaStore.put(k,n+e.delta,r)})}}function A(e,t){B._docCountQueue.queue.push({delta:e,callback:t}),O()}function I(e){return("0000000000000000"+e).slice(-16)}function N(e){return parseInt(e,10)}function R(e,t){var n=e.data;if(n._id=e.metadata.id,"_rev"in n){if(n._rev!==e.metadata.rev)return t(new Error("wrong doc returned"))}else n._rev=e.metadata.rev;t(null,{doc:n,metadata:e.metadata})}e=d.clone(e);var L,B,C=this,T={},D=e.name;"undefined"==typeof e.createIfMissing&&(e.createIfMissing=!0);var M=e.db||a;"function"!=typeof M.destroy&&(M.destroy=function(e,t){t()});var U;w.has(M.name)?U=w.get(M.name):(U=new d.Map,w.set(M.name,U)),U.has(D)?(B=U.get(D),x()):U.set(D,u(s(D,e,function(n){return n?(U["delete"](D),t(n)):(B=U.get(D),B._locks=B._locks||new d.Set,B._docCountQueue={queue:[],running:!1,docCount:-1},void(e.db||e.noMigrate?x():h.toSublevel(D,B,x)))}))),C.type=function(){return"leveldb"},C._id=function(e){e(null,L)},C._info=function(e){j(function(t,n){return t?e(t):void T.metaStore.get(E,function(t,r){return t&&(r=B._updateSeq),e(null,{doc_count:n,update_seq:r})})})},C._get=function(e,t,n){function r(e){o.push(e)}t=d.clone(t);var o=[];B.on("pouchdb-id-"+e,r),T.docStore.get(e,function(i,s){function a(e){u=e}if(B.removeListener("pouchdb-id-"+e,r),i||!s)return n(l.MISSING_DOC);if(d.isDeleted(s)&&!t.rev)return n(l.error(l.MISSING_DOC,"deleted"));var u,c=f.winningRev(s);c=t.rev?t.rev:c;var h=s.rev_map[c],p=o.filter(function(e){return e.metadata.seq===h});return p.length?R(p.pop(),n):(B.on("pouchdb-"+h,a),void T.bySeqStore.get(I(h),function(e,t){if(B.removeListener("pouchdb-"+h,a),u)return R(u,n);if(!t)return n(l.MISSING_DOC);if("_id"in t&&t._id!==s.id)return n(new Error("wrong doc returned"));if(t._id=s.id,"_rev"in t){if(t._rev!==c)return n(new Error("wrong doc returned"))}else t._rev=c;return n(null,{doc:t,metadata:s})}))})},C._getAttachment=function(e,t,i){var s=e.digest;T.binaryStore.get(s,function(s,a){var u;return s&&"NotFoundError"===s.name?(u=t.encode?"":n.browser?d.createBlob([""],{type:e.content_type}):new o(""),i(null,u)):s?i(s):(u=n.browser?t.encode?d.btoa(r.unescape(a)):d.createBlob([d.fixBinary(r.unescape(a))],{type:e.content_type}):t.encode?d.btoa(a):a,void i(null,u))})},C.lock=function(e){return B._locks.has(e)?!1:(B._locks.add(e),!0)},C.unlock=function(e){return B._locks.has(e)?(B._locks["delete"](e),!0):!1},C._bulkDocs=function(e,t,o){function s(){var e=w;if(!(S>_)){if(e>=m.length)return 0===S?p():void 0;var t=m[e];if(w++,S++,t._id&&d.isLocalId(t._id))return void C[t._deleted?"_removeLocal":"_putLocal"](t,function(t){b[e]=t?t:{},S--,s()});T.docStore.get(t.metadata.id,function(n,r){return C.lock(t.metadata.id)?void(n?"NotFoundError"===n.name?a(t,e,function(){C.unlock(t.metadata.id),S--,s()}):(n.error=!0,b[e]=n,C.unlock(t.metadata.id),S--,s()):u(r,t,e,function(){C.unlock(t.metadata.id),S--,s()})):(b[e]=g(l.REV_CONFLICT,"someobody else is accessing this"),S--,s())}),v&&s()}}function a(e,n,r){return"was_delete"in t&&d.isDeleted(e.metadata)?(b[n]=g(l.MISSING_DOC,e._bulk_seq),r()):void c(e,n,function(t){return t?r(t):d.isDeleted(e.metadata)?r():void A(1,r)})}function u(e,t,n,r){var o=f.merge(e.rev_tree,t.metadata.rev_tree[0],1e3),i=d.isDeleted(e)&&d.isDeleted(t.metadata)&&v||!d.isDeleted(e)&&v&&"new_leaf"!==o.conflicts;if(i)return b[n]=g(l.REV_CONFLICT,t._bulk_seq),r();t.metadata.rev_tree=o.tree,t.metadata.rev_map=e.rev_map;var s=0,a=d.isDeleted(e),u=d.isDeleted(t.metadata);s=a===u?0:u>a?-1:1,A(s,function(e){return e?r(e):void c(t,n,r)})}function c(e,t,i){function s(e){p||(e?(p=e,i(p)):g===v.length&&f())}function a(e){g++,s(e)}function u(e,t,n,r,o){return function(i){h(e,t+i,n,r,o)}}function c(e,t,n,o){return function(i){var s=r.escape(d.arrayBufferToBinaryString(i.target.result));d.MD5(s).then(u(e,t,n,s,o))}}function f(){var n=e.metadata.rev_map[e.metadata.rev];n||(n=++B._updateSeq),e.metadata.rev_map[e.metadata.rev]=e.metadata.seq=n;var r=I(n);B.emit("pouchdb-id-"+e.metadata.id,e),B.emit("pouchdb-"+r,e),B.batch([{key:r,value:e.data,prefix:T.bySeqStore,type:"put",valueEncoding:"json"},{key:e.metadata.id,value:e.metadata,prefix:T.docStore,type:"put",valueEncoding:"json"}],function(n){return n||(B.emit("pouchdb-id-"+e.metadata.id,e),B.emit("pouchdb-"+r,e)),T.metaStore.put(E,B._updateSeq,function(n){return b[t]=n?n:e,i()})})}var p=null,g=0;e.data._id=e.metadata.id,e.data._rev=e.metadata.rev,d.isDeleted(e.metadata)&&(e.data._deleted=!0);for(var v=e.data._attachments?Object.keys(e.data._attachments):[],y=0;y<v.length;y++){var m=v[y];if(e.data._attachments[m].stub)g++,s();else{var _,w,k=e.data._attachments[m];if("string"==typeof k.data){try{_=d.atob(k.data),n.browser&&(_=r.escape(_))}catch(S){return void o(d.extend({},l.BAD_ARG,{reason:"Attachments need to be base64 encoded"}))}w=n.browser?"md5-":""}else{if(n.browser){var x=new FileReader;return x.onloadend=c(e,"md5-",m,a),void x.readAsArrayBuffer(k.data)}_=k.data,w=""}d.MD5(_).then(u(e,w,m,_,a))}}v.length||f()}function h(e,t,n,r,o){delete e.data._attachments[n].data,e.data._attachments[n].digest=t,T.attachmentStore.get(t,function(n,i){if(n&&"NotFoundError"!==n.name)return o(n);var s=[e.metadata.id,e.metadata.rev].join("@"),a={};i?i.refs&&(a.refs=i.refs,a.refs[s]=!0):(a.refs={},a.refs[s]=!0),T.attachmentStore.put(t,a,function(e){return 0===r.length?o(e):void T.binaryStore.put(t,r,function(e){o(e)})})})}function p(){b.sort(function(e,t){return e._bulk_seq-t._bulk_seq});var e=b.map(function(e){if(e._bulk_seq)delete e._bulk_seq;else if(!Object.keys(e).length)return{ok:!0};if(e.error)return e;var t=e.metadata,n=f.winningRev(t);return{ok:!0,id:t.id,rev:n}});i.Changes.notify(D),n.nextTick(function(){o(null,e)})}function g(e,t){return e._bulk_seq=t,e}var v=t.new_edits,b=new Array(e.docs.length),y=e.docs,m=y.map(function(e,t){if(e._id&&d.isLocalId(e._id))return e;var n=d.parseDoc(e,v);return n._bulk_seq=t,n.metadata&&!n.metadata.rev_map&&(n.metadata.rev_map={}),n}),w=0,k=m.filter(function(e){return e.error});if(k.length)return o(k[0]);var S=0;s()},C._allDocs=function(e,t){e=d.clone(e),j(function(n,r){if(n)return t(n);var o={},i=e.skip||0;if(e.startkey&&(o.start=e.startkey),e.endkey&&(o.end=e.endkey),e.key&&(o.start=o.end=e.key),e.descending){o.reverse=!0;var s=o.start;o.start=o.end,o.end=s}var a;if(a="number"==typeof e.limit?e.limit:-1,0===a||"start"in o&&"end"in o&&o.start>o.end)return t(null,{total_rows:r,offset:e.skip,rows:[]});var u=[],l=T.docStore.readStream(o),h=c(function(t,n,r){function o(t,n){var o={id:t.id,key:t.id,value:{rev:f.winningRev(t)}};if(e.include_docs){o.doc=n,o.doc._rev=o.value.rev,e.conflicts&&(o.doc._conflicts=f.collectConflicts(t));for(var i in o.doc._attachments)o.doc._attachments.hasOwnProperty(i)&&(o.doc._attachments[i].stub=!0)}if(e.inclusive_end===!1&&t.id===e.endkey)return r();if(d.isDeleted(t)){if("ok"!==e.deleted)return r();o.value.deleted=!0,o.doc=null}u.push(o),r()}if(d.isDeleted(t.value)){if("ok"!==e.deleted)return void r()}else{if(i-->0)return void r();if(0===a--)return l.unpipe(),l.destroy(),void r()}var s=t.value;if(e.include_docs){var c=s.rev_map[f.winningRev(s)];T.bySeqStore.get(I(c),function(e,t){o(s,t)})}else o(s)},function(n){t(null,{total_rows:r,offset:e.skip,rows:u}),n()}).on("unpipe",function(){h.end()});l.on("error",t),l.pipe(h)})},C._changes=function(e){function t(){e.done=!0,h&&e.limit&&e.limit<s.length&&(s.length=e.limit),g.unpipe(v),g.destroy(),e.continuous||e.cancelled||e.complete(null,{results:s,last_seq:a})}if(e=d.clone(e),e.continuous){var n=D+":"+d.uuid();return i.Changes.addListener(D,n,C,e),i.Changes.notify(D),{cancel:function(){i.Changes.removeListener(D,n)}}}var r,o=e.descending,s=[],a=0,u=0,l={reverse:o};"limit"in e&&e.limit>0&&(r=e.limit),l.reverse||(l.start=I(e.since?e.since+1:0));var h,p=d.filterChange(e);h="returnDocs"in e?e.returnDocs:!0;var g=T.bySeqStore.readStream(l),v=c(function(n,o,i){return r&&u>=r?(t(),i()):e.cancelled||e.done?i():void T.docStore.get(n.value._id,function(t,r){if(e.cancelled||e.done||B.isClosed()||d.isLocalId(r.id))return i();var o=n.value;o._rev=f.winningRev(r);var c=e.processChange(o,r,e);c.seq=r.seq,a<r.seq&&(a=r.seq),N(n.key)===r.rev_map[c.doc._rev]&&p(c)&&(u++,d.call(e.onChange,c),h&&s.push(c)),i()})},function(t){return e.cancelled?t():(h&&e.limit&&e.limit<s.length&&(s.length=e.limit),void t())}).on("unpipe",function(){v.end(),t()});return g.pipe(v),{cancel:function(){e.cancelled=!0,t()}}},C._close=function(e){return B.isClosed()?e(l.NOT_OPEN):void B.close(function(t){t?e(t):(U["delete"](D),e())})},C._getRevisionTree=function(e,t){T.docStore.get(e,function(e,n){e?t(l.MISSING_DOC):t(null,n.rev_tree)})},C._doCompaction=function(e,t,n,r){T.docStore.get(e,function(e,o){if(e)return r(e);var i=o.rev_map;o.rev_tree=t,n.length||r();var s=[];s.push({key:o.id,value:o,type:"put",valueEncoding:"json",prefix:T.docStore}),n.forEach(function(e){var t=i[e];t&&s.push({key:I(t),type:"del",prefix:T.bySeqStore})}),B.batch(s,r)})},C._getLocal=function(e,t){T.localStore.get(e,function(e,n){e?t(l.MISSING_DOC):t(null,n)})},C._putLocal=function(e,t){var n=e._rev,r=e._id;T.localStore.get(r,function(o,i){return o&&n?t(l.REV_CONFLICT):i&&i._rev!==n?t(l.REV_CONFLICT):(e._rev=n?"0-"+(parseInt(n.split("-")[1],10)+1):"0-0",void T.localStore.put(r,e,function(n){if(n)return t(n);var r={ok:!0,id:e._id,rev:e._rev};t(null,r)}))})},C._removeLocal=function(e,t){T.localStore.get(e._id,function(n,r){return n?t(n):r._rev!==e._rev?t(l.REV_CONFLICT):void T.localStore.del(e._id,function(n){if(n)return t(n);var r={ok:!0,id:e._id,rev:"0-0"};t(null,r)})})}}var s=e("levelup"),a=e("leveldown"),u=e("level-sublevel"),c=e("through2").obj,l=e("../deps/errors"),f=e("../merge"),d=e("../utils"),h=e("../deps/migrate"),p="document-store",g="by-sequence",v="attach-store",b="attach-binary-store",y="local-store",m="meta-store",_=50,w=new d.Map,E="_local_last_update_seq",k="_local_doc_count",S="_local_uuid";i.valid=function(){return n&&!n.browser},i.destroy=d.toPromise(function(e,t,r){function o(e,t){"function"==typeof u.destroy?u.destroy(e,t):n.nextTick(r)}t=d.clone(t);var s,u=t.db||a;return w.has(u.name)?(s=w.get(u.name),void(s.has(e)?(i.Changes.removeAllListeners(e),s.get(e).close(function(){s["delete"](e),o(e,r)})):o(e,r))):o(e,r)}),i.use_prefix=!1,i.Changes=new d.Changes,t.exports=i}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{},e("buffer").Buffer)},{"../deps/errors":5,"../deps/migrate":"JpIkFB","../merge":8,"../utils":15,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,"level-sublevel":52,leveldown:"A2RG/S",levelup:66,through2:122}],2:[function(e,t){"use strict";function n(e,t){function n(t,n,r){if(e.binary||e.json||!e.processData||"string"==typeof t){if(!e.binary&&e.json&&"string"==typeof t)try{t=JSON.parse(t)}catch(o){return r(o)}}else t=JSON.stringify(t);Array.isArray(t)&&(t=t.map(function(e){var t;return e.ok?e:e.error&&"conflict"===e.error?(t=i.REV_CONFLICT,t.id=e.id,t):e.error&&"forbidden"===e.error?(t=i.FORBIDDEN,t.id=e.id,t.reason=e.reason,t):e.missing?(t=i.MISSING_DOC,t.missing=e.missing,t):e})),r(null,t,n)}function a(e,t){var n,r,o,s;try{n=JSON.parse(e.responseText);for(s in i)if(i.hasOwnProperty(s)&&i[s].name===n.error){o=i[s];break}o||(o=i.UNKNOWN_ERROR,e.status&&(o.status=e.status),e.statusText&&(e.name=e.statusText)),r=i.error(o,n.reason)}catch(a){for(var s in i)if(i.hasOwnProperty(s)&&i[s].status===e.status){o=i[s];break}o||(o=i.UNKNOWN_ERROR,e.status&&(o.status=e.status),e.statusText&&(e.name=e.statusText)),r=i.error(o)}e.withCredentials&&0===e.status&&(r.status=405,r.statusText="Method Not Allowed"),t(r)}var u=!1,c=s.getArguments(function(e){u||(t.apply(this,e),u=!0)});"function"==typeof e&&(c=e,e={}),e=s.clone(e);var l={method:"GET",headers:{},json:!0,processData:!0,timeout:1e4,cache:!1};if(e=s.extend(!0,l,e),"GET"===e.method&&!e.cache){var f=-1!==e.url.indexOf("?");e.url+=(f?"&":"?")+"_nonce="+s.uuid(16)}var d,h;h=e.xhr?new e.xhr:new XMLHttpRequest,h.open(e.method,e.url),h.withCredentials=!0,e.json&&(e.headers.Accept="application/json",e.headers["Content-Type"]=e.headers["Content-Type"]||"application/json",e.body&&e.processData&&"string"!=typeof e.body&&(e.body=JSON.stringify(e.body))),e.binary&&(h.responseType="arraybuffer");var p=function(e,t,n){var r="";if(n){var o=new Date;o.setTime(o.getTime()+24*n*60*60*1e3),r="; expires="+o.toGMTString()}document.cookie=e+"="+t+r+"; path=/"};for(var g in e.headers)if("Cookie"===g){var v=e.headers[g].split("=");p(v[0],v[1],10)}else h.setRequestHeader(g,e.headers[g]);"body"in e||(e.body=null);var b=function(){u||(h.abort(),a(h,c))};if(h.onreadystatechange=function(){if(4===h.readyState&&!u)if(clearTimeout(d),h.status>=200&&h.status<300){var t;t=e.binary?o([h.response||""],{type:h.getResponseHeader("Content-Type")}):h.responseText,n(t,h,c)}else a(h,c)},e.timeout>0&&(d=setTimeout(b,e.timeout),h.onprogress=function(){clearTimeout(d),d=setTimeout(b,e.timeout)},"undefined"==typeof r&&(r=-1!==Object.keys(h).indexOf("upload")),r&&(h.upload.onprogress=h.onprogress)),e.body&&e.body instanceof Blob){var y=new FileReader;y.onloadend=function(){for(var e="",t=new Uint8Array(this.result),n=t.byteLength,r=0;n>r;r++)e+=String.fromCharCode(t[r]);e=s.fixBinary(e),h.send(e)},y.readAsArrayBuffer(e.body)}else h.send(e.body);return{abort:b}}var r,o=e("./blob.js"),i=e("./errors"),s=e("../utils");t.exports=n},{"../utils":15,"./blob.js":3,"./errors":5}],3:[function(e,t){(function(e){"use strict";function n(t,n){t=t||[],n=n||{};try{return new Blob(t,n)}catch(r){if("TypeError"!==r.name)throw r;for(var o=e.BlobBuilder||e.MSBlobBuilder||e.MozBlobBuilder||e.WebKitBlobBuilder,i=new o,s=0;s<t.length;s+=1)i.append(t[s]);return i.getBlob(n.type)}}t.exports=n}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],4:[function(e,t,n){"use strict";function r(){this.store={}}function o(){this.store=new r}n.Map=r,n.Set=o,r.prototype.mangle=function(e){if("string"!=typeof e)throw new TypeError("key must be a string but Got "+e);return"$"+e},r.prototype.unmangle=function(e){return e.substring(1)},r.prototype.get=function(e){var t=this.mangle(e);return t in this.store?this.store[t]:void 0},r.prototype.set=function(e,t){var n=this.mangle(e);return this.store[n]=t,!0},r.prototype.has=function(e){var t=this.mangle(e);return t in this.store},r.prototype["delete"]=function(e){var t=this.mangle(e);return t in this.store?(delete this.store[t],!0):!1},r.prototype.forEach=function(e){var t=this,n=Object.keys(t.store);n.forEach(function(n){var r=t.store[n];n=t.unmangle(n),e(r,n)})},o.prototype.add=function(e){return this.store.set(e,!0)},o.prototype.has=function(e){return this.store.has(e)},o.prototype["delete"]=function(e){return this.store["delete"](e)}},{}],5:[function(e,t,n){"use strict";function r(e){this.status=e.status,this.name=e.error,this.message=e.reason,this.error=!0}r.prototype__proto__=Error.prototype,r.prototype.toString=function(){return JSON.stringify({status:this.status,name:this.name,message:this.message})},n.UNAUTHORIZED=new r({status:401,error:"unauthorized",reason:"Name or password is incorrect."}),n.MISSING_BULK_DOCS=new r({status:400,error:"bad_request",reason:"Missing JSON list of 'docs'"}),n.MISSING_DOC=new r({status:404,error:"not_found",reason:"missing"}),n.REV_CONFLICT=new r({status:409,error:"conflict",reason:"Document update conflict"}),n.INVALID_ID=new r({status:400,error:"invalid_id",reason:"_id field must contain a string"}),n.MISSING_ID=new r({status:412,error:"missing_id",reason:"_id is required for puts"}),n.RESERVED_ID=new r({status:400,error:"bad_request",reason:"Only reserved document ids may start with underscore."}),n.NOT_OPEN=new r({status:412,error:"precondition_failed",reason:"Database not open"}),n.UNKNOWN_ERROR=new r({status:500,error:"unknown_error",reason:"Database encountered an unknown error"}),n.BAD_ARG=new r({status:500,error:"badarg",reason:"Some query argument is invalid"}),n.INVALID_REQUEST=new r({status:400,error:"invalid_request",reason:"Request was invalid"}),n.QUERY_PARSE_ERROR=new r({status:400,error:"query_parse_error",reason:"Some query parameter is invalid"}),n.DOC_VALIDATION=new r({status:500,error:"doc_validation",reason:"Bad special document member"}),n.BAD_REQUEST=new r({status:400,error:"bad_request",reason:"Something wrong with the request"}),n.NOT_AN_OBJECT=new r({status:400,error:"bad_request",reason:"Document must be a JSON object"}),n.DB_MISSING=new r({status:404,error:"not_found",reason:"Database not found"}),n.IDB_ERROR=new r({status:500,error:"indexed_db_went_bad",reason:"unknown"}),n.WSQ_ERROR=new r({status:500,error:"web_sql_went_bad",reason:"unknown"}),n.LDB_ERROR=new r({status:500,error:"levelDB_went_went_bad",reason:"unknown"}),n.FORBIDDEN=new r({status:403,error:"forbidden",reason:"Forbidden by design doc validate_doc_update function"}),n.error=function(e,t,n){function r(){this.message=t,n&&(this.name=n)}return r.prototype=e,new r(t)}},{}],6:[function(e,t){(function(n,r){"use strict";function o(e,t,n){if("function"==typeof e.slice)return e.slice(t,n);t=Math.floor(t||0),n=Math.floor(n||0);var r=e.byteLength;if(t=0>t?Math.max(t+r,0):Math.min(r,t),n=0>n?Math.max(n+r,0):Math.min(r,n),0>=n-t)return new ArrayBuffer(0);var o=new ArrayBuffer(n-t),i=new Uint8Array(o),s=new Uint8Array(e,t,n-t);return i.set(s),o}var i=e("crypto"),s=e("spark-md5"),a=r.setImmediate||r.setTimeout;t.exports=function(e,t){function r(){var n=l*u,i=n+u;n+u>=e.size&&(i=e.size),l++,c>l?(f.append(o(e,n,i)),a(r)):(f.append(o(e,n,i)),t(null,f.end()),f.destroy())}if(!n.browser)return void t(null,i.createHash("md5").update(e).digest("hex"));var u=Math.min(524288,e.length),c=Math.ceil(e.length/u),l=0,f=new s;r()}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,crypto:17,"spark-md5":107}],7:[function(e,t){"use strict";function n(e){return 0|Math.random()*e}function r(e,t){t=t||o.length;var r="",i=-1;if(e){for(;++i<e;)r+=o[n(t)];return r}for(;++i<36;)switch(i){case 8:case 13:case 18:case 23:r+="-";break;case 19:r+=o[3&n(16)|8];break;default:r+=o[n(16)]}return r}var o="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split("");t.exports=r},{}],8:[function(e,t){"use strict";function n(e){for(var t,n=e.shift(),r=[n.id,n.opts,[]],o=r;e.length;)n=e.shift(),t=[n.id,n.opts,[]],o[2].push(t),o=t;return r}function r(e,t){for(var n=[{tree1:e,tree2:t}],r=!1;n.length>0;){var o=n.pop(),i=o.tree1,s=o.tree2;(i[1].status||s[1].status)&&(i[1].status="available"===i[1].status||"available"===s[1].status?"available":"missing");for(var a=0;a<s[2].length;a++)if(i[2][0]){for(var u=!1,c=0;c<i[2].length;c++)i[2][c][0]===s[2][a][0]&&(n.push({tree1:i[2][c],tree2:s[2][a]}),u=!0);u||(r="new_branch",i[2].push(s[2][a]),i[2].sort())}else r="new_leaf",i[2][0]=s[2][a]}return{conflicts:r,tree:e}}function o(e,t,n){var o,i=[],s=!1,a=!1;return e.length?(e.forEach(function(e){if(e.pos===t.pos&&e.ids[0]===t.ids[0])o=r(e.ids,t.ids),i.push({pos:e.pos,ids:o.tree}),s=s||o.conflicts,a=!0;else if(n!==!0){var u=e.pos<t.pos?e:t,c=e.pos<t.pos?t:e,l=c.pos-u.pos,f=[],d=[];for(d.push({ids:u.ids,diff:l,parent:null,parentIdx:null});d.length>0;){var h=d.pop();0!==h.diff?h.ids&&h.ids[2].forEach(function(e,t){d.push({ids:e,diff:h.diff-1,parent:h.ids,parentIdx:t})}):h.ids[0]===c.ids[0]&&f.push(h)}var p=f[0];p?(o=r(p.ids,c.ids),p.parent[2][p.parentIdx]=o.tree,i.push({pos:u.pos,ids:u.ids}),s=s||o.conflicts,a=!0):i.push(e)}else i.push(e)}),a||i.push(t),i.sort(function(e,t){return e.pos-t.pos}),{tree:i,conflicts:s||"internal_node"}):{tree:[t],conflicts:"new_leaf"}}function i(e,t){var r=a.rootToLeaf(e).map(function(e){var r=e.ids.slice(-t);return{pos:e.pos+(e.ids.length-r.length),ids:n(r)}});return r.reduce(function(e,t){return o(e,t,!0).tree},[r.shift()])}var s=e("pouchdb-extend"),a={};a.merge=function(e,t,n){e=s(!0,[],e),t=s(!0,{},t);var r=o(e,t);return{tree:i(r.tree,n),conflicts:r.conflicts}},a.winningRev=function(e){var t=[];return a.traverseRevTree(e.rev_tree,function(e,n,r,o,i){e&&t.push({pos:n,id:r,deleted:!!i.deleted})}),t.sort(function(e,t){return e.deleted!==t.deleted?e.deleted>t.deleted?1:-1:e.pos!==t.pos?t.pos-e.pos:e.id<t.id?1:-1}),t[0].pos+"-"+t[0].id},a.traverseRevTree=function(e,t){for(var n,r=e.slice();n=r.pop();)for(var o=n.pos,i=n.ids,s=i[2],a=t(0===s.length,o,i[0],n.ctx,i[1]),u=0,c=s.length;c>u;u++)r.push({pos:o+1,ids:s[u],ctx:a})},a.collectLeaves=function(e){var t=[];return a.traverseRevTree(e,function(e,n,r,o,i){e&&t.unshift({rev:n+"-"+r,pos:n,opts:i})}),t.sort(function(e,t){return t.pos-e.pos}),t.map(function(e){delete e.pos}),t},a.collectConflicts=function(e){var t=a.winningRev(e),n=a.collectLeaves(e.rev_tree),r=[];return n.forEach(function(e){e.rev===t||e.opts.deleted||r.push(e.rev)}),r},a.rootToLeaf=function(e){var t=[];return a.traverseRevTree(e,function(e,n,r,o,i){if(o=o?o.slice(0):[],o.push({id:r,opts:i}),e){var s=n+1-o.length;t.unshift({pos:s,ids:o})}return o}),t},t.exports=a},{"pouchdb-extend":106}],"adapter-config":[function(e,t){t.exports=e("QLOuoD")},{}],QLOuoD:[function(e,t){"use strict";t.exports={name:"idb-alt",valid:function(){return"idb"in window.PouchDB.adapters&&window.PouchDB.adapters.idb.valid()},use_prefix:!0}},{}],11:[function(e){"use strict";var t=e("adapter-config"),n=t.name,r=e("./levelalt");window.PouchDB.adapter(n,r),window.PouchDB.preferredAdapters.push(n)},{"./levelalt":12,"adapter-config":"QLOuoD"}],12:[function(e,t){"use strict";function n(e,t){var n=s.extend({db:o},e);r.call(this,n,t)}var r=e("../adapters/leveldb"),o=e("leveldown"),i=e("adapter-config"),s=e("../utils");n.valid=function(){return i.valid()},n.use_prefix=i.use_prefix,n.destroy=s.toPromise(function(e,t,n){"function"==typeof t&&(n=t,t={});var i=s.extend({db:o},t);return r.destroy(e,i,n)}),t.exports=n},{"../adapters/leveldb":1,"../utils":15,"adapter-config":"QLOuoD",leveldown:"A2RG/S"}],JpIkFB:[function(e,t,n){(function(e){"use strict";n.toSublevel=function(t,n,r){e.nextTick(function(){r()})},n.localAndMetaStores=function(t,n,r){e.nextTick(function(){r()})}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],"../adapters/../deps/migrate":[function(e,t){t.exports=e("JpIkFB")},{}],15:[function(e,t,n){(function(t,r){function o(e){var t={};return e.forEach(function(e){t[e]=!0}),t}function i(){return"undefined"!=typeof chrome&&"undefined"!=typeof chrome.storage&&"undefined"!=typeof chrome.storage.local}function s(){if(!(this instanceof s))return new s;var e=this;l.call(this),this.isChrome=i(),this.listeners={},this.hasLocal=!1,this.isChrome||(this.hasLocal=n.hasLocalStorage()),this.isChrome?chrome.storage.onChanged.addListener(function(t){null!=t.db_name&&e.emit(t.dbName.newValue)}):this.hasLocal&&(r.addEventListener?r.addEventListener("storage",function(t){e.emit(t.key)}):r.attachEvent("storage",function(t){e.emit(t.key)}))}var a=e("./merge");n.extend=e("pouchdb-extend"),n.ajax=e("./deps/ajax"),n.createBlob=e("./deps/blob"),n.uuid=e("./deps/uuid"),n.getArguments=e("argsarray");var u=e("./deps/buffer"),c=e("./deps/errors"),l=e("events").EventEmitter,f=e("./deps/collections");n.Map=f.Map,n.Set=f.Set,n.Promise="function"==typeof r.Promise?r.Promise:e("bluebird");var d=n.Promise,h=o(["_id","_rev","_attachments","_deleted","_revisions","_revs_info","_conflicts","_deleted_conflicts","_local_seq","_rev_tree","_replication_id","_replication_state","_replication_state_time","_replication_state_reason","_replication_stats"]);n.clone=function(e){return n.extend(!0,{},e)},n.inherits=e("inherits"),n.invalidIdError=function(e){var t;if(e?"string"!=typeof e?(t=new TypeError(c.INVALID_ID.message),t.status=400):/^_/.test(e)&&!/^_(design|local)/.test(e)&&(t=new TypeError(c.RESERVED_ID.message),t.status=400):(t=new TypeError(c.MISSING_ID.message),t.status=412),t)throw t},n.call=n.getArguments(function(e){if(e.length){var t=e.shift();"function"==typeof t&&t.apply(this,e)}}),n.isLocalId=function(e){return/^_local/.test(e)},n.isDeleted=function(e,t){t||(t=a.winningRev(e));var n=t.indexOf("-");-1!==n&&(t=t.substring(n+1));var r=!1;return a.traverseRevTree(e.rev_tree,function(e,n,o,i,s){o===t&&(r=!!s.deleted)}),r},n.filterChange=function(e){return function(t){var n={},r=e.filter&&"function"==typeof e.filter;if(n.query=e.query_params,e.filter&&r&&!e.filter.call(this,t.doc,n))return!1;if(e.doc_ids&&-1===e.doc_ids.indexOf(t.id))return!1;if(e.include_docs)for(var o in t.doc._attachments)t.doc._attachments.hasOwnProperty(o)&&(t.doc._attachments[o].stub=!0);else delete t.doc;return!0}},n.parseDoc=function(e,t){var r,o,i,s,a={status:"available"};if(e._deleted&&(a.deleted=!0),t)if(e._id||(e._id=n.uuid()),o=n.uuid(32,16).toLowerCase(),e._rev){if(i=/^(\d+)-(.+)$/.exec(e._rev),!i){var u=new TypeError("invalid value for property '_rev'");u.status=400}e._rev_tree=[{pos:parseInt(i[1],10),ids:[i[2],{status:"missing"},[[o,a,[]]]]}],r=parseInt(i[1],10)+1}else e._rev_tree=[{pos:1,ids:[o,a,[]]}],r=1;else if(e._revisions&&(e._rev_tree=[{pos:e._revisions.start-e._revisions.ids.length+1,ids:e._revisions.ids.reduce(function(e,t){return null===e?[t,a,[]]:[t,{status:"missing"},[e]]},null)}],r=e._revisions.start,o=e._revisions.ids[0]),!e._rev_tree){if(i=/^(\d+)-(.+)$/.exec(e._rev),!i)throw s=new TypeError(c.BAD_ARG.message),s.status=c.BAD_ARG.status,s;r=parseInt(i[1],10),o=i[2],e._rev_tree=[{pos:parseInt(i[1],10),ids:[i[2],a,[]]}]}n.invalidIdError(e._id),e._id=decodeURIComponent(e._id),e._rev=[r,o].join("-");var l={metadata:{},data:{}};for(var f in e)if(e.hasOwnProperty(f)){var d="_"===f[0];if(d&&!h[f])throw s=new Error(c.DOC_VALIDATION.message+": "+f),s.status=c.DOC_VALIDATION.status,s;d&&"_attachments"!==f?l.metadata[f.slice(1)]=e[f]:l.data[f]=e[f]}return l},n.isCordova=function(){return"undefined"!=typeof cordova||"undefined"!=typeof PhoneGap||"undefined"!=typeof phonegap},n.hasLocalStorage=function(){if(i())return!1;try{return r.localStorage}catch(e){return!1}},n.Changes=s,n.inherits(s,l),s.prototype.addListener=function(e,t,r,o){function i(){r.changes({include_docs:o.include_docs,conflicts:o.conflicts,continuous:!1,descending:!1,filter:o.filter,view:o.view,since:o.since,query_params:o.query_params,onChange:function(e){e.seq>o.since&&!o.cancelled&&(o.since=e.seq,n.call(o.onChange,e))}})}this.listeners[t]||(this.listeners[t]=i,this.on(e,i))},s.prototype.removeListener=function(e,t){t in this.listeners&&l.prototype.removeListener.call(this,e,this.listeners[t])},s.prototype.notifyLocalWindows=function(e){this.isChrome?chrome.storage.local.set({dbName:e}):this.hasLocal&&(localStorage[e]="a"===localStorage[e]?"b":"a")},s.prototype.notify=function(e){this.emit(e),this.notifyLocalWindows(e)},n.atob=t.browser&&"atob"in r?function(e){return atob(e)}:function(e){var t=new u(e,"base64");if(t.toString("base64")!==e)throw"Cannot base64 encode full string";return t.toString("binary")},n.btoa=t.browser&&"btoa"in r?function(e){return btoa(e)}:function(e){return new u(e,"binary").toString("base64")},n.fixBinary=function(e){if(!t.browser)return e;for(var n=e.length,r=new ArrayBuffer(n),o=new Uint8Array(r),i=0;n>i;i++)o[i]=e.charCodeAt(i);return r},n.once=function(e){var t=!1;return n.getArguments(function(n){if(t)throw"function"==typeof console.trace&&console.trace(),new Error("once called more than once");t=!0,e.apply(this,n)})},n.toPromise=function(e){return n.getArguments(function(r){var o,i=this,s="function"==typeof r[r.length-1]?r.pop():!1;s&&(o=function(e,n){t.nextTick(function(){s(e,n)})});var a=new d(function(t,o){var s;try{var a=n.once(function(e,n){e?o(e):t(n)});r.push(a),s=e.apply(i,r),s&&"function"==typeof s.then&&t(s)}catch(u){o(u)}});return o&&a.then(function(e){o(null,e)},o),a.cancel=function(){return this},a})},n.adapterFun=function(e,t){return n.toPromise(n.getArguments(function(r){if(this._closed)return d.reject(new Error("database is closed"));var o=this;return this.taskqueue.isReady?t.apply(this,r):new n.Promise(function(t,n){o.taskqueue.addTask(function(i){i?n(i):t(o[e].apply(o,r))})})}))},n.arrayBufferToBinaryString=function(e){for(var t="",n=new Uint8Array(e),r=n.byteLength,o=0;r>o;o++)t+=String.fromCharCode(n[o]);return t},n.cancellableFun=function(e,t,r){r=r?n.clone(!0,{},r):{};var o=new l,i=r.complete||function(){},s=r.complete=n.once(function(e,t){e?i(e):(o.emit("end",t),i(null,t)),o.removeAllListeners()}),a=r.onChange||function(){},u=0;t.on("destroyed",function(){o.removeAllListeners()}),r.onChange=function(e){a(e),e.seq<=u||(u=e.seq,o.emit("change",e),e.deleted?o.emit("delete",e):1===e.changes.length&&"1-"===e.changes[0].rev.slice(0,1)?o.emit("create",e):o.emit("update",e))};var c=new d(function(e,t){r.complete=function(n,r){n?t(n):e(r)}});return c.then(function(e){s(null,e)},s),c.cancel=function(){c.isCancelled=!0,t.taskqueue.isReady&&r.complete(null,{status:"cancelled"})},t.taskqueue.isReady?e(t,r,c):t.taskqueue.addTask(function(){c.isCancelled?r.complete(null,{status:"cancelled"}):e(t,r,c)}),c.on=o.on.bind(o),c.once=o.once.bind(o),c.addListener=o.addListener.bind(o),c.removeListener=o.removeListener.bind(o),c.removeAllListeners=o.removeAllListeners.bind(o),c.setMaxListeners=o.setMaxListeners.bind(o),c.listeners=o.listeners.bind(o),c.emit=o.emit.bind(o),c},n.MD5=n.toPromise(e("./deps/md5"))}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./deps/ajax":2,"./deps/blob":3,"./deps/buffer":17,"./deps/collections":4,"./deps/errors":5,"./deps/md5":6,"./deps/uuid":7,"./merge":8,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,argsarray:16,bluebird:92,events:18,inherits:33,"pouchdb-extend":106}],16:[function(e,t){"use strict";
+function n(e){return function(){var t=arguments.length;if(t){for(var n=[],r=-1;++r<t;)n[r]=arguments[r];return e.call(this,n)}return e.call(this,[])}}t.exports=n},{}],17:[function(){},{}],18:[function(e,t){function n(){this._events=this._events||{},this._maxListeners=this._maxListeners||void 0}function r(e){return"function"==typeof e}function o(e){return"number"==typeof e}function i(e){return"object"==typeof e&&null!==e}function s(e){return void 0===e}t.exports=n,n.EventEmitter=n,n.prototype._events=void 0,n.prototype._maxListeners=void 0,n.defaultMaxListeners=10,n.prototype.setMaxListeners=function(e){if(!o(e)||0>e||isNaN(e))throw TypeError("n must be a positive number");return this._maxListeners=e,this},n.prototype.emit=function(e){var t,n,o,a,u,c;if(this._events||(this._events={}),"error"===e&&(!this._events.error||i(this._events.error)&&!this._events.error.length))throw t=arguments[1],t instanceof Error?t:TypeError('Uncaught, unspecified "error" event.');if(n=this._events[e],s(n))return!1;if(r(n))switch(arguments.length){case 1:n.call(this);break;case 2:n.call(this,arguments[1]);break;case 3:n.call(this,arguments[1],arguments[2]);break;default:for(o=arguments.length,a=new Array(o-1),u=1;o>u;u++)a[u-1]=arguments[u];n.apply(this,a)}else if(i(n)){for(o=arguments.length,a=new Array(o-1),u=1;o>u;u++)a[u-1]=arguments[u];for(c=n.slice(),o=c.length,u=0;o>u;u++)c[u].apply(this,a)}return!0},n.prototype.addListener=function(e,t){var o;if(!r(t))throw TypeError("listener must be a function");if(this._events||(this._events={}),this._events.newListener&&this.emit("newListener",e,r(t.listener)?t.listener:t),this._events[e]?i(this._events[e])?this._events[e].push(t):this._events[e]=[this._events[e],t]:this._events[e]=t,i(this._events[e])&&!this._events[e].warned){var o;o=s(this._maxListeners)?n.defaultMaxListeners:this._maxListeners,o&&o>0&&this._events[e].length>o&&(this._events[e].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[e].length),"function"==typeof console.trace&&console.trace())}return this},n.prototype.on=n.prototype.addListener,n.prototype.once=function(e,t){function n(){this.removeListener(e,n),o||(o=!0,t.apply(this,arguments))}if(!r(t))throw TypeError("listener must be a function");var o=!1;return n.listener=t,this.on(e,n),this},n.prototype.removeListener=function(e,t){var n,o,s,a;if(!r(t))throw TypeError("listener must be a function");if(!this._events||!this._events[e])return this;if(n=this._events[e],s=n.length,o=-1,n===t||r(n.listener)&&n.listener===t)delete this._events[e],this._events.removeListener&&this.emit("removeListener",e,t);else if(i(n)){for(a=s;a-->0;)if(n[a]===t||n[a].listener&&n[a].listener===t){o=a;break}if(0>o)return this;1===n.length?(n.length=0,delete this._events[e]):n.splice(o,1),this._events.removeListener&&this.emit("removeListener",e,t)}return this},n.prototype.removeAllListeners=function(e){var t,n;if(!this._events)return this;if(!this._events.removeListener)return 0===arguments.length?this._events={}:this._events[e]&&delete this._events[e],this;if(0===arguments.length){for(t in this._events)"removeListener"!==t&&this.removeAllListeners(t);return this.removeAllListeners("removeListener"),this._events={},this}if(n=this._events[e],r(n))this.removeListener(e,n);else for(;n.length;)this.removeListener(e,n[n.length-1]);return delete this._events[e],this},n.prototype.listeners=function(e){var t;return t=this._events&&this._events[e]?r(this._events[e])?[this._events[e]]:this._events[e].slice():[]},n.listenerCount=function(e,t){var n;return n=e._events&&e._events[t]?r(e._events[t])?1:e._events[t].length:0}},{}],19:[function(e,t){var n=t.exports={};n.nextTick=function(){var e="undefined"!=typeof window&&window.setImmediate,t="undefined"!=typeof window&&window.postMessage&&window.addEventListener;if(e)return function(e){return window.setImmediate(e)};if(t){var n=[];return window.addEventListener("message",function(e){var t=e.source;if((t===window||null===t)&&"process-tick"===e.data&&(e.stopPropagation(),n.length>0)){var r=n.shift();r()}},!0),function(e){n.push(e),window.postMessage("process-tick","*")}}return function(e){setTimeout(e,0)}}(),n.title="browser",n.browser=!0,n.env={},n.argv=[],n.binding=function(){throw new Error("process.binding is not supported")},n.cwd=function(){return"/"},n.chdir=function(){throw new Error("process.chdir is not supported")}},{}],20:[function(e,t,n){function r(e,t,n){if(!(this instanceof r))return new r(e,t,n);var o=typeof e;if("base64"===t&&"string"===o)for(e=j(e);e.length%4!==0;)e+="=";var i;if("number"===o)i=I(e);else if("string"===o)i=r.byteLength(e,t);else{if("object"!==o)throw new Error("First argument needs to be a number, array or string.");i=I(e.length)}var s;r._useTypedArrays?s=O(new Uint8Array(i)):(s=this,s.length=i,s._isBuffer=!0);var a;if(r._useTypedArrays&&"function"==typeof Uint8Array&&e instanceof Uint8Array)s._set(e);else if(R(e))for(a=0;i>a;a++)s[a]=r.isBuffer(e)?e.readUInt8(a):e[a];else if("string"===o)s.write(e,0,t);else if("number"===o&&!r._useTypedArrays&&!n)for(a=0;i>a;a++)s[a]=0;return s}function o(e,t,n,o){n=Number(n)||0;var i=e.length-n;o?(o=Number(o),o>i&&(o=i)):o=i;var s=t.length;q(s%2===0,"Invalid hex string"),o>s/2&&(o=s/2);for(var a=0;o>a;a++){var u=parseInt(t.substr(2*a,2),16);q(!isNaN(u),"Invalid hex string"),e[n+a]=u}return r._charsWritten=2*a,a}function i(e,t,n,o){var i=r._charsWritten=D(B(t),e,n,o);return i}function s(e,t,n,o){var i=r._charsWritten=D(C(t),e,n,o);return i}function a(e,t,n,r){return s(e,t,n,r)}function u(e,t,n,o){var i=r._charsWritten=D(T(t),e,n,o);return i}function c(e,t,n){return W.fromByteArray(0===t&&n===e.length?e:e.slice(t,n))}function l(e,t,n){var r="",o="";n=Math.min(e.length,n);for(var i=t;n>i;i++)e[i]<=127?(r+=M(o)+String.fromCharCode(e[i]),o=""):o+="%"+e[i].toString(16);return r+M(o)}function f(e,t,n){var r="";n=Math.min(e.length,n);for(var o=t;n>o;o++)r+=String.fromCharCode(e[o]);return r}function d(e,t,n){return f(e,t,n)}function h(e,t,n){var r=e.length;(!t||0>t)&&(t=0),(!n||0>n||n>r)&&(n=r);for(var o="",i=t;n>i;i++)o+=L(e[i]);return o}function p(e,t,n,r){r||(q("boolean"==typeof n,"missing or invalid endian"),q(void 0!==t&&null!==t,"missing offset"),q(t+1<e.length,"Trying to read beyond buffer length"));var o=e.length;if(!(t>=o)){var i;return n?(i=e[t],o>t+1&&(i|=e[t+1]<<8)):(i=e[t]<<8,o>t+1&&(i|=e[t+1])),i}}function g(e,t,n,r){r||(q("boolean"==typeof n,"missing or invalid endian"),q(void 0!==t&&null!==t,"missing offset"),q(t+3<e.length,"Trying to read beyond buffer length"));var o=e.length;if(!(t>=o)){var i;return n?(o>t+2&&(i=e[t+2]<<16),o>t+1&&(i|=e[t+1]<<8),i|=e[t],o>t+3&&(i+=e[t+3]<<24>>>0)):(o>t+1&&(i=e[t+1]<<16),o>t+2&&(i|=e[t+2]<<8),o>t+3&&(i|=e[t+3]),i+=e[t]<<24>>>0),i}}function v(e,t,n,r){r||(q("boolean"==typeof n,"missing or invalid endian"),q(void 0!==t&&null!==t,"missing offset"),q(t+1<e.length,"Trying to read beyond buffer length"));var o=e.length;if(!(t>=o)){var i=p(e,t,n,!0),s=32768&i;return s?-1*(65535-i+1):i}}function b(e,t,n,r){r||(q("boolean"==typeof n,"missing or invalid endian"),q(void 0!==t&&null!==t,"missing offset"),q(t+3<e.length,"Trying to read beyond buffer length"));var o=e.length;if(!(t>=o)){var i=g(e,t,n,!0),s=2147483648&i;return s?-1*(4294967295-i+1):i}}function y(e,t,n,r){return r||(q("boolean"==typeof n,"missing or invalid endian"),q(t+3<e.length,"Trying to read beyond buffer length")),V.read(e,t,n,23,4)}function m(e,t,n,r){return r||(q("boolean"==typeof n,"missing or invalid endian"),q(t+7<e.length,"Trying to read beyond buffer length")),V.read(e,t,n,52,8)}function _(e,t,n,r,o){o||(q(void 0!==t&&null!==t,"missing value"),q("boolean"==typeof r,"missing or invalid endian"),q(void 0!==n&&null!==n,"missing offset"),q(n+1<e.length,"trying to write beyond buffer length"),U(t,65535));var i=e.length;if(!(n>=i))for(var s=0,a=Math.min(i-n,2);a>s;s++)e[n+s]=(t&255<<8*(r?s:1-s))>>>8*(r?s:1-s)}function w(e,t,n,r,o){o||(q(void 0!==t&&null!==t,"missing value"),q("boolean"==typeof r,"missing or invalid endian"),q(void 0!==n&&null!==n,"missing offset"),q(n+3<e.length,"trying to write beyond buffer length"),U(t,4294967295));var i=e.length;if(!(n>=i))for(var s=0,a=Math.min(i-n,4);a>s;s++)e[n+s]=t>>>8*(r?s:3-s)&255}function E(e,t,n,r,o){o||(q(void 0!==t&&null!==t,"missing value"),q("boolean"==typeof r,"missing or invalid endian"),q(void 0!==n&&null!==n,"missing offset"),q(n+1<e.length,"Trying to write beyond buffer length"),P(t,32767,-32768));var i=e.length;n>=i||(t>=0?_(e,t,n,r,o):_(e,65535+t+1,n,r,o))}function k(e,t,n,r,o){o||(q(void 0!==t&&null!==t,"missing value"),q("boolean"==typeof r,"missing or invalid endian"),q(void 0!==n&&null!==n,"missing offset"),q(n+3<e.length,"Trying to write beyond buffer length"),P(t,2147483647,-2147483648));var i=e.length;n>=i||(t>=0?w(e,t,n,r,o):w(e,4294967295+t+1,n,r,o))}function S(e,t,n,r,o){o||(q(void 0!==t&&null!==t,"missing value"),q("boolean"==typeof r,"missing or invalid endian"),q(void 0!==n&&null!==n,"missing offset"),q(n+3<e.length,"Trying to write beyond buffer length"),F(t,3.4028234663852886e38,-3.4028234663852886e38));var i=e.length;n>=i||V.write(e,t,n,r,23,4)}function x(e,t,n,r,o){o||(q(void 0!==t&&null!==t,"missing value"),q("boolean"==typeof r,"missing or invalid endian"),q(void 0!==n&&null!==n,"missing offset"),q(n+7<e.length,"Trying to write beyond buffer length"),F(t,1.7976931348623157e308,-1.7976931348623157e308));var i=e.length;n>=i||V.write(e,t,n,r,52,8)}function j(e){return e.trim?e.trim():e.replace(/^\s+|\s+$/g,"")}function O(e){return e._isBuffer=!0,e._get=e.get,e._set=e.set,e.get=z.get,e.set=z.set,e.write=z.write,e.toString=z.toString,e.toLocaleString=z.toString,e.toJSON=z.toJSON,e.copy=z.copy,e.slice=z.slice,e.readUInt8=z.readUInt8,e.readUInt16LE=z.readUInt16LE,e.readUInt16BE=z.readUInt16BE,e.readUInt32LE=z.readUInt32LE,e.readUInt32BE=z.readUInt32BE,e.readInt8=z.readInt8,e.readInt16LE=z.readInt16LE,e.readInt16BE=z.readInt16BE,e.readInt32LE=z.readInt32LE,e.readInt32BE=z.readInt32BE,e.readFloatLE=z.readFloatLE,e.readFloatBE=z.readFloatBE,e.readDoubleLE=z.readDoubleLE,e.readDoubleBE=z.readDoubleBE,e.writeUInt8=z.writeUInt8,e.writeUInt16LE=z.writeUInt16LE,e.writeUInt16BE=z.writeUInt16BE,e.writeUInt32LE=z.writeUInt32LE,e.writeUInt32BE=z.writeUInt32BE,e.writeInt8=z.writeInt8,e.writeInt16LE=z.writeInt16LE,e.writeInt16BE=z.writeInt16BE,e.writeInt32LE=z.writeInt32LE,e.writeInt32BE=z.writeInt32BE,e.writeFloatLE=z.writeFloatLE,e.writeFloatBE=z.writeFloatBE,e.writeDoubleLE=z.writeDoubleLE,e.writeDoubleBE=z.writeDoubleBE,e.fill=z.fill,e.inspect=z.inspect,e.toArrayBuffer=z.toArrayBuffer,e}function A(e,t,n){return"number"!=typeof e?n:(e=~~e,e>=t?t:e>=0?e:(e+=t,e>=0?e:0))}function I(e){return e=~~Math.ceil(+e),0>e?0:e}function N(e){return(Array.isArray||function(e){return"[object Array]"===Object.prototype.toString.call(e)})(e)}function R(e){return N(e)||r.isBuffer(e)||e&&"object"==typeof e&&"number"==typeof e.length}function L(e){return 16>e?"0"+e.toString(16):e.toString(16)}function B(e){for(var t=[],n=0;n<e.length;n++){var r=e.charCodeAt(n);if(127>=r)t.push(e.charCodeAt(n));else{var o=n;r>=55296&&57343>=r&&n++;for(var i=encodeURIComponent(e.slice(o,n+1)).substr(1).split("%"),s=0;s<i.length;s++)t.push(parseInt(i[s],16))}}return t}function C(e){for(var t=[],n=0;n<e.length;n++)t.push(255&e.charCodeAt(n));return t}function T(e){return W.toByteArray(e)}function D(e,t,n,r){for(var o=0;r>o&&!(o+n>=t.length||o>=e.length);o++)t[o+n]=e[o];return o}function M(e){try{return decodeURIComponent(e)}catch(t){return String.fromCharCode(65533)}}function U(e,t){q("number"==typeof e,"cannot write a non-number as a number"),q(e>=0,"specified a negative value for writing an unsigned value"),q(t>=e,"value is larger than maximum value for type"),q(Math.floor(e)===e,"value has a fractional component")}function P(e,t,n){q("number"==typeof e,"cannot write a non-number as a number"),q(t>=e,"value larger than maximum allowed value"),q(e>=n,"value smaller than minimum allowed value"),q(Math.floor(e)===e,"value has a fractional component")}function F(e,t,n){q("number"==typeof e,"cannot write a non-number as a number"),q(t>=e,"value larger than maximum allowed value"),q(e>=n,"value smaller than minimum allowed value")}function q(e,t){if(!e)throw new Error(t||"Failed assertion")}var W=e("base64-js"),V=e("ieee754");n.Buffer=r,n.SlowBuffer=r,n.INSPECT_MAX_BYTES=50,r.poolSize=8192,r._useTypedArrays=function(){if("undefined"==typeof Uint8Array||"undefined"==typeof ArrayBuffer)return!1;try{var e=new Uint8Array(0);return e.foo=function(){return 42},42===e.foo()&&"function"==typeof e.subarray}catch(t){return!1}}(),r.isEncoding=function(e){switch(String(e).toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"raw":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return!0;default:return!1}},r.isBuffer=function(e){return!(null===e||void 0===e||!e._isBuffer)},r.byteLength=function(e,t){var n;switch(e+="",t||"utf8"){case"hex":n=e.length/2;break;case"utf8":case"utf-8":n=B(e).length;break;case"ascii":case"binary":case"raw":n=e.length;break;case"base64":n=T(e).length;break;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":n=2*e.length;break;default:throw new Error("Unknown encoding")}return n},r.concat=function(e,t){if(q(N(e),"Usage: Buffer.concat(list, [totalLength])\nlist should be an Array."),0===e.length)return new r(0);if(1===e.length)return e[0];var n;if("number"!=typeof t)for(t=0,n=0;n<e.length;n++)t+=e[n].length;var o=new r(t),i=0;for(n=0;n<e.length;n++){var s=e[n];s.copy(o,i),i+=s.length}return o},r.prototype.write=function(e,t,n,r){if(isFinite(t))isFinite(n)||(r=n,n=void 0);else{var c=r;r=t,t=n,n=c}t=Number(t)||0;var l=this.length-t;switch(n?(n=Number(n),n>l&&(n=l)):n=l,r=String(r||"utf8").toLowerCase()){case"hex":return o(this,e,t,n);case"utf8":case"utf-8":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return i(this,e,t,n);case"ascii":return s(this,e,t,n);case"binary":return a(this,e,t,n);case"base64":return u(this,e,t,n);default:throw new Error("Unknown encoding")}},r.prototype.toString=function(e,t,n){var r=this;if(e=String(e||"utf8").toLowerCase(),t=Number(t)||0,n=void 0!==n?Number(n):n=r.length,n===t)return"";switch(e){case"hex":return h(r,t,n);case"utf8":case"utf-8":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return l(r,t,n);case"ascii":return f(r,t,n);case"binary":return d(r,t,n);case"base64":return c(r,t,n);default:throw new Error("Unknown encoding")}},r.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}},r.prototype.copy=function(e,t,n,r){var o=this;if(n||(n=0),r||0===r||(r=this.length),t||(t=0),r!==n&&0!==e.length&&0!==o.length){q(r>=n,"sourceEnd < sourceStart"),q(t>=0&&t<e.length,"targetStart out of bounds"),q(n>=0&&n<o.length,"sourceStart out of bounds"),q(r>=0&&r<=o.length,"sourceEnd out of bounds"),r>this.length&&(r=this.length),e.length-t<r-n&&(r=e.length-t+n);for(var i=0;r-n>i;i++)e[i+t]=this[i+n]}},r.prototype.slice=function(e,t){var n=this.length;if(e=A(e,n,0),t=A(t,n,n),r._useTypedArrays)return O(this.subarray(e,t));for(var o=t-e,i=new r(o,void 0,!0),s=0;o>s;s++)i[s]=this[s+e];return i},r.prototype.get=function(e){return console.log(".get() is deprecated. Access using array indexes instead."),this.readUInt8(e)},r.prototype.set=function(e,t){return console.log(".set() is deprecated. Access using array indexes instead."),this.writeUInt8(e,t)},r.prototype.readUInt8=function(e,t){return t||(q(void 0!==e&&null!==e,"missing offset"),q(e<this.length,"Trying to read beyond buffer length")),e>=this.length?void 0:this[e]},r.prototype.readUInt16LE=function(e,t){return p(this,e,!0,t)},r.prototype.readUInt16BE=function(e,t){return p(this,e,!1,t)},r.prototype.readUInt32LE=function(e,t){return g(this,e,!0,t)},r.prototype.readUInt32BE=function(e,t){return g(this,e,!1,t)},r.prototype.readInt8=function(e,t){if(t||(q(void 0!==e&&null!==e,"missing offset"),q(e<this.length,"Trying to read beyond buffer length")),!(e>=this.length)){var n=128&this[e];return n?-1*(255-this[e]+1):this[e]}},r.prototype.readInt16LE=function(e,t){return v(this,e,!0,t)},r.prototype.readInt16BE=function(e,t){return v(this,e,!1,t)},r.prototype.readInt32LE=function(e,t){return b(this,e,!0,t)},r.prototype.readInt32BE=function(e,t){return b(this,e,!1,t)},r.prototype.readFloatLE=function(e,t){return y(this,e,!0,t)},r.prototype.readFloatBE=function(e,t){return y(this,e,!1,t)},r.prototype.readDoubleLE=function(e,t){return m(this,e,!0,t)},r.prototype.readDoubleBE=function(e,t){return m(this,e,!1,t)},r.prototype.writeUInt8=function(e,t,n){n||(q(void 0!==e&&null!==e,"missing value"),q(void 0!==t&&null!==t,"missing offset"),q(t<this.length,"trying to write beyond buffer length"),U(e,255)),t>=this.length||(this[t]=e)},r.prototype.writeUInt16LE=function(e,t,n){_(this,e,t,!0,n)},r.prototype.writeUInt16BE=function(e,t,n){_(this,e,t,!1,n)},r.prototype.writeUInt32LE=function(e,t,n){w(this,e,t,!0,n)},r.prototype.writeUInt32BE=function(e,t,n){w(this,e,t,!1,n)},r.prototype.writeInt8=function(e,t,n){n||(q(void 0!==e&&null!==e,"missing value"),q(void 0!==t&&null!==t,"missing offset"),q(t<this.length,"Trying to write beyond buffer length"),P(e,127,-128)),t>=this.length||(e>=0?this.writeUInt8(e,t,n):this.writeUInt8(255+e+1,t,n))},r.prototype.writeInt16LE=function(e,t,n){E(this,e,t,!0,n)},r.prototype.writeInt16BE=function(e,t,n){E(this,e,t,!1,n)},r.prototype.writeInt32LE=function(e,t,n){k(this,e,t,!0,n)},r.prototype.writeInt32BE=function(e,t,n){k(this,e,t,!1,n)},r.prototype.writeFloatLE=function(e,t,n){S(this,e,t,!0,n)},r.prototype.writeFloatBE=function(e,t,n){S(this,e,t,!1,n)},r.prototype.writeDoubleLE=function(e,t,n){x(this,e,t,!0,n)},r.prototype.writeDoubleBE=function(e,t,n){x(this,e,t,!1,n)},r.prototype.fill=function(e,t,n){if(e||(e=0),t||(t=0),n||(n=this.length),"string"==typeof e&&(e=e.charCodeAt(0)),q("number"==typeof e&&!isNaN(e),"value is not a number"),q(n>=t,"end < start"),n!==t&&0!==this.length){q(t>=0&&t<this.length,"start out of bounds"),q(n>=0&&n<=this.length,"end out of bounds");for(var r=t;n>r;r++)this[r]=e}},r.prototype.inspect=function(){for(var e=[],t=this.length,r=0;t>r;r++)if(e[r]=L(this[r]),r===n.INSPECT_MAX_BYTES){e[r+1]="...";break}return"<Buffer "+e.join(" ")+">"},r.prototype.toArrayBuffer=function(){if("function"==typeof Uint8Array){if(r._useTypedArrays)return new r(this).buffer;for(var e=new Uint8Array(this.length),t=0,n=e.length;n>t;t+=1)e[t]=this[t];return e.buffer}throw new Error("Buffer.toArrayBuffer not supported in this browser")};var z=r.prototype},{"base64-js":21,ieee754:22}],21:[function(e,t,n){var r="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";!function(e){"use strict";function t(e){var t=e.charCodeAt(0);return t===s?62:t===a?63:u>t?-1:u+10>t?t-u+26+26:l+26>t?t-l:c+26>t?t-c+26:void 0}function n(e){function n(e){c[f++]=e}var r,o,s,a,u,c;if(e.length%4>0)throw new Error("Invalid string. Length must be a multiple of 4");var l=e.length;u="="===e.charAt(l-2)?2:"="===e.charAt(l-1)?1:0,c=new i(3*e.length/4-u),s=u>0?e.length-4:e.length;var f=0;for(r=0,o=0;s>r;r+=4,o+=3)a=t(e.charAt(r))<<18|t(e.charAt(r+1))<<12|t(e.charAt(r+2))<<6|t(e.charAt(r+3)),n((16711680&a)>>16),n((65280&a)>>8),n(255&a);return 2===u?(a=t(e.charAt(r))<<2|t(e.charAt(r+1))>>4,n(255&a)):1===u&&(a=t(e.charAt(r))<<10|t(e.charAt(r+1))<<4|t(e.charAt(r+2))>>2,n(a>>8&255),n(255&a)),c}function o(e){function t(e){return r.charAt(e)}function n(e){return t(e>>18&63)+t(e>>12&63)+t(e>>6&63)+t(63&e)}var o,i,s,a=e.length%3,u="";for(o=0,s=e.length-a;s>o;o+=3)i=(e[o]<<16)+(e[o+1]<<8)+e[o+2],u+=n(i);switch(a){case 1:i=e[e.length-1],u+=t(i>>2),u+=t(i<<4&63),u+="==";break;case 2:i=(e[e.length-2]<<8)+e[e.length-1],u+=t(i>>10),u+=t(i>>4&63),u+=t(i<<2&63),u+="="}return u}var i="undefined"!=typeof Uint8Array?Uint8Array:Array,s="+".charCodeAt(0),a="/".charCodeAt(0),u="0".charCodeAt(0),c="a".charCodeAt(0),l="A".charCodeAt(0);e.toByteArray=n,e.fromByteArray=o}("undefined"==typeof n?this.base64js={}:n)},{}],22:[function(e,t,n){n.read=function(e,t,n,r,o){var i,s,a=8*o-r-1,u=(1<<a)-1,c=u>>1,l=-7,f=n?o-1:0,d=n?-1:1,h=e[t+f];for(f+=d,i=h&(1<<-l)-1,h>>=-l,l+=a;l>0;i=256*i+e[t+f],f+=d,l-=8);for(s=i&(1<<-l)-1,i>>=-l,l+=r;l>0;s=256*s+e[t+f],f+=d,l-=8);if(0===i)i=1-c;else{if(i===u)return s?0/0:1/0*(h?-1:1);s+=Math.pow(2,r),i-=c}return(h?-1:1)*s*Math.pow(2,i-r)},n.write=function(e,t,n,r,o,i){var s,a,u,c=8*i-o-1,l=(1<<c)-1,f=l>>1,d=23===o?Math.pow(2,-24)-Math.pow(2,-77):0,h=r?0:i-1,p=r?1:-1,g=0>t||0===t&&0>1/t?1:0;for(t=Math.abs(t),isNaN(t)||1/0===t?(a=isNaN(t)?1:0,s=l):(s=Math.floor(Math.log(t)/Math.LN2),t*(u=Math.pow(2,-s))<1&&(s--,u*=2),t+=s+f>=1?d/u:d*Math.pow(2,1-f),t*u>=2&&(s++,u/=2),s+f>=l?(a=0,s=l):s+f>=1?(a=(t*u-1)*Math.pow(2,o),s+=f):(a=t*Math.pow(2,f-1)*Math.pow(2,o),s=0));o>=8;e[n+h]=255&a,h+=p,a/=256,o-=8);for(s=s<<o|a,c+=o;c>0;e[n+h]=255&s,h+=p,s/=256,c-=8);e[n+h-p]|=128*g}},{}],23:[function(e,t){function n(e){return this instanceof n?(s.call(this,e),a.call(this,e),e&&e.readable===!1&&(this.readable=!1),e&&e.writable===!1&&(this.writable=!1),this.allowHalfOpen=!0,e&&e.allowHalfOpen===!1&&(this.allowHalfOpen=!1),void this.once("end",r)):new n(e)}function r(){if(!this.allowHalfOpen&&!this._writableState.ended){var e=this;i(function(){e.end()})}}t.exports=n;var o=e("inherits"),i=e("process/browser.js").nextTick,s=e("./readable.js"),a=e("./writable.js");o(n,s),n.prototype.write=a.prototype.write,n.prototype.end=a.prototype.end,n.prototype._write=a.prototype._write},{"./readable.js":27,"./writable.js":29,inherits:33,"process/browser.js":25}],24:[function(e,t){function n(){r.call(this)}t.exports=n;var r=e("events").EventEmitter,o=e("inherits");o(n,r),n.Readable=e("./readable.js"),n.Writable=e("./writable.js"),n.Duplex=e("./duplex.js"),n.Transform=e("./transform.js"),n.PassThrough=e("./passthrough.js"),n.Stream=n,n.prototype.pipe=function(e,t){function n(t){e.writable&&!1===e.write(t)&&c.pause&&c.pause()}function o(){c.readable&&c.resume&&c.resume()}function i(){l||(l=!0,e.end())}function s(){l||(l=!0,"function"==typeof e.destroy&&e.destroy())}function a(e){if(u(),0===r.listenerCount(this,"error"))throw e}function u(){c.removeListener("data",n),e.removeListener("drain",o),c.removeListener("end",i),c.removeListener("close",s),c.removeListener("error",a),e.removeListener("error",a),c.removeListener("end",u),c.removeListener("close",u),e.removeListener("close",u)}var c=this;c.on("data",n),e.on("drain",o),e._isStdio||t&&t.end===!1||(c.on("end",i),c.on("close",s));var l=!1;return c.on("error",a),e.on("error",a),c.on("end",u),c.on("close",u),e.on("close",u),e.emit("pipe",c),e}},{"./duplex.js":23,"./passthrough.js":26,"./readable.js":27,"./transform.js":28,"./writable.js":29,events:18,inherits:33}],25:[function(e,t){t.exports=e(19)},{}],26:[function(e,t){function n(e){return this instanceof n?void r.call(this,e):new n(e)}t.exports=n;var r=e("./transform.js"),o=e("inherits");o(n,r),n.prototype._transform=function(e,t,n){n(null,e)}},{"./transform.js":28,inherits:33}],27:[function(e,t){(function(n){function r(t){t=t||{};var n=t.highWaterMark;this.highWaterMark=n||0===n?n:16384,this.highWaterMark=~~this.highWaterMark,this.buffer=[],this.length=0,this.pipes=null,this.pipesCount=0,this.flowing=!1,this.ended=!1,this.endEmitted=!1,this.reading=!1,this.calledRead=!1,this.sync=!0,this.needReadable=!1,this.emittedReadable=!1,this.readableListening=!1,this.objectMode=!!t.objectMode,this.defaultEncoding=t.defaultEncoding||"utf8",this.ranOut=!1,this.awaitDrain=0,this.readingMore=!1,this.decoder=null,this.encoding=null,t.encoding&&(k||(k=e("string_decoder").StringDecoder),this.decoder=new k(t.encoding),this.encoding=t.encoding)}function o(e){return this instanceof o?(this._readableState=new r(e,this),this.readable=!0,void x.call(this)):new o(e)}function i(e,t,n,r,o){var i=c(t,n);if(i)e.emit("error",i);else if(null===n||void 0===n)t.reading=!1,t.ended||l(e,t);else if(t.objectMode||n&&n.length>0)if(t.ended&&!o){var a=new Error("stream.push() after EOF");e.emit("error",a)}else if(t.endEmitted&&o){var a=new Error("stream.unshift() after end event");e.emit("error",a)}else!t.decoder||o||r||(n=t.decoder.write(n)),t.length+=t.objectMode?1:n.length,o?t.buffer.unshift(n):(t.reading=!1,t.buffer.push(n)),t.needReadable&&f(e),h(e,t);else o||(t.reading=!1);return s(t)}function s(e){return!e.ended&&(e.needReadable||e.length<e.highWaterMark||0===e.length)}function a(e){if(e>=I)e=I;else{e--;for(var t=1;32>t;t<<=1)e|=e>>t;e++}return e}function u(e,t){return 0===t.length&&t.ended?0:t.objectMode?0===e?0:1:isNaN(e)||null===e?t.flowing&&t.buffer.length?t.buffer[0].length:t.length:0>=e?0:(e>t.highWaterMark&&(t.highWaterMark=a(e)),e>t.length?t.ended?t.length:(t.needReadable=!0,0):e)}function c(e,t){var n=null;return j.isBuffer(t)||"string"==typeof t||null===t||void 0===t||e.objectMode||n||(n=new TypeError("Invalid non-string/buffer chunk")),n}function l(e,t){if(t.decoder&&!t.ended){var n=t.decoder.end();n&&n.length&&(t.buffer.push(n),t.length+=t.objectMode?1:n.length)}t.ended=!0,t.length>0?f(e):_(e)}function f(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(t.emittedReadable=!0,t.sync?O(function(){d(e)}):d(e))}function d(e){e.emit("readable")}function h(e,t){t.readingMore||(t.readingMore=!0,O(function(){p(e,t)}))}function p(e,t){for(var n=t.length;!t.reading&&!t.flowing&&!t.ended&&t.length<t.highWaterMark&&(e.read(0),n!==t.length);)n=t.length;t.readingMore=!1}function g(e){return function(){var t=e._readableState;t.awaitDrain--,0===t.awaitDrain&&v(e)}}function v(e){function t(e){var t=e.write(n);!1===t&&r.awaitDrain++}var n,r=e._readableState;for(r.awaitDrain=0;r.pipesCount&&null!==(n=e.read());)if(1===r.pipesCount?t(r.pipes,0,null):w(r.pipes,t),e.emit("data",n),r.awaitDrain>0)return;return 0===r.pipesCount?(r.flowing=!1,void(S.listenerCount(e,"data")>0&&y(e))):void(r.ranOut=!0)}function b(){this._readableState.ranOut&&(this._readableState.ranOut=!1,v(this))}function y(e,t){var n=e._readableState;if(n.flowing)throw new Error("Cannot switch to old mode now.");var r=t||!1,o=!1;e.readable=!0,e.pipe=x.prototype.pipe,e.on=e.addListener=x.prototype.on,e.on("readable",function(){o=!0;for(var t;!r&&null!==(t=e.read());)e.emit("data",t);null===t&&(o=!1,e._readableState.needReadable=!0)}),e.pause=function(){r=!0,this.emit("pause")},e.resume=function(){r=!1,o?O(function(){e.emit("readable")}):this.read(0),this.emit("resume")},e.emit("readable")}function m(e,t){var n,r=t.buffer,o=t.length,i=!!t.decoder,s=!!t.objectMode;if(0===r.length)return null;if(0===o)n=null;else if(s)n=r.shift();else if(!e||e>=o)n=i?r.join(""):j.concat(r,o),r.length=0;else if(e<r[0].length){var a=r[0];n=a.slice(0,e),r[0]=a.slice(e)}else if(e===r[0].length)n=r.shift();else{n=i?"":new j(e);for(var u=0,c=0,l=r.length;l>c&&e>u;c++){var a=r[0],f=Math.min(e-u,a.length);i?n+=a.slice(0,f):a.copy(n,u,0,f),f<a.length?r[0]=a.slice(f):r.shift(),u+=f}}return n}function _(e){var t=e._readableState;if(t.length>0)throw new Error("endReadable called on non-empty stream");!t.endEmitted&&t.calledRead&&(t.ended=!0,O(function(){t.endEmitted||0!==t.length||(t.endEmitted=!0,e.readable=!1,e.emit("end"))}))}function w(e,t){for(var n=0,r=e.length;r>n;n++)t(e[n],n)}function E(e,t){for(var n=0,r=e.length;r>n;n++)if(e[n]===t)return n;return-1}t.exports=o,o.ReadableState=r;var k,S=e("events").EventEmitter,x=e("./index.js"),j=e("buffer").Buffer,O=e("process/browser.js").nextTick,A=e("inherits");A(o,x),o.prototype.push=function(e,t){var n=this._readableState;return"string"!=typeof e||n.objectMode||(t=t||n.defaultEncoding,t!==n.encoding&&(e=new j(e,t),t="")),i(this,n,e,t,!1)},o.prototype.unshift=function(e){var t=this._readableState;return i(this,t,e,"",!0)},o.prototype.setEncoding=function(t){k||(k=e("string_decoder").StringDecoder),this._readableState.decoder=new k(t),this._readableState.encoding=t};var I=8388608;o.prototype.read=function(e){var t=this._readableState;t.calledRead=!0;var n=e;if(("number"!=typeof e||e>0)&&(t.emittedReadable=!1),0===e&&t.needReadable&&(t.length>=t.highWaterMark||t.ended))return f(this),null;if(e=u(e,t),0===e&&t.ended)return 0===t.length&&_(this),null;var r=t.needReadable;t.length-e<=t.highWaterMark&&(r=!0),(t.ended||t.reading)&&(r=!1),r&&(t.reading=!0,t.sync=!0,0===t.length&&(t.needReadable=!0),this._read(t.highWaterMark),t.sync=!1),r&&!t.reading&&(e=u(n,t));var o;return o=e>0?m(e,t):null,null===o&&(t.needReadable=!0,e=0),t.length-=e,0!==t.length||t.ended||(t.needReadable=!0),t.ended&&!t.endEmitted&&0===t.length&&_(this),o},o.prototype._read=function(){this.emit("error",new Error("not implemented"))},o.prototype.pipe=function(e,t){function r(e){e===l&&i()}function o(){e.end()}function i(){e.removeListener("close",a),e.removeListener("finish",u),e.removeListener("drain",p),e.removeListener("error",s),e.removeListener("unpipe",r),l.removeListener("end",o),l.removeListener("end",i),(!e._writableState||e._writableState.needDrain)&&p()}function s(t){c(),0===y&&0===S.listenerCount(e,"error")&&e.emit("error",t)}function a(){e.removeListener("finish",u),c()}function u(){e.removeListener("close",a),c()}function c(){l.unpipe(e)}var l=this,f=this._readableState;switch(f.pipesCount){case 0:f.pipes=e;break;case 1:f.pipes=[f.pipes,e];break;default:f.pipes.push(e)}f.pipesCount+=1;var d=(!t||t.end!==!1)&&e!==n.stdout&&e!==n.stderr,h=d?o:i;f.endEmitted?O(h):l.once("end",h),e.on("unpipe",r);var p=g(l);e.on("drain",p);var y=S.listenerCount(e,"error");return e.once("error",s),e.once("close",a),e.once("finish",u),e.emit("pipe",l),f.flowing||(this.on("readable",b),f.flowing=!0,O(function(){v(l)})),e},o.prototype.unpipe=function(e){var t=this._readableState;if(0===t.pipesCount)return this;if(1===t.pipesCount)return e&&e!==t.pipes?this:(e||(e=t.pipes),t.pipes=null,t.pipesCount=0,this.removeListener("readable",b),t.flowing=!1,e&&e.emit("unpipe",this),this);if(!e){var n=t.pipes,r=t.pipesCount;t.pipes=null,t.pipesCount=0,this.removeListener("readable",b),t.flowing=!1;for(var o=0;r>o;o++)n[o].emit("unpipe",this);return this}var o=E(t.pipes,e);return-1===o?this:(t.pipes.splice(o,1),t.pipesCount-=1,1===t.pipesCount&&(t.pipes=t.pipes[0]),e.emit("unpipe",this),this)},o.prototype.on=function(e,t){var n=x.prototype.on.call(this,e,t);if("data"!==e||this._readableState.flowing||y(this),"readable"===e&&this.readable){var r=this._readableState;r.readableListening||(r.readableListening=!0,r.emittedReadable=!1,r.needReadable=!0,r.reading?r.length&&f(this,r):this.read(0))}return n},o.prototype.addListener=o.prototype.on,o.prototype.resume=function(){y(this),this.read(0),this.emit("resume")},o.prototype.pause=function(){y(this,!0),this.emit("pause")},o.prototype.wrap=function(e){var t=this._readableState,n=!1,r=this;e.on("end",function(){if(t.decoder&&!t.ended){var e=t.decoder.end();e&&e.length&&r.push(e)}r.push(null)}),e.on("data",function(o){if(t.decoder&&(o=t.decoder.write(o)),o&&(t.objectMode||o.length)){var i=r.push(o);i||(n=!0,e.pause())}});for(var o in e)"function"==typeof e[o]&&"undefined"==typeof this[o]&&(this[o]=function(t){return function(){return e[t].apply(e,arguments)}}(o));var i=["error","close","destroy","pause","resume"];return w(i,function(t){e.on(t,function(e){return r.emit.apply(r,t,e)})}),r._read=function(){n&&(n=!1,e.resume())},r},o._fromList=m}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"./index.js":24,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,events:18,inherits:33,"process/browser.js":25,string_decoder:30}],28:[function(e,t){function n(e,t){this.afterTransform=function(e,n){return r(t,e,n)},this.needTransform=!1,this.transforming=!1,this.writecb=null,this.writechunk=null}function r(e,t,n){var r=e._transformState;r.transforming=!1;var o=r.writecb;if(!o)return e.emit("error",new Error("no writecb in Transform class"));
+r.writechunk=null,r.writecb=null,null!==n&&void 0!==n&&e.push(n),o&&o(t);var i=e._readableState;i.reading=!1,(i.needReadable||i.length<i.highWaterMark)&&e._read(i.highWaterMark)}function o(e){if(!(this instanceof o))return new o(e);s.call(this,e);var t=(this._transformState=new n(e,this),this);this._readableState.needReadable=!0,this._readableState.sync=!1,this.once("finish",function(){"function"==typeof this._flush?this._flush(function(e){i(t,e)}):i(t)})}function i(e,t){if(t)return e.emit("error",t);var n=e._writableState,r=(e._readableState,e._transformState);if(n.length)throw new Error("calling transform done when ws.length != 0");if(r.transforming)throw new Error("calling transform done when still transforming");return e.push(null)}t.exports=o;var s=e("./duplex.js"),a=e("inherits");a(o,s),o.prototype.push=function(e,t){return this._transformState.needTransform=!1,s.prototype.push.call(this,e,t)},o.prototype._transform=function(){throw new Error("not implemented")},o.prototype._write=function(e,t,n){var r=this._transformState;if(r.writecb=n,r.writechunk=e,r.writeencoding=t,!r.transforming){var o=this._readableState;(r.needTransform||o.needReadable||o.length<o.highWaterMark)&&this._read(o.highWaterMark)}},o.prototype._read=function(){var e=this._transformState;e.writechunk&&e.writecb&&!e.transforming?(e.transforming=!0,this._transform(e.writechunk,e.writeencoding,e.afterTransform)):e.needTransform=!0}},{"./duplex.js":23,inherits:33}],29:[function(e,t){function n(e,t,n){this.chunk=e,this.encoding=t,this.callback=n}function r(e,t){e=e||{};var n=e.highWaterMark;this.highWaterMark=n||0===n?n:16384,this.objectMode=!!e.objectMode,this.highWaterMark=~~this.highWaterMark,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1;var r=e.decodeStrings===!1;this.decodeStrings=!r,this.defaultEncoding=e.defaultEncoding||"utf8",this.length=0,this.writing=!1,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(e){d(t,e)},this.writecb=null,this.writelen=0,this.buffer=[]}function o(e){return this instanceof o||this instanceof E.Duplex?(this._writableState=new r(e,this),this.writable=!0,void E.call(this)):new o(e)}function i(e,t,n){var r=new Error("write after end");e.emit("error",r),k(function(){n(r)})}function s(e,t,n,r){var o=!0;if(!S.isBuffer(n)&&"string"!=typeof n&&null!==n&&void 0!==n&&!t.objectMode){var i=new TypeError("Invalid non-string/buffer chunk");e.emit("error",i),k(function(){r(i)}),o=!1}return o}function a(e,t,n){return e.objectMode||e.decodeStrings===!1||"string"!=typeof t||(t=new S(t,n)),t}function u(e,t,r,o,i){r=a(t,r,o);var s=t.objectMode?1:r.length;t.length+=s;var u=t.length<t.highWaterMark;return t.needDrain=!u,t.writing?t.buffer.push(new n(r,o,i)):c(e,t,s,r,o,i),u}function c(e,t,n,r,o,i){t.writelen=n,t.writecb=i,t.writing=!0,t.sync=!0,e._write(r,o,t.onwrite),t.sync=!1}function l(e,t,n,r,o){n?k(function(){o(r)}):o(r),e.emit("error",r)}function f(e){e.writing=!1,e.writecb=null,e.length-=e.writelen,e.writelen=0}function d(e,t){var n=e._writableState,r=n.sync,o=n.writecb;if(f(n),t)l(e,n,r,t,o);else{var i=v(e,n);i||n.bufferProcessing||!n.buffer.length||g(e,n),r?k(function(){h(e,n,i,o)}):h(e,n,i,o)}}function h(e,t,n,r){n||p(e,t),r(),n&&b(e,t)}function p(e,t){0===t.length&&t.needDrain&&(t.needDrain=!1,e.emit("drain"))}function g(e,t){t.bufferProcessing=!0;for(var n=0;n<t.buffer.length;n++){var r=t.buffer[n],o=r.chunk,i=r.encoding,s=r.callback,a=t.objectMode?1:o.length;if(c(e,t,a,o,i,s),t.writing){n++;break}}t.bufferProcessing=!1,n<t.buffer.length?t.buffer=t.buffer.slice(n):t.buffer.length=0}function v(e,t){return t.ending&&0===t.length&&!t.finished&&!t.writing}function b(e,t){var n=v(e,t);return n&&(t.finished=!0,e.emit("finish")),n}function y(e,t,n){t.ending=!0,b(e,t),n&&(t.finished?k(n):e.once("finish",n)),t.ended=!0}t.exports=o,o.WritableState=r;var m="undefined"!=typeof Uint8Array?function(e){return e instanceof Uint8Array}:function(e){return e&&e.constructor&&"Uint8Array"===e.constructor.name},_="undefined"!=typeof ArrayBuffer?function(e){return e instanceof ArrayBuffer}:function(e){return e&&e.constructor&&"ArrayBuffer"===e.constructor.name},w=e("inherits"),E=e("./index.js"),k=e("process/browser.js").nextTick,S=e("buffer").Buffer;w(o,E),o.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe. Not readable."))},o.prototype.write=function(e,t,n){var r=this._writableState,o=!1;return"function"==typeof t&&(n=t,t=null),!S.isBuffer(e)&&m(e)&&(e=new S(e)),_(e)&&"undefined"!=typeof Uint8Array&&(e=new S(new Uint8Array(e))),S.isBuffer(e)?t="buffer":t||(t=r.defaultEncoding),"function"!=typeof n&&(n=function(){}),r.ended?i(this,r,n):s(this,r,e,n)&&(o=u(this,r,e,t,n)),o},o.prototype._write=function(e,t,n){n(new Error("not implemented"))},o.prototype.end=function(e,t,n){var r=this._writableState;"function"==typeof e?(n=e,e=null,t=null):"function"==typeof t&&(n=t,t=null),"undefined"!=typeof e&&null!==e&&this.write(e,t),r.ending||r.finished||y(this,r,n)}},{"./index.js":24,buffer:20,inherits:33,"process/browser.js":25}],30:[function(e,t,n){function r(e){if(e&&!a.isEncoding(e))throw new Error("Unknown encoding: "+e)}function o(e){return e.toString(this.encoding)}function i(e){var t=this.charReceived=e.length%2;return this.charLength=t?2:0,t}function s(e){var t=this.charReceived=e.length%3;return this.charLength=t?3:0,t}var a=e("buffer").Buffer,u=n.StringDecoder=function(e){switch(this.encoding=(e||"utf8").toLowerCase().replace(/[-_]/,""),r(e),this.encoding){case"utf8":this.surrogateSize=3;break;case"ucs2":case"utf16le":this.surrogateSize=2,this.detectIncompleteChar=i;break;case"base64":this.surrogateSize=3,this.detectIncompleteChar=s;break;default:return void(this.write=o)}this.charBuffer=new a(6),this.charReceived=0,this.charLength=0};u.prototype.write=function(e){for(var t="",n=0;this.charLength;){var r=e.length>=this.charLength-this.charReceived?this.charLength-this.charReceived:e.length;if(e.copy(this.charBuffer,this.charReceived,n,r),this.charReceived+=r-n,n=r,this.charReceived<this.charLength)return"";t=this.charBuffer.slice(0,this.charLength).toString(this.encoding);var o=t.charCodeAt(t.length-1);if(!(o>=55296&&56319>=o)){if(this.charReceived=this.charLength=0,r==e.length)return t;e=e.slice(r,e.length);break}this.charLength+=this.surrogateSize,t=""}var i=this.detectIncompleteChar(e),s=e.length;this.charLength&&(e.copy(this.charBuffer,0,e.length-i,s),this.charReceived=i,s-=i),t+=e.toString(this.encoding,0,s);var s=t.length-1,o=t.charCodeAt(s);if(o>=55296&&56319>=o){var a=this.surrogateSize;return this.charLength+=a,this.charReceived+=a,this.charBuffer.copy(this.charBuffer,a,0,a),this.charBuffer.write(t.charAt(t.length-1),this.encoding),t.substring(0,s)}return t},u.prototype.detectIncompleteChar=function(e){for(var t=e.length>=3?3:e.length;t>0;t--){var n=e[e.length-t];if(1==t&&n>>5==6){this.charLength=2;break}if(2>=t&&n>>4==14){this.charLength=3;break}if(3>=t&&n>>3==30){this.charLength=4;break}}return t},u.prototype.end=function(e){var t="";if(e&&e.length&&(t=this.write(e)),this.charReceived){var n=this.charReceived,r=this.charBuffer,o=this.encoding;t+=r.slice(0,n).toString(o)}return t}},{buffer:20}],31:[function(e,t){t.exports=function(e){return e&&"object"==typeof e&&"function"==typeof e.copy&&"function"==typeof e.fill&&"function"==typeof e.readUInt8}},{}],32:[function(e,t,n){(function(t,r){function o(e,t){var r={seen:[],stylize:s};return arguments.length>=3&&(r.depth=arguments[2]),arguments.length>=4&&(r.colors=arguments[3]),g(t)?r.showHidden=t:t&&n._extend(r,t),w(r.showHidden)&&(r.showHidden=!1),w(r.depth)&&(r.depth=2),w(r.colors)&&(r.colors=!1),w(r.customInspect)&&(r.customInspect=!0),r.colors&&(r.stylize=i),u(r,e,r.depth)}function i(e,t){var n=o.styles[t];return n?"["+o.colors[n][0]+"m"+e+"["+o.colors[n][1]+"m":e}function s(e){return e}function a(e){var t={};return e.forEach(function(e){t[e]=!0}),t}function u(e,t,r){if(e.customInspect&&t&&j(t.inspect)&&t.inspect!==n.inspect&&(!t.constructor||t.constructor.prototype!==t)){var o=t.inspect(r,e);return m(o)||(o=u(e,o,r)),o}var i=c(e,t);if(i)return i;var s=Object.keys(t),g=a(s);if(e.showHidden&&(s=Object.getOwnPropertyNames(t)),x(t)&&(s.indexOf("message")>=0||s.indexOf("description")>=0))return l(t);if(0===s.length){if(j(t)){var v=t.name?": "+t.name:"";return e.stylize("[Function"+v+"]","special")}if(E(t))return e.stylize(RegExp.prototype.toString.call(t),"regexp");if(S(t))return e.stylize(Date.prototype.toString.call(t),"date");if(x(t))return l(t)}var b="",y=!1,_=["{","}"];if(p(t)&&(y=!0,_=["[","]"]),j(t)){var w=t.name?": "+t.name:"";b=" [Function"+w+"]"}if(E(t)&&(b=" "+RegExp.prototype.toString.call(t)),S(t)&&(b=" "+Date.prototype.toUTCString.call(t)),x(t)&&(b=" "+l(t)),0===s.length&&(!y||0==t.length))return _[0]+b+_[1];if(0>r)return E(t)?e.stylize(RegExp.prototype.toString.call(t),"regexp"):e.stylize("[Object]","special");e.seen.push(t);var k;return k=y?f(e,t,r,g,s):s.map(function(n){return d(e,t,r,g,n,y)}),e.seen.pop(),h(k,b,_)}function c(e,t){if(w(t))return e.stylize("undefined","undefined");if(m(t)){var n="'"+JSON.stringify(t).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return e.stylize(n,"string")}return y(t)?e.stylize(""+t,"number"):g(t)?e.stylize(""+t,"boolean"):v(t)?e.stylize("null","null"):void 0}function l(e){return"["+Error.prototype.toString.call(e)+"]"}function f(e,t,n,r,o){for(var i=[],s=0,a=t.length;a>s;++s)i.push(R(t,String(s))?d(e,t,n,r,String(s),!0):"");return o.forEach(function(o){o.match(/^\d+$/)||i.push(d(e,t,n,r,o,!0))}),i}function d(e,t,n,r,o,i){var s,a,c;if(c=Object.getOwnPropertyDescriptor(t,o)||{value:t[o]},c.get?a=c.set?e.stylize("[Getter/Setter]","special"):e.stylize("[Getter]","special"):c.set&&(a=e.stylize("[Setter]","special")),R(r,o)||(s="["+o+"]"),a||(e.seen.indexOf(c.value)<0?(a=v(n)?u(e,c.value,null):u(e,c.value,n-1),a.indexOf("\n")>-1&&(a=i?a.split("\n").map(function(e){return" "+e}).join("\n").substr(2):"\n"+a.split("\n").map(function(e){return" "+e}).join("\n"))):a=e.stylize("[Circular]","special")),w(s)){if(i&&o.match(/^\d+$/))return a;s=JSON.stringify(""+o),s.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(s=s.substr(1,s.length-2),s=e.stylize(s,"name")):(s=s.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),s=e.stylize(s,"string"))}return s+": "+a}function h(e,t,n){var r=0,o=e.reduce(function(e,t){return r++,t.indexOf("\n")>=0&&r++,e+t.replace(/\u001b\[\d\d?m/g,"").length+1},0);return o>60?n[0]+(""===t?"":t+"\n ")+" "+e.join(",\n ")+" "+n[1]:n[0]+t+" "+e.join(", ")+" "+n[1]}function p(e){return Array.isArray(e)}function g(e){return"boolean"==typeof e}function v(e){return null===e}function b(e){return null==e}function y(e){return"number"==typeof e}function m(e){return"string"==typeof e}function _(e){return"symbol"==typeof e}function w(e){return void 0===e}function E(e){return k(e)&&"[object RegExp]"===A(e)}function k(e){return"object"==typeof e&&null!==e}function S(e){return k(e)&&"[object Date]"===A(e)}function x(e){return k(e)&&("[object Error]"===A(e)||e instanceof Error)}function j(e){return"function"==typeof e}function O(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"==typeof e||"undefined"==typeof e}function A(e){return Object.prototype.toString.call(e)}function I(e){return 10>e?"0"+e.toString(10):e.toString(10)}function N(){var e=new Date,t=[I(e.getHours()),I(e.getMinutes()),I(e.getSeconds())].join(":");return[e.getDate(),T[e.getMonth()],t].join(" ")}function R(e,t){return Object.prototype.hasOwnProperty.call(e,t)}var L=/%[sdj%]/g;n.format=function(e){if(!m(e)){for(var t=[],n=0;n<arguments.length;n++)t.push(o(arguments[n]));return t.join(" ")}for(var n=1,r=arguments,i=r.length,s=String(e).replace(L,function(e){if("%%"===e)return"%";if(n>=i)return e;switch(e){case"%s":return String(r[n++]);case"%d":return Number(r[n++]);case"%j":try{return JSON.stringify(r[n++])}catch(t){return"[Circular]"}default:return e}}),a=r[n];i>n;a=r[++n])s+=v(a)||!k(a)?" "+a:" "+o(a);return s},n.deprecate=function(e,o){function i(){if(!s){if(t.throwDeprecation)throw new Error(o);t.traceDeprecation?console.trace(o):console.error(o),s=!0}return e.apply(this,arguments)}if(w(r.process))return function(){return n.deprecate(e,o).apply(this,arguments)};if(t.noDeprecation===!0)return e;var s=!1;return i};var B,C={};n.debuglog=function(e){if(w(B)&&(B=t.env.NODE_DEBUG||""),e=e.toUpperCase(),!C[e])if(new RegExp("\\b"+e+"\\b","i").test(B)){var r=t.pid;C[e]=function(){var t=n.format.apply(n,arguments);console.error("%s %d: %s",e,r,t)}}else C[e]=function(){};return C[e]},n.inspect=o,o.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]},o.styles={special:"cyan",number:"yellow","boolean":"yellow",undefined:"grey","null":"bold",string:"green",date:"magenta",regexp:"red"},n.isArray=p,n.isBoolean=g,n.isNull=v,n.isNullOrUndefined=b,n.isNumber=y,n.isString=m,n.isSymbol=_,n.isUndefined=w,n.isRegExp=E,n.isObject=k,n.isDate=S,n.isError=x,n.isFunction=j,n.isPrimitive=O,n.isBuffer=e("./support/isBuffer");var T=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];n.log=function(){console.log("%s - %s",N(),n.format.apply(n,arguments))},n.inherits=e("inherits"),n._extend=function(e,t){if(!t||!k(t))return e;for(var n=Object.keys(t),r=n.length;r--;)e[n[r]]=t[n[r]];return e}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./support/isBuffer":31,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,inherits:33}],33:[function(e,t){t.exports="function"==typeof Object.create?function(e,t){e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}})}:function(e,t){e.super_=t;var n=function(){};n.prototype=t.prototype,e.prototype=new n,e.prototype.constructor=e}},{}],leveldown:[function(e,t){t.exports=e("A2RG/S")},{}],"A2RG/S":[function(e,t){(function(n){function r(e){if(!(this instanceof r))return new r(e);if(!e)throw new Error("constructor requires at least a location argument");this.IDBOptions={},this.location=e}t.exports=r;var o=e("idb-wrapper"),i=e("abstract-leveldown").AbstractLevelDOWN,s=e("util"),a=e("./iterator"),u=e("isbuffer"),c=e("xtend"),l=e("typedarray-to-buffer");s.inherits(r,i),r.prototype._open=function(e,t){var n=this,r={storeName:this.location,autoIncrement:!1,keyPath:null,onStoreReady:function(){t&&t(null,n.idb)},onError:function(e){t&&t(e)}};c(r,e),this.IDBOptions=r,this.idb=new o(r)},r.prototype._get=function(e,t,r){this.idb.get(e,function(o){if(void 0===o)return r(new Error("NotFound"));var i=!0;return t.asBuffer===!1&&(i=!1),t.raw&&(i=!1),i&&(o=o instanceof Uint8Array?l(o):new n(String(o))),r(null,o,e)},r)},r.prototype._del=function(e,t,n){this.idb.remove(e,n,n)},r.prototype._put=function(e,t,r,o){t instanceof ArrayBuffer&&(t=l(new Uint8Array(t)));var i=this.convertEncoding(e,t,r);n.isBuffer(i.value)&&(i.value=new Uint8Array(t.toArrayBuffer())),this.idb.put(i.key,i.value,function(){o()},o)},r.prototype.convertEncoding=function(e,t,n){if(n.raw)return{key:e,value:t};if(t){var r=t.toString();"NaN"===r&&(t="NaN")}var o=n.valueEncoding,i={key:e,value:t};return!t||o&&"binary"===o||"object"!=typeof i.value&&(i.value=r),i},r.prototype.iterator=function(e){return"object"!=typeof e&&(e={}),new a(this.idb,e)},r.prototype._batch=function(e,t,n){var r,o,i,s,a=[];if(0===e.length)return setTimeout(n,0);for(r=0;r<e.length;r++){i={},s=e[r],a[r]=i;var u=this.convertEncoding(s.key,s.value,t);s.key=u.key,s.value=u.value;for(o in s)i[o]="type"===o&&"del"==s[o]?"remove":s[o]}return this.idb.batch(a,function(){n()},n)},r.prototype._close=function(e){this.idb.db.close(),e()},r.prototype._approximateSize=function(e,t,n){var r=new Error("Not implemented");if(n)return n(r);throw r},r.prototype._isBuffer=function(e){return n.isBuffer(e)},r.destroy=function(e,t){if("object"==typeof e)var n=e.IDBOptions.storePrefix||"IDBWrapper-",r=e.location;else var n="IDBWrapper-",r=e;var o=indexedDB.deleteDatabase(n+r);o.onsuccess=function(){t()},o.onerror=function(e){t(e)}};r.prototype._checkKeyValue=function(e,t){return null===e||void 0===e?new Error(t+" cannot be `null` or `undefined`"):null===e||void 0===e?new Error(t+" cannot be `null` or `undefined`"):u(e)&&0===e.byteLength?new Error(t+" cannot be an empty ArrayBuffer"):""===String(e)?new Error(t+" cannot be an empty String"):0===e.length?new Error(t+" cannot be an empty Array"):void 0}}).call(this,e("buffer").Buffer)},{"./iterator":36,"abstract-leveldown":39,buffer:20,"idb-wrapper":41,isbuffer:42,"typedarray-to-buffer":44,util:32,xtend:46}],36:[function(e,t){function n(e,t){t||(t={}),this.options=t,o.call(this,e),this._order=t.reverse?"DESC":"ASC",this._limit=t.limit,this._count=0,this._done=!1;var n=i.lowerBound(t),r=i.upperBound(t);this._keyRange=n||r?this.db.makeKeyRange({lower:n,upper:r,excludeLower:i.lowerBoundExclusive(t),excludeUpper:i.upperBoundExclusive(t)}):null,this.callback=null}var r=e("util"),o=e("abstract-leveldown").AbstractIterator,i=e("ltgt");t.exports=n,r.inherits(n,o),n.prototype.createIterator=function(){var e=this;e.iterator=e.db.iterate(function(){e.onItem.apply(e,arguments)},{keyRange:e._keyRange,autoContinue:!1,order:e._order,onError:function(e){console.log("horrible error",e)}})},n.prototype.onItem=function(e,t){if(!t&&this.callback)return this.callback(),void(this.callback=!1);var n=!0;this._limit&&this._limit>0&&this._count++>=this._limit&&(n=!1),n&&this.callback(!1,t.key,t.value),t&&t["continue"]()},n.prototype._next=function(e){return e?(this._started||(this.createIterator(),this._started=!0),void(this.callback=e)):new Error("next() requires a callback argument")}},{"abstract-leveldown":39,ltgt:43,util:32}],37:[function(e,t){(function(e){function n(e){this._db=e,this._operations=[],this._written=!1}n.prototype._checkWritten=function(){if(this._written)throw new Error("write() already called on this batch")},n.prototype.put=function(e,t){this._checkWritten();var n=this._db._checkKeyValue(e,"key",this._db._isBuffer);if(n)throw n;if(n=this._db._checkKeyValue(t,"value",this._db._isBuffer))throw n;return this._db._isBuffer(e)||(e=String(e)),this._db._isBuffer(t)||(t=String(t)),"function"==typeof this._put?this._put(e,t):this._operations.push({type:"put",key:e,value:t}),this},n.prototype.del=function(e){this._checkWritten();var t=this._db._checkKeyValue(e,"key",this._db._isBuffer);if(t)throw t;return this._db._isBuffer(e)||(e=String(e)),"function"==typeof this._del?this._del(e):this._operations.push({type:"del",key:e}),this},n.prototype.clear=function(){return this._checkWritten(),this._operations=[],"function"==typeof this._clear&&this._clear(),this},n.prototype.write=function(t,n){if(this._checkWritten(),"function"==typeof t&&(n=t),"function"!=typeof n)throw new Error("write() requires a callback argument");return"object"!=typeof t&&(t={}),this._written=!0,"function"==typeof this._write?this._write(n):"function"==typeof this._db._batch?this._db._batch(this._operations,t,n):void e.nextTick(n)},t.exports=n}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],38:[function(e,t){(function(e){function n(e){this.db=e,this._ended=!1,this._nexting=!1}n.prototype.next=function(t){var n=this;if("function"!=typeof t)throw new Error("next() requires a callback argument");return n._ended?t(new Error("cannot call next() after end()")):n._nexting?t(new Error("cannot call next() before previous next() has completed")):(n._nexting=!0,"function"==typeof n._next?n._next(function(){n._nexting=!1,t.apply(null,arguments)}):void e.nextTick(function(){n._nexting=!1,t()}))},n.prototype.end=function(t){if("function"!=typeof t)throw new Error("end() requires a callback argument");return this._ended?t(new Error("end() already called on iterator")):(this._ended=!0,"function"==typeof this._end?this._end(t):void e.nextTick(t))},t.exports=n}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],39:[function(e,t){(function(n,r){function o(e){if(!arguments.length||void 0===e)throw new Error("constructor requires at least a location argument");if("string"!=typeof e)throw new Error("constructor requires a location string argument");this.location=e}var i=e("xtend"),s=e("./abstract-iterator"),a=e("./abstract-chained-batch");o.prototype.open=function(e,t){if("function"==typeof e&&(t=e),"function"!=typeof t)throw new Error("open() requires a callback argument");return"object"!=typeof e&&(e={}),"function"==typeof this._open?this._open(e,t):void n.nextTick(t)},o.prototype.close=function(e){if("function"!=typeof e)throw new Error("close() requires a callback argument");return"function"==typeof this._close?this._close(e):void n.nextTick(e)},o.prototype.get=function(e,t,r){var o;if("function"==typeof t&&(r=t),"function"!=typeof r)throw new Error("get() requires a callback argument");return(o=this._checkKeyValue(e,"key",this._isBuffer))?r(o):(this._isBuffer(e)||(e=String(e)),"object"!=typeof t&&(t={}),"function"==typeof this._get?this._get(e,t,r):void n.nextTick(function(){r(new Error("NotFound"))}))},o.prototype.put=function(e,t,r,o){var i;if("function"==typeof r&&(o=r),"function"!=typeof o)throw new Error("put() requires a callback argument");return(i=this._checkKeyValue(e,"key",this._isBuffer))?o(i):(i=this._checkKeyValue(t,"value",this._isBuffer))?o(i):(this._isBuffer(e)||(e=String(e)),this._isBuffer(t)||n.browser||(t=String(t)),"object"!=typeof r&&(r={}),"function"==typeof this._put?this._put(e,t,r,o):void n.nextTick(o))},o.prototype.del=function(e,t,r){var o;if("function"==typeof t&&(r=t),"function"!=typeof r)throw new Error("del() requires a callback argument");return(o=this._checkKeyValue(e,"key",this._isBuffer))?r(o):(this._isBuffer(e)||(e=String(e)),"object"!=typeof t&&(t={}),"function"==typeof this._del?this._del(e,t,r):void n.nextTick(r))},o.prototype.batch=function(e,t,r){if(!arguments.length)return this._chainedBatch();if("function"==typeof t&&(r=t),"function"!=typeof r)throw new Error("batch(array) requires a callback argument");if(!Array.isArray(e))return r(new Error("batch(array) requires an array argument"));"object"!=typeof t&&(t={});for(var o,i,s=0,a=e.length;a>s;s++)if(o=e[s],"object"==typeof o){if(i=this._checkKeyValue(o.type,"type",this._isBuffer))return r(i);if(i=this._checkKeyValue(o.key,"key",this._isBuffer))return r(i);if("put"==o.type&&(i=this._checkKeyValue(o.value,"value",this._isBuffer)))return r(i)}return"function"==typeof this._batch?this._batch(e,t,r):void n.nextTick(r)},o.prototype.approximateSize=function(e,t,r){if(null==e||null==t||"function"==typeof e||"function"==typeof t)throw new Error("approximateSize() requires valid `start`, `end` and `callback` arguments");if("function"!=typeof r)throw new Error("approximateSize() requires a callback argument");return this._isBuffer(e)||(e=String(e)),this._isBuffer(t)||(t=String(t)),"function"==typeof this._approximateSize?this._approximateSize(e,t,r):void n.nextTick(function(){r(null,0)})},o.prototype._setupIteratorOptions=function(e){var t=this;return e=i(e),["start","end","gt","gte","lt","lte"].forEach(function(n){e[n]&&t._isBuffer(e[n])&&0===e[n].length&&delete e[n]}),e.reverse=!!e.reverse,e.reverse&&e.lt&&(e.start=e.lt),e.reverse&&e.lte&&(e.start=e.lte),!e.reverse&&e.gt&&(e.start=e.gt),!e.reverse&&e.gte&&(e.start=e.gte),(e.reverse&&e.lt&&!e.lte||!e.reverse&&e.gt&&!e.gte)&&(e.exclusiveStart=!0),e},o.prototype.iterator=function(e){return"object"!=typeof e&&(e={}),e=this._setupIteratorOptions(e),"function"==typeof this._iterator?this._iterator(e):new s(this)},o.prototype._chainedBatch=function(){return new a(this)},o.prototype._isBuffer=function(e){return r.isBuffer(e)},o.prototype._checkKeyValue=function(e,t){if(null===e||void 0===e)return new Error(t+" cannot be `null` or `undefined`");if(null===e||void 0===e)return new Error(t+" cannot be `null` or `undefined`");if(this._isBuffer(e)){if(0===e.length)return new Error(t+" cannot be an empty Buffer")}else if(""===String(e))return new Error(t+" cannot be an empty String")},t.exports.AbstractLevelDOWN=o,t.exports.AbstractIterator=s,t.exports.AbstractChainedBatch=a}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),e("buffer").Buffer)},{"./abstract-chained-batch":37,"./abstract-iterator":38,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,xtend:40}],40:[function(e,t){function n(){for(var e={},t=0;t<arguments.length;t++){var n=arguments[t];for(var r in n)n.hasOwnProperty(r)&&(e[r]=n[r])}return e}t.exports=n},{}],41:[function(e,t){!function(e,n,r){"function"==typeof define?define(n):"undefined"!=typeof t&&t.exports?t.exports=n():r[e]=n()}("IDBStore",function(){"use strict";var e=function(e){throw e},t={storeName:"Store",storePrefix:"IDBWrapper-",dbVersion:1,keyPath:"id",autoIncrement:!0,onStoreReady:function(){},onError:e,indexes:[]},n=function(e,n){"undefined"==typeof n&&"function"==typeof e&&(n=e),"[object Object]"!=Object.prototype.toString.call(e)&&(e={});for(var r in t)this[r]="undefined"!=typeof e[r]?e[r]:t[r];this.dbName=this.storePrefix+this.storeName,this.dbVersion=parseInt(this.dbVersion,10)||1,n&&(this.onStoreReady=n);var o="object"==typeof window?window:self;this.idb=o.indexedDB||o.webkitIndexedDB||o.mozIndexedDB,this.keyRange=o.IDBKeyRange||o.webkitIDBKeyRange||o.mozIDBKeyRange,this.features={hasAutoIncrement:!o.mozIndexedDB},this.consts={READ_ONLY:"readonly",READ_WRITE:"readwrite",VERSION_CHANGE:"versionchange",NEXT:"next",NEXT_NO_DUPLICATE:"nextunique",PREV:"prev",PREV_NO_DUPLICATE:"prevunique"},this.openDB()};n.prototype={constructor:n,version:"1.4.1",db:null,dbName:null,dbVersion:null,store:null,storeName:null,keyPath:null,autoIncrement:null,indexes:null,features:null,onStoreReady:null,onError:null,_insertIdCount:0,openDB:function(){var e=this.idb.open(this.dbName,this.dbVersion),t=!1;e.onerror=function(e){var t=!1;"error"in e.target?t="VersionError"==e.target.error.name:"errorCode"in e.target&&(t=12==e.target.errorCode),this.onError(t?new Error("The version number provided is lower than the existing one."):e)}.bind(this),e.onsuccess=function(e){if(!t){if(this.db)return void this.onStoreReady();if(this.db=e.target.result,"string"==typeof this.db.version)return void this.onError(new Error("The IndexedDB implementation in this browser is outdated. Please upgrade your browser."));if(!this.db.objectStoreNames.contains(this.storeName))return void this.onError(new Error("Something is wrong with the IndexedDB implementation in this browser. Please upgrade your browser."));var n=this.db.transaction([this.storeName],this.consts.READ_ONLY);this.store=n.objectStore(this.storeName);var r=Array.prototype.slice.call(this.getIndexList());this.indexes.forEach(function(e){var n=e.name;if(!n)return t=!0,void this.onError(new Error("Cannot create index: No index name given."));if(this.normalizeIndexData(e),this.hasIndex(n)){var o=this.store.index(n),i=this.indexComplies(o,e);i||(t=!0,this.onError(new Error('Cannot modify index "'+n+'" for current version. Please bump version number to '+(this.dbVersion+1)+"."))),r.splice(r.indexOf(n),1)}else t=!0,this.onError(new Error('Cannot create new index "'+n+'" for current version. Please bump version number to '+(this.dbVersion+1)+"."))},this),r.length&&(t=!0,this.onError(new Error('Cannot delete index(es) "'+r.toString()+'" for current version. Please bump version number to '+(this.dbVersion+1)+"."))),t||this.onStoreReady()}}.bind(this),e.onupgradeneeded=function(e){if(this.db=e.target.result,this.db.objectStoreNames.contains(this.storeName))this.store=e.target.transaction.objectStore(this.storeName);else{var n={autoIncrement:this.autoIncrement};null!==this.keyPath&&(n.keyPath=this.keyPath),this.store=this.db.createObjectStore(this.storeName,n)}var r=Array.prototype.slice.call(this.getIndexList());this.indexes.forEach(function(e){var n=e.name;if(n||(t=!0,this.onError(new Error("Cannot create index: No index name given."))),this.normalizeIndexData(e),this.hasIndex(n)){var o=this.store.index(n),i=this.indexComplies(o,e);i||(this.store.deleteIndex(n),this.store.createIndex(n,e.keyPath,{unique:e.unique,multiEntry:e.multiEntry})),r.splice(r.indexOf(n),1)}else this.store.createIndex(n,e.keyPath,{unique:e.unique,multiEntry:e.multiEntry})},this),r.length&&r.forEach(function(e){this.store.deleteIndex(e)},this)}.bind(this)},deleteDatabase:function(){this.idb.deleteDatabase&&this.idb.deleteDatabase(this.dbName)},put:function(t,n,o,i){null!==this.keyPath&&(i=o,o=n,n=t),i||(i=e),o||(o=r);var s,a=!1,u=null,c=this.db.transaction([this.storeName],this.consts.READ_WRITE);return c.oncomplete=function(){var e=a?o:i;e(u)},c.onabort=i,c.onerror=i,null!==this.keyPath?(this._addIdPropertyIfNeeded(n),s=c.objectStore(this.storeName).put(n)):s=c.objectStore(this.storeName).put(n,t),s.onsuccess=function(e){a=!0,u=e.target.result},s.onerror=i,c},get:function(t,n,o){o||(o=e),n||(n=r);var i=!1,s=null,a=this.db.transaction([this.storeName],this.consts.READ_ONLY);a.oncomplete=function(){var e=i?n:o;e(s)},a.onabort=o,a.onerror=o;var u=a.objectStore(this.storeName).get(t);return u.onsuccess=function(e){i=!0,s=e.target.result},u.onerror=o,a},remove:function(t,n,o){o||(o=e),n||(n=r);var i=!1,s=null,a=this.db.transaction([this.storeName],this.consts.READ_WRITE);a.oncomplete=function(){var e=i?n:o;e(s)},a.onabort=o,a.onerror=o;var u=a.objectStore(this.storeName)["delete"](t);return u.onsuccess=function(e){i=!0,s=e.target.result},u.onerror=o,a},batch:function(t,n,o){o||(o=e),n||(n=r),"[object Array]"!=Object.prototype.toString.call(t)&&o(new Error("dataArray argument must be of type Array."));var i=this.db.transaction([this.storeName],this.consts.READ_WRITE);i.oncomplete=function(){var e=u?n:o;e(u)},i.onabort=o,i.onerror=o;var s=t.length,a=!1,u=!1,c=function(){s--,0!==s||a||(a=!0,u=!0)};return t.forEach(function(e){var t=e.type,n=e.key,r=e.value,s=function(e){i.abort(),a||(a=!0,o(e,t,n))};if("remove"==t){var u=i.objectStore(this.storeName)["delete"](n);u.onsuccess=c,u.onerror=s}else if("put"==t){var l;null!==this.keyPath?(this._addIdPropertyIfNeeded(r),l=i.objectStore(this.storeName).put(r)):l=i.objectStore(this.storeName).put(r,n),l.onsuccess=c,l.onerror=s}},this),i},putBatch:function(e,t,n){var r=e.map(function(e){return{type:"put",value:e}});return this.batch(r,t,n)},removeBatch:function(e,t,n){var r=e.map(function(e){return{type:"remove",key:e}});return this.batch(r,t,n)},getBatch:function(t,n,o,i){o||(o=e),n||(n=r),i||(i="sparse"),"[object Array]"!=Object.prototype.toString.call(t)&&o(new Error("keyArray argument must be of type Array."));var s=this.db.transaction([this.storeName],this.consts.READ_ONLY);s.oncomplete=function(){var e=l?n:o;e(f)},s.onabort=o,s.onerror=o;var a=[],u=t.length,c=!1,l=!1,f=null,d=function(e){e.target.result||"dense"==i?a.push(e.target.result):"sparse"==i&&a.length++,u--,0===u&&(c=!0,l=!0,f=a)};return t.forEach(function(e){var t=function(e){c=!0,f=e,o(e),s.abort()},n=s.objectStore(this.storeName).get(e);n.onsuccess=d,n.onerror=t},this),s},getAll:function(t,n){n||(n=e),t||(t=r);var o=this.db.transaction([this.storeName],this.consts.READ_ONLY),i=o.objectStore(this.storeName);return i.getAll?this._getAllNative(o,i,t,n):this._getAllCursor(o,i,t,n),o
+},_getAllNative:function(e,t,n,r){var o=!1,i=null;e.oncomplete=function(){var e=o?n:r;e(i)},e.onabort=r,e.onerror=r;var s=t.getAll();s.onsuccess=function(e){o=!0,i=e.target.result},s.onerror=r},_getAllCursor:function(e,t,n,r){var o=[],i=!1,s=null;e.oncomplete=function(){var e=i?n:r;e(s)},e.onabort=r,e.onerror=r;var a=t.openCursor();a.onsuccess=function(e){var t=e.target.result;t?(o.push(t.value),t["continue"]()):(i=!0,s=o)},a.onError=r},clear:function(t,n){n||(n=e),t||(t=r);var o=!1,i=null,s=this.db.transaction([this.storeName],this.consts.READ_WRITE);s.oncomplete=function(){var e=o?t:n;e(i)},s.onabort=n,s.onerror=n;var a=s.objectStore(this.storeName).clear();return a.onsuccess=function(e){o=!0,i=e.target.result},a.onerror=n,s},_addIdPropertyIfNeeded:function(e){this.features.hasAutoIncrement||"undefined"!=typeof e[this.keyPath]||(e[this.keyPath]=this._insertIdCount++ +Date.now())},getIndexList:function(){return this.store.indexNames},hasIndex:function(e){return this.store.indexNames.contains(e)},normalizeIndexData:function(e){e.keyPath=e.keyPath||e.name,e.unique=!!e.unique,e.multiEntry=!!e.multiEntry},indexComplies:function(e,t){var n=["keyPath","unique","multiEntry"].every(function(n){if("multiEntry"==n&&void 0===e[n]&&t[n]===!1)return!0;if("keyPath"==n&&"[object Array]"==Object.prototype.toString.call(t[n])){var r=t.keyPath,o=e.keyPath;if("string"==typeof o)return r.toString()==o;if("function"!=typeof o.contains&&"function"!=typeof o.indexOf)return!1;if(o.length!==r.length)return!1;for(var i=0,s=r.length;s>i;i++)if(!(o.contains&&o.contains(r[i])||o.indexOf(-1!==r[i])))return!1;return!0}return t[n]==e[n]});return n},iterate:function(t,n){n=i({index:null,order:"ASC",autoContinue:!0,filterDuplicates:!1,keyRange:null,writeAccess:!1,onEnd:null,onError:e},n||{});var r="desc"==n.order.toLowerCase()?"PREV":"NEXT";n.filterDuplicates&&(r+="_NO_DUPLICATE");var o=!1,s=this.db.transaction([this.storeName],this.consts[n.writeAccess?"READ_WRITE":"READ_ONLY"]),a=s.objectStore(this.storeName);n.index&&(a=a.index(n.index)),s.oncomplete=function(){return o?void(n.onEnd?n.onEnd():t(null)):void n.onError(null)},s.onabort=n.onError,s.onerror=n.onError;var u=a.openCursor(n.keyRange,this.consts[r]);return u.onerror=n.onError,u.onsuccess=function(e){var r=e.target.result;r?(t(r.value,r,s),n.autoContinue&&r["continue"]()):o=!0},s},query:function(e,t){var n=[];return t=t||{},t.onEnd=function(){e(n)},this.iterate(function(e){n.push(e)},t)},count:function(t,n){n=i({index:null,keyRange:null},n||{});var r=n.onError||e,o=!1,s=null,a=this.db.transaction([this.storeName],this.consts.READ_ONLY);a.oncomplete=function(){var e=o?t:r;e(s)},a.onabort=r,a.onerror=r;var u=a.objectStore(this.storeName);n.index&&(u=u.index(n.index));var c=u.count(n.keyRange);return c.onsuccess=function(e){o=!0,s=e.target.result},c.onError=r,a},makeKeyRange:function(e){var t,n="undefined"!=typeof e.lower,r="undefined"!=typeof e.upper,o="undefined"!=typeof e.only;switch(!0){case o:t=this.keyRange.only(e.only);break;case n&&r:t=this.keyRange.bound(e.lower,e.upper,e.excludeLower,e.excludeUpper);break;case n:t=this.keyRange.lowerBound(e.lower,e.excludeLower);break;case r:t=this.keyRange.upperBound(e.upper,e.excludeUpper);break;default:throw new Error('Cannot create KeyRange. Provide one or both of "lower" or "upper" value, or an "only" value.')}return t}};var r=function(){},o={},i=function(e,t){var n,r;for(n in t)r=t[n],r!==o[n]&&r!==e[n]&&(e[n]=r);return e};return n.version=n.prototype.version,n},this)},{}],42:[function(e,t){function n(e){return r.isBuffer(e)||/\[object (.+Array|Array.+)\]/.test(Object.prototype.toString.call(e))}var r=e("buffer").Buffer;t.exports=n},{buffer:20}],43:[function(e,t,n){(function(e){function t(e){return null!=e&&""!==e}n.compare=function(t,n){if(e.isBuffer(t)){for(var r=Math.min(t.length,n.length),o=0;r>o;o++){var i=t[o]-n[o];if(i)return i}return t.length-n.length}return n>t?-1:t>n?1:0};var r=n.lowerBound=function(e){return t(e.gt)?e.gt:t(e.gte)?e.gte:t(e.min)?e.min:t(e.start)&&!e.reverse?e.start:t(e.end)&&e.reverse?e.end:void 0};n.lowerBoundInclusive=function(e){return t(e.gt)?!1:!0},n.upperBoundInclusive=function(e){return t(e.lt)?!1:!0};var o=n.lowerBoundExclusive=function(e){return t(e.gt)?!0:!1},i=n.upperBoundExclusive=function(e){return t(e.lt)?!0:!1},s=n.upperBound=function(e){return t(e.lt)?e.lt:t(e.lte)?e.lte:t(e.max)?e.max:t(e.start)&&e.reverse?e.start:t(e.end)&&!e.reverse?e.end:void 0};n.contains=function(e,a,u){u=u||n.compare;var c=r(e);if(t(c)){var l=u(a,c);if(0>l||0===l&&o(e))return!1}var f=s(e);if(t(f)){var l=u(a,f);if(l>0||0===l&&i(e))return!1}return!0},n.filter=function(e,t){return function(r){return n.contains(e,r,t)}}}).call(this,e("buffer").Buffer)},{buffer:20}],44:[function(e,t){(function(e){t.exports=function(t){return"function"==typeof e._augment&&e._useTypedArrays?e._augment(t):new e(t)}}).call(this,e("buffer").Buffer)},{buffer:20}],45:[function(e,t){function n(e){return null!==e&&("object"==typeof e||"function"==typeof e)}t.exports=n},{}],46:[function(e,t){function n(){for(var e={},t=0;t<arguments.length;t++){var n=arguments[t];if(o(n))for(var i=r(n),s=0;s<i.length;s++){var a=i[s];e[a]=n[a]}}return e}var r=e("object-keys"),o=e("./has-keys");t.exports=n},{"./has-keys":45,"object-keys":48}],47:[function(e,t){var n=Object.prototype.hasOwnProperty,r=Object.prototype.toString,o=function(e){var t="function"==typeof e&&!(e instanceof RegExp)||"[object Function]"===r.call(e);return t||"undefined"==typeof window||(t=e===window.setTimeout||e===window.alert||e===window.confirm||e===window.prompt),t};t.exports=function(e,t){if(!o(t))throw new TypeError("iterator must be a function");var r,i,s="string"==typeof e,a=e.length,u=arguments.length>2?arguments[2]:null;if(a===+a)for(r=0;a>r;r++)null===u?t(s?e.charAt(r):e[r],r,e):t.call(u,s?e.charAt(r):e[r],r,e);else for(i in e)n.call(e,i)&&(null===u?t(e[i],i,e):t.call(u,e[i],i,e))}},{}],48:[function(e,t){t.exports=Object.keys||e("./shim")},{"./shim":50}],49:[function(e,t){var n=Object.prototype.toString;t.exports=function r(e){var t=n.call(e),r="[object Arguments]"===t;return r||(r="[object Array]"!==t&&null!==e&&"object"==typeof e&&"number"==typeof e.length&&e.length>=0&&"[object Function]"===n.call(e.callee)),r}},{}],50:[function(e,t){!function(){"use strict";var n,r=Object.prototype.hasOwnProperty,o=Object.prototype.toString,i=e("./foreach"),s=e("./isArguments"),a=!{toString:null}.propertyIsEnumerable("toString"),u=function(){}.propertyIsEnumerable("prototype"),c=["toString","toLocaleString","valueOf","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","constructor"];n=function(e){var t=null!==e&&"object"==typeof e,n="[object Function]"===o.call(e),l=s(e),f=[];if(!t&&!n&&!l)throw new TypeError("Object.keys called on a non-object");if(l)i(e,function(e){f.push(e)});else{var d,h=u&&n;for(d in e)h&&"prototype"===d||!r.call(e,d)||f.push(d)}if(a){var p=e.constructor,g=p&&p.prototype===e;i(c,function(t){g&&"constructor"===t||!r.call(e,t)||f.push(t)})}return f},t.exports=n}()},{"./foreach":47,"./isArguments":49}],51:[function(e,t){function n(e,t,n,r){var o={type:e,key:t,value:n,options:r};return r&&r.prefix&&(o.prefix=r.prefix,delete r.prefix),this._operations.push(o),this}function r(e){this._operations=[],this._sdb=e,this.put=n.bind(this,"put"),this.del=n.bind(this,"del")}var o=r.prototype;o.clear=function(){this._operations=[]},o.write=function(e){this._sdb.batch(this._operations,e)},t.exports=r},{}],52:[function(e,t){(function(n){var r=(e("events").EventEmitter,n.nextTick,e("./sub")),o=e("./batch"),i=e("level-fix-range"),s=e("level-hooks");t.exports=function(e,t){function n(){}function a(e){return function(t){return t=t||{},t=i(t),t.reverse?t.start=t.start||c:t.end=t.end||c,e.call(u,t)}}n.prototype=e;var u=new n;if(u.sublevel)return u;t=t||{};var c=t.sep=t.sep||"ÿ";u._options=t,s(u),u.sublevels={},u.sublevel=function(e,t){return u.sublevels[e]?u.sublevels[e]:new r(u,e,t||this._options)},u.methods={},u.prefix=function(e){return""+(e||"")},u.pre=function(e,t){return t||(t=e,e={max:c}),u.hooks.pre(e,t)},u.post=function(e,t){return t||(t=e,e={max:c}),u.hooks.post(e,t)},u.readStream=u.createReadStream=a(u.createReadStream),u.keyStream=u.createKeyStream=a(u.createKeyStream),u.valuesStream=u.createValueStream=a(u.createValueStream);var l=u.batch;return u.batch=function(e,t,n){return Array.isArray(e)?(e.forEach(function(e){e.prefix&&("function"==typeof e.prefix.prefix?e.key=e.prefix.prefix(e.key):"string"==typeof e.prefix&&(e.key=e.prefix+e.key))}),void l.call(u,e,t,n)):new o(u)},u}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"./batch":51,"./sub":63,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,events:18,"level-fix-range":53,"level-hooks":55}],53:[function(e,t){var n=e("clone");t.exports=function(e){e=n(e);var t=e.reverse,r=e.max||e.end,o=e.min||e.start,i=[o,r];return null!=o&&null!=r&&i.sort(),t&&(i=i.reverse()),e.start=i[0],e.end=i[1],delete e.min,delete e.max,e}},{clone:54}],54:[function(e,t){(function(e){"use strict";function n(e){return Object.prototype.toString.call(e)}function r(t,n,r,i){function s(t,r){if(null===t)return null;if(0==r)return t;var l;if("object"!=typeof t)return t;if(o.isArray(t))l=[];else if(o.isRegExp(t))l=new RegExp(t.source,o.getRegExpFlags(t)),t.lastIndex&&(l.lastIndex=t.lastIndex);else if(o.isDate(t))l=new Date(t.getTime());else{if(c&&e.isBuffer(t))return l=new e(t.length),t.copy(l),l;l=Object.create("undefined"==typeof i?Object.getPrototypeOf(t):i)}if(n){var f=a.indexOf(t);if(-1!=f)return u[f];a.push(t),u.push(l)}for(var d in t)l[d]=s(t[d],r-1);return l}var a=[],u=[],c="undefined"!=typeof e;return"undefined"==typeof n&&(n=!0),"undefined"==typeof r&&(r=1/0),s(t,r)}var o={isArray:function(e){return Array.isArray(e)||"object"==typeof e&&"[object Array]"===n(e)},isDate:function(e){return"object"==typeof e&&"[object Date]"===n(e)},isRegExp:function(e){return"object"==typeof e&&"[object RegExp]"===n(e)},getRegExpFlags:function(e){var t="";return e.global&&(t+="g"),e.ignoreCase&&(t+="i"),e.multiline&&(t+="m"),t}};"object"==typeof t&&(t.exports=r),r.clonePrototype=function(e){if(null===e)return null;var t=function(){};return t.prototype=e,new t}}).call(this,e("buffer").Buffer)},{buffer:20}],55:[function(e,t){var n=e("string-range");t.exports=function(e){function t(e){return e&&("string"==typeof e?e:"string"==typeof e.prefix?e.prefix:"function"==typeof e.prefix?e.prefix():"")}function r(e){return e&&e._getKeyEncoding?e._getKeyEncoding(e):void 0}function o(e){return e&&e._getValueEncoding?e._getValueEncoding(e):void 0}function i(e,t){return function(){var n=e.indexOf(t);return~n?(e.splice(n,1),!0):!1}}function s(e){e&&e.type&&u.forEach(function(t){t.test(e.key)&&t.hook(e)})}function a(n,i,s,a){try{i.forEach(function p(e,n){c.forEach(function(s){if(s.test(String(e.key))){var a={add:function(e,a){if("undefined"==typeof e)return this;if(e===!1)return delete i[n];var u=t(e.prefix)||t(a)||s.prefix||"";if(u&&(e.prefix=u),e.key=u+e.key,s.safe&&s.test(String(e.key)))throw new Error("prehook cannot insert into own range");var c=e.keyEncoding||r(e.prefix),l=e.valueEncoding||o(e.prefix);return c&&(e.keyEncoding=c),l&&(e.valueEncoding=l),i.push(e),p(e,i.length-1),this},put:function(e,t){return"object"==typeof e&&(e.type="put"),this.add(e,t)},del:function(e,t){return"object"==typeof e&&(e.type="del"),this.add(e,t)},veto:function(){return this.add(!1)}};s.hook.call(a,e,a.add,i)}})})}catch(u){return(a||s)(u)}if(i=i.filter(function(e){return e&&e.type}),1==i.length&&!n){var h=i[0];return"put"==h.type?l.call(e,h.key,h.value,s,a):f.call(e,h.key,s,a)}return d.call(e,i,s,a)}if(!e.hooks){var u=[],c=[];e.hooks={post:function(e,t){t||(t=e,e="");var r={test:n.checker(e),hook:t};return u.push(r),i(u,r)},pre:function(e,t){t||(t=e,e="");var r={test:n.checker(e),hook:t,safe:!1!==e.safe};return c.push(r),i(c,r)},posthooks:u,prehooks:c},e.on("put",function(e,t){s({type:"put",key:e,value:t})}),e.on("del",function(e,t){s({type:"del",key:e,value:t})}),e.on("batch",function(e){e.forEach(s)});var l=e.put,f=e.del,d=e.batch;e.put=function(e,t,n,r){var o=[{key:e,value:t,type:"put"}];return a(!1,o,n,r)},e.del=function(e,t,n){var r=[{key:e,type:"del"}];return a(!1,r,t,n)},e.batch=function(e,t,n){return a(!0,e,t,n)}}}},{"string-range":56}],56:[function(e,t,n){{var r=n.range=function(e){return null==e?{}:"string"==typeof r?{min:r,max:r+"ÿ"}:e},o=(n.prefix=function(e,t,r){e=n.range(e);var o={};return r=r||"ÿ",e instanceof RegExp||"function"==typeof e?(o.min=t,o.max=t+r,o.inner=function(n){var r=n.substring(t.length);return e.test?e.test(r):e(r)}):"object"==typeof e&&(o.min=t+(e.min||e.start||""),o.max=t+(e.max||e.end||r||"~"),o.reverse=!!e.reverse),o},n.checker=function(e){return e||(e={}),"string"==typeof e?function(t){return 0==t.indexOf(e)}:e instanceof RegExp?function(t){return e.test(t)}:"object"==typeof e?function(t){var n=e.min||e.start,r=e.max||e.end;return t=String(t),(!n||t>=n)&&(!r||r>=t)&&(!e.inner||(e.inner.test?e.inner.test(t):e.inner(t)))}:"function"==typeof e?e:void 0});n.satisfies=function(e,t){return o(t)(e)}}},{}],57:[function(e,t){t.exports=e(45)},{}],58:[function(e,t,n){arguments[4][46][0].apply(n,arguments)},{"./has-keys":57,"object-keys":59}],59:[function(e,t,n){arguments[4][48][0].apply(n,arguments)},{"./shim":62}],60:[function(e,t){var n=Object.prototype.hasOwnProperty,r=Object.prototype.toString;t.exports=function(e,t,o){if("[object Function]"!==r.call(t))throw new TypeError("iterator must be a function");var i=e.length;if(i===+i)for(var s=0;i>s;s++)t.call(o,e[s],s,e);else for(var a in e)n.call(e,a)&&t.call(o,e[a],a,e)}},{}],61:[function(e,t){var n=Object.prototype,r=n.hasOwnProperty,o=n.toString,i=function(e){return e!==e},s={"boolean":1,number:1,string:1,undefined:1},a=t.exports={};a.a=a.type=function(e,t){return typeof e===t},a.defined=function(e){return void 0!==e},a.empty=function(e){var t,n=o.call(e);if("[object Array]"===n||"[object Arguments]"===n)return 0===e.length;if("[object Object]"===n){for(t in e)if(r.call(e,t))return!1;return!0}return"[object String]"===n?""===e:!1},a.equal=function(e,t){var n,r=o.call(e);if(r!==o.call(t))return!1;if("[object Object]"===r){for(n in e)if(!a.equal(e[n],t[n]))return!1;return!0}if("[object Array]"===r){if(n=e.length,n!==t.length)return!1;for(;--n;)if(!a.equal(e[n],t[n]))return!1;return!0}return"[object Function]"===r?e.prototype===t.prototype:"[object Date]"===r?e.getTime()===t.getTime():e===t},a.hosted=function(e,t){var n=typeof t[e];return"object"===n?!!t[e]:!s[n]},a.instance=a["instanceof"]=function(e,t){return e instanceof t},a["null"]=function(e){return null===e},a.undefined=function(e){return void 0===e},a.arguments=function(e){var t="[object Arguments]"===o.call(e),n=!a.array(e)&&a.arraylike(e)&&a.object(e)&&a.fn(e.callee);return t||n},a.array=function(e){return"[object Array]"===o.call(e)},a.arguments.empty=function(e){return a.arguments(e)&&0===e.length},a.array.empty=function(e){return a.array(e)&&0===e.length},a.arraylike=function(e){return!!e&&!a.boolean(e)&&r.call(e,"length")&&isFinite(e.length)&&a.number(e.length)&&e.length>=0},a.boolean=function(e){return"[object Boolean]"===o.call(e)},a["false"]=function(e){return a.boolean(e)&&(e===!1||e.valueOf()===!1)},a["true"]=function(e){return a.boolean(e)&&(e===!0||e.valueOf()===!0)},a.date=function(e){return"[object Date]"===o.call(e)},a.element=function(e){return void 0!==e&&"undefined"!=typeof HTMLElement&&e instanceof HTMLElement&&1===e.nodeType},a.error=function(e){return"[object Error]"===o.call(e)},a.fn=a["function"]=function(e){var t="undefined"!=typeof window&&e===window.alert;return t||"[object Function]"===o.call(e)},a.number=function(e){return"[object Number]"===o.call(e)},a.infinite=function(e){return 1/0===e||e===-1/0},a.decimal=function(e){return a.number(e)&&!i(e)&&!a.infinite(e)&&e%1!==0},a.divisibleBy=function(e,t){var n=a.infinite(e),r=a.infinite(t),o=a.number(e)&&!i(e)&&a.number(t)&&!i(t)&&0!==t;return n||r||o&&e%t===0},a.int=function(e){return a.number(e)&&!i(e)&&e%1===0},a.maximum=function(e,t){if(i(e))throw new TypeError("NaN is not a valid value");if(!a.arraylike(t))throw new TypeError("second argument must be array-like");for(var n=t.length;--n>=0;)if(e<t[n])return!1;return!0},a.minimum=function(e,t){if(i(e))throw new TypeError("NaN is not a valid value");if(!a.arraylike(t))throw new TypeError("second argument must be array-like");for(var n=t.length;--n>=0;)if(e>t[n])return!1;return!0},a.nan=function(e){return!a.number(e)||e!==e},a.even=function(e){return a.infinite(e)||a.number(e)&&e===e&&e%2===0},a.odd=function(e){return a.infinite(e)||a.number(e)&&e===e&&e%2!==0},a.ge=function(e,t){if(i(e)||i(t))throw new TypeError("NaN is not a valid value");return!a.infinite(e)&&!a.infinite(t)&&e>=t},a.gt=function(e,t){if(i(e)||i(t))throw new TypeError("NaN is not a valid value");return!a.infinite(e)&&!a.infinite(t)&&e>t},a.le=function(e,t){if(i(e)||i(t))throw new TypeError("NaN is not a valid value");return!a.infinite(e)&&!a.infinite(t)&&t>=e},a.lt=function(e,t){if(i(e)||i(t))throw new TypeError("NaN is not a valid value");return!a.infinite(e)&&!a.infinite(t)&&t>e},a.within=function(e,t,n){if(i(e)||i(t)||i(n))throw new TypeError("NaN is not a valid value");if(!a.number(e)||!a.number(t)||!a.number(n))throw new TypeError("all arguments must be numbers");var r=a.infinite(e)||a.infinite(t)||a.infinite(n);return r||e>=t&&n>=e},a.object=function(e){return e&&"[object Object]"===o.call(e)},a.hash=function(e){return a.object(e)&&e.constructor===Object&&!e.nodeType&&!e.setInterval},a.regexp=function(e){return"[object RegExp]"===o.call(e)},a.string=function(e){return"[object String]"===o.call(e)}},{}],62:[function(e,t){!function(){"use strict";var n,r=Object.prototype.hasOwnProperty,o=e("is"),i=e("foreach"),s=!{toString:null}.propertyIsEnumerable("toString"),a=["toString","toLocaleString","valueOf","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","constructor"];n=function(e){if(!o.object(e)&&!o.array(e))throw new TypeError("Object.keys called on a non-object");var t,n=[];for(t in e)r.call(e,t)&&n.push(t);return s&&i(a,function(t){r.call(e,t)&&n.push(t)}),n},t.exports=n}()},{foreach:60,is:61}],63:[function(e,t){function n(e,t,r){if("string"==typeof r&&(console.error("db.sublevel(name, seperator<string>) is depreciated"),console.error("use db.sublevel(name, {sep: separator})) if you must"),r={sep:r}),!(this instanceof n))return new n(e,t,r);if(!e)throw new Error("must provide db");if(!t)throw new Error("must provide prefix");r=r||{},r.sep=r.sep||"ÿ",this._parent=e,this._options=r,this.options=r,this._prefix=t,this._root=o(this),e.sublevels[t]=this,this.sublevels={},this.methods={};var i=this;this.hooks={pre:function(){return i.pre.apply(i,arguments)},post:function(){return i.post.apply(i,arguments)}}}function r(e,t){["valueEncoding","encoding","keyEncoding","reverse","values","keys","limit","fillCache"].forEach(function(n){t.hasOwnProperty(n)&&(e[n]=t[n])})}function o(e){return e._parent?o(e._parent):e}var i=e("events").EventEmitter,s=e("util").inherits,a=e("string-range"),u=e("level-fix-range"),c=e("xtend"),l=e("./batch");s(n,i);var f=n.prototype;f._key=function(e){var t=this._options.sep;return t+this._prefix+t+e},f._getOptsAndCb=function(e,t){return"function"==typeof e&&(t=e,e={}),{opts:c(e,this._options),cb:t}},f.sublevel=function(e,t){return this.sublevels[e]?this.sublevels[e]:new n(this,e,t||this._options)},f.put=function(e,t,n,r){var o=this._getOptsAndCb(n,r);this._root.put(this.prefix(e),t,o.opts,o.cb)},f.get=function(e,t,n){var r=this._getOptsAndCb(t,n);this._root.get(this.prefix(e),r.opts,r.cb)},f.del=function(e,t,n){var r=this._getOptsAndCb(t,n);this._root.del(this.prefix(e),r.opts,r.cb)},f.batch=function(e,t,n){if(!Array.isArray(e))return new l(this);var r=this,o=this._getOptsAndCb(t,n);e.forEach(function(e){e.key="string"==typeof e.prefix?e.prefix+e.key:(e.prefix||r).prefix(e.key),e.prefix&&(e.prefix=null)}),this._root.batch(e,o.opts,o.cb)},f._getKeyEncoding=function(){return this.options.keyEncoding?this.options.keyEncoding:this._parent&&this._parent._getKeyEncoding?this._parent._getKeyEncoding():void 0},f._getValueEncoding=function(){return this.options.valueEncoding?this.options.valueEncoding:this._parent&&this._parent._getValueEncoding?this._parent._getValueEncoding():void 0},f.prefix=function(e){var t=this._options.sep;return this._parent.prefix()+t+this._prefix+t+(e||"")},f.keyStream=f.createKeyStream=function(e){return e=e||{},e.keys=!0,e.values=!1,this.createReadStream(e)},f.valueStream=f.createValueStream=function(e){return e=e||{},e.keys=!1,e.values=!0,e.keys=!1,this.createReadStream(e)},f.readStream=f.createReadStream=function(e){e=e||{};var t=o(this),n=this.prefix(),i=a.prefix(e,n);r(i,c(e,this._options));var s=t.createReadStream(i);if(i.values===!1){var u=s.read;if(u)s.read=function(e){var t=u.call(this,e);return t&&(t=t.substring(n.length)),t};else{var l=s.emit;s.emit=function(e,t){"data"===e?l.call(this,"data",t.substring(n.length)):l.call(this,e,t)}}return s}if(i.keys===!1)return s;var u=s.read;return u?s.read=function(e){var t=u.call(this,e);return t&&(t.key=t.key.substring(n.length)),t}:s.on("data",function(e){e.key=e.key.substring(n.length)}),s},f.writeStream=f.createWriteStream=function(){var e=o(this),t=this.prefix(),n=e.createWriteStream.apply(e,arguments),r=n.write,i=this._options.encoding,s=this._options.valueEncoding,a=this._options.keyEncoding,u=!i&&!s&&!a;return n.write=u?function(e){return e.key=t+e.key,r.call(n,e)}:function(e){return e.key=t+e.key,i&&"undefined"==typeof e.encoding&&(e.encoding=i),s&&"undefined"==typeof e.valueEncoding&&(e.valueEncoding=s),a&&"undefined"==typeof e.keyEncoding&&(e.keyEncoding=a),r.call(n,e)},n},f.approximateSize=function(){var e=o(db);return e.approximateSize.apply(e,arguments)},f.pre=function(e,t){t||(t=e,e=null),e=a.prefix(e,this.prefix(),this._options.sep);var n=o(this._parent),r=this.prefix();return n.hooks.pre(u(e),function(e,n,o){t({key:e.key.substring(r.length),value:e.value,type:e.type},function(e,t){n(e,e.prefix?t:t||r)},o)})},f.post=function(e,t){t||(t=e,e=null);var n=o(this._parent),r=this.prefix();return e=a.prefix(e,r,this._options.sep),n.hooks.post(u(e),function(e){t({key:e.key.substring(r.length),value:e.value,type:e.type})})};t.exports=n},{"./batch":51,events:18,"level-fix-range":53,"string-range":56,util:32,xtend:58}],64:[function(e,t){function n(e){this._levelup=e,this.batch=e.db.batch(),this.ops=[]}var r=e("./util"),o=e("./errors").WriteError,i=r.getOptions,s=r.dispatchError;n.prototype.put=function(e,t,n){n=i(this._levelup,n);var s=r.encodeKey(e,n),a=r.encodeValue(t,n);try{this.batch.put(s,a)}catch(u){throw new o(u)}return this.ops.push({type:"put",key:s,value:a}),this},n.prototype.del=function(e,t){t=i(this._levelup,t);var n=r.encodeKey(e,t);try{this.batch.del(n)}catch(s){throw new o(s)}return this.ops.push({type:"del",key:n}),this},n.prototype.clear=function(){try{this.batch.clear()}catch(e){throw new o(e)}return this.ops=[],this},n.prototype.write=function(e){var t=this._levelup,n=this.ops;try{this.batch.write(function(r){return r?s(t,new o(r),e):(t.emit("batch",n),void(e&&e()))})}catch(r){throw new o(r)}},t.exports=n},{"./errors":65,"./util":68}],65:[function(e,t){var n=e("errno").create,r=n("LevelUPError"),o=n("NotFoundError",r);o.prototype.notFound=!0,o.prototype.status=404,t.exports={LevelUPError:r,InitializationError:n("InitializationError",r),OpenError:n("OpenError",r),ReadError:n("ReadError",r),WriteError:n("WriteError",r),NotFoundError:o,EncodingError:n("EncodingError",r)}},{errno:76}],66:[function(e,t){(function(n){function r(e,t){return"function"==typeof e?e:t}function o(e,t,r){if(!(this instanceof o))return new o(e,t,r);var i;if(s.call(this),this.setMaxListeners(1/0),"function"==typeof e?(t="object"==typeof t?t:{},t.db=e,e=null):"object"==typeof e&&"function"==typeof e.db&&(t=e,e=null),"function"==typeof t&&(r=t,t={}),(!t||"function"!=typeof t.db)&&"string"!=typeof e){if(i=new v("Must provide a location for the database"),r)return n.nextTick(function(){r(i)});throw i}t=w(this,t),this.options=u(E,t),this._status="new",c(this,"location",e,"e"),this.open(r)}function i(e){return function(t,n){k()[e](t,n||function(){})}}var s=e("events").EventEmitter,a=e("util").inherits,u=e("xtend"),c=e("prr"),l=e("deferred-leveldown"),f=e("./errors").WriteError,d=e("./errors").ReadError,h=e("./errors").NotFoundError,p=e("./errors").OpenError,g=e("./errors").EncodingError,v=e("./errors").InitializationError,b=e("./read-stream"),y=e("./write-stream"),m=e("./util"),_=e("./batch"),w=m.getOptions,E=m.defaultOptions,k=m.getLevelDOWN,S=m.dispatchError;a(o,s),o.prototype.open=function(e){var t,r,o=this;return this.isOpen()?(e&&n.nextTick(function(){e(null,o)}),this):this._isOpening()?e&&this.once("open",function(){e(null,o)}):(this.emit("opening"),this._status="opening",this.db=new l(this.location),t=this.options.db||k(),r=t(this.location),void r.open(this.options,function(t){return t?S(o,new p(t),e):(o.db.setDb(r),o.db=r,o._status="open",e&&e(null,o),o.emit("open"),o.emit("ready"),void 0)}))},o.prototype.close=function(e){var t=this;if(this.isOpen())this._status="closing",this.db.close(function(){t._status="closed",t.emit("closed"),e&&e.apply(null,arguments)}),this.emit("closing"),this.db=null;else{if("closed"==this._status&&e)return n.nextTick(e);"closing"==this._status&&e?this.once("closed",e):this._isOpening()&&this.once("open",function(){t.close(e)})}},o.prototype.isOpen=function(){return"open"==this._status},o.prototype._isOpening=function(){return"opening"==this._status},o.prototype.isClosed=function(){return/^clos/.test(this._status)},o.prototype.get=function(e,t,n){var o,i=this;return n=r(t,n),"function"!=typeof n?S(this,new d("get() requires key and callback arguments")):this._isOpening()||this.isOpen()?(t=m.getOptions(this,t),o=m.encodeKey(e,t),t.asBuffer=m.isValueAsBuffer(t),void this.db.get(o,t,function(r,o){if(r)return r=/notfound/i.test(r)?new h("Key not found in database ["+e+"]",r):new d(r),S(i,r,n);if(n){try{o=m.decodeValue(o,t)}catch(s){return n(new g(s))}n(null,o)}})):S(this,new d("Database is not open"),n)},o.prototype.put=function(e,t,n,o){var i,s,a=this;return o=r(n,o),null===e||void 0===e||null===t||void 0===t?S(this,new f("put() requires key and value arguments"),o):this._isOpening()||this.isOpen()?(n=w(this,n),i=m.encodeKey(e,n),s=m.encodeValue(t,n),void this.db.put(i,s,n,function(n){return n?S(a,new f(n),o):(a.emit("put",e,t),void(o&&o()))})):S(this,new f("Database is not open"),o)},o.prototype.del=function(e,t,n){var o,i=this;return n=r(t,n),null===e||void 0===e?S(this,new f("del() requires a key argument"),n):this._isOpening()||this.isOpen()?(t=w(this,t),o=m.encodeKey(e,t),void this.db.del(o,t,function(t){return t?S(i,new f(t),n):(i.emit("del",e),void(n&&n()))})):S(this,new f("Database is not open"),n)},o.prototype.batch=function(e,t,n){var o,i,s,a=this;return arguments.length?(n=r(t,n),Array.isArray(e)?this._isOpening()||this.isOpen()?(t=w(this,t),o=t.keyEncoding,i=t.valueEncoding,s=e.map(function(e){if(void 0===e.type||void 0===e.key)return{};var n,r=e.keyEncoding||o,s=e.valueEncoding||e.encoding||i;return"utf8"!=r&&"binary"!=r||"utf8"!=s&&"binary"!=s?(n={type:e.type,key:m.encodeKey(e.key,t,e)},void 0!==e.value&&(n.value=m.encodeValue(e.value,t,e)),n):e}),void this.db.batch(s,t,function(t){return t?S(a,new f(t),n):(a.emit("batch",e),void(n&&n()))})):S(this,new f("Database is not open"),n):S(this,new f("batch() requires an array argument"),n)):new _(this)},o.prototype.approximateSize=function(e,t,n){var r,o,i=this;return null===e||void 0===e||null===t||void 0===t||"function"!=typeof n?S(this,new d("approximateSize() requires start, end and callback arguments"),n):(r=m.encodeKey(e,this.options),o=m.encodeKey(t,this.options),this._isOpening()||this.isOpen()?void this.db.approximateSize(r,o,function(e,t){return e?S(i,new p(e),n):void(n&&n(null,t))}):S(this,new f("Database is not open"),n))},o.prototype.readStream=o.prototype.createReadStream=function(e){var t=this;return e=u(this.options,e),new b(e,this,function(e){return t.db.iterator(e)})},o.prototype.keyStream=o.prototype.createKeyStream=function(e){return this.createReadStream(u(e,{keys:!0,values:!1}))},o.prototype.valueStream=o.prototype.createValueStream=function(e){return this.createReadStream(u(e,{keys:!1,values:!0}))},o.prototype.writeStream=o.prototype.createWriteStream=function(e){return new y(u(e),this)},o.prototype.toString=function(){return"LevelUP"},t.exports=o,t.exports.copy=m.copy,t.exports.destroy=i("destroy"),t.exports.repair=i("repair")}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"./batch":64,"./errors":65,"./read-stream":67,"./util":68,"./write-stream":69,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"deferred-leveldown":71,events:18,prr:77,util:32,xtend:87}],67:[function(e,t){function n(e,t,o){if(!(this instanceof n))return new n(e,t,o);r.call(this,{objectMode:!0,highWaterMark:e.highWaterMark}),this._db=t,e=this._options=i(u,e),this._keyEncoding=e.keyEncoding||e.encoding,this._valueEncoding=e.valueEncoding||e.encoding,"undefined"!=typeof this._options.start&&(this._options.start=a.encodeKey(this._options.start,this._options)),"undefined"!=typeof this._options.end&&(this._options.end=a.encodeKey(this._options.end,this._options)),"number"!=typeof this._options.limit&&(this._options.limit=-1),this._options.keyAsBuffer=a.isKeyAsBuffer(this._options),this._options.valueAsBuffer=a.isValueAsBuffer(this._options),this._makeData=this._options.keys&&this._options.values?c:this._options.keys?l:this._options.values?f:d;var s=this;this._db.isOpen()?this._iterator=o(this._options):this._db.once("ready",function(){s._destroyed||(s._iterator=o(s._options))})}var r=e("readable-stream").Readable,o=e("util").inherits,i=e("xtend"),s=e("./errors").EncodingError,a=e("./util"),u={keys:!0,values:!0},c=function(e,t){return{key:a.decodeKey(e,this._options),value:a.decodeValue(t,this._options)}},l=function(e){return a.decodeKey(e,this._options)},f=function(e,t){return a.decodeValue(t,this._options)},d=function(){return null};o(n,r),n.prototype._read=function h(){var e=this;return e._db.isOpen()?void(e._destroyed||e._iterator.next(function(t,n,r){if(t||void 0===n&&void 0===r)return t||e._destroyed||e.push(null),e._cleanup(t);try{r=e._makeData(n,r)}catch(o){return e._cleanup(new s(o))}e._destroyed||e.push(r)})):e._db.once("ready",function(){h.call(e)})},n.prototype._cleanup=function(e){if(!this._destroyed){this._destroyed=!0;var t=this;e&&t.emit("error",e),t._iterator?t._iterator.end(function(){t._iterator=null,t.emit("close")}):t.emit("close")}},n.prototype.destroy=function(){this._cleanup()},n.prototype.toString=function(){return"LevelUP.ReadStream"},t.exports=n},{"./errors":65,"./util":68,"readable-stream":86,util:32,xtend:87}],68:[function(e,t){(function(n,r){function o(e,t,n){e.readStream().pipe(t.writeStream()).on("close",n?n:function(){}).on("error",n?n:function(e){throw e})}function i(e,t){var n="string"==typeof t;return!n&&t&&t.encoding&&!t.valueEncoding&&(t.valueEncoding=t.encoding),b(e&&e.options||{},n?E[t]||E[_.valueEncoding]:t)}function s(){if(v)return v;var t,n=e("../package.json").devDependencies.leveldown,r="Could not locate LevelDOWN, try `npm install leveldown`";try{t=e("leveldown/package").version}catch(o){throw new y(r)}if(!e("semver").satisfies(t,n))throw new y("Installed version of LevelDOWN ("+t+") does not match required version ("+n+")");try{return v=e("leveldown")}catch(o){throw new y(r)}}function a(e,t,n){return"function"==typeof n?n(t):e.emit("error",t)}function u(e,t){var n=t&&t.keyEncoding||e.keyEncoding||"utf8";return w[n]||n
+}function c(e,t){var n=t&&(t.valueEncoding||t.encoding)||e.valueEncoding||e.encoding||"utf8";return w[n]||n}function l(e,t,n){return u(t,n).encode(e)}function f(e,t,n){return c(t,n).encode(e)}function d(e,t){return u(t).decode(e)}function h(e,t){return c(t).decode(e)}function p(e,t){return c(e,t).buffer}function g(e,t){return u(e,t).buffer}var v,b=e("xtend"),y=e("./errors").LevelUPError,m=["hex","utf8","utf-8","ascii","binary","base64","ucs2","ucs-2","utf16le","utf-16le"],_={createIfMissing:!0,errorIfExists:!1,keyEncoding:"utf8",valueEncoding:"utf8",compression:!0},w=function(){function e(e){return void 0===e||null===e||r.isBuffer(e)}var t={};return t.utf8=t["utf-8"]={encode:function(t){return e(t)?t:String(t)},decode:function(e){return e},buffer:!1,type:"utf8"},t.json={encode:JSON.stringify,decode:JSON.parse,buffer:!1,type:"json"},m.forEach(function(o){t[o]||(t[o]={encode:function(t){return e(t)?t:new r(t,o)},decode:function(e){return n.browser?e.toString(o):e},buffer:!0,type:o})}),t}(),E=function(){var e={};return m.forEach(function(t){e[t]={valueEncoding:t}}),e}();t.exports={defaultOptions:_,copy:o,getOptions:i,getLevelDOWN:s,dispatchError:a,encodeKey:l,encodeValue:f,isValueAsBuffer:p,isKeyAsBuffer:g,decodeValue:h,decodeKey:d}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),e("buffer").Buffer)},{"../package.json":88,"./errors":65,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,leveldown:"A2RG/S","leveldown/package":17,semver:17,xtend:87}],69:[function(e,t){(function(n,r){function o(e,t){if(!(this instanceof o))return new o(e,t);i.call(this),this._options=a(f,l(t,e)),this._db=t,this._buffer=[],this._status="init",this._end=!1,this.writable=!0,this.readable=!1;var n=this,r=function(){n.writable&&(n._status="ready",n.emit("ready"),n._process())};t.isOpen()?c(r):t.once("ready",r)}var i=e("stream").Stream,s=e("util").inherits,a=e("xtend"),u=e("bl"),c=r.setImmediate||n.nextTick,l=e("./util").getOptions,f={type:"put"};s(o,i),o.prototype.write=function(e){return this.writable?(this._buffer.push(e),"init"!=this._status&&this._processDelayed(),this._options.maxBufferLength&&this._buffer.length>this._options.maxBufferLength?(this._writeBlock=!0,!1):!0):!1},o.prototype.end=function(e){var t=this;e&&this.write(e),c(function(){t._end=!0,t._process()})},o.prototype.destroy=function(){this.writable=!1,this.end()},o.prototype.destroySoon=function(){this.end()},o.prototype.add=function(e){return e.props?(e.props.Directory?e.pipe(this._db.writeStream(this._options)):(e.props.File||e.File||"File"==e.type)&&this._write(e),!0):void 0},o.prototype._processDelayed=function(){var e=this;c(function(){e._process()})},o.prototype._process=function(){var e,t=this,n=function(e){return t.writable?("closed"!=t._status&&(t._status="ready"),e?(t.writable=!1,t.emit("error",e)):void t._process()):void 0};return"ready"!=t._status&&t.writable?void(t._buffer.length&&"closed"!=t._status&&t._processDelayed()):t._buffer.length&&t.writable?(t._status="writing",e=t._buffer,t._buffer=[],t._db.batch(e.map(function(e){return{type:e.type||t._options.type,key:e.key,value:e.value,keyEncoding:e.keyEncoding||t._options.keyEncoding,valueEncoding:e.valueEncoding||e.encoding||t._options.valueEncoding}}),n),void(t._writeBlock&&(t._writeBlock=!1,t.emit("drain")))):void(t._end&&"closed"!=t._status&&(t._status="closed",t.writable=!1,t.emit("close")))},o.prototype._write=function(e){var t=e.path||e.props.path,n=this;t&&e.pipe(u(function(e,r){return e?(n.writable=!1,n.emit("error",e)):(n._options.fstreamRoot&&t.indexOf(n._options.fstreamRoot)>-1&&(t=t.substr(n._options.fstreamRoot.length+1)),void n.write({key:t,value:r.slice(0)}))}))},o.prototype.toString=function(){return"LevelUP.WriteStream"},t.exports=o}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./util":68,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,bl:70,stream:24,util:32,xtend:87}],70:[function(e,t){(function(n){function r(e){if(!(this instanceof r))return new r(e);if(this._bufs=[],this.length=0,"function"==typeof e){this._callback=e;var t=function(e){this._callback&&(this._callback(e),this._callback=null)}.bind(this);this.on("pipe",function(e){e.on("error",t)}),this.on("unpipe",function(e){e.removeListener("error",t)})}else n.isBuffer(e)?this.append(e):Array.isArray(e)&&e.forEach(function(e){n.isBuffer(e)&&this.append(e)}.bind(this));o.call(this)}var o=e("readable-stream").Duplex,i=e("util");i.inherits(r,o),r.prototype._offset=function(e){for(var t,n=0,r=0;r<this._bufs.length;r++){if(t=n+this._bufs[r].length,t>e)return[r,e-n];n=t}},r.prototype.append=function(e){return this._bufs.push(n.isBuffer(e)?e:new n(e)),this.length+=e.length,this},r.prototype._write=function(e,t,n){this.append(e),n&&n()},r.prototype._read=function(e){return this.length?(e=Math.min(e,this.length),this.push(this.slice(0,e)),void this.consume(e)):this.push(null)},r.prototype.end=function(e){o.prototype.end.call(this,e),this._callback&&(this._callback(null,this.slice()),this._callback=null)},r.prototype.get=function(e){return this.slice(e,e+1)[0]},r.prototype.slice=function(e,t){return this.copy(null,0,e,t)},r.prototype.copy=function(e,t,r,o){if(("number"!=typeof r||0>r)&&(r=0),("number"!=typeof o||o>this.length)&&(o=this.length),r>=this.length)return e||new n(0);if(0>=o)return e||new n(0);var i,s,a=!!e,u=this._offset(r),c=o-r,l=c,f=a&&t||0,d=u[1];if(0===r&&o==this.length){if(!a)return n.concat(this._bufs);for(s=0;s<this._bufs.length;s++)this._bufs[s].copy(e,f),f+=this._bufs[s].length;return e}if(l<=this._bufs[u[0]].length-d)return a?this._bufs[u[0]].copy(e,t,d,d+l):this._bufs[u[0]].slice(d,d+l);for(a||(e=new n(c)),s=u[0];s<this._bufs.length;s++){if(i=this._bufs[s].length-d,!(l>i)){this._bufs[s].copy(e,f,d,d+l);break}this._bufs[s].copy(e,f,d),f+=i,l-=i,d&&(d=0)}return e},r.prototype.toString=function(e,t,n){return this.slice(t,n).toString(e)},r.prototype.consume=function(e){for(;this._bufs.length;){if(!(e>this._bufs[0].length)){this._bufs[0]=this._bufs[0].slice(e),this.length-=e;break}e-=this._bufs[0].length,this.length-=this._bufs[0].length,this._bufs.shift()}return this},r.prototype.duplicate=function(){for(var e=0,t=new r;e<this._bufs.length;e++)t.append(this._bufs[e]);return t},r.prototype.destroy=function(){this._bufs.length=0,this.length=0,this.push(null)},function(){var e={readDoubleBE:8,readDoubleLE:8,readFloatBE:4,readFloatLE:4,readInt32BE:4,readInt32LE:4,readUInt32BE:4,readUInt32LE:4,readInt16BE:2,readInt16LE:2,readUInt16BE:2,readUInt16LE:2,readInt8:1,readUInt8:1};for(var t in e)!function(t){r.prototype[t]=function(n){return this.slice(n,n+e[t])[t](0)}}(t)}(),t.exports=r}).call(this,e("buffer").Buffer)},{buffer:20,"readable-stream":86,util:32}],71:[function(e,t){(function(n,r){function o(e){s.call(this,"string"==typeof e?e:""),this._db=void 0,this._operations=[]}var i=e("util"),s=e("abstract-leveldown").AbstractLevelDOWN;i.inherits(o,s),o.prototype.setDb=function(e){this._db=e,this._operations.forEach(function(t){e[t.method].apply(e,t.args)})},o.prototype._open=function(e,t){return n.nextTick(t)},o.prototype._operation=function(e,t){return this._db?this._db[e].apply(this._db,t):void this._operations.push({method:e,args:t})},"put get del batch approximateSize".split(" ").forEach(function(e){o.prototype["_"+e]=function(){this._operation(e,arguments)}}),o.prototype._isBuffer=function(e){return r.isBuffer(e)},o.prototype._iterator=function(){throw new TypeError("not implemented")},t.exports=o}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),e("buffer").Buffer)},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"abstract-leveldown":74,buffer:20,util:32}],72:[function(e,t){t.exports=e(37)},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],73:[function(e,t){t.exports=e(38)},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],74:[function(e,t){t.exports=e(39)},{"./abstract-chained-batch":72,"./abstract-iterator":73,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,xtend:87}],75:[function(e,t){function n(e,t,n){i(this,{type:e,name:e,cause:"string"!=typeof t?t:n,message:t&&"string"!=typeof t?t.message:t},"ewr")}function r(e,t){Error.call(this),Error.captureStackTrace&&Error.captureStackTrace(this,arguments.callee),n.call(this,"CustomError",e,t)}function o(e,t,o){var i=function(r,o){n.call(this,t,r,o),"FilesystemError"==t&&(this.code=this.cause.code,this.path=this.cause.path,this.errno=this.cause.errno,this.message=(e.errno[this.cause.errno]?e.errno[this.cause.errno].description:this.cause.message)+(this.cause.path?" ["+this.cause.path+"]":"")),Error.call(this),Error.captureStackTrace&&Error.captureStackTrace(this,arguments.callee)};return i.prototype=o?new o:new r,i}var i=e("prr");r.prototype=new Error,t.exports=function(e){var t=function(t,n){return o(e,t,n)};return{CustomError:r,FilesystemError:t("FilesystemError"),createError:t}}},{prr:77}],76:[function(e,t){var n=t.exports.all=[{errno:-1,code:"UNKNOWN",description:"unknown error"},{errno:0,code:"OK",description:"success"},{errno:1,code:"EOF",description:"end of file"},{errno:2,code:"EADDRINFO",description:"getaddrinfo error"},{errno:3,code:"EACCES",description:"permission denied"},{errno:4,code:"EAGAIN",description:"resource temporarily unavailable"},{errno:5,code:"EADDRINUSE",description:"address already in use"},{errno:6,code:"EADDRNOTAVAIL",description:"address not available"},{errno:7,code:"EAFNOSUPPORT",description:"address family not supported"},{errno:8,code:"EALREADY",description:"connection already in progress"},{errno:9,code:"EBADF",description:"bad file descriptor"},{errno:10,code:"EBUSY",description:"resource busy or locked"},{errno:11,code:"ECONNABORTED",description:"software caused connection abort"},{errno:12,code:"ECONNREFUSED",description:"connection refused"},{errno:13,code:"ECONNRESET",description:"connection reset by peer"},{errno:14,code:"EDESTADDRREQ",description:"destination address required"},{errno:15,code:"EFAULT",description:"bad address in system call argument"},{errno:16,code:"EHOSTUNREACH",description:"host is unreachable"},{errno:17,code:"EINTR",description:"interrupted system call"},{errno:18,code:"EINVAL",description:"invalid argument"},{errno:19,code:"EISCONN",description:"socket is already connected"},{errno:20,code:"EMFILE",description:"too many open files"},{errno:21,code:"EMSGSIZE",description:"message too long"},{errno:22,code:"ENETDOWN",description:"network is down"},{errno:23,code:"ENETUNREACH",description:"network is unreachable"},{errno:24,code:"ENFILE",description:"file table overflow"},{errno:25,code:"ENOBUFS",description:"no buffer space available"},{errno:26,code:"ENOMEM",description:"not enough memory"},{errno:27,code:"ENOTDIR",description:"not a directory"},{errno:28,code:"EISDIR",description:"illegal operation on a directory"},{errno:29,code:"ENONET",description:"machine is not on the network"},{errno:31,code:"ENOTCONN",description:"socket is not connected"},{errno:32,code:"ENOTSOCK",description:"socket operation on non-socket"},{errno:33,code:"ENOTSUP",description:"operation not supported on socket"},{errno:34,code:"ENOENT",description:"no such file or directory"},{errno:35,code:"ENOSYS",description:"function not implemented"},{errno:36,code:"EPIPE",description:"broken pipe"},{errno:37,code:"EPROTO",description:"protocol error"},{errno:38,code:"EPROTONOSUPPORT",description:"protocol not supported"},{errno:39,code:"EPROTOTYPE",description:"protocol wrong type for socket"},{errno:40,code:"ETIMEDOUT",description:"connection timed out"},{errno:41,code:"ECHARSET",description:"invalid Unicode character"},{errno:42,code:"EAIFAMNOSUPPORT",description:"address family for hostname not supported"},{errno:44,code:"EAISERVICE",description:"servname not supported for ai_socktype"},{errno:45,code:"EAISOCKTYPE",description:"ai_socktype not supported"},{errno:46,code:"ESHUTDOWN",description:"cannot send after transport endpoint shutdown"},{errno:47,code:"EEXIST",description:"file already exists"},{errno:48,code:"ESRCH",description:"no such process"},{errno:49,code:"ENAMETOOLONG",description:"name too long"},{errno:50,code:"EPERM",description:"operation not permitted"},{errno:51,code:"ELOOP",description:"too many symbolic links encountered"},{errno:52,code:"EXDEV",description:"cross-device link not permitted"},{errno:53,code:"ENOTEMPTY",description:"directory not empty"},{errno:54,code:"ENOSPC",description:"no space left on device"},{errno:55,code:"EIO",description:"i/o error"},{errno:56,code:"EROFS",description:"read-only file system"},{errno:57,code:"ENODEV",description:"no such device"},{errno:58,code:"ESPIPE",description:"invalid seek"},{errno:59,code:"ECANCELED",description:"operation canceled"}];t.exports.errno={"-1":n[0],0:n[1],1:n[2],2:n[3],3:n[4],4:n[5],5:n[6],6:n[7],7:n[8],8:n[9],9:n[10],10:n[11],11:n[12],12:n[13],13:n[14],14:n[15],15:n[16],16:n[17],17:n[18],18:n[19],19:n[20],20:n[21],21:n[22],22:n[23],23:n[24],24:n[25],25:n[26],26:n[27],27:n[28],28:n[29],29:n[30],31:n[31],32:n[32],33:n[33],34:n[34],35:n[35],36:n[36],37:n[37],38:n[38],39:n[39],40:n[40],41:n[41],42:n[42],44:n[43],45:n[44],46:n[45],47:n[46],48:n[47],49:n[48],50:n[49],51:n[50],52:n[51],53:n[52],54:n[53],55:n[54],56:n[55],57:n[56],58:n[57],59:n[58]},t.exports.code={UNKNOWN:n[0],OK:n[1],EOF:n[2],EADDRINFO:n[3],EACCES:n[4],EAGAIN:n[5],EADDRINUSE:n[6],EADDRNOTAVAIL:n[7],EAFNOSUPPORT:n[8],EALREADY:n[9],EBADF:n[10],EBUSY:n[11],ECONNABORTED:n[12],ECONNREFUSED:n[13],ECONNRESET:n[14],EDESTADDRREQ:n[15],EFAULT:n[16],EHOSTUNREACH:n[17],EINTR:n[18],EINVAL:n[19],EISCONN:n[20],EMFILE:n[21],EMSGSIZE:n[22],ENETDOWN:n[23],ENETUNREACH:n[24],ENFILE:n[25],ENOBUFS:n[26],ENOMEM:n[27],ENOTDIR:n[28],EISDIR:n[29],ENONET:n[30],ENOTCONN:n[31],ENOTSOCK:n[32],ENOTSUP:n[33],ENOENT:n[34],ENOSYS:n[35],EPIPE:n[36],EPROTO:n[37],EPROTONOSUPPORT:n[38],EPROTOTYPE:n[39],ETIMEDOUT:n[40],ECHARSET:n[41],EAIFAMNOSUPPORT:n[42],EAISERVICE:n[43],EAISOCKTYPE:n[44],ESHUTDOWN:n[45],EEXIST:n[46],ESRCH:n[47],ENAMETOOLONG:n[48],EPERM:n[49],ELOOP:n[50],EXDEV:n[51],ENOTEMPTY:n[52],ENOSPC:n[53],EIO:n[54],EROFS:n[55],ENODEV:n[56],ESPIPE:n[57],ECANCELED:n[58]},t.exports.custom=e("./custom")(t.exports),t.exports.create=t.exports.custom.createError},{"./custom":75}],77:[function(e,t){!function(e,n,r){"undefined"!=typeof t&&t.exports?t.exports=r():n[e]=r()}("prr",this,function(){var e="function"==typeof Object.defineProperty?function(e,t,n){return Object.defineProperty(e,t,n),e}:function(e,t,n){return e[t]=n.value,e},t=function(e,t){var n="object"==typeof t,r=!n&&"string"==typeof t,o=function(e){return n?!!t[e]:r?t.indexOf(e[0])>-1:!1};return{enumerable:o("enumerable"),configurable:o("configurable"),writable:o("writable"),value:e}},n=function(n,r,o,i){var s;if(i=t(o,i),"object"==typeof r){for(s in r)Object.hasOwnProperty.call(r,s)&&(i.value=r[s],e(n,s,i));return n}return e(n,r,i)};return n})},{}],78:[function(e,t){(function(n){function r(e){return this instanceof r?(u.call(this,e),c.call(this,e),e&&e.readable===!1&&(this.readable=!1),e&&e.writable===!1&&(this.writable=!1),this.allowHalfOpen=!0,e&&e.allowHalfOpen===!1&&(this.allowHalfOpen=!1),void this.once("end",o)):new r(e)}function o(){this.allowHalfOpen||this._writableState.ended||n.nextTick(this.end.bind(this))}function i(e,t){for(var n=0,r=e.length;r>n;n++)t(e[n],n)}t.exports=r;var s=Object.keys||function(e){var t=[];for(var n in e)t.push(n);return t},a=e("core-util-is");a.inherits=e("inherits");var u=e("./_stream_readable"),c=e("./_stream_writable");a.inherits(r,u),i(s(c.prototype),function(e){r.prototype[e]||(r.prototype[e]=c.prototype[e])})}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"./_stream_readable":80,"./_stream_writable":82,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"core-util-is":83,inherits:33}],79:[function(e,t){function n(e){return this instanceof n?void r.call(this,e):new n(e)}t.exports=n;var r=e("./_stream_transform"),o=e("core-util-is");o.inherits=e("inherits"),o.inherits(n,r),n.prototype._transform=function(e,t,n){n(null,e)}},{"./_stream_transform":81,"core-util-is":83,inherits:33}],80:[function(e,t){(function(n){function r(t){t=t||{};var n=t.highWaterMark;this.highWaterMark=n||0===n?n:16384,this.highWaterMark=~~this.highWaterMark,this.buffer=[],this.length=0,this.pipes=null,this.pipesCount=0,this.flowing=!1,this.ended=!1,this.endEmitted=!1,this.reading=!1,this.calledRead=!1,this.sync=!0,this.needReadable=!1,this.emittedReadable=!1,this.readableListening=!1,this.objectMode=!!t.objectMode,this.defaultEncoding=t.defaultEncoding||"utf8",this.ranOut=!1,this.awaitDrain=0,this.readingMore=!1,this.decoder=null,this.encoding=null,t.encoding&&(A||(A=e("string_decoder/").StringDecoder),this.decoder=new A(t.encoding),this.encoding=t.encoding)}function o(e){return this instanceof o?(this._readableState=new r(e,this),this.readable=!0,void j.call(this)):new o(e)}function i(e,t,n,r,o){var i=c(t,n);if(i)e.emit("error",i);else if(null===n||void 0===n)t.reading=!1,t.ended||l(e,t);else if(t.objectMode||n&&n.length>0)if(t.ended&&!o){var a=new Error("stream.push() after EOF");e.emit("error",a)}else if(t.endEmitted&&o){var a=new Error("stream.unshift() after end event");e.emit("error",a)}else!t.decoder||o||r||(n=t.decoder.write(n)),t.length+=t.objectMode?1:n.length,o?t.buffer.unshift(n):(t.reading=!1,t.buffer.push(n)),t.needReadable&&f(e),h(e,t);else o||(t.reading=!1);return s(t)}function s(e){return!e.ended&&(e.needReadable||e.length<e.highWaterMark||0===e.length)}function a(e){if(e>=I)e=I;else{e--;for(var t=1;32>t;t<<=1)e|=e>>t;e++}return e}function u(e,t){return 0===t.length&&t.ended?0:t.objectMode?0===e?0:1:isNaN(e)||null===e?t.flowing&&t.buffer.length?t.buffer[0].length:t.length:0>=e?0:(e>t.highWaterMark&&(t.highWaterMark=a(e)),e>t.length?t.ended?t.length:(t.needReadable=!0,0):e)}function c(e,t){var n=null;return S.isBuffer(t)||"string"==typeof t||null===t||void 0===t||e.objectMode||n||(n=new TypeError("Invalid non-string/buffer chunk")),n}function l(e,t){if(t.decoder&&!t.ended){var n=t.decoder.end();n&&n.length&&(t.buffer.push(n),t.length+=t.objectMode?1:n.length)}t.ended=!0,t.length>0?f(e):_(e)}function f(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(t.emittedReadable=!0,t.sync?n.nextTick(function(){d(e)}):d(e))}function d(e){e.emit("readable")}function h(e,t){t.readingMore||(t.readingMore=!0,n.nextTick(function(){p(e,t)}))}function p(e,t){for(var n=t.length;!t.reading&&!t.flowing&&!t.ended&&t.length<t.highWaterMark&&(e.read(0),n!==t.length);)n=t.length;t.readingMore=!1}function g(e){return function(){var t=e._readableState;t.awaitDrain--,0===t.awaitDrain&&v(e)}}function v(e){function t(e){var t=e.write(n);!1===t&&r.awaitDrain++}var n,r=e._readableState;for(r.awaitDrain=0;r.pipesCount&&null!==(n=e.read());)if(1===r.pipesCount?t(r.pipes,0,null):w(r.pipes,t),e.emit("data",n),r.awaitDrain>0)return;return 0===r.pipesCount?(r.flowing=!1,void(x.listenerCount(e,"data")>0&&y(e))):void(r.ranOut=!0)}function b(){this._readableState.ranOut&&(this._readableState.ranOut=!1,v(this))}function y(e,t){var r=e._readableState;if(r.flowing)throw new Error("Cannot switch to old mode now.");var o=t||!1,i=!1;e.readable=!0,e.pipe=j.prototype.pipe,e.on=e.addListener=j.prototype.on,e.on("readable",function(){i=!0;for(var t;!o&&null!==(t=e.read());)e.emit("data",t);null===t&&(i=!1,e._readableState.needReadable=!0)}),e.pause=function(){o=!0,this.emit("pause")},e.resume=function(){o=!1,i?n.nextTick(function(){e.emit("readable")}):this.read(0),this.emit("resume")},e.emit("readable")}function m(e,t){var n,r=t.buffer,o=t.length,i=!!t.decoder,s=!!t.objectMode;if(0===r.length)return null;if(0===o)n=null;else if(s)n=r.shift();else if(!e||e>=o)n=i?r.join(""):S.concat(r,o),r.length=0;else if(e<r[0].length){var a=r[0];n=a.slice(0,e),r[0]=a.slice(e)}else if(e===r[0].length)n=r.shift();else{n=i?"":new S(e);for(var u=0,c=0,l=r.length;l>c&&e>u;c++){var a=r[0],f=Math.min(e-u,a.length);i?n+=a.slice(0,f):a.copy(n,u,0,f),f<a.length?r[0]=a.slice(f):r.shift(),u+=f}}return n}function _(e){var t=e._readableState;if(t.length>0)throw new Error("endReadable called on non-empty stream");!t.endEmitted&&t.calledRead&&(t.ended=!0,n.nextTick(function(){t.endEmitted||0!==t.length||(t.endEmitted=!0,e.readable=!1,e.emit("end"))}))}function w(e,t){for(var n=0,r=e.length;r>n;n++)t(e[n],n)}function E(e,t){for(var n=0,r=e.length;r>n;n++)if(e[n]===t)return n;return-1}t.exports=o;var k=e("isarray"),S=e("buffer").Buffer;o.ReadableState=r;var x=e("events").EventEmitter;x.listenerCount||(x.listenerCount=function(e,t){return e.listeners(t).length});var j=e("stream"),O=e("core-util-is");O.inherits=e("inherits");var A;O.inherits(o,j),o.prototype.push=function(e,t){var n=this._readableState;return"string"!=typeof e||n.objectMode||(t=t||n.defaultEncoding,t!==n.encoding&&(e=new S(e,t),t="")),i(this,n,e,t,!1)},o.prototype.unshift=function(e){var t=this._readableState;return i(this,t,e,"",!0)},o.prototype.setEncoding=function(t){A||(A=e("string_decoder/").StringDecoder),this._readableState.decoder=new A(t),this._readableState.encoding=t};var I=8388608;o.prototype.read=function(e){var t=this._readableState;t.calledRead=!0;var n=e;if(("number"!=typeof e||e>0)&&(t.emittedReadable=!1),0===e&&t.needReadable&&(t.length>=t.highWaterMark||t.ended))return f(this),null;if(e=u(e,t),0===e&&t.ended)return 0===t.length&&_(this),null;var r=t.needReadable;t.length-e<=t.highWaterMark&&(r=!0),(t.ended||t.reading)&&(r=!1),r&&(t.reading=!0,t.sync=!0,0===t.length&&(t.needReadable=!0),this._read(t.highWaterMark),t.sync=!1),r&&!t.reading&&(e=u(n,t));var o;return o=e>0?m(e,t):null,null===o&&(t.needReadable=!0,e=0),t.length-=e,0!==t.length||t.ended||(t.needReadable=!0),t.ended&&!t.endEmitted&&0===t.length&&_(this),o},o.prototype._read=function(){this.emit("error",new Error("not implemented"))},o.prototype.pipe=function(e,t){function r(e){e===l&&i()}function o(){e.end()}function i(){e.removeListener("close",a),e.removeListener("finish",u),e.removeListener("drain",p),e.removeListener("error",s),e.removeListener("unpipe",r),l.removeListener("end",o),l.removeListener("end",i),(!e._writableState||e._writableState.needDrain)&&p()}function s(t){c(),e.removeListener("error",s),0===x.listenerCount(e,"error")&&e.emit("error",t)}function a(){e.removeListener("finish",u),c()}function u(){e.removeListener("close",a),c()}function c(){l.unpipe(e)}var l=this,f=this._readableState;switch(f.pipesCount){case 0:f.pipes=e;break;case 1:f.pipes=[f.pipes,e];break;default:f.pipes.push(e)}f.pipesCount+=1;var d=(!t||t.end!==!1)&&e!==n.stdout&&e!==n.stderr,h=d?o:i;f.endEmitted?n.nextTick(h):l.once("end",h),e.on("unpipe",r);var p=g(l);return e.on("drain",p),e._events&&e._events.error?k(e._events.error)?e._events.error.unshift(s):e._events.error=[s,e._events.error]:e.on("error",s),e.once("close",a),e.once("finish",u),e.emit("pipe",l),f.flowing||(this.on("readable",b),f.flowing=!0,n.nextTick(function(){v(l)})),e},o.prototype.unpipe=function(e){var t=this._readableState;if(0===t.pipesCount)return this;if(1===t.pipesCount)return e&&e!==t.pipes?this:(e||(e=t.pipes),t.pipes=null,t.pipesCount=0,this.removeListener("readable",b),t.flowing=!1,e&&e.emit("unpipe",this),this);if(!e){var n=t.pipes,r=t.pipesCount;t.pipes=null,t.pipesCount=0,this.removeListener("readable",b),t.flowing=!1;for(var o=0;r>o;o++)n[o].emit("unpipe",this);return this}var o=E(t.pipes,e);return-1===o?this:(t.pipes.splice(o,1),t.pipesCount-=1,1===t.pipesCount&&(t.pipes=t.pipes[0]),e.emit("unpipe",this),this)},o.prototype.on=function(e,t){var n=j.prototype.on.call(this,e,t);if("data"!==e||this._readableState.flowing||y(this),"readable"===e&&this.readable){var r=this._readableState;r.readableListening||(r.readableListening=!0,r.emittedReadable=!1,r.needReadable=!0,r.reading?r.length&&f(this,r):this.read(0))}return n},o.prototype.addListener=o.prototype.on,o.prototype.resume=function(){y(this),this.read(0),this.emit("resume")},o.prototype.pause=function(){y(this,!0),this.emit("pause")},o.prototype.wrap=function(e){var t=this._readableState,n=!1,r=this;e.on("end",function(){if(t.decoder&&!t.ended){var e=t.decoder.end();e&&e.length&&r.push(e)}r.push(null)}),e.on("data",function(o){if(t.decoder&&(o=t.decoder.write(o)),o&&(t.objectMode||o.length)){var i=r.push(o);i||(n=!0,e.pause())}});for(var o in e)"function"==typeof e[o]&&"undefined"==typeof this[o]&&(this[o]=function(t){return function(){return e[t].apply(e,arguments)}}(o));var i=["error","close","destroy","pause","resume"];return w(i,function(t){e.on(t,r.emit.bind(r,t))}),r._read=function(){n&&(n=!1,e.resume())},r},o._fromList=m}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,"core-util-is":83,events:18,inherits:33,isarray:84,stream:24,"string_decoder/":85}],81:[function(e,t){function n(e,t){this.afterTransform=function(e,n){return r(t,e,n)},this.needTransform=!1,this.transforming=!1,this.writecb=null,this.writechunk=null}function r(e,t,n){var r=e._transformState;r.transforming=!1;var o=r.writecb;if(!o)return e.emit("error",new Error("no writecb in Transform class"));r.writechunk=null,r.writecb=null,null!==n&&void 0!==n&&e.push(n),o&&o(t);var i=e._readableState;i.reading=!1,(i.needReadable||i.length<i.highWaterMark)&&e._read(i.highWaterMark)}function o(e){if(!(this instanceof o))return new o(e);s.call(this,e);var t=(this._transformState=new n(e,this),this);this._readableState.needReadable=!0,this._readableState.sync=!1,this.once("finish",function(){"function"==typeof this._flush?this._flush(function(e){i(t,e)}):i(t)})}function i(e,t){if(t)return e.emit("error",t);var n=e._writableState,r=(e._readableState,e._transformState);if(n.length)throw new Error("calling transform done when ws.length != 0");if(r.transforming)throw new Error("calling transform done when still transforming");return e.push(null)}t.exports=o;var s=e("./_stream_duplex"),a=e("core-util-is");a.inherits=e("inherits"),a.inherits(o,s),o.prototype.push=function(e,t){return this._transformState.needTransform=!1,s.prototype.push.call(this,e,t)},o.prototype._transform=function(){throw new Error("not implemented")},o.prototype._write=function(e,t,n){var r=this._transformState;if(r.writecb=n,r.writechunk=e,r.writeencoding=t,!r.transforming){var o=this._readableState;(r.needTransform||o.needReadable||o.length<o.highWaterMark)&&this._read(o.highWaterMark)}},o.prototype._read=function(){var e=this._transformState;null!==e.writechunk&&e.writecb&&!e.transforming?(e.transforming=!0,this._transform(e.writechunk,e.writeencoding,e.afterTransform)):e.needTransform=!0}},{"./_stream_duplex":78,"core-util-is":83,inherits:33}],82:[function(e,t){(function(n){function r(e,t,n){this.chunk=e,this.encoding=t,this.callback=n}function o(e,t){e=e||{};var n=e.highWaterMark;this.highWaterMark=n||0===n?n:16384,this.objectMode=!!e.objectMode,this.highWaterMark=~~this.highWaterMark,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1;var r=e.decodeStrings===!1;this.decodeStrings=!r,this.defaultEncoding=e.defaultEncoding||"utf8",this.length=0,this.writing=!1,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(e){h(t,e)},this.writecb=null,this.writelen=0,this.buffer=[],this.errorEmitted=!1}function i(t){var n=e("./_stream_duplex");return this instanceof i||this instanceof n?(this._writableState=new o(t,this),this.writable=!0,void E.call(this)):new i(t)}function s(e,t,r){var o=new Error("write after end");e.emit("error",o),n.nextTick(function(){r(o)})}function a(e,t,r,o){var i=!0;if(!_.isBuffer(r)&&"string"!=typeof r&&null!==r&&void 0!==r&&!t.objectMode){var s=new TypeError("Invalid non-string/buffer chunk");e.emit("error",s),n.nextTick(function(){o(s)}),i=!1}return i}function u(e,t,n){return e.objectMode||e.decodeStrings===!1||"string"!=typeof t||(t=new _(t,n)),t}function c(e,t,n,o,i){n=u(t,n,o),_.isBuffer(n)&&(o="buffer");var s=t.objectMode?1:n.length;t.length+=s;var a=t.length<t.highWaterMark;return a||(t.needDrain=!0),t.writing?t.buffer.push(new r(n,o,i)):l(e,t,s,n,o,i),a}function l(e,t,n,r,o,i){t.writelen=n,t.writecb=i,t.writing=!0,t.sync=!0,e._write(r,o,t.onwrite),t.sync=!1}function f(e,t,r,o,i){r?n.nextTick(function(){i(o)}):i(o),e._writableState.errorEmitted=!0,e.emit("error",o)}function d(e){e.writing=!1,e.writecb=null,e.length-=e.writelen,e.writelen=0}function h(e,t){var r=e._writableState,o=r.sync,i=r.writecb;if(d(r),t)f(e,r,o,t,i);else{var s=b(e,r);s||r.bufferProcessing||!r.buffer.length||v(e,r),o?n.nextTick(function(){p(e,r,s,i)}):p(e,r,s,i)}}function p(e,t,n,r){n||g(e,t),r(),n&&y(e,t)}function g(e,t){0===t.length&&t.needDrain&&(t.needDrain=!1,e.emit("drain"))}function v(e,t){t.bufferProcessing=!0;for(var n=0;n<t.buffer.length;n++){var r=t.buffer[n],o=r.chunk,i=r.encoding,s=r.callback,a=t.objectMode?1:o.length;if(l(e,t,a,o,i,s),t.writing){n++;break}}t.bufferProcessing=!1,n<t.buffer.length?t.buffer=t.buffer.slice(n):t.buffer.length=0}function b(e,t){return t.ending&&0===t.length&&!t.finished&&!t.writing}function y(e,t){var n=b(e,t);return n&&(t.finished=!0,e.emit("finish")),n}function m(e,t,r){t.ending=!0,y(e,t),r&&(t.finished?n.nextTick(r):e.once("finish",r)),t.ended=!0}t.exports=i;var _=e("buffer").Buffer;i.WritableState=o;var w=e("core-util-is");w.inherits=e("inherits");var E=e("stream");w.inherits(i,E),i.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe. Not readable."))},i.prototype.write=function(e,t,n){var r=this._writableState,o=!1;return"function"==typeof t&&(n=t,t=null),_.isBuffer(e)?t="buffer":t||(t=r.defaultEncoding),"function"!=typeof n&&(n=function(){}),r.ended?s(this,r,n):a(this,r,e,n)&&(o=c(this,r,e,t,n)),o},i.prototype._write=function(e,t,n){n(new Error("not implemented"))},i.prototype.end=function(e,t,n){var r=this._writableState;"function"==typeof e?(n=e,e=null,t=null):"function"==typeof t&&(n=t,t=null),"undefined"!=typeof e&&null!==e&&this.write(e,t),r.ending||r.finished||m(this,r,n)}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"./_stream_duplex":78,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,"core-util-is":83,inherits:33,stream:24}],83:[function(e,t,n){(function(e){function t(e){return Array.isArray(e)}function r(e){return"boolean"==typeof e}function o(e){return null===e}function i(e){return null==e}function s(e){return"number"==typeof e}function a(e){return"string"==typeof e}function u(e){return"symbol"==typeof e}function c(e){return void 0===e}function l(e){return f(e)&&"[object RegExp]"===b(e)}function f(e){return"object"==typeof e&&null!==e}function d(e){return f(e)&&"[object Date]"===b(e)}function h(e){return f(e)&&("[object Error]"===b(e)||e instanceof Error)}function p(e){return"function"==typeof e}function g(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"==typeof e||"undefined"==typeof e}function v(t){return e.isBuffer(t)
+}function b(e){return Object.prototype.toString.call(e)}n.isArray=t,n.isBoolean=r,n.isNull=o,n.isNullOrUndefined=i,n.isNumber=s,n.isString=a,n.isSymbol=u,n.isUndefined=c,n.isRegExp=l,n.isObject=f,n.isDate=d,n.isError=h,n.isFunction=p,n.isPrimitive=g,n.isBuffer=v}).call(this,e("buffer").Buffer)},{buffer:20}],84:[function(e,t){t.exports=Array.isArray||function(e){return"[object Array]"==Object.prototype.toString.call(e)}},{}],85:[function(e,t,n){function r(e){if(e&&!u(e))throw new Error("Unknown encoding: "+e)}function o(e){return e.toString(this.encoding)}function i(e){var t=this.charReceived=e.length%2;return this.charLength=t?2:0,t}function s(e){var t=this.charReceived=e.length%3;return this.charLength=t?3:0,t}var a=e("buffer").Buffer,u=a.isEncoding||function(e){switch(e&&e.toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":case"raw":return!0;default:return!1}},c=n.StringDecoder=function(e){switch(this.encoding=(e||"utf8").toLowerCase().replace(/[-_]/,""),r(e),this.encoding){case"utf8":this.surrogateSize=3;break;case"ucs2":case"utf16le":this.surrogateSize=2,this.detectIncompleteChar=i;break;case"base64":this.surrogateSize=3,this.detectIncompleteChar=s;break;default:return void(this.write=o)}this.charBuffer=new a(6),this.charReceived=0,this.charLength=0};c.prototype.write=function(e){for(var t="",n=0;this.charLength;){var r=e.length>=this.charLength-this.charReceived?this.charLength-this.charReceived:e.length;if(e.copy(this.charBuffer,this.charReceived,n,r),this.charReceived+=r-n,n=r,this.charReceived<this.charLength)return"";t=this.charBuffer.slice(0,this.charLength).toString(this.encoding);var o=t.charCodeAt(t.length-1);if(!(o>=55296&&56319>=o)){if(this.charReceived=this.charLength=0,r==e.length)return t;e=e.slice(r,e.length);break}this.charLength+=this.surrogateSize,t=""}var i=this.detectIncompleteChar(e),s=e.length;this.charLength&&(e.copy(this.charBuffer,0,e.length-i,s),this.charReceived=i,s-=i),t+=e.toString(this.encoding,0,s);var s=t.length-1,o=t.charCodeAt(s);if(o>=55296&&56319>=o){var a=this.surrogateSize;return this.charLength+=a,this.charReceived+=a,this.charBuffer.copy(this.charBuffer,a,0,a),this.charBuffer.write(t.charAt(t.length-1),this.encoding),t.substring(0,s)}return t},c.prototype.detectIncompleteChar=function(e){for(var t=e.length>=3?3:e.length;t>0;t--){var n=e[e.length-t];if(1==t&&n>>5==6){this.charLength=2;break}if(2>=t&&n>>4==14){this.charLength=3;break}if(3>=t&&n>>3==30){this.charLength=4;break}}return t},c.prototype.end=function(e){var t="";if(e&&e.length&&(t=this.write(e)),this.charReceived){var n=this.charReceived,r=this.charBuffer,o=this.encoding;t+=r.slice(0,n).toString(o)}return t}},{buffer:20}],86:[function(e,t,n){n=t.exports=e("./lib/_stream_readable.js"),n.Readable=n,n.Writable=e("./lib/_stream_writable.js"),n.Duplex=e("./lib/_stream_duplex.js"),n.Transform=e("./lib/_stream_transform.js"),n.PassThrough=e("./lib/_stream_passthrough.js")},{"./lib/_stream_duplex.js":78,"./lib/_stream_passthrough.js":79,"./lib/_stream_readable.js":80,"./lib/_stream_transform.js":81,"./lib/_stream_writable.js":82}],87:[function(e,t){t.exports=e(40)},{}],88:[function(e,t){t.exports={name:"levelup",description:"Fast & simple storage - a Node.js-style LevelDB wrapper",version:"0.18.6",contributors:[{name:"Rod Vagg",email:"r@va.gg",url:"https://github.com/rvagg"},{name:"John Chesley",email:"john@chesl.es",url:"https://github.com/chesles/"},{name:"Jake Verbaten",email:"raynos2@gmail.com",url:"https://github.com/raynos"},{name:"Dominic Tarr",email:"dominic.tarr@gmail.com",url:"https://github.com/dominictarr"},{name:"Max Ogden",email:"max@maxogden.com",url:"https://github.com/maxogden"},{name:"Lars-Magnus Skog",email:"lars.magnus.skog@gmail.com",url:"https://github.com/ralphtheninja"},{name:"David Björklund",email:"david.bjorklund@gmail.com",url:"https://github.com/kesla"},{name:"Julian Gruber",email:"julian@juliangruber.com",url:"https://github.com/juliangruber"},{name:"Paolo Fragomeni",email:"paolo@async.ly",url:"https://github.com/hij1nx"},{name:"Anton Whalley",email:"anton.whalley@nearform.com",url:"https://github.com/No9"},{name:"Matteo Collina",email:"matteo.collina@gmail.com",url:"https://github.com/mcollina"},{name:"Pedro Teixeira",email:"pedro.teixeira@gmail.com",url:"https://github.com/pgte"},{name:"James Halliday",email:"mail@substack.net",url:"https://github.com/substack"}],repository:{type:"git",url:"https://github.com/rvagg/node-levelup.git"},homepage:"https://github.com/rvagg/node-levelup",keywords:["leveldb","stream","database","db","store","storage","json"],main:"lib/levelup.js",dependencies:{bl:"~0.8.1","deferred-leveldown":"~0.2.0",errno:"~0.1.1",prr:"~0.0.0","readable-stream":"~1.0.26",semver:"~2.3.1",xtend:"~3.0.0"},devDependencies:{leveldown:"~0.10.0",bustermove:"*",tap:"*",referee:"*",rimraf:"*",async:"*",fstream:"*",tar:"*",mkfiletree:"*",readfiletree:"*","slow-stream":">=0.0.4",delayed:"*",boganipsum:"*",du:"*",memdown:"*","msgpack-js":"*"},browser:{leveldown:!1,"leveldown/package":!1,semver:!1},scripts:{test:"tap test/*-test.js --stderr",functionaltests:"node ./test/functional/fstream-test.js && node ./test/functional/binary-data-test.js && node ./test/functional/compat-test.js",alltests:"npm test && npm run-script functionaltests"},license:"MIT",gitHead:"213e989e2b75273e2b44c23f84f95e35bff7ea11",bugs:{url:"https://github.com/rvagg/node-levelup/issues"},_id:"levelup@0.18.6",_shasum:"e6a01cb089616c8ecc0291c2a9bd3f0c44e3e5eb",_from:"levelup@~0.18.4",_npmVersion:"1.4.14",_npmUser:{name:"rvagg",email:"rod@vagg.org"},maintainers:[{name:"rvagg",email:"rod@vagg.org"}],dist:{shasum:"e6a01cb089616c8ecc0291c2a9bd3f0c44e3e5eb",tarball:"http://127.0.0.1:5080/tarballs/levelup/0.18.6.tgz"},_resolved:"http://127.0.0.1:5080/tarballs/levelup/0.18.6.tgz",readme:"ERROR: No README data found!"}},{}],89:[function(e,t){"use strict";function n(){}t.exports=n},{}],90:[function(e,t){"use strict";var n=e("./promise"),r=e("./reject"),o=e("./resolve"),i=e("./INTERNAL"),s=e("./handlers"),a=r(new TypeError("must be an array"));t.exports=function(e){function t(e,t){function n(e){c[t]=e,++l===r&!u&&(u=!0,s.resolve(d,c))}o(e).then(n,function(e){u||(u=!0,s.reject(d,e))})}if("[object Array]"!==Object.prototype.toString.call(e))return a;var r=e.length,u=!1;if(!r)return o([]);for(var c=new Array(r),l=0,f=-1,d=new n(i);++f<r;)t(e[f],f);return d}},{"./INTERNAL":89,"./handlers":91,"./promise":93,"./reject":95,"./resolve":96}],91:[function(e,t,n){"use strict";function r(e){var t=e&&e.then;return e&&"object"==typeof e&&"function"==typeof t?function(){t.apply(e,arguments)}:void 0}var o=e("./tryCatch"),i=e("./resolveThenable"),s=e("./states");n.resolve=function(e,t){var a=o(r,t);if("error"===a.status)return n.reject(e,a.value);var u=a.value;if(u)i.safely(e,u);else{e.state=s.FULFILLED,e.outcome=t;for(var c=-1,l=e.queue.length;++c<l;)e.queue[c].callFulfilled(t)}return e},n.reject=function(e,t){e.state=s.REJECTED,e.outcome=t;for(var n=-1,r=e.queue.length;++n<r;)e.queue[n].callRejected(t);return e}},{"./resolveThenable":97,"./states":98,"./tryCatch":99}],92:[function(e,t,n){t.exports=n=e("./promise"),n.resolve=e("./resolve"),n.reject=e("./reject"),n.all=e("./all")},{"./all":90,"./promise":93,"./reject":95,"./resolve":96}],93:[function(e,t){"use strict";function n(e){if(!(this instanceof n))return new n(e);if("function"!=typeof e)throw new TypeError("reslover must be a function");this.state=s.PENDING,this.queue=[],this.outcome=void 0,e!==o&&i.safely(this,e)}var r=e("./unwrap"),o=e("./INTERNAL"),i=e("./resolveThenable"),s=e("./states"),a=e("./queueItem");t.exports=n,n.prototype["catch"]=function(e){return this.then(null,e)},n.prototype.then=function(e,t){if("function"!=typeof e&&this.state===s.FULFILLED||"function"!=typeof t&&this.state===s.REJECTED)return this;var i=new n(o);if(this.state!==s.PENDING){var u=this.state===s.FULFILLED?e:t;r(i,u,this.outcome)}else this.queue.push(new a(i,e,t));return i}},{"./INTERNAL":89,"./queueItem":94,"./resolveThenable":97,"./states":98,"./unwrap":100}],94:[function(e,t){"use strict";function n(e,t,n){this.promise=e,"function"==typeof t&&(this.onFulfilled=t,this.callFulfilled=this.otherCallFulfilled),"function"==typeof n&&(this.onRejected=n,this.callRejected=this.otherCallRejected)}var r=e("./handlers"),o=e("./unwrap");t.exports=n,n.prototype.callFulfilled=function(e){r.resolve(this.promise,e)},n.prototype.otherCallFulfilled=function(e){o(this.promise,this.onFulfilled,e)},n.prototype.callRejected=function(e){r.reject(this.promise,e)},n.prototype.otherCallRejected=function(e){o(this.promise,this.onRejected,e)}},{"./handlers":91,"./unwrap":100}],95:[function(e,t){"use strict";function n(e){var t=new r(o);return i.reject(t,e)}var r=e("./promise"),o=e("./INTERNAL"),i=e("./handlers");t.exports=n},{"./INTERNAL":89,"./handlers":91,"./promise":93}],96:[function(e,t){"use strict";function n(e){if(e)return e instanceof r?e:i.resolve(new r(o),e);var t=typeof e;switch(t){case"boolean":return s;case"undefined":return u;case"object":return a;case"number":return c;case"string":return l}}var r=e("./promise"),o=e("./INTERNAL"),i=e("./handlers");t.exports=n;var s=i.resolve(new r(o),!1),a=i.resolve(new r(o),null),u=i.resolve(new r(o),void 0),c=i.resolve(new r(o),0),l=i.resolve(new r(o),"")},{"./INTERNAL":89,"./handlers":91,"./promise":93}],97:[function(e,t,n){"use strict";function r(e,t){function n(t){a||(a=!0,o.reject(e,t))}function r(t){a||(a=!0,o.resolve(e,t))}function s(){t(r,n)}var a=!1,u=i(s);"error"===u.status&&n(u.value)}var o=e("./handlers"),i=e("./tryCatch");n.safely=r},{"./handlers":91,"./tryCatch":99}],98:[function(e,t,n){n.REJECTED=["REJECTED"],n.FULFILLED=["FULFILLED"],n.PENDING=["PENDING"]},{}],99:[function(e,t){"use strict";function n(e,t){var n={};try{n.value=e(t),n.status="success"}catch(r){n.status="error",n.value=r}return n}t.exports=n},{}],100:[function(e,t){"use strict";function n(e,t,n){r(function(){var r;try{r=t(n)}catch(i){return o.reject(e,i)}r===e?o.reject(e,new TypeError("Cannot resolve promise with itself")):o.resolve(e,r)})}var r=e("immediate"),o=e("./handlers");t.exports=n},{"./handlers":91,immediate:101}],101:[function(e,t){"use strict";function n(){o=!0;for(var e,t,n=a.length;n;){for(t=a,a=[],e=-1;++e<n;)t[e]();n=a.length}o=!1}function r(e){1!==a.push(e)||o||i()}for(var o,i,s=[e("./nextTick"),e("./mutation.js"),e("./messageChannel"),e("./stateChange"),e("./timeout")],a=[],u=-1,c=s.length;++u<c;)if(s[u]&&s[u].test&&s[u].test()){i=s[u].install(n);break}t.exports=r},{"./messageChannel":102,"./mutation.js":103,"./nextTick":17,"./stateChange":104,"./timeout":105}],102:[function(e,t,n){(function(e){"use strict";n.test=function(){return e.setImmediate?!1:"undefined"!=typeof e.MessageChannel},n.install=function(t){var n=new e.MessageChannel;return n.port1.onmessage=t,function(){n.port2.postMessage(0)}}}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],103:[function(e,t,n){(function(e){"use strict";var t=e.MutationObserver||e.WebKitMutationObserver;n.test=function(){return t},n.install=function(n){var r=0,o=new t(n),i=e.document.createTextNode("");return o.observe(i,{characterData:!0}),function(){i.data=r=++r%2}}}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],104:[function(e,t,n){(function(e){"use strict";n.test=function(){return"document"in e&&"onreadystatechange"in e.document.createElement("script")},n.install=function(t){return function(){var n=e.document.createElement("script");return n.onreadystatechange=function(){t(),n.onreadystatechange=null,n.parentNode.removeChild(n),n=null},e.document.documentElement.appendChild(n),t}}}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],105:[function(e,t,n){"use strict";n.test=function(){return!0},n.install=function(e){return function(){setTimeout(e,0)}}},{}],106:[function(e,t){"use strict";function n(e){return null===e?String(e):"object"==typeof e||"function"==typeof e?a[f.call(e)]||"object":typeof e}function r(e){return null!==e&&e===e.window}function o(e){if(!e||"object"!==n(e)||e.nodeType||r(e))return!1;try{if(e.constructor&&!d.call(e,"constructor")&&!d.call(e.constructor.prototype,"isPrototypeOf"))return!1}catch(t){return!1}var o;for(o in e);return void 0===o||d.call(e,o)}function i(e){return"function"===n(e)}function s(){var e,t,n,r,a,u,c=arguments[0]||{},l=1,f=arguments.length,d=!1;for("boolean"==typeof c&&(d=c,c=arguments[1]||{},l=2),"object"==typeof c||i(c)||(c={}),f===l&&(c=this,--l);f>l;l++)if(null!=(e=arguments[l]))for(t in e)if(!(t in Object.prototype)){if(n=c[t],r=e[t],c===r)continue;d&&r&&(o(r)||(a=h(r)))?(a?(a=!1,u=n&&h(n)?n:[]):u=n&&o(n)?n:{},c[t]=s(d,u,r)):void 0!==r&&(h(e)&&i(r)||(c[t]=r))}return c}for(var a={},u=["Boolean","Number","String","Function","Array","Date","RegExp","Object","Error"],c=0;c<u.length;c++){var l=u[c];a["[object "+l+"]"]=l.toLowerCase()}var f=a.toString,d=a.hasOwnProperty,h=Array.isArray||function(e){return"array"===n(e)};t.exports=s},{}],107:[function(e,t,n){!function(e){if("object"==typeof n)t.exports=e();else if("function"==typeof define&&define.amd)define(e);else{var r;try{r=window}catch(o){r=self}r.SparkMD5=e()}}(function(){"use strict";var e=function(e,t){return e+t&4294967295},t=function(t,n,r,o,i,s){return n=e(e(n,t),e(o,s)),e(n<<i|n>>>32-i,r)},n=function(e,n,r,o,i,s,a){return t(n&r|~n&o,e,n,i,s,a)},r=function(e,n,r,o,i,s,a){return t(n&o|r&~o,e,n,i,s,a)},o=function(e,n,r,o,i,s,a){return t(n^r^o,e,n,i,s,a)},i=function(e,n,r,o,i,s,a){return t(r^(n|~o),e,n,i,s,a)},s=function(t,s){var a=t[0],u=t[1],c=t[2],l=t[3];a=n(a,u,c,l,s[0],7,-680876936),l=n(l,a,u,c,s[1],12,-389564586),c=n(c,l,a,u,s[2],17,606105819),u=n(u,c,l,a,s[3],22,-1044525330),a=n(a,u,c,l,s[4],7,-176418897),l=n(l,a,u,c,s[5],12,1200080426),c=n(c,l,a,u,s[6],17,-1473231341),u=n(u,c,l,a,s[7],22,-45705983),a=n(a,u,c,l,s[8],7,1770035416),l=n(l,a,u,c,s[9],12,-1958414417),c=n(c,l,a,u,s[10],17,-42063),u=n(u,c,l,a,s[11],22,-1990404162),a=n(a,u,c,l,s[12],7,1804603682),l=n(l,a,u,c,s[13],12,-40341101),c=n(c,l,a,u,s[14],17,-1502002290),u=n(u,c,l,a,s[15],22,1236535329),a=r(a,u,c,l,s[1],5,-165796510),l=r(l,a,u,c,s[6],9,-1069501632),c=r(c,l,a,u,s[11],14,643717713),u=r(u,c,l,a,s[0],20,-373897302),a=r(a,u,c,l,s[5],5,-701558691),l=r(l,a,u,c,s[10],9,38016083),c=r(c,l,a,u,s[15],14,-660478335),u=r(u,c,l,a,s[4],20,-405537848),a=r(a,u,c,l,s[9],5,568446438),l=r(l,a,u,c,s[14],9,-1019803690),c=r(c,l,a,u,s[3],14,-187363961),u=r(u,c,l,a,s[8],20,1163531501),a=r(a,u,c,l,s[13],5,-1444681467),l=r(l,a,u,c,s[2],9,-51403784),c=r(c,l,a,u,s[7],14,1735328473),u=r(u,c,l,a,s[12],20,-1926607734),a=o(a,u,c,l,s[5],4,-378558),l=o(l,a,u,c,s[8],11,-2022574463),c=o(c,l,a,u,s[11],16,1839030562),u=o(u,c,l,a,s[14],23,-35309556),a=o(a,u,c,l,s[1],4,-1530992060),l=o(l,a,u,c,s[4],11,1272893353),c=o(c,l,a,u,s[7],16,-155497632),u=o(u,c,l,a,s[10],23,-1094730640),a=o(a,u,c,l,s[13],4,681279174),l=o(l,a,u,c,s[0],11,-358537222),c=o(c,l,a,u,s[3],16,-722521979),u=o(u,c,l,a,s[6],23,76029189),a=o(a,u,c,l,s[9],4,-640364487),l=o(l,a,u,c,s[12],11,-421815835),c=o(c,l,a,u,s[15],16,530742520),u=o(u,c,l,a,s[2],23,-995338651),a=i(a,u,c,l,s[0],6,-198630844),l=i(l,a,u,c,s[7],10,1126891415),c=i(c,l,a,u,s[14],15,-1416354905),u=i(u,c,l,a,s[5],21,-57434055),a=i(a,u,c,l,s[12],6,1700485571),l=i(l,a,u,c,s[3],10,-1894986606),c=i(c,l,a,u,s[10],15,-1051523),u=i(u,c,l,a,s[1],21,-2054922799),a=i(a,u,c,l,s[8],6,1873313359),l=i(l,a,u,c,s[15],10,-30611744),c=i(c,l,a,u,s[6],15,-1560198380),u=i(u,c,l,a,s[13],21,1309151649),a=i(a,u,c,l,s[4],6,-145523070),l=i(l,a,u,c,s[11],10,-1120210379),c=i(c,l,a,u,s[2],15,718787259),u=i(u,c,l,a,s[9],21,-343485551),t[0]=e(a,t[0]),t[1]=e(u,t[1]),t[2]=e(c,t[2]),t[3]=e(l,t[3])},a=function(e){var t,n=[];for(t=0;64>t;t+=4)n[t>>2]=e.charCodeAt(t)+(e.charCodeAt(t+1)<<8)+(e.charCodeAt(t+2)<<16)+(e.charCodeAt(t+3)<<24);return n},u=function(e){var t,n=[];for(t=0;64>t;t+=4)n[t>>2]=e[t]+(e[t+1]<<8)+(e[t+2]<<16)+(e[t+3]<<24);return n},c=function(e){var t,n,r,o,i,u,c=e.length,l=[1732584193,-271733879,-1732584194,271733878];for(t=64;c>=t;t+=64)s(l,a(e.substring(t-64,t)));for(e=e.substring(t-64),n=e.length,r=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],t=0;n>t;t+=1)r[t>>2]|=e.charCodeAt(t)<<(t%4<<3);if(r[t>>2]|=128<<(t%4<<3),t>55)for(s(l,r),t=0;16>t;t+=1)r[t]=0;return o=8*c,o=o.toString(16).match(/(.*?)(.{0,8})$/),i=parseInt(o[2],16),u=parseInt(o[1],16)||0,r[14]=i,r[15]=u,s(l,r),l},l=function(e){var t,n,r,o,i,a,c=e.length,l=[1732584193,-271733879,-1732584194,271733878];for(t=64;c>=t;t+=64)s(l,u(e.subarray(t-64,t)));for(e=c>t-64?e.subarray(t-64):new Uint8Array(0),n=e.length,r=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],t=0;n>t;t+=1)r[t>>2]|=e[t]<<(t%4<<3);if(r[t>>2]|=128<<(t%4<<3),t>55)for(s(l,r),t=0;16>t;t+=1)r[t]=0;return o=8*c,o=o.toString(16).match(/(.*?)(.{0,8})$/),i=parseInt(o[2],16),a=parseInt(o[1],16)||0,r[14]=i,r[15]=a,s(l,r),l},f=["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"],d=function(e){var t,n="";for(t=0;4>t;t+=1)n+=f[e>>8*t+4&15]+f[e>>8*t&15];return n},h=function(e){var t;for(t=0;t<e.length;t+=1)e[t]=d(e[t]);return e.join("")},p=function(e){return h(c(e))},g=function(){this.reset()};return"5d41402abc4b2a76b9719d911017c592"!==p("hello")&&(e=function(e,t){var n=(65535&e)+(65535&t),r=(e>>16)+(t>>16)+(n>>16);return r<<16|65535&n}),g.prototype.append=function(e){return/[\u0080-\uFFFF]/.test(e)&&(e=unescape(encodeURIComponent(e))),this.appendBinary(e),this},g.prototype.appendBinary=function(e){this._buff+=e,this._length+=e.length;var t,n=this._buff.length;for(t=64;n>=t;t+=64)s(this._state,a(this._buff.substring(t-64,t)));return this._buff=this._buff.substr(t-64),this},g.prototype.end=function(e){var t,n,r=this._buff,o=r.length,i=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];for(t=0;o>t;t+=1)i[t>>2]|=r.charCodeAt(t)<<(t%4<<3);return this._finish(i,o),n=e?this._state:h(this._state),this.reset(),n},g.prototype._finish=function(e,t){var n,r,o,i=t;if(e[i>>2]|=128<<(i%4<<3),i>55)for(s(this._state,e),i=0;16>i;i+=1)e[i]=0;n=8*this._length,n=n.toString(16).match(/(.*?)(.{0,8})$/),r=parseInt(n[2],16),o=parseInt(n[1],16)||0,e[14]=r,e[15]=o,s(this._state,e)},g.prototype.reset=function(){return this._buff="",this._length=0,this._state=[1732584193,-271733879,-1732584194,271733878],this},g.prototype.destroy=function(){delete this._state,delete this._buff,delete this._length},g.hash=function(e,t){/[\u0080-\uFFFF]/.test(e)&&(e=unescape(encodeURIComponent(e)));var n=c(e);return t?n:h(n)},g.hashBinary=function(e,t){var n=c(e);return t?n:h(n)},g.ArrayBuffer=function(){this.reset()},g.ArrayBuffer.prototype.append=function(e){var t,n=this._concatArrayBuffer(this._buff,e),r=n.length;for(this._length+=e.byteLength,t=64;r>=t;t+=64)s(this._state,u(n.subarray(t-64,t)));return this._buff=r>t-64?n.subarray(t-64):new Uint8Array(0),this},g.ArrayBuffer.prototype.end=function(e){var t,n,r=this._buff,o=r.length,i=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];for(t=0;o>t;t+=1)i[t>>2]|=r[t]<<(t%4<<3);return this._finish(i,o),n=e?this._state:h(this._state),this.reset(),n},g.ArrayBuffer.prototype._finish=g.prototype._finish,g.ArrayBuffer.prototype.reset=function(){return this._buff=new Uint8Array(0),this._length=0,this._state=[1732584193,-271733879,-1732584194,271733878],this},g.ArrayBuffer.prototype.destroy=g.prototype.destroy,g.ArrayBuffer.prototype._concatArrayBuffer=function(e,t){var n=e.length,r=new Uint8Array(n+t.byteLength);return r.set(e),r.set(new Uint8Array(t),n),r},g.ArrayBuffer.hash=function(e,t){var n=l(new Uint8Array(e));return t?n:h(n)},g})},{}],108:[function(e,t,n){arguments[4][78][0].apply(n,arguments)},{"./_stream_readable":109,"./_stream_writable":111,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"core-util-is":112,inherits:33}],109:[function(e,t){t.exports=e(80)},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,"core-util-is":112,events:18,inherits:33,isarray:113,stream:24,"string_decoder/":114}],110:[function(e,t,n){arguments[4][81][0].apply(n,arguments)},{"./_stream_duplex":108,"core-util-is":112,inherits:33}],111:[function(e,t,n){arguments[4][82][0].apply(n,arguments)},{"./_stream_duplex":108,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,"core-util-is":112,inherits:33,stream:24}],112:[function(e,t){t.exports=e(83)},{buffer:20}],113:[function(e,t){t.exports=e(84)},{}],114:[function(e,t){t.exports=e(85)},{buffer:20}],115:[function(e,t){t.exports=e("./lib/_stream_transform.js")},{"./lib/_stream_transform.js":110}],116:[function(e,t){t.exports=e(45)},{}],117:[function(e,t,n){arguments[4][46][0].apply(n,arguments)},{"./has-keys":116,"object-keys":119}],118:[function(e,t){t.exports=e(47)},{}],119:[function(e,t,n){arguments[4][48][0].apply(n,arguments)},{"./shim":121}],120:[function(e,t){t.exports=e(49)},{}],121:[function(e,t){t.exports=e(50)},{"./foreach":118,"./isArguments":120}],122:[function(e,t){function n(e,t,n){n(null,e)}function r(e){return function(t,r,o){return"function"==typeof t&&(o=r,r=t,t={}),"function"!=typeof r&&(r=n),"function"!=typeof o&&(o=null),e(t,r,o)}}var o=e("readable-stream/transform"),i=e("util").inherits,s=e("xtend");t.exports=r(function(e,t,n){var r=new o(e);return r._transform=t,n&&(r._flush=n),r}),t.exports.ctor=r(function(e,t,n){function r(t){return this instanceof r?(this.options=s(e,t),void o.call(this,this.options)):new r(t)}return i(r,o),r.prototype._transform=t,n&&(r.prototype._flush=n),r}),t.exports.obj=r(function(e,t,n){var r=new o(s({objectMode:!0},e));return r._transform=t,n&&(r._flush=n),r})},{"readable-stream/transform":115,util:32,xtend:117}]},{},[11]);
\ No newline at end of file
diff --git a/dist/pouchdb.js b/dist/pouchdb.js
new file mode 100644
index 0000000..24469be
--- /dev/null
+++ b/dist/pouchdb.js
@@ -0,0 +1,10227 @@
+// PouchDB 3.0.1
+//
+// (c) 2012-2014 Dale Harvey and the PouchDB team
+// PouchDB may be freely distributed under the Apache license, version 2.0.
+// For all details and documentation:
+// http://pouchdb.com
+!function(e){if("object"==typeof exports)module.exports=e();else if("function"==typeof define&&define.amd)define(e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.PouchDB=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
+"use strict";
+
+var utils = _dereq_('./utils');
+var merge = _dereq_('./merge');
+var errors = _dereq_('./deps/errors');
+var EventEmitter = _dereq_('events').EventEmitter;
+var upsert = _dereq_('./deps/upsert');
+var Changes = _dereq_('./changes');
+var Promise = utils.Promise;
+
+/*
+ * A generic pouch adapter
+ */
+
+// returns first element of arr satisfying callback predicate
+function arrayFirst(arr, callback) {
+ for (var i = 0; i < arr.length; i++) {
+ if (callback(arr[i], i) === true) {
+ return arr[i];
+ }
+ }
+ return false;
+}
+
+// Wrapper for functions that call the bulkdocs api with a single doc,
+// if the first result is an error, return an error
+function yankError(callback) {
+ return function (err, results) {
+ if (err || results[0].error) {
+ callback(err || results[0]);
+ } else {
+ callback(null, results[0]);
+ }
+ };
+}
+
+// for every node in a revision tree computes its distance from the closest
+// leaf
+function computeHeight(revs) {
+ var height = {};
+ var edges = [];
+ merge.traverseRevTree(revs, function (isLeaf, pos, id, prnt) {
+ var rev = pos + "-" + id;
+ if (isLeaf) {
+ height[rev] = 0;
+ }
+ if (prnt !== undefined) {
+ edges.push({from: prnt, to: rev});
+ }
+ return rev;
+ });
+
+ edges.reverse();
+ edges.forEach(function (edge) {
+ if (height[edge.from] === undefined) {
+ height[edge.from] = 1 + height[edge.to];
+ } else {
+ height[edge.from] = Math.min(height[edge.from], 1 + height[edge.to]);
+ }
+ });
+ return height;
+}
+
+function allDocsKeysQuery(api, opts, callback) {
+ var keys = ('limit' in opts) ?
+ opts.keys.slice(opts.skip, opts.limit + opts.skip) :
+ (opts.skip > 0) ? opts.keys.slice(opts.skip) : opts.keys;
+ if (opts.descending) {
+ keys.reverse();
+ }
+ if (!keys.length) {
+ return api._allDocs({limit: 0}, callback);
+ }
+ var finalResults = {
+ offset: opts.skip
+ };
+ return Promise.all(keys.map(function (key, i) {
+ var subOpts = utils.extend(true, {key: key, deleted: 'ok'}, opts);
+ ['limit', 'skip', 'keys'].forEach(function (optKey) {
+ delete subOpts[optKey];
+ });
+ return new Promise(function (resolve, reject) {
+ api._allDocs(subOpts, function (err, res) {
+ if (err) {
+ return reject(err);
+ }
+ finalResults.total_rows = res.total_rows;
+ resolve(res.rows[0] || {key: key, error: 'not_found'});
+ });
+ });
+ })).then(function (results) {
+ finalResults.rows = results;
+ return finalResults;
+ });
+}
+
+utils.inherits(AbstractPouchDB, EventEmitter);
+module.exports = AbstractPouchDB;
+
+function AbstractPouchDB() {
+ var self = this;
+ EventEmitter.call(this);
+ self.autoCompact = function (callback) {
+ if (!self.auto_compaction) {
+ return callback;
+ }
+ return function (err, res) {
+ if (err) {
+ callback(err);
+ } else {
+ var count = res.length;
+ var decCount = function () {
+ count--;
+ if (!count) {
+ callback(null, res);
+ }
+ };
+ res.forEach(function (doc) {
+ if (doc.ok && doc.id) { // if no id, then it was a local doc
+ // TODO: we need better error handling
+ self.compactDocument(doc.id, 1, decCount);
+ } else {
+ decCount();
+ }
+ });
+ }
+ };
+ };
+
+ var listeners = 0, changes;
+ var eventNames = ['change', 'delete', 'create', 'update'];
+ this.on('newListener', function (eventName) {
+ if (~eventNames.indexOf(eventName)) {
+ if (listeners) {
+ listeners++;
+ return;
+ } else {
+ listeners++;
+ }
+ } else {
+ return;
+ }
+ var lastChange = 0;
+ changes = this.changes({
+ conflicts: true,
+ include_docs: true,
+ continuous: true,
+ since: 'now',
+ onChange: function (change) {
+ if (change.seq <= lastChange) {
+ return;
+ }
+ lastChange = change.seq;
+ self.emit('change', change);
+ if (change.doc._deleted) {
+ self.emit('delete', change);
+ } else if (change.doc._rev.split('-')[0] === '1') {
+ self.emit('create', change);
+ } else {
+ self.emit('update', change);
+ }
+ }
+ });
+ });
+ this.on('removeListener', function (eventName) {
+ if (~eventNames.indexOf(eventName)) {
+ listeners--;
+ if (listeners) {
+ return;
+ }
+ } else {
+ return;
+ }
+ changes.cancel();
+ });
+}
+
+AbstractPouchDB.prototype.post =
+ utils.adapterFun('post', function (doc, opts, callback) {
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ if (typeof doc !== 'object' || Array.isArray(doc)) {
+ return callback(errors.NOT_AN_OBJECT);
+ }
+ this.bulkDocs({docs: [doc]}, opts,
+ this.autoCompact(yankError(callback)));
+});
+
+AbstractPouchDB.prototype.put =
+ utils.adapterFun('put', utils.getArguments(function (args) {
+ var temp, temptype, opts, callback;
+ var doc = args.shift();
+ var id = '_id' in doc;
+ if (typeof doc !== 'object' || Array.isArray(doc)) {
+ callback = args.pop();
+ return callback(errors.NOT_AN_OBJECT);
+ }
+ doc = utils.clone(doc);
+ while (true) {
+ temp = args.shift();
+ temptype = typeof temp;
+ if (temptype === "string" && !id) {
+ doc._id = temp;
+ id = true;
+ } else if (temptype === "string" && id && !('_rev' in doc)) {
+ doc._rev = temp;
+ } else if (temptype === "object") {
+ opts = temp;
+ } else if (temptype === "function") {
+ callback = temp;
+ }
+ if (!args.length) {
+ break;
+ }
+ }
+ opts = opts || {};
+ var error = utils.invalidIdError(doc._id);
+ if (error) {
+ return callback(error);
+ }
+ if (utils.isLocalId(doc._id) && typeof this._putLocal === 'function') {
+ if (doc._deleted) {
+ return this._removeLocal(doc, callback);
+ } else {
+ return this._putLocal(doc, callback);
+ }
+ }
+ this.bulkDocs({docs: [doc]}, opts,
+ this.autoCompact(yankError(callback)));
+}));
+
+AbstractPouchDB.prototype.putAttachment =
+ utils.adapterFun('putAttachment', function (docId, attachmentId, rev,
+ blob, type, callback) {
+ var api = this;
+ if (typeof type === 'function') {
+ callback = type;
+ type = blob;
+ blob = rev;
+ rev = null;
+ }
+ if (typeof type === 'undefined') {
+ type = blob;
+ blob = rev;
+ rev = null;
+ }
+
+ function createAttachment(doc) {
+ doc._attachments = doc._attachments || {};
+ doc._attachments[attachmentId] = {
+ content_type: type,
+ data: blob
+ };
+ return api.put(doc);
+ }
+
+ return api.get(docId).then(function (doc) {
+ if (doc._rev !== rev) {
+ throw errors.REV_CONFLICT;
+ }
+
+ return createAttachment(doc);
+ }, function (err) {
+ // create new doc
+ if (err.error === errors.MISSING_DOC.error) {
+ return createAttachment({_id: docId});
+ } else {
+ throw err;
+ }
+ });
+});
+
+AbstractPouchDB.prototype.removeAttachment =
+ utils.adapterFun('removeAttachment', function (docId, attachmentId, rev,
+ callback) {
+ var self = this;
+ self.get(docId, function (err, obj) {
+ if (err) {
+ callback(err);
+ return;
+ }
+ if (obj._rev !== rev) {
+ callback(errors.REV_CONFLICT);
+ return;
+ }
+ if (!obj._attachments) {
+ return callback();
+ }
+ delete obj._attachments[attachmentId];
+ if (Object.keys(obj._attachments).length === 0) {
+ delete obj._attachments;
+ }
+ self.put(obj, callback);
+ });
+});
+
+AbstractPouchDB.prototype.remove =
+ utils.adapterFun('remove', function (docOrId, optsOrRev, opts, callback) {
+ var doc;
+ if (typeof optsOrRev === 'string') {
+ // id, rev, opts, callback style
+ doc = {
+ _id: docOrId,
+ _rev: optsOrRev
+ };
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ } else {
+ // doc, opts, callback style
+ doc = docOrId;
+ if (typeof optsOrRev === 'function') {
+ callback = optsOrRev;
+ opts = {};
+ } else {
+ callback = opts;
+ opts = optsOrRev;
+ }
+ }
+ opts = utils.clone(opts || {});
+ opts.was_delete = true;
+ var newDoc = {_id: doc._id, _rev: (doc._rev || opts.rev)};
+ newDoc._deleted = true;
+ if (utils.isLocalId(newDoc._id) && typeof this._removeLocal === 'function') {
+ return this._removeLocal(doc, callback);
+ }
+ this.bulkDocs({docs: [newDoc]}, opts, yankError(callback));
+});
+
+AbstractPouchDB.prototype.revsDiff =
+ utils.adapterFun('revsDiff', function (req, opts, callback) {
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ opts = utils.clone(opts);
+ var ids = Object.keys(req);
+
+ if (!ids.length) {
+ return callback(null, {});
+ }
+
+ var count = 0;
+ var missing = new utils.Map();
+
+ function addToMissing(id, revId) {
+ if (!missing.has(id)) {
+ missing.set(id, {missing: []});
+ }
+ missing.get(id).missing.push(revId);
+ }
+
+ function processDoc(id, rev_tree) {
+ // Is this fast enough? Maybe we should switch to a set simulated by a map
+ var missingForId = req[id].slice(0);
+ merge.traverseRevTree(rev_tree, function (isLeaf, pos, revHash, ctx,
+ opts) {
+ var rev = pos + '-' + revHash;
+ var idx = missingForId.indexOf(rev);
+ if (idx === -1) {
+ return;
+ }
+
+ missingForId.splice(idx, 1);
+ if (opts.status !== 'available') {
+ addToMissing(id, rev);
+ }
+ });
+
+ // Traversing the tree is synchronous, so now `missingForId` contains
+ // revisions that were not found in the tree
+ missingForId.forEach(function (rev) {
+ addToMissing(id, rev);
+ });
+ }
+
+ ids.map(function (id) {
+ this._getRevisionTree(id, function (err, rev_tree) {
+ if (err && err.name === 'not_found' && err.message === 'missing') {
+ missing.set(id, {missing: req[id]});
+ } else if (err) {
+ return callback(err);
+ } else {
+ processDoc(id, rev_tree);
+ }
+
+ if (++count === ids.length) {
+ // convert LazyMap to object
+ var missingObj = {};
+ missing.forEach(function (value, key) {
+ missingObj[key] = value;
+ });
+ return callback(null, missingObj);
+ }
+ });
+ }, this);
+});
+
+// compact one document and fire callback
+// by compacting we mean removing all revisions which
+// are further from the leaf in revision tree than max_height
+AbstractPouchDB.prototype.compactDocument =
+ function (docId, max_height, callback) {
+ var self = this;
+ this._getRevisionTree(docId, function (err, rev_tree) {
+ if (err) {
+ return callback(err);
+ }
+ var height = computeHeight(rev_tree);
+ var candidates = [];
+ var revs = [];
+ Object.keys(height).forEach(function (rev) {
+ if (height[rev] > max_height) {
+ candidates.push(rev);
+ }
+ });
+
+ merge.traverseRevTree(rev_tree, function (isLeaf, pos, revHash, ctx, opts) {
+ var rev = pos + '-' + revHash;
+ if (opts.status === 'available' && candidates.indexOf(rev) !== -1) {
+ opts.status = 'missing';
+ revs.push(rev);
+ }
+ });
+ self._doCompaction(docId, rev_tree, revs, callback);
+ });
+};
+
+// compact the whole database using single document
+// compaction
+AbstractPouchDB.prototype.compact =
+ utils.adapterFun('compact', function (opts, callback) {
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ var self = this;
+ this.changes({complete: function (err, res) {
+ if (err) {
+ callback(); // TODO: silently fail
+ return;
+ }
+ var count = res.results.length;
+ if (!count) {
+ callback();
+ return;
+ }
+ res.results.forEach(function (row) {
+ self.compactDocument(row.id, 0, function () {
+ count--;
+ if (!count) {
+ callback();
+ }
+ });
+ });
+ }});
+});
+
+/* Begin api wrappers. Specific functionality to storage belongs in the
+ _[method] */
+AbstractPouchDB.prototype.get =
+ utils.adapterFun('get', function (id, opts, callback) {
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ if (typeof id !== 'string') {
+ return callback(errors.INVALID_ID);
+ }
+ if (utils.isLocalId(id) && typeof this._getLocal === 'function') {
+ return this._getLocal(id, callback);
+ }
+ var leaves = [], self = this;
+ function finishOpenRevs() {
+ var result = [];
+ var count = leaves.length;
+ if (!count) {
+ return callback(null, result);
+ }
+ // order with open_revs is unspecified
+ leaves.forEach(function (leaf) {
+ self.get(id,
+ {rev: leaf, revs: opts.revs, attachments: opts.attachments},
+ function (err, doc) {
+ if (!err) {
+ result.push({ok: doc});
+ } else {
+ result.push({missing: leaf});
+ }
+ count--;
+ if (!count) {
+ callback(null, result);
+ }
+ });
+ });
+ }
+
+ if (opts.open_revs) {
+ if (opts.open_revs === "all") {
+ this._getRevisionTree(id, function (err, rev_tree) {
+ if (err) {
+ // if there's no such document we should treat this
+ // situation the same way as if revision tree was empty
+ rev_tree = [];
+ }
+ leaves = merge.collectLeaves(rev_tree).map(function (leaf) {
+ return leaf.rev;
+ });
+ finishOpenRevs();
+ });
+ } else {
+ if (Array.isArray(opts.open_revs)) {
+ leaves = opts.open_revs;
+ for (var i = 0; i < leaves.length; i++) {
+ var l = leaves[i];
+ // looks like it's the only thing couchdb checks
+ if (!(typeof(l) === "string" && /^\d+-/.test(l))) {
+ return callback(errors.error(errors.BAD_REQUEST,
+ "Invalid rev format"));
+ }
+ }
+ finishOpenRevs();
+ } else {
+ return callback(errors.error(errors.UNKNOWN_ERROR,
+ 'function_clause'));
+ }
+ }
+ return; // open_revs does not like other options
+ }
+
+ return this._get(id, opts, function (err, result) {
+ opts = utils.clone(opts);
+ if (err) {
+ return callback(err);
+ }
+
+ var doc = result.doc;
+ if (!doc) {
+ // a smoke test for something being very wrong
+ return callback(new Error('no doc!'));
+ }
+ var metadata = result.metadata;
+ var ctx = result.ctx;
+
+ if (opts.conflicts) {
+ var conflicts = merge.collectConflicts(metadata);
+ if (conflicts.length) {
+ doc._conflicts = conflicts;
+ }
+ }
+
+ if (opts.revs || opts.revs_info) {
+ var paths = merge.rootToLeaf(metadata.rev_tree);
+ var path = arrayFirst(paths, function (arr) {
+ return arr.ids.map(function (x) { return x.id; })
+ .indexOf(doc._rev.split('-')[1]) !== -1;
+ });
+
+ var indexOfRev = path.ids.map(function (x) {return x.id; })
+ .indexOf(doc._rev.split('-')[1]) + 1;
+ var howMany = path.ids.length - indexOfRev;
+ path.ids.splice(indexOfRev, howMany);
+ path.ids.reverse();
+
+ if (opts.revs) {
+ doc._revisions = {
+ start: (path.pos + path.ids.length) - 1,
+ ids: path.ids.map(function (rev) {
+ return rev.id;
+ })
+ };
+ }
+ if (opts.revs_info) {
+ var pos = path.pos + path.ids.length;
+ doc._revs_info = path.ids.map(function (rev) {
+ pos--;
+ return {
+ rev: pos + '-' + rev.id,
+ status: rev.opts.status
+ };
+ });
+ }
+ }
+
+ if (opts.local_seq) {
+ doc._local_seq = result.metadata.seq;
+ }
+
+ if (opts.attachments && doc._attachments) {
+ var attachments = doc._attachments;
+ var count = Object.keys(attachments).length;
+ if (count === 0) {
+ return callback(null, doc);
+ }
+ Object.keys(attachments).forEach(function (key) {
+ this._getAttachment(attachments[key],
+ {encode: true, ctx: ctx}, function (err, data) {
+ var att = doc._attachments[key];
+ att.data = data;
+ delete att.stub;
+ if (!--count) {
+ callback(null, doc);
+ }
+ });
+ }, self);
+ } else {
+ if (doc._attachments) {
+ for (var key in doc._attachments) {
+ if (doc._attachments.hasOwnProperty(key)) {
+ doc._attachments[key].stub = true;
+ }
+ }
+ }
+ callback(null, doc);
+ }
+ });
+});
+
+AbstractPouchDB.prototype.getAttachment =
+ utils.adapterFun('getAttachment', function (docId, attachmentId, opts,
+ callback) {
+ var self = this;
+ if (opts instanceof Function) {
+ callback = opts;
+ opts = {};
+ }
+ opts = utils.clone(opts);
+ this._get(docId, opts, function (err, res) {
+ if (err) {
+ return callback(err);
+ }
+ if (res.doc._attachments && res.doc._attachments[attachmentId]) {
+ opts.ctx = res.ctx;
+ self._getAttachment(res.doc._attachments[attachmentId], opts, callback);
+ } else {
+ return callback(errors.MISSING_DOC);
+ }
+ });
+});
+
+AbstractPouchDB.prototype.allDocs =
+ utils.adapterFun('allDocs', function (opts, callback) {
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ opts = utils.clone(opts);
+ opts.skip = typeof opts.skip !== 'undefined' ? opts.skip : 0;
+ if ('keys' in opts) {
+ if (!Array.isArray(opts.keys)) {
+ return callback(new TypeError('options.keys must be an array'));
+ }
+ var incompatibleOpt =
+ ['startkey', 'endkey', 'key'].filter(function (incompatibleOpt) {
+ return incompatibleOpt in opts;
+ })[0];
+ if (incompatibleOpt) {
+ callback(errors.error(errors.QUERY_PARSE_ERROR,
+ 'Query parameter `' + incompatibleOpt +
+ '` is not compatible with multi-get'
+ ));
+ return;
+ }
+ if (this.type() !== 'http') {
+ return allDocsKeysQuery(this, opts, callback);
+ }
+ }
+
+ return this._allDocs(opts, callback);
+});
+
+AbstractPouchDB.prototype.changes = function (opts, callback) {
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ return new Changes(this, opts, callback);
+};
+
+AbstractPouchDB.prototype.close =
+ utils.adapterFun('close', function (callback) {
+ this._closed = true;
+ return this._close(callback);
+});
+
+AbstractPouchDB.prototype.info = utils.adapterFun('info', function (callback) {
+ var self = this;
+ this._info(function (err, info) {
+ if (err) {
+ return callback(err);
+ }
+ // assume we know better than the adapter, unless it informs us
+ info.db_name = info.db_name || self._db_name;
+ callback(null, info);
+ });
+});
+
+AbstractPouchDB.prototype.id = utils.adapterFun('id', function (callback) {
+ return this._id(callback);
+});
+
+AbstractPouchDB.prototype.type = function () {
+ return (typeof this._type === 'function') ? this._type() : this.adapter;
+};
+
+AbstractPouchDB.prototype.bulkDocs =
+ utils.adapterFun('bulkDocs', function (req, opts, callback) {
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+
+ opts = utils.clone(opts);
+
+ if (Array.isArray(req)) {
+ req = {
+ docs: req
+ };
+ }
+
+ if (!req || !req.docs || !Array.isArray(req.docs)) {
+ return callback(errors.MISSING_BULK_DOCS);
+ }
+
+ for (var i = 0; i < req.docs.length; ++i) {
+ if (typeof req.docs[i] !== 'object' || Array.isArray(req.docs[i])) {
+ return callback(errors.NOT_AN_OBJECT);
+ }
+ }
+
+ req = utils.clone(req);
+ if (!('new_edits' in opts)) {
+ if ('new_edits' in req) {
+ opts.new_edits = req.new_edits;
+ } else {
+ opts.new_edits = true;
+ }
+ }
+
+ return this._bulkDocs(req, opts, this.autoCompact(callback));
+});
+
+AbstractPouchDB.prototype.registerDependentDatabase =
+ utils.adapterFun('registerDependentDatabase', function (dependentDb,
+ callback) {
+ var depDB = new this.constructor(dependentDb, {adapter: this._adapter});
+ function diffFun(doc) {
+ doc.dependentDbs = doc.dependentDbs || {};
+ if (doc.dependentDbs[dependentDb]) {
+ return false; // no update required
+ }
+ doc.dependentDbs[dependentDb] = true;
+ return doc;
+ }
+ upsert(this, '_local/_pouch_dependentDbs', diffFun, function (err) {
+ if (err) {
+ return callback(err);
+ }
+ return callback(null, {db: depDB});
+ });
+});
+
+},{"./changes":6,"./deps/errors":11,"./deps/upsert":13,"./merge":18,"./utils":23,"events":27}],2:[function(_dereq_,module,exports){
+"use strict";
+
+var CHANGES_BATCH_SIZE = 25;
+
+var utils = _dereq_('../utils');
+var errors = _dereq_('../deps/errors');
+// parseUri 1.2.2
+// (c) Steven Levithan <stevenlevithan.com>
+// MIT License
+function parseUri(str) {
+ var o = parseUri.options;
+ var m = o.parser[o.strictMode ? "strict" : "loose"].exec(str);
+ var uri = {};
+ var i = 14;
+
+ while (i--) {
+ uri[o.key[i]] = m[i] || "";
+ }
+
+ uri[o.q.name] = {};
+ uri[o.key[12]].replace(o.q.parser, function ($0, $1, $2) {
+ if ($1) {
+ uri[o.q.name][$1] = $2;
+ }
+ });
+
+ return uri;
+}
+
+function encodeDocId(id) {
+ if (/^_(design|local)/.test(id)) {
+ return id;
+ }
+ return encodeURIComponent(id);
+}
+
+parseUri.options = {
+ strictMode: false,
+ key: ["source", "protocol", "authority", "userInfo", "user", "password",
+ "host", "port", "relative", "path", "directory", "file", "query",
+ "anchor"],
+ q: {
+ name: "queryKey",
+ parser: /(?:^|&)([^&=]*)=?([^&]*)/g
+ },
+ parser: {
+ /* jshint maxlen: false */
+ strict: /^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/,
+ loose: /^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/
+ }
+};
+
+// Get all the information you possibly can about the URI given by name and
+// return it as a suitable object.
+function getHost(name, opts) {
+ // If the given name contains "http:"
+ if (/http(s?):/.test(name)) {
+ // Prase the URI into all its little bits
+ var uri = parseUri(name);
+
+ // Store the fact that it is a remote URI
+ uri.remote = true;
+
+ // Store the user and password as a separate auth object
+ if (uri.user || uri.password) {
+ uri.auth = {username: uri.user, password: uri.password};
+ }
+
+ // Split the path part of the URI into parts using '/' as the delimiter
+ // after removing any leading '/' and any trailing '/'
+ var parts = uri.path.replace(/(^\/|\/$)/g, '').split('/');
+
+ // Store the first part as the database name and remove it from the parts
+ // array
+ uri.db = parts.pop();
+
+ // Restore the path by joining all the remaining parts (all the parts
+ // except for the database name) with '/'s
+ uri.path = parts.join('/');
+ opts = opts || {};
+ opts = utils.clone(opts);
+ uri.headers = opts.headers || {};
+
+ if (opts.auth || uri.auth) {
+ var nAuth = opts.auth || uri.auth;
+ var token = utils.btoa(nAuth.username + ':' + nAuth.password);
+ uri.headers.Authorization = 'Basic ' + token;
+ }
+
+ if (opts.headers) {
+ uri.headers = opts.headers;
+ }
+
+ return uri;
+ }
+
+ // If the given name does not contain 'http:' then return a very basic object
+ // with no host, the current path, the given name as the database name and no
+ // username/password
+ return {host: '', path: '/', db: name, auth: false};
+}
+
+// Generate a URL with the host data given by opts and the given path
+function genDBUrl(opts, path) {
+ return genUrl(opts, opts.db + '/' + path);
+}
+
+// Generate a URL with the host data given by opts and the given path
+function genUrl(opts, path) {
+ if (opts.remote) {
+ // If the host already has a path, then we need to have a path delimiter
+ // Otherwise, the path delimiter is the empty string
+ var pathDel = !opts.path ? '' : '/';
+
+ // If the host already has a path, then we need to have a path delimiter
+ // Otherwise, the path delimiter is the empty string
+ return opts.protocol + '://' + opts.host + ':' + opts.port + '/' +
+ opts.path + pathDel + path;
+ }
+
+ return '/' + path;
+}
+// Implements the PouchDB API for dealing with CouchDB instances over HTTP
+function HttpPouch(opts, callback) {
+ // The functions that will be publicly available for HttpPouch
+ var api = this;
+ api.getHost = opts.getHost ? opts.getHost : getHost;
+
+ // Parse the URI given by opts.name into an easy-to-use object
+ var host = api.getHost(opts.name, opts);
+
+ // Generate the database URL based on the host
+ var dbUrl = genDBUrl(host, '');
+
+ api.getUrl = function () {return dbUrl; };
+
+ var ajaxOpts = opts.ajax || {};
+ opts = utils.clone(opts);
+ function ajax(options, callback) {
+ return utils.ajax(utils.extend({}, ajaxOpts, options), callback);
+ }
+
+ // Create a new CouchDB database based on the given opts
+ var createDB = function () {
+ ajax({headers: host.headers, method: 'PUT', url: dbUrl},
+ function (err, ret) {
+ // If we get an "Unauthorized" error
+ if (err && err.status === 401) {
+ // Test if the database already exists
+ ajax({headers: host.headers, method: 'HEAD', url: dbUrl},
+ function (err, ret) {
+ // If there is still an error
+ if (err) {
+ // Give the error to the callback to deal with
+ callback(err);
+ } else {
+ // Continue as if there had been no errors
+ callback(null, api);
+ }
+ });
+ // If there were no errros or if the only error is "Precondition Failed"
+ // (note: "Precondition Failed" occurs when we try to create a database
+ // that already exists)
+ } else if (!err || err.status === 412) {
+ // Continue as if there had been no errors
+ callback(null, api);
+ } else {
+ callback(err);
+ }
+ });
+ };
+ if (!opts.skipSetup) {
+ ajax({headers: host.headers, method: 'GET', url: dbUrl},
+ function (err, ret) {
+ //check if the db exists
+ if (err) {
+ if (err.status === 404) {
+ //if it doesn't, create it
+ createDB();
+ } else {
+ callback(err);
+ }
+ } else {
+ //go do stuff with the db
+ callback(null, api);
+ }
+ });
+ }
+
+ api.type = function () {
+ return 'http';
+ };
+
+ api.id = utils.adapterFun('id', function (callback) {
+ ajax({
+ headers: host.headers,
+ method: 'GET',
+ url: genUrl(host, '')
+ }, function (err, result) {
+ var uuid = (result && result.uuid) ?
+ result.uuid + host.db : genDBUrl(host, '');
+ callback(null, uuid);
+ });
+ });
+
+ api.request = utils.adapterFun('request', function (options, callback) {
+ options.headers = host.headers;
+ options.url = genDBUrl(host, options.url);
+ ajax(options, callback);
+ });
+
+ // Sends a POST request to the host calling the couchdb _compact function
+ // version: The version of CouchDB it is running
+ api.compact = utils.adapterFun('compact', function (opts, callback) {
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ opts = utils.clone(opts);
+ ajax({
+ headers: host.headers,
+ url: genDBUrl(host, '_compact'),
+ method: 'POST'
+ }, function () {
+ function ping() {
+ api.info(function (err, res) {
+ if (!res.compact_running) {
+ callback();
+ } else {
+ setTimeout(ping, opts.interval || 200);
+ }
+ });
+ }
+ // Ping the http if it's finished compaction
+ if (typeof callback === "function") {
+ ping();
+ }
+ });
+ });
+
+ // Calls GET on the host, which gets back a JSON string containing
+ // couchdb: A welcome string
+ // version: The version of CouchDB it is running
+ api._info = function (callback) {
+ ajax({
+ headers: host.headers,
+ method: 'GET',
+ url: genDBUrl(host, '')
+ }, function (err, res) {
+ if (err) {
+ callback(err);
+ } else {
+ res.host = genDBUrl(host, '');
+ callback(null, res);
+ }
+ });
+ };
+
+ // Get the document with the given id from the database given by host.
+ // The id could be solely the _id in the database, or it may be a
+ // _design/ID or _local/ID path
+ api.get = utils.adapterFun('get', function (id, opts, callback) {
+ // If no options were given, set the callback to the second parameter
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ opts = utils.clone(opts);
+ if (opts.auto_encode === undefined) {
+ opts.auto_encode = true;
+ }
+
+ // List of parameters to add to the GET request
+ var params = [];
+
+ // If it exists, add the opts.revs value to the list of parameters.
+ // If revs=true then the resulting JSON will include a field
+ // _revisions containing an array of the revision IDs.
+ if (opts.revs) {
+ params.push('revs=true');
+ }
+
+ // If it exists, add the opts.revs_info value to the list of parameters.
+ // If revs_info=true then the resulting JSON will include the field
+ // _revs_info containing an array of objects in which each object
+ // representing an available revision.
+ if (opts.revs_info) {
+ params.push('revs_info=true');
+ }
+
+ if (opts.local_seq) {
+ params.push('local_seq=true');
+ }
+ // If it exists, add the opts.open_revs value to the list of parameters.
+ // If open_revs=all then the resulting JSON will include all the leaf
+ // revisions. If open_revs=["rev1", "rev2",...] then the resulting JSON
+ // will contain an array of objects containing data of all revisions
+ if (opts.open_revs) {
+ if (opts.open_revs !== "all") {
+ opts.open_revs = JSON.stringify(opts.open_revs);
+ }
+ params.push('open_revs=' + opts.open_revs);
+ }
+
+ // If it exists, add the opts.attachments value to the list of parameters.
+ // If attachments=true the resulting JSON will include the base64-encoded
+ // contents in the "data" property of each attachment.
+ if (opts.attachments) {
+ params.push('attachments=true');
+ }
+
+ // If it exists, add the opts.rev value to the list of parameters.
+ // If rev is given a revision number then get the specified revision.
+ if (opts.rev) {
+ params.push('rev=' + opts.rev);
+ }
+
+ // If it exists, add the opts.conflicts value to the list of parameters.
+ // If conflicts=true then the resulting JSON will include the field
+ // _conflicts containing all the conflicting revisions.
+ if (opts.conflicts) {
+ params.push('conflicts=' + opts.conflicts);
+ }
+
+ // Format the list of parameters into a valid URI query string
+ params = params.join('&');
+ params = params === '' ? '' : '?' + params;
+
+ if (opts.auto_encode) {
+ id = encodeDocId(id);
+ }
+
+ // Set the options for the ajax call
+ var options = {
+ headers: host.headers,
+ method: 'GET',
+ url: genDBUrl(host, id + params)
+ };
+
+ // If the given id contains at least one '/' and the part before the '/'
+ // is NOT "_design" and is NOT "_local"
+ // OR
+ // If the given id contains at least two '/' and the part before the first
+ // '/' is "_design".
+ // TODO This second condition seems strange since if parts[0] === '_design'
+ // then we already know that parts[0] !== '_local'.
+ var parts = id.split('/');
+ if ((parts.length > 1 && parts[0] !== '_design' && parts[0] !== '_local') ||
+ (parts.length > 2 && parts[0] === '_design' && parts[0] !== '_local')) {
+ // Binary is expected back from the server
+ options.binary = true;
+ }
+
+ // Get the document
+ ajax(options, function (err, doc, xhr) {
+ // If the document does not exist, send an error to the callback
+ if (err) {
+ return callback(err);
+ }
+
+ // Send the document to the callback
+ callback(null, doc, xhr);
+ });
+ });
+
+ // Delete the document given by doc from the database given by host.
+ api.remove = utils.adapterFun('remove', function (docOrId, optsOrRev, opts, callback) {
+ var doc;
+ if (typeof optsOrRev === 'string') {
+ // id, rev, opts, callback style
+ doc = {
+ _id: docOrId,
+ _rev: optsOrRev
+ };
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ } else {
+ // doc, opts, callback style
+ doc = docOrId;
+ if (typeof optsOrRev === 'function') {
+ callback = optsOrRev;
+ opts = {};
+ } else {
+ callback = opts;
+ opts = optsOrRev;
+ }
+ }
+
+ var rev = (doc._rev || opts.rev);
+
+ // Delete the document
+ ajax({
+ headers: host.headers,
+ method: 'DELETE',
+ url: genDBUrl(host, encodeDocId(doc._id)) + '?rev=' + rev
+ }, callback);
+ });
+
+ // Get the attachment
+ api.getAttachment =
+ utils.adapterFun('getAttachment', function (docId, attachmentId, opts,
+ callback) {
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ opts = utils.clone(opts);
+ if (opts.auto_encode === undefined) {
+ opts.auto_encode = true;
+ }
+ if (opts.auto_encode) {
+ docId = encodeDocId(docId);
+ }
+ opts.auto_encode = false;
+ api.get(docId + '/' + attachmentId, opts, callback);
+ });
+
+ // Remove the attachment given by the id and rev
+ api.removeAttachment =
+ utils.adapterFun('removeAttachment', function (docId, attachmentId, rev,
+ callback) {
+ ajax({
+ headers: host.headers,
+ method: 'DELETE',
+ url: genDBUrl(host, encodeDocId(docId) + '/' + attachmentId) + '?rev=' +
+ rev
+ }, callback);
+ });
+
+ // Add the attachment given by blob and its contentType property
+ // to the document with the given id, the revision given by rev, and
+ // add it to the database given by host.
+ api.putAttachment =
+ utils.adapterFun('putAttachment', function (docId, attachmentId, rev, blob,
+ type, callback) {
+ if (typeof type === 'function') {
+ callback = type;
+ type = blob;
+ blob = rev;
+ rev = null;
+ }
+ if (typeof type === 'undefined') {
+ type = blob;
+ blob = rev;
+ rev = null;
+ }
+ var id = encodeDocId(docId) + '/' + attachmentId;
+ var url = genDBUrl(host, id);
+ if (rev) {
+ url += '?rev=' + rev;
+ }
+
+ var opts = {
+ headers: utils.clone(host.headers),
+ method: 'PUT',
+ url: url,
+ processData: false,
+ body: blob,
+ timeout: 60000
+ };
+ opts.headers['Content-Type'] = type;
+ // Add the attachment
+ ajax(opts, callback);
+ });
+
+ // Add the document given by doc (in JSON string format) to the database
+ // given by host. This fails if the doc has no _id field.
+ api.put = utils.adapterFun('put', utils.getArguments(function (args) {
+ var temp, temptype, opts, callback;
+ var doc = args.shift();
+ var id = '_id' in doc;
+ if (typeof doc !== 'object' || Array.isArray(doc)) {
+ callback = args.pop();
+ return callback(errors.NOT_AN_OBJECT);
+ }
+ doc = utils.clone(doc);
+ while (true) {
+ temp = args.shift();
+ temptype = typeof temp;
+ if (temptype === "string" && !id) {
+ doc._id = temp;
+ id = true;
+ } else if (temptype === "string" && id && !('_rev' in doc)) {
+ doc._rev = temp;
+ } else if (temptype === "object") {
+ opts = utils.clone(temp);
+ } else if (temptype === "function") {
+ callback = temp;
+ }
+ if (!args.length) {
+ break;
+ }
+ }
+ opts = opts || {};
+ var error = utils.invalidIdError(doc._id);
+ if (error) {
+ return callback(error);
+ }
+
+ // List of parameter to add to the PUT request
+ var params = [];
+
+ // If it exists, add the opts.new_edits value to the list of parameters.
+ // If new_edits = false then the database will NOT assign this document a
+ // new revision number
+ if (opts && typeof opts.new_edits !== 'undefined') {
+ params.push('new_edits=' + opts.new_edits);
+ }
+
+ // Format the list of parameters into a valid URI query string
+ params = params.join('&');
+ if (params !== '') {
+ params = '?' + params;
+ }
+
+ // Add the document
+ ajax({
+ headers: host.headers,
+ method: 'PUT',
+ url: genDBUrl(host, encodeDocId(doc._id)) + params,
+ body: doc
+ }, function (err, res) {
+ if (err) {
+ return callback(err);
+ }
+ res.ok = true;
+ callback(null, res);
+ });
+ }));
+
+ // Add the document given by doc (in JSON string format) to the database
+ // given by host. This does not assume that doc is a new document
+ // (i.e. does not have a _id or a _rev field.)
+ api.post = utils.adapterFun('post', function (doc, opts, callback) {
+ // If no options were given, set the callback to be the second parameter
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ opts = utils.clone(opts);
+ if (typeof doc !== 'object') {
+ return callback(errors.NOT_AN_OBJECT);
+ }
+ if (! ("_id" in doc)) {
+ doc._id = utils.uuid();
+ }
+ api.put(doc, opts, function (err, res) {
+ if (err) {
+ return callback(err);
+ }
+ res.ok = true;
+ callback(null, res);
+ });
+ });
+
+ // Update/create multiple documents given by req in the database
+ // given by host.
+ api._bulkDocs = function (req, opts, callback) {
+ // If opts.new_edits exists add it to the document data to be
+ // send to the database.
+ // If new_edits=false then it prevents the database from creating
+ // new revision numbers for the documents. Instead it just uses
+ // the old ones. This is used in database replication.
+ if (typeof opts.new_edits !== 'undefined') {
+ req.new_edits = opts.new_edits;
+ }
+
+ // Update/create the documents
+ ajax({
+ headers: host.headers,
+ method: 'POST',
+ url: genDBUrl(host, '_bulk_docs'),
+ body: req
+ }, function (err, results) {
+ if (err) {
+ return callback(err);
+ }
+ results.forEach(function (result) {
+ result.ok = true; // smooths out cloudant not adding this
+ });
+ callback(null, results);
+ });
+ };
+
+ // Get a listing of the documents in the database given
+ // by host and ordered by increasing id.
+ api.allDocs = utils.adapterFun('allDocs', function (opts, callback) {
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ opts = utils.clone(opts);
+ // List of parameters to add to the GET request
+ var params = [];
+ var body;
+ var method = 'GET';
+
+ // TODO I don't see conflicts as a valid parameter for a
+ // _all_docs request
+ // (see http://wiki.apache.org/couchdb/HTTP_Document_API#all_docs)
+ if (opts.conflicts) {
+ params.push('conflicts=true');
+ }
+
+ // If opts.descending is truthy add it to params
+ if (opts.descending) {
+ params.push('descending=true');
+ }
+
+ // If opts.include_docs exists, add the include_docs value to the
+ // list of parameters.
+ // If include_docs=true then include the associated document with each
+ // result.
+ if (opts.include_docs) {
+ params.push('include_docs=true');
+ }
+
+ if (opts.key) {
+ params.push('key=' + encodeURIComponent(JSON.stringify(opts.key)));
+ }
+
+ // If opts.startkey exists, add the startkey value to the list of
+ // parameters.
+ // If startkey is given then the returned list of documents will
+ // start with the document whose id is startkey.
+ if (opts.startkey) {
+ params.push('startkey=' +
+ encodeURIComponent(JSON.stringify(opts.startkey)));
+ }
+
+ // If opts.endkey exists, add the endkey value to the list of parameters.
+ // If endkey is given then the returned list of docuemnts will
+ // end with the document whose id is endkey.
+ if (opts.endkey) {
+ params.push('endkey=' + encodeURIComponent(JSON.stringify(opts.endkey)));
+ }
+
+ if (typeof opts.inclusive_end !== 'undefined') {
+ params.push('inclusive_end=' + !!opts.inclusive_end);
+ }
+
+ // If opts.limit exists, add the limit value to the parameter list.
+ if (typeof opts.limit !== 'undefined') {
+ params.push('limit=' + opts.limit);
+ }
+
+ if (typeof opts.skip !== 'undefined') {
+ params.push('skip=' + opts.skip);
+ }
+
+ // Format the list of parameters into a valid URI query string
+ params = params.join('&');
+ if (params !== '') {
+ params = '?' + params;
+ }
+
+ if (typeof opts.keys !== 'undefined') {
+
+ var MAX_URL_LENGTH = 2000;
+ // according to http://stackoverflow.com/a/417184/680742,
+ // the de factor URL length limit is 2000 characters
+
+ var keysAsString =
+ 'keys=' + encodeURIComponent(JSON.stringify(opts.keys));
+ if (keysAsString.length + params.length + 1 <= MAX_URL_LENGTH) {
+ // If the keys are short enough, do a GET. we do this to work around
+ // Safari not understanding 304s on POSTs (see issue #1239)
+ params += (params.indexOf('?') !== -1 ? '&' : '?') + keysAsString;
+ } else {
+ // If keys are too long, issue a POST request to circumvent GET
+ // query string limits
+ // see http://wiki.apache.org/couchdb/HTTP_view_API#Querying_Options
+ method = 'POST';
+ body = JSON.stringify({keys: opts.keys});
+ }
+ }
+
+ // Get the document listing
+ ajax({
+ headers: host.headers,
+ method: method,
+ url: genDBUrl(host, '_all_docs' + params),
+ body: body
+ }, callback);
+ });
+
+ // Get a list of changes made to documents in the database given by host.
+ // TODO According to the README, there should be two other methods here,
+ // api.changes.addListener and api.changes.removeListener.
+ api._changes = function (opts) {
+ // We internally page the results of a changes request, this means
+ // if there is a large set of changes to be returned we can start
+ // processing them quicker instead of waiting on the entire
+ // set of changes to return and attempting to process them at once
+ var batchSize = 'batch_size' in opts ? opts.batch_size : CHANGES_BATCH_SIZE;
+
+ opts = utils.clone(opts);
+ opts.timeout = opts.timeout || 30 * 1000;
+
+ // We give a 5 second buffer for CouchDB changes to respond with
+ // an ok timeout
+ var params = { timeout: opts.timeout - (5 * 1000) };
+ var limit = (typeof opts.limit !== 'undefined') ? opts.limit : false;
+ if (limit === 0) {
+ limit = 1;
+ }
+ var returnDocs;
+ if ('returnDocs' in opts) {
+ returnDocs = opts.returnDocs;
+ } else {
+ returnDocs = true;
+ }
+ //
+ var leftToFetch = limit;
+
+ if (opts.style) {
+ params.style = opts.style;
+ }
+
+ if (opts.include_docs || opts.filter && typeof opts.filter === 'function') {
+ params.include_docs = true;
+ }
+
+ if (opts.continuous) {
+ params.feed = 'longpoll';
+ }
+
+ if (opts.conflicts) {
+ params.conflicts = true;
+ }
+
+ if (opts.descending) {
+ params.descending = true;
+ }
+
+ if (opts.filter && typeof opts.filter === 'string') {
+ params.filter = opts.filter;
+ if (opts.filter === '_view' &&
+ opts.view &&
+ typeof opts.view === 'string') {
+ params.view = opts.view;
+ }
+ }
+
+ // If opts.query_params exists, pass it through to the changes request.
+ // These parameters may be used by the filter on the source database.
+ if (opts.query_params && typeof opts.query_params === 'object') {
+ for (var param_name in opts.query_params) {
+ if (opts.query_params.hasOwnProperty(param_name)) {
+ params[param_name] = opts.query_params[param_name];
+ }
+ }
+ }
+
+ var xhr;
+ var lastFetchedSeq;
+
+ // Get all the changes starting wtih the one immediately after the
+ // sequence number given by since.
+ var fetch = function (since, callback) {
+ if (opts.aborted) {
+ return;
+ }
+ params.since = since;
+ if (opts.descending) {
+ if (limit) {
+ params.limit = leftToFetch;
+ }
+ } else {
+ params.limit = (!limit || leftToFetch > batchSize) ?
+ batchSize : leftToFetch;
+ }
+
+ var paramStr = '?' + Object.keys(params).map(function (k) {
+ return k + '=' + params[k];
+ }).join('&');
+
+ // Set the options for the ajax call
+ var xhrOpts = {
+ headers: host.headers,
+ method: 'GET',
+ url: genDBUrl(host, '_changes' + paramStr),
+ // _changes can take a long time to generate, especially when filtered
+ timeout: opts.timeout
+ };
+ lastFetchedSeq = since;
+
+ if (opts.aborted) {
+ return;
+ }
+
+ // Get the changes
+ xhr = ajax(xhrOpts, callback);
+ };
+
+ // If opts.since exists, get all the changes from the sequence
+ // number given by opts.since. Otherwise, get all the changes
+ // from the sequence number 0.
+ var fetchTimeout = 10;
+ var fetchRetryCount = 0;
+
+ var results = {results: []};
+
+ var fetched = function (err, res) {
+ if (opts.aborted) {
+ return;
+ }
+ var raw_results_length = 0;
+ // If the result of the ajax call (res) contains changes (res.results)
+ if (res && res.results) {
+ raw_results_length = res.results.length;
+ results.last_seq = res.last_seq;
+ // For each change
+ var req = {};
+ req.query = opts.query_params;
+ res.results = res.results.filter(function (c) {
+ leftToFetch--;
+ var ret = utils.filterChange(opts)(c);
+ if (ret) {
+ if (returnDocs) {
+ results.results.push(c);
+ }
+ utils.call(opts.onChange, c);
+ }
+ return ret;
+ });
+ } else if (err) {
+ // In case of an error, stop listening for changes and call
+ // opts.complete
+ opts.aborted = true;
+ utils.call(opts.complete, err);
+ return;
+ }
+
+ // The changes feed may have timed out with no results
+ // if so reuse last update sequence
+ if (res && res.last_seq) {
+ lastFetchedSeq = res.last_seq;
+ }
+
+ var finished = (limit && leftToFetch <= 0) ||
+ (res && raw_results_length < batchSize) ||
+ (opts.descending);
+
+ if ((opts.continuous && !(limit && leftToFetch <= 0)) || !finished) {
+ // Increase retry delay exponentially as long as errors persist
+ if (err) {
+ fetchRetryCount += 1;
+ } else {
+ fetchRetryCount = 0;
+ }
+ var timeoutMultiplier = 1 << fetchRetryCount;
+ var retryWait = fetchTimeout * timeoutMultiplier;
+ var maximumWait = opts.maximumWait || 30000;
+
+ if (retryWait > maximumWait) {
+ utils.call(opts.complete, err || errors.UNKNOWN_ERROR);
+ return;
+ }
+
+ // Queue a call to fetch again with the newest sequence number
+ setTimeout(function () { fetch(lastFetchedSeq, fetched); }, retryWait);
+ } else {
+ // We're done, call the callback
+ utils.call(opts.complete, null, results);
+ }
+ };
+
+ fetch(opts.since || 0, fetched);
+
+ // Return a method to cancel this method from processing any more
+ return {
+ cancel: function () {
+ opts.aborted = true;
+ if (xhr) {
+ xhr.abort();
+ }
+ }
+ };
+ };
+
+ // Given a set of document/revision IDs (given by req), tets the subset of
+ // those that do NOT correspond to revisions stored in the database.
+ // See http://wiki.apache.org/couchdb/HttpPostRevsDiff
+ api.revsDiff = utils.adapterFun('revsDiff', function (req, opts, callback) {
+ // If no options were given, set the callback to be the second parameter
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+
+ // Get the missing document/revision IDs
+ ajax({
+ headers: host.headers,
+ method: 'POST',
+ url: genDBUrl(host, '_revs_diff'),
+ body: JSON.stringify(req)
+ }, callback);
+ });
+
+ api._close = function (callback) {
+ callback();
+ };
+
+ api.destroy = utils.adapterFun('destroy', function (callback) {
+ ajax({
+ url: genDBUrl(host, ''),
+ method: 'DELETE',
+ headers: host.headers
+ }, function (err, resp) {
+ if (err) {
+ api.emit('error', err);
+ callback(err);
+ } else {
+ api.emit('destroyed');
+ callback(null, resp);
+ }
+ });
+ });
+}
+
+// Delete the HttpPouch specified by the given name.
+HttpPouch.destroy = utils.toPromise(function (name, opts, callback) {
+ var host = getHost(name, opts);
+ opts = opts || {};
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ opts = utils.clone(opts);
+ opts.headers = host.headers;
+ opts.method = 'DELETE';
+ opts.url = genDBUrl(host, '');
+ var ajaxOpts = opts.ajax || {};
+ opts = utils.extend({}, opts, ajaxOpts);
+ utils.ajax(opts, callback);
+});
+
+// HttpPouch is a valid adapter.
+HttpPouch.valid = function () {
+ return true;
+};
+
+module.exports = HttpPouch;
+
+},{"../deps/errors":11,"../utils":23}],3:[function(_dereq_,module,exports){
+(function (process,global){
+'use strict';
+
+var utils = _dereq_('../utils');
+var merge = _dereq_('../merge');
+var errors = _dereq_('../deps/errors');
+
+var cachedDBs = {};
+var taskQueue = {
+ running: false,
+ queue: []
+};
+
+function tryCode(fun, that, args) {
+ try {
+ fun.apply(that, args);
+ } catch (err) { // shouldn't happen
+ if (window.PouchDB) {
+ window.PouchDB.emit('error', err);
+ }
+ }
+}
+
+function applyNext() {
+ if (taskQueue.running || !taskQueue.queue.length) {
+ return;
+ }
+ taskQueue.running = true;
+ var item = taskQueue.queue.shift();
+ item.action(function (err, res) {
+ tryCode(item.callback, this, [err, res]);
+ taskQueue.running = false;
+ process.nextTick(applyNext);
+ });
+}
+
+function idbError(callback) {
+ return function (event) {
+ var message = (event.target && event.target.error &&
+ event.target.error.name) || event.target;
+ callback(errors.error(errors.IDB_ERROR, message, event.type));
+ };
+}
+
+function isModernIdb() {
+ // check for outdated implementations of IDB
+ // that rely on the setVersion method instead of onupgradeneeded (issue #1207)
+
+ // cache based on appVersion, in case the browser is updated
+ var cacheKey = "_pouch__checkModernIdb_" +
+ (global.navigator && global.navigator.appVersion);
+ var cached = utils.hasLocalStorage() && global.localStorage[cacheKey];
+ if (cached) {
+ return JSON.parse(cached);
+ }
+
+ var dbName = '_pouch__checkModernIdb';
+ var result = global.indexedDB.open(dbName, 1).onupgradeneeded === null;
+
+ if (global.indexedDB.deleteDatabase) {
+ global.indexedDB.deleteDatabase(dbName); // db no longer needed
+ }
+ if (utils.hasLocalStorage()) {
+ global.localStorage[cacheKey] = JSON.stringify(result); // cache
+ }
+ return result;
+}
+
+function IdbPouch(opts, callback) {
+ var api = this;
+
+ taskQueue.queue.push({
+ action: function (thisCallback) {
+ init(api, opts, thisCallback);
+ },
+ callback: callback
+ });
+ applyNext();
+}
+
+function init(api, opts, callback) {
+
+ // IndexedDB requires a versioned database structure, so we use the
+ // version here to manage migrations.
+ var ADAPTER_VERSION = 3;
+
+ // The object stores created for each database
+ // DOC_STORE stores the document meta data, its revision history and state
+ // Keyed by document id
+ var DOC_STORE = 'document-store';
+ // BY_SEQ_STORE stores a particular version of a document, keyed by its
+ // sequence id
+ var BY_SEQ_STORE = 'by-sequence';
+ // Where we store attachments
+ var ATTACH_STORE = 'attach-store';
+ // Where we store database-wide meta data in a single record
+ // keyed by id: META_STORE
+ var META_STORE = 'meta-store';
+ // Where we store local documents
+ var LOCAL_STORE = 'local-store';
+ // Where we detect blob support
+ var DETECT_BLOB_SUPPORT_STORE = 'detect-blob-support';
+
+ var name = opts.name;
+
+ var blobSupport = null;
+ var instanceId = null;
+ var idStored = false;
+ var idb = null;
+ var docCount = -1;
+
+ function createSchema(db) {
+ db.createObjectStore(DOC_STORE, {keyPath : 'id'})
+ .createIndex('seq', 'seq', {unique: true});
+ db.createObjectStore(BY_SEQ_STORE, {autoIncrement: true})
+ .createIndex('_doc_id_rev', '_doc_id_rev', {unique: true});
+ db.createObjectStore(ATTACH_STORE, {keyPath: 'digest'});
+ db.createObjectStore(META_STORE, {keyPath: 'id', autoIncrement: false});
+ db.createObjectStore(DETECT_BLOB_SUPPORT_STORE);
+ }
+
+ // migration to version 2
+ // unfortunately "deletedOrLocal" is a misnomer now that we no longer
+ // store local docs in the main doc-store, but whaddyagonnado
+ function addDeletedOrLocalIndex(e, callback) {
+ var transaction = e.currentTarget.transaction;
+ var docStore = transaction.objectStore(DOC_STORE);
+ docStore.createIndex('deletedOrLocal', 'deletedOrLocal', {unique : false});
+
+ docStore.openCursor().onsuccess = function (event) {
+ var cursor = event.target.result;
+ if (cursor) {
+ var metadata = cursor.value;
+ var deleted = utils.isDeleted(metadata);
+ metadata.deletedOrLocal = deleted ? "1" : "0";
+ docStore.put(metadata);
+ cursor["continue"]();
+ } else {
+ callback(transaction);
+ }
+ };
+ }
+
+ // migrations to get to version 3
+
+ function createLocalStoreSchema(db) {
+ db.createObjectStore(LOCAL_STORE, {keyPath: '_id'})
+ .createIndex('_doc_id_rev', '_doc_id_rev', {unique: true});
+ }
+
+ function migrateLocalStore(e, tx) {
+ tx = tx || e.currentTarget.transaction;
+ var localStore = tx.objectStore(LOCAL_STORE);
+ var docStore = tx.objectStore(DOC_STORE);
+ var seqStore = tx.objectStore(BY_SEQ_STORE);
+
+ var cursor = docStore.openCursor();
+ cursor.onsuccess = function (event) {
+ var cursor = event.target.result;
+ if (cursor) {
+ var metadata = cursor.value;
+ var docId = metadata.id;
+ var local = utils.isLocalId(docId);
+ var rev = merge.winningRev(metadata);
+ if (local) {
+ var docIdRev = docId + "::" + rev;
+ // remove all seq entries
+ // associated with this docId
+ var start = docId + "::";
+ var end = docId + "::~";
+ var index = seqStore.index('_doc_id_rev');
+ var range = global.IDBKeyRange.bound(start, end, false, false);
+ var seqCursor = index.openCursor(range);
+ seqCursor.onsuccess = function (e) {
+ seqCursor = e.target.result;
+ if (!seqCursor) {
+ // done
+ docStore["delete"](cursor.primaryKey);
+ cursor["continue"]();
+ } else {
+ var data = seqCursor.value;
+ if (data._doc_id_rev === docIdRev) {
+ localStore.put(data);
+ }
+ seqStore["delete"](seqCursor.primaryKey);
+ seqCursor["continue"]();
+ }
+ };
+ } else {
+ cursor["continue"]();
+ }
+ }
+ };
+ }
+
+ api.type = function () {
+ return 'idb';
+ };
+
+ api._id = utils.toPromise(function (callback) {
+ callback(null, instanceId);
+ });
+
+ api._bulkDocs = function idb_bulkDocs(req, opts, callback) {
+ var newEdits = opts.new_edits;
+ var userDocs = req.docs;
+ // Parse the docs, give them a sequence number for the result
+ var docInfos = userDocs.map(function (doc, i) {
+ if (doc._id && utils.isLocalId(doc._id)) {
+ return doc;
+ }
+ var newDoc = utils.parseDoc(doc, newEdits);
+ newDoc._bulk_seq = i;
+ return newDoc;
+ });
+
+ var docInfoErrors = docInfos.filter(function (docInfo) {
+ return docInfo.error;
+ });
+ if (docInfoErrors.length) {
+ return callback(docInfoErrors[0]);
+ }
+
+ var results = new Array(docInfos.length);
+ var fetchedDocs = new utils.Map();
+ var updateSeq = 0;
+ var numDocsWritten = 0;
+
+ function writeMetaData(e) {
+ var meta = e.target.result;
+ meta.updateSeq = (meta.updateSeq || 0) + updateSeq;
+ txn.objectStore(META_STORE).put(meta);
+ }
+
+ function checkDoneWritingDocs() {
+ if (++numDocsWritten === docInfos.length) {
+ txn.objectStore(META_STORE).get(META_STORE).onsuccess = writeMetaData;
+ }
+ }
+
+ function processDocs() {
+ if (!docInfos.length) {
+ return;
+ }
+
+ var idsToDocs = new utils.Map();
+
+ docInfos.forEach(function (currentDoc, resultsIdx) {
+ if (currentDoc._id && utils.isLocalId(currentDoc._id)) {
+ api[currentDoc._deleted ? '_removeLocal' : '_putLocal'](
+ currentDoc, {ctx: txn}, function (err, resp) {
+ if (err) {
+ results[resultsIdx] = err;
+ } else {
+ results[resultsIdx] = {};
+ }
+ checkDoneWritingDocs();
+ });
+ return;
+ }
+
+ var id = currentDoc.metadata.id;
+ if (idsToDocs.has(id)) {
+ idsToDocs.get(id).push([currentDoc, resultsIdx]);
+ } else {
+ idsToDocs.set(id, [[currentDoc, resultsIdx]]);
+ }
+ });
+
+ // in the case of new_edits, the user can provide multiple docs
+ // with the same id. these need to be processed sequentially
+ idsToDocs.forEach(function (docs, id) {
+ var numDone = 0;
+
+ function docWritten() {
+ checkDoneWritingDocs();
+ if (++numDone < docs.length) {
+ nextDoc();
+ }
+ }
+ function nextDoc() {
+ var value = docs[numDone];
+ var currentDoc = value[0];
+ var resultsIdx = value[1];
+
+ if (fetchedDocs.has(id)) {
+ updateDoc(fetchedDocs.get(id), currentDoc, resultsIdx, docWritten);
+ } else {
+ insertDoc(currentDoc, resultsIdx, docWritten);
+ }
+ }
+ nextDoc();
+ });
+ }
+
+ function fetchExistingDocs(callback) {
+ if (!docInfos.length) {
+ return callback();
+ }
+
+ var numFetched = 0;
+
+ function checkDone() {
+ if (++numFetched === docInfos.length) {
+ callback();
+ }
+ }
+
+ docInfos.forEach(function (docInfo) {
+ if (docInfo._id && utils.isLocalId(docInfo._id)) {
+ return checkDone(); // skip local docs
+ }
+ var id = docInfo.metadata.id;
+ var req = txn.objectStore(DOC_STORE).get(id);
+ req.onsuccess = function process_docRead(event) {
+ var metadata = event.target.result;
+ if (metadata) {
+ fetchedDocs.set(id, metadata);
+ }
+ checkDone();
+ };
+ });
+ }
+
+ function complete() {
+ var aresults = results.map(function (result) {
+ if (result._bulk_seq) {
+ delete result._bulk_seq;
+ } else if (!Object.keys(result).length) {
+ return {
+ ok: true
+ };
+ }
+ if (result.error) {
+ return result;
+ }
+
+ var metadata = result.metadata;
+ var rev = merge.winningRev(metadata);
+
+ return {
+ ok: true,
+ id: metadata.id,
+ rev: rev
+ };
+ });
+ IdbPouch.Changes.notify(name);
+ docCount = -1; // invalidate
+ callback(null, aresults);
+ }
+
+ function preprocessAttachment(att, finish) {
+ if (att.stub) {
+ return finish();
+ }
+ if (typeof att.data === 'string') {
+ var data;
+ try {
+ data = atob(att.data);
+ } catch (e) {
+ var err = errors.error(errors.BAD_ARG,
+ "Attachments need to be base64 encoded");
+ return callback(err);
+ }
+ if (blobSupport) {
+ var type = att.content_type;
+ data = utils.fixBinary(data);
+ att.data = utils.createBlob([data], {type: type});
+ }
+ utils.MD5(data).then(function (result) {
+ att.digest = 'md5-' + result;
+ finish();
+ });
+ return;
+ }
+ var reader = new FileReader();
+ reader.onloadend = function (e) {
+ var binary = utils.arrayBufferToBinaryString(this.result);
+ if (!blobSupport) {
+ att.data = btoa(binary);
+ }
+ utils.MD5(binary).then(function (result) {
+ att.digest = 'md5-' + result;
+ finish();
+ });
+ };
+ reader.readAsArrayBuffer(att.data);
+ }
+
+ function preprocessAttachments(callback) {
+ if (!docInfos.length) {
+ return callback();
+ }
+
+ var docv = 0;
+ docInfos.forEach(function (docInfo) {
+ var attachments = docInfo.data && docInfo.data._attachments ?
+ Object.keys(docInfo.data._attachments) : [];
+
+ if (!attachments.length) {
+ return done();
+ }
+
+ var recv = 0;
+ function attachmentProcessed() {
+ recv++;
+ if (recv === attachments.length) {
+ done();
+ }
+ }
+
+ for (var key in docInfo.data._attachments) {
+ if (docInfo.data._attachments.hasOwnProperty(key)) {
+ preprocessAttachment(docInfo.data._attachments[key],
+ attachmentProcessed);
+ }
+ }
+ });
+
+ function done() {
+ docv++;
+ if (docInfos.length === docv) {
+ callback();
+ }
+ }
+ }
+
+ function writeDoc(docInfo, winningRev, deleted, callback, resultsIdx) {
+ var err = null;
+ var recv = 0;
+ docInfo.data._id = docInfo.metadata.id;
+ docInfo.data._rev = docInfo.metadata.rev;
+
+ if (deleted) {
+ docInfo.data._deleted = true;
+ }
+
+ var attachments = docInfo.data._attachments ?
+ Object.keys(docInfo.data._attachments) : [];
+
+ function collectResults(attachmentErr) {
+ if (!err) {
+ if (attachmentErr) {
+ err = attachmentErr;
+ callback(err);
+ } else if (recv === attachments.length) {
+ finish();
+ }
+ }
+ }
+
+ function attachmentSaved(err) {
+ recv++;
+ collectResults(err);
+ }
+
+ for (var key in docInfo.data._attachments) {
+ if (!docInfo.data._attachments[key].stub) {
+ var data = docInfo.data._attachments[key].data;
+ delete docInfo.data._attachments[key].data;
+ var digest = docInfo.data._attachments[key].digest;
+ saveAttachment(docInfo, digest, data, attachmentSaved);
+ } else {
+ recv++;
+ collectResults();
+ }
+ }
+
+ function finish() {
+ updateSeq++;
+ docInfo.data._doc_id_rev = docInfo.data._id + "::" + docInfo.data._rev;
+ var seqStore = txn.objectStore(BY_SEQ_STORE);
+ var index = seqStore.index('_doc_id_rev');
+
+ function afterPut(e) {
+ var metadata = docInfo.metadata;
+ metadata.seq = e.target.result;
+ // Current _rev is calculated from _rev_tree on read
+ delete metadata.rev;
+ metadata.deletedOrLocal = deleted ? "1" : "0";
+ metadata.winningRev = winningRev;
+ var metaDataReq = txn.objectStore(DOC_STORE).put(metadata);
+ metaDataReq.onsuccess = function () {
+ delete metadata.deletedOrLocal;
+ delete metadata.winningRev;
+ results[resultsIdx] = docInfo;
+ fetchedDocs.set(docInfo.metadata.id, docInfo.metadata);
+ utils.call(callback);
+ };
+ }
+
+ var putReq = seqStore.put(docInfo.data);
+
+ putReq.onsuccess = afterPut;
+ putReq.onerror = function (e) {
+ // ConstraintError, need to update, not put (see #1638 for details)
+ e.preventDefault(); // avoid transaction abort
+ e.stopPropagation(); // avoid transaction onerror
+ var getKeyReq = index.getKey(docInfo.data._doc_id_rev);
+ getKeyReq.onsuccess = function (e) {
+ var putReq = seqStore.put(docInfo.data, e.target.result);
+ updateSeq--; // discount, since it's an update, not a new seq
+ putReq.onsuccess = afterPut;
+ };
+ };
+ }
+
+ if (!attachments.length) {
+ finish();
+ }
+ }
+
+ function updateDoc(oldDoc, docInfo, resultsIdx, callback) {
+ var merged =
+ merge.merge(oldDoc.rev_tree, docInfo.metadata.rev_tree[0], 1000);
+ var wasPreviouslyDeleted = utils.isDeleted(oldDoc);
+ var deleted = utils.isDeleted(docInfo.metadata);
+ var inConflict = (wasPreviouslyDeleted && deleted && newEdits) ||
+ (!wasPreviouslyDeleted && newEdits && merged.conflicts !== 'new_leaf');
+
+ if (inConflict) {
+ results[resultsIdx] = makeErr(errors.REV_CONFLICT, docInfo._bulk_seq);
+ return callback();
+ }
+
+ docInfo.metadata.rev_tree = merged.tree;
+
+ // recalculate
+ var winningRev = merge.winningRev(docInfo.metadata);
+ deleted = utils.isDeleted(docInfo.metadata, winningRev);
+
+ writeDoc(docInfo, winningRev, deleted, callback, resultsIdx);
+ }
+
+ function insertDoc(docInfo, resultsIdx, callback) {
+ var winningRev = merge.winningRev(docInfo.metadata);
+ var deleted = utils.isDeleted(docInfo.metadata, winningRev);
+ // Cant insert new deleted documents
+ if ('was_delete' in opts && deleted) {
+ results[resultsIdx] = errors.MISSING_DOC;
+ return callback();
+ }
+
+ writeDoc(docInfo, winningRev, deleted, callback, resultsIdx);
+ }
+
+ // Insert sequence number into the error so we can sort later
+ function makeErr(err, seq) {
+ err._bulk_seq = seq;
+ return err;
+ }
+
+ function saveAttachment(docInfo, digest, data, callback) {
+ var objectStore = txn.objectStore(ATTACH_STORE);
+ objectStore.get(digest).onsuccess = function (e) {
+ var originalRefs = e.target.result && e.target.result.refs || {};
+ var ref = [docInfo.metadata.id, docInfo.metadata.rev].join('@');
+ var newAtt = {
+ digest: digest,
+ body: data,
+ refs: originalRefs
+ };
+ newAtt.refs[ref] = true;
+ objectStore.put(newAtt).onsuccess = function (e) {
+ utils.call(callback);
+ };
+ };
+ }
+
+ var txn;
+ preprocessAttachments(function () {
+ var stores = [DOC_STORE, BY_SEQ_STORE, ATTACH_STORE, META_STORE,
+ LOCAL_STORE];
+ txn = idb.transaction(stores, 'readwrite');
+ txn.onerror = idbError(callback);
+ txn.ontimeout = idbError(callback);
+ txn.oncomplete = complete;
+
+ fetchExistingDocs(processDocs);
+ });
+ };
+
+ // First we look up the metadata in the ids database, then we fetch the
+ // current revision(s) from the by sequence store
+ api._get = function idb_get(id, opts, callback) {
+ var doc;
+ var metadata;
+ var err;
+ var txn;
+ opts = utils.clone(opts);
+ if (opts.ctx) {
+ txn = opts.ctx;
+ } else {
+ txn =
+ idb.transaction([DOC_STORE, BY_SEQ_STORE, ATTACH_STORE], 'readonly');
+ }
+
+ function finish() {
+ callback(err, {doc: doc, metadata: metadata, ctx: txn});
+ }
+
+ txn.objectStore(DOC_STORE).get(id).onsuccess = function (e) {
+ metadata = e.target.result;
+ // we can determine the result here if:
+ // 1. there is no such document
+ // 2. the document is deleted and we don't ask about specific rev
+ // When we ask with opts.rev we expect the answer to be either
+ // doc (possibly with _deleted=true) or missing error
+ if (!metadata) {
+ err = errors.MISSING_DOC;
+ return finish();
+ }
+ if (utils.isDeleted(metadata) && !opts.rev) {
+ err = errors.error(errors.MISSING_DOC, "deleted");
+ return finish();
+ }
+ var objectStore = txn.objectStore(BY_SEQ_STORE);
+
+ // metadata.winningRev was added later, so older DBs might not have it
+ var rev = opts.rev || metadata.winningRev || merge.winningRev(metadata);
+ var key = metadata.id + '::' + rev;
+
+ objectStore.index('_doc_id_rev').get(key).onsuccess = function (e) {
+ doc = e.target.result;
+ if (doc && doc._doc_id_rev) {
+ delete(doc._doc_id_rev);
+ }
+ if (!doc) {
+ err = errors.MISSING_DOC;
+ return finish();
+ }
+ finish();
+ };
+ };
+ };
+
+ api._getAttachment = function (attachment, opts, callback) {
+ var result;
+ var txn;
+ opts = utils.clone(opts);
+ if (opts.ctx) {
+ txn = opts.ctx;
+ } else {
+ txn =
+ idb.transaction([DOC_STORE, BY_SEQ_STORE, ATTACH_STORE], 'readonly');
+ }
+ var digest = attachment.digest;
+ var type = attachment.content_type;
+
+ txn.objectStore(ATTACH_STORE).get(digest).onsuccess = function (e) {
+ var data = e.target.result.body;
+ if (opts.encode) {
+ if (blobSupport) {
+ var reader = new FileReader();
+ reader.onloadend = function (e) {
+ var binary = utils.arrayBufferToBinaryString(this.result);
+ result = btoa(binary);
+ callback(null, result);
+ };
+ reader.readAsArrayBuffer(data);
+ } else {
+ result = data;
+ callback(null, result);
+ }
+ } else {
+ if (blobSupport) {
+ result = data;
+ } else {
+ data = utils.fixBinary(atob(data));
+ result = utils.createBlob([data], {type: type});
+ }
+ callback(null, result);
+ }
+ };
+ };
+
+ function allDocsQuery(totalRows, opts, callback) {
+ var start = 'startkey' in opts ? opts.startkey : false;
+ var end = 'endkey' in opts ? opts.endkey : false;
+ var key = 'key' in opts ? opts.key : false;
+ var skip = opts.skip || 0;
+ var limit = typeof opts.limit === 'number' ? opts.limit : -1;
+ var inclusiveEnd = opts.inclusive_end !== false;
+ var descending = 'descending' in opts && opts.descending ? 'prev' : null;
+
+ var manualDescEnd = false;
+ if (descending && start && end) {
+ // unfortunately IDB has a quirk where IDBKeyRange.bound is invalid if the
+ // start is less than the end, even in descending mode. Best bet
+ // is just to handle it manually in that case.
+ manualDescEnd = end;
+ end = false;
+ }
+
+ var keyRange = null;
+ try {
+ if (start && end) {
+ keyRange = global.IDBKeyRange.bound(start, end, false, !inclusiveEnd);
+ } else if (start) {
+ if (descending) {
+ keyRange = global.IDBKeyRange.upperBound(start);
+ } else {
+ keyRange = global.IDBKeyRange.lowerBound(start);
+ }
+ } else if (end) {
+ if (descending) {
+ keyRange = global.IDBKeyRange.lowerBound(end, !inclusiveEnd);
+ } else {
+ keyRange = global.IDBKeyRange.upperBound(end, !inclusiveEnd);
+ }
+ } else if (key) {
+ keyRange = global.IDBKeyRange.only(key);
+ }
+ } catch (e) {
+ if (e.name === "DataError" && e.code === 0) {
+ // data error, start is less than end
+ return callback(null, {
+ total_rows : totalRows,
+ offset : opts.skip,
+ rows : []
+ });
+ } else {
+ return callback(errors.error(errors.IDB_ERROR, e.name, e.message));
+ }
+ }
+
+ var transaction = idb.transaction([DOC_STORE, BY_SEQ_STORE], 'readonly');
+ transaction.oncomplete = function () {
+ callback(null, {
+ total_rows: totalRows,
+ offset: opts.skip,
+ rows: results
+ });
+ };
+
+ var oStore = transaction.objectStore(DOC_STORE);
+ var oCursor = descending ? oStore.openCursor(keyRange, descending)
+ : oStore.openCursor(keyRange);
+ var results = [];
+ oCursor.onsuccess = function (e) {
+ if (!e.target.result) {
+ return;
+ }
+ var cursor = e.target.result;
+ var metadata = cursor.value;
+ // metadata.winningRev added later, some dbs might be missing it
+ var winningRev = metadata.winningRev || merge.winningRev(metadata);
+
+ function allDocsInner(metadata, data) {
+ var doc = {
+ id: metadata.id,
+ key: metadata.id,
+ value: {
+ rev: winningRev
+ }
+ };
+ if (opts.include_docs) {
+ doc.doc = data;
+ doc.doc._rev = winningRev;
+ if (doc.doc._doc_id_rev) {
+ delete(doc.doc._doc_id_rev);
+ }
+ if (opts.conflicts) {
+ doc.doc._conflicts = merge.collectConflicts(metadata);
+ }
+ for (var att in doc.doc._attachments) {
+ if (doc.doc._attachments.hasOwnProperty(att)) {
+ doc.doc._attachments[att].stub = true;
+ }
+ }
+ }
+ var deleted = utils.isDeleted(metadata, winningRev);
+ if (opts.deleted === 'ok') {
+ // deleted docs are okay with keys_requests
+ if (deleted) {
+ doc.value.deleted = true;
+ doc.doc = null;
+ }
+ results.push(doc);
+ } else if (!deleted && skip-- <= 0) {
+ if (manualDescEnd) {
+ if (inclusiveEnd && doc.key < manualDescEnd) {
+ return;
+ } else if (!inclusiveEnd && doc.key <= manualDescEnd) {
+ return;
+ }
+ }
+ results.push(doc);
+ if (--limit === 0) {
+ return;
+ }
+ }
+ cursor["continue"]();
+ }
+
+ if (!opts.include_docs) {
+ allDocsInner(metadata);
+ } else {
+ var index = transaction.objectStore(BY_SEQ_STORE).index('_doc_id_rev');
+ var key = metadata.id + "::" + winningRev;
+ index.get(key).onsuccess = function (event) {
+ allDocsInner(cursor.value, event.target.result);
+ };
+ }
+ };
+ }
+
+ function countDocs(callback) {
+ if (docCount !== -1) {
+ return callback(null, docCount);
+ }
+
+ var count;
+ var txn = idb.transaction([DOC_STORE], 'readonly');
+ var index = txn.objectStore(DOC_STORE).index('deletedOrLocal');
+ index.count(global.IDBKeyRange.only("0")).onsuccess = function (e) {
+ count = e.target.result;
+ };
+ txn.onerror = idbError(callback);
+ txn.oncomplete = function () {
+ docCount = count;
+ callback(null, docCount);
+ };
+ }
+
+ api._allDocs = function idb_allDocs(opts, callback) {
+
+ // first count the total_rows
+ countDocs(function (err, totalRows) {
+ if (err) {
+ return callback(err);
+ }
+ if (opts.limit === 0) {
+ return callback(null, {
+ total_rows : totalRows,
+ offset : opts.skip,
+ rows : []
+ });
+ }
+ allDocsQuery(totalRows, opts, callback);
+ });
+ };
+
+ api._info = function idb_info(callback) {
+
+ countDocs(function (err, count) {
+ if (err) {
+ return callback(err);
+ }
+ if (idb === null) {
+ var error = new Error('db isn\'t open');
+ error.id = 'idbNull';
+ return callback(error);
+ }
+ var updateSeq = 0;
+ var txn = idb.transaction([META_STORE], 'readonly');
+
+ txn.objectStore(META_STORE).get(META_STORE).onsuccess = function (e) {
+ updateSeq = e.target.result && e.target.result.updateSeq || 0;
+ };
+
+ txn.oncomplete = function () {
+ callback(null, {
+ doc_count: count,
+ update_seq: updateSeq
+ });
+ };
+ });
+ };
+
+ api._changes = function (opts) {
+ opts = utils.clone(opts);
+
+ if (opts.continuous) {
+ var id = name + ':' + utils.uuid();
+ IdbPouch.Changes.addListener(name, id, api, opts);
+ IdbPouch.Changes.notify(name);
+ return {
+ cancel: function () {
+ IdbPouch.Changes.removeListener(name, id);
+ }
+ };
+ }
+
+ var descending = opts.descending ? 'prev' : null;
+ var lastSeq = 0;
+
+ // Ignore the `since` parameter when `descending` is true
+ opts.since = opts.since && !descending ? opts.since : 0;
+
+ var limit = 'limit' in opts ? opts.limit : -1;
+ if (limit === 0) {
+ limit = 1; // per CouchDB _changes spec
+ }
+ var returnDocs;
+ if ('returnDocs' in opts) {
+ returnDocs = opts.returnDocs;
+ } else {
+ returnDocs = true;
+ }
+
+ var results = [];
+ var numResults = 0;
+ var filter = utils.filterChange(opts);
+
+ var txn;
+
+ function fetchChanges() {
+ txn = idb.transaction([DOC_STORE, BY_SEQ_STORE], 'readonly');
+ txn.oncomplete = onTxnComplete;
+
+ var req;
+
+ if (descending) {
+ req = txn.objectStore(BY_SEQ_STORE)
+ .openCursor(global.IDBKeyRange.lowerBound(opts.since, true),
+ descending);
+ } else {
+ req = txn.objectStore(BY_SEQ_STORE)
+ .openCursor(global.IDBKeyRange.lowerBound(opts.since, true));
+ }
+
+ req.onsuccess = onsuccess;
+ req.onerror = onerror;
+ }
+
+ fetchChanges();
+
+ function onsuccess(event) {
+ var cursor = event.target.result;
+
+ if (!cursor) {
+ return;
+ }
+
+ var doc = cursor.value;
+
+ if (opts.doc_ids && opts.doc_ids.indexOf(doc._id) === -1) {
+ return cursor["continue"]();
+ }
+
+ var index = txn.objectStore(DOC_STORE);
+ index.get(doc._id).onsuccess = function (event) {
+ var metadata = event.target.result;
+
+ if (lastSeq < metadata.seq) {
+ lastSeq = metadata.seq;
+ }
+ // metadata.winningRev was only added later
+ var winningRev = metadata.winningRev || merge.winningRev(metadata);
+ if (doc._rev !== winningRev) {
+ return cursor["continue"]();
+ }
+
+ delete doc['_doc_id_rev'];
+
+ var change = opts.processChange(doc, metadata, opts);
+ change.seq = cursor.key;
+ if (filter(change)) {
+ numResults++;
+ if (returnDocs) {
+ results.push(change);
+ }
+ opts.onChange(change);
+ }
+ if (numResults !== limit) {
+ cursor["continue"]();
+ }
+ };
+ }
+
+ function onTxnComplete() {
+ if (!opts.continuous) {
+ opts.complete(null, {
+ results: results,
+ last_seq: lastSeq
+ });
+ }
+ }
+ };
+
+ api._close = function (callback) {
+ if (idb === null) {
+ return callback(errors.NOT_OPEN);
+ }
+
+ // https://developer.mozilla.org/en-US/docs/IndexedDB/IDBDatabase#close
+ // "Returns immediately and closes the connection in a separate thread..."
+ idb.close();
+ delete cachedDBs[name];
+ idb = null;
+ callback();
+ };
+
+ api._getRevisionTree = function (docId, callback) {
+ var txn = idb.transaction([DOC_STORE], 'readonly');
+ var req = txn.objectStore(DOC_STORE).get(docId);
+ req.onsuccess = function (event) {
+ var doc = event.target.result;
+ if (!doc) {
+ callback(errors.MISSING_DOC);
+ } else {
+ callback(null, doc.rev_tree);
+ }
+ };
+ };
+
+ // This function removes revisions of document docId
+ // which are listed in revs and sets this document
+ // revision to to rev_tree
+ api._doCompaction = function (docId, rev_tree, revs, callback) {
+ var txn = idb.transaction([DOC_STORE, BY_SEQ_STORE], 'readwrite');
+
+ var index = txn.objectStore(DOC_STORE);
+ index.get(docId).onsuccess = function (event) {
+ var metadata = event.target.result;
+ metadata.rev_tree = rev_tree;
+
+ var count = revs.length;
+ revs.forEach(function (rev) {
+ var index = txn.objectStore(BY_SEQ_STORE).index('_doc_id_rev');
+ var key = docId + "::" + rev;
+ index.getKey(key).onsuccess = function (e) {
+ var seq = e.target.result;
+ if (!seq) {
+ return;
+ }
+ txn.objectStore(BY_SEQ_STORE)["delete"](seq);
+
+ count--;
+ if (!count) {
+ txn.objectStore(DOC_STORE).put(metadata);
+ }
+ };
+ });
+ };
+ txn.oncomplete = function () {
+ utils.call(callback);
+ };
+ };
+
+
+ api._getLocal = function (id, callback) {
+ var tx = idb.transaction([LOCAL_STORE], 'readonly');
+ var req = tx.objectStore(LOCAL_STORE).get(id);
+
+ req.onerror = idbError(callback);
+ req.onsuccess = function (e) {
+ var doc = e.target.result;
+ if (!doc) {
+ callback(errors.MISSING_DOC);
+ } else {
+ delete doc['_doc_id_rev'];
+ callback(null, doc);
+ }
+ };
+ };
+
+ api._putLocal = function (doc, opts, callback) {
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ var oldRev = doc._rev;
+ var id = doc._id;
+ if (!oldRev) {
+ doc._rev = '0-0';
+ } else {
+ doc._rev = '0-' + (parseInt(oldRev.split('-')[1], 10) + 1);
+ }
+ doc._doc_id_rev = id + '::' + doc._rev;
+
+ var tx = opts.ctx;
+ var ret;
+ if (!tx) {
+ tx = idb.transaction([LOCAL_STORE], 'readwrite');
+ tx.onerror = idbError(callback);
+ tx.oncomplete = function () {
+ if (ret) {
+ callback(null, ret);
+ }
+ };
+ }
+
+ var oStore = tx.objectStore(LOCAL_STORE);
+ var req;
+ if (oldRev) {
+ var index = oStore.index('_doc_id_rev');
+ var docIdRev = id + '::' + oldRev;
+ req = index.get(docIdRev);
+ req.onsuccess = function (e) {
+ if (!e.target.result) {
+ callback(errors.REV_CONFLICT);
+ } else { // update
+ var req = oStore.put(doc);
+ req.onsuccess = function () {
+ ret = {ok: true, id: doc._id, rev: doc._rev};
+ if (opts.ctx) { // retuthis.immediately
+ callback(null, ret);
+ }
+ };
+ }
+ };
+ } else { // new doc
+ req = oStore.get(id);
+ req.onsuccess = function (e) {
+ if (e.target.result) { // already exists
+ callback(errors.REV_CONFLICT);
+ } else { // insert
+ var req = oStore.put(doc);
+ req.onsuccess = function () {
+ ret = {ok: true, id: doc._id, rev: doc._rev};
+ if (opts.ctx) { // return immediately
+ callback(null, ret);
+ }
+ };
+ }
+ };
+ }
+ };
+
+ api._removeLocal = function (doc, callback) {
+ var tx = idb.transaction([LOCAL_STORE], 'readwrite');
+ var ret;
+ tx.oncomplete = function () {
+ if (ret) {
+ callback(null, ret);
+ }
+ };
+ var docIdRev = doc._id + '::' + doc._rev;
+ var oStore = tx.objectStore(LOCAL_STORE);
+ var index = oStore.index('_doc_id_rev');
+ var req = index.get(docIdRev);
+
+ req.onerror = idbError(callback);
+ req.onsuccess = function (e) {
+ var doc = e.target.result;
+ if (!doc) {
+ callback(errors.MISSING_DOC);
+ } else {
+ var req = index.getKey(docIdRev);
+ req.onsuccess = function (e) {
+ var key = e.target.result;
+ oStore["delete"](key);
+ ret = {ok: true, id: doc._id, rev: '0-0'};
+ };
+ }
+ };
+ };
+
+ var cached = cachedDBs[name];
+
+ if (cached) {
+ idb = cached.idb;
+ blobSupport = cached.blobSupport;
+ instanceId = cached.instanceId;
+ idStored = cached.idStored;
+ process.nextTick(function () {
+ callback(null, api);
+ });
+ return;
+ }
+
+ var req = global.indexedDB.open(name, ADAPTER_VERSION);
+
+ if (!('openReqList' in IdbPouch)) {
+ IdbPouch.openReqList = {};
+ }
+ IdbPouch.openReqList[name] = req;
+
+ req.onupgradeneeded = function (e) {
+ var db = e.target.result;
+ if (e.oldVersion < 1) {
+ // initial schema
+ createSchema(db);
+ }
+ if (e.oldVersion < 3) {
+ createLocalStoreSchema(db);
+ if (e.oldVersion < 2) {
+ // version 2 adds the deletedOrLocal index
+ addDeletedOrLocalIndex(e, function (transaction) {
+ migrateLocalStore(e, transaction);
+ });
+ } else {
+ migrateLocalStore(e);
+ }
+ }
+ };
+
+ req.onsuccess = function (e) {
+
+ idb = e.target.result;
+
+ idb.onversionchange = function () {
+ idb.close();
+ delete cachedDBs[name];
+ };
+ idb.onabort = function () {
+ idb.close();
+ delete cachedDBs[name];
+ };
+
+ var txn = idb.transaction([META_STORE, DETECT_BLOB_SUPPORT_STORE],
+ 'readwrite');
+
+ var req = txn.objectStore(META_STORE).get(META_STORE);
+
+ req.onsuccess = function (e) {
+
+ var checkSetupComplete = function () {
+ if (blobSupport === null || !idStored) {
+ return;
+ } else {
+ cachedDBs[name] = {
+ idb: idb,
+ blobSupport: blobSupport,
+ instanceId: instanceId,
+ idStored: idStored,
+ loaded: true
+ };
+ callback(null, api);
+ }
+ };
+
+ var meta = e.target.result || {id: META_STORE};
+ if (name + '_id' in meta) {
+ instanceId = meta[name + '_id'];
+ idStored = true;
+ checkSetupComplete();
+ } else {
+ instanceId = utils.uuid();
+ meta[name + '_id'] = instanceId;
+ txn.objectStore(META_STORE).put(meta).onsuccess = function () {
+ idStored = true;
+ checkSetupComplete();
+ };
+ }
+
+ // detect blob support
+ try {
+ txn.objectStore(DETECT_BLOB_SUPPORT_STORE).put(utils.createBlob(),
+ "key");
+ blobSupport = true;
+ } catch (err) {
+ blobSupport = false;
+ } finally {
+ checkSetupComplete();
+ }
+ };
+ };
+
+ req.onerror = idbError(callback);
+
+}
+
+IdbPouch.valid = function () {
+ return global.indexedDB && isModernIdb();
+};
+
+function destroy(name, opts, callback) {
+ if (!('openReqList' in IdbPouch)) {
+ IdbPouch.openReqList = {};
+ }
+ IdbPouch.Changes.removeAllListeners(name);
+
+ //Close open request for "name" database to fix ie delay.
+ if (IdbPouch.openReqList[name] && IdbPouch.openReqList[name].result) {
+ IdbPouch.openReqList[name].result.close();
+ }
+ var req = global.indexedDB.deleteDatabase(name);
+
+ req.onsuccess = function () {
+ //Remove open request from the list.
+ if (IdbPouch.openReqList[name]) {
+ IdbPouch.openReqList[name] = null;
+ }
+ if (utils.hasLocalStorage() && (name in global.localStorage)) {
+ delete global.localStorage[name];
+ }
+ delete cachedDBs[name];
+ callback(null, { 'ok': true });
+ };
+
+ req.onerror = idbError(callback);
+}
+
+IdbPouch.destroy = utils.toPromise(function (name, opts, callback) {
+ taskQueue.queue.push({
+ action: function (thisCallback) {
+ destroy(name, opts, thisCallback);
+ },
+ callback: callback
+ });
+ applyNext();
+});
+
+IdbPouch.Changes = new utils.Changes();
+
+module.exports = IdbPouch;
+
+}).call(this,_dereq_("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"../deps/errors":11,"../merge":18,"../utils":23,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":28}],4:[function(_dereq_,module,exports){
+module.exports = ['idb', 'websql'];
+},{}],5:[function(_dereq_,module,exports){
+(function (global){
+'use strict';
+
+var utils = _dereq_('../utils');
+var merge = _dereq_('../merge');
+var errors = _dereq_('../deps/errors');
+function quote(str) {
+ return "'" + str + "'";
+}
+
+var cachedDatabases = {};
+
+var openDB = utils.getArguments(function (args) {
+ if (typeof global !== 'undefined') {
+ if (global.navigator && global.navigator.sqlitePlugin &&
+ global.navigator.sqlitePlugin.openDatabase) {
+ return navigator.sqlitePlugin.openDatabase
+ .apply(navigator.sqlitePlugin, args);
+ } else if (global.sqlitePlugin && global.sqlitePlugin.openDatabase) {
+ return global.sqlitePlugin.openDatabase
+ .apply(global.sqlitePlugin, args);
+ } else {
+ var db = cachedDatabases[args[0]];
+ if (!db) {
+ db = cachedDatabases[args[0]] =
+ global.openDatabase.apply(global, args);
+ }
+ return db;
+ }
+ }
+});
+
+var POUCH_VERSION = 1;
+var ADAPTER_VERSION = 4; // used to manage migrations
+
+// The object stores created for each database
+// DOC_STORE stores the document meta data, its revision history and state
+var DOC_STORE = quote('document-store');
+// BY_SEQ_STORE stores a particular version of a document, keyed by its
+// sequence id
+var BY_SEQ_STORE = quote('by-sequence');
+// Where we store attachments
+var ATTACH_STORE = quote('attach-store');
+var LOCAL_STORE = quote('local-store');
+var META_STORE = quote('metadata-store');
+
+// these indexes cover the ground for most allDocs queries
+var BY_SEQ_STORE_DELETED_INDEX_SQL =
+ 'CREATE INDEX IF NOT EXISTS \'by-seq-deleted-idx\' ON ' +
+ BY_SEQ_STORE + ' (seq, deleted)';
+var BY_SEQ_STORE_DOC_ID_REV_INDEX_SQL =
+ 'CREATE UNIQUE INDEX IF NOT EXISTS \'by-seq-doc-id-rev\' ON ' +
+ BY_SEQ_STORE + ' (doc_id, rev)';
+var DOC_STORE_WINNINGSEQ_INDEX_SQL =
+ 'CREATE INDEX IF NOT EXISTS \'doc-winningseq-idx\' ON ' +
+ DOC_STORE + ' (winningseq)';
+
+var DOC_STORE_AND_BY_SEQ_JOINER = BY_SEQ_STORE +
+ '.seq = ' + DOC_STORE + '.winningseq';
+
+var SELECT_DOCS = BY_SEQ_STORE + '.seq AS seq, ' +
+ BY_SEQ_STORE + '.deleted AS deleted, ' +
+ BY_SEQ_STORE + '.json AS data, ' +
+ BY_SEQ_STORE + '.rev AS rev, ' +
+ DOC_STORE + '.json AS metadata';
+
+function select(selector, table, joiner, where, orderBy) {
+ return 'SELECT ' + selector + ' FROM ' +
+ (typeof table === 'string' ? table : table.join(' JOIN ')) +
+ (joiner ? (' ON ' + joiner) : '') +
+ (where ? (' WHERE ' +
+ (typeof where === 'string' ? where : where.join(' AND '))) : '') +
+ (orderBy ? (' ORDER BY ' + orderBy) : '');
+}
+
+function unknownError(callback) {
+ return function (event) {
+ // event may actually be a SQLError object, so report is as such
+ var errorNameMatch = event && event.constructor.toString()
+ .match(/function ([^\(]+)/);
+ var errorName = (errorNameMatch && errorNameMatch[1]) || event.type;
+ var errorReason = event.target || event.message;
+ callback(errors.error(errors.WSQ_ERROR, errorReason, errorName));
+ };
+}
+function decodeUtf8(str) {
+ return decodeURIComponent(window.escape(str));
+}
+function parseHexString(str, encoding) {
+ var result = '';
+ var charWidth = encoding === 'UTF-8' ? 2 : 4;
+ for (var i = 0, len = str.length; i < len; i += charWidth) {
+ var substring = str.substring(i, i + charWidth);
+ if (charWidth === 4) { // UTF-16, twiddle the bits
+ substring = substring.substring(2, 4) + substring.substring(0, 2);
+ }
+ result += String.fromCharCode(parseInt(substring, 16));
+ }
+ result = encoding === 'UTF-8' ? decodeUtf8(result) : result;
+ return result;
+}
+
+function stringifyDoc(doc) {
+ // don't bother storing the id/rev. it uses lots of space,
+ // in persistent map/reduce especially
+ delete doc._id;
+ delete doc._rev;
+ return JSON.stringify(doc);
+}
+
+function unstringifyDoc(doc, id, rev) {
+ doc = JSON.parse(doc);
+ doc._id = id;
+ doc._rev = rev;
+ return doc;
+}
+
+function getSize(opts) {
+ if ('size' in opts) {
+ // triggers immediate popup in iOS, fixes #2347
+ // e.g. 5000001 asks for 5 MB, 10000001 asks for 10 MB,
+ return opts.size * 1000000;
+ }
+ // In iOS, doesn't matter as long as it's <= 5000000.
+ // Except that if you request too much, our tests fail
+ // because of the native "do you accept?" popup.
+ // In Android <=4.3, this value is actually used as an
+ // honest-to-god ceiling for data, so we need to
+ // set it to a decently high number.
+ var isAndroid = /Android/.test(window.navigator.userAgent);
+ return isAndroid ? 5000000 : 1;
+}
+
+function WebSqlPouch(opts, callback) {
+ var api = this;
+ var instanceId = null;
+ var name = opts.name;
+ var size = getSize(opts);
+ var idRequests = [];
+ var docCount = -1; // cache sqlite count(*) for performance
+ var encoding;
+
+ var db = openDB(name, POUCH_VERSION, name, size);
+ if (!db) {
+ return callback(errors.UNKNOWN_ERROR);
+ } else if (typeof db.readTransaction !== 'function') {
+ // doesn't exist in sqlite plugin
+ db.readTransaction = db.transaction;
+ }
+
+ function dbCreated() {
+ // note the db name in case the browser upgrades to idb
+ if (utils.hasLocalStorage()) {
+ global.localStorage['_pouch__websqldb_' + name] = true;
+ }
+ callback(null, api);
+ }
+
+ // In this migration, we added the 'deleted' and 'local' columns to the
+ // by-seq and doc store tables.
+ // To preserve existing user data, we re-process all the existing JSON
+ // and add these values.
+ // Called migration2 because it corresponds to adapter version (db_version) #2
+ function runMigration2(tx, callback) {
+ // index used for the join in the allDocs query
+ tx.executeSql(DOC_STORE_WINNINGSEQ_INDEX_SQL);
+
+ tx.executeSql('ALTER TABLE ' + BY_SEQ_STORE +
+ ' ADD COLUMN deleted TINYINT(1) DEFAULT 0', [], function () {
+ tx.executeSql(BY_SEQ_STORE_DELETED_INDEX_SQL);
+ tx.executeSql('ALTER TABLE ' + DOC_STORE +
+ ' ADD COLUMN local TINYINT(1) DEFAULT 0', [], function () {
+ tx.executeSql('CREATE INDEX IF NOT EXISTS \'doc-store-local-idx\' ON ' +
+ DOC_STORE + ' (local, id)');
+
+ var sql = 'SELECT ' + DOC_STORE + '.winningseq AS seq, ' + DOC_STORE +
+ '.json AS metadata FROM ' + BY_SEQ_STORE + ' JOIN ' + DOC_STORE +
+ ' ON ' + BY_SEQ_STORE + '.seq = ' + DOC_STORE + '.winningseq';
+
+ tx.executeSql(sql, [], function (tx, result) {
+
+ var deleted = [];
+ var local = [];
+
+ for (var i = 0; i < result.rows.length; i++) {
+ var item = result.rows.item(i);
+ var seq = item.seq;
+ var metadata = JSON.parse(item.metadata);
+ if (utils.isDeleted(metadata)) {
+ deleted.push(seq);
+ }
+ if (utils.isLocalId(metadata.id)) {
+ local.push(metadata.id);
+ }
+ }
+ tx.executeSql('UPDATE ' + DOC_STORE + 'SET local = 1 WHERE id IN (' +
+ local.map(function () {
+ return '?';
+ }).join(',') + ')', local, function () {
+ tx.executeSql('UPDATE ' + BY_SEQ_STORE +
+ ' SET deleted = 1 WHERE seq IN (' + deleted.map(function () {
+ return '?';
+ }).join(',') + ')', deleted, callback);
+ });
+ });
+ });
+ });
+ }
+
+ // in this migration, we make all the local docs unversioned
+ function runMigration3(tx, callback) {
+ var local = 'CREATE TABLE IF NOT EXISTS ' + LOCAL_STORE +
+ ' (id UNIQUE, rev, json)';
+ tx.executeSql(local, [], function () {
+ var sql = 'SELECT ' + DOC_STORE + '.id AS id, ' +
+ BY_SEQ_STORE + '.json AS data ' +
+ 'FROM ' + BY_SEQ_STORE + ' JOIN ' +
+ DOC_STORE + ' ON ' + BY_SEQ_STORE + '.seq = ' +
+ DOC_STORE + '.winningseq WHERE local = 1';
+ tx.executeSql(sql, [], function (tx, res) {
+ var rows = [];
+ for (var i = 0; i < res.rows.length; i++) {
+ rows.push(res.rows.item(i));
+ }
+ function doNext() {
+ if (!rows.length) {
+ return callback();
+ }
+ var row = rows.shift();
+ var rev = JSON.parse(row.data)._rev;
+ tx.executeSql('INSERT INTO ' + LOCAL_STORE +
+ ' (id, rev, json) VALUES (?,?,?)',
+ [row.id, rev, row.data], function (tx) {
+ tx.executeSql('DELETE FROM ' + DOC_STORE + ' WHERE id=?',
+ [row.id], function (tx) {
+ tx.executeSql('DELETE FROM ' + BY_SEQ_STORE + ' WHERE seq=?',
+ [row.seq], function () {
+ doNext();
+ });
+ });
+ });
+ }
+ doNext();
+ });
+ });
+ }
+
+ // in this migration, we remove doc_id_rev and just use rev
+ function runMigration4(tx, callback) {
+
+ function updateRows(rows, encoding) {
+ function doNext() {
+ if (!rows.length) {
+ return callback();
+ }
+ var row = rows.shift();
+ var doc_id_rev = parseHexString(row.hex, encoding);
+ var idx = doc_id_rev.lastIndexOf('::');
+ var doc_id = doc_id_rev.substring(0, idx);
+ var rev = doc_id_rev.substring(idx + 2);
+ var sql = 'UPDATE ' + BY_SEQ_STORE +
+ ' SET doc_id=?, rev=? WHERE doc_id_rev=?';
+ tx.executeSql(sql, [doc_id, rev, doc_id_rev], function () {
+ doNext();
+ });
+ }
+ doNext();
+ }
+
+ var sql = 'ALTER TABLE ' + BY_SEQ_STORE + ' ADD COLUMN doc_id';
+ tx.executeSql(sql, [], function (tx) {
+ var sql = 'ALTER TABLE ' + BY_SEQ_STORE + ' ADD COLUMN rev';
+ tx.executeSql(sql, [], function (tx) {
+ tx.executeSql(BY_SEQ_STORE_DOC_ID_REV_INDEX_SQL, [], function (tx) {
+ var sql = 'SELECT hex(doc_id_rev) as hex FROM ' + BY_SEQ_STORE;
+ tx.executeSql(sql, [], function (tx, res) {
+ var rows = [];
+ for (var i = 0; i < res.rows.length; i++) {
+ rows.push(res.rows.item(i));
+ }
+ // it sucks, but we fetch the encoding twice
+ tx.executeSql(
+ 'SELECT dbid, hex(dbid) AS hexId FROM ' + META_STORE, [],
+ function (tx, result) {
+ var id = result.rows.item(0).dbid;
+ var hexId = result.rows.item(0).hexId;
+ var encoding = (hexId.length === id.length * 2) ?
+ 'UTF-8' : 'UTF-16';
+ updateRows(rows, encoding);
+ }
+ );
+ });
+ });
+ });
+ });
+ }
+
+ function onGetInstanceId(tx) {
+ while (idRequests.length > 0) {
+ var idCallback = idRequests.pop();
+ idCallback(null, instanceId);
+ }
+ checkDbEncoding(tx);
+ }
+
+ function checkDbEncoding(tx) {
+ // check db encoding - utf-8 (chrome, opera) or utf-16 (safari)?
+ tx.executeSql('SELECT dbid, hex(dbid) AS hexId FROM ' + META_STORE, [],
+ function (tx, result) {
+ var id = result.rows.item(0).dbid;
+ var hexId = result.rows.item(0).hexId;
+ encoding = (hexId.length === id.length * 2) ? 'UTF-8' : 'UTF-16';
+ }
+ );
+ }
+
+ function onGetVersion(tx, dbVersion) {
+ if (dbVersion === 0) {
+ // initial schema
+
+ var meta = 'CREATE TABLE IF NOT EXISTS ' + META_STORE +
+ ' (update_seq INTEGER, dbid, db_version INTEGER)';
+ var attach = 'CREATE TABLE IF NOT EXISTS ' + ATTACH_STORE +
+ ' (digest, json, body BLOB)';
+ var doc = 'CREATE TABLE IF NOT EXISTS ' + DOC_STORE +
+ ' (id unique, json, winningseq)';
+ var seq = 'CREATE TABLE IF NOT EXISTS ' + BY_SEQ_STORE +
+ ' (seq INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, ' +
+ 'json, deleted TINYINT(1), doc_id, rev)';
+ var local = 'CREATE TABLE IF NOT EXISTS ' + LOCAL_STORE +
+ ' (id UNIQUE, rev, json)';
+
+ // creates
+ tx.executeSql(attach);
+ tx.executeSql(local);
+ tx.executeSql(doc, [], function () {
+ tx.executeSql(DOC_STORE_WINNINGSEQ_INDEX_SQL);
+ tx.executeSql(seq, [], function () {
+ tx.executeSql(BY_SEQ_STORE_DELETED_INDEX_SQL);
+ tx.executeSql(BY_SEQ_STORE_DOC_ID_REV_INDEX_SQL);
+ tx.executeSql(meta, [], function () {
+ // mark the update_seq, db version, and new dbid
+ var initSeq = 'INSERT INTO ' + META_STORE +
+ ' (update_seq, db_version, dbid) VALUES (?, ?, ?)';
+ instanceId = utils.uuid();
+ var initSeqArgs = [0, ADAPTER_VERSION, instanceId];
+ tx.executeSql(initSeq, initSeqArgs, function (tx) {
+ onGetInstanceId(tx);
+ });
+ });
+ });
+ });
+ } else { // version > 0
+
+ var setupDone = function () {
+ var migrated = dbVersion < ADAPTER_VERSION;
+ if (migrated) {
+ // update the db version within this transaction
+ tx.executeSql('UPDATE ' + META_STORE + ' SET db_version = ' +
+ ADAPTER_VERSION);
+ }
+ // notify db.id() callers
+ var sql = 'SELECT dbid FROM ' + META_STORE;
+ tx.executeSql(sql, [], function (tx, result) {
+ instanceId = result.rows.item(0).dbid;
+ onGetInstanceId(tx);
+ });
+ };
+
+ // would love to use promises here, but then websql
+ // ends the transaction early
+ switch (dbVersion) {
+ case 1:
+ runMigration2(tx, function () {
+ runMigration3(tx, function () {
+ runMigration4(tx, setupDone);
+ });
+ });
+ break;
+ case 2:
+ runMigration3(tx, function () {
+ runMigration4(tx, setupDone);
+ });
+ break;
+ case 3:
+ runMigration4(tx, setupDone);
+ break;
+ default:
+ setupDone();
+ break;
+ }
+ }
+ }
+
+ function setup() {
+
+ db.transaction(function (tx) {
+ // first get the version
+ tx.executeSql('SELECT sql FROM sqlite_master WHERE tbl_name = ' +
+ META_STORE, [], function (tx, result) {
+ if (!result.rows.length) {
+ // database hasn't even been created yet (version 0)
+ onGetVersion(tx, 0);
+ } else if (!/db_version/.test(result.rows.item(0).sql)) {
+ // table was created, but without the new db_version column,
+ // so add it.
+ tx.executeSql('ALTER TABLE ' + META_STORE +
+ ' ADD COLUMN db_version INTEGER', [], function () {
+ // before version 2, this column didn't even exist
+ onGetVersion(tx, 1);
+ });
+ } else { // column exists, we can safely get it
+ tx.executeSql('SELECT db_version FROM ' + META_STORE, [],
+ function (tx, result) {
+ var dbVersion = result.rows.item(0).db_version;
+ onGetVersion(tx, dbVersion);
+ });
+ }
+ });
+ }, unknownError(callback), dbCreated);
+ }
+
+ if (utils.isCordova() && typeof global !== 'undefined') {
+ //to wait until custom api is made in pouch.adapters before doing setup
+ global.addEventListener(name + '_pouch', function cordova_init() {
+ global.removeEventListener(name + '_pouch', cordova_init, false);
+ setup();
+ }, false);
+ } else {
+ setup();
+ }
+
+ api.type = function () {
+ return 'websql';
+ };
+
+ api._id = utils.toPromise(function (callback) {
+ callback(null, instanceId);
+ });
+
+ api._info = function (callback) {
+ db.readTransaction(function (tx) {
+ countDocs(tx, function (docCount) {
+ var sql = 'SELECT update_seq FROM ' + META_STORE;
+ tx.executeSql(sql, [], function (tx, result) {
+ var updateSeq = result.rows.item(0).update_seq;
+ callback(null, {
+ doc_count: docCount,
+ update_seq: updateSeq
+ });
+ });
+ });
+ }, unknownError(callback));
+ };
+
+ api._bulkDocs = function (req, opts, callback) {
+
+ var newEdits = opts.new_edits;
+ var userDocs = req.docs;
+
+ // Parse the docs, give them a sequence number for the result
+ var docInfos = userDocs.map(function (doc, i) {
+ if (doc._id && utils.isLocalId(doc._id)) {
+ return doc;
+ }
+ var newDoc = utils.parseDoc(doc, newEdits);
+ newDoc._bulk_seq = i;
+ return newDoc;
+ });
+
+ var docInfoErrors = docInfos.filter(function (docInfo) {
+ return docInfo.error;
+ });
+ if (docInfoErrors.length) {
+ return callback(docInfoErrors[0]);
+ }
+
+ var tx;
+ var results = new Array(docInfos.length);
+ var updateSeq = 0;
+ var fetchedDocs = new utils.Map();
+ var numDocsWritten = 0;
+
+ function complete() {
+ var aresults = results.map(function (result) {
+ if (result._bulk_seq) {
+ delete result._bulk_seq;
+ } else if (!Object.keys(result).length) {
+ return {
+ ok: true
+ };
+ }
+ if (result.error) {
+ return result;
+ }
+
+ var metadata = result.metadata;
+ var rev = merge.winningRev(metadata);
+
+ return {
+ ok: true,
+ id: metadata.id,
+ rev: rev
+ };
+ });
+ WebSqlPouch.Changes.notify(name);
+
+ var updateseq = 'SELECT update_seq FROM ' + META_STORE;
+ tx.executeSql(updateseq, [], function (tx, result) {
+ var update_seq = result.rows.item(0).update_seq + updateSeq;
+ var sql = 'UPDATE ' + META_STORE + ' SET update_seq=?';
+ tx.executeSql(sql, [update_seq], function () {
+ callback(null, aresults);
+ });
+ });
+ }
+
+ function preprocessAttachment(att, finish) {
+ if (att.stub) {
+ return finish();
+ }
+ if (typeof att.data === 'string') {
+ try {
+ att.data = atob(att.data);
+ } catch (e) {
+ var err = errors.error(errors.BAD_ARG,
+ "Attachments need to be base64 encoded");
+ return callback(err);
+ }
+ var data = utils.fixBinary(att.data);
+ att.data = utils.createBlob([data], {type: att.content_type});
+ }
+ var reader = new FileReader();
+ reader.onloadend = function (e) {
+ var binary = utils.arrayBufferToBinaryString(this.result);
+ att.data = binary;
+ utils.MD5(binary).then(function (result) {
+ att.digest = 'md5-' + result;
+ finish();
+ });
+ };
+ reader.readAsArrayBuffer(att.data);
+ }
+
+ function preprocessAttachments(callback) {
+ if (!docInfos.length) {
+ return callback();
+ }
+
+ var docv = 0;
+
+ docInfos.forEach(function (docInfo) {
+ var attachments = docInfo.data && docInfo.data._attachments ?
+ Object.keys(docInfo.data._attachments) : [];
+ var recv = 0;
+
+ if (!attachments.length) {
+ return done();
+ }
+
+ function processedAttachment() {
+ recv++;
+ if (recv === attachments.length) {
+ done();
+ }
+ }
+
+ for (var key in docInfo.data._attachments) {
+ if (docInfo.data._attachments.hasOwnProperty(key)) {
+ preprocessAttachment(docInfo.data._attachments[key],
+ processedAttachment);
+ }
+ }
+ });
+
+ function done() {
+ docv++;
+ if (docInfos.length === docv) {
+ callback();
+ }
+ }
+ }
+
+ function writeDoc(docInfo, winningRev, deleted, callback, isUpdate,
+ resultsIdx) {
+
+ function finish() {
+ updateSeq++;
+ var data = docInfo.data;
+ var deletedInt = deleted ? 1 : 0;
+
+ var id = data._id;
+ var rev = data._rev;
+ var json = stringifyDoc(data);
+ var sql = 'INSERT INTO ' + BY_SEQ_STORE +
+ ' (doc_id, rev, json, deleted) VALUES (?, ?, ?, ?);';
+ var sqlArgs = [id, rev, json, deletedInt];
+
+ tx.executeSql(sql, sqlArgs, function (tx, result) {
+ dataWritten(tx, result.insertId);
+ }, function () {
+ // constraint error, recover by updating instead (see #1638)
+ var fetchSql = select('seq', BY_SEQ_STORE, null,
+ 'doc_id=? AND rev=?');
+ tx.executeSql(fetchSql, [id, rev], function (tx, res) {
+ var seq = res.rows.item(0).seq;
+ var sql = 'UPDATE ' + BY_SEQ_STORE +
+ ' SET json=?, deleted=? WHERE doc_id=? AND rev=?;';
+ var sqlArgs = [json, deletedInt, id, rev];
+ tx.executeSql(sql, sqlArgs, function (tx) {
+ updateSeq--; // discount, since it's an update, not a new seq
+ dataWritten(tx, seq);
+ });
+ });
+ return false; // ack that we've handled the error
+ });
+ }
+
+ function collectResults(attachmentErr) {
+ if (!err) {
+ if (attachmentErr) {
+ err = attachmentErr;
+ callback(err);
+ } else if (recv === attachments.length) {
+ finish();
+ }
+ }
+ }
+
+ var err = null;
+ var recv = 0;
+
+ docInfo.data._id = docInfo.metadata.id;
+ docInfo.data._rev = docInfo.metadata.rev;
+
+ if (deleted) {
+ docInfo.data._deleted = true;
+ }
+
+ var attachments = docInfo.data._attachments ?
+ Object.keys(docInfo.data._attachments) : [];
+
+ function attachmentSaved(err) {
+ recv++;
+ collectResults(err);
+ }
+
+ for (var key in docInfo.data._attachments) {
+ if (!docInfo.data._attachments[key].stub) {
+ var data = docInfo.data._attachments[key].data;
+ delete docInfo.data._attachments[key].data;
+ var digest = docInfo.data._attachments[key].digest;
+ saveAttachment(docInfo, digest, data, attachmentSaved);
+ } else {
+ recv++;
+ collectResults();
+ }
+ }
+
+ if (!attachments.length) {
+ finish();
+ }
+
+ function dataWritten(tx, seq) {
+ docInfo.metadata.seq = seq;
+ delete docInfo.metadata.rev;
+
+ var sql = isUpdate ?
+ 'UPDATE ' + DOC_STORE +
+ ' SET json=?, winningseq=(SELECT seq FROM ' + BY_SEQ_STORE +
+ ' WHERE doc_id=' + DOC_STORE + '.id AND rev=?) WHERE id=?'
+ : 'INSERT INTO ' + DOC_STORE +
+ ' (id, winningseq, json) VALUES (?, ?, ?);';
+ var metadataStr = JSON.stringify(docInfo.metadata);
+ var id = docInfo.metadata.id;
+ var params = isUpdate ?
+ [metadataStr, winningRev, id] :
+ [id, seq, metadataStr];
+ tx.executeSql(sql, params, function () {
+ results[resultsIdx] = docInfo;
+ fetchedDocs.set(id, docInfo.metadata);
+ callback();
+ });
+ }
+ }
+
+ function updateDoc(oldDoc, docInfo, resultsIdx, callback) {
+ var merged =
+ merge.merge(oldDoc.rev_tree, docInfo.metadata.rev_tree[0], 1000);
+ var deleted = utils.isDeleted(docInfo.metadata);
+ var oldDocDeleted = utils.isDeleted(oldDoc);
+ var inConflict = (oldDocDeleted && deleted && newEdits) ||
+ (!oldDocDeleted && newEdits && merged.conflicts !== 'new_leaf');
+ if (inConflict) {
+ results[resultsIdx] = makeErr(errors.REV_CONFLICT, docInfo._bulk_seq);
+ return callback();
+ }
+
+ docInfo.metadata.rev_tree = merged.tree;
+
+ // recalculate
+ var winningRev = merge.winningRev(docInfo.metadata);
+ deleted = utils.isDeleted(docInfo.metadata, winningRev);
+
+ writeDoc(docInfo, winningRev, deleted, callback, true, resultsIdx);
+ }
+
+ function insertDoc(docInfo, resultsIdx, callback) {
+ // Cant insert new deleted documents
+ var winningRev = merge.winningRev(docInfo.metadata);
+ var deleted = utils.isDeleted(docInfo.metadata, winningRev);
+ if ('was_delete' in opts && deleted) {
+ results[resultsIdx] = errors.MISSING_DOC;
+ return callback();
+ }
+ writeDoc(docInfo, winningRev, deleted, callback, false, resultsIdx);
+ }
+
+ function checkDoneWritingDocs() {
+ if (++numDocsWritten === docInfos.length) {
+ complete();
+ }
+ }
+
+ function processDocs() {
+ if (!docInfos.length) {
+ return complete();
+ }
+
+ var idsToDocs = new utils.Map();
+
+ docInfos.forEach(function (currentDoc, resultsIdx) {
+
+ if (currentDoc._id && utils.isLocalId(currentDoc._id)) {
+ api[currentDoc._deleted ? '_removeLocal' : '_putLocal'](
+ currentDoc, {ctx: tx}, function (err, resp) {
+ if (err) {
+ results[resultsIdx] = err;
+ } else {
+ results[resultsIdx] = {};
+ }
+ checkDoneWritingDocs();
+ });
+ return;
+ }
+
+ var id = currentDoc.metadata.id;
+ if (idsToDocs.has(id)) {
+ idsToDocs.get(id).push([currentDoc, resultsIdx]);
+ } else {
+ idsToDocs.set(id, [[currentDoc, resultsIdx]]);
+ }
+ });
+
+ // in the case of new_edits, the user can provide multiple docs
+ // with the same id. these need to be processed sequentially
+ idsToDocs.forEach(function (docs, id) {
+ var numDone = 0;
+
+ function docWritten() {
+ checkDoneWritingDocs();
+ if (++numDone < docs.length) {
+ nextDoc();
+ }
+ }
+ function nextDoc() {
+ var value = docs[numDone];
+ var currentDoc = value[0];
+ var resultsIdx = value[1];
+
+ if (fetchedDocs.has(id)) {
+ updateDoc(fetchedDocs.get(id), currentDoc, resultsIdx, docWritten);
+ } else {
+ insertDoc(currentDoc, resultsIdx, docWritten);
+ }
+ }
+ nextDoc();
+ });
+ }
+
+ function fetchExistingDocs(callback) {
+ if (!docInfos.length) {
+ return callback();
+ }
+
+ var numFetched = 0;
+
+ function checkDone() {
+ if (++numFetched === docInfos.length) {
+ callback();
+ }
+ }
+
+ docInfos.forEach(function (docInfo) {
+ if (docInfo._id && utils.isLocalId(docInfo._id)) {
+ return checkDone(); // skip local docs
+ }
+ var id = docInfo.metadata.id;
+ tx.executeSql('SELECT json FROM ' + DOC_STORE +
+ ' WHERE id = ?', [id], function (tx, result) {
+ if (result.rows.length) {
+ var metadata = JSON.parse(result.rows.item(0).json);
+ fetchedDocs.set(id, metadata);
+ }
+ checkDone();
+ });
+ });
+ }
+
+ // Insert sequence number into the error so we can sort later
+ function makeErr(err, seq) {
+ err._bulk_seq = seq;
+ return err;
+ }
+
+ function saveAttachment(docInfo, digest, data, callback) {
+ var ref = [docInfo.metadata.id, docInfo.metadata.rev].join('@');
+ var newAtt = {digest: digest};
+ var sql = 'SELECT digest, json FROM ' + ATTACH_STORE + ' WHERE digest=?';
+ tx.executeSql(sql, [digest], function (tx, result) {
+ if (!result.rows.length) {
+ newAtt.refs = {};
+ newAtt.refs[ref] = true;
+ sql = 'INSERT INTO ' + ATTACH_STORE +
+ '(digest, json, body) VALUES (?, ?, ?)';
+ tx.executeSql(sql, [digest, JSON.stringify(newAtt), data],
+ function () {
+ callback();
+ });
+ } else {
+ newAtt.refs = JSON.parse(result.rows.item(0).json).refs;
+ sql = 'UPDATE ' + ATTACH_STORE + ' SET json=?, body=? WHERE digest=?';
+ tx.executeSql(sql, [JSON.stringify(newAtt), data, digest],
+ function () {
+ callback();
+ });
+ }
+ });
+ }
+
+ preprocessAttachments(function () {
+ db.transaction(function (txn) {
+ tx = txn;
+ fetchExistingDocs(processDocs);
+ }, unknownError(callback), function () {
+ docCount = -1;
+ });
+ });
+ };
+
+ api._get = function (id, opts, callback) {
+ opts = utils.clone(opts);
+ var doc;
+ var metadata;
+ var err;
+ if (!opts.ctx) {
+ db.readTransaction(function (txn) {
+ opts.ctx = txn;
+ api._get(id, opts, callback);
+ });
+ return;
+ }
+ var tx = opts.ctx;
+
+ function finish() {
+ callback(err, {doc: doc, metadata: metadata, ctx: tx});
+ }
+
+ var sql;
+ var sqlArgs;
+ if (opts.rev) {
+ sql = select(
+ SELECT_DOCS,
+ [DOC_STORE, BY_SEQ_STORE],
+ DOC_STORE + '.id=' + BY_SEQ_STORE + '.doc_id',
+ [BY_SEQ_STORE + '.doc_id=?', BY_SEQ_STORE + '.rev=?']);
+ sqlArgs = [id, opts.rev];
+ } else {
+ sql = select(
+ SELECT_DOCS,
+ [DOC_STORE, BY_SEQ_STORE],
+ DOC_STORE_AND_BY_SEQ_JOINER,
+ DOC_STORE + '.id=?');
+ sqlArgs = [id];
+ }
+ tx.executeSql(sql, sqlArgs, function (a, results) {
+ if (!results.rows.length) {
+ err = errors.MISSING_DOC;
+ return finish();
+ }
+ var item = results.rows.item(0);
+ metadata = JSON.parse(item.metadata);
+ if (item.deleted && !opts.rev) {
+ err = errors.error(errors.MISSING_DOC, 'deleted');
+ return finish();
+ }
+ doc = unstringifyDoc(item.data, metadata.id, item.rev);
+ finish();
+ });
+ };
+
+ function countDocs(tx, callback) {
+
+ if (docCount !== -1) {
+ return callback(docCount);
+ }
+
+ // count the total rows
+ var sql = select(
+ 'COUNT(' + DOC_STORE + '.id) AS \'num\'',
+ [DOC_STORE, BY_SEQ_STORE],
+ DOC_STORE_AND_BY_SEQ_JOINER,
+ BY_SEQ_STORE + '.deleted=0');
+
+ tx.executeSql(sql, [], function (tx, result) {
+ docCount = result.rows.item(0).num;
+ callback(docCount);
+ });
+ }
+
+ api._allDocs = function (opts, callback) {
+ var results = [];
+ var totalRows;
+
+ var start = 'startkey' in opts ? opts.startkey : false;
+ var end = 'endkey' in opts ? opts.endkey : false;
+ var key = 'key' in opts ? opts.key : false;
+ var descending = 'descending' in opts ? opts.descending : false;
+ var limit = 'limit' in opts ? opts.limit : -1;
+ var offset = 'skip' in opts ? opts.skip : 0;
+ var inclusiveEnd = opts.inclusive_end !== false;
+
+ var sqlArgs = [];
+ var criteria = [];
+
+ if (key !== false) {
+ criteria.push(DOC_STORE + '.id = ?');
+ sqlArgs.push(key);
+ } else if (start !== false || end !== false) {
+ if (start !== false) {
+ criteria.push(DOC_STORE + '.id ' + (descending ? '<=' : '>=') + ' ?');
+ sqlArgs.push(start);
+ }
+ if (end !== false) {
+ var comparator = descending ? '>' : '<';
+ if (inclusiveEnd) {
+ comparator += '=';
+ }
+ criteria.push(DOC_STORE + '.id ' + comparator + ' ?');
+ sqlArgs.push(end);
+ }
+ if (key !== false) {
+ criteria.push(DOC_STORE + '.id = ?');
+ sqlArgs.push(key);
+ }
+ }
+
+ if (opts.deleted !== 'ok') {
+ // report deleted if keys are specified
+ criteria.push(BY_SEQ_STORE + '.deleted = 0');
+ }
+
+ db.readTransaction(function (tx) {
+
+ // first count up the total rows
+ countDocs(tx, function (count) {
+ totalRows = count;
+
+ if (limit === 0) {
+ return;
+ }
+
+ // then actually fetch the documents
+ var sql = select(
+ SELECT_DOCS,
+ [DOC_STORE, BY_SEQ_STORE],
+ DOC_STORE_AND_BY_SEQ_JOINER,
+ criteria,
+ DOC_STORE + '.id ' + (descending ? 'DESC' : 'ASC')
+ );
+ sql += ' LIMIT ' + limit + ' OFFSET ' + offset;
+
+ tx.executeSql(sql, sqlArgs, function (tx, result) {
+ for (var i = 0, l = result.rows.length; i < l; i++) {
+ var item = result.rows.item(i);
+ var metadata = JSON.parse(item.metadata);
+ var data = unstringifyDoc(item.data, metadata.id, item.rev);
+ var winningRev = data._rev;
+ var doc = {
+ id: metadata.id,
+ key: metadata.id,
+ value: {rev: winningRev}
+ };
+ if (opts.include_docs) {
+ doc.doc = data;
+ doc.doc._rev = winningRev;
+ if (opts.conflicts) {
+ doc.doc._conflicts = merge.collectConflicts(metadata);
+ }
+ for (var att in doc.doc._attachments) {
+ if (doc.doc._attachments.hasOwnProperty(att)) {
+ doc.doc._attachments[att].stub = true;
+ }
+ }
+ }
+ if (item.deleted) {
+ if (opts.deleted === 'ok') {
+ doc.value.deleted = true;
+ doc.doc = null;
+ } else {
+ continue;
+ }
+ }
+ results.push(doc);
+ }
+ });
+ });
+ }, unknownError(callback), function () {
+ callback(null, {
+ total_rows: totalRows,
+ offset: opts.skip,
+ rows: results
+ });
+ });
+ };
+
+ api._changes = function (opts) {
+ opts = utils.clone(opts);
+
+ if (opts.continuous) {
+ var id = name + ':' + utils.uuid();
+ WebSqlPouch.Changes.addListener(name, id, api, opts);
+ WebSqlPouch.Changes.notify(name);
+ return {
+ cancel: function () {
+ WebSqlPouch.Changes.removeListener(name, id);
+ }
+ };
+ }
+
+ var descending = opts.descending;
+
+ // Ignore the `since` parameter when `descending` is true
+ opts.since = opts.since && !descending ? opts.since : 0;
+
+ var limit = 'limit' in opts ? opts.limit : -1;
+ if (limit === 0) {
+ limit = 1; // per CouchDB _changes spec
+ }
+
+ var returnDocs;
+ if ('returnDocs' in opts) {
+ returnDocs = opts.returnDocs;
+ } else {
+ returnDocs = true;
+ }
+ var results = [];
+ var numResults = 0;
+ function fetchChanges() {
+
+ var criteria = [
+ DOC_STORE + '.winningseq > ' + opts.since
+ ];
+ var sqlArgs = [];
+ if (opts.doc_ids) {
+ criteria.push(DOC_STORE + '.id IN (' + opts.doc_ids.map(function () {
+ return '?';
+ }).join(',') + ')');
+ sqlArgs = opts.doc_ids;
+ }
+
+ var sql = select(SELECT_DOCS, [DOC_STORE, BY_SEQ_STORE],
+ DOC_STORE_AND_BY_SEQ_JOINER, criteria,
+ DOC_STORE + '.winningseq ' + (descending ? 'DESC' : 'ASC'));
+
+ var filter = utils.filterChange(opts);
+ if (!opts.view && !opts.filter) {
+ // we can just limit in the query
+ sql += ' LIMIT ' + limit;
+ }
+
+ db.readTransaction(function (tx) {
+ tx.executeSql(sql, sqlArgs, function (tx, result) {
+ var lastSeq = 0;
+ for (var i = 0, l = result.rows.length; i < l; i++) {
+ var res = result.rows.item(i);
+ var metadata = JSON.parse(res.metadata);
+ if (lastSeq < res.seq) {
+ lastSeq = res.seq;
+ }
+ var doc = unstringifyDoc(res.data, metadata.id, res.rev);
+ var change = opts.processChange(doc, metadata, opts);
+ change.seq = res.seq;
+ if (filter(change)) {
+ numResults++;
+ if (returnDocs) {
+ results.push(change);
+ }
+ opts.onChange(change);
+ }
+ if (numResults === limit) {
+ break;
+ }
+ }
+ if (!opts.continuous) {
+ opts.complete(null, {
+ results: results,
+ last_seq: lastSeq
+ });
+ }
+ });
+ });
+ }
+
+ fetchChanges();
+ };
+
+ api._close = function (callback) {
+ //WebSQL databases do not need to be closed
+ callback();
+ };
+
+ api._getAttachment = function (attachment, opts, callback) {
+ var res;
+ var tx = opts.ctx;
+ var digest = attachment.digest;
+ var type = attachment.content_type;
+ var sql = 'SELECT hex(body) as body FROM ' + ATTACH_STORE +
+ ' WHERE digest=?';
+ tx.executeSql(sql, [digest], function (tx, result) {
+ // sqlite normally stores data as utf8, so even the hex() function
+ // "encodes" the binary data in utf8/16 before returning it. yet hex()
+ // is the only way to get the full data, so we do this.
+ var data = parseHexString(result.rows.item(0).body, encoding);
+ if (opts.encode) {
+ res = btoa(data);
+ } else {
+ data = utils.fixBinary(data);
+ res = utils.createBlob([data], {type: type});
+ }
+ callback(null, res);
+ });
+ };
+
+ api._getRevisionTree = function (docId, callback) {
+ db.readTransaction(function (tx) {
+ var sql = 'SELECT json AS metadata FROM ' + DOC_STORE + ' WHERE id = ?';
+ tx.executeSql(sql, [docId], function (tx, result) {
+ if (!result.rows.length) {
+ callback(errors.MISSING_DOC);
+ } else {
+ var data = JSON.parse(result.rows.item(0).metadata);
+ callback(null, data.rev_tree);
+ }
+ });
+ });
+ };
+
+ api._doCompaction = function (docId, rev_tree, revs, callback) {
+ if (!revs.length) {
+ return callback();
+ }
+ db.transaction(function (tx) {
+ var sql = 'SELECT json AS metadata FROM ' + DOC_STORE + ' WHERE id = ?';
+ tx.executeSql(sql, [docId], function (tx, result) {
+ if (!result.rows.length) {
+ return utils.call(callback);
+ }
+ var metadata = JSON.parse(result.rows.item(0).metadata);
+ metadata.rev_tree = rev_tree;
+
+ var numDone = 0;
+ revs.forEach(function (rev) {
+ var sql = 'DELETE FROM ' + BY_SEQ_STORE + ' WHERE doc_id=? AND rev=?';
+ tx.executeSql(sql, [docId, rev], function (tx) {
+ if (++numDone === revs.length) {
+ var sql = 'UPDATE ' + DOC_STORE + ' SET json = ? WHERE id = ?';
+ tx.executeSql(sql, [JSON.stringify(metadata), docId],
+ function () {
+ callback();
+ });
+ }
+ });
+ });
+ });
+ });
+ };
+
+ api._getLocal = function (id, callback) {
+ db.readTransaction(function (tx) {
+ var sql = 'SELECT json, rev FROM ' + LOCAL_STORE + ' WHERE id=?';
+ tx.executeSql(sql, [id], function (tx, res) {
+ if (res.rows.length) {
+ var item = res.rows.item(0);
+ var doc = unstringifyDoc(item.json, id, item.rev);
+ callback(null, doc);
+ } else {
+ callback(errors.MISSING_DOC);
+ }
+ });
+ });
+ };
+
+ api._putLocal = function (doc, opts, callback) {
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ var oldRev = doc._rev;
+ var id = doc._id;
+ var newRev;
+ if (!oldRev) {
+ newRev = doc._rev = '0-0';
+ } else {
+ newRev = doc._rev = '0-' + (parseInt(oldRev.split('-')[1], 10) + 1);
+ }
+ var json = stringifyDoc(doc);
+
+ var ret;
+ function putLocal(tx) {
+ var sql;
+ var values;
+ if (oldRev) {
+ sql = 'UPDATE ' + LOCAL_STORE + ' SET rev=?, json=? ' +
+ 'WHERE id=? AND rev=?';
+ values = [newRev, json, id, oldRev];
+ } else {
+ sql = 'INSERT INTO ' + LOCAL_STORE + ' (id, rev, json) VALUES (?,?,?)';
+ values = [id, newRev, json];
+ }
+ tx.executeSql(sql, values, function (tx, res) {
+ if (res.rowsAffected) {
+ ret = {ok: true, id: id, rev: newRev};
+ if (opts.ctx) { // return immediately
+ callback(null, ret);
+ }
+ } else {
+ callback(errors.REV_CONFLICT);
+ }
+ }, function () {
+ callback(errors.REV_CONFLICT);
+ return false; // ack that we handled the error
+ });
+ }
+
+ if (opts.ctx) {
+ putLocal(opts.ctx);
+ } else {
+ db.transaction(function (tx) {
+ putLocal(tx);
+ }, unknownError(callback), function () {
+ if (ret) {
+ callback(null, ret);
+ }
+ });
+ }
+ };
+
+ api._removeLocal = function (doc, callback) {
+ var ret;
+ db.transaction(function (tx) {
+ var sql = 'DELETE FROM ' + LOCAL_STORE + ' WHERE id=? AND rev=?';
+ var params = [doc._id, doc._rev];
+ tx.executeSql(sql, params, function (tx, res) {
+ if (!res.rowsAffected) {
+ return callback(errors.REV_CONFLICT);
+ }
+ ret = {ok: true, id: doc._id, rev: '0-0'};
+ });
+ }, unknownError(callback), function () {
+ callback(null, ret);
+ });
+ };
+}
+
+WebSqlPouch.valid = function () {
+ if (typeof global !== 'undefined') {
+ if (global.navigator &&
+ global.navigator.sqlitePlugin &&
+ global.navigator.sqlitePlugin.openDatabase) {
+ return true;
+ } else if (global.sqlitePlugin && global.sqlitePlugin.openDatabase) {
+ return true;
+ } else if (global.openDatabase) {
+ return true;
+ }
+ }
+ return false;
+};
+
+WebSqlPouch.destroy = utils.toPromise(function (name, opts, callback) {
+ WebSqlPouch.Changes.removeAllListeners(name);
+ var size = getSize(opts);
+ var db = openDB(name, POUCH_VERSION, name, size);
+ db.transaction(function (tx) {
+ var stores = [DOC_STORE, BY_SEQ_STORE, ATTACH_STORE, META_STORE,
+ LOCAL_STORE];
+ stores.forEach(function (store) {
+ tx.executeSql('DROP TABLE IF EXISTS ' + store, []);
+ });
+ }, unknownError(callback), function () {
+ if (utils.hasLocalStorage()) {
+ delete global.localStorage['_pouch__websqldb_' + name];
+ delete global.localStorage[name];
+ }
+ callback(null, {'ok': true});
+ });
+});
+
+WebSqlPouch.Changes = new utils.Changes();
+
+module.exports = WebSqlPouch;
+
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"../deps/errors":11,"../merge":18,"../utils":23}],6:[function(_dereq_,module,exports){
+'use strict';
+var utils = _dereq_('./utils');
+var merge = _dereq_('./merge');
+var errors = _dereq_('./deps/errors');
+var EE = _dereq_('events').EventEmitter;
+var evalFilter = _dereq_('./evalFilter');
+var evalView = _dereq_('./evalView');
+module.exports = Changes;
+utils.inherits(Changes, EE);
+
+function Changes(db, opts, callback) {
+ EE.call(this);
+ var self = this;
+ this.db = db;
+ opts = opts ? utils.clone(opts) : {};
+ var oldComplete = callback || opts.complete || function () {};
+ var complete = opts.complete = utils.once(function (err, resp) {
+ if (err) {
+ self.emit('error', err);
+ } else {
+ self.emit('complete', resp);
+ }
+ self.removeAllListeners();
+ db.removeListener('destroyed', onDestroy);
+ });
+ if (oldComplete) {
+ self.on('complete', function (resp) {
+ oldComplete(null, resp);
+ });
+ self.on('error', function (err) {
+ oldComplete(err);
+ });
+ }
+ var oldOnChange = opts.onChange;
+ if (oldOnChange) {
+ self.on('change', oldOnChange);
+ }
+ function onDestroy() {
+ self.cancel();
+ }
+ db.once('destroyed', onDestroy);
+
+ opts.onChange = function (change) {
+ if (opts.isCancelled) {
+ return;
+ }
+ self.emit('change', change);
+ if (self.startSeq && self.startSeq <= change.seq) {
+ self.emit('uptodate');
+ self.startSeq = false;
+ }
+ if (change.deleted) {
+ self.emit('delete', change);
+ } else if (change.changes.length === 1 &&
+ change.changes[0].rev.slice(0, 2) === '1-') {
+ self.emit('create', change);
+ } else {
+ self.emit('update', change);
+ }
+ };
+
+ var promise = new utils.Promise(function (fulfill, reject) {
+ opts.complete = function (err, res) {
+ if (err) {
+ reject(err);
+ } else {
+ fulfill(res);
+ }
+ };
+ });
+ self.once('cancel', function () {
+ if (oldOnChange) {
+ self.removeListener('change', oldOnChange);
+ }
+ opts.complete(null, {status: 'cancelled'});
+ });
+ this.then = promise.then.bind(promise);
+ this['catch'] = promise['catch'].bind(promise);
+ this.then(function (result) {
+ complete(null, result);
+ }, complete);
+
+
+
+ if (!db.taskqueue.isReady) {
+ db.taskqueue.addTask(function () {
+ if (self.isCancelled) {
+ self.emit('cancel');
+ } else {
+ self.doChanges(opts);
+ }
+ });
+ } else {
+ self.doChanges(opts);
+ }
+}
+Changes.prototype.cancel = function () {
+ this.isCancelled = true;
+ if (this.db.taskqueue.isReady) {
+ this.emit('cancel');
+ }
+};
+function processChange(doc, metadata, opts) {
+ var changeList = [{rev: doc._rev}];
+ if (opts.style === 'all_docs') {
+ changeList = merge.collectLeaves(metadata.rev_tree)
+ .map(function (x) { return {rev: x.rev}; });
+ }
+ var change = {
+ id: metadata.id,
+ changes: changeList,
+ doc: doc
+ };
+
+ if (utils.isDeleted(metadata, doc._rev)) {
+ change.deleted = true;
+ }
+ if (opts.conflicts) {
+ change.doc._conflicts = merge.collectConflicts(metadata);
+ if (!change.doc._conflicts.length) {
+ delete change.doc._conflicts;
+ }
+ }
+ return change;
+}
+
+Changes.prototype.doChanges = function (opts) {
+ var self = this;
+ var callback = opts.complete;
+
+ opts = utils.clone(opts);
+ if ('live' in opts && !('continuous' in opts)) {
+ opts.continuous = opts.live;
+ }
+ opts.processChange = processChange;
+
+ if (opts.since === 'latest') {
+ opts.since = 'now';
+ }
+ if (!opts.since) {
+ opts.since = 0;
+ }
+ if (opts.since === 'now') {
+ this.db.info().then(function (info) {
+ if (self.isCancelled) {
+ callback(null, {status: 'cancelled'});
+ return;
+ }
+ opts.since = info.update_seq - 1;
+ self.doChanges(opts);
+ }, callback);
+ return;
+ }
+
+ if (opts.continuous && opts.since !== 'now') {
+ this.db.info().then(function (info) {
+ self.startSeq = info.update_seq - 1;
+ }, function (err) {
+ if (err.id === 'idbNull') {
+ //db closed before this returned
+ //thats ok
+ return;
+ }
+ throw err;
+ });
+ }
+
+ if (this.db.type() !== 'http' &&
+ opts.filter && typeof opts.filter === 'string') {
+ return this.filterChanges(opts);
+ }
+
+ if (!('descending' in opts)) {
+ opts.descending = false;
+ }
+
+ // 0 and 1 should return 1 document
+ opts.limit = opts.limit === 0 ? 1 : opts.limit;
+ opts.complete = callback;
+ var newPromise = this.db._changes(opts);
+ if (newPromise && typeof newPromise.cancel === 'function') {
+ var cancel = self.cancel;
+ self.cancel = utils.getArguments(function (args) {
+ newPromise.cancel();
+ cancel.apply(this, args);
+ });
+ }
+};
+
+Changes.prototype.filterChanges = function (opts) {
+ var self = this;
+ var callback = opts.complete;
+ if (opts.filter === '_view') {
+ if (!opts.view || typeof opts.view !== 'string') {
+ var err = new Error('`view` filter parameter is not provided.');
+ err.status = errors.BAD_REQUEST.status;
+ err.name = errors.BAD_REQUEST.name;
+ err.error = true;
+ callback(err);
+ return;
+ }
+ // fetch a view from a design doc, make it behave like a filter
+ var viewName = opts.view.split('/');
+ this.db.get('_design/' + viewName[0], function (err, ddoc) {
+ if (self.isCancelled) {
+ callback(null, {status: 'cancelled'});
+ return;
+ }
+ if (err) {
+ callback(err);
+ return;
+ }
+ if (ddoc && ddoc.views && ddoc.views[viewName[1]]) {
+
+ var filter = evalView(ddoc.views[viewName[1]].map);
+ opts.filter = filter;
+ self.doChanges(opts);
+ return;
+ }
+ var msg = ddoc.views ? 'missing json key: ' + viewName[1] :
+ 'missing json key: views';
+ if (!err) {
+ err = new Error(msg);
+ err.status = errors.MISSING_DOC.status;
+ err.name = errors.MISSING_DOC.name;
+ err.error = true;
+ }
+ callback(err);
+ return;
+ });
+ } else {
+ // fetch a filter from a design doc
+ var filterName = opts.filter.split('/');
+ this.db.get('_design/' + filterName[0], function (err, ddoc) {
+ if (self.isCancelled) {
+ callback(null, {status: 'cancelled'});
+ return;
+ }
+ if (err) {
+ callback(err);
+ return;
+ }
+ if (ddoc && ddoc.filters && ddoc.filters[filterName[1]]) {
+ var filter = evalFilter(ddoc.filters[filterName[1]]);
+ opts.filter = filter;
+ self.doChanges(opts);
+ return;
+ } else {
+ var msg = (ddoc && ddoc.filters) ? 'missing json key: ' + filterName[1]
+ : 'missing json key: filters';
+ if (!err) {
+ err = new Error(msg);
+ err.status = errors.MISSING_DOC.status;
+ err.name = errors.MISSING_DOC.name;
+ err.error = true;
+ }
+ callback(err);
+ return;
+ }
+ });
+ }
+};
+},{"./deps/errors":11,"./evalFilter":15,"./evalView":16,"./merge":18,"./utils":23,"events":27}],7:[function(_dereq_,module,exports){
+(function (global){
+/*globals cordova */
+"use strict";
+
+var Adapter = _dereq_('./adapter');
+var utils = _dereq_('./utils');
+var TaskQueue = _dereq_('./taskqueue');
+var Promise = utils.Promise;
+
+function defaultCallback(err) {
+ if (err && global.debug) {
+ console.error(err);
+ }
+}
+
+utils.inherits(PouchDB, Adapter);
+function PouchDB(name, opts, callback) {
+
+ if (!(this instanceof PouchDB)) {
+ return new PouchDB(name, opts, callback);
+ }
+ var self = this;
+ if (typeof opts === 'function' || typeof opts === 'undefined') {
+ callback = opts;
+ opts = {};
+ }
+
+ if (name && typeof name === 'object') {
+ opts = name;
+ name = undefined;
+ }
+ if (typeof callback === 'undefined') {
+ callback = defaultCallback;
+ }
+ opts = opts || {};
+ var oldCB = callback;
+ self.auto_compaction = opts.auto_compaction;
+ self.prefix = PouchDB.prefix;
+ Adapter.call(self);
+ self.taskqueue = new TaskQueue();
+ var promise = new Promise(function (fulfill, reject) {
+ callback = function (err, resp) {
+ if (err) {
+ return reject(err);
+ }
+ delete resp.then;
+ fulfill(resp);
+ };
+
+ opts = utils.clone(opts);
+ var originalName = opts.name || name;
+ var backend, error;
+ (function () {
+ try {
+
+ if (typeof originalName !== 'string') {
+ error = new Error('Missing/invalid DB name');
+ error.code = 400;
+ throw error;
+ }
+
+ backend = PouchDB.parseAdapter(originalName, opts);
+
+ opts.originalName = originalName;
+ opts.name = backend.name;
+ if (opts.prefix && backend.adapter !== 'http' &&
+ backend.adapter !== 'https') {
+ opts.name = opts.prefix + opts.name;
+ }
+ opts.adapter = opts.adapter || backend.adapter;
+ self._adapter = opts.adapter;
+ self._db_name = originalName;
+ if (!PouchDB.adapters[opts.adapter]) {
+ error = new Error('Adapter is missing');
+ error.code = 404;
+ throw error;
+ }
+
+ if (!PouchDB.adapters[opts.adapter].valid()) {
+ error = new Error('Invalid Adapter');
+ error.code = 404;
+ throw error;
+ }
+ } catch (err) {
+ self.taskqueue.fail(err);
+ self.changes = utils.toPromise(function (opts) {
+ if (opts.complete) {
+ opts.complete(err);
+ }
+ });
+ }
+ }());
+ if (error) {
+ return reject(error); // constructor error, see above
+ }
+ self.adapter = opts.adapter;
+
+ // needs access to PouchDB;
+ self.replicate = {};
+
+ self.replicate.from = function (url, opts, callback) {
+ return self.constructor.replicate(url, self, opts, callback);
+ };
+
+ self.replicate.to = function (url, opts, callback) {
+ return self.constructor.replicate(self, url, opts, callback);
+ };
+
+ self.sync = function (dbName, opts, callback) {
+ return self.constructor.sync(self, dbName, opts, callback);
+ };
+
+ self.replicate.sync = self.sync;
+
+ self.destroy = utils.adapterFun('destroy', function (callback) {
+ var self = this;
+ self.info(function (err, info) {
+ if (err) {
+ return callback(err);
+ }
+ self.constructor.destroy(info.db_name, callback);
+ });
+ });
+
+ PouchDB.adapters[opts.adapter].call(self, opts, function (err, db) {
+ if (err) {
+ if (callback) {
+ self.taskqueue.fail(err);
+ callback(err);
+ }
+ return;
+ }
+ function destructionListener(event) {
+ if (event === 'destroyed') {
+ self.emit('destroyed');
+ PouchDB.removeListener(originalName, destructionListener);
+ }
+ }
+ PouchDB.on(originalName, destructionListener);
+ self.emit('created', self);
+ PouchDB.emit('created', opts.originalName);
+ self.taskqueue.ready(self);
+ callback(null, self);
+
+ });
+ if (opts.skipSetup) {
+ self.taskqueue.ready(self);
+ }
+
+ if (utils.isCordova()) {
+ //to inform websql adapter that we can use api
+ cordova.fireWindowEvent(opts.name + "_pouch", {});
+ }
+ });
+ promise.then(function (resp) {
+ oldCB(null, resp);
+ }, oldCB);
+ self.then = promise.then.bind(promise);
+ self["catch"] = promise["catch"].bind(promise);
+
+}
+
+module.exports = PouchDB;
+
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./adapter":1,"./taskqueue":22,"./utils":23}],8:[function(_dereq_,module,exports){
+"use strict";
+
+var createBlob = _dereq_('./blob.js');
+var errors = _dereq_('./errors');
+var utils = _dereq_("../utils");
+var hasUpload;
+
+function ajax(options, adapterCallback) {
+
+ var requestCompleted = false;
+ var callback = utils.getArguments(function (args) {
+ if (requestCompleted) {
+ return;
+ }
+ adapterCallback.apply(this, args);
+ requestCompleted = true;
+ });
+
+ if (typeof options === "function") {
+ callback = options;
+ options = {};
+ }
+
+ options = utils.clone(options);
+
+ var defaultOptions = {
+ method : "GET",
+ headers: {},
+ json: true,
+ processData: true,
+ timeout: 10000,
+ cache: false
+ };
+
+ options = utils.extend(true, defaultOptions, options);
+
+ // cache-buster, specifically designed to work around IE's aggressive caching
+ // see http://www.dashbay.com/2011/05/internet-explorer-caches-ajax/
+ if (options.method === 'GET' && !options.cache) {
+ var hasArgs = options.url.indexOf('?') !== -1;
+ options.url += (hasArgs ? '&' : '?') + '_nonce=' + utils.uuid(16);
+ }
+
+ function onSuccess(obj, resp, cb) {
+ if (!options.binary && !options.json && options.processData &&
+ typeof obj !== 'string') {
+ obj = JSON.stringify(obj);
+ } else if (!options.binary && options.json && typeof obj === 'string') {
+ try {
+ obj = JSON.parse(obj);
+ } catch (e) {
+ // Probably a malformed JSON from server
+ return cb(e);
+ }
+ }
+ if (Array.isArray(obj)) {
+ obj = obj.map(function (v) {
+ var obj;
+ if (v.ok) {
+ return v;
+ } else if (v.error && v.error === 'conflict') {
+ obj = errors.REV_CONFLICT;
+ obj.id = v.id;
+ return obj;
+ } else if (v.error && v.error === 'forbidden') {
+ obj = errors.FORBIDDEN;
+ obj.id = v.id;
+ obj.reason = v.reason;
+ return obj;
+ } else if (v.missing) {
+ obj = errors.MISSING_DOC;
+ obj.missing = v.missing;
+ return obj;
+ } else {
+ return v;
+ }
+ });
+ }
+ cb(null, obj, resp);
+ }
+
+ function onError(err, cb) {
+ var errParsed, errObj, errType, key;
+ try {
+ errParsed = JSON.parse(err.responseText);
+ //would prefer not to have a try/catch clause
+ for (key in errors) {
+ if (errors.hasOwnProperty(key) &&
+ errors[key].name === errParsed.error) {
+ errType = errors[key];
+ break;
+ }
+ }
+ if (!errType) {
+ errType = errors.UNKNOWN_ERROR;
+ if (err.status) {
+ errType.status = err.status;
+ }
+ if (err.statusText) {
+ err.name = err.statusText;
+ }
+ }
+ errObj = errors.error(errType, errParsed.reason);
+ } catch (e) {
+ for (var key in errors) {
+ if (errors.hasOwnProperty(key) && errors[key].status === err.status) {
+ errType = errors[key];
+ break;
+ }
+ }
+ if (!errType) {
+ errType = errors.UNKNOWN_ERROR;
+ if (err.status) {
+ errType.status = err.status;
+ }
+ if (err.statusText) {
+ err.name = err.statusText;
+ }
+ }
+ errObj = errors.error(errType);
+ }
+ if (err.withCredentials && err.status === 0) {
+ // apparently this is what we get when the method
+ // is reported as not allowed by CORS. so fudge it
+ errObj.status = 405;
+ errObj.statusText = "Method Not Allowed";
+ }
+ cb(errObj);
+ }
+
+ var timer;
+ var xhr;
+ if (options.xhr) {
+ xhr = new options.xhr();
+ } else {
+ xhr = new XMLHttpRequest();
+ }
+ xhr.open(options.method, options.url);
+ xhr.withCredentials = true;
+
+ if (options.json) {
+ options.headers.Accept = 'application/json';
+ options.headers['Content-Type'] = options.headers['Content-Type'] ||
+ 'application/json';
+ if (options.body &&
+ options.processData &&
+ typeof options.body !== "string") {
+ options.body = JSON.stringify(options.body);
+ }
+ }
+
+ if (options.binary) {
+ xhr.responseType = 'arraybuffer';
+ }
+
+ var createCookie = function (name, value, days) {
+ var expires = "";
+ if (days) {
+ var date = new Date();
+ date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+ expires = "; expires=" + date.toGMTString();
+ }
+ document.cookie = name + "=" + value + expires + "; path=/";
+ };
+
+ for (var key in options.headers) {
+ if (key === 'Cookie') {
+ var cookie = options.headers[key].split('=');
+ createCookie(cookie[0], cookie[1], 10);
+ } else {
+ xhr.setRequestHeader(key, options.headers[key]);
+ }
+ }
+
+ if (!("body" in options)) {
+ options.body = null;
+ }
+
+ var abortReq = function () {
+ if (requestCompleted) {
+ return;
+ }
+ xhr.abort();
+ onError(xhr, callback);
+ };
+
+ xhr.onreadystatechange = function () {
+ if (xhr.readyState !== 4 || requestCompleted) {
+ return;
+ }
+ clearTimeout(timer);
+ if (xhr.status >= 200 && xhr.status < 300) {
+ var data;
+ if (options.binary) {
+ data = createBlob([xhr.response || ''], {
+ type: xhr.getResponseHeader('Content-Type')
+ });
+ } else {
+ data = xhr.responseText;
+ }
+ onSuccess(data, xhr, callback);
+ } else {
+ onError(xhr, callback);
+ }
+ };
+
+ if (options.timeout > 0) {
+ timer = setTimeout(abortReq, options.timeout);
+ xhr.onprogress = function () {
+ clearTimeout(timer);
+ timer = setTimeout(abortReq, options.timeout);
+ };
+ if (typeof hasUpload === 'undefined') {
+ // IE throws an error if you try to access it directly
+ hasUpload = Object.keys(xhr).indexOf('upload') !== -1;
+ }
+ if (hasUpload) { // does not exist in ie9
+ xhr.upload.onprogress = xhr.onprogress;
+ }
+ }
+ if (options.body && (options.body instanceof Blob)) {
+ var reader = new FileReader();
+ reader.onloadend = function (e) {
+
+ var binary = "";
+ var bytes = new Uint8Array(this.result);
+ var length = bytes.byteLength;
+
+ for (var i = 0; i < length; i++) {
+ binary += String.fromCharCode(bytes[i]);
+ }
+
+ binary = utils.fixBinary(binary);
+ xhr.send(binary);
+ };
+ reader.readAsArrayBuffer(options.body);
+ } else {
+ xhr.send(options.body);
+ }
+ return {abort: abortReq};
+}
+
+module.exports = ajax;
+
+},{"../utils":23,"./blob.js":9,"./errors":11}],9:[function(_dereq_,module,exports){
+(function (global){
+"use strict";
+
+//Abstracts constructing a Blob object, so it also works in older
+//browsers that don't support the native Blob constructor. (i.e.
+//old QtWebKit versions, at least).
+function createBlob(parts, properties) {
+ parts = parts || [];
+ properties = properties || {};
+ try {
+ return new Blob(parts, properties);
+ } catch (e) {
+ if (e.name !== "TypeError") {
+ throw e;
+ }
+ var BlobBuilder = global.BlobBuilder ||
+ global.MSBlobBuilder ||
+ global.MozBlobBuilder ||
+ global.WebKitBlobBuilder;
+ var builder = new BlobBuilder();
+ for (var i = 0; i < parts.length; i += 1) {
+ builder.append(parts[i]);
+ }
+ return builder.getBlob(properties.type);
+ }
+}
+
+module.exports = createBlob;
+
+
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],10:[function(_dereq_,module,exports){
+'use strict';
+exports.Map = LazyMap; // TODO: use ES6 map
+exports.Set = LazySet; // TODO: use ES6 set
+// based on https://github.com/montagejs/collections
+function LazyMap() {
+ this.store = {};
+}
+LazyMap.prototype.mangle = function (key) {
+ if (typeof key !== "string") {
+ throw new TypeError("key must be a string but Got " + key);
+ }
+ return '$' + key;
+};
+LazyMap.prototype.unmangle = function (key) {
+ return key.substring(1);
+};
+LazyMap.prototype.get = function (key) {
+ var mangled = this.mangle(key);
+ if (mangled in this.store) {
+ return this.store[mangled];
+ } else {
+ return void 0;
+ }
+};
+LazyMap.prototype.set = function (key, value) {
+ var mangled = this.mangle(key);
+ this.store[mangled] = value;
+ return true;
+};
+LazyMap.prototype.has = function (key) {
+ var mangled = this.mangle(key);
+ return mangled in this.store;
+};
+LazyMap.prototype["delete"] = function (key) {
+ var mangled = this.mangle(key);
+ if (mangled in this.store) {
+ delete this.store[mangled];
+ return true;
+ }
+ return false;
+};
+LazyMap.prototype.forEach = function (cb) {
+ var self = this;
+ var keys = Object.keys(self.store);
+ keys.forEach(function (key) {
+ var value = self.store[key];
+ key = self.unmangle(key);
+ cb(value, key);
+ });
+};
+
+function LazySet() {
+ this.store = new LazyMap();
+}
+LazySet.prototype.add = function (key) {
+ return this.store.set(key, true);
+};
+LazySet.prototype.has = function (key) {
+ return this.store.has(key);
+};
+LazySet.prototype["delete"] = function (key) {
+ return this.store["delete"](key);
+};
+},{}],11:[function(_dereq_,module,exports){
+"use strict";
+
+function PouchError(opts) {
+ this.status = opts.status;
+ this.name = opts.error;
+ this.message = opts.reason;
+ this.error = true;
+}
+
+PouchError.prototype__proto__ = Error.prototype;
+
+PouchError.prototype.toString = function () {
+ return JSON.stringify({
+ status: this.status,
+ name: this.name,
+ message: this.message
+ });
+};
+
+exports.UNAUTHORIZED = new PouchError({
+ status: 401,
+ error: 'unauthorized',
+ reason: "Name or password is incorrect."
+});
+exports.MISSING_BULK_DOCS = new PouchError({
+ status: 400,
+ error: 'bad_request',
+ reason: "Missing JSON list of 'docs'"
+});
+exports.MISSING_DOC = new PouchError({
+ status: 404,
+ error: 'not_found',
+ reason: 'missing'
+});
+exports.REV_CONFLICT = new PouchError({
+ status: 409,
+ error: 'conflict',
+ reason: 'Document update conflict'
+});
+exports.INVALID_ID = new PouchError({
+ status: 400,
+ error: 'invalid_id',
+ reason: '_id field must contain a string'
+});
+exports.MISSING_ID = new PouchError({
+ status: 412,
+ error: 'missing_id',
+ reason: '_id is required for puts'
+});
+exports.RESERVED_ID = new PouchError({
+ status: 400,
+ error: 'bad_request',
+ reason: 'Only reserved document ids may start with underscore.'
+});
+exports.NOT_OPEN = new PouchError({
+ status: 412,
+ error: 'precondition_failed',
+ reason: 'Database not open'
+});
+exports.UNKNOWN_ERROR = new PouchError({
+ status: 500,
+ error: 'unknown_error',
+ reason: 'Database encountered an unknown error'
+});
+exports.BAD_ARG = new PouchError({
+ status: 500,
+ error: 'badarg',
+ reason: 'Some query argument is invalid'
+});
+exports.INVALID_REQUEST = new PouchError({
+ status: 400,
+ error: 'invalid_request',
+ reason: 'Request was invalid'
+});
+exports.QUERY_PARSE_ERROR = new PouchError({
+ status: 400,
+ error: 'query_parse_error',
+ reason: 'Some query parameter is invalid'
+});
+exports.DOC_VALIDATION = new PouchError({
+ status: 500,
+ error: 'doc_validation',
+ reason: 'Bad special document member'
+});
+exports.BAD_REQUEST = new PouchError({
+ status: 400,
+ error: 'bad_request',
+ reason: 'Something wrong with the request'
+});
+exports.NOT_AN_OBJECT = new PouchError({
+ status: 400,
+ error: 'bad_request',
+ reason: 'Document must be a JSON object'
+});
+exports.DB_MISSING = new PouchError({
+ status: 404,
+ error: 'not_found',
+ reason: 'Database not found'
+});
+exports.IDB_ERROR = new PouchError({
+ status: 500,
+ error: 'indexed_db_went_bad',
+ reason: 'unknown'
+});
+exports.WSQ_ERROR = new PouchError({
+ status: 500,
+ error: 'web_sql_went_bad',
+ reason: 'unknown'
+});
+exports.LDB_ERROR = new PouchError({
+ status: 500,
+ error: 'levelDB_went_went_bad',
+ reason: 'unknown'
+});
+exports.FORBIDDEN = new PouchError({
+ status: 403,
+ error: 'forbidden',
+ reason: 'Forbidden by design doc validate_doc_update function'
+});
+exports.error = function (error, reason, name) {
+ function CustomPouchError(msg) {
+ this.message = reason;
+ if (name) {
+ this.name = name;
+ }
+ }
+ CustomPouchError.prototype = error;
+ return new CustomPouchError(reason);
+};
+
+},{}],12:[function(_dereq_,module,exports){
+(function (process,global){
+'use strict';
+
+var crypto = _dereq_('crypto');
+var Md5 = _dereq_('spark-md5');
+var setImmediateShim = global.setImmediate || global.setTimeout;
+
+function sliceShim(arrayBuffer, begin, end) {
+ if (typeof arrayBuffer.slice === 'function') {
+ return arrayBuffer.slice(begin, end);
+ }
+ //
+ // shim for IE courtesy of http://stackoverflow.com/a/21440217
+ //
+
+ //If `begin`/`end` is unspecified, Chrome assumes 0, so we do the same
+ //Chrome also converts the values to integers via flooring
+ begin = Math.floor(begin || 0);
+ end = Math.floor(end || 0);
+
+ var len = arrayBuffer.byteLength;
+
+ //If either `begin` or `end` is negative, it refers to an
+ //index from the end of the array, as opposed to from the beginning.
+ //The range specified by the `begin` and `end` values is clamped to the
+ //valid index range for the current array.
+ begin = begin < 0 ? Math.max(begin + len, 0) : Math.min(len, begin);
+ end = end < 0 ? Math.max(end + len, 0) : Math.min(len, end);
+
+ //If the computed length of the new ArrayBuffer would be negative, it
+ //is clamped to zero.
+ if (end - begin <= 0) {
+ return new ArrayBuffer(0);
+ }
+
+ var result = new ArrayBuffer(end - begin);
+ var resultBytes = new Uint8Array(result);
+ var sourceBytes = new Uint8Array(arrayBuffer, begin, end - begin);
+
+ resultBytes.set(sourceBytes);
+
+ return result;
+}
+
+module.exports = function (data, callback) {
+ if (!process.browser) {
+ callback(null, crypto.createHash('md5').update(data).digest('hex'));
+ return;
+ }
+ var chunkSize = Math.min(524288, data.length);
+ var chunks = Math.ceil(data.length / chunkSize);
+ var currentChunk = 0;
+ var buffer = new Md5();
+ function loadNextChunk() {
+ var start = currentChunk * chunkSize;
+ var end = start + chunkSize;
+ if ((start + chunkSize) >= data.size) {
+ end = data.size;
+ }
+ currentChunk++;
+ if (currentChunk < chunks) {
+ buffer.append(sliceShim(data, start, end));
+ setImmediateShim(loadNextChunk);
+ } else {
+ buffer.append(sliceShim(data, start, end));
+ callback(null, buffer.end());
+ buffer.destroy();
+ }
+ }
+ loadNextChunk();
+};
+
+}).call(this,_dereq_("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":28,"crypto":26,"spark-md5":56}],13:[function(_dereq_,module,exports){
+'use strict';
+var Promise = _dereq_('../utils').Promise;
+
+// this is essentially the "update sugar" function from daleharvey/pouchdb#1388
+// the diffFun tells us what delta to apply to the doc. it either returns
+// the doc, or false if it doesn't need to do an update after all
+function upsert(db, docId, diffFun) {
+ return new Promise(function (fulfill, reject) {
+ if (docId && typeof docId === 'object') {
+ docId = docId._id;
+ }
+ if (typeof docId !== 'string') {
+ return reject(new Error('doc id is required'));
+ }
+
+ db.get(docId, function (err, doc) {
+ if (err) {
+ if (err.name !== 'not_found') {
+ return reject(err);
+ }
+ return fulfill(tryAndPut(db, diffFun({_id : docId}), diffFun));
+ }
+ var newDoc = diffFun(doc);
+ if (!newDoc) {
+ return fulfill(doc);
+ }
+ fulfill(tryAndPut(db, newDoc, diffFun));
+ });
+ });
+}
+
+function tryAndPut(db, doc, diffFun) {
+ return db.put(doc)["catch"](function (err) {
+ if (err.name !== 'conflict') {
+ throw err;
+ }
+ return upsert(db, doc, diffFun);
+ });
+}
+
+module.exports = function (db, docId, diffFun, cb) {
+ if (typeof cb === 'function') {
+ upsert(db, docId, diffFun).then(function (resp) {
+ cb(null, resp);
+ }, cb);
+ } else {
+ return upsert(db, docId, diffFun);
+ }
+};
+
+},{"../utils":23}],14:[function(_dereq_,module,exports){
+"use strict";
+
+// BEGIN Math.uuid.js
+
+/*!
+Math.uuid.js (v1.4)
+http://www.broofa.com
+mailto:robert@broofa.com
+
+Copyright (c) 2010 Robert Kieffer
+Dual licensed under the MIT and GPL licenses.
+*/
+
+/*
+ * Generate a random uuid.
+ *
+ * USAGE: Math.uuid(length, radix)
+ * length - the desired number of characters
+ * radix - the number of allowable values for each character.
+ *
+ * EXAMPLES:
+ * // No arguments - returns RFC4122, version 4 ID
+ * >>> Math.uuid()
+ * "92329D39-6F5C-4520-ABFC-AAB64544E172"
+ *
+ * // One argument - returns ID of the specified length
+ * >>> Math.uuid(15) // 15 character ID (default base=62)
+ * "VcydxgltxrVZSTV"
+ *
+ * // Two arguments - returns ID of the specified length, and radix.
+ * // (Radix must be <= 62)
+ * >>> Math.uuid(8, 2) // 8 character ID (base=2)
+ * "01001010"
+ * >>> Math.uuid(8, 10) // 8 character ID (base=10)
+ * "47473046"
+ * >>> Math.uuid(8, 16) // 8 character ID (base=16)
+ * "098F4D35"
+ */
+var chars = (
+ '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ' +
+ 'abcdefghijklmnopqrstuvwxyz'
+).split('');
+function getValue(radix) {
+ return 0 | Math.random() * radix;
+}
+function uuid(len, radix) {
+ radix = radix || chars.length;
+ var out = '';
+ var i = -1;
+
+ if (len) {
+ // Compact form
+ while (++i < len) {
+ out += chars[getValue(radix)];
+ }
+ return out;
+ }
+ // rfc4122, version 4 form
+ // Fill in random data. At i==19 set the high bits of clock sequence as
+ // per rfc4122, sec. 4.1.5
+ while (++i < 36) {
+ switch (i) {
+ case 8:
+ case 13:
+ case 18:
+ case 23:
+ out += '-';
+ break;
+ case 19:
+ out += chars[(getValue(16) & 0x3) | 0x8];
+ break;
+ default:
+ out += chars[getValue(16)];
+ }
+ }
+
+ return out;
+}
+
+
+
+module.exports = uuid;
+
+
+},{}],15:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = evalFilter;
+function evalFilter(input) {
+ /*jshint evil: true */
+ return eval([
+ '(function () { return ',
+ input,
+ ' })()'
+ ].join(''));
+}
+},{}],16:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = evalView;
+function evalView(input) {
+ /*jshint evil: true */
+ return eval([
+ '(function () {',
+ ' return function (doc) {',
+ ' var emitted = false;',
+ ' var emit = function (a, b) {',
+ ' emitted = true;',
+ ' };',
+ ' var view = ' + input + ';',
+ ' view(doc);',
+ ' if (emitted) {',
+ ' return true;',
+ ' }',
+ ' }',
+ '})()'
+ ].join('\n'));
+}
+},{}],17:[function(_dereq_,module,exports){
+(function (process){
+"use strict";
+
+var PouchDB = _dereq_('./setup');
+
+module.exports = PouchDB;
+
+PouchDB.ajax = _dereq_('./deps/ajax');
+PouchDB.extend = _dereq_('pouchdb-extend');
+PouchDB.utils = _dereq_('./utils');
+PouchDB.Errors = _dereq_('./deps/errors');
+PouchDB.replicate = _dereq_('./replicate').replicate;
+PouchDB.sync = _dereq_('./sync');
+PouchDB.version = _dereq_('./version');
+var httpAdapter = _dereq_('./adapters/http');
+PouchDB.adapter('http', httpAdapter);
+PouchDB.adapter('https', httpAdapter);
+
+PouchDB.adapter('idb', _dereq_('./adapters/idb'));
+PouchDB.adapter('websql', _dereq_('./adapters/websql'));
+PouchDB.plugin(_dereq_('pouchdb-mapreduce'));
+
+if (!process.browser) {
+ var ldbAdapter = _dereq_('./adapters/leveldb');
+ PouchDB.adapter('ldb', ldbAdapter);
+ PouchDB.adapter('leveldb', ldbAdapter);
+}
+
+}).call(this,_dereq_("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"./adapters/http":2,"./adapters/idb":3,"./adapters/leveldb":26,"./adapters/websql":5,"./deps/ajax":8,"./deps/errors":11,"./replicate":19,"./setup":20,"./sync":21,"./utils":23,"./version":24,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":28,"pouchdb-extend":47,"pouchdb-mapreduce":50}],18:[function(_dereq_,module,exports){
+'use strict';
+var extend = _dereq_('pouchdb-extend');
+
+
+// for a better overview of what this is doing, read:
+// https://github.com/apache/couchdb/blob/master/src/couchdb/couch_key_tree.erl
+//
+// But for a quick intro, CouchDB uses a revision tree to store a documents
+// history, A -> B -> C, when a document has conflicts, that is a branch in the
+// tree, A -> (B1 | B2 -> C), We store these as a nested array in the format
+//
+// KeyTree = [Path ... ]
+// Path = {pos: position_from_root, ids: Tree}
+// Tree = [Key, Opts, [Tree, ...]], in particular single node: [Key, []]
+
+// Turn a path as a flat array into a tree with a single branch
+function pathToTree(path) {
+ var doc = path.shift();
+ var root = [doc.id, doc.opts, []];
+ var leaf = root;
+ var nleaf;
+
+ while (path.length) {
+ doc = path.shift();
+ nleaf = [doc.id, doc.opts, []];
+ leaf[2].push(nleaf);
+ leaf = nleaf;
+ }
+ return root;
+}
+
+// Merge two trees together
+// The roots of tree1 and tree2 must be the same revision
+function mergeTree(in_tree1, in_tree2) {
+ var queue = [{tree1: in_tree1, tree2: in_tree2}];
+ var conflicts = false;
+ while (queue.length > 0) {
+ var item = queue.pop();
+ var tree1 = item.tree1;
+ var tree2 = item.tree2;
+
+ if (tree1[1].status || tree2[1].status) {
+ tree1[1].status =
+ (tree1[1].status === 'available' ||
+ tree2[1].status === 'available') ? 'available' : 'missing';
+ }
+
+ for (var i = 0; i < tree2[2].length; i++) {
+ if (!tree1[2][0]) {
+ conflicts = 'new_leaf';
+ tree1[2][0] = tree2[2][i];
+ continue;
+ }
+
+ var merged = false;
+ for (var j = 0; j < tree1[2].length; j++) {
+ if (tree1[2][j][0] === tree2[2][i][0]) {
+ queue.push({tree1: tree1[2][j], tree2: tree2[2][i]});
+ merged = true;
+ }
+ }
+ if (!merged) {
+ conflicts = 'new_branch';
+ tree1[2].push(tree2[2][i]);
+ tree1[2].sort();
+ }
+ }
+ }
+ return {conflicts: conflicts, tree: in_tree1};
+}
+
+function doMerge(tree, path, dontExpand) {
+ var restree = [];
+ var conflicts = false;
+ var merged = false;
+ var res;
+
+ if (!tree.length) {
+ return {tree: [path], conflicts: 'new_leaf'};
+ }
+
+ tree.forEach(function (branch) {
+ if (branch.pos === path.pos && branch.ids[0] === path.ids[0]) {
+ // Paths start at the same position and have the same root, so they need
+ // merged
+ res = mergeTree(branch.ids, path.ids);
+ restree.push({pos: branch.pos, ids: res.tree});
+ conflicts = conflicts || res.conflicts;
+ merged = true;
+ } else if (dontExpand !== true) {
+ // The paths start at a different position, take the earliest path and
+ // traverse up until it as at the same point from root as the path we
+ // want to merge. If the keys match we return the longer path with the
+ // other merged After stemming we dont want to expand the trees
+
+ var t1 = branch.pos < path.pos ? branch : path;
+ var t2 = branch.pos < path.pos ? path : branch;
+ var diff = t2.pos - t1.pos;
+
+ var candidateParents = [];
+
+ var trees = [];
+ trees.push({ids: t1.ids, diff: diff, parent: null, parentIdx: null});
+ while (trees.length > 0) {
+ var item = trees.pop();
+ if (item.diff === 0) {
+ if (item.ids[0] === t2.ids[0]) {
+ candidateParents.push(item);
+ }
+ continue;
+ }
+ if (!item.ids) {
+ continue;
+ }
+ /*jshint loopfunc:true */
+ item.ids[2].forEach(function (el, idx) {
+ trees.push(
+ {ids: el, diff: item.diff - 1, parent: item.ids, parentIdx: idx});
+ });
+ }
+
+ var el = candidateParents[0];
+
+ if (!el) {
+ restree.push(branch);
+ } else {
+ res = mergeTree(el.ids, t2.ids);
+ el.parent[2][el.parentIdx] = res.tree;
+ restree.push({pos: t1.pos, ids: t1.ids});
+ conflicts = conflicts || res.conflicts;
+ merged = true;
+ }
+ } else {
+ restree.push(branch);
+ }
+ });
+
+ // We didnt find
+ if (!merged) {
+ restree.push(path);
+ }
+
+ restree.sort(function (a, b) {
+ return a.pos - b.pos;
+ });
+
+ return {
+ tree: restree,
+ conflicts: conflicts || 'internal_node'
+ };
+}
+
+// To ensure we dont grow the revision tree infinitely, we stem old revisions
+function stem(tree, depth) {
+ // First we break out the tree into a complete list of root to leaf paths,
+ // we cut off the start of the path and generate a new set of flat trees
+ var stemmedPaths = PouchMerge.rootToLeaf(tree).map(function (path) {
+ var stemmed = path.ids.slice(-depth);
+ return {
+ pos: path.pos + (path.ids.length - stemmed.length),
+ ids: pathToTree(stemmed)
+ };
+ });
+ // Then we remerge all those flat trees together, ensuring that we dont
+ // connect trees that would go beyond the depth limit
+ return stemmedPaths.reduce(function (prev, current, i, arr) {
+ return doMerge(prev, current, true).tree;
+ }, [stemmedPaths.shift()]);
+}
+
+var PouchMerge = {};
+
+PouchMerge.merge = function (tree, path, depth) {
+ // Ugh, nicer way to not modify arguments in place?
+ tree = extend(true, [], tree);
+ path = extend(true, {}, path);
+ var newTree = doMerge(tree, path);
+ return {
+ tree: stem(newTree.tree, depth),
+ conflicts: newTree.conflicts
+ };
+};
+
+// We fetch all leafs of the revision tree, and sort them based on tree length
+// and whether they were deleted, undeleted documents with the longest revision
+// tree (most edits) win
+// The final sort algorithm is slightly documented in a sidebar here:
+// http://guide.couchdb.org/draft/conflicts.html
+PouchMerge.winningRev = function (metadata) {
+ var leafs = [];
+ PouchMerge.traverseRevTree(metadata.rev_tree,
+ function (isLeaf, pos, id, something, opts) {
+ if (isLeaf) {
+ leafs.push({pos: pos, id: id, deleted: !!opts.deleted});
+ }
+ });
+ leafs.sort(function (a, b) {
+ if (a.deleted !== b.deleted) {
+ return a.deleted > b.deleted ? 1 : -1;
+ }
+ if (a.pos !== b.pos) {
+ return b.pos - a.pos;
+ }
+ return a.id < b.id ? 1 : -1;
+ });
+
+ return leafs[0].pos + '-' + leafs[0].id;
+};
+
+// Pretty much all below can be combined into a higher order function to
+// traverse revisions
+// The return value from the callback will be passed as context to all
+// children of that node
+PouchMerge.traverseRevTree = function (revs, callback) {
+ var toVisit = revs.slice();
+
+ var node;
+ while ((node = toVisit.pop())) {
+ var pos = node.pos;
+ var tree = node.ids;
+ var branches = tree[2];
+ var newCtx =
+ callback(branches.length === 0, pos, tree[0], node.ctx, tree[1]);
+ for (var i = 0, len = branches.length; i < len; i++) {
+ toVisit.push({pos: pos + 1, ids: branches[i], ctx: newCtx});
+ }
+ }
+};
+
+PouchMerge.collectLeaves = function (revs) {
+ var leaves = [];
+ PouchMerge.traverseRevTree(revs, function (isLeaf, pos, id, acc, opts) {
+ if (isLeaf) {
+ leaves.unshift({rev: pos + "-" + id, pos: pos, opts: opts});
+ }
+ });
+ leaves.sort(function (a, b) {
+ return b.pos - a.pos;
+ });
+ leaves.map(function (leaf) { delete leaf.pos; });
+ return leaves;
+};
+
+// returns revs of all conflicts that is leaves such that
+// 1. are not deleted and
+// 2. are different than winning revision
+PouchMerge.collectConflicts = function (metadata) {
+ var win = PouchMerge.winningRev(metadata);
+ var leaves = PouchMerge.collectLeaves(metadata.rev_tree);
+ var conflicts = [];
+ leaves.forEach(function (leaf) {
+ if (leaf.rev !== win && !leaf.opts.deleted) {
+ conflicts.push(leaf.rev);
+ }
+ });
+ return conflicts;
+};
+
+PouchMerge.rootToLeaf = function (tree) {
+ var paths = [];
+ PouchMerge.traverseRevTree(tree, function (isLeaf, pos, id, history, opts) {
+ history = history ? history.slice(0) : [];
+ history.push({id: id, opts: opts});
+ if (isLeaf) {
+ var rootPos = pos + 1 - history.length;
+ paths.unshift({pos: rootPos, ids: history});
+ }
+ return history;
+ });
+ return paths;
+};
+
+
+module.exports = PouchMerge;
+
+},{"pouchdb-extend":47}],19:[function(_dereq_,module,exports){
+'use strict';
+
+var utils = _dereq_('./utils');
+var Pouch = _dereq_('./index');
+var EE = _dereq_('events').EventEmitter;
+
+// We create a basic promise so the caller can cancel the replication possibly
+// before we have actually started listening to changes etc
+utils.inherits(Replication, EE);
+function Replication(opts) {
+ EE.call(this);
+ this.cancelled = false;
+ var self = this;
+ var promise = new utils.Promise(function (fulfill, reject) {
+ self.once('complete', fulfill);
+ self.once('error', reject);
+ });
+ self.then = function (resolve, reject) {
+ return promise.then(resolve, reject);
+ };
+ self["catch"] = function (reject) {
+ return promise["catch"](reject);
+ };
+ // As we allow error handling via "error" event as well,
+ // put a stub in here so that rejecting never throws UnhandledError.
+ self["catch"](function (err) {});
+}
+
+Replication.prototype.cancel = function () {
+ this.cancelled = true;
+ this.emit('cancel');
+};
+
+Replication.prototype.ready = function (src, target) {
+ var self = this;
+ function onDestroy() {
+ self.cancel();
+ }
+ src.once('destroyed', onDestroy);
+ target.once('destroyed', onDestroy);
+ function cleanup() {
+ src.removeListener('destroyed', onDestroy);
+ target.removeListener('destroyed', onDestroy);
+ }
+ this.then(cleanup, cleanup);
+};
+
+
+// TODO: check CouchDB's replication id generation
+// Generate a unique id particular to this replication
+function genReplicationId(src, target, opts) {
+ var filterFun = opts.filter ? opts.filter.toString() : '';
+ return src.id().then(function (src_id) {
+ return target.id().then(function (target_id) {
+ var queryData = src_id + target_id + filterFun +
+ JSON.stringify(opts.query_params) + opts.doc_ids;
+ return utils.MD5(queryData).then(function (md5) {
+ return '_local/' + md5;
+ });
+ });
+ });
+}
+
+
+function updateCheckpoint(db, id, checkpoint) {
+ return db.get(id)["catch"](function (err) {
+ if (err.status === 404) {
+ return {_id: id};
+ }
+ throw err;
+ }).then(function (doc) {
+ doc.last_seq = checkpoint;
+ return db.put(doc);
+ });
+ }
+
+function Checkpointer(src, target, id) {
+ this.src = src;
+ this.target = target;
+ this.id = id;
+}
+
+Checkpointer.prototype.writeCheckpoint = function (checkpoint) {
+ var self = this;
+ return this.updateTarget(checkpoint).then(function () {
+ return self.updateSource(checkpoint);
+ });
+};
+Checkpointer.prototype.updateTarget = function (checkpoint) {
+ return updateCheckpoint(this.target, this.id, checkpoint);
+};
+Checkpointer.prototype.updateSource = function (checkpoint) {
+ var self = this;
+ if (this.readOnlySource) {
+ return utils.Promise.resolve(true);
+ }
+ return updateCheckpoint(this.src, this.id, checkpoint)["catch"](function (err) {
+ var isForbidden = typeof err.status === 'number' &&
+ Math.floor(err.status / 100) === 4;
+ if (isForbidden) {
+ self.readOnlySource = true;
+ return true;
+ }
+ throw err;
+ });
+};
+Checkpointer.prototype.getCheckpoint = function () {
+ var self = this;
+ return self.target.get(self.id).then(function (targetDoc) {
+ return self.src.get(self.id).then(function (sourceDoc) {
+ if (targetDoc.last_seq === sourceDoc.last_seq) {
+ return sourceDoc.last_seq;
+ }
+ return 0;
+ }, function (err) {
+ if (err.status === 404 && targetDoc.last_seq) {
+ return self.src.put({
+ _id: self.id,
+ last_seq: 0
+ }).then(function () {
+ return 0;
+ }, function (err) {
+ if (err.status === 401) {
+ self.readOnlySource = true;
+ return targetDoc.last_seq;
+ }
+ return 0;
+ });
+ }
+ throw err;
+ });
+ })["catch"](function (err) {
+ if (err.status !== 404) {
+ throw err;
+ }
+ return 0;
+ });
+};
+function replicate(repId, src, target, opts, returnValue) {
+ var batches = []; // list of batches to be processed
+ var currentBatch; // the batch currently being processed
+ var pendingBatch = {
+ seq: 0,
+ changes: [],
+ docs: []
+ }; // next batch, not yet ready to be processed
+ var writingCheckpoint = false; // true while checkpoint is being written
+ var changesCompleted = false; // true when all changes received
+ var replicationCompleted = false; // true when replication has completed
+ var last_seq = 0;
+ var continuous = opts.continuous || opts.live || false;
+ var batch_size = opts.batch_size || 100;
+ var batches_limit = opts.batches_limit || 10;
+ var changesPending = false; // true while src.changes is running
+ var changesCount = 0; // number of changes received since calling src.changes
+ var doc_ids = opts.doc_ids;
+ var checkpointer = new Checkpointer(src, target, repId);
+ var result = {
+ ok: true,
+ start_time: new Date(),
+ docs_read: 0,
+ docs_written: 0,
+ doc_write_failures: 0,
+ errors: []
+ };
+ var changesOpts = {};
+ returnValue.ready(src, target);
+
+
+ function writeDocs() {
+ if (currentBatch.docs.length === 0) {
+ return;
+ }
+ var docs = currentBatch.docs;
+ return target.bulkDocs({
+ docs: docs
+ }, {
+ new_edits: false
+ }).then(function (res) {
+ if (returnValue.cancelled) {
+ completeReplication();
+ throw new Error('cancelled');
+ }
+ var errors = [];
+ res.forEach(function (res) {
+ if (!res.ok) {
+ result.doc_write_failures++;
+ errors.push(new Error(res.reason || res.message || 'Unknown reason'));
+ }
+ });
+ if (errors.length > 0) {
+ var error = new Error('bulkDocs error');
+ error.other_errors = errors;
+ abortReplication('target.bulkDocs failed to write docs', error);
+ throw new Error('bulkWrite partial failure');
+ }
+ }, function (err) {
+ result.doc_write_failures += docs.length;
+ throw err;
+ });
+ }
+
+ function getDocs() {
+ var docIds = Object.keys(currentBatch.diffs);
+ if (!docIds.length) {
+ return utils.Promise.resolve();
+ }
+ var idsToDocs = new utils.Map();
+ currentBatch.changes.forEach(function (change) {
+ idsToDocs.set(change.id, change.doc);
+ });
+ return utils.Promise.all(docIds.map(function (docId) {
+ return mapToDocWithOpenRevs(docId, idsToDocs.get(docId));
+ })).then(function (docLists) {
+ docLists.forEach(function (docs) {
+ docs.forEach(processSourceDoc);
+ });
+ });
+ }
+
+ function mapToDocWithOpenRevs(docId, doc) {
+ // as an optimization, we optimistically try to fetch all the open
+ // revs using just the docs returned from changes()
+ // if that's not possible, we do separate GETs for the open_revs
+ if (doc._deleted) {
+ return [{ok: doc}];
+ }
+ var diffs = currentBatch.diffs;
+ var missing = diffs[docId].missing;
+ var needAttachments = doc._attachments;
+ var needOtherRevs = missing.length > 1 || missing[0] !== doc._rev;
+ if (needAttachments || needOtherRevs) {
+ // fetch individually (slower)
+ return src.get(docId, {
+ revs: true,
+ open_revs: "all", // avoid url too long error, don't send revs array
+ attachments: true
+ }).then(function (results) {
+ var missingMap = {};
+ missing.forEach(function (missingRev) {
+ missingMap[missingRev] = true;
+ });
+ return results.filter(function (res) {
+ var rev = res.ok ? res.ok._rev : res.missing;
+ return missingMap[rev];
+ });
+ });
+ }
+ return [{ok: doc}];
+ }
+
+ function processSourceDoc(doc) {
+ var diffs = currentBatch.diffs;
+ if (returnValue.cancelled) {
+ return completeReplication();
+ }
+ if (doc.ok) {
+ result.docs_read++;
+ currentBatch.pendingRevs++;
+ currentBatch.docs.push(doc.ok);
+ delete diffs[doc.ok._id];
+ }
+ }
+
+
+ function finishBatch() {
+ writingCheckpoint = true;
+ return checkpointer.writeCheckpoint(
+ currentBatch.seq
+ ).then(function (res) {
+ writingCheckpoint = false;
+ if (returnValue.cancelled) {
+ completeReplication();
+ throw new Error('cancelled');
+ }
+ result.last_seq = last_seq = currentBatch.seq;
+ result.docs_written += currentBatch.docs.length;
+ returnValue.emit('change', utils.clone(result));
+ currentBatch = undefined;
+ getChanges();
+ })["catch"](function (err) {
+ writingCheckpoint = false;
+ abortReplication('writeCheckpoint completed with error', err);
+ throw err;
+ });
+ }
+
+
+ function getDiffs() {
+ var diff = {};
+ currentBatch.changes.forEach(function (change) {
+ diff[change.id] = change.changes.map(function (x) {
+ return x.rev;
+ });
+ });
+ return target.revsDiff(diff).then(function (diffs) {
+ if (returnValue.cancelled) {
+ completeReplication();
+ throw new Error('cancelled');
+ }
+ // currentBatch.diffs elements are deleted as the documents are written
+ currentBatch.diffs = diffs;
+ currentBatch.pendingRevs = 0;
+ });
+ }
+
+
+ function startNextBatch() {
+ if (returnValue.cancelled || currentBatch) {
+ return;
+ }
+ if (batches.length === 0) {
+ processPendingBatch(true);
+ return;
+ }
+ currentBatch = batches.shift();
+ getDiffs()
+ .then(getDocs)
+ .then(writeDocs)
+ .then(finishBatch)
+ .then(startNextBatch)[
+ "catch"](function (err) {
+ abortReplication('batch processing terminated with error', err);
+ });
+ }
+
+
+ function processPendingBatch(immediate) {
+ if (pendingBatch.changes.length === 0) {
+ if (batches.length === 0 && !currentBatch) {
+ if ((continuous && changesOpts.live) || changesCompleted) {
+ returnValue.emit('uptodate', utils.clone(result));
+ }
+ if (changesCompleted) {
+ completeReplication();
+ }
+ }
+ return;
+ }
+ if (
+ immediate ||
+ changesCompleted ||
+ pendingBatch.changes.length >= batch_size
+ ) {
+ batches.push(pendingBatch);
+ pendingBatch = {
+ seq: 0,
+ changes: [],
+ docs: []
+ };
+ startNextBatch();
+ }
+ }
+
+
+ function abortReplication(reason, err) {
+ if (replicationCompleted) {
+ return;
+ }
+ result.ok = false;
+ result.status = 'aborted';
+ result.errors.push(err);
+ batches = [];
+ pendingBatch = {
+ seq: 0,
+ changes: [],
+ docs: []
+ };
+ completeReplication();
+ }
+
+
+ function completeReplication() {
+ if (replicationCompleted) {
+ return;
+ }
+ if (returnValue.cancelled) {
+ result.status = 'cancelled';
+ if (writingCheckpoint) {
+ return;
+ }
+ }
+ result.status = result.status || 'complete';
+ result.end_time = new Date();
+ result.last_seq = last_seq;
+ replicationCompleted = returnValue.cancelled = true;
+ if (result.errors.length > 0) {
+ var error = result.errors.pop();
+ if (result.errors.length > 0) {
+ error.other_errors = result.errors;
+ }
+ error.result = result;
+ returnValue.emit('error', error);
+ } else {
+ returnValue.emit('complete', result);
+ }
+ returnValue.removeAllListeners();
+ }
+
+
+ function onChange(change) {
+ if (returnValue.cancelled) {
+ return completeReplication();
+ }
+ changesCount++;
+ if (
+ pendingBatch.changes.length === 0 &&
+ batches.length === 0 &&
+ !currentBatch
+ ) {
+ returnValue.emit('outofdate', utils.clone(result));
+ }
+ pendingBatch.seq = change.seq;
+ pendingBatch.changes.push(change);
+ processPendingBatch(batches.length === 0);
+ }
+
+
+ function onChangesComplete(changes) {
+ changesPending = false;
+ if (returnValue.cancelled) {
+ return completeReplication();
+ }
+ if (changesCount > 0) {
+ changesOpts.since = changes.last_seq;
+ getChanges();
+ } else {
+ if (continuous) {
+ changesOpts.live = true;
+ getChanges();
+ } else {
+ changesCompleted = true;
+ }
+ }
+ processPendingBatch(true);
+ }
+
+
+ function onChangesError(err) {
+ changesPending = false;
+ if (returnValue.cancelled) {
+ return completeReplication();
+ }
+ abortReplication('changes rejected', err);
+ }
+
+
+ function getChanges() {
+ if (
+ !changesPending &&
+ !changesCompleted &&
+ batches.length < batches_limit
+ ) {
+ changesPending = true;
+ changesCount = 0;
+ src.changes(changesOpts)
+ .on('change', onChange)
+ .then(onChangesComplete)[
+ "catch"](onChangesError);
+ }
+ }
+
+
+ function startChanges() {
+ checkpointer.getCheckpoint().then(function (checkpoint) {
+ last_seq = checkpoint;
+ changesOpts = {
+ since: last_seq,
+ limit: batch_size,
+ batch_size: batch_size,
+ style: 'all_docs',
+ doc_ids: doc_ids,
+ returnDocs: false,
+ include_docs: true
+ };
+ if (opts.filter) {
+ changesOpts.filter = opts.filter;
+ }
+ if (opts.query_params) {
+ changesOpts.query_params = opts.query_params;
+ }
+ getChanges();
+ })["catch"](function (err) {
+ abortReplication('getCheckpoint rejected with ', err);
+ });
+ }
+
+
+ returnValue.once('cancel', completeReplication);
+
+ if (typeof opts.onChange === 'function') {
+ returnValue.on('change', opts.onChange);
+ }
+
+ if (typeof opts.complete === 'function') {
+ returnValue.once('error', opts.complete);
+ returnValue.once('complete', function (result) {
+ opts.complete(null, result);
+ });
+ }
+
+ if (typeof opts.since === 'undefined') {
+ startChanges();
+ } else {
+ writingCheckpoint = true;
+ checkpointer.writeCheckpoint(opts.since).then(function (res) {
+ writingCheckpoint = false;
+ if (returnValue.cancelled) {
+ completeReplication();
+ return;
+ }
+ last_seq = opts.since;
+ startChanges();
+ })["catch"](function (err) {
+ writingCheckpoint = false;
+ abortReplication('writeCheckpoint completed with error', err);
+ throw err;
+ });
+ }
+}
+
+
+function toPouch(db, PouchConstructor) {
+ if (typeof db === 'string') {
+ return new PouchConstructor(db);
+ } else if (db.then) {
+ return db;
+ } else {
+ return utils.Promise.resolve(db);
+ }
+}
+
+
+function replicateWrapper(src, target, opts, callback) {
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ if (typeof opts === 'undefined') {
+ opts = {};
+ }
+ if (!opts.complete) {
+ opts.complete = callback || function () {};
+ }
+ opts = utils.clone(opts);
+ opts.continuous = opts.continuous || opts.live;
+ var replicateRet = new Replication(opts);
+ var PouchConstructor = opts.pouchConstructor || Pouch;
+ toPouch(src, PouchConstructor).then(function (src) {
+ return toPouch(target, PouchConstructor).then(function (target) {
+ return genReplicationId(src, target, opts).then(function (repId) {
+ replicate(repId, src, target, opts, replicateRet);
+ });
+ });
+ })["catch"](function (err) {
+ replicateRet.emit('error', err);
+ opts.complete(err);
+ });
+ return replicateRet;
+}
+
+exports.replicate = replicateWrapper;
+
+},{"./index":17,"./utils":23,"events":27}],20:[function(_dereq_,module,exports){
+(function (global){
+"use strict";
+
+var PouchDB = _dereq_("./constructor");
+var utils = _dereq_('./utils');
+var Promise = utils.Promise;
+var EventEmitter = _dereq_('events').EventEmitter;
+PouchDB.adapters = {};
+PouchDB.preferredAdapters = _dereq_('./adapters/preferredAdapters.js');
+
+PouchDB.prefix = '_pouch_';
+
+var eventEmitter = new EventEmitter();
+
+var eventEmitterMethods = [
+ 'on',
+ 'addListener',
+ 'emit',
+ 'listeners',
+ 'once',
+ 'removeAllListeners',
+ 'removeListener',
+ 'setMaxListeners'
+];
+
+eventEmitterMethods.forEach(function (method) {
+ PouchDB[method] = eventEmitter[method].bind(eventEmitter);
+});
+PouchDB.setMaxListeners(0);
+PouchDB.parseAdapter = function (name, opts) {
+ var match = name.match(/([a-z\-]*):\/\/(.*)/);
+ var adapter, adapterName;
+ if (match) {
+ // the http adapter expects the fully qualified name
+ name = /http(s?)/.test(match[1]) ? match[1] + '://' + match[2] : match[2];
+ adapter = match[1];
+ if (!PouchDB.adapters[adapter].valid()) {
+ throw 'Invalid adapter';
+ }
+ return {name: name, adapter: match[1]};
+ }
+
+ // check for browsers that have been upgraded from websql-only to websql+idb
+ var skipIdb = 'idb' in PouchDB.adapters && 'websql' in PouchDB.adapters &&
+ utils.hasLocalStorage() &&
+ global.localStorage['_pouch__websqldb_' + PouchDB.prefix + name];
+
+ if (typeof opts !== 'undefined' && opts.db) {
+ adapterName = 'leveldb';
+ } else {
+ for (var i = 0; i < PouchDB.preferredAdapters.length; ++i) {
+ adapterName = PouchDB.preferredAdapters[i];
+ if (adapterName in PouchDB.adapters) {
+ if (skipIdb && adapterName === 'idb') {
+ continue; // keep using websql to avoid user data loss
+ }
+ break;
+ }
+ }
+ }
+
+ adapter = PouchDB.adapters[adapterName];
+ if (adapterName && adapter) {
+ var use_prefix = 'use_prefix' in adapter ? adapter.use_prefix : true;
+
+ return {
+ name: use_prefix ? PouchDB.prefix + name : name,
+ adapter: adapterName
+ };
+ }
+
+ throw 'No valid adapter found';
+};
+
+PouchDB.destroy = utils.toPromise(function (name, opts, callback) {
+ if (typeof opts === 'function' || typeof opts === 'undefined') {
+ callback = opts;
+ opts = {};
+ }
+
+ if (name && typeof name === 'object') {
+ opts = name;
+ name = undefined;
+ }
+
+ var backend = PouchDB.parseAdapter(opts.name || name, opts);
+ var dbName = backend.name;
+ var adapter = PouchDB.adapters[backend.adapter];
+ var usePrefix = 'use_prefix' in adapter ? adapter.use_prefix : true;
+ var baseName = usePrefix ?
+ dbName.replace(new RegExp('^' + PouchDB.prefix), '') : dbName;
+ var fullName = (backend.adapter === 'http' || backend.adapter === 'https' ?
+ '' : (opts.prefix || '')) + dbName;
+ function destroyDb() {
+ // call destroy method of the particular adaptor
+ adapter.destroy(fullName, opts, function (err, resp) {
+ if (err) {
+ callback(err);
+ } else {
+ PouchDB.emit('destroyed', name);
+ //so we don't have to sift through all dbnames
+ PouchDB.emit(name, 'destroyed');
+ callback(null, resp || { 'ok': true });
+ }
+ });
+ }
+
+ var createOpts = utils.extend(true, {}, opts, {adapter : backend.adapter});
+ new PouchDB(baseName, createOpts, function (err, db) {
+ if (err) {
+ return callback(err);
+ }
+ db.get('_local/_pouch_dependentDbs', function (err, localDoc) {
+ if (err) {
+ if (err.name !== 'not_found') {
+ return callback(err);
+ } else { // no dependencies
+ return destroyDb();
+ }
+ }
+ var dependentDbs = localDoc.dependentDbs;
+ var deletedMap = Object.keys(dependentDbs).map(function (name) {
+ var trueName = usePrefix ?
+ name.replace(new RegExp('^' + PouchDB.prefix), '') : name;
+ var subOpts = utils.extend(true, opts, {adapter: backend.adapter});
+ return PouchDB.destroy(trueName, subOpts);
+ });
+ Promise.all(deletedMap).then(destroyDb, function (error) {
+ callback(error);
+ });
+ });
+ });
+});
+
+PouchDB.allDbs = utils.toPromise(function (callback) {
+ var err = new Error('allDbs method removed');
+ err.stats = '400';
+ callback(err);
+});
+PouchDB.adapter = function (id, obj) {
+ if (obj.valid()) {
+ PouchDB.adapters[id] = obj;
+ }
+};
+
+PouchDB.plugin = function (obj) {
+ Object.keys(obj).forEach(function (id) {
+ PouchDB.prototype[id] = obj[id];
+ });
+};
+
+PouchDB.defaults = function (defaultOpts) {
+ function PouchAlt(name, opts, callback) {
+ if (typeof opts === 'function' || typeof opts === 'undefined') {
+ callback = opts;
+ opts = {};
+ }
+ if (name && typeof name === 'object') {
+ opts = name;
+ name = undefined;
+ }
+
+ opts = utils.extend(true, {}, defaultOpts, opts);
+ PouchDB.call(this, name, opts, callback);
+ }
+
+ utils.inherits(PouchAlt, PouchDB);
+
+ PouchAlt.destroy = utils.toPromise(function (name, opts, callback) {
+ if (typeof opts === 'function' || typeof opts === 'undefined') {
+ callback = opts;
+ opts = {};
+ }
+
+ if (name && typeof name === 'object') {
+ opts = name;
+ name = undefined;
+ }
+ opts = utils.extend(true, {}, defaultOpts, opts);
+ return PouchDB.destroy(name, opts, callback);
+ });
+
+ eventEmitterMethods.forEach(function (method) {
+ PouchAlt[method] = eventEmitter[method].bind(eventEmitter);
+ });
+ PouchAlt.setMaxListeners(0);
+
+ PouchAlt.preferredAdapters = PouchDB.preferredAdapters.slice();
+ Object.keys(PouchDB).forEach(function (key) {
+ if (!(key in PouchAlt)) {
+ PouchAlt[key] = PouchDB[key];
+ }
+ });
+
+ PouchAlt.replicate = function replicateWrapper(src, target, opts, callback) {
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ if (typeof opts === 'undefined') {
+ opts = {};
+ }
+ opts = utils.clone(opts);
+ opts.pouchConstructor = PouchAlt;
+ return PouchDB.replicate(src, target, opts, callback);
+ };
+
+ return PouchAlt;
+};
+
+module.exports = PouchDB;
+
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./adapters/preferredAdapters.js":4,"./constructor":7,"./utils":23,"events":27}],21:[function(_dereq_,module,exports){
+'use strict';
+var utils = _dereq_('./utils');
+var replicate = _dereq_('./replicate').replicate;
+var EE = _dereq_('events').EventEmitter;
+
+module.exports = Sync;
+utils.inherits(Sync, EE);
+function Sync(src, target, opts, callback) {
+ if (!(this instanceof Sync)) {
+ return new Sync(src, target, opts, callback);
+ }
+ var self = this;
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ if (typeof opts === 'undefined') {
+ opts = {};
+ }
+ this.canceled = false;
+ opts = utils.clone(opts);
+ var onChange, complete;
+ if ('onChange' in opts) {
+ onChange = opts.onChange;
+ delete opts.onChange;
+ }
+ if (typeof callback === 'function' && !opts.complete) {
+ complete = callback;
+ } else if ('complete' in opts) {
+ complete = opts.complete;
+ delete opts.complete;
+ }
+ this.push = replicate(src, target, opts);
+
+ this.pull = replicate(target, src, opts);
+ var emittedCancel = false;
+ function onCancel(data) {
+ if (!emittedCancel) {
+ emittedCancel = true;
+ self.emit('cancel', data);
+ }
+ }
+
+ function pullChange(change) {
+ self.emit('change', {
+ direction: 'pull',
+ change: change
+ });
+ }
+ function pushChange(change) {
+ self.emit('change', {
+ direction: 'push',
+ change: change
+ });
+ }
+ var listeners = {};
+
+ var removed = {};
+ function removeAll(type) { // type is 'push' or 'pull'
+ return function (event, func) {
+ var isChange = event === 'change' &&
+ (func === pullChange || func === pushChange);
+ var isCancel = event === 'cancel' && func === onCancel;
+ var isOtherEvent = event in listeners && func === listeners[event];
+
+ if (isChange || isCancel || isOtherEvent) {
+ if (!(event in removed)) {
+ removed[event] = {};
+ }
+ removed[event][type] = true;
+ if (Object.keys(removed[event]).length === 2) {
+ // both push and pull have asked to be removed
+ self.removeAllListeners(event);
+ }
+ }
+ };
+ }
+
+ this.on('newListener', function (event) {
+ if (event === 'change') {
+ self.pull.on('change', pullChange);
+ self.push.on('change', pushChange);
+ } else if (event === 'cancel') {
+ self.pull.on('cancel', onCancel);
+ self.push.on('cancel', onCancel);
+ } else if (event !== 'error' &&
+ event !== 'removeListener' &&
+ event !== 'complete' && !(event in listeners)) {
+ listeners[event] = function (e) {
+ self.emit(event, e);
+ };
+ self.pull.on(event, listeners[event]);
+ self.push.on(event, listeners[event]);
+ }
+ });
+
+ this.on('removeListener', function (event) {
+ if (event === 'change') {
+ self.pull.removeListener('change', pullChange);
+ self.push.removeListener('change', pushChange);
+ } else if (event === 'cancel') {
+ self.pull.removeListener('cancel', onCancel);
+ self.push.removeListener('cancel', onCancel);
+ } else if (event in listeners) {
+ if (typeof listeners[event] === 'function') {
+ self.pull.removeListener(event, listeners[event]);
+ self.push.removeListener(event, listeners[event]);
+ delete listeners[event];
+ }
+ }
+ });
+
+ this.pull.on('removeListener', removeAll('pull'));
+ this.push.on('removeListener', removeAll('push'));
+
+ var promise = utils.Promise.all([
+ this.push,
+ this.pull
+ ]).then(function (resp) {
+ var out = {
+ push: resp[0],
+ pull: resp[1]
+ };
+ self.emit('complete', out);
+ if (complete) {
+ complete(null, out);
+ }
+ self.removeAllListeners();
+ return out;
+ }, function (err) {
+ self.cancel();
+ self.emit('error', err);
+ if (complete) {
+ complete(err);
+ }
+ self.removeAllListeners();
+ throw err;
+ });
+
+ this.then = function (success, err) {
+ return promise.then(success, err);
+ };
+
+ this["catch"] = function (err) {
+ return promise["catch"](err);
+ };
+}
+
+Sync.prototype.cancel = function () {
+ if (!this.canceled) {
+ this.canceled = true;
+ this.push.cancel();
+ this.pull.cancel();
+ }
+};
+
+},{"./replicate":19,"./utils":23,"events":27}],22:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = TaskQueue;
+
+function TaskQueue() {
+ this.isReady = false;
+ this.failed = false;
+ this.queue = [];
+}
+
+TaskQueue.prototype.execute = function () {
+ var d, func;
+ if (this.failed) {
+ while ((d = this.queue.shift())) {
+ if (typeof d === 'function') {
+ d(this.failed);
+ continue;
+ }
+ func = d.parameters[d.parameters.length - 1];
+ if (typeof func === 'function') {
+ func(this.failed);
+ } else if (d.name === 'changes' && typeof func.complete === 'function') {
+ func.complete(this.failed);
+ }
+ }
+ } else if (this.isReady) {
+ while ((d = this.queue.shift())) {
+
+ if (typeof d === 'function') {
+ d();
+ } else {
+ d.task = this.db[d.name].apply(this.db, d.parameters);
+ }
+ }
+ }
+};
+
+TaskQueue.prototype.fail = function (err) {
+ this.failed = err;
+ this.execute();
+};
+
+TaskQueue.prototype.ready = function (db) {
+ if (this.failed) {
+ return false;
+ } else if (arguments.length === 0) {
+ return this.isReady;
+ }
+ this.isReady = db ? true: false;
+ this.db = db;
+ this.execute();
+};
+
+TaskQueue.prototype.addTask = function (name, parameters) {
+ if (typeof name === 'function') {
+ this.queue.push(name);
+ if (this.failed) {
+ this.execute();
+ }
+ } else {
+ var task = { name: name, parameters: parameters };
+ this.queue.push(task);
+ if (this.failed) {
+ this.execute();
+ }
+ return task;
+ }
+};
+
+},{}],23:[function(_dereq_,module,exports){
+(function (process,global){
+/*jshint strict: false */
+/*global chrome */
+var merge = _dereq_('./merge');
+exports.extend = _dereq_('pouchdb-extend');
+exports.ajax = _dereq_('./deps/ajax');
+exports.createBlob = _dereq_('./deps/blob');
+exports.uuid = _dereq_('./deps/uuid');
+exports.getArguments = _dereq_('argsarray');
+var buffer = _dereq_('./deps/buffer');
+var errors = _dereq_('./deps/errors');
+var EventEmitter = _dereq_('events').EventEmitter;
+var collections = _dereq_('./deps/collections');
+exports.Map = collections.Map;
+exports.Set = collections.Set;
+
+if (typeof global.Promise === 'function') {
+ exports.Promise = global.Promise;
+} else {
+ exports.Promise = _dereq_('bluebird');
+}
+var Promise = exports.Promise;
+
+function toObject(array) {
+ var obj = {};
+ array.forEach(function (item) { obj[item] = true; });
+ return obj;
+}
+// List of top level reserved words for doc
+var reservedWords = toObject([
+ '_id',
+ '_rev',
+ '_attachments',
+ '_deleted',
+ '_revisions',
+ '_revs_info',
+ '_conflicts',
+ '_deleted_conflicts',
+ '_local_seq',
+ '_rev_tree',
+ //replication documents
+ '_replication_id',
+ '_replication_state',
+ '_replication_state_time',
+ '_replication_state_reason',
+ '_replication_stats'
+]);
+exports.clone = function (obj) {
+ return exports.extend(true, {}, obj);
+};
+exports.inherits = _dereq_('inherits');
+// Determine id an ID is valid
+// - invalid IDs begin with an underescore that does not begin '_design' or
+// '_local'
+// - any other string value is a valid id
+// Returns the specific error object for each case
+exports.invalidIdError = function (id) {
+ var err;
+ if (!id) {
+ err = new TypeError(errors.MISSING_ID.message);
+ err.status = 412;
+ } else if (typeof id !== 'string') {
+ err = new TypeError(errors.INVALID_ID.message);
+ err.status = 400;
+ } else if (/^_/.test(id) && !(/^_(design|local)/).test(id)) {
+ err = new TypeError(errors.RESERVED_ID.message);
+ err.status = 400;
+ }
+ if (err) {
+ throw err;
+ }
+};
+
+function isChromeApp() {
+ return (typeof chrome !== "undefined" &&
+ typeof chrome.storage !== "undefined" &&
+ typeof chrome.storage.local !== "undefined");
+}
+
+// Pretty dumb name for a function, just wraps callback calls so we dont
+// to if (callback) callback() everywhere
+exports.call = exports.getArguments(function (args) {
+ if (!args.length) {
+ return;
+ }
+ var fun = args.shift();
+ if (typeof fun === 'function') {
+ fun.apply(this, args);
+ }
+});
+
+exports.isLocalId = function (id) {
+ return (/^_local/).test(id);
+};
+
+// check if a specific revision of a doc has been deleted
+// - metadata: the metadata object from the doc store
+// - rev: (optional) the revision to check. defaults to winning revision
+exports.isDeleted = function (metadata, rev) {
+ if (!rev) {
+ rev = merge.winningRev(metadata);
+ }
+ var dashIndex = rev.indexOf('-');
+ if (dashIndex !== -1) {
+ rev = rev.substring(dashIndex + 1);
+ }
+ var deleted = false;
+ merge.traverseRevTree(metadata.rev_tree,
+ function (isLeaf, pos, id, acc, opts) {
+ if (id === rev) {
+ deleted = !!opts.deleted;
+ }
+ });
+
+ return deleted;
+};
+
+exports.filterChange = function (opts) {
+ return function (change) {
+ var req = {};
+ var hasFilter = opts.filter && typeof opts.filter === 'function';
+
+ req.query = opts.query_params;
+ if (opts.filter && hasFilter && !opts.filter.call(this, change.doc, req)) {
+ return false;
+ }
+ if (opts.doc_ids && opts.doc_ids.indexOf(change.id) === -1) {
+ return false;
+ }
+ if (!opts.include_docs) {
+ delete change.doc;
+ } else {
+ for (var att in change.doc._attachments) {
+ if (change.doc._attachments.hasOwnProperty(att)) {
+ change.doc._attachments[att].stub = true;
+ }
+ }
+ }
+ return true;
+ };
+};
+
+// Preprocess documents, parse their revisions, assign an id and a
+// revision for new writes that are missing them, etc
+exports.parseDoc = function (doc, newEdits) {
+ var nRevNum;
+ var newRevId;
+ var revInfo;
+ var error;
+ var opts = {status: 'available'};
+ if (doc._deleted) {
+ opts.deleted = true;
+ }
+
+ if (newEdits) {
+ if (!doc._id) {
+ doc._id = exports.uuid();
+ }
+ newRevId = exports.uuid(32, 16).toLowerCase();
+ if (doc._rev) {
+ revInfo = /^(\d+)-(.+)$/.exec(doc._rev);
+ if (!revInfo) {
+ var err = new TypeError("invalid value for property '_rev'");
+ err.status = 400;
+ }
+ doc._rev_tree = [{
+ pos: parseInt(revInfo[1], 10),
+ ids: [revInfo[2], {status: 'missing'}, [[newRevId, opts, []]]]
+ }];
+ nRevNum = parseInt(revInfo[1], 10) + 1;
+ } else {
+ doc._rev_tree = [{
+ pos: 1,
+ ids : [newRevId, opts, []]
+ }];
+ nRevNum = 1;
+ }
+ } else {
+ if (doc._revisions) {
+ doc._rev_tree = [{
+ pos: doc._revisions.start - doc._revisions.ids.length + 1,
+ ids: doc._revisions.ids.reduce(function (acc, x) {
+ if (acc === null) {
+ return [x, opts, []];
+ } else {
+ return [x, {status: 'missing'}, [acc]];
+ }
+ }, null)
+ }];
+ nRevNum = doc._revisions.start;
+ newRevId = doc._revisions.ids[0];
+ }
+ if (!doc._rev_tree) {
+ revInfo = /^(\d+)-(.+)$/.exec(doc._rev);
+ if (!revInfo) {
+ error = new TypeError(errors.BAD_ARG.message);
+ error.status = errors.BAD_ARG.status;
+ throw error;
+ }
+ nRevNum = parseInt(revInfo[1], 10);
+ newRevId = revInfo[2];
+ doc._rev_tree = [{
+ pos: parseInt(revInfo[1], 10),
+ ids: [revInfo[2], opts, []]
+ }];
+ }
+ }
+
+ exports.invalidIdError(doc._id);
+
+ doc._id = decodeURIComponent(doc._id);
+ doc._rev = [nRevNum, newRevId].join('-');
+
+ var result = {metadata : {}, data : {}};
+ for (var key in doc) {
+ if (doc.hasOwnProperty(key)) {
+ var specialKey = key[0] === '_';
+ if (specialKey && !reservedWords[key]) {
+ error = new Error(errors.DOC_VALIDATION.message + ': ' + key);
+ error.status = errors.DOC_VALIDATION.status;
+ throw error;
+ } else if (specialKey && key !== '_attachments') {
+ result.metadata[key.slice(1)] = doc[key];
+ } else {
+ result.data[key] = doc[key];
+ }
+ }
+ }
+ return result;
+};
+
+exports.isCordova = function () {
+ return (typeof cordova !== "undefined" ||
+ typeof PhoneGap !== "undefined" ||
+ typeof phonegap !== "undefined");
+};
+
+exports.hasLocalStorage = function () {
+ if (isChromeApp()) {
+ return false;
+ }
+ try {
+ return global.localStorage;
+ } catch (e) {
+ return false;
+ }
+};
+exports.Changes = Changes;
+exports.inherits(Changes, EventEmitter);
+function Changes() {
+ if (!(this instanceof Changes)) {
+ return new Changes();
+ }
+ var self = this;
+ EventEmitter.call(this);
+ this.isChrome = isChromeApp();
+ this.listeners = {};
+ this.hasLocal = false;
+ if (!this.isChrome) {
+ this.hasLocal = exports.hasLocalStorage();
+ }
+ if (this.isChrome) {
+ chrome.storage.onChanged.addListener(function (e) {
+ // make sure it's event addressed to us
+ if (e.db_name != null) {
+ //object only has oldValue, newValue members
+ self.emit(e.dbName.newValue);
+ }
+ });
+ } else if (this.hasLocal) {
+ if (global.addEventListener) {
+ global.addEventListener("storage", function (e) {
+ self.emit(e.key);
+ });
+ } else {
+ global.attachEvent("storage", function (e) {
+ self.emit(e.key);
+ });
+ }
+ }
+
+}
+Changes.prototype.addListener = function (dbName, id, db, opts) {
+ if (this.listeners[id]) {
+ return;
+ }
+ function eventFunction() {
+ db.changes({
+ include_docs: opts.include_docs,
+ conflicts: opts.conflicts,
+ continuous: false,
+ descending: false,
+ filter: opts.filter,
+ view: opts.view,
+ since: opts.since,
+ query_params: opts.query_params,
+ onChange: function (c) {
+ if (c.seq > opts.since && !opts.cancelled) {
+ opts.since = c.seq;
+ exports.call(opts.onChange, c);
+ }
+ }
+ });
+ }
+ this.listeners[id] = eventFunction;
+ this.on(dbName, eventFunction);
+};
+
+Changes.prototype.removeListener = function (dbName, id) {
+ if (!(id in this.listeners)) {
+ return;
+ }
+ EventEmitter.prototype.removeListener.call(this, dbName,
+ this.listeners[id]);
+};
+
+
+Changes.prototype.notifyLocalWindows = function (dbName) {
+ //do a useless change on a storage thing
+ //in order to get other windows's listeners to activate
+ if (this.isChrome) {
+ chrome.storage.local.set({dbName: dbName});
+ } else if (this.hasLocal) {
+ localStorage[dbName] = (localStorage[dbName] === "a") ? "b" : "a";
+ }
+};
+
+Changes.prototype.notify = function (dbName) {
+ this.emit(dbName);
+ this.notifyLocalWindows(dbName);
+};
+
+if (!process.browser || !('atob' in global)) {
+ exports.atob = function (str) {
+ var base64 = new buffer(str, 'base64');
+ // Node.js will just skip the characters it can't encode instead of
+ // throwing and exception
+ if (base64.toString('base64') !== str) {
+ throw ("Cannot base64 encode full string");
+ }
+ return base64.toString('binary');
+ };
+} else {
+ exports.atob = function (str) {
+ return atob(str);
+ };
+}
+
+if (!process.browser || !('btoa' in global)) {
+ exports.btoa = function (str) {
+ return new buffer(str, 'binary').toString('base64');
+ };
+} else {
+ exports.btoa = function (str) {
+ return btoa(str);
+ };
+}
+
+// From http://stackoverflow.com/questions/14967647/ (continues on next line)
+// encode-decode-image-with-base64-breaks-image (2013-04-21)
+exports.fixBinary = function (bin) {
+ if (!process.browser) {
+ // don't need to do this in Node
+ return bin;
+ }
+
+ var length = bin.length;
+ var buf = new ArrayBuffer(length);
+ var arr = new Uint8Array(buf);
+ for (var i = 0; i < length; i++) {
+ arr[i] = bin.charCodeAt(i);
+ }
+ return buf;
+};
+
+exports.once = function (fun) {
+ var called = false;
+ return exports.getArguments(function (args) {
+ if (called) {
+ if (typeof console.trace === 'function') {
+ console.trace();
+ }
+ throw new Error('once called more than once');
+ } else {
+ called = true;
+ fun.apply(this, args);
+ }
+ });
+};
+
+exports.toPromise = function (func) {
+ //create the function we will be returning
+ return exports.getArguments(function (args) {
+ var self = this;
+ var tempCB =
+ (typeof args[args.length - 1] === 'function') ? args.pop() : false;
+ // if the last argument is a function, assume its a callback
+ var usedCB;
+ if (tempCB) {
+ // if it was a callback, create a new callback which calls it,
+ // but do so async so we don't trap any errors
+ usedCB = function (err, resp) {
+ process.nextTick(function () {
+ tempCB(err, resp);
+ });
+ };
+ }
+ var promise = new Promise(function (fulfill, reject) {
+ var resp;
+ try {
+ var callback = exports.once(function (err, mesg) {
+ if (err) {
+ reject(err);
+ } else {
+ fulfill(mesg);
+ }
+ });
+ // create a callback for this invocation
+ // apply the function in the orig context
+ args.push(callback);
+ resp = func.apply(self, args);
+ if (resp && typeof resp.then === 'function') {
+ fulfill(resp);
+ }
+ } catch (e) {
+ reject(e);
+ }
+ });
+ // if there is a callback, call it back
+ if (usedCB) {
+ promise.then(function (result) {
+ usedCB(null, result);
+ }, usedCB);
+ }
+ promise.cancel = function () {
+ return this;
+ };
+ return promise;
+ });
+};
+
+exports.adapterFun = function (name, callback) {
+ return exports.toPromise(exports.getArguments(function (args) {
+ if (this._closed) {
+ return Promise.reject(new Error('database is closed'));
+ }
+ var self = this;
+ if (!this.taskqueue.isReady) {
+ return new exports.Promise(function (fulfill, reject) {
+ self.taskqueue.addTask(function (failed) {
+ if (failed) {
+ reject(failed);
+ } else {
+ fulfill(self[name].apply(self, args));
+ }
+ });
+ });
+ }
+ return callback.apply(this, args);
+ }));
+};
+//Can't find original post, but this is close
+//http://stackoverflow.com/questions/6965107/ (continues on next line)
+//converting-between-strings-and-arraybuffers
+exports.arrayBufferToBinaryString = function (buffer) {
+ var binary = "";
+ var bytes = new Uint8Array(buffer);
+ var length = bytes.byteLength;
+ for (var i = 0; i < length; i++) {
+ binary += String.fromCharCode(bytes[i]);
+ }
+ return binary;
+};
+
+exports.cancellableFun = function (fun, self, opts) {
+
+ opts = opts ? exports.clone(true, {}, opts) : {};
+
+ var emitter = new EventEmitter();
+ var oldComplete = opts.complete || function () { };
+ var complete = opts.complete = exports.once(function (err, resp) {
+ if (err) {
+ oldComplete(err);
+ } else {
+ emitter.emit('end', resp);
+ oldComplete(null, resp);
+ }
+ emitter.removeAllListeners();
+ });
+ var oldOnChange = opts.onChange || function () {};
+ var lastChange = 0;
+ self.on('destroyed', function () {
+ emitter.removeAllListeners();
+ });
+ opts.onChange = function (change) {
+ oldOnChange(change);
+ if (change.seq <= lastChange) {
+ return;
+ }
+ lastChange = change.seq;
+ emitter.emit('change', change);
+ if (change.deleted) {
+ emitter.emit('delete', change);
+ } else if (change.changes.length === 1 &&
+ change.changes[0].rev.slice(0, 1) === '1-') {
+ emitter.emit('create', change);
+ } else {
+ emitter.emit('update', change);
+ }
+ };
+ var promise = new Promise(function (fulfill, reject) {
+ opts.complete = function (err, res) {
+ if (err) {
+ reject(err);
+ } else {
+ fulfill(res);
+ }
+ };
+ });
+
+ promise.then(function (result) {
+ complete(null, result);
+ }, complete);
+
+ // this needs to be overwridden by caller, dont fire complete until
+ // the task is ready
+ promise.cancel = function () {
+ promise.isCancelled = true;
+ if (self.taskqueue.isReady) {
+ opts.complete(null, {status: 'cancelled'});
+ }
+ };
+
+ if (!self.taskqueue.isReady) {
+ self.taskqueue.addTask(function () {
+ if (promise.isCancelled) {
+ opts.complete(null, {status: 'cancelled'});
+ } else {
+ fun(self, opts, promise);
+ }
+ });
+ } else {
+ fun(self, opts, promise);
+ }
+ promise.on = emitter.on.bind(emitter);
+ promise.once = emitter.once.bind(emitter);
+ promise.addListener = emitter.addListener.bind(emitter);
+ promise.removeListener = emitter.removeListener.bind(emitter);
+ promise.removeAllListeners = emitter.removeAllListeners.bind(emitter);
+ promise.setMaxListeners = emitter.setMaxListeners.bind(emitter);
+ promise.listeners = emitter.listeners.bind(emitter);
+ promise.emit = emitter.emit.bind(emitter);
+ return promise;
+};
+
+exports.MD5 = exports.toPromise(_dereq_('./deps/md5'));
+}).call(this,_dereq_("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./deps/ajax":8,"./deps/blob":9,"./deps/buffer":26,"./deps/collections":10,"./deps/errors":11,"./deps/md5":12,"./deps/uuid":14,"./merge":18,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":28,"argsarray":25,"bluebird":33,"events":27,"inherits":29,"pouchdb-extend":47}],24:[function(_dereq_,module,exports){
+module.exports = "3.0.1";
+
+},{}],25:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = argsArray;
+
+function argsArray(fun) {
+ return function () {
+ var len = arguments.length;
+ if (len) {
+ var args = [];
+ var i = -1;
+ while (++i < len) {
+ args[i] = arguments[i];
+ }
+ return fun.call(this, args);
+ } else {
+ return fun.call(this, []);
+ }
+ };
+}
+},{}],26:[function(_dereq_,module,exports){
+
+},{}],27:[function(_dereq_,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+function EventEmitter() {
+ this._events = this._events || {};
+ this._maxListeners = this._maxListeners || undefined;
+}
+module.exports = EventEmitter;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+EventEmitter.defaultMaxListeners = 10;
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function(n) {
+ if (!isNumber(n) || n < 0 || isNaN(n))
+ throw TypeError('n must be a positive number');
+ this._maxListeners = n;
+ return this;
+};
+
+EventEmitter.prototype.emit = function(type) {
+ var er, handler, len, args, i, listeners;
+
+ if (!this._events)
+ this._events = {};
+
+ // If there is no 'error' event listener then throw.
+ if (type === 'error') {
+ if (!this._events.error ||
+ (isObject(this._events.error) && !this._events.error.length)) {
+ er = arguments[1];
+ if (er instanceof Error) {
+ throw er; // Unhandled 'error' event
+ } else {
+ throw TypeError('Uncaught, unspecified "error" event.');
+ }
+ return false;
+ }
+ }
+
+ handler = this._events[type];
+
+ if (isUndefined(handler))
+ return false;
+
+ if (isFunction(handler)) {
+ switch (arguments.length) {
+ // fast cases
+ case 1:
+ handler.call(this);
+ break;
+ case 2:
+ handler.call(this, arguments[1]);
+ break;
+ case 3:
+ handler.call(this, arguments[1], arguments[2]);
+ break;
+ // slower
+ default:
+ len = arguments.length;
+ args = new Array(len - 1);
+ for (i = 1; i < len; i++)
+ args[i - 1] = arguments[i];
+ handler.apply(this, args);
+ }
+ } else if (isObject(handler)) {
+ len = arguments.length;
+ args = new Array(len - 1);
+ for (i = 1; i < len; i++)
+ args[i - 1] = arguments[i];
+
+ listeners = handler.slice();
+ len = listeners.length;
+ for (i = 0; i < len; i++)
+ listeners[i].apply(this, args);
+ }
+
+ return true;
+};
+
+EventEmitter.prototype.addListener = function(type, listener) {
+ var m;
+
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ if (!this._events)
+ this._events = {};
+
+ // To avoid recursion in the case that type === "newListener"! Before
+ // adding it to the listeners, first emit "newListener".
+ if (this._events.newListener)
+ this.emit('newListener', type,
+ isFunction(listener.listener) ?
+ listener.listener : listener);
+
+ if (!this._events[type])
+ // Optimize the case of one listener. Don't need the extra array object.
+ this._events[type] = listener;
+ else if (isObject(this._events[type]))
+ // If we've already got an array, just append.
+ this._events[type].push(listener);
+ else
+ // Adding the second element, need to change to array.
+ this._events[type] = [this._events[type], listener];
+
+ // Check for listener leak
+ if (isObject(this._events[type]) && !this._events[type].warned) {
+ var m;
+ if (!isUndefined(this._maxListeners)) {
+ m = this._maxListeners;
+ } else {
+ m = EventEmitter.defaultMaxListeners;
+ }
+
+ if (m && m > 0 && this._events[type].length > m) {
+ this._events[type].warned = true;
+ console.error('(node) warning: possible EventEmitter memory ' +
+ 'leak detected. %d listeners added. ' +
+ 'Use emitter.setMaxListeners() to increase limit.',
+ this._events[type].length);
+ if (typeof console.trace === 'function') {
+ // not supported in IE 10
+ console.trace();
+ }
+ }
+ }
+
+ return this;
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.once = function(type, listener) {
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ var fired = false;
+
+ function g() {
+ this.removeListener(type, g);
+
+ if (!fired) {
+ fired = true;
+ listener.apply(this, arguments);
+ }
+ }
+
+ g.listener = listener;
+ this.on(type, g);
+
+ return this;
+};
+
+// emits a 'removeListener' event iff the listener was removed
+EventEmitter.prototype.removeListener = function(type, listener) {
+ var list, position, length, i;
+
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ if (!this._events || !this._events[type])
+ return this;
+
+ list = this._events[type];
+ length = list.length;
+ position = -1;
+
+ if (list === listener ||
+ (isFunction(list.listener) && list.listener === listener)) {
+ delete this._events[type];
+ if (this._events.removeListener)
+ this.emit('removeListener', type, listener);
+
+ } else if (isObject(list)) {
+ for (i = length; i-- > 0;) {
+ if (list[i] === listener ||
+ (list[i].listener && list[i].listener === listener)) {
+ position = i;
+ break;
+ }
+ }
+
+ if (position < 0)
+ return this;
+
+ if (list.length === 1) {
+ list.length = 0;
+ delete this._events[type];
+ } else {
+ list.splice(position, 1);
+ }
+
+ if (this._events.removeListener)
+ this.emit('removeListener', type, listener);
+ }
+
+ return this;
+};
+
+EventEmitter.prototype.removeAllListeners = function(type) {
+ var key, listeners;
+
+ if (!this._events)
+ return this;
+
+ // not listening for removeListener, no need to emit
+ if (!this._events.removeListener) {
+ if (arguments.length === 0)
+ this._events = {};
+ else if (this._events[type])
+ delete this._events[type];
+ return this;
+ }
+
+ // emit removeListener for all listeners on all events
+ if (arguments.length === 0) {
+ for (key in this._events) {
+ if (key === 'removeListener') continue;
+ this.removeAllListeners(key);
+ }
+ this.removeAllListeners('removeListener');
+ this._events = {};
+ return this;
+ }
+
+ listeners = this._events[type];
+
+ if (isFunction(listeners)) {
+ this.removeListener(type, listeners);
+ } else {
+ // LIFO order
+ while (listeners.length)
+ this.removeListener(type, listeners[listeners.length - 1]);
+ }
+ delete this._events[type];
+
+ return this;
+};
+
+EventEmitter.prototype.listeners = function(type) {
+ var ret;
+ if (!this._events || !this._events[type])
+ ret = [];
+ else if (isFunction(this._events[type]))
+ ret = [this._events[type]];
+ else
+ ret = this._events[type].slice();
+ return ret;
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+ var ret;
+ if (!emitter._events || !emitter._events[type])
+ ret = 0;
+ else if (isFunction(emitter._events[type]))
+ ret = 1;
+ else
+ ret = emitter._events[type].length;
+ return ret;
+};
+
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+
+function isUndefined(arg) {
+ return arg === void 0;
+}
+
+},{}],28:[function(_dereq_,module,exports){
+// shim for using process in browser
+
+var process = module.exports = {};
+
+process.nextTick = (function () {
+ var canSetImmediate = typeof window !== 'undefined'
+ && window.setImmediate;
+ var canPost = typeof window !== 'undefined'
+ && window.postMessage && window.addEventListener
+ ;
+
+ if (canSetImmediate) {
+ return function (f) { return window.setImmediate(f) };
+ }
+
+ if (canPost) {
+ var queue = [];
+ window.addEventListener('message', function (ev) {
+ var source = ev.source;
+ if ((source === window || source === null) && ev.data === 'process-tick') {
+ ev.stopPropagation();
+ if (queue.length > 0) {
+ var fn = queue.shift();
+ fn();
+ }
+ }
+ }, true);
+
+ return function nextTick(fn) {
+ queue.push(fn);
+ window.postMessage('process-tick', '*');
+ };
+ }
+
+ return function nextTick(fn) {
+ setTimeout(fn, 0);
+ };
+})();
+
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+
+process.binding = function (name) {
+ throw new Error('process.binding is not supported');
+}
+
+// TODO(shtylman)
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+ throw new Error('process.chdir is not supported');
+};
+
+},{}],29:[function(_dereq_,module,exports){
+if (typeof Object.create === 'function') {
+ // implementation from standard node.js 'util' module
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor
+ ctor.prototype = Object.create(superCtor.prototype, {
+ constructor: {
+ value: ctor,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ });
+ };
+} else {
+ // old school shim for old browsers
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor
+ var TempCtor = function () {}
+ TempCtor.prototype = superCtor.prototype
+ ctor.prototype = new TempCtor()
+ ctor.prototype.constructor = ctor
+ }
+}
+
+},{}],30:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = INTERNAL;
+
+function INTERNAL() {}
+},{}],31:[function(_dereq_,module,exports){
+'use strict';
+var Promise = _dereq_('./promise');
+var reject = _dereq_('./reject');
+var resolve = _dereq_('./resolve');
+var INTERNAL = _dereq_('./INTERNAL');
+var handlers = _dereq_('./handlers');
+var noArray = reject(new TypeError('must be an array'));
+module.exports = function all(iterable) {
+ if (Object.prototype.toString.call(iterable) !== '[object Array]') {
+ return noArray;
+ }
+
+ var len = iterable.length;
+ var called = false;
+ if (!len) {
+ return resolve([]);
+ }
+
+ var values = new Array(len);
+ var resolved = 0;
+ var i = -1;
+ var promise = new Promise(INTERNAL);
+
+ while (++i < len) {
+ allResolver(iterable[i], i);
+ }
+ return promise;
+ function allResolver(value, i) {
+ resolve(value).then(resolveFromAll, function (error) {
+ if (!called) {
+ called = true;
+ handlers.reject(promise, error);
+ }
+ });
+ function resolveFromAll(outValue) {
+ values[i] = outValue;
+ if (++resolved === len & !called) {
+ called = true;
+ handlers.resolve(promise, values);
+ }
+ }
+ }
+};
+},{"./INTERNAL":30,"./handlers":32,"./promise":34,"./reject":36,"./resolve":37}],32:[function(_dereq_,module,exports){
+'use strict';
+var tryCatch = _dereq_('./tryCatch');
+var resolveThenable = _dereq_('./resolveThenable');
+var states = _dereq_('./states');
+
+exports.resolve = function (self, value) {
+ var result = tryCatch(getThen, value);
+ if (result.status === 'error') {
+ return exports.reject(self, result.value);
+ }
+ var thenable = result.value;
+
+ if (thenable) {
+ resolveThenable.safely(self, thenable);
+ } else {
+ self.state = states.FULFILLED;
+ self.outcome = value;
+ var i = -1;
+ var len = self.queue.length;
+ while (++i < len) {
+ self.queue[i].callFulfilled(value);
+ }
+ }
+ return self;
+};
+exports.reject = function (self, error) {
+ self.state = states.REJECTED;
+ self.outcome = error;
+ var i = -1;
+ var len = self.queue.length;
+ while (++i < len) {
+ self.queue[i].callRejected(error);
+ }
+ return self;
+};
+
+function getThen(obj) {
+ // Make sure we only access the accessor once as required by the spec
+ var then = obj && obj.then;
+ if (obj && typeof obj === 'object' && typeof then === 'function') {
+ return function appyThen() {
+ then.apply(obj, arguments);
+ };
+ }
+}
+},{"./resolveThenable":38,"./states":39,"./tryCatch":40}],33:[function(_dereq_,module,exports){
+module.exports = exports = _dereq_('./promise');
+
+exports.resolve = _dereq_('./resolve');
+exports.reject = _dereq_('./reject');
+exports.all = _dereq_('./all');
+},{"./all":31,"./promise":34,"./reject":36,"./resolve":37}],34:[function(_dereq_,module,exports){
+'use strict';
+
+var unwrap = _dereq_('./unwrap');
+var INTERNAL = _dereq_('./INTERNAL');
+var resolveThenable = _dereq_('./resolveThenable');
+var states = _dereq_('./states');
+var QueueItem = _dereq_('./queueItem');
+
+module.exports = Promise;
+function Promise(resolver) {
+ if (!(this instanceof Promise)) {
+ return new Promise(resolver);
+ }
+ if (typeof resolver !== 'function') {
+ throw new TypeError('reslover must be a function');
+ }
+ this.state = states.PENDING;
+ this.queue = [];
+ this.outcome = void 0;
+ if (resolver !== INTERNAL) {
+ resolveThenable.safely(this, resolver);
+ }
+}
+
+Promise.prototype['catch'] = function (onRejected) {
+ return this.then(null, onRejected);
+};
+Promise.prototype.then = function (onFulfilled, onRejected) {
+ if (typeof onFulfilled !== 'function' && this.state === states.FULFILLED ||
+ typeof onRejected !== 'function' && this.state === states.REJECTED) {
+ return this;
+ }
+ var promise = new Promise(INTERNAL);
+
+
+ if (this.state !== states.PENDING) {
+ var resolver = this.state === states.FULFILLED ? onFulfilled: onRejected;
+ unwrap(promise, resolver, this.outcome);
+ } else {
+ this.queue.push(new QueueItem(promise, onFulfilled, onRejected));
+ }
+
+ return promise;
+};
+
+},{"./INTERNAL":30,"./queueItem":35,"./resolveThenable":38,"./states":39,"./unwrap":41}],35:[function(_dereq_,module,exports){
+'use strict';
+var handlers = _dereq_('./handlers');
+var unwrap = _dereq_('./unwrap');
+
+module.exports = QueueItem;
+function QueueItem(promise, onFulfilled, onRejected) {
+ this.promise = promise;
+ if (typeof onFulfilled === 'function') {
+ this.onFulfilled = onFulfilled;
+ this.callFulfilled = this.otherCallFulfilled;
+ }
+ if (typeof onRejected === 'function') {
+ this.onRejected = onRejected;
+ this.callRejected = this.otherCallRejected;
+ }
+}
+QueueItem.prototype.callFulfilled = function (value) {
+ handlers.resolve(this.promise, value);
+};
+QueueItem.prototype.otherCallFulfilled = function (value) {
+ unwrap(this.promise, this.onFulfilled, value);
+};
+QueueItem.prototype.callRejected = function (value) {
+ handlers.reject(this.promise, value);
+};
+QueueItem.prototype.otherCallRejected = function (value) {
+ unwrap(this.promise, this.onRejected, value);
+};
+},{"./handlers":32,"./unwrap":41}],36:[function(_dereq_,module,exports){
+'use strict';
+
+var Promise = _dereq_('./promise');
+var INTERNAL = _dereq_('./INTERNAL');
+var handlers = _dereq_('./handlers');
+module.exports = reject;
+
+function reject(reason) {
+ var promise = new Promise(INTERNAL);
+ return handlers.reject(promise, reason);
+}
+},{"./INTERNAL":30,"./handlers":32,"./promise":34}],37:[function(_dereq_,module,exports){
+'use strict';
+
+var Promise = _dereq_('./promise');
+var INTERNAL = _dereq_('./INTERNAL');
+var handlers = _dereq_('./handlers');
+module.exports = resolve;
+
+var FALSE = handlers.resolve(new Promise(INTERNAL), false);
+var NULL = handlers.resolve(new Promise(INTERNAL), null);
+var UNDEFINED = handlers.resolve(new Promise(INTERNAL), void 0);
+var ZERO = handlers.resolve(new Promise(INTERNAL), 0);
+var EMPTYSTRING = handlers.resolve(new Promise(INTERNAL), '');
+
+function resolve(value) {
+ if (value) {
+ if (value instanceof Promise) {
+ return value;
+ }
+ return handlers.resolve(new Promise(INTERNAL), value);
+ }
+ var valueType = typeof value;
+ switch (valueType) {
+ case 'boolean':
+ return FALSE;
+ case 'undefined':
+ return UNDEFINED;
+ case 'object':
+ return NULL;
+ case 'number':
+ return ZERO;
+ case 'string':
+ return EMPTYSTRING;
+ }
+}
+},{"./INTERNAL":30,"./handlers":32,"./promise":34}],38:[function(_dereq_,module,exports){
+'use strict';
+var handlers = _dereq_('./handlers');
+var tryCatch = _dereq_('./tryCatch');
+function safelyResolveThenable(self, thenable) {
+ // Either fulfill, reject or reject with error
+ var called = false;
+ function onError(value) {
+ if (called) {
+ return;
+ }
+ called = true;
+ handlers.reject(self, value);
+ }
+
+ function onSuccess(value) {
+ if (called) {
+ return;
+ }
+ called = true;
+ handlers.resolve(self, value);
+ }
+
+ function tryToUnwrap() {
+ thenable(onSuccess, onError);
+ }
+
+ var result = tryCatch(tryToUnwrap);
+ if (result.status === 'error') {
+ onError(result.value);
+ }
+}
+exports.safely = safelyResolveThenable;
+},{"./handlers":32,"./tryCatch":40}],39:[function(_dereq_,module,exports){
+// Lazy man's symbols for states
+
+exports.REJECTED = ['REJECTED'];
+exports.FULFILLED = ['FULFILLED'];
+exports.PENDING = ['PENDING'];
+},{}],40:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = tryCatch;
+
+function tryCatch(func, value) {
+ var out = {};
+ try {
+ out.value = func(value);
+ out.status = 'success';
+ } catch (e) {
+ out.status = 'error';
+ out.value = e;
+ }
+ return out;
+}
+},{}],41:[function(_dereq_,module,exports){
+'use strict';
+
+var immediate = _dereq_('immediate');
+var handlers = _dereq_('./handlers');
+module.exports = unwrap;
+
+function unwrap(promise, func, value) {
+ immediate(function () {
+ var returnValue;
+ try {
+ returnValue = func(value);
+ } catch (e) {
+ return handlers.reject(promise, e);
+ }
+ if (returnValue === promise) {
+ handlers.reject(promise, new TypeError('Cannot resolve promise with itself'));
+ } else {
+ handlers.resolve(promise, returnValue);
+ }
+ });
+}
+},{"./handlers":32,"immediate":42}],42:[function(_dereq_,module,exports){
+'use strict';
+var types = [
+ _dereq_('./nextTick'),
+ _dereq_('./mutation.js'),
+ _dereq_('./messageChannel'),
+ _dereq_('./stateChange'),
+ _dereq_('./timeout')
+];
+var draining;
+var queue = [];
+function drainQueue() {
+ draining = true;
+ var i, oldQueue;
+ var len = queue.length;
+ while (len) {
+ oldQueue = queue;
+ queue = [];
+ i = -1;
+ while (++i < len) {
+ oldQueue[i]();
+ }
+ len = queue.length;
+ }
+ draining = false;
+}
+var scheduleDrain;
+var i = -1;
+var len = types.length;
+while (++ i < len) {
+ if (types[i] && types[i].test && types[i].test()) {
+ scheduleDrain = types[i].install(drainQueue);
+ break;
+ }
+}
+module.exports = immediate;
+function immediate(task) {
+ if (queue.push(task) === 1 && !draining) {
+ scheduleDrain();
+ }
+}
+},{"./messageChannel":43,"./mutation.js":44,"./nextTick":26,"./stateChange":45,"./timeout":46}],43:[function(_dereq_,module,exports){
+(function (global){
+'use strict';
+
+exports.test = function () {
+ if (global.setImmediate) {
+ // we can only get here in IE10
+ // which doesn't handel postMessage well
+ return false;
+ }
+ return typeof global.MessageChannel !== 'undefined';
+};
+
+exports.install = function (func) {
+ var channel = new global.MessageChannel();
+ channel.port1.onmessage = func;
+ return function () {
+ channel.port2.postMessage(0);
+ };
+};
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],44:[function(_dereq_,module,exports){
+(function (global){
+'use strict';
+//based off rsvp https://github.com/tildeio/rsvp.js
+//license https://github.com/tildeio/rsvp.js/blob/master/LICENSE
+//https://github.com/tildeio/rsvp.js/blob/master/lib/rsvp/asap.js
+
+var Mutation = global.MutationObserver || global.WebKitMutationObserver;
+
+exports.test = function () {
+ return Mutation;
+};
+
+exports.install = function (handle) {
+ var called = 0;
+ var observer = new Mutation(handle);
+ var element = global.document.createTextNode('');
+ observer.observe(element, {
+ characterData: true
+ });
+ return function () {
+ element.data = (called = ++called % 2);
+ };
+};
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],45:[function(_dereq_,module,exports){
+(function (global){
+'use strict';
+
+exports.test = function () {
+ return 'document' in global && 'onreadystatechange' in global.document.createElement('script');
+};
+
+exports.install = function (handle) {
+ return function () {
+
+ // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
+ // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
+ var scriptEl = global.document.createElement('script');
+ scriptEl.onreadystatechange = function () {
+ handle();
+
+ scriptEl.onreadystatechange = null;
+ scriptEl.parentNode.removeChild(scriptEl);
+ scriptEl = null;
+ };
+ global.document.documentElement.appendChild(scriptEl);
+
+ return handle;
+ };
+};
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],46:[function(_dereq_,module,exports){
+'use strict';
+exports.test = function () {
+ return true;
+};
+
+exports.install = function (t) {
+ return function () {
+ setTimeout(t, 0);
+ };
+};
+},{}],47:[function(_dereq_,module,exports){
+"use strict";
+
+// Extends method
+// (taken from http://code.jquery.com/jquery-1.9.0.js)
+// Populate the class2type map
+var class2type = {};
+
+var types = [
+ "Boolean", "Number", "String", "Function", "Array",
+ "Date", "RegExp", "Object", "Error"
+];
+for (var i = 0; i < types.length; i++) {
+ var typename = types[i];
+ class2type["[object " + typename + "]"] = typename.toLowerCase();
+}
+
+var core_toString = class2type.toString;
+var core_hasOwn = class2type.hasOwnProperty;
+
+function type(obj) {
+ if (obj === null) {
+ return String(obj);
+ }
+ return typeof obj === "object" || typeof obj === "function" ?
+ class2type[core_toString.call(obj)] || "object" :
+ typeof obj;
+}
+
+function isWindow(obj) {
+ return obj !== null && obj === obj.window;
+}
+
+function isPlainObject(obj) {
+ // Must be an Object.
+ // Because of IE, we also have to check the presence of
+ // the constructor property.
+ // Make sure that DOM nodes and window objects don't pass through, as well
+ if (!obj || type(obj) !== "object" || obj.nodeType || isWindow(obj)) {
+ return false;
+ }
+
+ try {
+ // Not own constructor property must be Object
+ if (obj.constructor &&
+ !core_hasOwn.call(obj, "constructor") &&
+ !core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) {
+ return false;
+ }
+ } catch ( e ) {
+ // IE8,9 Will throw exceptions on certain host objects #9897
+ return false;
+ }
+
+ // Own properties are enumerated firstly, so to speed up,
+ // if last one is own, then all properties are own.
+ var key;
+ for (key in obj) {}
+
+ return key === undefined || core_hasOwn.call(obj, key);
+}
+
+
+function isFunction(obj) {
+ return type(obj) === "function";
+}
+
+var isArray = Array.isArray || function (obj) {
+ return type(obj) === "array";
+};
+
+function extend() {
+ var options, name, src, copy, copyIsArray, clone,
+ target = arguments[0] || {},
+ i = 1,
+ length = arguments.length,
+ deep = false;
+
+ // Handle a deep copy situation
+ if (typeof target === "boolean") {
+ deep = target;
+ target = arguments[1] || {};
+ // skip the boolean and the target
+ i = 2;
+ }
+
+ // Handle case when target is a string or something (possible in deep copy)
+ if (typeof target !== "object" && !isFunction(target)) {
+ target = {};
+ }
+
+ // extend jQuery itself if only one argument is passed
+ if (length === i) {
+ /* jshint validthis: true */
+ target = this;
+ --i;
+ }
+
+ for (; i < length; i++) {
+ // Only deal with non-null/undefined values
+ if ((options = arguments[i]) != null) {
+ // Extend the base object
+ for (name in options) {
+ //if (options.hasOwnProperty(name)) {
+ if (!(name in Object.prototype)) {
+
+ src = target[name];
+ copy = options[name];
+
+ // Prevent never-ending loop
+ if (target === copy) {
+ continue;
+ }
+
+ // Recurse if we're merging plain objects or arrays
+ if (deep && copy && (isPlainObject(copy) ||
+ (copyIsArray = isArray(copy)))) {
+ if (copyIsArray) {
+ copyIsArray = false;
+ clone = src && isArray(src) ? src : [];
+
+ } else {
+ clone = src && isPlainObject(src) ? src : {};
+ }
+
+ // Never move original objects, clone them
+ target[name] = extend(deep, clone, copy);
+
+ // Don't bring in undefined values
+ } else if (copy !== undefined) {
+ if (!(isArray(options) && isFunction(copy))) {
+ target[name] = copy;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Return the modified object
+ return target;
+}
+
+
+module.exports = extend;
+
+
+
+},{}],48:[function(_dereq_,module,exports){
+'use strict';
+
+var upsert = _dereq_('./upsert');
+var utils = _dereq_('./utils');
+var Promise = utils.Promise;
+
+module.exports = function (opts) {
+ var sourceDB = opts.db;
+ var viewName = opts.viewName;
+ var mapFun = opts.map;
+ var reduceFun = opts.reduce;
+ var temporary = opts.temporary;
+
+ // the "undefined" part is for backwards compatibility
+ var viewSignature = mapFun.toString() + (reduceFun && reduceFun.toString()) +
+ 'undefined';
+
+ if (!temporary && sourceDB._cachedViews) {
+ var cachedView = sourceDB._cachedViews[viewSignature];
+ if (cachedView) {
+ return Promise.resolve(cachedView);
+ }
+ }
+
+ return sourceDB.info().then(function (info) {
+
+ var depDbName = info.db_name + '-mrview-' +
+ (temporary ? 'temp' : utils.MD5(viewSignature));
+
+ // save the view name in the source PouchDB so it can be cleaned up if necessary
+ // (e.g. when the _design doc is deleted, remove all associated view data)
+ function diffFunction(doc) {
+ doc.views = doc.views || {};
+ var fullViewName = viewName;
+ if (fullViewName.indexOf('/') === -1) {
+ fullViewName = viewName + '/' + viewName;
+ }
+ var depDbs = doc.views[fullViewName] = doc.views[fullViewName] || {};
+ /* istanbul ignore if */
+ if (depDbs[depDbName]) {
+ return; // no update necessary
+ }
+ depDbs[depDbName] = true;
+ return doc;
+ }
+ return upsert(sourceDB, '_local/mrviews', diffFunction).then(function () {
+ return sourceDB.registerDependentDatabase(depDbName).then(function (res) {
+ var db = res.db;
+ db.auto_compaction = true;
+ var view = {
+ name: depDbName,
+ db: db,
+ sourceDB: sourceDB,
+ adapter: sourceDB.adapter,
+ mapFun: mapFun,
+ reduceFun: reduceFun
+ };
+ return view.db.get('_local/lastSeq')["catch"](function (err) {
+ /* istanbul ignore if */
+ if (err.name !== 'not_found') {
+ throw err;
+ }
+ }).then(function (lastSeqDoc) {
+ view.seq = lastSeqDoc ? lastSeqDoc.seq : 0;
+ if (!temporary) {
+ sourceDB._cachedViews = sourceDB._cachedViews || {};
+ sourceDB._cachedViews[viewSignature] = view;
+ view.db.on('destroyed', function () {
+ delete sourceDB._cachedViews[viewSignature];
+ });
+ }
+ return view;
+ });
+ });
+ });
+ });
+};
+
+},{"./upsert":54,"./utils":55}],49:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = function (func, emit, sum, log, isArray, toJSON) {
+ /*jshint evil:true,unused:false */
+ return eval("'use strict'; (" + func.replace(/;\s*$/, "") + ");");
+};
+
+},{}],50:[function(_dereq_,module,exports){
+(function (process){
+'use strict';
+
+var pouchCollate = _dereq_('pouchdb-collate');
+var TaskQueue = _dereq_('./taskqueue');
+var collate = pouchCollate.collate;
+var toIndexableString = pouchCollate.toIndexableString;
+var normalizeKey = pouchCollate.normalizeKey;
+var createView = _dereq_('./create-view');
+var evalFunc = _dereq_('./evalfunc');
+var log;
+/* istanbul ignore else */
+if ((typeof console !== 'undefined') && (typeof console.log === 'function')) {
+ log = Function.prototype.bind.call(console.log, console);
+} else {
+ log = function () {};
+}
+var utils = _dereq_('./utils');
+var Promise = utils.Promise;
+var mainQueue = new TaskQueue();
+var tempViewQueue = new TaskQueue();
+var CHANGES_BATCH_SIZE = 50;
+
+function parseViewName(name) {
+ // can be either 'ddocname/viewname' or just 'viewname'
+ // (where the ddoc name is the same)
+ return name.indexOf('/') === -1 ? [name, name] : name.split('/');
+}
+
+function tryCode(db, fun, args) {
+ // emit an event if there was an error thrown by a map/reduce function.
+ // putting try/catches in a single function also avoids deoptimizations.
+ try {
+ return {
+ output : fun.apply(null, args)
+ };
+ } catch (e) {
+ db.emit('error', e);
+ return {error : e};
+ }
+}
+
+function sortByKeyThenValue(x, y) {
+ var keyCompare = collate(x.key, y.key);
+ return keyCompare !== 0 ? keyCompare : collate(x.value, y.value);
+}
+
+function sliceResults(results, limit, skip) {
+ skip = skip || 0;
+ if (typeof limit === 'number') {
+ return results.slice(skip, limit + skip);
+ } else if (skip > 0) {
+ return results.slice(skip);
+ }
+ return results;
+}
+
+function createBuiltInError(name) {
+ var error = new Error('builtin ' + name +
+ ' function requires map values to be numbers' +
+ ' or number arrays');
+ error.name = 'invalid_value';
+ error.status = 500;
+ return error;
+}
+
+function sum(values) {
+ var result = 0;
+ for (var i = 0, len = values.length; i < len; i++) {
+ var num = values[i];
+ if (typeof num !== 'number') {
+ if (Array.isArray(num)) {
+ // lists of numbers are also allowed, sum them separately
+ result = typeof result === 'number' ? [result] : result;
+ for (var j = 0, jLen = num.length; j < jLen; j++) {
+ var jNum = num[j];
+ if (typeof jNum !== 'number') {
+ throw createBuiltInError('_sum');
+ } else if (typeof result[j] === 'undefined') {
+ result.push(jNum);
+ } else {
+ result[j] += jNum;
+ }
+ }
+ } else { // not array/number
+ throw createBuiltInError('_sum');
+ }
+ } else if (typeof result === 'number') {
+ result += num;
+ } else { // add number to array
+ result[0] += num;
+ }
+ }
+ return result;
+}
+
+var builtInReduce = {
+ _sum: function (keys, values) {
+ return sum(values);
+ },
+
+ _count: function (keys, values) {
+ return values.length;
+ },
+
+ _stats: function (keys, values) {
+ // no need to implement rereduce=true, because Pouch
+ // will never call it
+ function sumsqr(values) {
+ var _sumsqr = 0;
+ for (var i = 0, len = values.length; i < len; i++) {
+ var num = values[i];
+ _sumsqr += (num * num);
+ }
+ return _sumsqr;
+ }
+ return {
+ sum : sum(values),
+ min : Math.min.apply(null, values),
+ max : Math.max.apply(null, values),
+ count : values.length,
+ sumsqr : sumsqr(values)
+ };
+ }
+};
+
+function addHttpParam(paramName, opts, params, asJson) {
+ // add an http param from opts to params, optionally json-encoded
+ var val = opts[paramName];
+ if (typeof val !== 'undefined') {
+ if (asJson) {
+ val = encodeURIComponent(JSON.stringify(val));
+ }
+ params.push(paramName + '=' + val);
+ }
+}
+
+function checkQueryParseError(options, fun) {
+ var startkeyName = options.descending ? 'endkey' : 'startkey';
+ var endkeyName = options.descending ? 'startkey' : 'endkey';
+
+ if (typeof options[startkeyName] !== 'undefined' &&
+ typeof options[endkeyName] !== 'undefined' &&
+ collate(options[startkeyName], options[endkeyName]) > 0) {
+ throw new QueryParseError('No rows can match your key range, reverse your ' +
+ 'start_key and end_key or set {descending : true}');
+ } else if (fun.reduce && options.reduce !== false) {
+ if (options.include_docs) {
+ throw new QueryParseError('{include_docs:true} is invalid for reduce');
+ } else if (options.keys && options.keys.length > 1 &&
+ !options.group && !options.group_level) {
+ throw new QueryParseError('Multi-key fetches for reduce views must use {group: true}');
+ }
+ }
+ if (options.group_level) {
+ if (typeof options.group_level !== 'number') {
+ throw new QueryParseError('Invalid value for integer: "' + options.group_level + '"');
+ }
+ if (options.group_level < 0) {
+ throw new QueryParseError('Invalid value for positive integer: ' +
+ '"' + options.group_level + '"');
+ }
+ }
+}
+
+function httpQuery(db, fun, opts) {
+ // List of parameters to add to the PUT request
+ var params = [];
+ var body;
+ var method = 'GET';
+
+ // If opts.reduce exists and is defined, then add it to the list
+ // of parameters.
+ // If reduce=false then the results are that of only the map function
+ // not the final result of map and reduce.
+ addHttpParam('reduce', opts, params);
+ addHttpParam('include_docs', opts, params);
+ addHttpParam('limit', opts, params);
+ addHttpParam('descending', opts, params);
+ addHttpParam('group', opts, params);
+ addHttpParam('group_level', opts, params);
+ addHttpParam('skip', opts, params);
+ addHttpParam('stale', opts, params);
+ addHttpParam('startkey', opts, params, true);
+ addHttpParam('endkey', opts, params, true);
+ addHttpParam('inclusive_end', opts, params);
+ addHttpParam('key', opts, params, true);
+
+ // Format the list of parameters into a valid URI query string
+ params = params.join('&');
+ params = params === '' ? '' : '?' + params;
+
+ // If keys are supplied, issue a POST request to circumvent GET query string limits
+ // see http://wiki.apache.org/couchdb/HTTP_view_API#Querying_Options
+ if (typeof opts.keys !== 'undefined') {
+ var MAX_URL_LENGTH = 2000;
+ // according to http://stackoverflow.com/a/417184/680742,
+ // the de facto URL length limit is 2000 characters
+
+ var keysAsString =
+ 'keys=' + encodeURIComponent(JSON.stringify(opts.keys));
+ if (keysAsString.length + params.length + 1 <= MAX_URL_LENGTH) {
+ // If the keys are short enough, do a GET. we do this to work around
+ // Safari not understanding 304s on POSTs (see pouchdb/pouchdb#1239)
+ params += (params[0] === '?' ? '&' : '?') + keysAsString;
+ } else {
+ method = 'POST';
+ if (typeof fun === 'string') {
+ body = JSON.stringify({keys: opts.keys});
+ } else { // fun is {map : mapfun}, so append to this
+ fun.keys = opts.keys;
+ }
+ }
+ }
+
+ // We are referencing a query defined in the design doc
+ if (typeof fun === 'string') {
+ var parts = parseViewName(fun);
+ return db.request({
+ method: method,
+ url: '_design/' + parts[0] + '/_view/' + parts[1] + params,
+ body: body
+ });
+ }
+
+ // We are using a temporary view, terrible for performance but good for testing
+ body = body || {};
+ Object.keys(fun).forEach(function (key) {
+ if (Array.isArray(fun[key])) {
+ body[key] = fun[key];
+ } else {
+ body[key] = fun[key].toString();
+ }
+ });
+ return db.request({
+ method: 'POST',
+ url: '_temp_view' + params,
+ body: body
+ });
+}
+
+function defaultsTo(value) {
+ return function (reason) {
+ /* istanbul ignore else */
+ if (reason.name === 'not_found') {
+ return value;
+ } else {
+ throw reason;
+ }
+ };
+}
+
+// returns a promise for a list of docs to update, based on the input docId.
+// we update the metaDoc first (i.e. the doc that points from the sourceDB
+// document Id to the ids of the documents in the mrview database), then
+// the key/value docs. that way, if lightning strikes the user's computer
+// in the middle of an update, we don't write any docs that we wouldn't
+// be able to find later using the metaDoc.
+function getDocsToPersist(docId, view, docIdsToEmits) {
+ var metaDocId = '_local/doc_' + docId;
+ return view.db.get(metaDocId)[
+ "catch"](defaultsTo({_id: metaDocId, keys: []}))
+ .then(function (metaDoc) {
+ return Promise.resolve().then(function () {
+ if (metaDoc.keys.length) {
+ return view.db.allDocs({
+ keys: metaDoc.keys,
+ include_docs: true
+ });
+ }
+ return {rows: []}; // no keys, no need for a lookup
+ }).then(function (res) {
+ var kvDocs = res.rows.map(function (row) {
+ return row.doc;
+ }).filter(function (row) {
+ return row;
+ });
+
+ var indexableKeysToKeyValues = docIdsToEmits[docId];
+ var oldKeysMap = {};
+ kvDocs.forEach(function (kvDoc) {
+ oldKeysMap[kvDoc._id] = true;
+ kvDoc._deleted = !indexableKeysToKeyValues[kvDoc._id];
+ if (!kvDoc._deleted) {
+ kvDoc.value = indexableKeysToKeyValues[kvDoc._id];
+ }
+ });
+
+ var newKeys = Object.keys(indexableKeysToKeyValues);
+ newKeys.forEach(function (key) {
+ if (!oldKeysMap[key]) {
+ // new doc
+ kvDocs.push({
+ _id: key,
+ value: indexableKeysToKeyValues[key]
+ });
+ }
+ });
+ metaDoc.keys = utils.uniq(newKeys.concat(metaDoc.keys));
+ kvDocs.splice(0, 0, metaDoc);
+
+ return kvDocs;
+ });
+ });
+}
+
+// updates all emitted key/value docs and metaDocs in the mrview database
+// for the given batch of documents from the source database
+function saveKeyValues(view, docIdsToEmits, seq) {
+ var seqDocId = '_local/lastSeq';
+ return view.db.get(seqDocId)[
+ "catch"](defaultsTo({_id: seqDocId, seq: 0}))
+ .then(function (lastSeqDoc) {
+ var docIds = Object.keys(docIdsToEmits);
+ return Promise.all(docIds.map(function (docId) {
+ return getDocsToPersist(docId, view, docIdsToEmits);
+ })).then(function (listOfDocsToPersist) {
+ var docsToPersist = [];
+ listOfDocsToPersist.forEach(function (docList) {
+ docsToPersist = docsToPersist.concat(docList);
+ });
+
+ // update the seq doc last, so that if a meteor strikes the user's
+ // computer in the middle of an update, we can apply the idempotent
+ // batch update operation again
+ lastSeqDoc.seq = seq;
+ docsToPersist.push(lastSeqDoc);
+
+ return view.db.bulkDocs({docs : docsToPersist});
+ });
+ });
+}
+
+var updateView = utils.sequentialize(mainQueue, function (view) {
+ // bind the emit function once
+ var mapResults;
+ var doc;
+
+ function emit(key, value) {
+ mapResults.push({
+ id : doc._id,
+ key : normalizeKey(key),
+ value : normalizeKey(value)
+ });
+ }
+
+ var mapFun;
+ // for temp_views one can use emit(doc, emit), see #38
+ if (typeof view.mapFun === "function" && view.mapFun.length === 2) {
+ var origMap = view.mapFun;
+ mapFun = function (doc) {
+ return origMap(doc, emit);
+ };
+ } else {
+ mapFun = evalFunc(view.mapFun.toString(), emit, sum, log, Array.isArray, JSON.parse);
+ }
+
+ var currentSeq = view.seq || 0;
+
+ function processChange(docIdsToEmits, seq) {
+ return function () {
+ return saveKeyValues(view, docIdsToEmits, seq);
+ };
+ }
+ var queue = new TaskQueue();
+ // TODO(neojski): https://github.com/daleharvey/pouchdb/issues/1521
+
+ return new Promise(function (resolve, reject) {
+
+ function complete() {
+ queue.finish().then(function () {
+ view.seq = currentSeq;
+ resolve();
+ });
+ }
+
+ function processNextBatch() {
+ view.sourceDB.changes({
+ conflicts: true,
+ include_docs: true,
+ since : currentSeq,
+ limit : CHANGES_BATCH_SIZE
+ }).on('complete', function (response) {
+ var results = response.results;
+ if (!results.length) {
+ return complete();
+ }
+ var docIdsToEmits = {};
+ for (var i = 0, l = results.length; i < l; i++) {
+ var change = results[i];
+ if (change.doc._id[0] !== '_') {
+ mapResults = [];
+ doc = change.doc;
+
+ if (!doc._deleted) {
+ tryCode(view.sourceDB, mapFun, [doc]);
+ }
+ mapResults.sort(sortByKeyThenValue);
+
+ var indexableKeysToKeyValues = {};
+ for (var j = 0, jl = mapResults.length; j < jl; j++) {
+ var obj = mapResults[j];
+ var indexableKey = toIndexableString([obj.key, obj.id, j]);
+ indexableKeysToKeyValues[indexableKey] = obj;
+ }
+ docIdsToEmits[change.doc._id] = indexableKeysToKeyValues;
+ }
+ currentSeq = change.seq;
+ }
+ queue.add(processChange(docIdsToEmits, currentSeq));
+ if (results.length < CHANGES_BATCH_SIZE) {
+ return complete();
+ }
+ return processNextBatch();
+ }).on('error', onError);
+ /* istanbul ignore next */
+ function onError(err) {
+ reject(err);
+ }
+ }
+ processNextBatch();
+ });
+});
+
+function reduceView(view, results, options) {
+ if (options.group_level === 0) {
+ delete options.group_level;
+ }
+
+ var shouldGroup = options.group || options.group_level;
+
+ var reduceFun;
+ if (builtInReduce[view.reduceFun]) {
+ reduceFun = builtInReduce[view.reduceFun];
+ } else {
+ reduceFun = evalFunc(
+ view.reduceFun.toString(), null, sum, log, Array.isArray, JSON.parse);
+ }
+
+ var groups = [];
+ var lvl = options.group_level;
+ results.forEach(function (e) {
+ var last = groups[groups.length - 1];
+ var key = shouldGroup ? e.key : null;
+
+ // only set group_level for array keys
+ if (shouldGroup && Array.isArray(key) && typeof lvl === 'number') {
+ key = key.length > lvl ? key.slice(0, lvl) : key;
+ }
+
+ if (last && collate(last.key[0][0], key) === 0) {
+ last.key.push([key, e.id]);
+ last.value.push(e.value);
+ return;
+ }
+ groups.push({key: [
+ [key, e.id]
+ ], value: [e.value]});
+ });
+ for (var i = 0, len = groups.length; i < len; i++) {
+ var e = groups[i];
+ var reduceTry = tryCode(view.sourceDB, reduceFun, [e.key, e.value, false]);
+ // CouchDB typically just sets the value to null if reduce errors out
+ e.value = reduceTry.error ? null : reduceTry.output;
+ e.key = e.key[0][0];
+ }
+ // no total_rows/offset when reducing
+ return {rows: sliceResults(groups, options.limit, options.skip)};
+}
+
+var queryView = utils.sequentialize(mainQueue, function (view, opts) {
+ var totalRows;
+ var shouldReduce = view.reduceFun && opts.reduce !== false;
+ var skip = opts.skip || 0;
+ if (typeof opts.keys !== 'undefined' && !opts.keys.length) {
+ // equivalent query
+ opts.limit = 0;
+ delete opts.keys;
+ }
+
+ function fetchFromView(viewOpts) {
+ viewOpts.include_docs = true;
+ return view.db.allDocs(viewOpts).then(function (res) {
+ totalRows = res.total_rows;
+ return res.rows.map(function (result) {
+ return result.doc.value;
+ });
+ });
+ }
+
+ function onMapResultsReady(results) {
+ var res;
+ if (shouldReduce) {
+ res = reduceView(view, results, opts);
+ } else {
+ res = {
+ total_rows: totalRows,
+ offset: skip,
+ rows: results
+ };
+ }
+ if (opts.include_docs) {
+ var getDocsPromises = results.map(function (row) {
+ var val = row.value;
+ var docId = (val && typeof val === 'object' && val._id) || row.id;
+ return view.sourceDB.get(docId).then(function (joinedDoc) {
+ row.doc = joinedDoc;
+ }, function () {
+ // document error = don't join
+ });
+ });
+ return Promise.all(getDocsPromises).then(function () {
+ return res;
+ });
+ } else {
+ return res;
+ }
+ }
+
+ var flatten = function (array) {
+ return array.reduce(function (prev, cur) {
+ return prev.concat(cur);
+ });
+ };
+
+ if (typeof opts.keys !== 'undefined') {
+ var keys = opts.keys;
+ var fetchPromises = keys.map(function (key) {
+ var viewOpts = {
+ startkey : toIndexableString([key]),
+ endkey : toIndexableString([key, {}])
+ };
+ return fetchFromView(viewOpts);
+ });
+ return Promise.all(fetchPromises).then(flatten).then(onMapResultsReady);
+ } else { // normal query, no 'keys'
+ var viewOpts = {
+ descending : opts.descending
+ };
+ if (typeof opts.startkey !== 'undefined') {
+ viewOpts.startkey = opts.descending ?
+ toIndexableString([opts.startkey, {}]) :
+ toIndexableString([opts.startkey]);
+ }
+ if (typeof opts.endkey !== 'undefined') {
+ var inclusiveEnd = opts.inclusive_end !== false;
+ if (opts.descending) {
+ inclusiveEnd = !inclusiveEnd;
+ }
+
+ viewOpts.endkey = toIndexableString(inclusiveEnd ? [opts.endkey, {}] : [opts.endkey]);
+ }
+ if (typeof opts.key !== 'undefined') {
+ var keyStart = toIndexableString([opts.key]);
+ var keyEnd = toIndexableString([opts.key, {}]);
+ if (viewOpts.descending) {
+ viewOpts.endkey = keyStart;
+ viewOpts.startkey = keyEnd;
+ } else {
+ viewOpts.startkey = keyStart;
+ viewOpts.endkey = keyEnd;
+ }
+ }
+ if (!shouldReduce) {
+ if (typeof opts.limit === 'number') {
+ viewOpts.limit = opts.limit;
+ }
+ viewOpts.skip = skip;
+ }
+ return fetchFromView(viewOpts).then(onMapResultsReady);
+ }
+});
+
+function httpViewCleanup(db) {
+ return db.request({
+ method: 'POST',
+ url: '_view_cleanup'
+ });
+}
+
+var localViewCleanup = utils.sequentialize(mainQueue, function (db) {
+ return db.get('_local/mrviews').then(function (metaDoc) {
+ var docsToViews = {};
+ Object.keys(metaDoc.views).forEach(function (fullViewName) {
+ var parts = parseViewName(fullViewName);
+ var designDocName = '_design/' + parts[0];
+ var viewName = parts[1];
+ docsToViews[designDocName] = docsToViews[designDocName] || {};
+ docsToViews[designDocName][viewName] = true;
+ });
+ var opts = {
+ keys : Object.keys(docsToViews),
+ include_docs : true
+ };
+ return db.allDocs(opts).then(function (res) {
+ var viewsToStatus = {};
+ res.rows.forEach(function (row) {
+ var ddocName = row.key.substring(8);
+ Object.keys(docsToViews[row.key]).forEach(function (viewName) {
+ var fullViewName = ddocName + '/' + viewName;
+ /* istanbul ignore if */
+ if (!metaDoc.views[fullViewName]) {
+ // new format, without slashes, to support PouchDB 2.2.0
+ // migration test in pouchdb's browser.migration.js verifies this
+ fullViewName = viewName;
+ }
+ var viewDBNames = Object.keys(metaDoc.views[fullViewName]);
+ // design doc deleted, or view function nonexistent
+ var statusIsGood = row.doc && row.doc.views && row.doc.views[viewName];
+ viewDBNames.forEach(function (viewDBName) {
+ viewsToStatus[viewDBName] = viewsToStatus[viewDBName] || statusIsGood;
+ });
+ });
+ });
+ var dbsToDelete = Object.keys(viewsToStatus).filter(function (viewDBName) {
+ return !viewsToStatus[viewDBName];
+ });
+ var destroyPromises = dbsToDelete.map(function (viewDBName) {
+ return db.constructor.destroy(viewDBName, {adapter : db.adapter});
+ });
+ return Promise.all(destroyPromises).then(function () {
+ return {ok: true};
+ });
+ });
+ }, defaultsTo({ok: true}));
+});
+
+exports.viewCleanup = utils.callbackify(function () {
+ var db = this;
+ if (db.type() === 'http') {
+ return httpViewCleanup(db);
+ }
+ return localViewCleanup(db);
+});
+
+function queryPromised(db, fun, opts) {
+ if (db.type() === 'http') {
+ return httpQuery(db, fun, opts);
+ }
+
+ if (typeof fun !== 'string') {
+ // temp_view
+ checkQueryParseError(opts, fun);
+
+ var createViewOpts = {
+ db : db,
+ viewName : 'temp_view/temp_view',
+ map : fun.map,
+ reduce : fun.reduce,
+ temporary : true
+ };
+ tempViewQueue.add(function () {
+ return createView(createViewOpts).then(function (view) {
+ function cleanup() {
+ return view.db.destroy();
+ }
+ return utils.fin(updateView(view).then(function () {
+ return queryView(view, opts);
+ }), cleanup);
+ });
+ });
+ return tempViewQueue.finish();
+ } else {
+ // persistent view
+ var fullViewName = fun;
+ var parts = parseViewName(fullViewName);
+ var designDocName = parts[0];
+ var viewName = parts[1];
+ return db.get('_design/' + designDocName).then(function (doc) {
+ var fun = doc.views && doc.views[viewName];
+
+ if (!fun || typeof fun.map !== 'string') {
+ throw new NotFoundError('ddoc ' + designDocName + ' has no view named ' +
+ viewName);
+ }
+ checkQueryParseError(opts, fun);
+
+ var createViewOpts = {
+ db : db,
+ viewName : fullViewName,
+ map : fun.map,
+ reduce : fun.reduce
+ };
+ return createView(createViewOpts).then(function (view) {
+ if (opts.stale === 'ok' || opts.stale === 'update_after') {
+ if (opts.stale === 'update_after') {
+ process.nextTick(function () {
+ updateView(view);
+ });
+ }
+ return queryView(view, opts);
+ } else { // stale not ok
+ return updateView(view).then(function () {
+ return queryView(view, opts);
+ });
+ }
+ });
+ });
+ }
+}
+
+exports.query = function (fun, opts, callback) {
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ opts = utils.extend(true, {}, opts);
+
+ if (typeof fun === 'function') {
+ fun = {map : fun};
+ }
+
+ var db = this;
+ var promise = Promise.resolve().then(function () {
+ return queryPromised(db, fun, opts);
+ });
+ utils.promisedCallback(promise, callback);
+ return promise;
+};
+
+function QueryParseError(message) {
+ this.status = 400;
+ this.name = 'query_parse_error';
+ this.message = message;
+ this.error = true;
+ try {
+ Error.captureStackTrace(this, QueryParseError);
+ } catch (e) {}
+}
+
+utils.inherits(QueryParseError, Error);
+
+function NotFoundError(message) {
+ this.status = 404;
+ this.name = 'not_found';
+ this.message = message;
+ this.error = true;
+ try {
+ Error.captureStackTrace(this, NotFoundError);
+ } catch (e) {}
+}
+
+utils.inherits(NotFoundError, Error);
+
+}).call(this,_dereq_("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"./create-view":48,"./evalfunc":49,"./taskqueue":53,"./utils":55,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":28,"pouchdb-collate":51}],51:[function(_dereq_,module,exports){
+'use strict';
+
+var MIN_MAGNITUDE = -324; // verified by -Number.MIN_VALUE
+var MAGNITUDE_DIGITS = 3; // ditto
+var SEP = ''; // set to '_' for easier debugging
+
+var utils = _dereq_('./utils');
+
+exports.collate = function (a, b) {
+
+ if (a === b) {
+ return 0;
+ }
+
+ a = exports.normalizeKey(a);
+ b = exports.normalizeKey(b);
+
+ var ai = collationIndex(a);
+ var bi = collationIndex(b);
+ if ((ai - bi) !== 0) {
+ return ai - bi;
+ }
+ if (a === null) {
+ return 0;
+ }
+ switch (typeof a) {
+ case 'number':
+ return a - b;
+ case 'boolean':
+ return a === b ? 0 : (a < b ? -1 : 1);
+ case 'string':
+ return stringCollate(a, b);
+ }
+ return Array.isArray(a) ? arrayCollate(a, b) : objectCollate(a, b);
+};
+
+// couch considers null/NaN/Infinity/-Infinity === undefined,
+// for the purposes of mapreduce indexes. also, dates get stringified.
+exports.normalizeKey = function (key) {
+ switch (typeof key) {
+ case 'undefined':
+ return null;
+ case 'number':
+ if (key === Infinity || key === -Infinity || isNaN(key)) {
+ return null;
+ }
+ return key;
+ case 'object':
+ var origKey = key;
+ if (Array.isArray(key)) {
+ var len = key.length;
+ key = new Array(len);
+ for (var i = 0; i < len; i++) {
+ key[i] = exports.normalizeKey(origKey[i]);
+ }
+ } else if (key instanceof Date) {
+ return key.toJSON();
+ } else if (key !== null) { // generic object
+ key = {};
+ for (var k in origKey) {
+ if (origKey.hasOwnProperty(k)) {
+ var val = origKey[k];
+ if (typeof val !== 'undefined') {
+ key[k] = exports.normalizeKey(val);
+ }
+ }
+ }
+ }
+ }
+ return key;
+};
+
+function indexify(key) {
+ if (key !== null) {
+ switch (typeof key) {
+ case 'boolean':
+ return key ? 1 : 0;
+ case 'number':
+ return numToIndexableString(key);
+ case 'string':
+ // We've to be sure that key does not contain \u0000
+ // Do order-preserving replacements:
+ // 0 -> 1, 1
+ // 1 -> 1, 2
+ // 2 -> 2, 2
+ return key
+ .replace(/\u0002/g, '\u0002\u0002')
+ .replace(/\u0001/g, '\u0001\u0002')
+ .replace(/\u0000/g, '\u0001\u0001');
+ case 'object':
+ var isArray = Array.isArray(key);
+ var arr = isArray ? key : Object.keys(key);
+ var i = -1;
+ var len = arr.length;
+ var result = '';
+ if (isArray) {
+ while (++i < len) {
+ result += exports.toIndexableString(arr[i]);
+ }
+ } else {
+ while (++i < len) {
+ var objKey = arr[i];
+ result += exports.toIndexableString(objKey) +
+ exports.toIndexableString(key[objKey]);
+ }
+ }
+ return result;
+ }
+ }
+ return '';
+}
+
+// convert the given key to a string that would be appropriate
+// for lexical sorting, e.g. within a database, where the
+// sorting is the same given by the collate() function.
+exports.toIndexableString = function (key) {
+ var zero = '\u0000';
+ key = exports.normalizeKey(key);
+ return collationIndex(key) + SEP + indexify(key) + zero;
+};
+
+function arrayCollate(a, b) {
+ var len = Math.min(a.length, b.length);
+ for (var i = 0; i < len; i++) {
+ var sort = exports.collate(a[i], b[i]);
+ if (sort !== 0) {
+ return sort;
+ }
+ }
+ return (a.length === b.length) ? 0 :
+ (a.length > b.length) ? 1 : -1;
+}
+function stringCollate(a, b) {
+ // See: https://github.com/daleharvey/pouchdb/issues/40
+ // This is incompatible with the CouchDB implementation, but its the
+ // best we can do for now
+ return (a === b) ? 0 : ((a > b) ? 1 : -1);
+}
+function objectCollate(a, b) {
+ var ak = Object.keys(a), bk = Object.keys(b);
+ var len = Math.min(ak.length, bk.length);
+ for (var i = 0; i < len; i++) {
+ // First sort the keys
+ var sort = exports.collate(ak[i], bk[i]);
+ if (sort !== 0) {
+ return sort;
+ }
+ // if the keys are equal sort the values
+ sort = exports.collate(a[ak[i]], b[bk[i]]);
+ if (sort !== 0) {
+ return sort;
+ }
+
+ }
+ return (ak.length === bk.length) ? 0 :
+ (ak.length > bk.length) ? 1 : -1;
+}
+// The collation is defined by erlangs ordered terms
+// the atoms null, true, false come first, then numbers, strings,
+// arrays, then objects
+// null/undefined/NaN/Infinity/-Infinity are all considered null
+function collationIndex(x) {
+ var id = ['boolean', 'number', 'string', 'object'];
+ var idx = id.indexOf(typeof x);
+ //false if -1 otherwise true, but fast!!!!1
+ if (~idx) {
+ if (x === null) {
+ return 1;
+ }
+ if (Array.isArray(x)) {
+ return 5;
+ }
+ return idx < 3 ? (idx + 2) : (idx + 3);
+ }
+ if (Array.isArray(x)) {
+ return 5;
+ }
+}
+
+// conversion:
+// x yyy zz...zz
+// x = 0 for negative, 1 for 0, 2 for positive
+// y = exponent (for negative numbers negated) moved so that it's >= 0
+// z = mantisse
+function numToIndexableString(num) {
+
+ if (num === 0) {
+ return '1';
+ }
+
+ // convert number to exponential format for easier and
+ // more succinct string sorting
+ var expFormat = num.toExponential().split(/e\+?/);
+ var magnitude = parseInt(expFormat[1], 10);
+
+ var neg = num < 0;
+
+ var result = neg ? '0' : '2';
+
+ // first sort by magnitude
+ // it's easier if all magnitudes are positive
+ var magForComparison = ((neg ? -magnitude : magnitude) - MIN_MAGNITUDE);
+ var magString = utils.padLeft((magForComparison).toString(), '0', MAGNITUDE_DIGITS);
+
+ result += SEP + magString;
+
+ // then sort by the factor
+ var factor = Math.abs(parseFloat(expFormat[0])); // [1..10)
+ if (neg) { // for negative reverse ordering
+ factor = 10 - factor;
+ }
+
+ var factorStr = factor.toFixed(20);
+
+ // strip zeros from the end
+ factorStr = factorStr.replace(/\.?0+$/, '');
+
+ result += SEP + factorStr;
+
+ return result;
+}
+
+},{"./utils":52}],52:[function(_dereq_,module,exports){
+'use strict';
+
+function pad(str, padWith, upToLength) {
+ var padding = '';
+ var targetLength = upToLength - str.length;
+ while (padding.length < targetLength) {
+ padding += padWith;
+ }
+ return padding;
+}
+
+exports.padLeft = function (str, padWith, upToLength) {
+ var padding = pad(str, padWith, upToLength);
+ return padding + str;
+};
+
+exports.padRight = function (str, padWith, upToLength) {
+ var padding = pad(str, padWith, upToLength);
+ return str + padding;
+};
+
+exports.stringLexCompare = function (a, b) {
+
+ var aLen = a.length;
+ var bLen = b.length;
+
+ var i;
+ for (i = 0; i < aLen; i++) {
+ if (i === bLen) {
+ // b is shorter substring of a
+ return 1;
+ }
+ var aChar = a.charAt(i);
+ var bChar = b.charAt(i);
+ if (aChar !== bChar) {
+ return aChar < bChar ? -1 : 1;
+ }
+ }
+
+ if (aLen < bLen) {
+ // a is shorter substring of b
+ return -1;
+ }
+
+ return 0;
+};
+
+/*
+ * returns the decimal form for the given integer, i.e. writes
+ * out all the digits (in base-10) instead of using scientific notation
+ */
+exports.intToDecimalForm = function (int) {
+
+ var isNeg = int < 0;
+ var result = '';
+
+ do {
+ var remainder = isNeg ? -Math.ceil(int % 10) : Math.floor(int % 10);
+
+ result = remainder + result;
+ int = isNeg ? Math.ceil(int / 10) : Math.floor(int / 10);
+ } while (int);
+
+
+ if (isNeg && result !== '0') {
+ result = '-' + result;
+ }
+
+ return result;
+};
+},{}],53:[function(_dereq_,module,exports){
+'use strict';
+/*
+ * Simple task queue to sequentialize actions. Assumes callbacks will eventually fire (once).
+ */
+
+var Promise = _dereq_('./utils').Promise;
+
+function TaskQueue() {
+ this.promise = new Promise(function (fulfill) {fulfill(); });
+}
+TaskQueue.prototype.add = function (promiseFactory) {
+ this.promise = this.promise["catch"](function () {
+ // just recover
+ }).then(function () {
+ return promiseFactory();
+ });
+ return this.promise;
+};
+TaskQueue.prototype.finish = function () {
+ return this.promise;
+};
+
+module.exports = TaskQueue;
+
+},{"./utils":55}],54:[function(_dereq_,module,exports){
+'use strict';
+var Promise = _dereq_('./utils').Promise;
+
+// this is essentially the "update sugar" function from daleharvey/pouchdb#1388
+// the diffFun tells us what delta to apply to the doc. it either returns
+// the doc, or false if it doesn't need to do an update after all
+function upsert(db, docId, diffFun) {
+ return new Promise(function (fulfill, reject) {
+ if (docId && typeof docId === 'object') {
+ docId = docId._id;
+ }
+ if (typeof docId !== 'string') {
+ return reject(new Error('doc id is required'));
+ }
+
+ db.get(docId, function (err, doc) {
+ if (err) {
+ if (err.name !== 'not_found') {
+ return reject(err);
+ }
+ return fulfill(tryAndPut(db, diffFun({_id : docId}), diffFun));
+ }
+ var newDoc = diffFun(doc);
+ if (!newDoc) {
+ return fulfill(doc);
+ }
+ fulfill(tryAndPut(db, newDoc, diffFun));
+ });
+ });
+}
+
+function tryAndPut(db, doc, diffFun) {
+ return db.put(doc)["catch"](function (err) {
+ if (err.name !== 'conflict') {
+ throw err;
+ }
+ return upsert(db, doc, diffFun);
+ });
+}
+
+module.exports = upsert;
+
+},{"./utils":55}],55:[function(_dereq_,module,exports){
+(function (process,global){
+'use strict';
+/* istanbul ignore if */
+if (typeof global.Promise === 'function') {
+ exports.Promise = global.Promise;
+} else {
+ exports.Promise = _dereq_('lie');
+}
+// uniquify a list, similar to underscore's _.uniq
+exports.uniq = function (arr) {
+ var map = {};
+ arr.forEach(function (element) {
+ map[element] = true;
+ });
+ return Object.keys(map);
+};
+
+exports.inherits = _dereq_('inherits');
+exports.extend = _dereq_('pouchdb-extend');
+var argsarray = _dereq_('argsarray');
+
+exports.promisedCallback = function (promise, callback) {
+ if (callback) {
+ promise.then(function (res) {
+ process.nextTick(function () {
+ callback(null, res);
+ });
+ }, function (reason) {
+ process.nextTick(function () {
+ callback(reason);
+ });
+ });
+ }
+ return promise;
+};
+
+exports.callbackify = function (fun) {
+ return argsarray(function (args) {
+ var cb = args.pop();
+ var promise = fun.apply(this, args);
+ if (typeof cb === 'function') {
+ exports.promisedCallback(promise, cb);
+ }
+ return promise;
+ });
+};
+
+// Promise finally util similar to Q.finally
+exports.fin = function (promise, cb) {
+ return promise.then(function (res) {
+ var promise2 = cb();
+ if (typeof promise2.then === 'function') {
+ return promise2.then(function () {
+ return res;
+ });
+ }
+ return res;
+ }, function (reason) {
+ var promise2 = cb();
+ if (typeof promise2.then === 'function') {
+ return promise2.then(function () {
+ throw reason;
+ });
+ }
+ throw reason;
+ });
+};
+
+exports.sequentialize = function (queue, promiseFactory) {
+ return function () {
+ var args = arguments;
+ var that = this;
+ return queue.add(function () {
+ return promiseFactory.apply(that, args);
+ });
+ };
+};
+
+var crypto = _dereq_('crypto');
+var Md5 = _dereq_('spark-md5');
+
+exports.MD5 = function (string) {
+ /* istanbul ignore else */
+ if (!process.browser) {
+ return crypto.createHash('md5').update(string).digest('hex');
+ } else {
+ return Md5.hash(string);
+ }
+};
+}).call(this,_dereq_("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":28,"argsarray":25,"crypto":26,"inherits":29,"lie":33,"pouchdb-extend":47,"spark-md5":56}],56:[function(_dereq_,module,exports){
+/*jshint bitwise:false*/
+/*global unescape*/
+
+(function (factory) {
+ if (typeof exports === 'object') {
+ // Node/CommonJS
+ module.exports = factory();
+ } else if (typeof define === 'function' && define.amd) {
+ // AMD
+ define(factory);
+ } else {
+ // Browser globals (with support for web workers)
+ var glob;
+ try {
+ glob = window;
+ } catch (e) {
+ glob = self;
+ }
+
+ glob.SparkMD5 = factory();
+ }
+}(function (undefined) {
+
+ 'use strict';
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ /*
+ * Fastest md5 implementation around (JKM md5)
+ * Credits: Joseph Myers
+ *
+ * @see http://www.myersdaily.org/joseph/javascript/md5-text.html
+ * @see http://jsperf.com/md5-shootout/7
+ */
+
+ /* this function is much faster,
+ so if possible we use it. Some IEs
+ are the only ones I know of that
+ need the idiotic second function,
+ generated by an if clause. */
+ var add32 = function (a, b) {
+ return (a + b) & 0xFFFFFFFF;
+ },
+
+ cmn = function (q, a, b, x, s, t) {
+ a = add32(add32(a, q), add32(x, t));
+ return add32((a << s) | (a >>> (32 - s)), b);
+ },
+
+ ff = function (a, b, c, d, x, s, t) {
+ return cmn((b & c) | ((~b) & d), a, b, x, s, t);
+ },
+
+ gg = function (a, b, c, d, x, s, t) {
+ return cmn((b & d) | (c & (~d)), a, b, x, s, t);
+ },
+
+ hh = function (a, b, c, d, x, s, t) {
+ return cmn(b ^ c ^ d, a, b, x, s, t);
+ },
+
+ ii = function (a, b, c, d, x, s, t) {
+ return cmn(c ^ (b | (~d)), a, b, x, s, t);
+ },
+
+ md5cycle = function (x, k) {
+ var a = x[0],
+ b = x[1],
+ c = x[2],
+ d = x[3];
+
+ a = ff(a, b, c, d, k[0], 7, -680876936);
+ d = ff(d, a, b, c, k[1], 12, -389564586);
+ c = ff(c, d, a, b, k[2], 17, 606105819);
+ b = ff(b, c, d, a, k[3], 22, -1044525330);
+ a = ff(a, b, c, d, k[4], 7, -176418897);
+ d = ff(d, a, b, c, k[5], 12, 1200080426);
+ c = ff(c, d, a, b, k[6], 17, -1473231341);
+ b = ff(b, c, d, a, k[7], 22, -45705983);
+ a = ff(a, b, c, d, k[8], 7, 1770035416);
+ d = ff(d, a, b, c, k[9], 12, -1958414417);
+ c = ff(c, d, a, b, k[10], 17, -42063);
+ b = ff(b, c, d, a, k[11], 22, -1990404162);
+ a = ff(a, b, c, d, k[12], 7, 1804603682);
+ d = ff(d, a, b, c, k[13], 12, -40341101);
+ c = ff(c, d, a, b, k[14], 17, -1502002290);
+ b = ff(b, c, d, a, k[15], 22, 1236535329);
+
+ a = gg(a, b, c, d, k[1], 5, -165796510);
+ d = gg(d, a, b, c, k[6], 9, -1069501632);
+ c = gg(c, d, a, b, k[11], 14, 643717713);
+ b = gg(b, c, d, a, k[0], 20, -373897302);
+ a = gg(a, b, c, d, k[5], 5, -701558691);
+ d = gg(d, a, b, c, k[10], 9, 38016083);
+ c = gg(c, d, a, b, k[15], 14, -660478335);
+ b = gg(b, c, d, a, k[4], 20, -405537848);
+ a = gg(a, b, c, d, k[9], 5, 568446438);
+ d = gg(d, a, b, c, k[14], 9, -1019803690);
+ c = gg(c, d, a, b, k[3], 14, -187363961);
+ b = gg(b, c, d, a, k[8], 20, 1163531501);
+ a = gg(a, b, c, d, k[13], 5, -1444681467);
+ d = gg(d, a, b, c, k[2], 9, -51403784);
+ c = gg(c, d, a, b, k[7], 14, 1735328473);
+ b = gg(b, c, d, a, k[12], 20, -1926607734);
+
+ a = hh(a, b, c, d, k[5], 4, -378558);
+ d = hh(d, a, b, c, k[8], 11, -2022574463);
+ c = hh(c, d, a, b, k[11], 16, 1839030562);
+ b = hh(b, c, d, a, k[14], 23, -35309556);
+ a = hh(a, b, c, d, k[1], 4, -1530992060);
+ d = hh(d, a, b, c, k[4], 11, 1272893353);
+ c = hh(c, d, a, b, k[7], 16, -155497632);
+ b = hh(b, c, d, a, k[10], 23, -1094730640);
+ a = hh(a, b, c, d, k[13], 4, 681279174);
+ d = hh(d, a, b, c, k[0], 11, -358537222);
+ c = hh(c, d, a, b, k[3], 16, -722521979);
+ b = hh(b, c, d, a, k[6], 23, 76029189);
+ a = hh(a, b, c, d, k[9], 4, -640364487);
+ d = hh(d, a, b, c, k[12], 11, -421815835);
+ c = hh(c, d, a, b, k[15], 16, 530742520);
+ b = hh(b, c, d, a, k[2], 23, -995338651);
+
+ a = ii(a, b, c, d, k[0], 6, -198630844);
+ d = ii(d, a, b, c, k[7], 10, 1126891415);
+ c = ii(c, d, a, b, k[14], 15, -1416354905);
+ b = ii(b, c, d, a, k[5], 21, -57434055);
+ a = ii(a, b, c, d, k[12], 6, 1700485571);
+ d = ii(d, a, b, c, k[3], 10, -1894986606);
+ c = ii(c, d, a, b, k[10], 15, -1051523);
+ b = ii(b, c, d, a, k[1], 21, -2054922799);
+ a = ii(a, b, c, d, k[8], 6, 1873313359);
+ d = ii(d, a, b, c, k[15], 10, -30611744);
+ c = ii(c, d, a, b, k[6], 15, -1560198380);
+ b = ii(b, c, d, a, k[13], 21, 1309151649);
+ a = ii(a, b, c, d, k[4], 6, -145523070);
+ d = ii(d, a, b, c, k[11], 10, -1120210379);
+ c = ii(c, d, a, b, k[2], 15, 718787259);
+ b = ii(b, c, d, a, k[9], 21, -343485551);
+
+ x[0] = add32(a, x[0]);
+ x[1] = add32(b, x[1]);
+ x[2] = add32(c, x[2]);
+ x[3] = add32(d, x[3]);
+ },
+
+ /* there needs to be support for Unicode here,
+ * unless we pretend that we can redefine the MD-5
+ * algorithm for multi-byte characters (perhaps
+ * by adding every four 16-bit characters and
+ * shortening the sum to 32 bits). Otherwise
+ * I suggest performing MD-5 as if every character
+ * was two bytes--e.g., 0040 0025 = @%--but then
+ * how will an ordinary MD-5 sum be matched?
+ * There is no way to standardize text to something
+ * like UTF-8 before transformation; speed cost is
+ * utterly prohibitive. The JavaScript standard
+ * itself needs to look at this: it should start
+ * providing access to strings as preformed UTF-8
+ * 8-bit unsigned value arrays.
+ */
+ md5blk = function (s) {
+ var md5blks = [],
+ i; /* Andy King said do it this way. */
+
+ for (i = 0; i < 64; i += 4) {
+ md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
+ }
+ return md5blks;
+ },
+
+ md5blk_array = function (a) {
+ var md5blks = [],
+ i; /* Andy King said do it this way. */
+
+ for (i = 0; i < 64; i += 4) {
+ md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
+ }
+ return md5blks;
+ },
+
+ md51 = function (s) {
+ var n = s.length,
+ state = [1732584193, -271733879, -1732584194, 271733878],
+ i,
+ length,
+ tail,
+ tmp,
+ lo,
+ hi;
+
+ for (i = 64; i <= n; i += 64) {
+ md5cycle(state, md5blk(s.substring(i - 64, i)));
+ }
+ s = s.substring(i - 64);
+ length = s.length;
+ tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+ for (i = 0; i < length; i += 1) {
+ tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
+ }
+ tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+ if (i > 55) {
+ md5cycle(state, tail);
+ for (i = 0; i < 16; i += 1) {
+ tail[i] = 0;
+ }
+ }
+
+ // Beware that the final length might not fit in 32 bits so we take care of that
+ tmp = n * 8;
+ tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+ lo = parseInt(tmp[2], 16);
+ hi = parseInt(tmp[1], 16) || 0;
+
+ tail[14] = lo;
+ tail[15] = hi;
+
+ md5cycle(state, tail);
+ return state;
+ },
+
+ md51_array = function (a) {
+ var n = a.length,
+ state = [1732584193, -271733879, -1732584194, 271733878],
+ i,
+ length,
+ tail,
+ tmp,
+ lo,
+ hi;
+
+ for (i = 64; i <= n; i += 64) {
+ md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
+ }
+
+ // Not sure if it is a bug, however IE10 will always produce a sub array of length 1
+ // containing the last element of the parent array if the sub array specified starts
+ // beyond the length of the parent array - weird.
+ // https://connect.microsoft.com/IE/feedback/details/771452/typed-array-subarray-issue
+ a = (i - 64) < n ? a.subarray(i - 64) : new Uint8Array(0);
+
+ length = a.length;
+ tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+ for (i = 0; i < length; i += 1) {
+ tail[i >> 2] |= a[i] << ((i % 4) << 3);
+ }
+
+ tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+ if (i > 55) {
+ md5cycle(state, tail);
+ for (i = 0; i < 16; i += 1) {
+ tail[i] = 0;
+ }
+ }
+
+ // Beware that the final length might not fit in 32 bits so we take care of that
+ tmp = n * 8;
+ tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+ lo = parseInt(tmp[2], 16);
+ hi = parseInt(tmp[1], 16) || 0;
+
+ tail[14] = lo;
+ tail[15] = hi;
+
+ md5cycle(state, tail);
+
+ return state;
+ },
+
+ hex_chr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'],
+
+ rhex = function (n) {
+ var s = '',
+ j;
+ for (j = 0; j < 4; j += 1) {
+ s += hex_chr[(n >> (j * 8 + 4)) & 0x0F] + hex_chr[(n >> (j * 8)) & 0x0F];
+ }
+ return s;
+ },
+
+ hex = function (x) {
+ var i;
+ for (i = 0; i < x.length; i += 1) {
+ x[i] = rhex(x[i]);
+ }
+ return x.join('');
+ },
+
+ md5 = function (s) {
+ return hex(md51(s));
+ },
+
+
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ /**
+ * SparkMD5 OOP implementation.
+ *
+ * Use this class to perform an incremental md5, otherwise use the
+ * static methods instead.
+ */
+ SparkMD5 = function () {
+ // call reset to init the instance
+ this.reset();
+ };
+
+
+ // In some cases the fast add32 function cannot be used..
+ if (md5('hello') !== '5d41402abc4b2a76b9719d911017c592') {
+ add32 = function (x, y) {
+ var lsw = (x & 0xFFFF) + (y & 0xFFFF),
+ msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+ return (msw << 16) | (lsw & 0xFFFF);
+ };
+ }
+
+
+ /**
+ * Appends a string.
+ * A conversion will be applied if an utf8 string is detected.
+ *
+ * @param {String} str The string to be appended
+ *
+ * @return {SparkMD5} The instance itself
+ */
+ SparkMD5.prototype.append = function (str) {
+ // converts the string to utf8 bytes if necessary
+ if (/[\u0080-\uFFFF]/.test(str)) {
+ str = unescape(encodeURIComponent(str));
+ }
+
+ // then append as binary
+ this.appendBinary(str);
+
+ return this;
+ };
+
+ /**
+ * Appends a binary string.
+ *
+ * @param {String} contents The binary string to be appended
+ *
+ * @return {SparkMD5} The instance itself
+ */
+ SparkMD5.prototype.appendBinary = function (contents) {
+ this._buff += contents;
+ this._length += contents.length;
+
+ var length = this._buff.length,
+ i;
+
+ for (i = 64; i <= length; i += 64) {
+ md5cycle(this._state, md5blk(this._buff.substring(i - 64, i)));
+ }
+
+ this._buff = this._buff.substr(i - 64);
+
+ return this;
+ };
+
+ /**
+ * Finishes the incremental computation, reseting the internal state and
+ * returning the result.
+ * Use the raw parameter to obtain the raw result instead of the hex one.
+ *
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.prototype.end = function (raw) {
+ var buff = this._buff,
+ length = buff.length,
+ i,
+ tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ ret;
+
+ for (i = 0; i < length; i += 1) {
+ tail[i >> 2] |= buff.charCodeAt(i) << ((i % 4) << 3);
+ }
+
+ this._finish(tail, length);
+ ret = !!raw ? this._state : hex(this._state);
+
+ this.reset();
+
+ return ret;
+ };
+
+ /**
+ * Finish the final calculation based on the tail.
+ *
+ * @param {Array} tail The tail (will be modified)
+ * @param {Number} length The length of the remaining buffer
+ */
+ SparkMD5.prototype._finish = function (tail, length) {
+ var i = length,
+ tmp,
+ lo,
+ hi;
+
+ tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+ if (i > 55) {
+ md5cycle(this._state, tail);
+ for (i = 0; i < 16; i += 1) {
+ tail[i] = 0;
+ }
+ }
+
+ // Do the final computation based on the tail and length
+ // Beware that the final length may not fit in 32 bits so we take care of that
+ tmp = this._length * 8;
+ tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+ lo = parseInt(tmp[2], 16);
+ hi = parseInt(tmp[1], 16) || 0;
+
+ tail[14] = lo;
+ tail[15] = hi;
+ md5cycle(this._state, tail);
+ };
+
+ /**
+ * Resets the internal state of the computation.
+ *
+ * @return {SparkMD5} The instance itself
+ */
+ SparkMD5.prototype.reset = function () {
+ this._buff = "";
+ this._length = 0;
+ this._state = [1732584193, -271733879, -1732584194, 271733878];
+
+ return this;
+ };
+
+ /**
+ * Releases memory used by the incremental buffer and other aditional
+ * resources. If you plan to use the instance again, use reset instead.
+ */
+ SparkMD5.prototype.destroy = function () {
+ delete this._state;
+ delete this._buff;
+ delete this._length;
+ };
+
+
+ /**
+ * Performs the md5 hash on a string.
+ * A conversion will be applied if utf8 string is detected.
+ *
+ * @param {String} str The string
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.hash = function (str, raw) {
+ // converts the string to utf8 bytes if necessary
+ if (/[\u0080-\uFFFF]/.test(str)) {
+ str = unescape(encodeURIComponent(str));
+ }
+
+ var hash = md51(str);
+
+ return !!raw ? hash : hex(hash);
+ };
+
+ /**
+ * Performs the md5 hash on a binary string.
+ *
+ * @param {String} content The binary string
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.hashBinary = function (content, raw) {
+ var hash = md51(content);
+
+ return !!raw ? hash : hex(hash);
+ };
+
+ /**
+ * SparkMD5 OOP implementation for array buffers.
+ *
+ * Use this class to perform an incremental md5 ONLY for array buffers.
+ */
+ SparkMD5.ArrayBuffer = function () {
+ // call reset to init the instance
+ this.reset();
+ };
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ /**
+ * Appends an array buffer.
+ *
+ * @param {ArrayBuffer} arr The array to be appended
+ *
+ * @return {SparkMD5.ArrayBuffer} The instance itself
+ */
+ SparkMD5.ArrayBuffer.prototype.append = function (arr) {
+ // TODO: we could avoid the concatenation here but the algorithm would be more complex
+ // if you find yourself needing extra performance, please make a PR.
+ var buff = this._concatArrayBuffer(this._buff, arr),
+ length = buff.length,
+ i;
+
+ this._length += arr.byteLength;
+
+ for (i = 64; i <= length; i += 64) {
+ md5cycle(this._state, md5blk_array(buff.subarray(i - 64, i)));
+ }
+
+ // Avoids IE10 weirdness (documented above)
+ this._buff = (i - 64) < length ? buff.subarray(i - 64) : new Uint8Array(0);
+
+ return this;
+ };
+
+ /**
+ * Finishes the incremental computation, reseting the internal state and
+ * returning the result.
+ * Use the raw parameter to obtain the raw result instead of the hex one.
+ *
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.ArrayBuffer.prototype.end = function (raw) {
+ var buff = this._buff,
+ length = buff.length,
+ tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ i,
+ ret;
+
+ for (i = 0; i < length; i += 1) {
+ tail[i >> 2] |= buff[i] << ((i % 4) << 3);
+ }
+
+ this._finish(tail, length);
+ ret = !!raw ? this._state : hex(this._state);
+
+ this.reset();
+
+ return ret;
+ };
+
+ SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;
+
+ /**
+ * Resets the internal state of the computation.
+ *
+ * @return {SparkMD5.ArrayBuffer} The instance itself
+ */
+ SparkMD5.ArrayBuffer.prototype.reset = function () {
+ this._buff = new Uint8Array(0);
+ this._length = 0;
+ this._state = [1732584193, -271733879, -1732584194, 271733878];
+
+ return this;
+ };
+
+ /**
+ * Releases memory used by the incremental buffer and other aditional
+ * resources. If you plan to use the instance again, use reset instead.
+ */
+ SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;
+
+ /**
+ * Concats two array buffers, returning a new one.
+ *
+ * @param {ArrayBuffer} first The first array buffer
+ * @param {ArrayBuffer} second The second array buffer
+ *
+ * @return {ArrayBuffer} The new array buffer
+ */
+ SparkMD5.ArrayBuffer.prototype._concatArrayBuffer = function (first, second) {
+ var firstLength = first.length,
+ result = new Uint8Array(firstLength + second.byteLength);
+
+ result.set(first);
+ result.set(new Uint8Array(second), firstLength);
+
+ return result;
+ };
+
+ /**
+ * Performs the md5 hash on an array buffer.
+ *
+ * @param {ArrayBuffer} arr The array buffer
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.ArrayBuffer.hash = function (arr, raw) {
+ var hash = md51_array(new Uint8Array(arr));
+
+ return !!raw ? hash : hex(hash);
+ };
+
+ return SparkMD5;
+}));
+
+},{}]},{},[17])
+(17)
+});
\ No newline at end of file
diff --git a/dist/pouchdb.localstorage.js b/dist/pouchdb.localstorage.js
new file mode 100644
index 0000000..5a0ac70
--- /dev/null
+++ b/dist/pouchdb.localstorage.js
@@ -0,0 +1,14748 @@
+// PouchDB localStorage plugin 3.0.1
+// Based on localstorage-down: https://github.com/No9/localstorage-down
+//
+// (c) 2012-2014 Dale Harvey and the PouchDB team
+// PouchDB may be freely distributed under the Apache license, version 2.0.
+// For all details and documentation:
+// http://pouchdb.com
+require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+(function (process,global,Buffer){
+'use strict';
+
+var levelup = require('levelup');
+var originalLeveldown = require('leveldown');
+var sublevel = require('level-sublevel');
+var through = require('through2').obj;
+
+var errors = require('../deps/errors');
+var merge = require('../merge');
+var utils = require('../utils');
+var migrate = require('../deps/migrate');
+
+var DOC_STORE = 'document-store';
+var BY_SEQ_STORE = 'by-sequence';
+var ATTACHMENT_STORE = 'attach-store';
+var BINARY_STORE = 'attach-binary-store';
+var LOCAL_STORE = 'local-store';
+var META_STORE = 'meta-store';
+var BATCH_SIZE = 50;
+
+// leveldb barks if we try to open a db multiple times
+// so we cache opened connections here for initstore()
+var dbStores = new utils.Map();
+
+// store the value of update_seq in the by-sequence store the key name will
+// never conflict, since the keys in the by-sequence store are integers
+var UPDATE_SEQ_KEY = '_local_last_update_seq';
+var DOC_COUNT_KEY = '_local_doc_count';
+var UUID_KEY = '_local_uuid';
+
+function LevelPouch(opts, callback) {
+ opts = utils.clone(opts);
+ var api = this;
+ var instanceId;
+ var stores = {};
+ var db;
+ var name = opts.name;
+ if (typeof opts.createIfMissing === 'undefined') {
+ opts.createIfMissing = true;
+ }
+
+ var leveldown = opts.db || originalLeveldown;
+ if (typeof leveldown.destroy !== 'function') {
+ leveldown.destroy = function (name, cb) { cb(); };
+ }
+ var dbStore;
+ if (dbStores.has(leveldown.name)) {
+ dbStore = dbStores.get(leveldown.name);
+ } else {
+ dbStore = new utils.Map();
+ dbStores.set(leveldown.name, dbStore);
+ }
+ if (dbStore.has(name)) {
+ db = dbStore.get(name);
+ afterDBCreated();
+ } else {
+ dbStore.set(name, sublevel(levelup(name, opts, function (err) {
+ if (err) {
+ dbStore["delete"](name);
+ return callback(err);
+ }
+ db = dbStore.get(name);
+ db._locks = db._locks || new utils.Set();
+ db._docCountQueue = {
+ queue : [],
+ running : false,
+ docCount : -1
+ };
+ if (opts.db || opts.noMigrate) {
+ afterDBCreated();
+ } else {
+ migrate.toSublevel(name, db, afterDBCreated);
+ }
+ })));
+ }
+
+ function afterDBCreated() {
+ stores.docStore = db.sublevel(DOC_STORE, {valueEncoding: 'json'});
+ stores.bySeqStore = db.sublevel(BY_SEQ_STORE, {valueEncoding: 'json'});
+ stores.attachmentStore =
+ db.sublevel(ATTACHMENT_STORE, {valueEncoding: 'json'});
+ stores.binaryStore = db.sublevel(BINARY_STORE, {valueEncoding: 'binary'});
+ stores.localStore = db.sublevel(LOCAL_STORE, {valueEncoding: 'json'});
+ stores.metaStore = db.sublevel(META_STORE, {valueEncoding: 'json'});
+ migrate.localAndMetaStores(db, stores, function () {
+ stores.metaStore.get(UPDATE_SEQ_KEY, function (err, value) {
+ if (typeof db._updateSeq === 'undefined') {
+ db._updateSeq = value || 0;
+ }
+ stores.metaStore.get(DOC_COUNT_KEY, function (err, value) {
+ db._docCountQueue.docCount = !err ? value : 0;
+ countDocs(function (err) { // notify queue that the docCount is ready
+ if (err) {
+ api.emit('error', err);
+ }
+ stores.metaStore.get(UUID_KEY, function (err, value) {
+ instanceId = !err ? value : utils.uuid();
+ stores.metaStore.put(UUID_KEY, instanceId, function (err, value) {
+ process.nextTick(function () {
+ callback(null, api);
+ });
+ });
+ });
+ });
+ });
+ });
+ });
+ }
+
+ function countDocs(callback) {
+ if (db._docCountQueue.running || !db._docCountQueue.queue.length ||
+ db._docCountQueue.docCount === -1) {
+ return incrementDocCount(0, callback); // wait for fresh data
+ }
+ return db._docCountQueue.docCount; // use cached value
+ }
+
+ function applyNextDocCountDelta() {
+ if (db._docCountQueue.running || !db._docCountQueue.queue.length ||
+ db._docCountQueue.docCount === -1) {
+ return;
+ }
+ db._docCountQueue.running = true;
+ var item = db._docCountQueue.queue.shift();
+ if (db.isClosed()) {
+ return item.callback(new Error('database is closed'));
+ }
+ stores.metaStore.get(DOC_COUNT_KEY, function (err, docCount) {
+ docCount = !err ? docCount : 0;
+
+ function complete(err) {
+ db._docCountQueue.docCount = docCount;
+ item.callback(err, docCount);
+ db._docCountQueue.running = false;
+ applyNextDocCountDelta();
+ }
+
+ if (item.delta === 0) {
+ complete();
+ } else {
+ stores.metaStore.put(DOC_COUNT_KEY, docCount + item.delta, complete);
+ }
+ });
+ }
+
+ function incrementDocCount(delta, callback) {
+ db._docCountQueue.queue.push({delta : delta, callback : callback});
+ applyNextDocCountDelta();
+ }
+
+ api.type = function () {
+ return 'leveldb';
+ };
+
+ api._id = function (callback) {
+ callback(null, instanceId);
+ };
+
+ api._info = function (callback) {
+ countDocs(function (err, docCount) {
+ if (err) {
+ return callback(err);
+ }
+ stores.metaStore.get(UPDATE_SEQ_KEY, function (err, otherUpdateSeq) {
+ if (err) {
+ otherUpdateSeq = db._updateSeq;
+ }
+
+ return callback(null, {
+ doc_count: docCount,
+ update_seq: otherUpdateSeq
+ });
+ });
+ });
+ };
+
+ function formatSeq(n) {
+ return ('0000000000000000' + n).slice(-16);
+ }
+
+ function parseSeq(s) {
+ return parseInt(s, 10);
+ }
+
+ function makeDoc(rawDoc, callback) {
+ var doc = rawDoc.data;
+ doc._id = rawDoc.metadata.id;
+ if ('_rev' in doc) {
+ if (doc._rev !== rawDoc.metadata.rev) {
+ return callback(new Error('wrong doc returned'));
+ }
+ } else {
+ // we didn't always store rev
+ doc._rev = rawDoc.metadata.rev;
+ }
+ callback(null, {doc: doc, metadata: rawDoc.metadata});
+ }
+
+ api._get = function (id, opts, callback) {
+ opts = utils.clone(opts);
+ var docChanged = [];
+
+ function didDocChange(doc) {
+ docChanged.push(doc);
+ }
+
+ db.on('pouchdb-id-' + id, didDocChange);
+
+ stores.docStore.get(id, function (err, metadata) {
+ db.removeListener('pouchdb-id-' + id, didDocChange);
+
+ if (err || !metadata) {
+ return callback(errors.MISSING_DOC);
+ }
+
+ if (utils.isDeleted(metadata) && !opts.rev) {
+ return callback(errors.error(errors.MISSING_DOC, "deleted"));
+ }
+
+ var updated;
+
+ function ifUpdate(doc) {
+ updated = doc;
+ }
+
+ var rev = merge.winningRev(metadata);
+ rev = opts.rev ? opts.rev : rev;
+
+ var seq = metadata.rev_map[rev];
+
+ var anyChanged = docChanged.filter(function (doc) {
+ return doc.metadata.seq === seq;
+ });
+
+ if (anyChanged.length) {
+ return makeDoc(anyChanged.pop(), callback);
+ }
+
+ db.on('pouchdb-' + seq, ifUpdate);
+
+ stores.bySeqStore.get(formatSeq(seq), function (err, doc) {
+ db.removeListener('pouchdb-' + seq, ifUpdate);
+ if (updated) {
+ return makeDoc(updated, callback);
+
+ }
+
+ if (!doc) {
+ return callback(errors.MISSING_DOC);
+ }
+ if ('_id' in doc && doc._id !== metadata.id) {
+ // this failing implies something very wrong
+ return callback(new Error('wrong doc returned'));
+ }
+ doc._id = metadata.id;
+ if ('_rev' in doc) {
+ if (doc._rev !== rev) {
+ // this failing implies something very wrong
+ return callback(new Error('wrong doc returned'));
+ }
+ } else {
+ // we didn't always store this
+ doc._rev = rev;
+ }
+ return callback(null, {doc: doc, metadata: metadata});
+ });
+ });
+ };
+
+ // not technically part of the spec, but if putAttachment has its own
+ // method...
+ api._getAttachment = function (attachment, opts, callback) {
+ var digest = attachment.digest;
+
+ stores.binaryStore.get(digest, function (err, attach) {
+ var data;
+
+ if (err && err.name === 'NotFoundError') {
+ // Empty attachment
+ data = opts.encode ? '' : process.browser ?
+ utils.createBlob([''], {type: attachment.content_type}) :
+ new Buffer('');
+ return callback(null, data);
+ }
+
+ if (err) {
+ return callback(err);
+ }
+
+ if (process.browser) {
+ if (opts.encode) {
+ data = utils.btoa(global.unescape(attach));
+ } else {
+ data = utils.createBlob([utils.fixBinary(global.unescape(attach))],
+ {type: attachment.content_type});
+ }
+ } else {
+ data = opts.encode ? utils.btoa(attach) : attach;
+ }
+ callback(null, data);
+ });
+ };
+ api.lock = function (id) {
+ if (db._locks.has(id)) {
+ return false;
+ } else {
+ db._locks.add(id);
+ return true;
+ }
+ };
+
+ api.unlock = function (id) {
+ if (db._locks.has(id)) {
+ db._locks["delete"](id);
+ return true;
+ }
+ return false;
+ };
+
+ api._bulkDocs = function (req, opts, callback) {
+ var newEdits = opts.new_edits;
+ var results = new Array(req.docs.length);
+
+ // parse the docs and give each a sequence number
+ var userDocs = req.docs;
+ var info = userDocs.map(function (doc, i) {
+ if (doc._id && utils.isLocalId(doc._id)) {
+ return doc;
+ }
+ var newDoc = utils.parseDoc(doc, newEdits);
+ newDoc._bulk_seq = i;
+
+ if (newDoc.metadata && !newDoc.metadata.rev_map) {
+ newDoc.metadata.rev_map = {};
+ }
+
+ return newDoc;
+ });
+ var current = 0;
+ var infoErrors = info.filter(function (doc) {
+ return doc.error;
+ });
+
+ if (infoErrors.length) {
+ return callback(infoErrors[0]);
+ }
+ var inProgress = 0;
+ function processDocs() {
+ var index = current;
+ if (inProgress > BATCH_SIZE) {
+ return;
+ }
+ if (index >= info.length) {
+ if (inProgress === 0) {
+ return complete();
+ } else {
+ return;
+ }
+ }
+ var currentDoc = info[index];
+ current++;
+ inProgress++;
+ if (currentDoc._id && utils.isLocalId(currentDoc._id)) {
+ api[currentDoc._deleted ? '_removeLocal' : '_putLocal'](
+ currentDoc, function (err, resp) {
+ if (err) {
+ results[index] = err;
+ } else {
+ results[index] = {};
+ }
+ inProgress--;
+ processDocs();
+ });
+ return;
+ }
+ stores.docStore.get(currentDoc.metadata.id, function (err, oldDoc) {
+ if (!api.lock(currentDoc.metadata.id)) {
+ results[index] = makeErr(errors.REV_CONFLICT,
+ 'someobody else is accessing this');
+ inProgress--;
+ return processDocs();
+ }
+ if (err) {
+ if (err.name === 'NotFoundError') {
+ insertDoc(currentDoc, index, function () {
+ api.unlock(currentDoc.metadata.id);
+ inProgress--;
+ processDocs();
+ });
+ } else {
+ err.error = true;
+ results[index] = err;
+ api.unlock(currentDoc.metadata.id);
+ inProgress--;
+ processDocs();
+ }
+ } else {
+ updateDoc(oldDoc, currentDoc, index, function () {
+ api.unlock(currentDoc.metadata.id);
+ inProgress--;
+ processDocs();
+ });
+ }
+ });
+ if (newEdits) {
+ processDocs();
+ }
+ }
+
+ function insertDoc(doc, index, callback) {
+ // Can't insert new deleted documents
+ if ('was_delete' in opts && utils.isDeleted(doc.metadata)) {
+ results[index] = makeErr(errors.MISSING_DOC, doc._bulk_seq);
+ return callback();
+ }
+ writeDoc(doc, index, function (err) {
+ if (err) {
+ return callback(err);
+ }
+ if (utils.isDeleted(doc.metadata)) {
+ return callback();
+ }
+ incrementDocCount(1, callback);
+ });
+ }
+
+ function updateDoc(oldDoc, docInfo, index, callback) {
+ var merged =
+ merge.merge(oldDoc.rev_tree, docInfo.metadata.rev_tree[0], 1000);
+
+ var conflict = (utils.isDeleted(oldDoc) &&
+ utils.isDeleted(docInfo.metadata) &&
+ newEdits) ||
+ (!utils.isDeleted(oldDoc) &&
+ newEdits && merged.conflicts !== 'new_leaf');
+
+
+ if (conflict) {
+ results[index] = makeErr(errors.REV_CONFLICT, docInfo._bulk_seq);
+ return callback();
+ }
+ docInfo.metadata.rev_tree = merged.tree;
+ docInfo.metadata.rev_map = oldDoc.rev_map;
+ var delta = 0;
+ var oldDeleted = utils.isDeleted(oldDoc);
+ var newDeleted = utils.isDeleted(docInfo.metadata);
+ delta = (oldDeleted === newDeleted) ? 0 :
+ oldDeleted < newDeleted ? -1 : 1;
+ incrementDocCount(delta, function (err) {
+ if (err) {
+ return callback(err);
+ }
+ writeDoc(docInfo, index, callback);
+ });
+
+ }
+
+ function writeDoc(doc, index, callback2) {
+ var err = null;
+ var recv = 0;
+
+ doc.data._id = doc.metadata.id;
+ doc.data._rev = doc.metadata.rev;
+
+ if (utils.isDeleted(doc.metadata)) {
+ doc.data._deleted = true;
+ }
+
+ var attachments = doc.data._attachments ?
+ Object.keys(doc.data._attachments) :
+ [];
+
+ function collectResults(attachmentErr) {
+ if (!err) {
+ if (attachmentErr) {
+ err = attachmentErr;
+ callback2(err);
+ } else if (recv === attachments.length) {
+ finish();
+ }
+ }
+ }
+
+ function attachmentSaved(err) {
+ recv++;
+ collectResults(err);
+ }
+
+ function onMD5Load(doc, prefix, key, data, attachmentSaved) {
+ return function (result) {
+ saveAttachment(doc, prefix + result, key, data, attachmentSaved);
+ };
+ }
+
+ function onLoadEnd(doc, prefix, key, attachmentSaved) {
+ return function (e) {
+ var data = global.escape(
+ utils.arrayBufferToBinaryString(e.target.result));
+ utils.MD5(data).then(
+ onMD5Load(doc, prefix, key, data, attachmentSaved)
+ );
+ };
+ }
+
+ for (var i = 0; i < attachments.length; i++) {
+ var key = attachments[i];
+
+ if (doc.data._attachments[key].stub) {
+ recv++;
+ collectResults();
+ continue;
+ }
+ var att = doc.data._attachments[key];
+ var data;
+ var prefix;
+ if (typeof att.data === 'string') {
+ try {
+ data = utils.atob(att.data);
+ if (process.browser) {
+ data = global.escape(data);
+ }
+ } catch (e) {
+ callback(utils.extend({}, errors.BAD_ARG,
+ {reason: "Attachments need to be base64 encoded"}));
+ return;
+ }
+ prefix = process.browser ? 'md5-' : '';
+ } else if (!process.browser) {
+ data = att.data;
+ prefix = '';
+ } else { // browser
+ var reader = new FileReader();
+ reader.onloadend = onLoadEnd(doc, 'md5-', key, attachmentSaved);
+ reader.readAsArrayBuffer(att.data);
+ return;
+ }
+ utils.MD5(data).then(
+ onMD5Load(doc, prefix, key, data, attachmentSaved)
+ );
+ }
+
+ function finish() {
+ var seq = doc.metadata.rev_map[doc.metadata.rev];
+ if (!seq) {
+ // check that there aren't any existing revisions with the same
+ // reivision id, else we shouldn't increment updateSeq
+ seq = ++db._updateSeq;
+ }
+ doc.metadata.rev_map[doc.metadata.rev] = doc.metadata.seq = seq;
+ var seqKey = formatSeq(seq);
+ db.emit('pouchdb-id-' + doc.metadata.id, doc);
+ db.emit('pouchdb-' + seqKey, doc);
+ db.batch([{
+ key: seqKey,
+ value: doc.data,
+ prefix: stores.bySeqStore,
+ type: 'put',
+ valueEncoding: 'json'
+ }, {
+ key: doc.metadata.id,
+ value: doc.metadata,
+ prefix: stores.docStore,
+ type: 'put',
+ valueEncoding: 'json'
+ }], function (err) {
+ if (!err) {
+ db.emit('pouchdb-id-' + doc.metadata.id, doc);
+ db.emit('pouchdb-' + seqKey, doc);
+ }
+ return stores.metaStore.put(UPDATE_SEQ_KEY, db._updateSeq,
+ function (err) {
+ if (err) {
+ results[index] = err;
+ } else {
+ results[index] = doc;
+ }
+ return callback2();
+ });
+ });
+ }
+
+ if (!attachments.length) {
+ finish();
+ }
+ }
+
+ function saveAttachment(docInfo, digest, key, data, callback) {
+ delete docInfo.data._attachments[key].data;
+ docInfo.data._attachments[key].digest = digest;
+ stores.attachmentStore.get(digest, function (err, oldAtt) {
+ if (err && err.name !== 'NotFoundError') {
+ return callback(err);
+ }
+
+ var ref = [docInfo.metadata.id, docInfo.metadata.rev].join('@');
+ var newAtt = {};
+
+ if (oldAtt) {
+ if (oldAtt.refs) {
+ // only update references if this attachment already has them
+ // since we cannot migrate old style attachments here without
+ // doing a full db scan for references
+ newAtt.refs = oldAtt.refs;
+ newAtt.refs[ref] = true;
+ }
+ } else {
+ newAtt.refs = {};
+ newAtt.refs[ref] = true;
+ }
+
+ stores.attachmentStore.put(digest, newAtt, function (err) {
+ // do not try to store empty attachments
+ if (data.length === 0) {
+ return callback(err);
+ }
+ // doing this in batch causes a test to fail, wtf?
+ stores.binaryStore.put(digest, data, function (err) {
+ callback(err);
+ });
+ });
+ });
+ }
+
+ function complete() {
+ results.sort(function (a, b) { return a._bulk_seq - b._bulk_seq; });
+ var aresults = results.map(function (result) {
+ if (result._bulk_seq) {
+ delete result._bulk_seq;
+ } else if (!Object.keys(result).length) {
+ return {
+ ok: true
+ };
+ }
+ if (result.error) {
+ return result;
+ }
+
+ var metadata = result.metadata;
+ var rev = merge.winningRev(metadata);
+
+ return {
+ ok: true,
+ id: metadata.id,
+ rev: rev
+ };
+ });
+ LevelPouch.Changes.notify(name);
+ process.nextTick(function () { callback(null, aresults); });
+ }
+
+ function makeErr(err, seq) {
+ err._bulk_seq = seq;
+ return err;
+ }
+
+ processDocs();
+ };
+
+ api._allDocs = function (opts, callback) {
+ opts = utils.clone(opts);
+ countDocs(function (err, docCount) {
+ if (err) {
+ return callback(err);
+ }
+ var readstreamOpts = {};
+ var skip = opts.skip || 0;
+ if (opts.startkey) {
+ readstreamOpts.start = opts.startkey;
+ }
+ if (opts.endkey) {
+ readstreamOpts.end = opts.endkey;
+ }
+ if (opts.key) {
+ readstreamOpts.start = readstreamOpts.end = opts.key;
+ }
+ if (opts.descending) {
+ readstreamOpts.reverse = true;
+ // switch start and ends
+ var tmp = readstreamOpts.start;
+ readstreamOpts.start = readstreamOpts.end;
+ readstreamOpts.end = tmp;
+ }
+ var limit;
+ if (typeof opts.limit === 'number') {
+ limit = opts.limit;
+ } else {
+ limit = -1;
+ }
+ if (limit === 0 ||
+ ('start' in readstreamOpts && 'end' in readstreamOpts &&
+ readstreamOpts.start > readstreamOpts.end)) {
+ // should return 0 results when start is greater than end.
+ // normally level would "fix" this for us by reversing the order,
+ // so short-circuit instead
+ return callback(null, {
+ total_rows: docCount,
+ offset: opts.skip,
+ rows: []
+ });
+ }
+ var results = [];
+ var docstream = stores.docStore.readStream(readstreamOpts);
+
+ var throughStream = through(function (entry, _, next) {
+ if (!utils.isDeleted(entry.value)) {
+ if (skip-- > 0) {
+ next();
+ return;
+ } else if (limit-- === 0) {
+ docstream.unpipe();
+ docstream.destroy();
+ next();
+ return;
+ }
+ } else if (opts.deleted !== 'ok') {
+ next();
+ return;
+ }
+ function allDocsInner(metadata, data) {
+ var doc = {
+ id: metadata.id,
+ key: metadata.id,
+ value: {
+ rev: merge.winningRev(metadata)
+ }
+ };
+ if (opts.include_docs) {
+ doc.doc = data;
+ doc.doc._rev = doc.value.rev;
+ if (opts.conflicts) {
+ doc.doc._conflicts = merge.collectConflicts(metadata);
+ }
+ for (var att in doc.doc._attachments) {
+ if (doc.doc._attachments.hasOwnProperty(att)) {
+ doc.doc._attachments[att].stub = true;
+ }
+ }
+ }
+ if (opts.inclusive_end === false && metadata.id === opts.endkey) {
+ return next();
+ } else if (utils.isDeleted(metadata)) {
+ if (opts.deleted === 'ok') {
+ doc.value.deleted = true;
+ doc.doc = null;
+ } else {
+ return next();
+ }
+ }
+ results.push(doc);
+ next();
+ }
+ var metadata = entry.value;
+ if (opts.include_docs) {
+ var seq = metadata.rev_map[merge.winningRev(metadata)];
+ stores.bySeqStore.get(formatSeq(seq), function (err, data) {
+ allDocsInner(metadata, data);
+ });
+ }
+ else {
+ allDocsInner(metadata);
+ }
+ }, function (next) {
+ callback(null, {
+ total_rows: docCount,
+ offset: opts.skip,
+ rows: results
+ });
+ next();
+ }).on('unpipe', function () {
+ throughStream.end();
+ });
+
+ docstream.on('error', callback);
+
+ docstream.pipe(throughStream);
+ });
+ };
+
+ api._changes = function (opts) {
+ opts = utils.clone(opts);
+
+ if (opts.continuous) {
+ var id = name + ':' + utils.uuid();
+ LevelPouch.Changes.addListener(name, id, api, opts);
+ LevelPouch.Changes.notify(name);
+ return {
+ cancel: function () {
+ LevelPouch.Changes.removeListener(name, id);
+ }
+ };
+ }
+
+ var descending = opts.descending;
+ var results = [];
+ var last_seq = 0;
+ var called = 0;
+ var streamOpts = {
+ reverse: descending
+ };
+ var limit;
+ if ('limit' in opts && opts.limit > 0) {
+ limit = opts.limit;
+ }
+ if (!streamOpts.reverse) {
+ streamOpts.start = formatSeq(opts.since ? opts.since + 1 : 0);
+ }
+ var filter = utils.filterChange(opts);
+ var returnDocs;
+ if ('returnDocs' in opts) {
+ returnDocs = opts.returnDocs;
+ } else {
+ returnDocs = true;
+ }
+
+ function complete() {
+ opts.done = true;
+ if (returnDocs && opts.limit) {
+ if (opts.limit < results.length) {
+ results.length = opts.limit;
+ }
+ }
+ changeStream.unpipe(throughStream);
+ changeStream.destroy();
+ if (!opts.continuous && !opts.cancelled) {
+ opts.complete(null, {results: results, last_seq: last_seq});
+ }
+ }
+ var changeStream = stores.bySeqStore.readStream(streamOpts);
+ var throughStream = through(function (data, _, next) {
+ if (limit && called >= limit) {
+ complete();
+ return next();
+ }
+ if (opts.cancelled || opts.done) {
+ return next();
+ }
+
+ stores.docStore.get(data.value._id, function (err, metadata) {
+ if (opts.cancelled || opts.done || db.isClosed() ||
+ utils.isLocalId(metadata.id)) {
+ return next();
+ }
+ var doc = data.value;
+ doc._rev = merge.winningRev(metadata);
+ var change = opts.processChange(doc, metadata, opts);
+ change.seq = metadata.seq;
+
+ if (last_seq < metadata.seq) {
+ last_seq = metadata.seq;
+ }
+
+ // Ensure duplicated dont overwrite winning rev
+ if (parseSeq(data.key) === metadata.rev_map[change.doc._rev] &&
+ filter(change)) {
+ called++;
+
+ utils.call(opts.onChange, change);
+
+ if (returnDocs) {
+ results.push(change);
+ }
+ }
+ next();
+ });
+ }, function (next) {
+ if (opts.cancelled) {
+ return next();
+ }
+ if (returnDocs && opts.limit) {
+ if (opts.limit < results.length) {
+ results.length = opts.limit;
+ }
+ }
+
+ next();
+ }).on('unpipe', function () {
+ throughStream.end();
+ complete();
+ });
+ changeStream.pipe(throughStream);
+ return {
+ cancel: function () {
+ opts.cancelled = true;
+ complete();
+ }
+ };
+ };
+
+ api._close = function (callback) {
+ if (db.isClosed()) {
+ return callback(errors.NOT_OPEN);
+ }
+ db.close(function (err) {
+ if (err) {
+ callback(err);
+ } else {
+ dbStore["delete"](name);
+ callback();
+ }
+ });
+ };
+
+ api._getRevisionTree = function (docId, callback) {
+ stores.docStore.get(docId, function (err, metadata) {
+ if (err) {
+ callback(errors.MISSING_DOC);
+ } else {
+ callback(null, metadata.rev_tree);
+ }
+ });
+ };
+
+ api._doCompaction = function (docId, rev_tree, revs, callback) {
+ stores.docStore.get(docId, function (err, metadata) {
+ if (err) {
+ return callback(err);
+ }
+ var seqs = metadata.rev_map; // map from rev to seq
+ metadata.rev_tree = rev_tree;
+ if (!revs.length) {
+ callback();
+ }
+ var batch = [];
+ batch.push({
+ key: metadata.id,
+ value: metadata,
+ type: 'put',
+ valueEncoding: 'json',
+ prefix: stores.docStore
+ });
+ revs.forEach(function (rev) {
+ var seq = seqs[rev];
+ if (!seq) {
+ return;
+ }
+ batch.push({
+ key: formatSeq(seq),
+ type: 'del',
+ prefix: stores.bySeqStore
+ });
+ });
+ db.batch(batch, callback);
+ });
+ };
+
+ api._getLocal = function (id, callback) {
+ stores.localStore.get(id, function (err, doc) {
+ if (err) {
+ callback(errors.MISSING_DOC);
+ } else {
+ callback(null, doc);
+ }
+ });
+ };
+
+ api._putLocal = function (doc, callback) {
+ var oldRev = doc._rev;
+ var id = doc._id;
+ stores.localStore.get(id, function (err, resp) {
+ if (err) {
+ if (oldRev) {
+ return callback(errors.REV_CONFLICT);
+ }
+ }
+ if (resp && resp._rev !== oldRev) {
+ return callback(errors.REV_CONFLICT);
+ }
+ if (!oldRev) {
+ doc._rev = '0-0';
+ } else {
+ doc._rev = '0-' + (parseInt(oldRev.split('-')[1], 10) + 1);
+ }
+ stores.localStore.put(id, doc, function (err) {
+ if (err) {
+ return callback(err);
+ }
+ var ret = {ok: true, id: doc._id, rev: doc._rev};
+ callback(null, ret);
+ });
+ });
+ };
+
+ api._removeLocal = function (doc, callback) {
+ stores.localStore.get(doc._id, function (err, resp) {
+ if (err) {
+ return callback(err);
+ }
+ if (resp._rev !== doc._rev) {
+ return callback(errors.REV_CONFLICT);
+ }
+ stores.localStore.del(doc._id, function (err) {
+ if (err) {
+ return callback(err);
+ }
+ var ret = {ok: true, id: doc._id, rev: '0-0'};
+ callback(null, ret);
+ });
+ });
+ };
+}
+
+LevelPouch.valid = function () {
+ return process && !process.browser;
+};
+
+// close and delete open leveldb stores
+LevelPouch.destroy = utils.toPromise(function (name, opts, callback) {
+ opts = utils.clone(opts);
+
+ var leveldown = opts.db || originalLeveldown;
+ function callDestroy(name, cb) {
+ if (typeof leveldown.destroy === 'function') {
+ leveldown.destroy(name, cb);
+ } else {
+ process.nextTick(callback);
+ }
+ }
+
+ var dbStore;
+ if (dbStores.has(leveldown.name)) {
+ dbStore = dbStores.get(leveldown.name);
+ } else {
+ return callDestroy(name, callback);
+ }
+
+ if (dbStore.has(name)) {
+
+ LevelPouch.Changes.removeAllListeners(name);
+
+ dbStore.get(name).close(function () {
+ dbStore["delete"](name);
+ callDestroy(name, callback);
+ });
+ } else {
+ callDestroy(name, callback);
+ }
+});
+
+LevelPouch.use_prefix = false;
+
+LevelPouch.Changes = new utils.Changes();
+
+module.exports = LevelPouch;
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer)
+},{"../deps/errors":5,"../deps/migrate":"JpIkFB","../merge":8,"../utils":15,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"level-sublevel":35,"leveldown":"3WVjcl","levelup":49,"through2":117}],2:[function(require,module,exports){
+"use strict";
+
+var createBlob = require('./blob.js');
+var errors = require('./errors');
+var utils = require("../utils");
+var hasUpload;
+
+function ajax(options, adapterCallback) {
+
+ var requestCompleted = false;
+ var callback = utils.getArguments(function (args) {
+ if (requestCompleted) {
+ return;
+ }
+ adapterCallback.apply(this, args);
+ requestCompleted = true;
+ });
+
+ if (typeof options === "function") {
+ callback = options;
+ options = {};
+ }
+
+ options = utils.clone(options);
+
+ var defaultOptions = {
+ method : "GET",
+ headers: {},
+ json: true,
+ processData: true,
+ timeout: 10000,
+ cache: false
+ };
+
+ options = utils.extend(true, defaultOptions, options);
+
+ // cache-buster, specifically designed to work around IE's aggressive caching
+ // see http://www.dashbay.com/2011/05/internet-explorer-caches-ajax/
+ if (options.method === 'GET' && !options.cache) {
+ var hasArgs = options.url.indexOf('?') !== -1;
+ options.url += (hasArgs ? '&' : '?') + '_nonce=' + utils.uuid(16);
+ }
+
+ function onSuccess(obj, resp, cb) {
+ if (!options.binary && !options.json && options.processData &&
+ typeof obj !== 'string') {
+ obj = JSON.stringify(obj);
+ } else if (!options.binary && options.json && typeof obj === 'string') {
+ try {
+ obj = JSON.parse(obj);
+ } catch (e) {
+ // Probably a malformed JSON from server
+ return cb(e);
+ }
+ }
+ if (Array.isArray(obj)) {
+ obj = obj.map(function (v) {
+ var obj;
+ if (v.ok) {
+ return v;
+ } else if (v.error && v.error === 'conflict') {
+ obj = errors.REV_CONFLICT;
+ obj.id = v.id;
+ return obj;
+ } else if (v.error && v.error === 'forbidden') {
+ obj = errors.FORBIDDEN;
+ obj.id = v.id;
+ obj.reason = v.reason;
+ return obj;
+ } else if (v.missing) {
+ obj = errors.MISSING_DOC;
+ obj.missing = v.missing;
+ return obj;
+ } else {
+ return v;
+ }
+ });
+ }
+ cb(null, obj, resp);
+ }
+
+ function onError(err, cb) {
+ var errParsed, errObj, errType, key;
+ try {
+ errParsed = JSON.parse(err.responseText);
+ //would prefer not to have a try/catch clause
+ for (key in errors) {
+ if (errors.hasOwnProperty(key) &&
+ errors[key].name === errParsed.error) {
+ errType = errors[key];
+ break;
+ }
+ }
+ if (!errType) {
+ errType = errors.UNKNOWN_ERROR;
+ if (err.status) {
+ errType.status = err.status;
+ }
+ if (err.statusText) {
+ err.name = err.statusText;
+ }
+ }
+ errObj = errors.error(errType, errParsed.reason);
+ } catch (e) {
+ for (var key in errors) {
+ if (errors.hasOwnProperty(key) && errors[key].status === err.status) {
+ errType = errors[key];
+ break;
+ }
+ }
+ if (!errType) {
+ errType = errors.UNKNOWN_ERROR;
+ if (err.status) {
+ errType.status = err.status;
+ }
+ if (err.statusText) {
+ err.name = err.statusText;
+ }
+ }
+ errObj = errors.error(errType);
+ }
+ if (err.withCredentials && err.status === 0) {
+ // apparently this is what we get when the method
+ // is reported as not allowed by CORS. so fudge it
+ errObj.status = 405;
+ errObj.statusText = "Method Not Allowed";
+ }
+ cb(errObj);
+ }
+
+ var timer;
+ var xhr;
+ if (options.xhr) {
+ xhr = new options.xhr();
+ } else {
+ xhr = new XMLHttpRequest();
+ }
+ xhr.open(options.method, options.url);
+ xhr.withCredentials = true;
+
+ if (options.json) {
+ options.headers.Accept = 'application/json';
+ options.headers['Content-Type'] = options.headers['Content-Type'] ||
+ 'application/json';
+ if (options.body &&
+ options.processData &&
+ typeof options.body !== "string") {
+ options.body = JSON.stringify(options.body);
+ }
+ }
+
+ if (options.binary) {
+ xhr.responseType = 'arraybuffer';
+ }
+
+ var createCookie = function (name, value, days) {
+ var expires = "";
+ if (days) {
+ var date = new Date();
+ date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+ expires = "; expires=" + date.toGMTString();
+ }
+ document.cookie = name + "=" + value + expires + "; path=/";
+ };
+
+ for (var key in options.headers) {
+ if (key === 'Cookie') {
+ var cookie = options.headers[key].split('=');
+ createCookie(cookie[0], cookie[1], 10);
+ } else {
+ xhr.setRequestHeader(key, options.headers[key]);
+ }
+ }
+
+ if (!("body" in options)) {
+ options.body = null;
+ }
+
+ var abortReq = function () {
+ if (requestCompleted) {
+ return;
+ }
+ xhr.abort();
+ onError(xhr, callback);
+ };
+
+ xhr.onreadystatechange = function () {
+ if (xhr.readyState !== 4 || requestCompleted) {
+ return;
+ }
+ clearTimeout(timer);
+ if (xhr.status >= 200 && xhr.status < 300) {
+ var data;
+ if (options.binary) {
+ data = createBlob([xhr.response || ''], {
+ type: xhr.getResponseHeader('Content-Type')
+ });
+ } else {
+ data = xhr.responseText;
+ }
+ onSuccess(data, xhr, callback);
+ } else {
+ onError(xhr, callback);
+ }
+ };
+
+ if (options.timeout > 0) {
+ timer = setTimeout(abortReq, options.timeout);
+ xhr.onprogress = function () {
+ clearTimeout(timer);
+ timer = setTimeout(abortReq, options.timeout);
+ };
+ if (typeof hasUpload === 'undefined') {
+ // IE throws an error if you try to access it directly
+ hasUpload = Object.keys(xhr).indexOf('upload') !== -1;
+ }
+ if (hasUpload) { // does not exist in ie9
+ xhr.upload.onprogress = xhr.onprogress;
+ }
+ }
+ if (options.body && (options.body instanceof Blob)) {
+ var reader = new FileReader();
+ reader.onloadend = function (e) {
+
+ var binary = "";
+ var bytes = new Uint8Array(this.result);
+ var length = bytes.byteLength;
+
+ for (var i = 0; i < length; i++) {
+ binary += String.fromCharCode(bytes[i]);
+ }
+
+ binary = utils.fixBinary(binary);
+ xhr.send(binary);
+ };
+ reader.readAsArrayBuffer(options.body);
+ } else {
+ xhr.send(options.body);
+ }
+ return {abort: abortReq};
+}
+
+module.exports = ajax;
+
+},{"../utils":15,"./blob.js":3,"./errors":5}],3:[function(require,module,exports){
+(function (global){
+"use strict";
+
+//Abstracts constructing a Blob object, so it also works in older
+//browsers that don't support the native Blob constructor. (i.e.
+//old QtWebKit versions, at least).
+function createBlob(parts, properties) {
+ parts = parts || [];
+ properties = properties || {};
+ try {
+ return new Blob(parts, properties);
+ } catch (e) {
+ if (e.name !== "TypeError") {
+ throw e;
+ }
+ var BlobBuilder = global.BlobBuilder ||
+ global.MSBlobBuilder ||
+ global.MozBlobBuilder ||
+ global.WebKitBlobBuilder;
+ var builder = new BlobBuilder();
+ for (var i = 0; i < parts.length; i += 1) {
+ builder.append(parts[i]);
+ }
+ return builder.getBlob(properties.type);
+ }
+}
+
+module.exports = createBlob;
+
+
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],4:[function(require,module,exports){
+'use strict';
+exports.Map = LazyMap; // TODO: use ES6 map
+exports.Set = LazySet; // TODO: use ES6 set
+// based on https://github.com/montagejs/collections
+function LazyMap() {
+ this.store = {};
+}
+LazyMap.prototype.mangle = function (key) {
+ if (typeof key !== "string") {
+ throw new TypeError("key must be a string but Got " + key);
+ }
+ return '$' + key;
+};
+LazyMap.prototype.unmangle = function (key) {
+ return key.substring(1);
+};
+LazyMap.prototype.get = function (key) {
+ var mangled = this.mangle(key);
+ if (mangled in this.store) {
+ return this.store[mangled];
+ } else {
+ return void 0;
+ }
+};
+LazyMap.prototype.set = function (key, value) {
+ var mangled = this.mangle(key);
+ this.store[mangled] = value;
+ return true;
+};
+LazyMap.prototype.has = function (key) {
+ var mangled = this.mangle(key);
+ return mangled in this.store;
+};
+LazyMap.prototype["delete"] = function (key) {
+ var mangled = this.mangle(key);
+ if (mangled in this.store) {
+ delete this.store[mangled];
+ return true;
+ }
+ return false;
+};
+LazyMap.prototype.forEach = function (cb) {
+ var self = this;
+ var keys = Object.keys(self.store);
+ keys.forEach(function (key) {
+ var value = self.store[key];
+ key = self.unmangle(key);
+ cb(value, key);
+ });
+};
+
+function LazySet() {
+ this.store = new LazyMap();
+}
+LazySet.prototype.add = function (key) {
+ return this.store.set(key, true);
+};
+LazySet.prototype.has = function (key) {
+ return this.store.has(key);
+};
+LazySet.prototype["delete"] = function (key) {
+ return this.store["delete"](key);
+};
+},{}],5:[function(require,module,exports){
+"use strict";
+
+function PouchError(opts) {
+ this.status = opts.status;
+ this.name = opts.error;
+ this.message = opts.reason;
+ this.error = true;
+}
+
+PouchError.prototype__proto__ = Error.prototype;
+
+PouchError.prototype.toString = function () {
+ return JSON.stringify({
+ status: this.status,
+ name: this.name,
+ message: this.message
+ });
+};
+
+exports.UNAUTHORIZED = new PouchError({
+ status: 401,
+ error: 'unauthorized',
+ reason: "Name or password is incorrect."
+});
+exports.MISSING_BULK_DOCS = new PouchError({
+ status: 400,
+ error: 'bad_request',
+ reason: "Missing JSON list of 'docs'"
+});
+exports.MISSING_DOC = new PouchError({
+ status: 404,
+ error: 'not_found',
+ reason: 'missing'
+});
+exports.REV_CONFLICT = new PouchError({
+ status: 409,
+ error: 'conflict',
+ reason: 'Document update conflict'
+});
+exports.INVALID_ID = new PouchError({
+ status: 400,
+ error: 'invalid_id',
+ reason: '_id field must contain a string'
+});
+exports.MISSING_ID = new PouchError({
+ status: 412,
+ error: 'missing_id',
+ reason: '_id is required for puts'
+});
+exports.RESERVED_ID = new PouchError({
+ status: 400,
+ error: 'bad_request',
+ reason: 'Only reserved document ids may start with underscore.'
+});
+exports.NOT_OPEN = new PouchError({
+ status: 412,
+ error: 'precondition_failed',
+ reason: 'Database not open'
+});
+exports.UNKNOWN_ERROR = new PouchError({
+ status: 500,
+ error: 'unknown_error',
+ reason: 'Database encountered an unknown error'
+});
+exports.BAD_ARG = new PouchError({
+ status: 500,
+ error: 'badarg',
+ reason: 'Some query argument is invalid'
+});
+exports.INVALID_REQUEST = new PouchError({
+ status: 400,
+ error: 'invalid_request',
+ reason: 'Request was invalid'
+});
+exports.QUERY_PARSE_ERROR = new PouchError({
+ status: 400,
+ error: 'query_parse_error',
+ reason: 'Some query parameter is invalid'
+});
+exports.DOC_VALIDATION = new PouchError({
+ status: 500,
+ error: 'doc_validation',
+ reason: 'Bad special document member'
+});
+exports.BAD_REQUEST = new PouchError({
+ status: 400,
+ error: 'bad_request',
+ reason: 'Something wrong with the request'
+});
+exports.NOT_AN_OBJECT = new PouchError({
+ status: 400,
+ error: 'bad_request',
+ reason: 'Document must be a JSON object'
+});
+exports.DB_MISSING = new PouchError({
+ status: 404,
+ error: 'not_found',
+ reason: 'Database not found'
+});
+exports.IDB_ERROR = new PouchError({
+ status: 500,
+ error: 'indexed_db_went_bad',
+ reason: 'unknown'
+});
+exports.WSQ_ERROR = new PouchError({
+ status: 500,
+ error: 'web_sql_went_bad',
+ reason: 'unknown'
+});
+exports.LDB_ERROR = new PouchError({
+ status: 500,
+ error: 'levelDB_went_went_bad',
+ reason: 'unknown'
+});
+exports.FORBIDDEN = new PouchError({
+ status: 403,
+ error: 'forbidden',
+ reason: 'Forbidden by design doc validate_doc_update function'
+});
+exports.error = function (error, reason, name) {
+ function CustomPouchError(msg) {
+ this.message = reason;
+ if (name) {
+ this.name = name;
+ }
+ }
+ CustomPouchError.prototype = error;
+ return new CustomPouchError(reason);
+};
+
+},{}],6:[function(require,module,exports){
+(function (process,global){
+'use strict';
+
+var crypto = require('crypto');
+var Md5 = require('spark-md5');
+var setImmediateShim = global.setImmediate || global.setTimeout;
+
+function sliceShim(arrayBuffer, begin, end) {
+ if (typeof arrayBuffer.slice === 'function') {
+ return arrayBuffer.slice(begin, end);
+ }
+ //
+ // shim for IE courtesy of http://stackoverflow.com/a/21440217
+ //
+
+ //If `begin`/`end` is unspecified, Chrome assumes 0, so we do the same
+ //Chrome also converts the values to integers via flooring
+ begin = Math.floor(begin || 0);
+ end = Math.floor(end || 0);
+
+ var len = arrayBuffer.byteLength;
+
+ //If either `begin` or `end` is negative, it refers to an
+ //index from the end of the array, as opposed to from the beginning.
+ //The range specified by the `begin` and `end` values is clamped to the
+ //valid index range for the current array.
+ begin = begin < 0 ? Math.max(begin + len, 0) : Math.min(len, begin);
+ end = end < 0 ? Math.max(end + len, 0) : Math.min(len, end);
+
+ //If the computed length of the new ArrayBuffer would be negative, it
+ //is clamped to zero.
+ if (end - begin <= 0) {
+ return new ArrayBuffer(0);
+ }
+
+ var result = new ArrayBuffer(end - begin);
+ var resultBytes = new Uint8Array(result);
+ var sourceBytes = new Uint8Array(arrayBuffer, begin, end - begin);
+
+ resultBytes.set(sourceBytes);
+
+ return result;
+}
+
+module.exports = function (data, callback) {
+ if (!process.browser) {
+ callback(null, crypto.createHash('md5').update(data).digest('hex'));
+ return;
+ }
+ var chunkSize = Math.min(524288, data.length);
+ var chunks = Math.ceil(data.length / chunkSize);
+ var currentChunk = 0;
+ var buffer = new Md5();
+ function loadNextChunk() {
+ var start = currentChunk * chunkSize;
+ var end = start + chunkSize;
+ if ((start + chunkSize) >= data.size) {
+ end = data.size;
+ }
+ currentChunk++;
+ if (currentChunk < chunks) {
+ buffer.append(sliceShim(data, start, end));
+ setImmediateShim(loadNextChunk);
+ } else {
+ buffer.append(sliceShim(data, start, end));
+ callback(null, buffer.end());
+ buffer.destroy();
+ }
+ }
+ loadNextChunk();
+};
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"crypto":17,"spark-md5":102}],7:[function(require,module,exports){
+"use strict";
+
+// BEGIN Math.uuid.js
+
+/*!
+Math.uuid.js (v1.4)
+http://www.broofa.com
+mailto:robert@broofa.com
+
+Copyright (c) 2010 Robert Kieffer
+Dual licensed under the MIT and GPL licenses.
+*/
+
+/*
+ * Generate a random uuid.
+ *
+ * USAGE: Math.uuid(length, radix)
+ * length - the desired number of characters
+ * radix - the number of allowable values for each character.
+ *
+ * EXAMPLES:
+ * // No arguments - returns RFC4122, version 4 ID
+ * >>> Math.uuid()
+ * "92329D39-6F5C-4520-ABFC-AAB64544E172"
+ *
+ * // One argument - returns ID of the specified length
+ * >>> Math.uuid(15) // 15 character ID (default base=62)
+ * "VcydxgltxrVZSTV"
+ *
+ * // Two arguments - returns ID of the specified length, and radix.
+ * // (Radix must be <= 62)
+ * >>> Math.uuid(8, 2) // 8 character ID (base=2)
+ * "01001010"
+ * >>> Math.uuid(8, 10) // 8 character ID (base=10)
+ * "47473046"
+ * >>> Math.uuid(8, 16) // 8 character ID (base=16)
+ * "098F4D35"
+ */
+var chars = (
+ '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ' +
+ 'abcdefghijklmnopqrstuvwxyz'
+).split('');
+function getValue(radix) {
+ return 0 | Math.random() * radix;
+}
+function uuid(len, radix) {
+ radix = radix || chars.length;
+ var out = '';
+ var i = -1;
+
+ if (len) {
+ // Compact form
+ while (++i < len) {
+ out += chars[getValue(radix)];
+ }
+ return out;
+ }
+ // rfc4122, version 4 form
+ // Fill in random data. At i==19 set the high bits of clock sequence as
+ // per rfc4122, sec. 4.1.5
+ while (++i < 36) {
+ switch (i) {
+ case 8:
+ case 13:
+ case 18:
+ case 23:
+ out += '-';
+ break;
+ case 19:
+ out += chars[(getValue(16) & 0x3) | 0x8];
+ break;
+ default:
+ out += chars[getValue(16)];
+ }
+ }
+
+ return out;
+}
+
+
+
+module.exports = uuid;
+
+
+},{}],8:[function(require,module,exports){
+'use strict';
+var extend = require('pouchdb-extend');
+
+
+// for a better overview of what this is doing, read:
+// https://github.com/apache/couchdb/blob/master/src/couchdb/couch_key_tree.erl
+//
+// But for a quick intro, CouchDB uses a revision tree to store a documents
+// history, A -> B -> C, when a document has conflicts, that is a branch in the
+// tree, A -> (B1 | B2 -> C), We store these as a nested array in the format
+//
+// KeyTree = [Path ... ]
+// Path = {pos: position_from_root, ids: Tree}
+// Tree = [Key, Opts, [Tree, ...]], in particular single node: [Key, []]
+
+// Turn a path as a flat array into a tree with a single branch
+function pathToTree(path) {
+ var doc = path.shift();
+ var root = [doc.id, doc.opts, []];
+ var leaf = root;
+ var nleaf;
+
+ while (path.length) {
+ doc = path.shift();
+ nleaf = [doc.id, doc.opts, []];
+ leaf[2].push(nleaf);
+ leaf = nleaf;
+ }
+ return root;
+}
+
+// Merge two trees together
+// The roots of tree1 and tree2 must be the same revision
+function mergeTree(in_tree1, in_tree2) {
+ var queue = [{tree1: in_tree1, tree2: in_tree2}];
+ var conflicts = false;
+ while (queue.length > 0) {
+ var item = queue.pop();
+ var tree1 = item.tree1;
+ var tree2 = item.tree2;
+
+ if (tree1[1].status || tree2[1].status) {
+ tree1[1].status =
+ (tree1[1].status === 'available' ||
+ tree2[1].status === 'available') ? 'available' : 'missing';
+ }
+
+ for (var i = 0; i < tree2[2].length; i++) {
+ if (!tree1[2][0]) {
+ conflicts = 'new_leaf';
+ tree1[2][0] = tree2[2][i];
+ continue;
+ }
+
+ var merged = false;
+ for (var j = 0; j < tree1[2].length; j++) {
+ if (tree1[2][j][0] === tree2[2][i][0]) {
+ queue.push({tree1: tree1[2][j], tree2: tree2[2][i]});
+ merged = true;
+ }
+ }
+ if (!merged) {
+ conflicts = 'new_branch';
+ tree1[2].push(tree2[2][i]);
+ tree1[2].sort();
+ }
+ }
+ }
+ return {conflicts: conflicts, tree: in_tree1};
+}
+
+function doMerge(tree, path, dontExpand) {
+ var restree = [];
+ var conflicts = false;
+ var merged = false;
+ var res;
+
+ if (!tree.length) {
+ return {tree: [path], conflicts: 'new_leaf'};
+ }
+
+ tree.forEach(function (branch) {
+ if (branch.pos === path.pos && branch.ids[0] === path.ids[0]) {
+ // Paths start at the same position and have the same root, so they need
+ // merged
+ res = mergeTree(branch.ids, path.ids);
+ restree.push({pos: branch.pos, ids: res.tree});
+ conflicts = conflicts || res.conflicts;
+ merged = true;
+ } else if (dontExpand !== true) {
+ // The paths start at a different position, take the earliest path and
+ // traverse up until it as at the same point from root as the path we
+ // want to merge. If the keys match we return the longer path with the
+ // other merged After stemming we dont want to expand the trees
+
+ var t1 = branch.pos < path.pos ? branch : path;
+ var t2 = branch.pos < path.pos ? path : branch;
+ var diff = t2.pos - t1.pos;
+
+ var candidateParents = [];
+
+ var trees = [];
+ trees.push({ids: t1.ids, diff: diff, parent: null, parentIdx: null});
+ while (trees.length > 0) {
+ var item = trees.pop();
+ if (item.diff === 0) {
+ if (item.ids[0] === t2.ids[0]) {
+ candidateParents.push(item);
+ }
+ continue;
+ }
+ if (!item.ids) {
+ continue;
+ }
+ /*jshint loopfunc:true */
+ item.ids[2].forEach(function (el, idx) {
+ trees.push(
+ {ids: el, diff: item.diff - 1, parent: item.ids, parentIdx: idx});
+ });
+ }
+
+ var el = candidateParents[0];
+
+ if (!el) {
+ restree.push(branch);
+ } else {
+ res = mergeTree(el.ids, t2.ids);
+ el.parent[2][el.parentIdx] = res.tree;
+ restree.push({pos: t1.pos, ids: t1.ids});
+ conflicts = conflicts || res.conflicts;
+ merged = true;
+ }
+ } else {
+ restree.push(branch);
+ }
+ });
+
+ // We didnt find
+ if (!merged) {
+ restree.push(path);
+ }
+
+ restree.sort(function (a, b) {
+ return a.pos - b.pos;
+ });
+
+ return {
+ tree: restree,
+ conflicts: conflicts || 'internal_node'
+ };
+}
+
+// To ensure we dont grow the revision tree infinitely, we stem old revisions
+function stem(tree, depth) {
+ // First we break out the tree into a complete list of root to leaf paths,
+ // we cut off the start of the path and generate a new set of flat trees
+ var stemmedPaths = PouchMerge.rootToLeaf(tree).map(function (path) {
+ var stemmed = path.ids.slice(-depth);
+ return {
+ pos: path.pos + (path.ids.length - stemmed.length),
+ ids: pathToTree(stemmed)
+ };
+ });
+ // Then we remerge all those flat trees together, ensuring that we dont
+ // connect trees that would go beyond the depth limit
+ return stemmedPaths.reduce(function (prev, current, i, arr) {
+ return doMerge(prev, current, true).tree;
+ }, [stemmedPaths.shift()]);
+}
+
+var PouchMerge = {};
+
+PouchMerge.merge = function (tree, path, depth) {
+ // Ugh, nicer way to not modify arguments in place?
+ tree = extend(true, [], tree);
+ path = extend(true, {}, path);
+ var newTree = doMerge(tree, path);
+ return {
+ tree: stem(newTree.tree, depth),
+ conflicts: newTree.conflicts
+ };
+};
+
+// We fetch all leafs of the revision tree, and sort them based on tree length
+// and whether they were deleted, undeleted documents with the longest revision
+// tree (most edits) win
+// The final sort algorithm is slightly documented in a sidebar here:
+// http://guide.couchdb.org/draft/conflicts.html
+PouchMerge.winningRev = function (metadata) {
+ var leafs = [];
+ PouchMerge.traverseRevTree(metadata.rev_tree,
+ function (isLeaf, pos, id, something, opts) {
+ if (isLeaf) {
+ leafs.push({pos: pos, id: id, deleted: !!opts.deleted});
+ }
+ });
+ leafs.sort(function (a, b) {
+ if (a.deleted !== b.deleted) {
+ return a.deleted > b.deleted ? 1 : -1;
+ }
+ if (a.pos !== b.pos) {
+ return b.pos - a.pos;
+ }
+ return a.id < b.id ? 1 : -1;
+ });
+
+ return leafs[0].pos + '-' + leafs[0].id;
+};
+
+// Pretty much all below can be combined into a higher order function to
+// traverse revisions
+// The return value from the callback will be passed as context to all
+// children of that node
+PouchMerge.traverseRevTree = function (revs, callback) {
+ var toVisit = revs.slice();
+
+ var node;
+ while ((node = toVisit.pop())) {
+ var pos = node.pos;
+ var tree = node.ids;
+ var branches = tree[2];
+ var newCtx =
+ callback(branches.length === 0, pos, tree[0], node.ctx, tree[1]);
+ for (var i = 0, len = branches.length; i < len; i++) {
+ toVisit.push({pos: pos + 1, ids: branches[i], ctx: newCtx});
+ }
+ }
+};
+
+PouchMerge.collectLeaves = function (revs) {
+ var leaves = [];
+ PouchMerge.traverseRevTree(revs, function (isLeaf, pos, id, acc, opts) {
+ if (isLeaf) {
+ leaves.unshift({rev: pos + "-" + id, pos: pos, opts: opts});
+ }
+ });
+ leaves.sort(function (a, b) {
+ return b.pos - a.pos;
+ });
+ leaves.map(function (leaf) { delete leaf.pos; });
+ return leaves;
+};
+
+// returns revs of all conflicts that is leaves such that
+// 1. are not deleted and
+// 2. are different than winning revision
+PouchMerge.collectConflicts = function (metadata) {
+ var win = PouchMerge.winningRev(metadata);
+ var leaves = PouchMerge.collectLeaves(metadata.rev_tree);
+ var conflicts = [];
+ leaves.forEach(function (leaf) {
+ if (leaf.rev !== win && !leaf.opts.deleted) {
+ conflicts.push(leaf.rev);
+ }
+ });
+ return conflicts;
+};
+
+PouchMerge.rootToLeaf = function (tree) {
+ var paths = [];
+ PouchMerge.traverseRevTree(tree, function (isLeaf, pos, id, history, opts) {
+ history = history ? history.slice(0) : [];
+ history.push({id: id, opts: opts});
+ if (isLeaf) {
+ var rootPos = pos + 1 - history.length;
+ paths.unshift({pos: rootPos, ids: history});
+ }
+ return history;
+ });
+ return paths;
+};
+
+
+module.exports = PouchMerge;
+
+},{"pouchdb-extend":101}],"AQa8tq":[function(require,module,exports){
+'use strict';
+
+module.exports = {
+ name: 'localstorage',
+ valid: function () {
+ return 'localStorage' in window;
+ },
+ use_prefix: true
+};
+},{}],"adapter-config":[function(require,module,exports){
+module.exports=require('AQa8tq');
+},{}],11:[function(require,module,exports){
+"use strict";
+
+var adapterConfig = require('adapter-config');
+var adapterName = adapterConfig.name;
+var adapter = require('./levelalt');
+
+window.PouchDB.adapter(adapterName, adapter);
+window.PouchDB.preferredAdapters.push(adapterName);
+
+},{"./levelalt":12,"adapter-config":"AQa8tq"}],12:[function(require,module,exports){
+'use strict';
+
+var LevelPouch = require('../adapters/leveldb');
+var leveldown = require('leveldown');
+var adapterConfig = require('adapter-config');
+var utils = require('../utils');
+
+function LevelPouchAlt(opts, callback) {
+ var _opts = utils.extend({
+ db: leveldown
+ }, opts);
+
+ LevelPouch.call(this, _opts, callback);
+}
+
+// overrides for normal LevelDB behavior on Node
+LevelPouchAlt.valid = function () {
+ return adapterConfig.valid();
+};
+LevelPouchAlt.use_prefix = adapterConfig.use_prefix;
+
+LevelPouchAlt.destroy = utils.toPromise(function (name, opts, callback) {
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ var _opts = utils.extend({
+ db: leveldown
+ }, opts);
+
+ return LevelPouch.destroy(name, _opts, callback);
+});
+
+module.exports = LevelPouchAlt;
+
+},{"../adapters/leveldb":1,"../utils":15,"adapter-config":"AQa8tq","leveldown":"3WVjcl"}],"JpIkFB":[function(require,module,exports){
+(function (process){
+'use strict';
+// LevelAlt doesn't need the pre-2.2.0 LevelDB-specific migrations
+exports.toSublevel = function (name, db, callback) {
+ process.nextTick(function () {
+ callback();
+ });
+};
+
+exports.localAndMetaStores = function (db, stores, callback) {
+ process.nextTick(function () {
+ callback();
+ });
+};
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],"../adapters/../deps/migrate":[function(require,module,exports){
+module.exports=require('JpIkFB');
+},{}],15:[function(require,module,exports){
+(function (process,global){
+/*jshint strict: false */
+/*global chrome */
+var merge = require('./merge');
+exports.extend = require('pouchdb-extend');
+exports.ajax = require('./deps/ajax');
+exports.createBlob = require('./deps/blob');
+exports.uuid = require('./deps/uuid');
+exports.getArguments = require('argsarray');
+var buffer = require('./deps/buffer');
+var errors = require('./deps/errors');
+var EventEmitter = require('events').EventEmitter;
+var collections = require('./deps/collections');
+exports.Map = collections.Map;
+exports.Set = collections.Set;
+
+if (typeof global.Promise === 'function') {
+ exports.Promise = global.Promise;
+} else {
+ exports.Promise = require('bluebird');
+}
+var Promise = exports.Promise;
+
+function toObject(array) {
+ var obj = {};
+ array.forEach(function (item) { obj[item] = true; });
+ return obj;
+}
+// List of top level reserved words for doc
+var reservedWords = toObject([
+ '_id',
+ '_rev',
+ '_attachments',
+ '_deleted',
+ '_revisions',
+ '_revs_info',
+ '_conflicts',
+ '_deleted_conflicts',
+ '_local_seq',
+ '_rev_tree',
+ //replication documents
+ '_replication_id',
+ '_replication_state',
+ '_replication_state_time',
+ '_replication_state_reason',
+ '_replication_stats'
+]);
+exports.clone = function (obj) {
+ return exports.extend(true, {}, obj);
+};
+exports.inherits = require('inherits');
+// Determine id an ID is valid
+// - invalid IDs begin with an underescore that does not begin '_design' or
+// '_local'
+// - any other string value is a valid id
+// Returns the specific error object for each case
+exports.invalidIdError = function (id) {
+ var err;
+ if (!id) {
+ err = new TypeError(errors.MISSING_ID.message);
+ err.status = 412;
+ } else if (typeof id !== 'string') {
+ err = new TypeError(errors.INVALID_ID.message);
+ err.status = 400;
+ } else if (/^_/.test(id) && !(/^_(design|local)/).test(id)) {
+ err = new TypeError(errors.RESERVED_ID.message);
+ err.status = 400;
+ }
+ if (err) {
+ throw err;
+ }
+};
+
+function isChromeApp() {
+ return (typeof chrome !== "undefined" &&
+ typeof chrome.storage !== "undefined" &&
+ typeof chrome.storage.local !== "undefined");
+}
+
+// Pretty dumb name for a function, just wraps callback calls so we dont
+// to if (callback) callback() everywhere
+exports.call = exports.getArguments(function (args) {
+ if (!args.length) {
+ return;
+ }
+ var fun = args.shift();
+ if (typeof fun === 'function') {
+ fun.apply(this, args);
+ }
+});
+
+exports.isLocalId = function (id) {
+ return (/^_local/).test(id);
+};
+
+// check if a specific revision of a doc has been deleted
+// - metadata: the metadata object from the doc store
+// - rev: (optional) the revision to check. defaults to winning revision
+exports.isDeleted = function (metadata, rev) {
+ if (!rev) {
+ rev = merge.winningRev(metadata);
+ }
+ var dashIndex = rev.indexOf('-');
+ if (dashIndex !== -1) {
+ rev = rev.substring(dashIndex + 1);
+ }
+ var deleted = false;
+ merge.traverseRevTree(metadata.rev_tree,
+ function (isLeaf, pos, id, acc, opts) {
+ if (id === rev) {
+ deleted = !!opts.deleted;
+ }
+ });
+
+ return deleted;
+};
+
+exports.filterChange = function (opts) {
+ return function (change) {
+ var req = {};
+ var hasFilter = opts.filter && typeof opts.filter === 'function';
+
+ req.query = opts.query_params;
+ if (opts.filter && hasFilter && !opts.filter.call(this, change.doc, req)) {
+ return false;
+ }
+ if (opts.doc_ids && opts.doc_ids.indexOf(change.id) === -1) {
+ return false;
+ }
+ if (!opts.include_docs) {
+ delete change.doc;
+ } else {
+ for (var att in change.doc._attachments) {
+ if (change.doc._attachments.hasOwnProperty(att)) {
+ change.doc._attachments[att].stub = true;
+ }
+ }
+ }
+ return true;
+ };
+};
+
+// Preprocess documents, parse their revisions, assign an id and a
+// revision for new writes that are missing them, etc
+exports.parseDoc = function (doc, newEdits) {
+ var nRevNum;
+ var newRevId;
+ var revInfo;
+ var error;
+ var opts = {status: 'available'};
+ if (doc._deleted) {
+ opts.deleted = true;
+ }
+
+ if (newEdits) {
+ if (!doc._id) {
+ doc._id = exports.uuid();
+ }
+ newRevId = exports.uuid(32, 16).toLowerCase();
+ if (doc._rev) {
+ revInfo = /^(\d+)-(.+)$/.exec(doc._rev);
+ if (!revInfo) {
+ var err = new TypeError("invalid value for property '_rev'");
+ err.status = 400;
+ }
+ doc._rev_tree = [{
+ pos: parseInt(revInfo[1], 10),
+ ids: [revInfo[2], {status: 'missing'}, [[newRevId, opts, []]]]
+ }];
+ nRevNum = parseInt(revInfo[1], 10) + 1;
+ } else {
+ doc._rev_tree = [{
+ pos: 1,
+ ids : [newRevId, opts, []]
+ }];
+ nRevNum = 1;
+ }
+ } else {
+ if (doc._revisions) {
+ doc._rev_tree = [{
+ pos: doc._revisions.start - doc._revisions.ids.length + 1,
+ ids: doc._revisions.ids.reduce(function (acc, x) {
+ if (acc === null) {
+ return [x, opts, []];
+ } else {
+ return [x, {status: 'missing'}, [acc]];
+ }
+ }, null)
+ }];
+ nRevNum = doc._revisions.start;
+ newRevId = doc._revisions.ids[0];
+ }
+ if (!doc._rev_tree) {
+ revInfo = /^(\d+)-(.+)$/.exec(doc._rev);
+ if (!revInfo) {
+ error = new TypeError(errors.BAD_ARG.message);
+ error.status = errors.BAD_ARG.status;
+ throw error;
+ }
+ nRevNum = parseInt(revInfo[1], 10);
+ newRevId = revInfo[2];
+ doc._rev_tree = [{
+ pos: parseInt(revInfo[1], 10),
+ ids: [revInfo[2], opts, []]
+ }];
+ }
+ }
+
+ exports.invalidIdError(doc._id);
+
+ doc._id = decodeURIComponent(doc._id);
+ doc._rev = [nRevNum, newRevId].join('-');
+
+ var result = {metadata : {}, data : {}};
+ for (var key in doc) {
+ if (doc.hasOwnProperty(key)) {
+ var specialKey = key[0] === '_';
+ if (specialKey && !reservedWords[key]) {
+ error = new Error(errors.DOC_VALIDATION.message + ': ' + key);
+ error.status = errors.DOC_VALIDATION.status;
+ throw error;
+ } else if (specialKey && key !== '_attachments') {
+ result.metadata[key.slice(1)] = doc[key];
+ } else {
+ result.data[key] = doc[key];
+ }
+ }
+ }
+ return result;
+};
+
+exports.isCordova = function () {
+ return (typeof cordova !== "undefined" ||
+ typeof PhoneGap !== "undefined" ||
+ typeof phonegap !== "undefined");
+};
+
+exports.hasLocalStorage = function () {
+ if (isChromeApp()) {
+ return false;
+ }
+ try {
+ return global.localStorage;
+ } catch (e) {
+ return false;
+ }
+};
+exports.Changes = Changes;
+exports.inherits(Changes, EventEmitter);
+function Changes() {
+ if (!(this instanceof Changes)) {
+ return new Changes();
+ }
+ var self = this;
+ EventEmitter.call(this);
+ this.isChrome = isChromeApp();
+ this.listeners = {};
+ this.hasLocal = false;
+ if (!this.isChrome) {
+ this.hasLocal = exports.hasLocalStorage();
+ }
+ if (this.isChrome) {
+ chrome.storage.onChanged.addListener(function (e) {
+ // make sure it's event addressed to us
+ if (e.db_name != null) {
+ //object only has oldValue, newValue members
+ self.emit(e.dbName.newValue);
+ }
+ });
+ } else if (this.hasLocal) {
+ if (global.addEventListener) {
+ global.addEventListener("storage", function (e) {
+ self.emit(e.key);
+ });
+ } else {
+ global.attachEvent("storage", function (e) {
+ self.emit(e.key);
+ });
+ }
+ }
+
+}
+Changes.prototype.addListener = function (dbName, id, db, opts) {
+ if (this.listeners[id]) {
+ return;
+ }
+ function eventFunction() {
+ db.changes({
+ include_docs: opts.include_docs,
+ conflicts: opts.conflicts,
+ continuous: false,
+ descending: false,
+ filter: opts.filter,
+ view: opts.view,
+ since: opts.since,
+ query_params: opts.query_params,
+ onChange: function (c) {
+ if (c.seq > opts.since && !opts.cancelled) {
+ opts.since = c.seq;
+ exports.call(opts.onChange, c);
+ }
+ }
+ });
+ }
+ this.listeners[id] = eventFunction;
+ this.on(dbName, eventFunction);
+};
+
+Changes.prototype.removeListener = function (dbName, id) {
+ if (!(id in this.listeners)) {
+ return;
+ }
+ EventEmitter.prototype.removeListener.call(this, dbName,
+ this.listeners[id]);
+};
+
+
+Changes.prototype.notifyLocalWindows = function (dbName) {
+ //do a useless change on a storage thing
+ //in order to get other windows's listeners to activate
+ if (this.isChrome) {
+ chrome.storage.local.set({dbName: dbName});
+ } else if (this.hasLocal) {
+ localStorage[dbName] = (localStorage[dbName] === "a") ? "b" : "a";
+ }
+};
+
+Changes.prototype.notify = function (dbName) {
+ this.emit(dbName);
+ this.notifyLocalWindows(dbName);
+};
+
+if (!process.browser || !('atob' in global)) {
+ exports.atob = function (str) {
+ var base64 = new buffer(str, 'base64');
+ // Node.js will just skip the characters it can't encode instead of
+ // throwing and exception
+ if (base64.toString('base64') !== str) {
+ throw ("Cannot base64 encode full string");
+ }
+ return base64.toString('binary');
+ };
+} else {
+ exports.atob = function (str) {
+ return atob(str);
+ };
+}
+
+if (!process.browser || !('btoa' in global)) {
+ exports.btoa = function (str) {
+ return new buffer(str, 'binary').toString('base64');
+ };
+} else {
+ exports.btoa = function (str) {
+ return btoa(str);
+ };
+}
+
+// From http://stackoverflow.com/questions/14967647/ (continues on next line)
+// encode-decode-image-with-base64-breaks-image (2013-04-21)
+exports.fixBinary = function (bin) {
+ if (!process.browser) {
+ // don't need to do this in Node
+ return bin;
+ }
+
+ var length = bin.length;
+ var buf = new ArrayBuffer(length);
+ var arr = new Uint8Array(buf);
+ for (var i = 0; i < length; i++) {
+ arr[i] = bin.charCodeAt(i);
+ }
+ return buf;
+};
+
+exports.once = function (fun) {
+ var called = false;
+ return exports.getArguments(function (args) {
+ if (called) {
+ if (typeof console.trace === 'function') {
+ console.trace();
+ }
+ throw new Error('once called more than once');
+ } else {
+ called = true;
+ fun.apply(this, args);
+ }
+ });
+};
+
+exports.toPromise = function (func) {
+ //create the function we will be returning
+ return exports.getArguments(function (args) {
+ var self = this;
+ var tempCB =
+ (typeof args[args.length - 1] === 'function') ? args.pop() : false;
+ // if the last argument is a function, assume its a callback
+ var usedCB;
+ if (tempCB) {
+ // if it was a callback, create a new callback which calls it,
+ // but do so async so we don't trap any errors
+ usedCB = function (err, resp) {
+ process.nextTick(function () {
+ tempCB(err, resp);
+ });
+ };
+ }
+ var promise = new Promise(function (fulfill, reject) {
+ var resp;
+ try {
+ var callback = exports.once(function (err, mesg) {
+ if (err) {
+ reject(err);
+ } else {
+ fulfill(mesg);
+ }
+ });
+ // create a callback for this invocation
+ // apply the function in the orig context
+ args.push(callback);
+ resp = func.apply(self, args);
+ if (resp && typeof resp.then === 'function') {
+ fulfill(resp);
+ }
+ } catch (e) {
+ reject(e);
+ }
+ });
+ // if there is a callback, call it back
+ if (usedCB) {
+ promise.then(function (result) {
+ usedCB(null, result);
+ }, usedCB);
+ }
+ promise.cancel = function () {
+ return this;
+ };
+ return promise;
+ });
+};
+
+exports.adapterFun = function (name, callback) {
+ return exports.toPromise(exports.getArguments(function (args) {
+ if (this._closed) {
+ return Promise.reject(new Error('database is closed'));
+ }
+ var self = this;
+ if (!this.taskqueue.isReady) {
+ return new exports.Promise(function (fulfill, reject) {
+ self.taskqueue.addTask(function (failed) {
+ if (failed) {
+ reject(failed);
+ } else {
+ fulfill(self[name].apply(self, args));
+ }
+ });
+ });
+ }
+ return callback.apply(this, args);
+ }));
+};
+//Can't find original post, but this is close
+//http://stackoverflow.com/questions/6965107/ (continues on next line)
+//converting-between-strings-and-arraybuffers
+exports.arrayBufferToBinaryString = function (buffer) {
+ var binary = "";
+ var bytes = new Uint8Array(buffer);
+ var length = bytes.byteLength;
+ for (var i = 0; i < length; i++) {
+ binary += String.fromCharCode(bytes[i]);
+ }
+ return binary;
+};
+
+exports.cancellableFun = function (fun, self, opts) {
+
+ opts = opts ? exports.clone(true, {}, opts) : {};
+
+ var emitter = new EventEmitter();
+ var oldComplete = opts.complete || function () { };
+ var complete = opts.complete = exports.once(function (err, resp) {
+ if (err) {
+ oldComplete(err);
+ } else {
+ emitter.emit('end', resp);
+ oldComplete(null, resp);
+ }
+ emitter.removeAllListeners();
+ });
+ var oldOnChange = opts.onChange || function () {};
+ var lastChange = 0;
+ self.on('destroyed', function () {
+ emitter.removeAllListeners();
+ });
+ opts.onChange = function (change) {
+ oldOnChange(change);
+ if (change.seq <= lastChange) {
+ return;
+ }
+ lastChange = change.seq;
+ emitter.emit('change', change);
+ if (change.deleted) {
+ emitter.emit('delete', change);
+ } else if (change.changes.length === 1 &&
+ change.changes[0].rev.slice(0, 1) === '1-') {
+ emitter.emit('create', change);
+ } else {
+ emitter.emit('update', change);
+ }
+ };
+ var promise = new Promise(function (fulfill, reject) {
+ opts.complete = function (err, res) {
+ if (err) {
+ reject(err);
+ } else {
+ fulfill(res);
+ }
+ };
+ });
+
+ promise.then(function (result) {
+ complete(null, result);
+ }, complete);
+
+ // this needs to be overwridden by caller, dont fire complete until
+ // the task is ready
+ promise.cancel = function () {
+ promise.isCancelled = true;
+ if (self.taskqueue.isReady) {
+ opts.complete(null, {status: 'cancelled'});
+ }
+ };
+
+ if (!self.taskqueue.isReady) {
+ self.taskqueue.addTask(function () {
+ if (promise.isCancelled) {
+ opts.complete(null, {status: 'cancelled'});
+ } else {
+ fun(self, opts, promise);
+ }
+ });
+ } else {
+ fun(self, opts, promise);
+ }
+ promise.on = emitter.on.bind(emitter);
+ promise.once = emitter.once.bind(emitter);
+ promise.addListener = emitter.addListener.bind(emitter);
+ promise.removeListener = emitter.removeListener.bind(emitter);
+ promise.removeAllListeners = emitter.removeAllListeners.bind(emitter);
+ promise.setMaxListeners = emitter.setMaxListeners.bind(emitter);
+ promise.listeners = emitter.listeners.bind(emitter);
+ promise.emit = emitter.emit.bind(emitter);
+ return promise;
+};
+
+exports.MD5 = exports.toPromise(require('./deps/md5'));
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./deps/ajax":2,"./deps/blob":3,"./deps/buffer":17,"./deps/collections":4,"./deps/errors":5,"./deps/md5":6,"./deps/uuid":7,"./merge":8,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"argsarray":16,"bluebird":75,"events":18,"inherits":33,"pouchdb-extend":101}],16:[function(require,module,exports){
+'use strict';
+
+module.exports = argsArray;
+
+function argsArray(fun) {
+ return function () {
+ var len = arguments.length;
+ if (len) {
+ var args = [];
+ var i = -1;
+ while (++i < len) {
+ args[i] = arguments[i];
+ }
+ return fun.call(this, args);
+ } else {
+ return fun.call(this, []);
+ }
+ };
+}
+},{}],17:[function(require,module,exports){
+
+},{}],18:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+function EventEmitter() {
+ this._events = this._events || {};
+ this._maxListeners = this._maxListeners || undefined;
+}
+module.exports = EventEmitter;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+EventEmitter.defaultMaxListeners = 10;
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function(n) {
+ if (!isNumber(n) || n < 0 || isNaN(n))
+ throw TypeError('n must be a positive number');
+ this._maxListeners = n;
+ return this;
+};
+
+EventEmitter.prototype.emit = function(type) {
+ var er, handler, len, args, i, listeners;
+
+ if (!this._events)
+ this._events = {};
+
+ // If there is no 'error' event listener then throw.
+ if (type === 'error') {
+ if (!this._events.error ||
+ (isObject(this._events.error) && !this._events.error.length)) {
+ er = arguments[1];
+ if (er instanceof Error) {
+ throw er; // Unhandled 'error' event
+ } else {
+ throw TypeError('Uncaught, unspecified "error" event.');
+ }
+ return false;
+ }
+ }
+
+ handler = this._events[type];
+
+ if (isUndefined(handler))
+ return false;
+
+ if (isFunction(handler)) {
+ switch (arguments.length) {
+ // fast cases
+ case 1:
+ handler.call(this);
+ break;
+ case 2:
+ handler.call(this, arguments[1]);
+ break;
+ case 3:
+ handler.call(this, arguments[1], arguments[2]);
+ break;
+ // slower
+ default:
+ len = arguments.length;
+ args = new Array(len - 1);
+ for (i = 1; i < len; i++)
+ args[i - 1] = arguments[i];
+ handler.apply(this, args);
+ }
+ } else if (isObject(handler)) {
+ len = arguments.length;
+ args = new Array(len - 1);
+ for (i = 1; i < len; i++)
+ args[i - 1] = arguments[i];
+
+ listeners = handler.slice();
+ len = listeners.length;
+ for (i = 0; i < len; i++)
+ listeners[i].apply(this, args);
+ }
+
+ return true;
+};
+
+EventEmitter.prototype.addListener = function(type, listener) {
+ var m;
+
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ if (!this._events)
+ this._events = {};
+
+ // To avoid recursion in the case that type === "newListener"! Before
+ // adding it to the listeners, first emit "newListener".
+ if (this._events.newListener)
+ this.emit('newListener', type,
+ isFunction(listener.listener) ?
+ listener.listener : listener);
+
+ if (!this._events[type])
+ // Optimize the case of one listener. Don't need the extra array object.
+ this._events[type] = listener;
+ else if (isObject(this._events[type]))
+ // If we've already got an array, just append.
+ this._events[type].push(listener);
+ else
+ // Adding the second element, need to change to array.
+ this._events[type] = [this._events[type], listener];
+
+ // Check for listener leak
+ if (isObject(this._events[type]) && !this._events[type].warned) {
+ var m;
+ if (!isUndefined(this._maxListeners)) {
+ m = this._maxListeners;
+ } else {
+ m = EventEmitter.defaultMaxListeners;
+ }
+
+ if (m && m > 0 && this._events[type].length > m) {
+ this._events[type].warned = true;
+ console.error('(node) warning: possible EventEmitter memory ' +
+ 'leak detected. %d listeners added. ' +
+ 'Use emitter.setMaxListeners() to increase limit.',
+ this._events[type].length);
+ if (typeof console.trace === 'function') {
+ // not supported in IE 10
+ console.trace();
+ }
+ }
+ }
+
+ return this;
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.once = function(type, listener) {
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ var fired = false;
+
+ function g() {
+ this.removeListener(type, g);
+
+ if (!fired) {
+ fired = true;
+ listener.apply(this, arguments);
+ }
+ }
+
+ g.listener = listener;
+ this.on(type, g);
+
+ return this;
+};
+
+// emits a 'removeListener' event iff the listener was removed
+EventEmitter.prototype.removeListener = function(type, listener) {
+ var list, position, length, i;
+
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ if (!this._events || !this._events[type])
+ return this;
+
+ list = this._events[type];
+ length = list.length;
+ position = -1;
+
+ if (list === listener ||
+ (isFunction(list.listener) && list.listener === listener)) {
+ delete this._events[type];
+ if (this._events.removeListener)
+ this.emit('removeListener', type, listener);
+
+ } else if (isObject(list)) {
+ for (i = length; i-- > 0;) {
+ if (list[i] === listener ||
+ (list[i].listener && list[i].listener === listener)) {
+ position = i;
+ break;
+ }
+ }
+
+ if (position < 0)
+ return this;
+
+ if (list.length === 1) {
+ list.length = 0;
+ delete this._events[type];
+ } else {
+ list.splice(position, 1);
+ }
+
+ if (this._events.removeListener)
+ this.emit('removeListener', type, listener);
+ }
+
+ return this;
+};
+
+EventEmitter.prototype.removeAllListeners = function(type) {
+ var key, listeners;
+
+ if (!this._events)
+ return this;
+
+ // not listening for removeListener, no need to emit
+ if (!this._events.removeListener) {
+ if (arguments.length === 0)
+ this._events = {};
+ else if (this._events[type])
+ delete this._events[type];
+ return this;
+ }
+
+ // emit removeListener for all listeners on all events
+ if (arguments.length === 0) {
+ for (key in this._events) {
+ if (key === 'removeListener') continue;
+ this.removeAllListeners(key);
+ }
+ this.removeAllListeners('removeListener');
+ this._events = {};
+ return this;
+ }
+
+ listeners = this._events[type];
+
+ if (isFunction(listeners)) {
+ this.removeListener(type, listeners);
+ } else {
+ // LIFO order
+ while (listeners.length)
+ this.removeListener(type, listeners[listeners.length - 1]);
+ }
+ delete this._events[type];
+
+ return this;
+};
+
+EventEmitter.prototype.listeners = function(type) {
+ var ret;
+ if (!this._events || !this._events[type])
+ ret = [];
+ else if (isFunction(this._events[type]))
+ ret = [this._events[type]];
+ else
+ ret = this._events[type].slice();
+ return ret;
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+ var ret;
+ if (!emitter._events || !emitter._events[type])
+ ret = 0;
+ else if (isFunction(emitter._events[type]))
+ ret = 1;
+ else
+ ret = emitter._events[type].length;
+ return ret;
+};
+
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+
+function isUndefined(arg) {
+ return arg === void 0;
+}
+
+},{}],19:[function(require,module,exports){
+// shim for using process in browser
+
+var process = module.exports = {};
+
+process.nextTick = (function () {
+ var canSetImmediate = typeof window !== 'undefined'
+ && window.setImmediate;
+ var canPost = typeof window !== 'undefined'
+ && window.postMessage && window.addEventListener
+ ;
+
+ if (canSetImmediate) {
+ return function (f) { return window.setImmediate(f) };
+ }
+
+ if (canPost) {
+ var queue = [];
+ window.addEventListener('message', function (ev) {
+ var source = ev.source;
+ if ((source === window || source === null) && ev.data === 'process-tick') {
+ ev.stopPropagation();
+ if (queue.length > 0) {
+ var fn = queue.shift();
+ fn();
+ }
+ }
+ }, true);
+
+ return function nextTick(fn) {
+ queue.push(fn);
+ window.postMessage('process-tick', '*');
+ };
+ }
+
+ return function nextTick(fn) {
+ setTimeout(fn, 0);
+ };
+})();
+
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+
+process.binding = function (name) {
+ throw new Error('process.binding is not supported');
+}
+
+// TODO(shtylman)
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+ throw new Error('process.chdir is not supported');
+};
+
+},{}],20:[function(require,module,exports){
+var base64 = require('base64-js')
+var ieee754 = require('ieee754')
+
+exports.Buffer = Buffer
+exports.SlowBuffer = Buffer
+exports.INSPECT_MAX_BYTES = 50
+Buffer.poolSize = 8192
+
+/**
+ * If `Buffer._useTypedArrays`:
+ * === true Use Uint8Array implementation (fastest)
+ * === false Use Object implementation (compatible down to IE6)
+ */
+Buffer._useTypedArrays = (function () {
+ // Detect if browser supports Typed Arrays. Supported browsers are IE 10+,
+ // Firefox 4+, Chrome 7+, Safari 5.1+, Opera 11.6+, iOS 4.2+.
+ if (typeof Uint8Array === 'undefined' || typeof ArrayBuffer === 'undefined')
+ return false
+
+ // Does the browser support adding properties to `Uint8Array` instances? If
+ // not, then that's the same as no `Uint8Array` support. We need to be able to
+ // add all the node Buffer API methods.
+ // Relevant Firefox bug: https://bugzilla.mozilla.org/show_bug.cgi?id=695438
+ try {
+ var arr = new Uint8Array(0)
+ arr.foo = function () { return 42 }
+ return 42 === arr.foo() &&
+ typeof arr.subarray === 'function' // Chrome 9-10 lack `subarray`
+ } catch (e) {
+ return false
+ }
+})()
+
+/**
+ * Class: Buffer
+ * =============
+ *
+ * The Buffer constructor returns instances of `Uint8Array` that are augmented
+ * with function properties for all the node `Buffer` API functions. We use
+ * `Uint8Array` so that square bracket notation works as expected -- it returns
+ * a single octet.
+ *
+ * By augmenting the instances, we can avoid modifying the `Uint8Array`
+ * prototype.
+ */
+function Buffer (subject, encoding, noZero) {
+ if (!(this instanceof Buffer))
+ return new Buffer(subject, encoding, noZero)
+
+ var type = typeof subject
+
+ // Workaround: node's base64 implementation allows for non-padded strings
+ // while base64-js does not.
+ if (encoding === 'base64' && type === 'string') {
+ subject = stringtrim(subject)
+ while (subject.length % 4 !== 0) {
+ subject = subject + '='
+ }
+ }
+
+ // Find the length
+ var length
+ if (type === 'number')
+ length = coerce(subject)
+ else if (type === 'string')
+ length = Buffer.byteLength(subject, encoding)
+ else if (type === 'object')
+ length = coerce(subject.length) // Assume object is an array
+ else
+ throw new Error('First argument needs to be a number, array or string.')
+
+ var buf
+ if (Buffer._useTypedArrays) {
+ // Preferred: Return an augmented `Uint8Array` instance for best performance
+ buf = augment(new Uint8Array(length))
+ } else {
+ // Fallback: Return THIS instance of Buffer (created by `new`)
+ buf = this
+ buf.length = length
+ buf._isBuffer = true
+ }
+
+ var i
+ if (Buffer._useTypedArrays && typeof Uint8Array === 'function' &&
+ subject instanceof Uint8Array) {
+ // Speed optimization -- use set if we're copying from a Uint8Array
+ buf._set(subject)
+ } else if (isArrayish(subject)) {
+ // Treat array-ish objects as a byte array
+ for (i = 0; i < length; i++) {
+ if (Buffer.isBuffer(subject))
+ buf[i] = subject.readUInt8(i)
+ else
+ buf[i] = subject[i]
+ }
+ } else if (type === 'string') {
+ buf.write(subject, 0, encoding)
+ } else if (type === 'number' && !Buffer._useTypedArrays && !noZero) {
+ for (i = 0; i < length; i++) {
+ buf[i] = 0
+ }
+ }
+
+ return buf
+}
+
+// STATIC METHODS
+// ==============
+
+Buffer.isEncoding = function (encoding) {
+ switch (String(encoding).toLowerCase()) {
+ case 'hex':
+ case 'utf8':
+ case 'utf-8':
+ case 'ascii':
+ case 'binary':
+ case 'base64':
+ case 'raw':
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return true
+ default:
+ return false
+ }
+}
+
+Buffer.isBuffer = function (b) {
+ return !!(b !== null && b !== undefined && b._isBuffer)
+}
+
+Buffer.byteLength = function (str, encoding) {
+ var ret
+ str = str + ''
+ switch (encoding || 'utf8') {
+ case 'hex':
+ ret = str.length / 2
+ break
+ case 'utf8':
+ case 'utf-8':
+ ret = utf8ToBytes(str).length
+ break
+ case 'ascii':
+ case 'binary':
+ case 'raw':
+ ret = str.length
+ break
+ case 'base64':
+ ret = base64ToBytes(str).length
+ break
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ ret = str.length * 2
+ break
+ default:
+ throw new Error('Unknown encoding')
+ }
+ return ret
+}
+
+Buffer.concat = function (list, totalLength) {
+ assert(isArray(list), 'Usage: Buffer.concat(list, [totalLength])\n' +
+ 'list should be an Array.')
+
+ if (list.length === 0) {
+ return new Buffer(0)
+ } else if (list.length === 1) {
+ return list[0]
+ }
+
+ var i
+ if (typeof totalLength !== 'number') {
+ totalLength = 0
+ for (i = 0; i < list.length; i++) {
+ totalLength += list[i].length
+ }
+ }
+
+ var buf = new Buffer(totalLength)
+ var pos = 0
+ for (i = 0; i < list.length; i++) {
+ var item = list[i]
+ item.copy(buf, pos)
+ pos += item.length
+ }
+ return buf
+}
+
+// BUFFER INSTANCE METHODS
+// =======================
+
+function _hexWrite (buf, string, offset, length) {
+ offset = Number(offset) || 0
+ var remaining = buf.length - offset
+ if (!length) {
+ length = remaining
+ } else {
+ length = Number(length)
+ if (length > remaining) {
+ length = remaining
+ }
+ }
+
+ // must be an even number of digits
+ var strLen = string.length
+ assert(strLen % 2 === 0, 'Invalid hex string')
+
+ if (length > strLen / 2) {
+ length = strLen / 2
+ }
+ for (var i = 0; i < length; i++) {
+ var byte = parseInt(string.substr(i * 2, 2), 16)
+ assert(!isNaN(byte), 'Invalid hex string')
+ buf[offset + i] = byte
+ }
+ Buffer._charsWritten = i * 2
+ return i
+}
+
+function _utf8Write (buf, string, offset, length) {
+ var charsWritten = Buffer._charsWritten =
+ blitBuffer(utf8ToBytes(string), buf, offset, length)
+ return charsWritten
+}
+
+function _asciiWrite (buf, string, offset, length) {
+ var charsWritten = Buffer._charsWritten =
+ blitBuffer(asciiToBytes(string), buf, offset, length)
+ return charsWritten
+}
+
+function _binaryWrite (buf, string, offset, length) {
+ return _asciiWrite(buf, string, offset, length)
+}
+
+function _base64Write (buf, string, offset, length) {
+ var charsWritten = Buffer._charsWritten =
+ blitBuffer(base64ToBytes(string), buf, offset, length)
+ return charsWritten
+}
+
+Buffer.prototype.write = function (string, offset, length, encoding) {
+ // Support both (string, offset, length, encoding)
+ // and the legacy (string, encoding, offset, length)
+ if (isFinite(offset)) {
+ if (!isFinite(length)) {
+ encoding = length
+ length = undefined
+ }
+ } else { // legacy
+ var swap = encoding
+ encoding = offset
+ offset = length
+ length = swap
+ }
+
+ offset = Number(offset) || 0
+ var remaining = this.length - offset
+ if (!length) {
+ length = remaining
+ } else {
+ length = Number(length)
+ if (length > remaining) {
+ length = remaining
+ }
+ }
+ encoding = String(encoding || 'utf8').toLowerCase()
+
+ switch (encoding) {
+ case 'hex':
+ return _hexWrite(this, string, offset, length)
+ case 'utf8':
+ case 'utf-8':
+ case 'ucs2': // TODO: No support for ucs2 or utf16le encodings yet
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return _utf8Write(this, string, offset, length)
+ case 'ascii':
+ return _asciiWrite(this, string, offset, length)
+ case 'binary':
+ return _binaryWrite(this, string, offset, length)
+ case 'base64':
+ return _base64Write(this, string, offset, length)
+ default:
+ throw new Error('Unknown encoding')
+ }
+}
+
+Buffer.prototype.toString = function (encoding, start, end) {
+ var self = this
+
+ encoding = String(encoding || 'utf8').toLowerCase()
+ start = Number(start) || 0
+ end = (end !== undefined)
+ ? Number(end)
+ : end = self.length
+
+ // Fastpath empty strings
+ if (end === start)
+ return ''
+
+ switch (encoding) {
+ case 'hex':
+ return _hexSlice(self, start, end)
+ case 'utf8':
+ case 'utf-8':
+ case 'ucs2': // TODO: No support for ucs2 or utf16le encodings yet
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return _utf8Slice(self, start, end)
+ case 'ascii':
+ return _asciiSlice(self, start, end)
+ case 'binary':
+ return _binarySlice(self, start, end)
+ case 'base64':
+ return _base64Slice(self, start, end)
+ default:
+ throw new Error('Unknown encoding')
+ }
+}
+
+Buffer.prototype.toJSON = function () {
+ return {
+ type: 'Buffer',
+ data: Array.prototype.slice.call(this._arr || this, 0)
+ }
+}
+
+// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
+Buffer.prototype.copy = function (target, target_start, start, end) {
+ var source = this
+
+ if (!start) start = 0
+ if (!end && end !== 0) end = this.length
+ if (!target_start) target_start = 0
+
+ // Copy 0 bytes; we're done
+ if (end === start) return
+ if (target.length === 0 || source.length === 0) return
+
+ // Fatal error conditions
+ assert(end >= start, 'sourceEnd < sourceStart')
+ assert(target_start >= 0 && target_start < target.length,
+ 'targetStart out of bounds')
+ assert(start >= 0 && start < source.length, 'sourceStart out of bounds')
+ assert(end >= 0 && end <= source.length, 'sourceEnd out of bounds')
+
+ // Are we oob?
+ if (end > this.length)
+ end = this.length
+ if (target.length - target_start < end - start)
+ end = target.length - target_start + start
+
+ // copy!
+ for (var i = 0; i < end - start; i++)
+ target[i + target_start] = this[i + start]
+}
+
+function _base64Slice (buf, start, end) {
+ if (start === 0 && end === buf.length) {
+ return base64.fromByteArray(buf)
+ } else {
+ return base64.fromByteArray(buf.slice(start, end))
+ }
+}
+
+function _utf8Slice (buf, start, end) {
+ var res = ''
+ var tmp = ''
+ end = Math.min(buf.length, end)
+
+ for (var i = start; i < end; i++) {
+ if (buf[i] <= 0x7F) {
+ res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i])
+ tmp = ''
+ } else {
+ tmp += '%' + buf[i].toString(16)
+ }
+ }
+
+ return res + decodeUtf8Char(tmp)
+}
+
+function _asciiSlice (buf, start, end) {
+ var ret = ''
+ end = Math.min(buf.length, end)
+
+ for (var i = start; i < end; i++)
+ ret += String.fromCharCode(buf[i])
+ return ret
+}
+
+function _binarySlice (buf, start, end) {
+ return _asciiSlice(buf, start, end)
+}
+
+function _hexSlice (buf, start, end) {
+ var len = buf.length
+
+ if (!start || start < 0) start = 0
+ if (!end || end < 0 || end > len) end = len
+
+ var out = ''
+ for (var i = start; i < end; i++) {
+ out += toHex(buf[i])
+ }
+ return out
+}
+
+// http://nodejs.org/api/buffer.html#buffer_buf_slice_start_end
+Buffer.prototype.slice = function (start, end) {
+ var len = this.length
+ start = clamp(start, len, 0)
+ end = clamp(end, len, len)
+
+ if (Buffer._useTypedArrays) {
+ return augment(this.subarray(start, end))
+ } else {
+ var sliceLen = end - start
+ var newBuf = new Buffer(sliceLen, undefined, true)
+ for (var i = 0; i < sliceLen; i++) {
+ newBuf[i] = this[i + start]
+ }
+ return newBuf
+ }
+}
+
+// `get` will be removed in Node 0.13+
+Buffer.prototype.get = function (offset) {
+ console.log('.get() is deprecated. Access using array indexes instead.')
+ return this.readUInt8(offset)
+}
+
+// `set` will be removed in Node 0.13+
+Buffer.prototype.set = function (v, offset) {
+ console.log('.set() is deprecated. Access using array indexes instead.')
+ return this.writeUInt8(v, offset)
+}
+
+Buffer.prototype.readUInt8 = function (offset, noAssert) {
+ if (!noAssert) {
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset < this.length, 'Trying to read beyond buffer length')
+ }
+
+ if (offset >= this.length)
+ return
+
+ return this[offset]
+}
+
+function _readUInt16 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val
+ if (littleEndian) {
+ val = buf[offset]
+ if (offset + 1 < len)
+ val |= buf[offset + 1] << 8
+ } else {
+ val = buf[offset] << 8
+ if (offset + 1 < len)
+ val |= buf[offset + 1]
+ }
+ return val
+}
+
+Buffer.prototype.readUInt16LE = function (offset, noAssert) {
+ return _readUInt16(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readUInt16BE = function (offset, noAssert) {
+ return _readUInt16(this, offset, false, noAssert)
+}
+
+function _readUInt32 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val
+ if (littleEndian) {
+ if (offset + 2 < len)
+ val = buf[offset + 2] << 16
+ if (offset + 1 < len)
+ val |= buf[offset + 1] << 8
+ val |= buf[offset]
+ if (offset + 3 < len)
+ val = val + (buf[offset + 3] << 24 >>> 0)
+ } else {
+ if (offset + 1 < len)
+ val = buf[offset + 1] << 16
+ if (offset + 2 < len)
+ val |= buf[offset + 2] << 8
+ if (offset + 3 < len)
+ val |= buf[offset + 3]
+ val = val + (buf[offset] << 24 >>> 0)
+ }
+ return val
+}
+
+Buffer.prototype.readUInt32LE = function (offset, noAssert) {
+ return _readUInt32(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readUInt32BE = function (offset, noAssert) {
+ return _readUInt32(this, offset, false, noAssert)
+}
+
+Buffer.prototype.readInt8 = function (offset, noAssert) {
+ if (!noAssert) {
+ assert(offset !== undefined && offset !== null,
+ 'missing offset')
+ assert(offset < this.length, 'Trying to read beyond buffer length')
+ }
+
+ if (offset >= this.length)
+ return
+
+ var neg = this[offset] & 0x80
+ if (neg)
+ return (0xff - this[offset] + 1) * -1
+ else
+ return this[offset]
+}
+
+function _readInt16 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val = _readUInt16(buf, offset, littleEndian, true)
+ var neg = val & 0x8000
+ if (neg)
+ return (0xffff - val + 1) * -1
+ else
+ return val
+}
+
+Buffer.prototype.readInt16LE = function (offset, noAssert) {
+ return _readInt16(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readInt16BE = function (offset, noAssert) {
+ return _readInt16(this, offset, false, noAssert)
+}
+
+function _readInt32 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val = _readUInt32(buf, offset, littleEndian, true)
+ var neg = val & 0x80000000
+ if (neg)
+ return (0xffffffff - val + 1) * -1
+ else
+ return val
+}
+
+Buffer.prototype.readInt32LE = function (offset, noAssert) {
+ return _readInt32(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readInt32BE = function (offset, noAssert) {
+ return _readInt32(this, offset, false, noAssert)
+}
+
+function _readFloat (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ return ieee754.read(buf, offset, littleEndian, 23, 4)
+}
+
+Buffer.prototype.readFloatLE = function (offset, noAssert) {
+ return _readFloat(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readFloatBE = function (offset, noAssert) {
+ return _readFloat(this, offset, false, noAssert)
+}
+
+function _readDouble (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset + 7 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ return ieee754.read(buf, offset, littleEndian, 52, 8)
+}
+
+Buffer.prototype.readDoubleLE = function (offset, noAssert) {
+ return _readDouble(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readDoubleBE = function (offset, noAssert) {
+ return _readDouble(this, offset, false, noAssert)
+}
+
+Buffer.prototype.writeUInt8 = function (value, offset, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset < this.length, 'trying to write beyond buffer length')
+ verifuint(value, 0xff)
+ }
+
+ if (offset >= this.length) return
+
+ this[offset] = value
+}
+
+function _writeUInt16 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'trying to write beyond buffer length')
+ verifuint(value, 0xffff)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ for (var i = 0, j = Math.min(len - offset, 2); i < j; i++) {
+ buf[offset + i] =
+ (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
+ (littleEndian ? i : 1 - i) * 8
+ }
+}
+
+Buffer.prototype.writeUInt16LE = function (value, offset, noAssert) {
+ _writeUInt16(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeUInt16BE = function (value, offset, noAssert) {
+ _writeUInt16(this, value, offset, false, noAssert)
+}
+
+function _writeUInt32 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'trying to write beyond buffer length')
+ verifuint(value, 0xffffffff)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ for (var i = 0, j = Math.min(len - offset, 4); i < j; i++) {
+ buf[offset + i] =
+ (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
+ }
+}
+
+Buffer.prototype.writeUInt32LE = function (value, offset, noAssert) {
+ _writeUInt32(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeUInt32BE = function (value, offset, noAssert) {
+ _writeUInt32(this, value, offset, false, noAssert)
+}
+
+Buffer.prototype.writeInt8 = function (value, offset, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset < this.length, 'Trying to write beyond buffer length')
+ verifsint(value, 0x7f, -0x80)
+ }
+
+ if (offset >= this.length)
+ return
+
+ if (value >= 0)
+ this.writeUInt8(value, offset, noAssert)
+ else
+ this.writeUInt8(0xff + value + 1, offset, noAssert)
+}
+
+function _writeInt16 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'Trying to write beyond buffer length')
+ verifsint(value, 0x7fff, -0x8000)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ if (value >= 0)
+ _writeUInt16(buf, value, offset, littleEndian, noAssert)
+ else
+ _writeUInt16(buf, 0xffff + value + 1, offset, littleEndian, noAssert)
+}
+
+Buffer.prototype.writeInt16LE = function (value, offset, noAssert) {
+ _writeInt16(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeInt16BE = function (value, offset, noAssert) {
+ _writeInt16(this, value, offset, false, noAssert)
+}
+
+function _writeInt32 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')
+ verifsint(value, 0x7fffffff, -0x80000000)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ if (value >= 0)
+ _writeUInt32(buf, value, offset, littleEndian, noAssert)
+ else
+ _writeUInt32(buf, 0xffffffff + value + 1, offset, littleEndian, noAssert)
+}
+
+Buffer.prototype.writeInt32LE = function (value, offset, noAssert) {
+ _writeInt32(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeInt32BE = function (value, offset, noAssert) {
+ _writeInt32(this, value, offset, false, noAssert)
+}
+
+function _writeFloat (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')
+ verifIEEE754(value, 3.4028234663852886e+38, -3.4028234663852886e+38)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ ieee754.write(buf, value, offset, littleEndian, 23, 4)
+}
+
+Buffer.prototype.writeFloatLE = function (value, offset, noAssert) {
+ _writeFloat(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeFloatBE = function (value, offset, noAssert) {
+ _writeFloat(this, value, offset, false, noAssert)
+}
+
+function _writeDouble (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 7 < buf.length,
+ 'Trying to write beyond buffer length')
+ verifIEEE754(value, 1.7976931348623157E+308, -1.7976931348623157E+308)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ ieee754.write(buf, value, offset, littleEndian, 52, 8)
+}
+
+Buffer.prototype.writeDoubleLE = function (value, offset, noAssert) {
+ _writeDouble(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeDoubleBE = function (value, offset, noAssert) {
+ _writeDouble(this, value, offset, false, noAssert)
+}
+
+// fill(value, start=0, end=buffer.length)
+Buffer.prototype.fill = function (value, start, end) {
+ if (!value) value = 0
+ if (!start) start = 0
+ if (!end) end = this.length
+
+ if (typeof value === 'string') {
+ value = value.charCodeAt(0)
+ }
+
+ assert(typeof value === 'number' && !isNaN(value), 'value is not a number')
+ assert(end >= start, 'end < start')
+
+ // Fill 0 bytes; we're done
+ if (end === start) return
+ if (this.length === 0) return
+
+ assert(start >= 0 && start < this.length, 'start out of bounds')
+ assert(end >= 0 && end <= this.length, 'end out of bounds')
+
+ for (var i = start; i < end; i++) {
+ this[i] = value
+ }
+}
+
+Buffer.prototype.inspect = function () {
+ var out = []
+ var len = this.length
+ for (var i = 0; i < len; i++) {
+ out[i] = toHex(this[i])
+ if (i === exports.INSPECT_MAX_BYTES) {
+ out[i + 1] = '...'
+ break
+ }
+ }
+ return '<Buffer ' + out.join(' ') + '>'
+}
+
+/**
+ * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.
+ * Added in Node 0.12. Only available in browsers that support ArrayBuffer.
+ */
+Buffer.prototype.toArrayBuffer = function () {
+ if (typeof Uint8Array === 'function') {
+ if (Buffer._useTypedArrays) {
+ return (new Buffer(this)).buffer
+ } else {
+ var buf = new Uint8Array(this.length)
+ for (var i = 0, len = buf.length; i < len; i += 1)
+ buf[i] = this[i]
+ return buf.buffer
+ }
+ } else {
+ throw new Error('Buffer.toArrayBuffer not supported in this browser')
+ }
+}
+
+// HELPER FUNCTIONS
+// ================
+
+function stringtrim (str) {
+ if (str.trim) return str.trim()
+ return str.replace(/^\s+|\s+$/g, '')
+}
+
+var BP = Buffer.prototype
+
+/**
+ * Augment the Uint8Array *instance* (not the class!) with Buffer methods
+ */
+function augment (arr) {
+ arr._isBuffer = true
+
+ // save reference to original Uint8Array get/set methods before overwriting
+ arr._get = arr.get
+ arr._set = arr.set
+
+ // deprecated, will be removed in node 0.13+
+ arr.get = BP.get
+ arr.set = BP.set
+
+ arr.write = BP.write
+ arr.toString = BP.toString
+ arr.toLocaleString = BP.toString
+ arr.toJSON = BP.toJSON
+ arr.copy = BP.copy
+ arr.slice = BP.slice
+ arr.readUInt8 = BP.readUInt8
+ arr.readUInt16LE = BP.readUInt16LE
+ arr.readUInt16BE = BP.readUInt16BE
+ arr.readUInt32LE = BP.readUInt32LE
+ arr.readUInt32BE = BP.readUInt32BE
+ arr.readInt8 = BP.readInt8
+ arr.readInt16LE = BP.readInt16LE
+ arr.readInt16BE = BP.readInt16BE
+ arr.readInt32LE = BP.readInt32LE
+ arr.readInt32BE = BP.readInt32BE
+ arr.readFloatLE = BP.readFloatLE
+ arr.readFloatBE = BP.readFloatBE
+ arr.readDoubleLE = BP.readDoubleLE
+ arr.readDoubleBE = BP.readDoubleBE
+ arr.writeUInt8 = BP.writeUInt8
+ arr.writeUInt16LE = BP.writeUInt16LE
+ arr.writeUInt16BE = BP.writeUInt16BE
+ arr.writeUInt32LE = BP.writeUInt32LE
+ arr.writeUInt32BE = BP.writeUInt32BE
+ arr.writeInt8 = BP.writeInt8
+ arr.writeInt16LE = BP.writeInt16LE
+ arr.writeInt16BE = BP.writeInt16BE
+ arr.writeInt32LE = BP.writeInt32LE
+ arr.writeInt32BE = BP.writeInt32BE
+ arr.writeFloatLE = BP.writeFloatLE
+ arr.writeFloatBE = BP.writeFloatBE
+ arr.writeDoubleLE = BP.writeDoubleLE
+ arr.writeDoubleBE = BP.writeDoubleBE
+ arr.fill = BP.fill
+ arr.inspect = BP.inspect
+ arr.toArrayBuffer = BP.toArrayBuffer
+
+ return arr
+}
+
+// slice(start, end)
+function clamp (index, len, defaultValue) {
+ if (typeof index !== 'number') return defaultValue
+ index = ~~index; // Coerce to integer.
+ if (index >= len) return len
+ if (index >= 0) return index
+ index += len
+ if (index >= 0) return index
+ return 0
+}
+
+function coerce (length) {
+ // Coerce length to a number (possibly NaN), round up
+ // in case it's fractional (e.g. 123.456) then do a
+ // double negate to coerce a NaN to 0. Easy, right?
+ length = ~~Math.ceil(+length)
+ return length < 0 ? 0 : length
+}
+
+function isArray (subject) {
+ return (Array.isArray || function (subject) {
+ return Object.prototype.toString.call(subject) === '[object Array]'
+ })(subject)
+}
+
+function isArrayish (subject) {
+ return isArray(subject) || Buffer.isBuffer(subject) ||
+ subject && typeof subject === 'object' &&
+ typeof subject.length === 'number'
+}
+
+function toHex (n) {
+ if (n < 16) return '0' + n.toString(16)
+ return n.toString(16)
+}
+
+function utf8ToBytes (str) {
+ var byteArray = []
+ for (var i = 0; i < str.length; i++) {
+ var b = str.charCodeAt(i)
+ if (b <= 0x7F)
+ byteArray.push(str.charCodeAt(i))
+ else {
+ var start = i
+ if (b >= 0xD800 && b <= 0xDFFF) i++
+ var h = encodeURIComponent(str.slice(start, i+1)).substr(1).split('%')
+ for (var j = 0; j < h.length; j++)
+ byteArray.push(parseInt(h[j], 16))
+ }
+ }
+ return byteArray
+}
+
+function asciiToBytes (str) {
+ var byteArray = []
+ for (var i = 0; i < str.length; i++) {
+ // Node's code seems to be doing this and not & 0x7F..
+ byteArray.push(str.charCodeAt(i) & 0xFF)
+ }
+ return byteArray
+}
+
+function base64ToBytes (str) {
+ return base64.toByteArray(str)
+}
+
+function blitBuffer (src, dst, offset, length) {
+ var pos
+ for (var i = 0; i < length; i++) {
+ if ((i + offset >= dst.length) || (i >= src.length))
+ break
+ dst[i + offset] = src[i]
+ }
+ return i
+}
+
+function decodeUtf8Char (str) {
+ try {
+ return decodeURIComponent(str)
+ } catch (err) {
+ return String.fromCharCode(0xFFFD) // UTF 8 invalid char
+ }
+}
+
+/*
+ * We have to make sure that the value is a valid integer. This means that it
+ * is non-negative. It has no fractional component and that it does not
+ * exceed the maximum allowed value.
+ */
+function verifuint (value, max) {
+ assert(typeof value == 'number', 'cannot write a non-number as a number')
+ assert(value >= 0,
+ 'specified a negative value for writing an unsigned value')
+ assert(value <= max, 'value is larger than maximum value for type')
+ assert(Math.floor(value) === value, 'value has a fractional component')
+}
+
+function verifsint(value, max, min) {
+ assert(typeof value == 'number', 'cannot write a non-number as a number')
+ assert(value <= max, 'value larger than maximum allowed value')
+ assert(value >= min, 'value smaller than minimum allowed value')
+ assert(Math.floor(value) === value, 'value has a fractional component')
+}
+
+function verifIEEE754(value, max, min) {
+ assert(typeof value == 'number', 'cannot write a non-number as a number')
+ assert(value <= max, 'value larger than maximum allowed value')
+ assert(value >= min, 'value smaller than minimum allowed value')
+}
+
+function assert (test, message) {
+ if (!test) throw new Error(message || 'Failed assertion')
+}
+
+},{"base64-js":21,"ieee754":22}],21:[function(require,module,exports){
+var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+;(function (exports) {
+ 'use strict';
+
+ var Arr = (typeof Uint8Array !== 'undefined')
+ ? Uint8Array
+ : Array
+
+ var PLUS = '+'.charCodeAt(0)
+ var SLASH = '/'.charCodeAt(0)
+ var NUMBER = '0'.charCodeAt(0)
+ var LOWER = 'a'.charCodeAt(0)
+ var UPPER = 'A'.charCodeAt(0)
+
+ function decode (elt) {
+ var code = elt.charCodeAt(0)
+ if (code === PLUS)
+ return 62 // '+'
+ if (code === SLASH)
+ return 63 // '/'
+ if (code < NUMBER)
+ return -1 //no match
+ if (code < NUMBER + 10)
+ return code - NUMBER + 26 + 26
+ if (code < UPPER + 26)
+ return code - UPPER
+ if (code < LOWER + 26)
+ return code - LOWER + 26
+ }
+
+ function b64ToByteArray (b64) {
+ var i, j, l, tmp, placeHolders, arr
+
+ if (b64.length % 4 > 0) {
+ throw new Error('Invalid string. Length must be a multiple of 4')
+ }
+
+ // the number of equal signs (place holders)
+ // if there are two placeholders, than the two characters before it
+ // represent one byte
+ // if there is only one, then the three characters before it represent 2 bytes
+ // this is just a cheap hack to not do indexOf twice
+ var len = b64.length
+ placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0
+
+ // base64 is 4/3 + up to two characters of the original data
+ arr = new Arr(b64.length * 3 / 4 - placeHolders)
+
+ // if there are placeholders, only get up to the last complete 4 chars
+ l = placeHolders > 0 ? b64.length - 4 : b64.length
+
+ var L = 0
+
+ function push (v) {
+ arr[L++] = v
+ }
+
+ for (i = 0, j = 0; i < l; i += 4, j += 3) {
+ tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))
+ push((tmp & 0xFF0000) >> 16)
+ push((tmp & 0xFF00) >> 8)
+ push(tmp & 0xFF)
+ }
+
+ if (placeHolders === 2) {
+ tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)
+ push(tmp & 0xFF)
+ } else if (placeHolders === 1) {
+ tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)
+ push((tmp >> 8) & 0xFF)
+ push(tmp & 0xFF)
+ }
+
+ return arr
+ }
+
+ function uint8ToBase64 (uint8) {
+ var i,
+ extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
+ output = "",
+ temp, length
+
+ function encode (num) {
+ return lookup.charAt(num)
+ }
+
+ function tripletToBase64 (num) {
+ return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)
+ }
+
+ // go through the array every three bytes, we'll deal with trailing stuff later
+ for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
+ temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
+ output += tripletToBase64(temp)
+ }
+
+ // pad the end with zeros, but make sure to not forget the extra bytes
+ switch (extraBytes) {
+ case 1:
+ temp = uint8[uint8.length - 1]
+ output += encode(temp >> 2)
+ output += encode((temp << 4) & 0x3F)
+ output += '=='
+ break
+ case 2:
+ temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])
+ output += encode(temp >> 10)
+ output += encode((temp >> 4) & 0x3F)
+ output += encode((temp << 2) & 0x3F)
+ output += '='
+ break
+ }
+
+ return output
+ }
+
+ exports.toByteArray = b64ToByteArray
+ exports.fromByteArray = uint8ToBase64
+}(typeof exports === 'undefined' ? (this.base64js = {}) : exports))
+
+},{}],22:[function(require,module,exports){
+exports.read = function(buffer, offset, isLE, mLen, nBytes) {
+ var e, m,
+ eLen = nBytes * 8 - mLen - 1,
+ eMax = (1 << eLen) - 1,
+ eBias = eMax >> 1,
+ nBits = -7,
+ i = isLE ? (nBytes - 1) : 0,
+ d = isLE ? -1 : 1,
+ s = buffer[offset + i];
+
+ i += d;
+
+ e = s & ((1 << (-nBits)) - 1);
+ s >>= (-nBits);
+ nBits += eLen;
+ for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);
+
+ m = e & ((1 << (-nBits)) - 1);
+ e >>= (-nBits);
+ nBits += mLen;
+ for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);
+
+ if (e === 0) {
+ e = 1 - eBias;
+ } else if (e === eMax) {
+ return m ? NaN : ((s ? -1 : 1) * Infinity);
+ } else {
+ m = m + Math.pow(2, mLen);
+ e = e - eBias;
+ }
+ return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+};
+
+exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
+ var e, m, c,
+ eLen = nBytes * 8 - mLen - 1,
+ eMax = (1 << eLen) - 1,
+ eBias = eMax >> 1,
+ rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),
+ i = isLE ? 0 : (nBytes - 1),
+ d = isLE ? 1 : -1,
+ s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
+
+ value = Math.abs(value);
+
+ if (isNaN(value) || value === Infinity) {
+ m = isNaN(value) ? 1 : 0;
+ e = eMax;
+ } else {
+ e = Math.floor(Math.log(value) / Math.LN2);
+ if (value * (c = Math.pow(2, -e)) < 1) {
+ e--;
+ c *= 2;
+ }
+ if (e + eBias >= 1) {
+ value += rt / c;
+ } else {
+ value += rt * Math.pow(2, 1 - eBias);
+ }
+ if (value * c >= 2) {
+ e++;
+ c /= 2;
+ }
+
+ if (e + eBias >= eMax) {
+ m = 0;
+ e = eMax;
+ } else if (e + eBias >= 1) {
+ m = (value * c - 1) * Math.pow(2, mLen);
+ e = e + eBias;
+ } else {
+ m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+ e = 0;
+ }
+ }
+
+ for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8);
+
+ e = (e << mLen) | m;
+ eLen += mLen;
+ for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8);
+
+ buffer[offset + i - d] |= s * 128;
+};
+
+},{}],23:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototypal inheritance, this class
+// prototypally inherits from Readable, and then parasitically from
+// Writable.
+
+module.exports = Duplex;
+var inherits = require('inherits');
+var setImmediate = require('process/browser.js').nextTick;
+var Readable = require('./readable.js');
+var Writable = require('./writable.js');
+
+inherits(Duplex, Readable);
+
+Duplex.prototype.write = Writable.prototype.write;
+Duplex.prototype.end = Writable.prototype.end;
+Duplex.prototype._write = Writable.prototype._write;
+
+function Duplex(options) {
+ if (!(this instanceof Duplex))
+ return new Duplex(options);
+
+ Readable.call(this, options);
+ Writable.call(this, options);
+
+ if (options && options.readable === false)
+ this.readable = false;
+
+ if (options && options.writable === false)
+ this.writable = false;
+
+ this.allowHalfOpen = true;
+ if (options && options.allowHalfOpen === false)
+ this.allowHalfOpen = false;
+
+ this.once('end', onend);
+}
+
+// the no-half-open enforcer
+function onend() {
+ // if we allow half-open state, or if the writable side ended,
+ // then we're ok.
+ if (this.allowHalfOpen || this._writableState.ended)
+ return;
+
+ // no more data can be written.
+ // But allow more writes to happen in this tick.
+ var self = this;
+ setImmediate(function () {
+ self.end();
+ });
+}
+
+},{"./readable.js":27,"./writable.js":29,"inherits":33,"process/browser.js":25}],24:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module.exports = Stream;
+
+var EE = require('events').EventEmitter;
+var inherits = require('inherits');
+
+inherits(Stream, EE);
+Stream.Readable = require('./readable.js');
+Stream.Writable = require('./writable.js');
+Stream.Duplex = require('./duplex.js');
+Stream.Transform = require('./transform.js');
+Stream.PassThrough = require('./passthrough.js');
+
+// Backwards-compat with node 0.4.x
+Stream.Stream = Stream;
+
+
+
+// old-style streams. Note that the pipe method (the only relevant
+// part of this class) is overridden in the Readable class.
+
+function Stream() {
+ EE.call(this);
+}
+
+Stream.prototype.pipe = function(dest, options) {
+ var source = this;
+
+ function ondata(chunk) {
+ if (dest.writable) {
+ if (false === dest.write(chunk) && source.pause) {
+ source.pause();
+ }
+ }
+ }
+
+ source.on('data', ondata);
+
+ function ondrain() {
+ if (source.readable && source.resume) {
+ source.resume();
+ }
+ }
+
+ dest.on('drain', ondrain);
+
+ // If the 'end' option is not supplied, dest.end() will be called when
+ // source gets the 'end' or 'close' events. Only dest.end() once.
+ if (!dest._isStdio && (!options || options.end !== false)) {
+ source.on('end', onend);
+ source.on('close', onclose);
+ }
+
+ var didOnEnd = false;
+ function onend() {
+ if (didOnEnd) return;
+ didOnEnd = true;
+
+ dest.end();
+ }
+
+
+ function onclose() {
+ if (didOnEnd) return;
+ didOnEnd = true;
+
+ if (typeof dest.destroy === 'function') dest.destroy();
+ }
+
+ // don't leave dangling pipes when there are errors.
+ function onerror(er) {
+ cleanup();
+ if (EE.listenerCount(this, 'error') === 0) {
+ throw er; // Unhandled stream error in pipe.
+ }
+ }
+
+ source.on('error', onerror);
+ dest.on('error', onerror);
+
+ // remove all the event listeners that were added.
+ function cleanup() {
+ source.removeListener('data', ondata);
+ dest.removeListener('drain', ondrain);
+
+ source.removeListener('end', onend);
+ source.removeListener('close', onclose);
+
+ source.removeListener('error', onerror);
+ dest.removeListener('error', onerror);
+
+ source.removeListener('end', cleanup);
+ source.removeListener('close', cleanup);
+
+ dest.removeListener('close', cleanup);
+ }
+
+ source.on('end', cleanup);
+ source.on('close', cleanup);
+
+ dest.on('close', cleanup);
+
+ dest.emit('pipe', source);
+
+ // Allow for unix-like usage: A.pipe(B).pipe(C)
+ return dest;
+};
+
+},{"./duplex.js":23,"./passthrough.js":26,"./readable.js":27,"./transform.js":28,"./writable.js":29,"events":18,"inherits":33}],25:[function(require,module,exports){
+module.exports=require(19)
+},{}],26:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+
+module.exports = PassThrough;
+
+var Transform = require('./transform.js');
+var inherits = require('inherits');
+inherits(PassThrough, Transform);
+
+function PassThrough(options) {
+ if (!(this instanceof PassThrough))
+ return new PassThrough(options);
+
+ Transform.call(this, options);
+}
+
+PassThrough.prototype._transform = function(chunk, encoding, cb) {
+ cb(null, chunk);
+};
+
+},{"./transform.js":28,"inherits":33}],27:[function(require,module,exports){
+(function (process){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module.exports = Readable;
+Readable.ReadableState = ReadableState;
+
+var EE = require('events').EventEmitter;
+var Stream = require('./index.js');
+var Buffer = require('buffer').Buffer;
+var setImmediate = require('process/browser.js').nextTick;
+var StringDecoder;
+
+var inherits = require('inherits');
+inherits(Readable, Stream);
+
+function ReadableState(options, stream) {
+ options = options || {};
+
+ // the point at which it stops calling _read() to fill the buffer
+ // Note: 0 is a valid value, means "don't call _read preemptively ever"
+ var hwm = options.highWaterMark;
+ this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
+
+ // cast to ints.
+ this.highWaterMark = ~~this.highWaterMark;
+
+ this.buffer = [];
+ this.length = 0;
+ this.pipes = null;
+ this.pipesCount = 0;
+ this.flowing = false;
+ this.ended = false;
+ this.endEmitted = false;
+ this.reading = false;
+
+ // In streams that never have any data, and do push(null) right away,
+ // the consumer can miss the 'end' event if they do some I/O before
+ // consuming the stream. So, we don't emit('end') until some reading
+ // happens.
+ this.calledRead = false;
+
+ // a flag to be able to tell if the onwrite cb is called immediately,
+ // or on a later tick. We set this to true at first, becuase any
+ // actions that shouldn't happen until "later" should generally also
+ // not happen before the first write call.
+ this.sync = true;
+
+ // whenever we return null, then we set a flag to say
+ // that we're awaiting a 'readable' event emission.
+ this.needReadable = false;
+ this.emittedReadable = false;
+ this.readableListening = false;
+
+
+ // object stream flag. Used to make read(n) ignore n and to
+ // make all the buffer merging and length checks go away
+ this.objectMode = !!options.objectMode;
+
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+ // when piping, we only care about 'readable' events that happen
+ // after read()ing all the bytes and not getting any pushback.
+ this.ranOut = false;
+
+ // the number of writers that are awaiting a drain event in .pipe()s
+ this.awaitDrain = 0;
+
+ // if true, a maybeReadMore has been scheduled
+ this.readingMore = false;
+
+ this.decoder = null;
+ this.encoding = null;
+ if (options.encoding) {
+ if (!StringDecoder)
+ StringDecoder = require('string_decoder').StringDecoder;
+ this.decoder = new StringDecoder(options.encoding);
+ this.encoding = options.encoding;
+ }
+}
+
+function Readable(options) {
+ if (!(this instanceof Readable))
+ return new Readable(options);
+
+ this._readableState = new ReadableState(options, this);
+
+ // legacy
+ this.readable = true;
+
+ Stream.call(this);
+}
+
+// Manually shove something into the read() buffer.
+// This returns true if the highWaterMark has not been hit yet,
+// similar to how Writable.write() returns true if you should
+// write() some more.
+Readable.prototype.push = function(chunk, encoding) {
+ var state = this._readableState;
+
+ if (typeof chunk === 'string' && !state.objectMode) {
+ encoding = encoding || state.defaultEncoding;
+ if (encoding !== state.encoding) {
+ chunk = new Buffer(chunk, encoding);
+ encoding = '';
+ }
+ }
+
+ return readableAddChunk(this, state, chunk, encoding, false);
+};
+
+// Unshift should *always* be something directly out of read()
+Readable.prototype.unshift = function(chunk) {
+ var state = this._readableState;
+ return readableAddChunk(this, state, chunk, '', true);
+};
+
+function readableAddChunk(stream, state, chunk, encoding, addToFront) {
+ var er = chunkInvalid(state, chunk);
+ if (er) {
+ stream.emit('error', er);
+ } else if (chunk === null || chunk === undefined) {
+ state.reading = false;
+ if (!state.ended)
+ onEofChunk(stream, state);
+ } else if (state.objectMode || chunk && chunk.length > 0) {
+ if (state.ended && !addToFront) {
+ var e = new Error('stream.push() after EOF');
+ stream.emit('error', e);
+ } else if (state.endEmitted && addToFront) {
+ var e = new Error('stream.unshift() after end event');
+ stream.emit('error', e);
+ } else {
+ if (state.decoder && !addToFront && !encoding)
+ chunk = state.decoder.write(chunk);
+
+ // update the buffer info.
+ state.length += state.objectMode ? 1 : chunk.length;
+ if (addToFront) {
+ state.buffer.unshift(chunk);
+ } else {
+ state.reading = false;
+ state.buffer.push(chunk);
+ }
+
+ if (state.needReadable)
+ emitReadable(stream);
+
+ maybeReadMore(stream, state);
+ }
+ } else if (!addToFront) {
+ state.reading = false;
+ }
+
+ return needMoreData(state);
+}
+
+
+
+// if it's past the high water mark, we can push in some more.
+// Also, if we have no data yet, we can stand some
+// more bytes. This is to work around cases where hwm=0,
+// such as the repl. Also, if the push() triggered a
+// readable event, and the user called read(largeNumber) such that
+// needReadable was set, then we ought to push more, so that another
+// 'readable' event will be triggered.
+function needMoreData(state) {
+ return !state.ended &&
+ (state.needReadable ||
+ state.length < state.highWaterMark ||
+ state.length === 0);
+}
+
+// backwards compatibility.
+Readable.prototype.setEncoding = function(enc) {
+ if (!StringDecoder)
+ StringDecoder = require('string_decoder').StringDecoder;
+ this._readableState.decoder = new StringDecoder(enc);
+ this._readableState.encoding = enc;
+};
+
+// Don't raise the hwm > 128MB
+var MAX_HWM = 0x800000;
+function roundUpToNextPowerOf2(n) {
+ if (n >= MAX_HWM) {
+ n = MAX_HWM;
+ } else {
+ // Get the next highest power of 2
+ n--;
+ for (var p = 1; p < 32; p <<= 1) n |= n >> p;
+ n++;
+ }
+ return n;
+}
+
+function howMuchToRead(n, state) {
+ if (state.length === 0 && state.ended)
+ return 0;
+
+ if (state.objectMode)
+ return n === 0 ? 0 : 1;
+
+ if (isNaN(n) || n === null) {
+ // only flow one buffer at a time
+ if (state.flowing && state.buffer.length)
+ return state.buffer[0].length;
+ else
+ return state.length;
+ }
+
+ if (n <= 0)
+ return 0;
+
+ // If we're asking for more than the target buffer level,
+ // then raise the water mark. Bump up to the next highest
+ // power of 2, to prevent increasing it excessively in tiny
+ // amounts.
+ if (n > state.highWaterMark)
+ state.highWaterMark = roundUpToNextPowerOf2(n);
+
+ // don't have that much. return null, unless we've ended.
+ if (n > state.length) {
+ if (!state.ended) {
+ state.needReadable = true;
+ return 0;
+ } else
+ return state.length;
+ }
+
+ return n;
+}
+
+// you can override either this method, or the async _read(n) below.
+Readable.prototype.read = function(n) {
+ var state = this._readableState;
+ state.calledRead = true;
+ var nOrig = n;
+
+ if (typeof n !== 'number' || n > 0)
+ state.emittedReadable = false;
+
+ // if we're doing read(0) to trigger a readable event, but we
+ // already have a bunch of data in the buffer, then just trigger
+ // the 'readable' event and move on.
+ if (n === 0 &&
+ state.needReadable &&
+ (state.length >= state.highWaterMark || state.ended)) {
+ emitReadable(this);
+ return null;
+ }
+
+ n = howMuchToRead(n, state);
+
+ // if we've ended, and we're now clear, then finish it up.
+ if (n === 0 && state.ended) {
+ if (state.length === 0)
+ endReadable(this);
+ return null;
+ }
+
+ // All the actual chunk generation logic needs to be
+ // *below* the call to _read. The reason is that in certain
+ // synthetic stream cases, such as passthrough streams, _read
+ // may be a completely synchronous operation which may change
+ // the state of the read buffer, providing enough data when
+ // before there was *not* enough.
+ //
+ // So, the steps are:
+ // 1. Figure out what the state of things will be after we do
+ // a read from the buffer.
+ //
+ // 2. If that resulting state will trigger a _read, then call _read.
+ // Note that this may be asynchronous, or synchronous. Yes, it is
+ // deeply ugly to write APIs this way, but that still doesn't mean
+ // that the Readable class should behave improperly, as streams are
+ // designed to be sync/async agnostic.
+ // Take note if the _read call is sync or async (ie, if the read call
+ // has returned yet), so that we know whether or not it's safe to emit
+ // 'readable' etc.
+ //
+ // 3. Actually pull the requested chunks out of the buffer and return.
+
+ // if we need a readable event, then we need to do some reading.
+ var doRead = state.needReadable;
+
+ // if we currently have less than the highWaterMark, then also read some
+ if (state.length - n <= state.highWaterMark)
+ doRead = true;
+
+ // however, if we've ended, then there's no point, and if we're already
+ // reading, then it's unnecessary.
+ if (state.ended || state.reading)
+ doRead = false;
+
+ if (doRead) {
+ state.reading = true;
+ state.sync = true;
+ // if the length is currently zero, then we *need* a readable event.
+ if (state.length === 0)
+ state.needReadable = true;
+ // call internal read method
+ this._read(state.highWaterMark);
+ state.sync = false;
+ }
+
+ // If _read called its callback synchronously, then `reading`
+ // will be false, and we need to re-evaluate how much data we
+ // can return to the user.
+ if (doRead && !state.reading)
+ n = howMuchToRead(nOrig, state);
+
+ var ret;
+ if (n > 0)
+ ret = fromList(n, state);
+ else
+ ret = null;
+
+ if (ret === null) {
+ state.needReadable = true;
+ n = 0;
+ }
+
+ state.length -= n;
+
+ // If we have nothing in the buffer, then we want to know
+ // as soon as we *do* get something into the buffer.
+ if (state.length === 0 && !state.ended)
+ state.needReadable = true;
+
+ // If we happened to read() exactly the remaining amount in the
+ // buffer, and the EOF has been seen at this point, then make sure
+ // that we emit 'end' on the very next tick.
+ if (state.ended && !state.endEmitted && state.length === 0)
+ endReadable(this);
+
+ return ret;
+};
+
+function chunkInvalid(state, chunk) {
+ var er = null;
+ if (!Buffer.isBuffer(chunk) &&
+ 'string' !== typeof chunk &&
+ chunk !== null &&
+ chunk !== undefined &&
+ !state.objectMode &&
+ !er) {
+ er = new TypeError('Invalid non-string/buffer chunk');
+ }
+ return er;
+}
+
+
+function onEofChunk(stream, state) {
+ if (state.decoder && !state.ended) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length) {
+ state.buffer.push(chunk);
+ state.length += state.objectMode ? 1 : chunk.length;
+ }
+ }
+ state.ended = true;
+
+ // if we've ended and we have some data left, then emit
+ // 'readable' now to make sure it gets picked up.
+ if (state.length > 0)
+ emitReadable(stream);
+ else
+ endReadable(stream);
+}
+
+// Don't emit readable right away in sync mode, because this can trigger
+// another read() call => stack overflow. This way, it might trigger
+// a nextTick recursion warning, but that's not so bad.
+function emitReadable(stream) {
+ var state = stream._readableState;
+ state.needReadable = false;
+ if (state.emittedReadable)
+ return;
+
+ state.emittedReadable = true;
+ if (state.sync)
+ setImmediate(function() {
+ emitReadable_(stream);
+ });
+ else
+ emitReadable_(stream);
+}
+
+function emitReadable_(stream) {
+ stream.emit('readable');
+}
+
+
+// at this point, the user has presumably seen the 'readable' event,
+// and called read() to consume some data. that may have triggered
+// in turn another _read(n) call, in which case reading = true if
+// it's in progress.
+// However, if we're not ended, or reading, and the length < hwm,
+// then go ahead and try to read some more preemptively.
+function maybeReadMore(stream, state) {
+ if (!state.readingMore) {
+ state.readingMore = true;
+ setImmediate(function() {
+ maybeReadMore_(stream, state);
+ });
+ }
+}
+
+function maybeReadMore_(stream, state) {
+ var len = state.length;
+ while (!state.reading && !state.flowing && !state.ended &&
+ state.length < state.highWaterMark) {
+ stream.read(0);
+ if (len === state.length)
+ // didn't get any data, stop spinning.
+ break;
+ else
+ len = state.length;
+ }
+ state.readingMore = false;
+}
+
+// abstract method. to be overridden in specific implementation classes.
+// call cb(er, data) where data is <= n in length.
+// for virtual (non-string, non-buffer) streams, "length" is somewhat
+// arbitrary, and perhaps not very meaningful.
+Readable.prototype._read = function(n) {
+ this.emit('error', new Error('not implemented'));
+};
+
+Readable.prototype.pipe = function(dest, pipeOpts) {
+ var src = this;
+ var state = this._readableState;
+
+ switch (state.pipesCount) {
+ case 0:
+ state.pipes = dest;
+ break;
+ case 1:
+ state.pipes = [state.pipes, dest];
+ break;
+ default:
+ state.pipes.push(dest);
+ break;
+ }
+ state.pipesCount += 1;
+
+ var doEnd = (!pipeOpts || pipeOpts.end !== false) &&
+ dest !== process.stdout &&
+ dest !== process.stderr;
+
+ var endFn = doEnd ? onend : cleanup;
+ if (state.endEmitted)
+ setImmediate(endFn);
+ else
+ src.once('end', endFn);
+
+ dest.on('unpipe', onunpipe);
+ function onunpipe(readable) {
+ if (readable !== src) return;
+ cleanup();
+ }
+
+ function onend() {
+ dest.end();
+ }
+
+ // when the dest drains, it reduces the awaitDrain counter
+ // on the source. This would be more elegant with a .once()
+ // handler in flow(), but adding and removing repeatedly is
+ // too slow.
+ var ondrain = pipeOnDrain(src);
+ dest.on('drain', ondrain);
+
+ function cleanup() {
+ // cleanup event handlers once the pipe is broken
+ dest.removeListener('close', onclose);
+ dest.removeListener('finish', onfinish);
+ dest.removeListener('drain', ondrain);
+ dest.removeListener('error', onerror);
+ dest.removeListener('unpipe', onunpipe);
+ src.removeListener('end', onend);
+ src.removeListener('end', cleanup);
+
+ // if the reader is waiting for a drain event from this
+ // specific writer, then it would cause it to never start
+ // flowing again.
+ // So, if this is awaiting a drain, then we just call it now.
+ // If we don't know, then assume that we are waiting for one.
+ if (!dest._writableState || dest._writableState.needDrain)
+ ondrain();
+ }
+
+ // if the dest has an error, then stop piping into it.
+ // however, don't suppress the throwing behavior for this.
+ // check for listeners before emit removes one-time listeners.
+ var errListeners = EE.listenerCount(dest, 'error');
+ function onerror(er) {
+ unpipe();
+ if (errListeners === 0 && EE.listenerCount(dest, 'error') === 0)
+ dest.emit('error', er);
+ }
+ dest.once('error', onerror);
+
+ // Both close and finish should trigger unpipe, but only once.
+ function onclose() {
+ dest.removeListener('finish', onfinish);
+ unpipe();
+ }
+ dest.once('close', onclose);
+ function onfinish() {
+ dest.removeListener('close', onclose);
+ unpipe();
+ }
+ dest.once('finish', onfinish);
+
+ function unpipe() {
+ src.unpipe(dest);
+ }
+
+ // tell the dest that it's being piped to
+ dest.emit('pipe', src);
+
+ // start the flow if it hasn't been started already.
+ if (!state.flowing) {
+ // the handler that waits for readable events after all
+ // the data gets sucked out in flow.
+ // This would be easier to follow with a .once() handler
+ // in flow(), but that is too slow.
+ this.on('readable', pipeOnReadable);
+
+ state.flowing = true;
+ setImmediate(function() {
+ flow(src);
+ });
+ }
+
+ return dest;
+};
+
+function pipeOnDrain(src) {
+ return function() {
+ var dest = this;
+ var state = src._readableState;
+ state.awaitDrain--;
+ if (state.awaitDrain === 0)
+ flow(src);
+ };
+}
+
+function flow(src) {
+ var state = src._readableState;
+ var chunk;
+ state.awaitDrain = 0;
+
+ function write(dest, i, list) {
+ var written = dest.write(chunk);
+ if (false === written) {
+ state.awaitDrain++;
+ }
+ }
+
+ while (state.pipesCount && null !== (chunk = src.read())) {
+
+ if (state.pipesCount === 1)
+ write(state.pipes, 0, null);
+ else
+ forEach(state.pipes, write);
+
+ src.emit('data', chunk);
+
+ // if anyone needs a drain, then we have to wait for that.
+ if (state.awaitDrain > 0)
+ return;
+ }
+
+ // if every destination was unpiped, either before entering this
+ // function, or in the while loop, then stop flowing.
+ //
+ // NB: This is a pretty rare edge case.
+ if (state.pipesCount === 0) {
+ state.flowing = false;
+
+ // if there were data event listeners added, then switch to old mode.
+ if (EE.listenerCount(src, 'data') > 0)
+ emitDataEvents(src);
+ return;
+ }
+
+ // at this point, no one needed a drain, so we just ran out of data
+ // on the next readable event, start it over again.
+ state.ranOut = true;
+}
+
+function pipeOnReadable() {
+ if (this._readableState.ranOut) {
+ this._readableState.ranOut = false;
+ flow(this);
+ }
+}
+
+
+Readable.prototype.unpipe = function(dest) {
+ var state = this._readableState;
+
+ // if we're not piping anywhere, then do nothing.
+ if (state.pipesCount === 0)
+ return this;
+
+ // just one destination. most common case.
+ if (state.pipesCount === 1) {
+ // passed in one, but it's not the right one.
+ if (dest && dest !== state.pipes)
+ return this;
+
+ if (!dest)
+ dest = state.pipes;
+
+ // got a match.
+ state.pipes = null;
+ state.pipesCount = 0;
+ this.removeListener('readable', pipeOnReadable);
+ state.flowing = false;
+ if (dest)
+ dest.emit('unpipe', this);
+ return this;
+ }
+
+ // slow case. multiple pipe destinations.
+
+ if (!dest) {
+ // remove all.
+ var dests = state.pipes;
+ var len = state.pipesCount;
+ state.pipes = null;
+ state.pipesCount = 0;
+ this.removeListener('readable', pipeOnReadable);
+ state.flowing = false;
+
+ for (var i = 0; i < len; i++)
+ dests[i].emit('unpipe', this);
+ return this;
+ }
+
+ // try to find the right one.
+ var i = indexOf(state.pipes, dest);
+ if (i === -1)
+ return this;
+
+ state.pipes.splice(i, 1);
+ state.pipesCount -= 1;
+ if (state.pipesCount === 1)
+ state.pipes = state.pipes[0];
+
+ dest.emit('unpipe', this);
+
+ return this;
+};
+
+// set up data events if they are asked for
+// Ensure readable listeners eventually get something
+Readable.prototype.on = function(ev, fn) {
+ var res = Stream.prototype.on.call(this, ev, fn);
+
+ if (ev === 'data' && !this._readableState.flowing)
+ emitDataEvents(this);
+
+ if (ev === 'readable' && this.readable) {
+ var state = this._readableState;
+ if (!state.readableListening) {
+ state.readableListening = true;
+ state.emittedReadable = false;
+ state.needReadable = true;
+ if (!state.reading) {
+ this.read(0);
+ } else if (state.length) {
+ emitReadable(this, state);
+ }
+ }
+ }
+
+ return res;
+};
+Readable.prototype.addListener = Readable.prototype.on;
+
+// pause() and resume() are remnants of the legacy readable stream API
+// If the user uses them, then switch into old mode.
+Readable.prototype.resume = function() {
+ emitDataEvents(this);
+ this.read(0);
+ this.emit('resume');
+};
+
+Readable.prototype.pause = function() {
+ emitDataEvents(this, true);
+ this.emit('pause');
+};
+
+function emitDataEvents(stream, startPaused) {
+ var state = stream._readableState;
+
+ if (state.flowing) {
+ // https://github.com/isaacs/readable-stream/issues/16
+ throw new Error('Cannot switch to old mode now.');
+ }
+
+ var paused = startPaused || false;
+ var readable = false;
+
+ // convert to an old-style stream.
+ stream.readable = true;
+ stream.pipe = Stream.prototype.pipe;
+ stream.on = stream.addListener = Stream.prototype.on;
+
+ stream.on('readable', function() {
+ readable = true;
+
+ var c;
+ while (!paused && (null !== (c = stream.read())))
+ stream.emit('data', c);
+
+ if (c === null) {
+ readable = false;
+ stream._readableState.needReadable = true;
+ }
+ });
+
+ stream.pause = function() {
+ paused = true;
+ this.emit('pause');
+ };
+
+ stream.resume = function() {
+ paused = false;
+ if (readable)
+ setImmediate(function() {
+ stream.emit('readable');
+ });
+ else
+ this.read(0);
+ this.emit('resume');
+ };
+
+ // now make it start, just in case it hadn't already.
+ stream.emit('readable');
+}
+
+// wrap an old-style stream as the async data source.
+// This is *not* part of the readable stream interface.
+// It is an ugly unfortunate mess of history.
+Readable.prototype.wrap = function(stream) {
+ var state = this._readableState;
+ var paused = false;
+
+ var self = this;
+ stream.on('end', function() {
+ if (state.decoder && !state.ended) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length)
+ self.push(chunk);
+ }
+
+ self.push(null);
+ });
+
+ stream.on('data', function(chunk) {
+ if (state.decoder)
+ chunk = state.decoder.write(chunk);
+ if (!chunk || !state.objectMode && !chunk.length)
+ return;
+
+ var ret = self.push(chunk);
+ if (!ret) {
+ paused = true;
+ stream.pause();
+ }
+ });
+
+ // proxy all the other methods.
+ // important when wrapping filters and duplexes.
+ for (var i in stream) {
+ if (typeof stream[i] === 'function' &&
+ typeof this[i] === 'undefined') {
+ this[i] = function(method) { return function() {
+ return stream[method].apply(stream, arguments);
+ }}(i);
+ }
+ }
+
+ // proxy certain important events.
+ var events = ['error', 'close', 'destroy', 'pause', 'resume'];
+ forEach(events, function(ev) {
+ stream.on(ev, function (x) {
+ return self.emit.apply(self, ev, x);
+ });
+ });
+
+ // when we try to consume some more bytes, simply unpause the
+ // underlying stream.
+ self._read = function(n) {
+ if (paused) {
+ paused = false;
+ stream.resume();
+ }
+ };
+
+ return self;
+};
+
+
+
+// exposed for testing purposes only.
+Readable._fromList = fromList;
+
+// Pluck off n bytes from an array of buffers.
+// Length is the combined lengths of all the buffers in the list.
+function fromList(n, state) {
+ var list = state.buffer;
+ var length = state.length;
+ var stringMode = !!state.decoder;
+ var objectMode = !!state.objectMode;
+ var ret;
+
+ // nothing in the list, definitely empty.
+ if (list.length === 0)
+ return null;
+
+ if (length === 0)
+ ret = null;
+ else if (objectMode)
+ ret = list.shift();
+ else if (!n || n >= length) {
+ // read it all, truncate the array.
+ if (stringMode)
+ ret = list.join('');
+ else
+ ret = Buffer.concat(list, length);
+ list.length = 0;
+ } else {
+ // read just some of it.
+ if (n < list[0].length) {
+ // just take a part of the first list item.
+ // slice is the same for buffers and strings.
+ var buf = list[0];
+ ret = buf.slice(0, n);
+ list[0] = buf.slice(n);
+ } else if (n === list[0].length) {
+ // first list is a perfect match
+ ret = list.shift();
+ } else {
+ // complex case.
+ // we have enough to cover it, but it spans past the first buffer.
+ if (stringMode)
+ ret = '';
+ else
+ ret = new Buffer(n);
+
+ var c = 0;
+ for (var i = 0, l = list.length; i < l && c < n; i++) {
+ var buf = list[0];
+ var cpy = Math.min(n - c, buf.length);
+
+ if (stringMode)
+ ret += buf.slice(0, cpy);
+ else
+ buf.copy(ret, c, 0, cpy);
+
+ if (cpy < buf.length)
+ list[0] = buf.slice(cpy);
+ else
+ list.shift();
+
+ c += cpy;
+ }
+ }
+ }
+
+ return ret;
+}
+
+function endReadable(stream) {
+ var state = stream._readableState;
+
+ // If we get here before consuming all the bytes, then that is a
+ // bug in node. Should never happen.
+ if (state.length > 0)
+ throw new Error('endReadable called on non-empty stream');
+
+ if (!state.endEmitted && state.calledRead) {
+ state.ended = true;
+ setImmediate(function() {
+ // Check that we didn't get one last unshift.
+ if (!state.endEmitted && state.length === 0) {
+ state.endEmitted = true;
+ stream.readable = false;
+ stream.emit('end');
+ }
+ });
+ }
+}
+
+function forEach (xs, f) {
+ for (var i = 0, l = xs.length; i < l; i++) {
+ f(xs[i], i);
+ }
+}
+
+function indexOf (xs, x) {
+ for (var i = 0, l = xs.length; i < l; i++) {
+ if (xs[i] === x) return i;
+ }
+ return -1;
+}
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"./index.js":24,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"events":18,"inherits":33,"process/browser.js":25,"string_decoder":30}],28:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a transform stream is a readable/writable stream where you do
+// something with the data. Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored. (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation. For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes. When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up. When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer. When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks. If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk. However,
+// a pathological inflate type of transform can cause excessive buffering
+// here. For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output. In this case, you could write a very small
+// amount of input, and end up with a very large amount of output. In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform. A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
+
+module.exports = Transform;
+
+var Duplex = require('./duplex.js');
+var inherits = require('inherits');
+inherits(Transform, Duplex);
+
+
+function TransformState(options, stream) {
+ this.afterTransform = function(er, data) {
+ return afterTransform(stream, er, data);
+ };
+
+ this.needTransform = false;
+ this.transforming = false;
+ this.writecb = null;
+ this.writechunk = null;
+}
+
+function afterTransform(stream, er, data) {
+ var ts = stream._transformState;
+ ts.transforming = false;
+
+ var cb = ts.writecb;
+
+ if (!cb)
+ return stream.emit('error', new Error('no writecb in Transform class'));
+
+ ts.writechunk = null;
+ ts.writecb = null;
+
+ if (data !== null && data !== undefined)
+ stream.push(data);
+
+ if (cb)
+ cb(er);
+
+ var rs = stream._readableState;
+ rs.reading = false;
+ if (rs.needReadable || rs.length < rs.highWaterMark) {
+ stream._read(rs.highWaterMark);
+ }
+}
+
+
+function Transform(options) {
+ if (!(this instanceof Transform))
+ return new Transform(options);
+
+ Duplex.call(this, options);
+
+ var ts = this._transformState = new TransformState(options, this);
+
+ // when the writable side finishes, then flush out anything remaining.
+ var stream = this;
+
+ // start out asking for a readable event once data is transformed.
+ this._readableState.needReadable = true;
+
+ // we have implemented the _read method, and done the other things
+ // that Readable wants before the first _read call, so unset the
+ // sync guard flag.
+ this._readableState.sync = false;
+
+ this.once('finish', function() {
+ if ('function' === typeof this._flush)
+ this._flush(function(er) {
+ done(stream, er);
+ });
+ else
+ done(stream);
+ });
+}
+
+Transform.prototype.push = function(chunk, encoding) {
+ this._transformState.needTransform = false;
+ return Duplex.prototype.push.call(this, chunk, encoding);
+};
+
+// This is the part where you do stuff!
+// override this function in implementation classes.
+// 'chunk' is an input chunk.
+//
+// Call `push(newChunk)` to pass along transformed output
+// to the readable side. You may call 'push' zero or more times.
+//
+// Call `cb(err)` when you are done with this chunk. If you pass
+// an error, then that'll put the hurt on the whole operation. If you
+// never call cb(), then you'll never get another chunk.
+Transform.prototype._transform = function(chunk, encoding, cb) {
+ throw new Error('not implemented');
+};
+
+Transform.prototype._write = function(chunk, encoding, cb) {
+ var ts = this._transformState;
+ ts.writecb = cb;
+ ts.writechunk = chunk;
+ ts.writeencoding = encoding;
+ if (!ts.transforming) {
+ var rs = this._readableState;
+ if (ts.needTransform ||
+ rs.needReadable ||
+ rs.length < rs.highWaterMark)
+ this._read(rs.highWaterMark);
+ }
+};
+
+// Doesn't matter what the args are here.
+// _transform does all the work.
+// That we got here means that the readable side wants more data.
+Transform.prototype._read = function(n) {
+ var ts = this._transformState;
+
+ if (ts.writechunk && ts.writecb && !ts.transforming) {
+ ts.transforming = true;
+ this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+ } else {
+ // mark that we need a transform, so that any data that comes in
+ // will get processed, now that we've asked for it.
+ ts.needTransform = true;
+ }
+};
+
+
+function done(stream, er) {
+ if (er)
+ return stream.emit('error', er);
+
+ // if there's nothing in the write buffer, then that means
+ // that nothing more will ever be provided
+ var ws = stream._writableState;
+ var rs = stream._readableState;
+ var ts = stream._transformState;
+
+ if (ws.length)
+ throw new Error('calling transform done when ws.length != 0');
+
+ if (ts.transforming)
+ throw new Error('calling transform done when still transforming');
+
+ return stream.push(null);
+}
+
+},{"./duplex.js":23,"inherits":33}],29:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// A bit simpler than readable streams.
+// Implement an async ._write(chunk, cb), and it'll handle all
+// the drain event emission and buffering.
+
+module.exports = Writable;
+Writable.WritableState = WritableState;
+
+var isUint8Array = typeof Uint8Array !== 'undefined'
+ ? function (x) { return x instanceof Uint8Array }
+ : function (x) {
+ return x && x.constructor && x.constructor.name === 'Uint8Array'
+ }
+;
+var isArrayBuffer = typeof ArrayBuffer !== 'undefined'
+ ? function (x) { return x instanceof ArrayBuffer }
+ : function (x) {
+ return x && x.constructor && x.constructor.name === 'ArrayBuffer'
+ }
+;
+
+var inherits = require('inherits');
+var Stream = require('./index.js');
+var setImmediate = require('process/browser.js').nextTick;
+var Buffer = require('buffer').Buffer;
+
+inherits(Writable, Stream);
+
+function WriteReq(chunk, encoding, cb) {
+ this.chunk = chunk;
+ this.encoding = encoding;
+ this.callback = cb;
+}
+
+function WritableState(options, stream) {
+ options = options || {};
+
+ // the point at which write() starts returning false
+ // Note: 0 is a valid value, means that we always return false if
+ // the entire buffer is not flushed immediately on write()
+ var hwm = options.highWaterMark;
+ this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
+
+ // object stream flag to indicate whether or not this stream
+ // contains buffers or objects.
+ this.objectMode = !!options.objectMode;
+
+ // cast to ints.
+ this.highWaterMark = ~~this.highWaterMark;
+
+ this.needDrain = false;
+ // at the start of calling end()
+ this.ending = false;
+ // when end() has been called, and returned
+ this.ended = false;
+ // when 'finish' is emitted
+ this.finished = false;
+
+ // should we decode strings into buffers before passing to _write?
+ // this is here so that some node-core streams can optimize string
+ // handling at a lower level.
+ var noDecode = options.decodeStrings === false;
+ this.decodeStrings = !noDecode;
+
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+ // not an actual buffer we keep track of, but a measurement
+ // of how much we're waiting to get pushed to some underlying
+ // socket or file.
+ this.length = 0;
+
+ // a flag to see when we're in the middle of a write.
+ this.writing = false;
+
+ // a flag to be able to tell if the onwrite cb is called immediately,
+ // or on a later tick. We set this to true at first, becuase any
+ // actions that shouldn't happen until "later" should generally also
+ // not happen before the first write call.
+ this.sync = true;
+
+ // a flag to know if we're processing previously buffered items, which
+ // may call the _write() callback in the same tick, so that we don't
+ // end up in an overlapped onwrite situation.
+ this.bufferProcessing = false;
+
+ // the callback that's passed to _write(chunk,cb)
+ this.onwrite = function(er) {
+ onwrite(stream, er);
+ };
+
+ // the callback that the user supplies to write(chunk,encoding,cb)
+ this.writecb = null;
+
+ // the amount that is being written when _write is called.
+ this.writelen = 0;
+
+ this.buffer = [];
+}
+
+function Writable(options) {
+ // Writable ctor is applied to Duplexes, though they're not
+ // instanceof Writable, they're instanceof Readable.
+ if (!(this instanceof Writable) && !(this instanceof Stream.Duplex))
+ return new Writable(options);
+
+ this._writableState = new WritableState(options, this);
+
+ // legacy.
+ this.writable = true;
+
+ Stream.call(this);
+}
+
+// Otherwise people can pipe Writable streams, which is just wrong.
+Writable.prototype.pipe = function() {
+ this.emit('error', new Error('Cannot pipe. Not readable.'));
+};
+
+
+function writeAfterEnd(stream, state, cb) {
+ var er = new Error('write after end');
+ // TODO: defer error events consistently everywhere, not just the cb
+ stream.emit('error', er);
+ setImmediate(function() {
+ cb(er);
+ });
+}
+
+// If we get something that is not a buffer, string, null, or undefined,
+// and we're not in objectMode, then that's an error.
+// Otherwise stream chunks are all considered to be of length=1, and the
+// watermarks determine how many objects to keep in the buffer, rather than
+// how many bytes or characters.
+function validChunk(stream, state, chunk, cb) {
+ var valid = true;
+ if (!Buffer.isBuffer(chunk) &&
+ 'string' !== typeof chunk &&
+ chunk !== null &&
+ chunk !== undefined &&
+ !state.objectMode) {
+ var er = new TypeError('Invalid non-string/buffer chunk');
+ stream.emit('error', er);
+ setImmediate(function() {
+ cb(er);
+ });
+ valid = false;
+ }
+ return valid;
+}
+
+Writable.prototype.write = function(chunk, encoding, cb) {
+ var state = this._writableState;
+ var ret = false;
+
+ if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (!Buffer.isBuffer(chunk) && isUint8Array(chunk))
+ chunk = new Buffer(chunk);
+ if (isArrayBuffer(chunk) && typeof Uint8Array !== 'undefined')
+ chunk = new Buffer(new Uint8Array(chunk));
+
+ if (Buffer.isBuffer(chunk))
+ encoding = 'buffer';
+ else if (!encoding)
+ encoding = state.defaultEncoding;
+
+ if (typeof cb !== 'function')
+ cb = function() {};
+
+ if (state.ended)
+ writeAfterEnd(this, state, cb);
+ else if (validChunk(this, state, chunk, cb))
+ ret = writeOrBuffer(this, state, chunk, encoding, cb);
+
+ return ret;
+};
+
+function decodeChunk(state, chunk, encoding) {
+ if (!state.objectMode &&
+ state.decodeStrings !== false &&
+ typeof chunk === 'string') {
+ chunk = new Buffer(chunk, encoding);
+ }
+ return chunk;
+}
+
+// if we're already writing something, then just put this
+// in the queue, and wait our turn. Otherwise, call _write
+// If we return false, then we need a drain event, so set that flag.
+function writeOrBuffer(stream, state, chunk, encoding, cb) {
+ chunk = decodeChunk(state, chunk, encoding);
+ var len = state.objectMode ? 1 : chunk.length;
+
+ state.length += len;
+
+ var ret = state.length < state.highWaterMark;
+ state.needDrain = !ret;
+
+ if (state.writing)
+ state.buffer.push(new WriteReq(chunk, encoding, cb));
+ else
+ doWrite(stream, state, len, chunk, encoding, cb);
+
+ return ret;
+}
+
+function doWrite(stream, state, len, chunk, encoding, cb) {
+ state.writelen = len;
+ state.writecb = cb;
+ state.writing = true;
+ state.sync = true;
+ stream._write(chunk, encoding, state.onwrite);
+ state.sync = false;
+}
+
+function onwriteError(stream, state, sync, er, cb) {
+ if (sync)
+ setImmediate(function() {
+ cb(er);
+ });
+ else
+ cb(er);
+
+ stream.emit('error', er);
+}
+
+function onwriteStateUpdate(state) {
+ state.writing = false;
+ state.writecb = null;
+ state.length -= state.writelen;
+ state.writelen = 0;
+}
+
+function onwrite(stream, er) {
+ var state = stream._writableState;
+ var sync = state.sync;
+ var cb = state.writecb;
+
+ onwriteStateUpdate(state);
+
+ if (er)
+ onwriteError(stream, state, sync, er, cb);
+ else {
+ // Check if we're actually ready to finish, but don't emit yet
+ var finished = needFinish(stream, state);
+
+ if (!finished && !state.bufferProcessing && state.buffer.length)
+ clearBuffer(stream, state);
+
+ if (sync) {
+ setImmediate(function() {
+ afterWrite(stream, state, finished, cb);
+ });
+ } else {
+ afterWrite(stream, state, finished, cb);
+ }
+ }
+}
+
+function afterWrite(stream, state, finished, cb) {
+ if (!finished)
+ onwriteDrain(stream, state);
+ cb();
+ if (finished)
+ finishMaybe(stream, state);
+}
+
+// Must force callback to be called on nextTick, so that we don't
+// emit 'drain' before the write() consumer gets the 'false' return
+// value, and has a chance to attach a 'drain' listener.
+function onwriteDrain(stream, state) {
+ if (state.length === 0 && state.needDrain) {
+ state.needDrain = false;
+ stream.emit('drain');
+ }
+}
+
+
+// if there's something in the buffer waiting, then process it
+function clearBuffer(stream, state) {
+ state.bufferProcessing = true;
+
+ for (var c = 0; c < state.buffer.length; c++) {
+ var entry = state.buffer[c];
+ var chunk = entry.chunk;
+ var encoding = entry.encoding;
+ var cb = entry.callback;
+ var len = state.objectMode ? 1 : chunk.length;
+
+ doWrite(stream, state, len, chunk, encoding, cb);
+
+ // if we didn't call the onwrite immediately, then
+ // it means that we need to wait until it does.
+ // also, that means that the chunk and cb are currently
+ // being processed, so move the buffer counter past them.
+ if (state.writing) {
+ c++;
+ break;
+ }
+ }
+
+ state.bufferProcessing = false;
+ if (c < state.buffer.length)
+ state.buffer = state.buffer.slice(c);
+ else
+ state.buffer.length = 0;
+}
+
+Writable.prototype._write = function(chunk, encoding, cb) {
+ cb(new Error('not implemented'));
+};
+
+Writable.prototype.end = function(chunk, encoding, cb) {
+ var state = this._writableState;
+
+ if (typeof chunk === 'function') {
+ cb = chunk;
+ chunk = null;
+ encoding = null;
+ } else if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (typeof chunk !== 'undefined' && chunk !== null)
+ this.write(chunk, encoding);
+
+ // ignore unnecessary end() calls.
+ if (!state.ending && !state.finished)
+ endWritable(this, state, cb);
+};
+
+
+function needFinish(stream, state) {
+ return (state.ending &&
+ state.length === 0 &&
+ !state.finished &&
+ !state.writing);
+}
+
+function finishMaybe(stream, state) {
+ var need = needFinish(stream, state);
+ if (need) {
+ state.finished = true;
+ stream.emit('finish');
+ }
+ return need;
+}
+
+function endWritable(stream, state, cb) {
+ state.ending = true;
+ finishMaybe(stream, state);
+ if (cb) {
+ if (state.finished)
+ setImmediate(cb);
+ else
+ stream.once('finish', cb);
+ }
+ state.ended = true;
+}
+
+},{"./index.js":24,"buffer":20,"inherits":33,"process/browser.js":25}],30:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var Buffer = require('buffer').Buffer;
+
+function assertEncoding(encoding) {
+ if (encoding && !Buffer.isEncoding(encoding)) {
+ throw new Error('Unknown encoding: ' + encoding);
+ }
+}
+
+var StringDecoder = exports.StringDecoder = function(encoding) {
+ this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
+ assertEncoding(encoding);
+ switch (this.encoding) {
+ case 'utf8':
+ // CESU-8 represents each of Surrogate Pair by 3-bytes
+ this.surrogateSize = 3;
+ break;
+ case 'ucs2':
+ case 'utf16le':
+ // UTF-16 represents each of Surrogate Pair by 2-bytes
+ this.surrogateSize = 2;
+ this.detectIncompleteChar = utf16DetectIncompleteChar;
+ break;
+ case 'base64':
+ // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
+ this.surrogateSize = 3;
+ this.detectIncompleteChar = base64DetectIncompleteChar;
+ break;
+ default:
+ this.write = passThroughWrite;
+ return;
+ }
+
+ this.charBuffer = new Buffer(6);
+ this.charReceived = 0;
+ this.charLength = 0;
+};
+
+
+StringDecoder.prototype.write = function(buffer) {
+ var charStr = '';
+ var offset = 0;
+
+ // if our last write ended with an incomplete multibyte character
+ while (this.charLength) {
+ // determine how many remaining bytes this buffer has to offer for this char
+ var i = (buffer.length >= this.charLength - this.charReceived) ?
+ this.charLength - this.charReceived :
+ buffer.length;
+
+ // add the new bytes to the char buffer
+ buffer.copy(this.charBuffer, this.charReceived, offset, i);
+ this.charReceived += (i - offset);
+ offset = i;
+
+ if (this.charReceived < this.charLength) {
+ // still not enough chars in this buffer? wait for more ...
+ return '';
+ }
+
+ // get the character that was split
+ charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
+
+ // lead surrogate (D800-DBFF) is also the incomplete character
+ var charCode = charStr.charCodeAt(charStr.length - 1);
+ if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+ this.charLength += this.surrogateSize;
+ charStr = '';
+ continue;
+ }
+ this.charReceived = this.charLength = 0;
+
+ // if there are no more bytes in this buffer, just emit our char
+ if (i == buffer.length) return charStr;
+
+ // otherwise cut off the characters end from the beginning of this buffer
+ buffer = buffer.slice(i, buffer.length);
+ break;
+ }
+
+ var lenIncomplete = this.detectIncompleteChar(buffer);
+
+ var end = buffer.length;
+ if (this.charLength) {
+ // buffer the incomplete character bytes we got
+ buffer.copy(this.charBuffer, 0, buffer.length - lenIncomplete, end);
+ this.charReceived = lenIncomplete;
+ end -= lenIncomplete;
+ }
+
+ charStr += buffer.toString(this.encoding, 0, end);
+
+ var end = charStr.length - 1;
+ var charCode = charStr.charCodeAt(end);
+ // lead surrogate (D800-DBFF) is also the incomplete character
+ if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+ var size = this.surrogateSize;
+ this.charLength += size;
+ this.charReceived += size;
+ this.charBuffer.copy(this.charBuffer, size, 0, size);
+ this.charBuffer.write(charStr.charAt(charStr.length - 1), this.encoding);
+ return charStr.substring(0, end);
+ }
+
+ // or just emit the charStr
+ return charStr;
+};
+
+StringDecoder.prototype.detectIncompleteChar = function(buffer) {
+ // determine how many bytes we have to check at the end of this buffer
+ var i = (buffer.length >= 3) ? 3 : buffer.length;
+
+ // Figure out if one of the last i bytes of our buffer announces an
+ // incomplete char.
+ for (; i > 0; i--) {
+ var c = buffer[buffer.length - i];
+
+ // See http://en.wikipedia.org/wiki/UTF-8#Description
+
+ // 110XXXXX
+ if (i == 1 && c >> 5 == 0x06) {
+ this.charLength = 2;
+ break;
+ }
+
+ // 1110XXXX
+ if (i <= 2 && c >> 4 == 0x0E) {
+ this.charLength = 3;
+ break;
+ }
+
+ // 11110XXX
+ if (i <= 3 && c >> 3 == 0x1E) {
+ this.charLength = 4;
+ break;
+ }
+ }
+
+ return i;
+};
+
+StringDecoder.prototype.end = function(buffer) {
+ var res = '';
+ if (buffer && buffer.length)
+ res = this.write(buffer);
+
+ if (this.charReceived) {
+ var cr = this.charReceived;
+ var buf = this.charBuffer;
+ var enc = this.encoding;
+ res += buf.slice(0, cr).toString(enc);
+ }
+
+ return res;
+};
+
+function passThroughWrite(buffer) {
+ return buffer.toString(this.encoding);
+}
+
+function utf16DetectIncompleteChar(buffer) {
+ var incomplete = this.charReceived = buffer.length % 2;
+ this.charLength = incomplete ? 2 : 0;
+ return incomplete;
+}
+
+function base64DetectIncompleteChar(buffer) {
+ var incomplete = this.charReceived = buffer.length % 3;
+ this.charLength = incomplete ? 3 : 0;
+ return incomplete;
+}
+
+},{"buffer":20}],31:[function(require,module,exports){
+module.exports = function isBuffer(arg) {
+ return arg && typeof arg === 'object'
+ && typeof arg.copy === 'function'
+ && typeof arg.fill === 'function'
+ && typeof arg.readUInt8 === 'function';
+}
+},{}],32:[function(require,module,exports){
+(function (process,global){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var formatRegExp = /%[sdj%]/g;
+exports.format = function(f) {
+ if (!isString(f)) {
+ var objects = [];
+ for (var i = 0; i < arguments.length; i++) {
+ objects.push(inspect(arguments[i]));
+ }
+ return objects.join(' ');
+ }
+
+ var i = 1;
+ var args = arguments;
+ var len = args.length;
+ var str = String(f).replace(formatRegExp, function(x) {
+ if (x === '%%') return '%';
+ if (i >= len) return x;
+ switch (x) {
+ case '%s': return String(args[i++]);
+ case '%d': return Number(args[i++]);
+ case '%j':
+ try {
+ return JSON.stringify(args[i++]);
+ } catch (_) {
+ return '[Circular]';
+ }
+ default:
+ return x;
+ }
+ });
+ for (var x = args[i]; i < len; x = args[++i]) {
+ if (isNull(x) || !isObject(x)) {
+ str += ' ' + x;
+ } else {
+ str += ' ' + inspect(x);
+ }
+ }
+ return str;
+};
+
+
+// Mark that a method should not be used.
+// Returns a modified function which warns once by default.
+// If --no-deprecation is set, then it is a no-op.
+exports.deprecate = function(fn, msg) {
+ // Allow for deprecating things in the process of starting up.
+ if (isUndefined(global.process)) {
+ return function() {
+ return exports.deprecate(fn, msg).apply(this, arguments);
+ };
+ }
+
+ if (process.noDeprecation === true) {
+ return fn;
+ }
+
+ var warned = false;
+ function deprecated() {
+ if (!warned) {
+ if (process.throwDeprecation) {
+ throw new Error(msg);
+ } else if (process.traceDeprecation) {
+ console.trace(msg);
+ } else {
+ console.error(msg);
+ }
+ warned = true;
+ }
+ return fn.apply(this, arguments);
+ }
+
+ return deprecated;
+};
+
+
+var debugs = {};
+var debugEnviron;
+exports.debuglog = function(set) {
+ if (isUndefined(debugEnviron))
+ debugEnviron = process.env.NODE_DEBUG || '';
+ set = set.toUpperCase();
+ if (!debugs[set]) {
+ if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
+ var pid = process.pid;
+ debugs[set] = function() {
+ var msg = exports.format.apply(exports, arguments);
+ console.error('%s %d: %s', set, pid, msg);
+ };
+ } else {
+ debugs[set] = function() {};
+ }
+ }
+ return debugs[set];
+};
+
+
+/**
+ * Echos the value of a value. Trys to print the value out
+ * in the best way possible given the different types.
+ *
+ * @param {Object} obj The object to print out.
+ * @param {Object} opts Optional options object that alters the output.
+ */
+/* legacy: obj, showHidden, depth, colors*/
+function inspect(obj, opts) {
+ // default options
+ var ctx = {
+ seen: [],
+ stylize: stylizeNoColor
+ };
+ // legacy...
+ if (arguments.length >= 3) ctx.depth = arguments[2];
+ if (arguments.length >= 4) ctx.colors = arguments[3];
+ if (isBoolean(opts)) {
+ // legacy...
+ ctx.showHidden = opts;
+ } else if (opts) {
+ // got an "options" object
+ exports._extend(ctx, opts);
+ }
+ // set default options
+ if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+ if (isUndefined(ctx.depth)) ctx.depth = 2;
+ if (isUndefined(ctx.colors)) ctx.colors = false;
+ if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+ if (ctx.colors) ctx.stylize = stylizeWithColor;
+ return formatValue(ctx, obj, ctx.depth);
+}
+exports.inspect = inspect;
+
+
+// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+inspect.colors = {
+ 'bold' : [1, 22],
+ 'italic' : [3, 23],
+ 'underline' : [4, 24],
+ 'inverse' : [7, 27],
+ 'white' : [37, 39],
+ 'grey' : [90, 39],
+ 'black' : [30, 39],
+ 'blue' : [34, 39],
+ 'cyan' : [36, 39],
+ 'green' : [32, 39],
+ 'magenta' : [35, 39],
+ 'red' : [31, 39],
+ 'yellow' : [33, 39]
+};
+
+// Don't use 'blue' not visible on cmd.exe
+inspect.styles = {
+ 'special': 'cyan',
+ 'number': 'yellow',
+ 'boolean': 'yellow',
+ 'undefined': 'grey',
+ 'null': 'bold',
+ 'string': 'green',
+ 'date': 'magenta',
+ // "name": intentionally not styling
+ 'regexp': 'red'
+};
+
+
+function stylizeWithColor(str, styleType) {
+ var style = inspect.styles[styleType];
+
+ if (style) {
+ return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+ '\u001b[' + inspect.colors[style][1] + 'm';
+ } else {
+ return str;
+ }
+}
+
+
+function stylizeNoColor(str, styleType) {
+ return str;
+}
+
+
+function arrayToHash(array) {
+ var hash = {};
+
+ array.forEach(function(val, idx) {
+ hash[val] = true;
+ });
+
+ return hash;
+}
+
+
+function formatValue(ctx, value, recurseTimes) {
+ // Provide a hook for user-specified inspect functions.
+ // Check that value is an object with an inspect function on it
+ if (ctx.customInspect &&
+ value &&
+ isFunction(value.inspect) &&
+ // Filter out the util module, it's inspect function is special
+ value.inspect !== exports.inspect &&
+ // Also filter out any prototype objects using the circular check.
+ !(value.constructor && value.constructor.prototype === value)) {
+ var ret = value.inspect(recurseTimes, ctx);
+ if (!isString(ret)) {
+ ret = formatValue(ctx, ret, recurseTimes);
+ }
+ return ret;
+ }
+
+ // Primitive types cannot have properties
+ var primitive = formatPrimitive(ctx, value);
+ if (primitive) {
+ return primitive;
+ }
+
+ // Look up the keys of the object.
+ var keys = Object.keys(value);
+ var visibleKeys = arrayToHash(keys);
+
+ if (ctx.showHidden) {
+ keys = Object.getOwnPropertyNames(value);
+ }
+
+ // IE doesn't make error fields non-enumerable
+ // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
+ if (isError(value)
+ && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+ return formatError(value);
+ }
+
+ // Some type of object without properties can be shortcutted.
+ if (keys.length === 0) {
+ if (isFunction(value)) {
+ var name = value.name ? ': ' + value.name : '';
+ return ctx.stylize('[Function' + name + ']', 'special');
+ }
+ if (isRegExp(value)) {
+ return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+ }
+ if (isDate(value)) {
+ return ctx.stylize(Date.prototype.toString.call(value), 'date');
+ }
+ if (isError(value)) {
+ return formatError(value);
+ }
+ }
+
+ var base = '', array = false, braces = ['{', '}'];
+
+ // Make Array say that they are Array
+ if (isArray(value)) {
+ array = true;
+ braces = ['[', ']'];
+ }
+
+ // Make functions say that they are functions
+ if (isFunction(value)) {
+ var n = value.name ? ': ' + value.name : '';
+ base = ' [Function' + n + ']';
+ }
+
+ // Make RegExps say that they are RegExps
+ if (isRegExp(value)) {
+ base = ' ' + RegExp.prototype.toString.call(value);
+ }
+
+ // Make dates with properties first say the date
+ if (isDate(value)) {
+ base = ' ' + Date.prototype.toUTCString.call(value);
+ }
+
+ // Make error with message first say the error
+ if (isError(value)) {
+ base = ' ' + formatError(value);
+ }
+
+ if (keys.length === 0 && (!array || value.length == 0)) {
+ return braces[0] + base + braces[1];
+ }
+
+ if (recurseTimes < 0) {
+ if (isRegExp(value)) {
+ return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+ } else {
+ return ctx.stylize('[Object]', 'special');
+ }
+ }
+
+ ctx.seen.push(value);
+
+ var output;
+ if (array) {
+ output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+ } else {
+ output = keys.map(function(key) {
+ return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+ });
+ }
+
+ ctx.seen.pop();
+
+ return reduceToSingleString(output, base, braces);
+}
+
+
+function formatPrimitive(ctx, value) {
+ if (isUndefined(value))
+ return ctx.stylize('undefined', 'undefined');
+ if (isString(value)) {
+ var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+ .replace(/'/g, "\\'")
+ .replace(/\\"/g, '"') + '\'';
+ return ctx.stylize(simple, 'string');
+ }
+ if (isNumber(value))
+ return ctx.stylize('' + value, 'number');
+ if (isBoolean(value))
+ return ctx.stylize('' + value, 'boolean');
+ // For some reason typeof null is "object", so special case here.
+ if (isNull(value))
+ return ctx.stylize('null', 'null');
+}
+
+
+function formatError(value) {
+ return '[' + Error.prototype.toString.call(value) + ']';
+}
+
+
+function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+ var output = [];
+ for (var i = 0, l = value.length; i < l; ++i) {
+ if (hasOwnProperty(value, String(i))) {
+ output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+ String(i), true));
+ } else {
+ output.push('');
+ }
+ }
+ keys.forEach(function(key) {
+ if (!key.match(/^\d+$/)) {
+ output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+ key, true));
+ }
+ });
+ return output;
+}
+
+
+function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+ var name, str, desc;
+ desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+ if (desc.get) {
+ if (desc.set) {
+ str = ctx.stylize('[Getter/Setter]', 'special');
+ } else {
+ str = ctx.stylize('[Getter]', 'special');
+ }
+ } else {
+ if (desc.set) {
+ str = ctx.stylize('[Setter]', 'special');
+ }
+ }
+ if (!hasOwnProperty(visibleKeys, key)) {
+ name = '[' + key + ']';
+ }
+ if (!str) {
+ if (ctx.seen.indexOf(desc.value) < 0) {
+ if (isNull(recurseTimes)) {
+ str = formatValue(ctx, desc.value, null);
+ } else {
+ str = formatValue(ctx, desc.value, recurseTimes - 1);
+ }
+ if (str.indexOf('\n') > -1) {
+ if (array) {
+ str = str.split('\n').map(function(line) {
+ return ' ' + line;
+ }).join('\n').substr(2);
+ } else {
+ str = '\n' + str.split('\n').map(function(line) {
+ return ' ' + line;
+ }).join('\n');
+ }
+ }
+ } else {
+ str = ctx.stylize('[Circular]', 'special');
+ }
+ }
+ if (isUndefined(name)) {
+ if (array && key.match(/^\d+$/)) {
+ return str;
+ }
+ name = JSON.stringify('' + key);
+ if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+ name = name.substr(1, name.length - 2);
+ name = ctx.stylize(name, 'name');
+ } else {
+ name = name.replace(/'/g, "\\'")
+ .replace(/\\"/g, '"')
+ .replace(/(^"|"$)/g, "'");
+ name = ctx.stylize(name, 'string');
+ }
+ }
+
+ return name + ': ' + str;
+}
+
+
+function reduceToSingleString(output, base, braces) {
+ var numLinesEst = 0;
+ var length = output.reduce(function(prev, cur) {
+ numLinesEst++;
+ if (cur.indexOf('\n') >= 0) numLinesEst++;
+ return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+ }, 0);
+
+ if (length > 60) {
+ return braces[0] +
+ (base === '' ? '' : base + '\n ') +
+ ' ' +
+ output.join(',\n ') +
+ ' ' +
+ braces[1];
+ }
+
+ return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+}
+
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+function isArray(ar) {
+ return Array.isArray(ar);
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+ return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+ return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+ return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+ return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+ return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+ return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+ return isObject(re) && objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+ return isObject(d) && objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+ return isObject(e) &&
+ (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+ return arg === null ||
+ typeof arg === 'boolean' ||
+ typeof arg === 'number' ||
+ typeof arg === 'string' ||
+ typeof arg === 'symbol' || // ES6 symbol
+ typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+exports.isBuffer = require('./support/isBuffer');
+
+function objectToString(o) {
+ return Object.prototype.toString.call(o);
+}
+
+
+function pad(n) {
+ return n < 10 ? '0' + n.toString(10) : n.toString(10);
+}
+
+
+var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+ 'Oct', 'Nov', 'Dec'];
+
+// 26 Feb 16:19:34
+function timestamp() {
+ var d = new Date();
+ var time = [pad(d.getHours()),
+ pad(d.getMinutes()),
+ pad(d.getSeconds())].join(':');
+ return [d.getDate(), months[d.getMonth()], time].join(' ');
+}
+
+
+// log is just a thin wrapper to console.log that prepends a timestamp
+exports.log = function() {
+ console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+};
+
+
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * The Function.prototype.inherits from lang.js rewritten as a standalone
+ * function (not on Function.prototype). NOTE: If this file is to be loaded
+ * during bootstrapping this function needs to be rewritten using some native
+ * functions as prototype setup using normal JavaScript does not work as
+ * expected during bootstrapping (see mirror.js in r114903).
+ *
+ * @param {function} ctor Constructor function which needs to inherit the
+ * prototype.
+ * @param {function} superCtor Constructor function to inherit prototype from.
+ */
+exports.inherits = require('inherits');
+
+exports._extend = function(origin, add) {
+ // Don't do anything if add isn't an object
+ if (!add || !isObject(add)) return origin;
+
+ var keys = Object.keys(add);
+ var i = keys.length;
+ while (i--) {
+ origin[keys[i]] = add[keys[i]];
+ }
+ return origin;
+};
+
+function hasOwnProperty(obj, prop) {
+ return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./support/isBuffer":31,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"inherits":33}],33:[function(require,module,exports){
+if (typeof Object.create === 'function') {
+ // implementation from standard node.js 'util' module
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor
+ ctor.prototype = Object.create(superCtor.prototype, {
+ constructor: {
+ value: ctor,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ });
+ };
+} else {
+ // old school shim for old browsers
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor
+ var TempCtor = function () {}
+ TempCtor.prototype = superCtor.prototype
+ ctor.prototype = new TempCtor()
+ ctor.prototype.constructor = ctor
+ }
+}
+
+},{}],34:[function(require,module,exports){
+function addOperation (type, key, value, options) {
+ var operation = {
+ type: type,
+ key: key,
+ value: value,
+ options: options
+ }
+
+ if (options && options.prefix) {
+ operation.prefix = options.prefix
+ delete options.prefix
+ }
+
+ this._operations.push(operation)
+
+ return this
+}
+
+function Batch(sdb) {
+ this._operations = []
+ this._sdb = sdb
+
+ this.put = addOperation.bind(this, 'put')
+ this.del = addOperation.bind(this, 'del')
+}
+
+var B = Batch.prototype
+
+
+B.clear = function () {
+ this._operations = []
+}
+
+B.write = function (cb) {
+ this._sdb.batch(this._operations, cb)
+}
+
+module.exports = Batch
+
+},{}],35:[function(require,module,exports){
+(function (process){
+var EventEmitter = require('events').EventEmitter
+var next = process.nextTick
+var SubDb = require('./sub')
+var Batch = require('./batch')
+var fixRange = require('level-fix-range')
+
+var Hooks = require('level-hooks')
+
+module.exports = function (_db, options) {
+ function DB () {}
+ DB.prototype = _db
+ var db = new DB()
+
+ if (db.sublevel) return db
+
+ options = options || {}
+
+ //use \xff (255) as the seperator,
+ //so that sections of the database will sort after the regular keys
+ var sep = options.sep = options.sep || '\xff'
+ db._options = options
+
+ Hooks(db)
+
+ db.sublevels = {}
+
+ db.sublevel = function (prefix, options) {
+ if(db.sublevels[prefix])
+ return db.sublevels[prefix]
+ return new SubDb(db, prefix, options || this._options)
+ }
+
+ db.methods = {}
+
+ db.prefix = function (key) {
+ return '' + (key || '')
+ }
+
+ db.pre = function (range, hook) {
+ if(!hook)
+ hook = range, range = {
+ max : sep
+ }
+ return db.hooks.pre(range, hook)
+ }
+
+ db.post = function (range, hook) {
+ if(!hook)
+ hook = range, range = {
+ max : sep
+ }
+ return db.hooks.post(range, hook)
+ }
+
+ function safeRange(fun) {
+ return function (opts) {
+ opts = opts || {}
+ opts = fixRange(opts)
+
+ if(opts.reverse) opts.start = opts.start || sep
+ else opts.end = opts.end || sep
+
+ return fun.call(db, opts)
+ }
+ }
+
+ db.readStream =
+ db.createReadStream = safeRange(db.createReadStream)
+ db.keyStream =
+ db.createKeyStream = safeRange(db.createKeyStream)
+ db.valuesStream =
+ db.createValueStream = safeRange(db.createValueStream)
+
+ var batch = db.batch
+ db.batch = function (changes, opts, cb) {
+ if(!Array.isArray(changes))
+ return new Batch(db)
+ changes.forEach(function (e) {
+ if(e.prefix) {
+ if('function' === typeof e.prefix.prefix)
+ e.key = e.prefix.prefix(e.key)
+ else if('string' === typeof e.prefix)
+ e.key = e.prefix + e.key
+ }
+ })
+ batch.call(db, changes, opts, cb)
+ }
+ return db
+}
+
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"./batch":34,"./sub":46,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"events":18,"level-fix-range":36,"level-hooks":38}],36:[function(require,module,exports){
+var clone = require('clone')
+
+module.exports =
+function fixRange(opts) {
+ opts = clone(opts)
+
+ var reverse = opts.reverse
+ var end = opts.max || opts.end
+ var start = opts.min || opts.start
+
+ var range = [start, end]
+ if(start != null && end != null)
+ range.sort()
+ if(reverse)
+ range = range.reverse()
+
+ opts.start = range[0]
+ opts.end = range[1]
+
+ delete opts.min
+ delete opts.max
+
+ return opts
+}
+
+},{"clone":37}],37:[function(require,module,exports){
+(function (Buffer){
+'use strict';
+
+function objectToString(o) {
+ return Object.prototype.toString.call(o);
+}
+
+// shim for Node's 'util' package
+// DO NOT REMOVE THIS! It is required for compatibility with EnderJS (http://enderjs.com/).
+var util = {
+ isArray: function (ar) {
+ return Array.isArray(ar) || (typeof ar === 'object' && objectToString(ar) === '[object Array]');
+ },
+ isDate: function (d) {
+ return typeof d === 'object' && objectToString(d) === '[object Date]';
+ },
+ isRegExp: function (re) {
+ return typeof re === 'object' && objectToString(re) === '[object RegExp]';
+ },
+ getRegExpFlags: function (re) {
+ var flags = '';
+ re.global && (flags += 'g');
+ re.ignoreCase && (flags += 'i');
+ re.multiline && (flags += 'm');
+ return flags;
+ }
+};
+
+
+if (typeof module === 'object')
+ module.exports = clone;
+
+/**
+ * Clones (copies) an Object using deep copying.
+ *
+ * This function supports circular references by default, but if you are certain
+ * there are no circular references in your object, you can save some CPU time
+ * by calling clone(obj, false).
+ *
+ * Caution: if `circular` is false and `parent` contains circular references,
+ * your program may enter an infinite loop and crash.
+ *
+ * @param `parent` - the object to be cloned
+ * @param `circular` - set to true if the object to be cloned may contain
+ * circular references. (optional - true by default)
+ * @param `depth` - set to a number if the object is only to be cloned to
+ * a particular depth. (optional - defaults to Infinity)
+ * @param `prototype` - sets the prototype to be used when cloning an object.
+ * (optional - defaults to parent prototype).
+*/
+
+function clone(parent, circular, depth, prototype) {
+ // maintain two arrays for circular references, where corresponding parents
+ // and children have the same index
+ var allParents = [];
+ var allChildren = [];
+
+ var useBuffer = typeof Buffer != 'undefined';
+
+ if (typeof circular == 'undefined')
+ circular = true;
+
+ if (typeof depth == 'undefined')
+ depth = Infinity;
+
+ // recurse this function so we don't reset allParents and allChildren
+ function _clone(parent, depth) {
+ // cloning null always returns null
+ if (parent === null)
+ return null;
+
+ if (depth == 0)
+ return parent;
+
+ var child;
+ if (typeof parent != 'object') {
+ return parent;
+ }
+
+ if (util.isArray(parent)) {
+ child = [];
+ } else if (util.isRegExp(parent)) {
+ child = new RegExp(parent.source, util.getRegExpFlags(parent));
+ if (parent.lastIndex) child.lastIndex = parent.lastIndex;
+ } else if (util.isDate(parent)) {
+ child = new Date(parent.getTime());
+ } else if (useBuffer && Buffer.isBuffer(parent)) {
+ child = new Buffer(parent.length);
+ parent.copy(child);
+ return child;
+ } else {
+ if (typeof prototype == 'undefined') child = Object.create(Object.getPrototypeOf(parent));
+ else child = Object.create(prototype);
+ }
+
+ if (circular) {
+ var index = allParents.indexOf(parent);
+
+ if (index != -1) {
+ return allChildren[index];
+ }
+ allParents.push(parent);
+ allChildren.push(child);
+ }
+
+ for (var i in parent) {
+ child[i] = _clone(parent[i], depth - 1);
+ }
+
+ return child;
+ }
+
+ return _clone(parent, depth);
+}
+
+/**
+ * Simple flat clone using prototype, accepts only objects, usefull for property
+ * override on FLAT configuration object (no nested props).
+ *
+ * USE WITH CAUTION! This may not behave as you wish if you do not know how this
+ * works.
+ */
+clone.clonePrototype = function(parent) {
+ if (parent === null)
+ return null;
+
+ var c = function () {};
+ c.prototype = parent;
+ return new c();
+};
+
+}).call(this,require("buffer").Buffer)
+},{"buffer":20}],38:[function(require,module,exports){
+var ranges = require('string-range')
+
+module.exports = function (db) {
+
+ if(db.hooks) {
+ return
+ }
+
+ var posthooks = []
+ var prehooks = []
+
+ function getPrefix (p) {
+ return p && (
+ 'string' === typeof p ? p
+ : 'string' === typeof p.prefix ? p.prefix
+ : 'function' === typeof p.prefix ? p.prefix()
+ : ''
+ )
+ }
+
+ function getKeyEncoding (db) {
+ if(db && db._getKeyEncoding)
+ return db._getKeyEncoding(db)
+ }
+
+ function getValueEncoding (db) {
+ if(db && db._getValueEncoding)
+ return db._getValueEncoding(db)
+ }
+
+ function remover (array, item) {
+ return function () {
+ var i = array.indexOf(item)
+ if(!~i) return false
+ array.splice(i, 1)
+ return true
+ }
+ }
+
+ db.hooks = {
+ post: function (prefix, hook) {
+ if(!hook) hook = prefix, prefix = ''
+ var h = {test: ranges.checker(prefix), hook: hook}
+ posthooks.push(h)
+ return remover(posthooks, h)
+ },
+ pre: function (prefix, hook) {
+ if(!hook) hook = prefix, prefix = ''
+ var h = {
+ test: ranges.checker(prefix),
+ hook: hook,
+ safe: false !== prefix.safe
+ }
+ prehooks.push(h)
+ return remover(prehooks, h)
+ },
+ posthooks: posthooks,
+ prehooks: prehooks
+ }
+
+ //POST HOOKS
+
+ function each (e) {
+ if(e && e.type) {
+ posthooks.forEach(function (h) {
+ if(h.test(e.key)) h.hook(e)
+ })
+ }
+ }
+
+ db.on('put', function (key, val) {
+ each({type: 'put', key: key, value: val})
+ })
+ db.on('del', function (key, val) {
+ each({type: 'del', key: key, value: val})
+ })
+ db.on('batch', function onBatch (ary) {
+ ary.forEach(each)
+ })
+
+ //PRE HOOKS
+
+ var put = db.put
+ var del = db.del
+ var batch = db.batch
+
+ function callHooks (isBatch, b, opts, cb) {
+ try {
+ b.forEach(function hook(e, i) {
+ prehooks.forEach(function (h) {
+ if(h.test(String(e.key))) {
+ //optimize this?
+ //maybe faster to not create a new object each time?
+ //have one object and expose scope to it?
+ var context = {
+ add: function (ch, db) {
+ if(typeof ch === 'undefined') {
+ return this
+ }
+ if(ch === false)
+ return delete b[i]
+ var prefix = (
+ getPrefix(ch.prefix) ||
+ getPrefix(db) ||
+ h.prefix || ''
+ )
+ //don't leave a circular json object there incase using multilevel.
+ if(prefix) ch.prefix = prefix
+ ch.key = prefix + ch.key
+ if(h.safe && h.test(String(ch.key))) {
+ //this usually means a stack overflow.
+ throw new Error('prehook cannot insert into own range')
+ }
+ var ke = ch.keyEncoding || getKeyEncoding(ch.prefix)
+ var ve = ch.valueEncoding || getValueEncoding(ch.prefix)
+ if(ke) ch.keyEncoding = ke
+ if(ve) ch.valueEncoding = ve
+
+ b.push(ch)
+ hook(ch, b.length - 1)
+ return this
+ },
+ put: function (ch, db) {
+ if('object' === typeof ch) ch.type = 'put'
+ return this.add(ch, db)
+ },
+ del: function (ch, db) {
+ if('object' === typeof ch) ch.type = 'del'
+ return this.add(ch, db)
+ },
+ veto: function () {
+ return this.add(false)
+ }
+ }
+ h.hook.call(context, e, context.add, b)
+ }
+ })
+ })
+ } catch (err) {
+ return (cb || opts)(err)
+ }
+ b = b.filter(function (e) {
+ return e && e.type //filter out empty items
+ })
+
+ if(b.length == 1 && !isBatch) {
+ var change = b[0]
+ return change.type == 'put'
+ ? put.call(db, change.key, change.value, opts, cb)
+ : del.call(db, change.key, opts, cb)
+ }
+ return batch.call(db, b, opts, cb)
+ }
+
+ db.put = function (key, value, opts, cb ) {
+ var batch = [{key: key, value: value, type: 'put'}]
+ return callHooks(false, batch, opts, cb)
+ }
+
+ db.del = function (key, opts, cb) {
+ var batch = [{key: key, type: 'del'}]
+ return callHooks(false, batch, opts, cb)
+ }
+
+ db.batch = function (batch, opts, cb) {
+ return callHooks(true, batch, opts, cb)
+ }
+}
+
+},{"string-range":39}],39:[function(require,module,exports){
+
+//force to a valid range
+var range = exports.range = function (obj) {
+ return null == obj ? {} : 'string' === typeof range ? {
+ min: range, max: range + '\xff'
+ } : obj
+}
+
+//turn into a sub range.
+var prefix = exports.prefix = function (range, within, term) {
+ range = exports.range(range)
+ var _range = {}
+ term = term || '\xff'
+ if(range instanceof RegExp || 'function' == typeof range) {
+ _range.min = within
+ _range.max = within + term,
+ _range.inner = function (k) {
+ var j = k.substring(within.length)
+ if(range.test)
+ return range.test(j)
+ return range(j)
+ }
+ }
+ else if('object' === typeof range) {
+ _range.min = within + (range.min || range.start || '')
+ _range.max = within + (range.max || range.end || (term || '~'))
+ _range.reverse = !!range.reverse
+ }
+ return _range
+}
+
+//return a function that checks a range
+var checker = exports.checker = function (range) {
+ if(!range) range = {}
+
+ if ('string' === typeof range)
+ return function (key) {
+ return key.indexOf(range) == 0
+ }
+ else if(range instanceof RegExp)
+ return function (key) {
+ return range.test(key)
+ }
+ else if('object' === typeof range)
+ return function (key) {
+ var min = range.min || range.start
+ var max = range.max || range.end
+
+ // fixes keys passed as ints from sublevels
+ key = String(key)
+
+ return (
+ !min || key >= min
+ ) && (
+ !max || key <= max
+ ) && (
+ !range.inner || (
+ range.inner.test
+ ? range.inner.test(key)
+ : range.inner(key)
+ )
+ )
+ }
+ else if('function' === typeof range)
+ return range
+}
+//check if a key is within a range.
+var satifies = exports.satisfies = function (key, range) {
+ return checker(range)(key)
+}
+
+
+
+},{}],40:[function(require,module,exports){
+module.exports = hasKeys
+
+function hasKeys(source) {
+ return source !== null &&
+ (typeof source === "object" ||
+ typeof source === "function")
+}
+
+},{}],41:[function(require,module,exports){
+var Keys = require("object-keys")
+var hasKeys = require("./has-keys")
+
+module.exports = extend
+
+function extend() {
+ var target = {}
+
+ for (var i = 0; i < arguments.length; i++) {
+ var source = arguments[i]
+
+ if (!hasKeys(source)) {
+ continue
+ }
+
+ var keys = Keys(source)
+
+ for (var j = 0; j < keys.length; j++) {
+ var name = keys[j]
+ target[name] = source[name]
+ }
+ }
+
+ return target
+}
+
+},{"./has-keys":40,"object-keys":42}],42:[function(require,module,exports){
+module.exports = Object.keys || require('./shim');
+
+
+},{"./shim":45}],43:[function(require,module,exports){
+
+var hasOwn = Object.prototype.hasOwnProperty;
+var toString = Object.prototype.toString;
+
+module.exports = function forEach (obj, fn, ctx) {
+ if (toString.call(fn) !== '[object Function]') {
+ throw new TypeError('iterator must be a function');
+ }
+ var l = obj.length;
+ if (l === +l) {
+ for (var i = 0; i < l; i++) {
+ fn.call(ctx, obj[i], i, obj);
+ }
+ } else {
+ for (var k in obj) {
+ if (hasOwn.call(obj, k)) {
+ fn.call(ctx, obj[k], k, obj);
+ }
+ }
+ }
+};
+
+
+},{}],44:[function(require,module,exports){
+
+/**!
+ * is
+ * the definitive JavaScript type testing library
+ *
+ * @copyright 2013 Enrico Marino
+ * @license MIT
+ */
+
+var objProto = Object.prototype;
+var owns = objProto.hasOwnProperty;
+var toString = objProto.toString;
+var isActualNaN = function (value) {
+ return value !== value;
+};
+var NON_HOST_TYPES = {
+ "boolean": 1,
+ "number": 1,
+ "string": 1,
+ "undefined": 1
+};
+
+/**
+ * Expose `is`
+ */
+
+var is = module.exports = {};
+
+/**
+ * Test general.
+ */
+
+/**
+ * is.type
+ * Test if `value` is a type of `type`.
+ *
+ * @param {Mixed} value value to test
+ * @param {String} type type
+ * @return {Boolean} true if `value` is a type of `type`, false otherwise
+ * @api public
+ */
+
+is.a =
+is.type = function (value, type) {
+ return typeof value === type;
+};
+
+/**
+ * is.defined
+ * Test if `value` is defined.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if 'value' is defined, false otherwise
+ * @api public
+ */
+
+is.defined = function (value) {
+ return value !== undefined;
+};
+
+/**
+ * is.empty
+ * Test if `value` is empty.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is empty, false otherwise
+ * @api public
+ */
+
+is.empty = function (value) {
+ var type = toString.call(value);
+ var key;
+
+ if ('[object Array]' === type || '[object Arguments]' === type) {
+ return value.length === 0;
+ }
+
+ if ('[object Object]' === type) {
+ for (key in value) if (owns.call(value, key)) return false;
+ return true;
+ }
+
+ if ('[object String]' === type) {
+ return '' === value;
+ }
+
+ return false;
+};
+
+/**
+ * is.equal
+ * Test if `value` is equal to `other`.
+ *
+ * @param {Mixed} value value to test
+ * @param {Mixed} other value to compare with
+ * @return {Boolean} true if `value` is equal to `other`, false otherwise
+ */
+
+is.equal = function (value, other) {
+ var type = toString.call(value)
+ var key;
+
+ if (type !== toString.call(other)) {
+ return false;
+ }
+
+ if ('[object Object]' === type) {
+ for (key in value) {
+ if (!is.equal(value[key], other[key])) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ if ('[object Array]' === type) {
+ key = value.length;
+ if (key !== other.length) {
+ return false;
+ }
+ while (--key) {
+ if (!is.equal(value[key], other[key])) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ if ('[object Function]' === type) {
+ return value.prototype === other.prototype;
+ }
+
+ if ('[object Date]' === type) {
+ return value.getTime() === other.getTime();
+ }
+
+ return value === other;
+};
+
+/**
+ * is.hosted
+ * Test if `value` is hosted by `host`.
+ *
+ * @param {Mixed} value to test
+ * @param {Mixed} host host to test with
+ * @return {Boolean} true if `value` is hosted by `host`, false otherwise
+ * @api public
+ */
+
+is.hosted = function (value, host) {
+ var type = typeof host[value];
+ return type === 'object' ? !!host[value] : !NON_HOST_TYPES[type];
+};
+
+/**
+ * is.instance
+ * Test if `value` is an instance of `constructor`.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an instance of `constructor`
+ * @api public
+ */
+
+is.instance = is['instanceof'] = function (value, constructor) {
+ return value instanceof constructor;
+};
+
+/**
+ * is.null
+ * Test if `value` is null.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is null, false otherwise
+ * @api public
+ */
+
+is['null'] = function (value) {
+ return value === null;
+};
+
+/**
+ * is.undefined
+ * Test if `value` is undefined.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is undefined, false otherwise
+ * @api public
+ */
+
+is.undefined = function (value) {
+ return value === undefined;
+};
+
+/**
+ * Test arguments.
+ */
+
+/**
+ * is.arguments
+ * Test if `value` is an arguments object.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an arguments object, false otherwise
+ * @api public
+ */
+
+is.arguments = function (value) {
+ var isStandardArguments = '[object Arguments]' === toString.call(value);
+ var isOldArguments = !is.array(value) && is.arraylike(value) && is.object(value) && is.fn(value.callee);
+ return isStandardArguments || isOldArguments;
+};
+
+/**
+ * Test array.
+ */
+
+/**
+ * is.array
+ * Test if 'value' is an array.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an array, false otherwise
+ * @api public
+ */
+
+is.array = function (value) {
+ return '[object Array]' === toString.call(value);
+};
+
+/**
+ * is.arguments.empty
+ * Test if `value` is an empty arguments object.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an empty arguments object, false otherwise
+ * @api public
+ */
+is.arguments.empty = function (value) {
+ return is.arguments(value) && value.length === 0;
+};
+
+/**
+ * is.array.empty
+ * Test if `value` is an empty array.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an empty array, false otherwise
+ * @api public
+ */
+is.array.empty = function (value) {
+ return is.array(value) && value.length === 0;
+};
+
+/**
+ * is.arraylike
+ * Test if `value` is an arraylike object.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an arguments object, false otherwise
+ * @api public
+ */
+
+is.arraylike = function (value) {
+ return !!value && !is.boolean(value)
+ && owns.call(value, 'length')
+ && isFinite(value.length)
+ && is.number(value.length)
+ && value.length >= 0;
+};
+
+/**
+ * Test boolean.
+ */
+
+/**
+ * is.boolean
+ * Test if `value` is a boolean.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a boolean, false otherwise
+ * @api public
+ */
+
+is.boolean = function (value) {
+ return '[object Boolean]' === toString.call(value);
+};
+
+/**
+ * is.false
+ * Test if `value` is false.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is false, false otherwise
+ * @api public
+ */
+
+is['false'] = function (value) {
+ return is.boolean(value) && (value === false || value.valueOf() === false);
+};
+
+/**
+ * is.true
+ * Test if `value` is true.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is true, false otherwise
+ * @api public
+ */
+
+is['true'] = function (value) {
+ return is.boolean(value) && (value === true || value.valueOf() === true);
+};
+
+/**
+ * Test date.
+ */
+
+/**
+ * is.date
+ * Test if `value` is a date.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a date, false otherwise
+ * @api public
+ */
+
+is.date = function (value) {
+ return '[object Date]' === toString.call(value);
+};
+
+/**
+ * Test element.
+ */
+
+/**
+ * is.element
+ * Test if `value` is an html element.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an HTML Element, false otherwise
+ * @api public
+ */
+
+is.element = function (value) {
+ return value !== undefined
+ && typeof HTMLElement !== 'undefined'
+ && value instanceof HTMLElement
+ && value.nodeType === 1;
+};
+
+/**
+ * Test error.
+ */
+
+/**
+ * is.error
+ * Test if `value` is an error object.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an error object, false otherwise
+ * @api public
+ */
+
+is.error = function (value) {
+ return '[object Error]' === toString.call(value);
+};
+
+/**
+ * Test function.
+ */
+
+/**
+ * is.fn / is.function (deprecated)
+ * Test if `value` is a function.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a function, false otherwise
+ * @api public
+ */
+
+is.fn = is['function'] = function (value) {
+ var isAlert = typeof window !== 'undefined' && value === window.alert;
+ return isAlert || '[object Function]' === toString.call(value);
+};
+
+/**
+ * Test number.
+ */
+
+/**
+ * is.number
+ * Test if `value` is a number.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a number, false otherwise
+ * @api public
+ */
+
+is.number = function (value) {
+ return '[object Number]' === toString.call(value);
+};
+
+/**
+ * is.infinite
+ * Test if `value` is positive or negative infinity.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is positive or negative Infinity, false otherwise
+ * @api public
+ */
+is.infinite = function (value) {
+ return value === Infinity || value === -Infinity;
+};
+
+/**
+ * is.decimal
+ * Test if `value` is a decimal number.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a decimal number, false otherwise
+ * @api public
+ */
+
+is.decimal = function (value) {
+ return is.number(value) && !isActualNaN(value) && !is.infinite(value) && value % 1 !== 0;
+};
+
+/**
+ * is.divisibleBy
+ * Test if `value` is divisible by `n`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} n dividend
+ * @return {Boolean} true if `value` is divisible by `n`, false otherwise
+ * @api public
+ */
+
+is.divisibleBy = function (value, n) {
+ var isDividendInfinite = is.infinite(value);
+ var isDivisorInfinite = is.infinite(n);
+ var isNonZeroNumber = is.number(value) && !isActualNaN(value) && is.number(n) && !isActualNaN(n) && n !== 0;
+ return isDividendInfinite || isDivisorInfinite || (isNonZeroNumber && value % n === 0);
+};
+
+/**
+ * is.int
+ * Test if `value` is an integer.
+ *
+ * @param value to test
+ * @return {Boolean} true if `value` is an integer, false otherwise
+ * @api public
+ */
+
+is.int = function (value) {
+ return is.number(value) && !isActualNaN(value) && value % 1 === 0;
+};
+
+/**
+ * is.maximum
+ * Test if `value` is greater than 'others' values.
+ *
+ * @param {Number} value value to test
+ * @param {Array} others values to compare with
+ * @return {Boolean} true if `value` is greater than `others` values
+ * @api public
+ */
+
+is.maximum = function (value, others) {
+ if (isActualNaN(value)) {
+ throw new TypeError('NaN is not a valid value');
+ } else if (!is.arraylike(others)) {
+ throw new TypeError('second argument must be array-like');
+ }
+ var len = others.length;
+
+ while (--len >= 0) {
+ if (value < others[len]) {
+ return false;
+ }
+ }
+
+ return true;
+};
+
+/**
+ * is.minimum
+ * Test if `value` is less than `others` values.
+ *
+ * @param {Number} value value to test
+ * @param {Array} others values to compare with
+ * @return {Boolean} true if `value` is less than `others` values
+ * @api public
+ */
+
+is.minimum = function (value, others) {
+ if (isActualNaN(value)) {
+ throw new TypeError('NaN is not a valid value');
+ } else if (!is.arraylike(others)) {
+ throw new TypeError('second argument must be array-like');
+ }
+ var len = others.length;
+
+ while (--len >= 0) {
+ if (value > others[len]) {
+ return false;
+ }
+ }
+
+ return true;
+};
+
+/**
+ * is.nan
+ * Test if `value` is not a number.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is not a number, false otherwise
+ * @api public
+ */
+
+is.nan = function (value) {
+ return !is.number(value) || value !== value;
+};
+
+/**
+ * is.even
+ * Test if `value` is an even number.
+ *
+ * @param {Number} value value to test
+ * @return {Boolean} true if `value` is an even number, false otherwise
+ * @api public
+ */
+
+is.even = function (value) {
+ return is.infinite(value) || (is.number(value) && value === value && value % 2 === 0);
+};
+
+/**
+ * is.odd
+ * Test if `value` is an odd number.
+ *
+ * @param {Number} value value to test
+ * @return {Boolean} true if `value` is an odd number, false otherwise
+ * @api public
+ */
+
+is.odd = function (value) {
+ return is.infinite(value) || (is.number(value) && value === value && value % 2 !== 0);
+};
+
+/**
+ * is.ge
+ * Test if `value` is greater than or equal to `other`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} other value to compare with
+ * @return {Boolean}
+ * @api public
+ */
+
+is.ge = function (value, other) {
+ if (isActualNaN(value) || isActualNaN(other)) {
+ throw new TypeError('NaN is not a valid value');
+ }
+ return !is.infinite(value) && !is.infinite(other) && value >= other;
+};
+
+/**
+ * is.gt
+ * Test if `value` is greater than `other`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} other value to compare with
+ * @return {Boolean}
+ * @api public
+ */
+
+is.gt = function (value, other) {
+ if (isActualNaN(value) || isActualNaN(other)) {
+ throw new TypeError('NaN is not a valid value');
+ }
+ return !is.infinite(value) && !is.infinite(other) && value > other;
+};
+
+/**
+ * is.le
+ * Test if `value` is less than or equal to `other`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} other value to compare with
+ * @return {Boolean} if 'value' is less than or equal to 'other'
+ * @api public
+ */
+
+is.le = function (value, other) {
+ if (isActualNaN(value) || isActualNaN(other)) {
+ throw new TypeError('NaN is not a valid value');
+ }
+ return !is.infinite(value) && !is.infinite(other) && value <= other;
+};
+
+/**
+ * is.lt
+ * Test if `value` is less than `other`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} other value to compare with
+ * @return {Boolean} if `value` is less than `other`
+ * @api public
+ */
+
+is.lt = function (value, other) {
+ if (isActualNaN(value) || isActualNaN(other)) {
+ throw new TypeError('NaN is not a valid value');
+ }
+ return !is.infinite(value) && !is.infinite(other) && value < other;
+};
+
+/**
+ * is.within
+ * Test if `value` is within `start` and `finish`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} start lower bound
+ * @param {Number} finish upper bound
+ * @return {Boolean} true if 'value' is is within 'start' and 'finish'
+ * @api public
+ */
+is.within = function (value, start, finish) {
+ if (isActualNaN(value) || isActualNaN(start) || isActualNaN(finish)) {
+ throw new TypeError('NaN is not a valid value');
+ } else if (!is.number(value) || !is.number(start) || !is.number(finish)) {
+ throw new TypeError('all arguments must be numbers');
+ }
+ var isAnyInfinite = is.infinite(value) || is.infinite(start) || is.infinite(finish);
+ return isAnyInfinite || (value >= start && value <= finish);
+};
+
+/**
+ * Test object.
+ */
+
+/**
+ * is.object
+ * Test if `value` is an object.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an object, false otherwise
+ * @api public
+ */
+
+is.object = function (value) {
+ return value && '[object Object]' === toString.call(value);
+};
+
+/**
+ * is.hash
+ * Test if `value` is a hash - a plain object literal.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a hash, false otherwise
+ * @api public
+ */
+
+is.hash = function (value) {
+ return is.object(value) && value.constructor === Object && !value.nodeType && !value.setInterval;
+};
+
+/**
+ * Test regexp.
+ */
+
+/**
+ * is.regexp
+ * Test if `value` is a regular expression.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a regexp, false otherwise
+ * @api public
+ */
+
+is.regexp = function (value) {
+ return '[object RegExp]' === toString.call(value);
+};
+
+/**
+ * Test string.
+ */
+
+/**
+ * is.string
+ * Test if `value` is a string.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if 'value' is a string, false otherwise
+ * @api public
+ */
+
+is.string = function (value) {
+ return '[object String]' === toString.call(value);
+};
+
+
+},{}],45:[function(require,module,exports){
+(function () {
+ "use strict";
+
+ // modified from https://github.com/kriskowal/es5-shim
+ var has = Object.prototype.hasOwnProperty,
+ is = require('is'),
+ forEach = require('foreach'),
+ hasDontEnumBug = !({'toString': null}).propertyIsEnumerable('toString'),
+ dontEnums = [
+ "toString",
+ "toLocaleString",
+ "valueOf",
+ "hasOwnProperty",
+ "isPrototypeOf",
+ "propertyIsEnumerable",
+ "constructor"
+ ],
+ keysShim;
+
+ keysShim = function keys(object) {
+ if (!is.object(object) && !is.array(object)) {
+ throw new TypeError("Object.keys called on a non-object");
+ }
+
+ var name, theKeys = [];
+ for (name in object) {
+ if (has.call(object, name)) {
+ theKeys.push(name);
+ }
+ }
+
+ if (hasDontEnumBug) {
+ forEach(dontEnums, function (dontEnum) {
+ if (has.call(object, dontEnum)) {
+ theKeys.push(dontEnum);
+ }
+ });
+ }
+ return theKeys;
+ };
+
+ module.exports = keysShim;
+}());
+
+
+},{"foreach":43,"is":44}],46:[function(require,module,exports){
+var EventEmitter = require('events').EventEmitter
+var inherits = require('util').inherits
+var ranges = require('string-range')
+var fixRange = require('level-fix-range')
+var xtend = require('xtend')
+var Batch = require('./batch')
+
+inherits(SubDB, EventEmitter)
+
+function SubDB (db, prefix, options) {
+ if('string' === typeof options) {
+ console.error('db.sublevel(name, seperator<string>) is depreciated')
+ console.error('use db.sublevel(name, {sep: separator})) if you must')
+ options = {sep: options}
+ }
+ if(!(this instanceof SubDB)) return new SubDB(db, prefix, options)
+ if(!db) throw new Error('must provide db')
+ if(!prefix) throw new Error('must provide prefix')
+
+ options = options || {}
+ options.sep = options.sep || '\xff'
+
+ this._parent = db
+ this._options = options
+ this.options = options
+ this._prefix = prefix
+ this._root = root(this)
+ db.sublevels[prefix] = this
+ this.sublevels = {}
+ this.methods = {}
+ var self = this
+ this.hooks = {
+ pre: function () {
+ return self.pre.apply(self, arguments)
+ },
+ post: function () {
+ return self.post.apply(self, arguments)
+ }
+ }
+}
+
+var SDB = SubDB.prototype
+
+SDB._key = function (key) {
+ var sep = this._options.sep
+ return sep
+ + this._prefix
+ + sep
+ + key
+}
+
+SDB._getOptsAndCb = function (opts, cb) {
+ if (typeof opts == 'function') {
+ cb = opts
+ opts = {}
+ }
+ return { opts: xtend(opts, this._options), cb: cb }
+}
+
+SDB.sublevel = function (prefix, options) {
+ if(this.sublevels[prefix])
+ return this.sublevels[prefix]
+ return new SubDB(this, prefix, options || this._options)
+}
+
+SDB.put = function (key, value, opts, cb) {
+ var res = this._getOptsAndCb(opts, cb)
+ this._root.put(this.prefix(key), value, res.opts, res.cb)
+}
+
+SDB.get = function (key, opts, cb) {
+ var res = this._getOptsAndCb(opts, cb)
+ this._root.get(this.prefix(key), res.opts, res.cb)
+}
+
+SDB.del = function (key, opts, cb) {
+ var res = this._getOptsAndCb(opts, cb)
+ this._root.del(this.prefix(key), res.opts, res.cb)
+}
+
+SDB.batch = function (changes, opts, cb) {
+ if(!Array.isArray(changes))
+ return new Batch(this)
+ var self = this,
+ res = this._getOptsAndCb(opts, cb)
+ changes.forEach(function (ch) {
+
+ //OH YEAH, WE NEED TO VALIDATE THAT UPDATING THIS KEY/PREFIX IS ALLOWED
+ if('string' === typeof ch.prefix)
+ ch.key = ch.prefix + ch.key
+ else
+ ch.key = (ch.prefix || self).prefix(ch.key)
+
+ if(ch.prefix) ch.prefix = null
+ })
+ this._root.batch(changes, res.opts, res.cb)
+}
+
+SDB._getKeyEncoding = function () {
+ if(this.options.keyEncoding)
+ return this.options.keyEncoding
+ if(this._parent && this._parent._getKeyEncoding)
+ return this._parent._getKeyEncoding()
+}
+
+SDB._getValueEncoding = function () {
+ if(this.options.valueEncoding)
+ return this.options.valueEncoding
+ if(this._parent && this._parent._getValueEncoding)
+ return this._parent._getValueEncoding()
+}
+
+SDB.prefix = function (key) {
+ var sep = this._options.sep
+ return this._parent.prefix() + sep + this._prefix + sep + (key || '')
+}
+
+SDB.keyStream =
+SDB.createKeyStream = function (opts) {
+ opts = opts || {}
+ opts.keys = true
+ opts.values = false
+ return this.createReadStream(opts)
+}
+
+SDB.valueStream =
+SDB.createValueStream = function (opts) {
+ opts = opts || {}
+ opts.keys = false
+ opts.values = true
+ opts.keys = false
+ return this.createReadStream(opts)
+}
+
+function selectivelyMerge(_opts, opts) {
+ [ 'valueEncoding'
+ , 'encoding'
+ , 'keyEncoding'
+ , 'reverse'
+ , 'values'
+ , 'keys'
+ , 'limit'
+ , 'fillCache'
+ ]
+ .forEach(function (k) {
+ if (opts.hasOwnProperty(k)) _opts[k] = opts[k]
+ })
+}
+
+SDB.readStream =
+SDB.createReadStream = function (opts) {
+ opts = opts || {}
+ var r = root(this)
+ var p = this.prefix()
+
+ var _opts = ranges.prefix(opts, p)
+ selectivelyMerge(_opts, xtend(opts, this._options))
+
+ var s = r.createReadStream(_opts)
+
+ if(_opts.values === false) {
+ var read = s.read
+ if (read) {
+ s.read = function (size) {
+ var val = read.call(this, size)
+ if (val) val = val.substring(p.length)
+ return val
+ }
+ } else {
+ var emit = s.emit
+ s.emit = function (event, val) {
+ if(event === 'data') {
+ emit.call(this, 'data', val.substring(p.length))
+ } else
+ emit.call(this, event, val)
+ }
+ }
+ return s
+ } else if(_opts.keys === false)
+ return s
+ else {
+ var read = s.read
+ if (read) {
+ s.read = function (size) {
+ var d = read.call(this, size)
+ if (d) d.key = d.key.substring(p.length)
+ return d
+ }
+ } else {
+ s.on('data', function (d) {
+ //mutate the prefix!
+ //this doesn't work for createKeyStream admittedly.
+ d.key = d.key.substring(p.length)
+ })
+ }
+ return s
+ }
+}
+
+
+SDB.writeStream =
+SDB.createWriteStream = function () {
+ var r = root(this)
+ var p = this.prefix()
+ var ws = r.createWriteStream.apply(r, arguments)
+ var write = ws.write
+
+ var encoding = this._options.encoding
+ var valueEncoding = this._options.valueEncoding
+ var keyEncoding = this._options.keyEncoding
+
+ // slight optimization, if no encoding was specified at all,
+ // which will be the case most times, make write not check at all
+ var nocheck = !encoding && !valueEncoding && !keyEncoding
+
+ ws.write = nocheck
+ ? function (data) {
+ data.key = p + data.key
+ return write.call(ws, data)
+ }
+ : function (data) {
+ data.key = p + data.key
+
+ // not merging all options here since this happens on every write and things could get slowed down
+ // at this point we only consider encoding important to propagate
+ if (encoding && typeof data.encoding === 'undefined')
+ data.encoding = encoding
+ if (valueEncoding && typeof data.valueEncoding === 'undefined')
+ data.valueEncoding = valueEncoding
+ if (keyEncoding && typeof data.keyEncoding === 'undefined')
+ data.keyEncoding = keyEncoding
+
+ return write.call(ws, data)
+ }
+ return ws
+}
+
+SDB.approximateSize = function () {
+ var r = root(db)
+ return r.approximateSize.apply(r, arguments)
+}
+
+function root(db) {
+ if(!db._parent) return db
+ return root(db._parent)
+}
+
+SDB.pre = function (range, hook) {
+ if(!hook) hook = range, range = null
+ range = ranges.prefix(range, this.prefix(), this._options.sep)
+ var r = root(this._parent)
+ var p = this.prefix()
+ return r.hooks.pre(fixRange(range), function (ch, add, batch) {
+ hook({
+ key: ch.key.substring(p.length),
+ value: ch.value,
+ type: ch.type
+ }, function (ch, _p) {
+ //maybe remove the second add arg now
+ //that op can have prefix?
+ add(ch, ch.prefix ? _p : (_p || p))
+ }, batch)
+ })
+}
+
+SDB.post = function (range, hook) {
+ if(!hook) hook = range, range = null
+ var r = root(this._parent)
+ var p = this.prefix()
+ range = ranges.prefix(range, p, this._options.sep)
+ return r.hooks.post(fixRange(range), function (data) {
+ hook({key: data.key.substring(p.length), value: data.value, type: data.type})
+ })
+}
+
+var exports = module.exports = SubDB
+
+
+},{"./batch":34,"events":18,"level-fix-range":36,"string-range":39,"util":32,"xtend":41}],47:[function(require,module,exports){
+/* Copyright (c) 2012-2014 LevelUP contributors
+ * See list at <https://github.com/rvagg/node-levelup#contributing>
+ * MIT License
+ * <https://github.com/rvagg/node-levelup/blob/master/LICENSE.md>
+ */
+
+var util = require('./util')
+ , WriteError = require('./errors').WriteError
+
+ , getOptions = util.getOptions
+ , dispatchError = util.dispatchError
+
+function Batch (levelup) {
+ this._levelup = levelup
+ this.batch = levelup.db.batch()
+ this.ops = []
+}
+
+Batch.prototype.put = function (key_, value_, options) {
+ options = getOptions(this._levelup, options)
+
+ var key = util.encodeKey(key_, options)
+ , value = util.encodeValue(value_, options)
+
+ try {
+ this.batch.put(key, value)
+ } catch (e) {
+ throw new WriteError(e)
+ }
+ this.ops.push({ type : 'put', key : key, value : value })
+
+ return this
+}
+
+Batch.prototype.del = function (key_, options) {
+ options = getOptions(this._levelup, options)
+
+ var key = util.encodeKey(key_, options)
+
+ try {
+ this.batch.del(key)
+ } catch (err) {
+ throw new WriteError(err)
+ }
+ this.ops.push({ type : 'del', key : key })
+
+ return this
+}
+
+Batch.prototype.clear = function () {
+ try {
+ this.batch.clear()
+ } catch (err) {
+ throw new WriteError(err)
+ }
+
+ this.ops = []
+ return this
+}
+
+Batch.prototype.write = function (callback) {
+ var levelup = this._levelup
+ , ops = this.ops
+
+ try {
+ this.batch.write(function (err) {
+ if (err)
+ return dispatchError(levelup, new WriteError(err), callback)
+ levelup.emit('batch', ops)
+ if (callback)
+ callback()
+ })
+ } catch (err) {
+ throw new WriteError(err)
+ }
+}
+
+module.exports = Batch
+
+},{"./errors":48,"./util":51}],48:[function(require,module,exports){
+/* Copyright (c) 2012-2014 LevelUP contributors
+ * See list at <https://github.com/rvagg/node-levelup#contributing>
+ * MIT License
+ * <https://github.com/rvagg/node-levelup/blob/master/LICENSE.md>
+ */
+
+var createError = require('errno').create
+ , LevelUPError = createError('LevelUPError')
+ , NotFoundError = createError('NotFoundError', LevelUPError)
+
+NotFoundError.prototype.notFound = true
+NotFoundError.prototype.status = 404
+
+module.exports = {
+ LevelUPError : LevelUPError
+ , InitializationError : createError('InitializationError', LevelUPError)
+ , OpenError : createError('OpenError', LevelUPError)
+ , ReadError : createError('ReadError', LevelUPError)
+ , WriteError : createError('WriteError', LevelUPError)
+ , NotFoundError : NotFoundError
+ , EncodingError : createError('EncodingError', LevelUPError)
+}
+
+},{"errno":59}],49:[function(require,module,exports){
+(function (process){
+/* Copyright (c) 2012-2014 LevelUP contributors
+ * See list at <https://github.com/rvagg/node-levelup#contributing>
+ * MIT License
+ * <https://github.com/rvagg/node-levelup/blob/master/LICENSE.md>
+ */
+
+var EventEmitter = require('events').EventEmitter
+ , inherits = require('util').inherits
+ , extend = require('xtend')
+ , prr = require('prr')
+ , DeferredLevelDOWN = require('deferred-leveldown')
+
+ , WriteError = require('./errors').WriteError
+ , ReadError = require('./errors').ReadError
+ , NotFoundError = require('./errors').NotFoundError
+ , OpenError = require('./errors').OpenError
+ , EncodingError = require('./errors').EncodingError
+ , InitializationError = require('./errors').InitializationError
+
+ , ReadStream = require('./read-stream')
+ , WriteStream = require('./write-stream')
+ , util = require('./util')
+ , Batch = require('./batch')
+
+ , getOptions = util.getOptions
+ , defaultOptions = util.defaultOptions
+ , getLevelDOWN = util.getLevelDOWN
+ , dispatchError = util.dispatchError
+
+function getCallback (options, callback) {
+ return typeof options == 'function' ? options : callback
+}
+
+// Possible LevelUP#_status values:
+// - 'new' - newly created, not opened or closed
+// - 'opening' - waiting for the database to be opened, post open()
+// - 'open' - successfully opened the database, available for use
+// - 'closing' - waiting for the database to be closed, post close()
+// - 'closed' - database has been successfully closed, should not be
+// used except for another open() operation
+
+function LevelUP (location, options, callback) {
+ if (!(this instanceof LevelUP))
+ return new LevelUP(location, options, callback)
+
+ var error
+
+ EventEmitter.call(this)
+ this.setMaxListeners(Infinity)
+
+ if (typeof location == 'function') {
+ options = typeof options == 'object' ? options : {}
+ options.db = location
+ location = null
+ } else if (typeof location == 'object' && typeof location.db == 'function') {
+ options = location
+ location = null
+ }
+
+ if (typeof options == 'function') {
+ callback = options
+ options = {}
+ }
+
+ if ((!options || typeof options.db != 'function') && typeof location != 'string') {
+ error = new InitializationError(
+ 'Must provide a location for the database')
+ if (callback) {
+ return process.nextTick(function () {
+ callback(error)
+ })
+ }
+ throw error
+ }
+
+ options = getOptions(this, options)
+ this.options = extend(defaultOptions, options)
+ this._status = 'new'
+ // set this.location as enumerable but not configurable or writable
+ prr(this, 'location', location, 'e')
+
+ this.open(callback)
+}
+
+inherits(LevelUP, EventEmitter)
+
+LevelUP.prototype.open = function (callback) {
+ var self = this
+ , dbFactory
+ , db
+
+ if (this.isOpen()) {
+ if (callback)
+ process.nextTick(function () { callback(null, self) })
+ return this
+ }
+
+ if (this._isOpening()) {
+ return callback && this.once(
+ 'open'
+ , function () { callback(null, self) }
+ )
+ }
+
+ this.emit('opening')
+
+ this._status = 'opening'
+ this.db = new DeferredLevelDOWN(this.location)
+ dbFactory = this.options.db || getLevelDOWN()
+ db = dbFactory(this.location)
+
+ db.open(this.options, function (err) {
+ if (err) {
+ return dispatchError(self, new OpenError(err), callback)
+ } else {
+ self.db.setDb(db)
+ self.db = db
+ self._status = 'open'
+ if (callback)
+ callback(null, self)
+ self.emit('open')
+ self.emit('ready')
+ }
+ })
+}
+
+LevelUP.prototype.close = function (callback) {
+ var self = this
+
+ if (this.isOpen()) {
+ this._status = 'closing'
+ this.db.close(function () {
+ self._status = 'closed'
+ self.emit('closed')
+ if (callback)
+ callback.apply(null, arguments)
+ })
+ this.emit('closing')
+ this.db = null
+ } else if (this._status == 'closed' && callback) {
+ return process.nextTick(callback)
+ } else if (this._status == 'closing' && callback) {
+ this.once('closed', callback)
+ } else if (this._isOpening()) {
+ this.once('open', function () {
+ self.close(callback)
+ })
+ }
+}
+
+LevelUP.prototype.isOpen = function () {
+ return this._status == 'open'
+}
+
+LevelUP.prototype._isOpening = function () {
+ return this._status == 'opening'
+}
+
+LevelUP.prototype.isClosed = function () {
+ return (/^clos/).test(this._status)
+}
+
+LevelUP.prototype.get = function (key_, options, callback) {
+ var self = this
+ , key
+
+ callback = getCallback(options, callback)
+
+ if (typeof callback != 'function') {
+ return dispatchError(
+ this
+ , new ReadError('get() requires key and callback arguments')
+ )
+ }
+
+ if (!this._isOpening() && !this.isOpen()) {
+ return dispatchError(
+ this
+ , new ReadError('Database is not open')
+ , callback
+ )
+ }
+
+ options = util.getOptions(this, options)
+ key = util.encodeKey(key_, options)
+
+ options.asBuffer = util.isValueAsBuffer(options)
+
+ this.db.get(key, options, function (err, value) {
+ if (err) {
+ if ((/notfound/i).test(err)) {
+ err = new NotFoundError(
+ 'Key not found in database [' + key_ + ']', err)
+ } else {
+ err = new ReadError(err)
+ }
+ return dispatchError(self, err, callback)
+ }
+ if (callback) {
+ try {
+ value = util.decodeValue(value, options)
+ } catch (e) {
+ return callback(new EncodingError(e))
+ }
+ callback(null, value)
+ }
+ })
+}
+
+LevelUP.prototype.put = function (key_, value_, options, callback) {
+ var self = this
+ , key
+ , value
+
+ callback = getCallback(options, callback)
+
+ if (key_ === null || key_ === undefined
+ || value_ === null || value_ === undefined) {
+ return dispatchError(
+ this
+ , new WriteError('put() requires key and value arguments')
+ , callback
+ )
+ }
+
+ if (!this._isOpening() && !this.isOpen()) {
+ return dispatchError(
+ this
+ , new WriteError('Database is not open')
+ , callback
+ )
+ }
+
+ options = getOptions(this, options)
+ key = util.encodeKey(key_, options)
+ value = util.encodeValue(value_, options)
+
+ this.db.put(key, value, options, function (err) {
+ if (err) {
+ return dispatchError(self, new WriteError(err), callback)
+ } else {
+ self.emit('put', key_, value_)
+ if (callback)
+ callback()
+ }
+ })
+}
+
+LevelUP.prototype.del = function (key_, options, callback) {
+ var self = this
+ , key
+
+ callback = getCallback(options, callback)
+
+ if (key_ === null || key_ === undefined) {
+ return dispatchError(
+ this
+ , new WriteError('del() requires a key argument')
+ , callback
+ )
+ }
+
+ if (!this._isOpening() && !this.isOpen()) {
+ return dispatchError(
+ this
+ , new WriteError('Database is not open')
+ , callback
+ )
+ }
+
+ options = getOptions(this, options)
+ key = util.encodeKey(key_, options)
+
+ this.db.del(key, options, function (err) {
+ if (err) {
+ return dispatchError(self, new WriteError(err), callback)
+ } else {
+ self.emit('del', key_)
+ if (callback)
+ callback()
+ }
+ })
+}
+
+LevelUP.prototype.batch = function (arr_, options, callback) {
+ var self = this
+ , keyEnc
+ , valueEnc
+ , arr
+
+ if (!arguments.length)
+ return new Batch(this)
+
+ callback = getCallback(options, callback)
+
+ if (!Array.isArray(arr_)) {
+ return dispatchError(
+ this
+ , new WriteError('batch() requires an array argument')
+ , callback
+ )
+ }
+
+ if (!this._isOpening() && !this.isOpen()) {
+ return dispatchError(
+ this
+ , new WriteError('Database is not open')
+ , callback
+ )
+ }
+
+ options = getOptions(this, options)
+ keyEnc = options.keyEncoding
+ valueEnc = options.valueEncoding
+
+ arr = arr_.map(function (e) {
+ if (e.type === undefined || e.key === undefined)
+ return {}
+
+ // inherit encoding
+ var kEnc = e.keyEncoding || keyEnc
+ , vEnc = e.valueEncoding || e.encoding || valueEnc
+ , o
+
+ // If we're not dealing with plain utf8 strings or plain
+ // Buffers then we have to do some work on the array to
+ // encode the keys and/or values. This includes JSON types.
+
+ if (kEnc != 'utf8' && kEnc != 'binary'
+ || vEnc != 'utf8' && vEnc != 'binary') {
+ o = {
+ type: e.type
+ , key: util.encodeKey(e.key, options, e)
+ }
+
+ if (e.value !== undefined)
+ o.value = util.encodeValue(e.value, options, e)
+
+ return o
+ } else {
+ return e
+ }
+ })
+
+ this.db.batch(arr, options, function (err) {
+ if (err) {
+ return dispatchError(self, new WriteError(err), callback)
+ } else {
+ self.emit('batch', arr_)
+ if (callback)
+ callback()
+ }
+ })
+}
+
+// DEPRECATED: prefer accessing LevelDOWN for this: db.db.approximateSize()
+LevelUP.prototype.approximateSize = function (start_, end_, callback) {
+ var self = this
+ , start
+ , end
+
+ if (start_ === null || start_ === undefined
+ || end_ === null || end_ === undefined
+ || typeof callback != 'function') {
+ return dispatchError(
+ this
+ , new ReadError('approximateSize() requires start, end and callback arguments')
+ , callback
+ )
+ }
+
+ start = util.encodeKey(start_, this.options)
+ end = util.encodeKey(end_, this.options)
+
+ if (!this._isOpening() && !this.isOpen()) {
+ return dispatchError(
+ this
+ , new WriteError('Database is not open')
+ , callback
+ )
+ }
+
+ this.db.approximateSize(start, end, function (err, size) {
+ if (err) {
+ return dispatchError(self, new OpenError(err), callback)
+ } else if (callback) {
+ callback(null, size)
+ }
+ })
+}
+
+LevelUP.prototype.readStream =
+LevelUP.prototype.createReadStream = function (options) {
+ var self = this
+ options = extend(this.options, options)
+ return new ReadStream(
+ options
+ , this
+ , function (options) {
+ return self.db.iterator(options)
+ }
+ )
+}
+
+LevelUP.prototype.keyStream =
+LevelUP.prototype.createKeyStream = function (options) {
+ return this.createReadStream(extend(options, { keys: true, values: false }))
+}
+
+LevelUP.prototype.valueStream =
+LevelUP.prototype.createValueStream = function (options) {
+ return this.createReadStream(extend(options, { keys: false, values: true }))
+}
+
+LevelUP.prototype.writeStream =
+LevelUP.prototype.createWriteStream = function (options) {
+ return new WriteStream(extend(options), this)
+}
+
+LevelUP.prototype.toString = function () {
+ return 'LevelUP'
+}
+
+function utilStatic (name) {
+ return function (location, callback) {
+ getLevelDOWN()[name](location, callback || function () {})
+ }
+}
+
+module.exports = LevelUP
+module.exports.copy = util.copy
+// DEPRECATED: prefer accessing LevelDOWN for this: require('leveldown').destroy()
+module.exports.destroy = utilStatic('destroy')
+// DEPRECATED: prefer accessing LevelDOWN for this: require('leveldown').repair()
+module.exports.repair = utilStatic('repair')
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"./batch":47,"./errors":48,"./read-stream":50,"./util":51,"./write-stream":52,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"deferred-leveldown":54,"events":18,"prr":60,"util":32,"xtend":70}],50:[function(require,module,exports){
+/* Copyright (c) 2012-2014 LevelUP contributors
+ * See list at <https://github.com/rvagg/node-levelup#contributing>
+ * MIT License <https://github.com/rvagg/node-levelup/blob/master/LICENSE.md>
+ */
+
+// NOTE: we are fixed to readable-stream@1.0.x for now
+// for pure Streams2 across Node versions
+var Readable = require('readable-stream').Readable
+ , inherits = require('util').inherits
+ , extend = require('xtend')
+ , EncodingError = require('./errors').EncodingError
+ , util = require('./util')
+
+ , defaultOptions = { keys: true, values: true }
+
+ , makeKeyValueData = function (key, value) {
+ return {
+ key: util.decodeKey(key, this._options)
+ , value: util.decodeValue(value, this._options)
+ }
+ }
+ , makeKeyData = function (key) {
+ return util.decodeKey(key, this._options)
+ }
+ , makeValueData = function (_, value) {
+ return util.decodeValue(value, this._options)
+ }
+ , makeNoData = function () { return null }
+
+function ReadStream (options, db, iteratorFactory) {
+ if (!(this instanceof ReadStream))
+ return new ReadStream(options, db, iteratorFactory)
+
+ Readable.call(this, { objectMode: true, highWaterMark: options.highWaterMark })
+
+ // purely to keep `db` around until we're done so it's not GCed if the user doesn't keep a ref
+ this._db = db
+
+ options = this._options = extend(defaultOptions, options)
+
+ this._keyEncoding = options.keyEncoding || options.encoding
+ this._valueEncoding = options.valueEncoding || options.encoding
+
+ if (typeof this._options.start != 'undefined')
+ this._options.start = util.encodeKey(this._options.start, this._options)
+ if (typeof this._options.end != 'undefined')
+ this._options.end = util.encodeKey(this._options.end, this._options)
+ if (typeof this._options.limit != 'number')
+ this._options.limit = -1
+
+ this._options.keyAsBuffer = util.isKeyAsBuffer(this._options)
+
+ this._options.valueAsBuffer = util.isValueAsBuffer(this._options)
+
+ this._makeData = this._options.keys && this._options.values
+ ? makeKeyValueData : this._options.keys
+ ? makeKeyData : this._options.values
+ ? makeValueData : makeNoData
+
+ var self = this
+ if (!this._db.isOpen()) {
+ this._db.once('ready', function () {
+ if (!self._destroyed) {
+ self._iterator = iteratorFactory(self._options)
+ }
+ })
+ } else
+ this._iterator = iteratorFactory(this._options)
+}
+
+inherits(ReadStream, Readable)
+
+ReadStream.prototype._read = function read () {
+ var self = this
+ if (!self._db.isOpen()) {
+ return self._db.once('ready', function () { read.call(self) })
+ }
+ if (self._destroyed)
+ return
+
+ self._iterator.next(function(err, key, value) {
+ if (err || (key === undefined && value === undefined)) {
+ if (!err && !self._destroyed)
+ self.push(null)
+ return self._cleanup(err)
+ }
+
+ try {
+ value = self._makeData(key, value)
+ } catch (e) {
+ return self._cleanup(new EncodingError(e))
+ }
+ if (!self._destroyed)
+ self.push(value)
+ })
+}
+
+ReadStream.prototype._cleanup = function (err) {
+ if (this._destroyed)
+ return
+
+ this._destroyed = true
+
+ var self = this
+ if (err)
+ self.emit('error', err)
+
+ if (self._iterator) {
+ self._iterator.end(function () {
+ self._iterator = null
+ self.emit('close')
+ })
+ } else {
+ self.emit('close')
+ }
+}
+
+ReadStream.prototype.destroy = function () {
+ this._cleanup()
+}
+
+ReadStream.prototype.toString = function () {
+ return 'LevelUP.ReadStream'
+}
+
+module.exports = ReadStream
+
+},{"./errors":48,"./util":51,"readable-stream":69,"util":32,"xtend":70}],51:[function(require,module,exports){
+(function (process,Buffer){
+/* Copyright (c) 2012-2014 LevelUP contributors
+ * See list at <https://github.com/rvagg/node-levelup#contributing>
+ * MIT License
+ * <https://github.com/rvagg/node-levelup/blob/master/LICENSE.md>
+ */
+
+var extend = require('xtend')
+ , LevelUPError = require('./errors').LevelUPError
+
+ , encodingNames = [
+ 'hex'
+ , 'utf8'
+ , 'utf-8'
+ , 'ascii'
+ , 'binary'
+ , 'base64'
+ , 'ucs2'
+ , 'ucs-2'
+ , 'utf16le'
+ , 'utf-16le'
+ ]
+
+ , defaultOptions = {
+ createIfMissing : true
+ , errorIfExists : false
+ , keyEncoding : 'utf8'
+ , valueEncoding : 'utf8'
+ , compression : true
+ }
+
+ , leveldown
+
+ , encodings = (function () {
+ function isBinary (data) {
+ return data === undefined || data === null || Buffer.isBuffer(data)
+ }
+
+ var encodings = {}
+ encodings.utf8 = encodings['utf-8'] = {
+ encode : function (data) {
+ return isBinary(data) ? data : String(data)
+ }
+ , decode : function (data) {
+ return data
+ }
+ , buffer : false
+ , type : 'utf8'
+ }
+ encodings.json = {
+ encode : JSON.stringify
+ , decode : JSON.parse
+ , buffer : false
+ , type : 'json'
+ }
+ encodingNames.forEach(function (type) {
+ if (encodings[type])
+ return
+ encodings[type] = {
+ encode : function (data) {
+ return isBinary(data) ? data : new Buffer(data, type)
+ }
+ , decode : function (buffer) {
+ return process.browser ? buffer.toString(type) : buffer;
+ }
+ , buffer : true
+ , type : type // useful for debugging purposes
+ }
+ })
+ return encodings
+ })()
+
+ , encodingOpts = (function () {
+ var eo = {}
+ encodingNames.forEach(function (e) {
+ eo[e] = { valueEncoding : e }
+ })
+ return eo
+ }())
+
+function copy (srcdb, dstdb, callback) {
+ srcdb.readStream()
+ .pipe(dstdb.writeStream())
+ .on('close', callback ? callback : function () {})
+ .on('error', callback ? callback : function (err) { throw err })
+}
+
+function getOptions (levelup, options) {
+ var s = typeof options == 'string' // just an encoding
+ if (!s && options && options.encoding && !options.valueEncoding)
+ options.valueEncoding = options.encoding
+ return extend(
+ (levelup && levelup.options) || {}
+ , s ? encodingOpts[options] || encodingOpts[defaultOptions.valueEncoding]
+ : options
+ )
+}
+
+function getLevelDOWN () {
+ if (leveldown)
+ return leveldown
+
+ var requiredVersion = require('../package.json').devDependencies.leveldown
+ , missingLevelDOWNError = 'Could not locate LevelDOWN, try `npm install leveldown`'
+ , leveldownVersion
+
+ try {
+ leveldownVersion = require('leveldown/package').version
+ } catch (e) {
+ throw new LevelUPError(missingLevelDOWNError)
+ }
+
+ if (!require('semver').satisfies(leveldownVersion, requiredVersion)) {
+ throw new LevelUPError(
+ 'Installed version of LevelDOWN ('
+ + leveldownVersion
+ + ') does not match required version ('
+ + requiredVersion
+ + ')'
+ )
+ }
+
+ try {
+ return leveldown = require('leveldown')
+ } catch (e) {
+ throw new LevelUPError(missingLevelDOWNError)
+ }
+}
+
+function dispatchError (levelup, error, callback) {
+ return typeof callback == 'function'
+ ? callback(error)
+ : levelup.emit('error', error)
+}
+
+function getKeyEncoder (options, op) {
+ var type = ((op && op.keyEncoding) || options.keyEncoding) || 'utf8'
+ return encodings[type] || type
+}
+
+function getValueEncoder (options, op) {
+ var type = (((op && (op.valueEncoding || op.encoding))
+ || options.valueEncoding || options.encoding)) || 'utf8'
+ return encodings[type] || type
+}
+
+function encodeKey (key, options, op) {
+ return getKeyEncoder(options, op).encode(key)
+}
+
+function encodeValue (value, options, op) {
+ return getValueEncoder(options, op).encode(value)
+}
+
+function decodeKey (key, options) {
+ return getKeyEncoder(options).decode(key)
+}
+
+function decodeValue (value, options) {
+ return getValueEncoder(options).decode(value)
+}
+
+function isValueAsBuffer (options, op) {
+ return getValueEncoder(options, op).buffer
+}
+
+function isKeyAsBuffer (options, op) {
+ return getKeyEncoder(options, op).buffer
+}
+
+module.exports = {
+ defaultOptions : defaultOptions
+ , copy : copy
+ , getOptions : getOptions
+ , getLevelDOWN : getLevelDOWN
+ , dispatchError : dispatchError
+ , encodeKey : encodeKey
+ , encodeValue : encodeValue
+ , isValueAsBuffer : isValueAsBuffer
+ , isKeyAsBuffer : isKeyAsBuffer
+ , decodeValue : decodeValue
+ , decodeKey : decodeKey
+}
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),require("buffer").Buffer)
+},{"../package.json":71,"./errors":48,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"leveldown":"3WVjcl","leveldown/package":17,"semver":17,"xtend":70}],52:[function(require,module,exports){
+(function (process,global){
+/* Copyright (c) 2012-2014 LevelUP contributors
+ * See list at <https://github.com/rvagg/node-levelup#contributing>
+ * MIT License
+ * <https://github.com/rvagg/node-levelup/blob/master/LICENSE.md>
+ */
+
+var Stream = require('stream').Stream
+ , inherits = require('util').inherits
+ , extend = require('xtend')
+ , bl = require('bl')
+
+ , setImmediate = global.setImmediate || process.nextTick
+
+ , getOptions = require('./util').getOptions
+
+ , defaultOptions = { type: 'put' }
+
+function WriteStream (options, db) {
+ if (!(this instanceof WriteStream))
+ return new WriteStream(options, db)
+
+ Stream.call(this)
+ this._options = extend(defaultOptions, getOptions(db, options))
+ this._db = db
+ this._buffer = []
+ this._status = 'init'
+ this._end = false
+ this.writable = true
+ this.readable = false
+
+ var self = this
+ , ready = function () {
+ if (!self.writable)
+ return
+ self._status = 'ready'
+ self.emit('ready')
+ self._process()
+ }
+
+ if (db.isOpen())
+ setImmediate(ready)
+ else
+ db.once('ready', ready)
+}
+
+inherits(WriteStream, Stream)
+
+WriteStream.prototype.write = function (data) {
+ if (!this.writable)
+ return false
+ this._buffer.push(data)
+ if (this._status != 'init')
+ this._processDelayed()
+ if (this._options.maxBufferLength &&
+ this._buffer.length > this._options.maxBufferLength) {
+ this._writeBlock = true
+ return false
+ }
+ return true
+}
+
+WriteStream.prototype.end = function (data) {
+ var self = this
+ if (data)
+ this.write(data)
+ setImmediate(function () {
+ self._end = true
+ self._process()
+ })
+}
+
+WriteStream.prototype.destroy = function () {
+ this.writable = false
+ this.end()
+}
+
+WriteStream.prototype.destroySoon = function () {
+ this.end()
+}
+
+WriteStream.prototype.add = function (entry) {
+ if (!entry.props)
+ return
+ if (entry.props.Directory)
+ entry.pipe(this._db.writeStream(this._options))
+ else if (entry.props.File || entry.File || entry.type == 'File')
+ this._write(entry)
+ return true
+}
+
+WriteStream.prototype._processDelayed = function () {
+ var self = this
+ setImmediate(function () {
+ self._process()
+ })
+}
+
+WriteStream.prototype._process = function () {
+ var buffer
+ , self = this
+
+ , cb = function (err) {
+ if (!self.writable)
+ return
+ if (self._status != 'closed')
+ self._status = 'ready'
+ if (err) {
+ self.writable = false
+ return self.emit('error', err)
+ }
+ self._process()
+ }
+
+ if (self._status != 'ready' && self.writable) {
+ if (self._buffer.length && self._status != 'closed')
+ self._processDelayed()
+ return
+ }
+
+ if (self._buffer.length && self.writable) {
+ self._status = 'writing'
+ buffer = self._buffer
+ self._buffer = []
+
+ self._db.batch(buffer.map(function (d) {
+ return {
+ type : d.type || self._options.type
+ , key : d.key
+ , value : d.value
+ , keyEncoding : d.keyEncoding || self._options.keyEncoding
+ , valueEncoding : d.valueEncoding
+ || d.encoding
+ || self._options.valueEncoding
+ }
+ }), cb)
+
+ if (self._writeBlock) {
+ self._writeBlock = false
+ self.emit('drain')
+ }
+
+ // don't allow close until callback has returned
+ return
+ }
+
+ if (self._end && self._status != 'closed') {
+ self._status = 'closed'
+ self.writable = false
+ self.emit('close')
+ }
+}
+
+WriteStream.prototype._write = function (entry) {
+ var key = entry.path || entry.props.path
+ , self = this
+
+ if (!key)
+ return
+
+ entry.pipe(bl(function (err, data) {
+ if (err) {
+ self.writable = false
+ return self.emit('error', err)
+ }
+
+ if (self._options.fstreamRoot &&
+ key.indexOf(self._options.fstreamRoot) > -1)
+ key = key.substr(self._options.fstreamRoot.length + 1)
+
+ self.write({ key: key, value: data.slice(0) })
+ }))
+}
+
+WriteStream.prototype.toString = function () {
+ return 'LevelUP.WriteStream'
+}
+
+module.exports = WriteStream
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./util":51,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"bl":53,"stream":24,"util":32,"xtend":70}],53:[function(require,module,exports){
+(function (Buffer){
+var DuplexStream = require('readable-stream').Duplex
+ , util = require('util')
+
+function BufferList (callback) {
+ if (!(this instanceof BufferList))
+ return new BufferList(callback)
+
+ this._bufs = []
+ this.length = 0
+
+ if (typeof callback == 'function') {
+ this._callback = callback
+
+ var piper = function (err) {
+ if (this._callback) {
+ this._callback(err)
+ this._callback = null
+ }
+ }.bind(this)
+
+ this.on('pipe', function (src) {
+ src.on('error', piper)
+ })
+ this.on('unpipe', function (src) {
+ src.removeListener('error', piper)
+ })
+ }
+ else if (Buffer.isBuffer(callback))
+ this.append(callback)
+ else if (Array.isArray(callback)) {
+ callback.forEach(function (b) {
+ Buffer.isBuffer(b) && this.append(b)
+ }.bind(this))
+ }
+
+ DuplexStream.call(this)
+}
+
+util.inherits(BufferList, DuplexStream)
+
+BufferList.prototype._offset = function (offset) {
+ var tot = 0, i = 0, _t
+ for (; i < this._bufs.length; i++) {
+ _t = tot + this._bufs[i].length
+ if (offset < _t)
+ return [ i, offset - tot ]
+ tot = _t
+ }
+}
+
+BufferList.prototype.append = function (buf) {
+ this._bufs.push(Buffer.isBuffer(buf) ? buf : new Buffer(buf))
+ this.length += buf.length
+ return this
+}
+
+BufferList.prototype._write = function (buf, encoding, callback) {
+ this.append(buf)
+ if (callback)
+ callback()
+}
+
+BufferList.prototype._read = function (size) {
+ if (!this.length)
+ return this.push(null)
+ size = Math.min(size, this.length)
+ this.push(this.slice(0, size))
+ this.consume(size)
+}
+
+BufferList.prototype.end = function (chunk) {
+ DuplexStream.prototype.end.call(this, chunk)
+
+ if (this._callback) {
+ this._callback(null, this.slice())
+ this._callback = null
+ }
+}
+
+BufferList.prototype.get = function (index) {
+ return this.slice(index, index + 1)[0]
+}
+
+BufferList.prototype.slice = function (start, end) {
+ return this.copy(null, 0, start, end)
+}
+
+BufferList.prototype.copy = function (dst, dstStart, srcStart, srcEnd) {
+ if (typeof srcStart != 'number' || srcStart < 0)
+ srcStart = 0
+ if (typeof srcEnd != 'number' || srcEnd > this.length)
+ srcEnd = this.length
+ if (srcStart >= this.length)
+ return dst || new Buffer(0)
+ if (srcEnd <= 0)
+ return dst || new Buffer(0)
+
+ var copy = !!dst
+ , off = this._offset(srcStart)
+ , len = srcEnd - srcStart
+ , bytes = len
+ , bufoff = (copy && dstStart) || 0
+ , start = off[1]
+ , l
+ , i
+
+ // copy/slice everything
+ if (srcStart === 0 && srcEnd == this.length) {
+ if (!copy) // slice, just return a full concat
+ return Buffer.concat(this._bufs)
+
+ // copy, need to copy individual buffers
+ for (i = 0; i < this._bufs.length; i++) {
+ this._bufs[i].copy(dst, bufoff)
+ bufoff += this._bufs[i].length
+ }
+
+ return dst
+ }
+
+ // easy, cheap case where it's a subset of one of the buffers
+ if (bytes <= this._bufs[off[0]].length - start) {
+ return copy
+ ? this._bufs[off[0]].copy(dst, dstStart, start, start + bytes)
+ : this._bufs[off[0]].slice(start, start + bytes)
+ }
+
+ if (!copy) // a slice, we need something to copy in to
+ dst = new Buffer(len)
+
+ for (i = off[0]; i < this._bufs.length; i++) {
+ l = this._bufs[i].length - start
+
+ if (bytes > l) {
+ this._bufs[i].copy(dst, bufoff, start)
+ } else {
+ this._bufs[i].copy(dst, bufoff, start, start + bytes)
+ break
+ }
+
+ bufoff += l
+ bytes -= l
+
+ if (start)
+ start = 0
+ }
+
+ return dst
+}
+
+BufferList.prototype.toString = function (encoding, start, end) {
+ return this.slice(start, end).toString(encoding)
+}
+
+BufferList.prototype.consume = function (bytes) {
+ while (this._bufs.length) {
+ if (bytes > this._bufs[0].length) {
+ bytes -= this._bufs[0].length
+ this.length -= this._bufs[0].length
+ this._bufs.shift()
+ } else {
+ this._bufs[0] = this._bufs[0].slice(bytes)
+ this.length -= bytes
+ break
+ }
+ }
+ return this
+}
+
+BufferList.prototype.duplicate = function () {
+ var i = 0
+ , copy = new BufferList()
+
+ for (; i < this._bufs.length; i++)
+ copy.append(this._bufs[i])
+
+ return copy
+}
+
+BufferList.prototype.destroy = function () {
+ this._bufs.length = 0;
+ this.length = 0;
+ this.push(null);
+}
+
+;(function () {
+ var methods = {
+ 'readDoubleBE' : 8
+ , 'readDoubleLE' : 8
+ , 'readFloatBE' : 4
+ , 'readFloatLE' : 4
+ , 'readInt32BE' : 4
+ , 'readInt32LE' : 4
+ , 'readUInt32BE' : 4
+ , 'readUInt32LE' : 4
+ , 'readInt16BE' : 2
+ , 'readInt16LE' : 2
+ , 'readUInt16BE' : 2
+ , 'readUInt16LE' : 2
+ , 'readInt8' : 1
+ , 'readUInt8' : 1
+ }
+
+ for (var m in methods) {
+ (function (m) {
+ BufferList.prototype[m] = function (offset) {
+ return this.slice(offset, offset + methods[m])[m](0)
+ }
+ }(m))
+ }
+}())
+
+module.exports = BufferList
+
+}).call(this,require("buffer").Buffer)
+},{"buffer":20,"readable-stream":69,"util":32}],54:[function(require,module,exports){
+(function (process,Buffer){
+var util = require('util')
+ , AbstractLevelDOWN = require('abstract-leveldown').AbstractLevelDOWN
+
+function DeferredLevelDOWN (location) {
+ AbstractLevelDOWN.call(this, typeof location == 'string' ? location : '') // optional location, who cares?
+ this._db = undefined
+ this._operations = []
+}
+
+util.inherits(DeferredLevelDOWN, AbstractLevelDOWN)
+
+// called by LevelUP when we have a real DB to take its place
+DeferredLevelDOWN.prototype.setDb = function (db) {
+ this._db = db
+ this._operations.forEach(function (op) {
+ db[op.method].apply(db, op.args)
+ })
+}
+
+DeferredLevelDOWN.prototype._open = function (options, callback) {
+ return process.nextTick(callback)
+}
+
+// queue a new deferred operation
+DeferredLevelDOWN.prototype._operation = function (method, args) {
+ if (this._db)
+ return this._db[method].apply(this._db, args)
+ this._operations.push({ method: method, args: args })
+}
+
+// deferrables
+'put get del batch approximateSize'.split(' ').forEach(function (m) {
+ DeferredLevelDOWN.prototype['_' + m] = function () {
+ this._operation(m, arguments)
+ }
+})
+
+DeferredLevelDOWN.prototype._isBuffer = function (obj) {
+ return Buffer.isBuffer(obj)
+}
+
+// don't need to implement this as LevelUP's ReadStream checks for 'ready' state
+DeferredLevelDOWN.prototype._iterator = function () {
+ throw new TypeError('not implemented')
+}
+
+module.exports = DeferredLevelDOWN
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),require("buffer").Buffer)
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"abstract-leveldown":57,"buffer":20,"util":32}],55:[function(require,module,exports){
+(function (process){
+/* Copyright (c) 2013 Rod Vagg, MIT License */
+
+function AbstractChainedBatch (db) {
+ this._db = db
+ this._operations = []
+ this._written = false
+}
+
+AbstractChainedBatch.prototype._checkWritten = function () {
+ if (this._written)
+ throw new Error('write() already called on this batch')
+}
+
+AbstractChainedBatch.prototype.put = function (key, value) {
+ this._checkWritten()
+
+ var err = this._db._checkKeyValue(key, 'key', this._db._isBuffer)
+ if (err) throw err
+ err = this._db._checkKeyValue(value, 'value', this._db._isBuffer)
+ if (err) throw err
+
+ if (!this._db._isBuffer(key)) key = String(key)
+ if (!this._db._isBuffer(value)) value = String(value)
+
+ if (typeof this._put == 'function' )
+ this._put(key, value)
+ else
+ this._operations.push({ type: 'put', key: key, value: value })
+
+ return this
+}
+
+AbstractChainedBatch.prototype.del = function (key) {
+ this._checkWritten()
+
+ var err = this._db._checkKeyValue(key, 'key', this._db._isBuffer)
+ if (err) throw err
+
+ if (!this._db._isBuffer(key)) key = String(key)
+
+ if (typeof this._del == 'function' )
+ this._del(key)
+ else
+ this._operations.push({ type: 'del', key: key })
+
+ return this
+}
+
+AbstractChainedBatch.prototype.clear = function () {
+ this._checkWritten()
+
+ this._operations = []
+
+ if (typeof this._clear == 'function' )
+ this._clear()
+
+ return this
+}
+
+AbstractChainedBatch.prototype.write = function (options, callback) {
+ this._checkWritten()
+
+ if (typeof options == 'function')
+ callback = options
+ if (typeof callback != 'function')
+ throw new Error('write() requires a callback argument')
+ if (typeof options != 'object')
+ options = {}
+
+ this._written = true
+
+ if (typeof this._write == 'function' )
+ return this._write(callback)
+
+ if (typeof this._db._batch == 'function')
+ return this._db._batch(this._operations, options, callback)
+
+ process.nextTick(callback)
+}
+
+module.exports = AbstractChainedBatch
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],56:[function(require,module,exports){
+(function (process){
+/* Copyright (c) 2013 Rod Vagg, MIT License */
+
+function AbstractIterator (db) {
+ this.db = db
+ this._ended = false
+ this._nexting = false
+}
+
+AbstractIterator.prototype.next = function (callback) {
+ var self = this
+
+ if (typeof callback != 'function')
+ throw new Error('next() requires a callback argument')
+
+ if (self._ended)
+ return callback(new Error('cannot call next() after end()'))
+ if (self._nexting)
+ return callback(new Error('cannot call next() before previous next() has completed'))
+
+ self._nexting = true
+ if (typeof self._next == 'function') {
+ return self._next(function () {
+ self._nexting = false
+ callback.apply(null, arguments)
+ })
+ }
+
+ process.nextTick(function () {
+ self._nexting = false
+ callback()
+ })
+}
+
+AbstractIterator.prototype.end = function (callback) {
+ if (typeof callback != 'function')
+ throw new Error('end() requires a callback argument')
+
+ if (this._ended)
+ return callback(new Error('end() already called on iterator'))
+
+ this._ended = true
+
+ if (typeof this._end == 'function')
+ return this._end(callback)
+
+ process.nextTick(callback)
+}
+
+module.exports = AbstractIterator
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],57:[function(require,module,exports){
+(function (process,Buffer){
+/* Copyright (c) 2013 Rod Vagg, MIT License */
+
+var xtend = require('xtend')
+ , AbstractIterator = require('./abstract-iterator')
+ , AbstractChainedBatch = require('./abstract-chained-batch')
+
+function AbstractLevelDOWN (location) {
+ if (!arguments.length || location === undefined)
+ throw new Error('constructor requires at least a location argument')
+
+ if (typeof location != 'string')
+ throw new Error('constructor requires a location string argument')
+
+ this.location = location
+}
+
+AbstractLevelDOWN.prototype.open = function (options, callback) {
+ if (typeof options == 'function')
+ callback = options
+
+ if (typeof callback != 'function')
+ throw new Error('open() requires a callback argument')
+
+ if (typeof options != 'object')
+ options = {}
+
+ if (typeof this._open == 'function')
+ return this._open(options, callback)
+
+ process.nextTick(callback)
+}
+
+AbstractLevelDOWN.prototype.close = function (callback) {
+ if (typeof callback != 'function')
+ throw new Error('close() requires a callback argument')
+
+ if (typeof this._close == 'function')
+ return this._close(callback)
+
+ process.nextTick(callback)
+}
+
+AbstractLevelDOWN.prototype.get = function (key, options, callback) {
+ var err
+
+ if (typeof options == 'function')
+ callback = options
+
+ if (typeof callback != 'function')
+ throw new Error('get() requires a callback argument')
+
+ if (err = this._checkKeyValue(key, 'key', this._isBuffer))
+ return callback(err)
+
+ if (!this._isBuffer(key))
+ key = String(key)
+
+ if (typeof options != 'object')
+ options = {}
+
+ if (typeof this._get == 'function')
+ return this._get(key, options, callback)
+
+ process.nextTick(function () { callback(new Error('NotFound')) })
+}
+
+AbstractLevelDOWN.prototype.put = function (key, value, options, callback) {
+ var err
+
+ if (typeof options == 'function')
+ callback = options
+
+ if (typeof callback != 'function')
+ throw new Error('put() requires a callback argument')
+
+ if (err = this._checkKeyValue(key, 'key', this._isBuffer))
+ return callback(err)
+
+ if (err = this._checkKeyValue(value, 'value', this._isBuffer))
+ return callback(err)
+
+ if (!this._isBuffer(key))
+ key = String(key)
+
+ // coerce value to string in node, don't touch it in browser
+ // (indexeddb can store any JS type)
+ if (!this._isBuffer(value) && !process.browser)
+ value = String(value)
+
+ if (typeof options != 'object')
+ options = {}
+
+ if (typeof this._put == 'function')
+ return this._put(key, value, options, callback)
+
+ process.nextTick(callback)
+}
+
+AbstractLevelDOWN.prototype.del = function (key, options, callback) {
+ var err
+
+ if (typeof options == 'function')
+ callback = options
+
+ if (typeof callback != 'function')
+ throw new Error('del() requires a callback argument')
+
+ if (err = this._checkKeyValue(key, 'key', this._isBuffer))
+ return callback(err)
+
+ if (!this._isBuffer(key))
+ key = String(key)
+
+ if (typeof options != 'object')
+ options = {}
+
+ if (typeof this._del == 'function')
+ return this._del(key, options, callback)
+
+ process.nextTick(callback)
+}
+
+AbstractLevelDOWN.prototype.batch = function (array, options, callback) {
+ if (!arguments.length)
+ return this._chainedBatch()
+
+ if (typeof options == 'function')
+ callback = options
+
+ if (typeof callback != 'function')
+ throw new Error('batch(array) requires a callback argument')
+
+ if (!Array.isArray(array))
+ return callback(new Error('batch(array) requires an array argument'))
+
+ if (typeof options != 'object')
+ options = {}
+
+ var i = 0
+ , l = array.length
+ , e
+ , err
+
+ for (; i < l; i++) {
+ e = array[i]
+ if (typeof e != 'object')
+ continue
+
+ if (err = this._checkKeyValue(e.type, 'type', this._isBuffer))
+ return callback(err)
+
+ if (err = this._checkKeyValue(e.key, 'key', this._isBuffer))
+ return callback(err)
+
+ if (e.type == 'put') {
+ if (err = this._checkKeyValue(e.value, 'value', this._isBuffer))
+ return callback(err)
+ }
+ }
+
+ if (typeof this._batch == 'function')
+ return this._batch(array, options, callback)
+
+ process.nextTick(callback)
+}
+
+//TODO: remove from here, not a necessary primitive
+AbstractLevelDOWN.prototype.approximateSize = function (start, end, callback) {
+ if ( start == null
+ || end == null
+ || typeof start == 'function'
+ || typeof end == 'function') {
+ throw new Error('approximateSize() requires valid `start`, `end` and `callback` arguments')
+ }
+
+ if (typeof callback != 'function')
+ throw new Error('approximateSize() requires a callback argument')
+
+ if (!this._isBuffer(start))
+ start = String(start)
+
+ if (!this._isBuffer(end))
+ end = String(end)
+
+ if (typeof this._approximateSize == 'function')
+ return this._approximateSize(start, end, callback)
+
+ process.nextTick(function () {
+ callback(null, 0)
+ })
+}
+
+AbstractLevelDOWN.prototype._setupIteratorOptions = function (options) {
+ var self = this
+
+ options = xtend(options)
+
+ ;[ 'start', 'end', 'gt', 'gte', 'lt', 'lte' ].forEach(function (o) {
+ if (options[o] && self._isBuffer(options[o]) && options[o].length === 0)
+ delete options[o]
+ })
+
+ options.reverse = !!options.reverse
+
+ // fix `start` so it takes into account gt, gte, lt, lte as appropriate
+ if (options.reverse && options.lt)
+ options.start = options.lt
+ if (options.reverse && options.lte)
+ options.start = options.lte
+ if (!options.reverse && options.gt)
+ options.start = options.gt
+ if (!options.reverse && options.gte)
+ options.start = options.gte
+
+ if ((options.reverse && options.lt && !options.lte)
+ || (!options.reverse && options.gt && !options.gte))
+ options.exclusiveStart = true // start should *not* include matching key
+
+ return options
+}
+
+AbstractLevelDOWN.prototype.iterator = function (options) {
+ if (typeof options != 'object')
+ options = {}
+
+ options = this._setupIteratorOptions(options)
+
+ if (typeof this._iterator == 'function')
+ return this._iterator(options)
+
+ return new AbstractIterator(this)
+}
+
+AbstractLevelDOWN.prototype._chainedBatch = function () {
+ return new AbstractChainedBatch(this)
+}
+
+AbstractLevelDOWN.prototype._isBuffer = function (obj) {
+ return Buffer.isBuffer(obj)
+}
+
+AbstractLevelDOWN.prototype._checkKeyValue = function (obj, type) {
+ if (obj === null || obj === undefined)
+ return new Error(type + ' cannot be `null` or `undefined`')
+
+ if (obj === null || obj === undefined)
+ return new Error(type + ' cannot be `null` or `undefined`')
+
+ if (this._isBuffer(obj)) {
+ if (obj.length === 0)
+ return new Error(type + ' cannot be an empty Buffer')
+ } else if (String(obj) === '')
+ return new Error(type + ' cannot be an empty String')
+}
+
+module.exports.AbstractLevelDOWN = AbstractLevelDOWN
+module.exports.AbstractIterator = AbstractIterator
+module.exports.AbstractChainedBatch = AbstractChainedBatch
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),require("buffer").Buffer)
+},{"./abstract-chained-batch":55,"./abstract-iterator":56,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"xtend":70}],58:[function(require,module,exports){
+var prr = require('prr')
+
+function init (type, message, cause) {
+ prr(this, {
+ type : type
+ , name : type
+ // can be passed just a 'cause'
+ , cause : typeof message != 'string' ? message : cause
+ , message : !!message && typeof message != 'string' ? message.message : message
+
+ }, 'ewr')
+}
+
+// generic prototype, not intended to be actually used - helpful for `instanceof`
+function CustomError (message, cause) {
+ Error.call(this)
+ if (Error.captureStackTrace)
+ Error.captureStackTrace(this, arguments.callee)
+ init.call(this, 'CustomError', message, cause)
+}
+
+CustomError.prototype = new Error()
+
+function createError (errno, type, proto) {
+ var err = function (message, cause) {
+ init.call(this, type, message, cause)
+ //TODO: the specificity here is stupid, errno should be available everywhere
+ if (type == 'FilesystemError') {
+ this.code = this.cause.code
+ this.path = this.cause.path
+ this.errno = this.cause.errno
+ this.message =
+ (errno.errno[this.cause.errno]
+ ? errno.errno[this.cause.errno].description
+ : this.cause.message)
+ + (this.cause.path ? ' [' + this.cause.path + ']' : '')
+ }
+ Error.call(this)
+ if (Error.captureStackTrace)
+ Error.captureStackTrace(this, arguments.callee)
+ }
+ err.prototype = !!proto ? new proto() : new CustomError()
+ return err
+}
+
+module.exports = function (errno) {
+ var ce = function (type, proto) {
+ return createError(errno, type, proto)
+ }
+ return {
+ CustomError : CustomError
+ , FilesystemError : ce('FilesystemError')
+ , createError : ce
+ }
+}
+
+},{"prr":60}],59:[function(require,module,exports){
+var all = module.exports.all = [
+ {
+ "errno": -1,
+ "code": "UNKNOWN",
+ "description": "unknown error"
+ },
+ {
+ "errno": 0,
+ "code": "OK",
+ "description": "success"
+ },
+ {
+ "errno": 1,
+ "code": "EOF",
+ "description": "end of file"
+ },
+ {
+ "errno": 2,
+ "code": "EADDRINFO",
+ "description": "getaddrinfo error"
+ },
+ {
+ "errno": 3,
+ "code": "EACCES",
+ "description": "permission denied"
+ },
+ {
+ "errno": 4,
+ "code": "EAGAIN",
+ "description": "resource temporarily unavailable"
+ },
+ {
+ "errno": 5,
+ "code": "EADDRINUSE",
+ "description": "address already in use"
+ },
+ {
+ "errno": 6,
+ "code": "EADDRNOTAVAIL",
+ "description": "address not available"
+ },
+ {
+ "errno": 7,
+ "code": "EAFNOSUPPORT",
+ "description": "address family not supported"
+ },
+ {
+ "errno": 8,
+ "code": "EALREADY",
+ "description": "connection already in progress"
+ },
+ {
+ "errno": 9,
+ "code": "EBADF",
+ "description": "bad file descriptor"
+ },
+ {
+ "errno": 10,
+ "code": "EBUSY",
+ "description": "resource busy or locked"
+ },
+ {
+ "errno": 11,
+ "code": "ECONNABORTED",
+ "description": "software caused connection abort"
+ },
+ {
+ "errno": 12,
+ "code": "ECONNREFUSED",
+ "description": "connection refused"
+ },
+ {
+ "errno": 13,
+ "code": "ECONNRESET",
+ "description": "connection reset by peer"
+ },
+ {
+ "errno": 14,
+ "code": "EDESTADDRREQ",
+ "description": "destination address required"
+ },
+ {
+ "errno": 15,
+ "code": "EFAULT",
+ "description": "bad address in system call argument"
+ },
+ {
+ "errno": 16,
+ "code": "EHOSTUNREACH",
+ "description": "host is unreachable"
+ },
+ {
+ "errno": 17,
+ "code": "EINTR",
+ "description": "interrupted system call"
+ },
+ {
+ "errno": 18,
+ "code": "EINVAL",
+ "description": "invalid argument"
+ },
+ {
+ "errno": 19,
+ "code": "EISCONN",
+ "description": "socket is already connected"
+ },
+ {
+ "errno": 20,
+ "code": "EMFILE",
+ "description": "too many open files"
+ },
+ {
+ "errno": 21,
+ "code": "EMSGSIZE",
+ "description": "message too long"
+ },
+ {
+ "errno": 22,
+ "code": "ENETDOWN",
+ "description": "network is down"
+ },
+ {
+ "errno": 23,
+ "code": "ENETUNREACH",
+ "description": "network is unreachable"
+ },
+ {
+ "errno": 24,
+ "code": "ENFILE",
+ "description": "file table overflow"
+ },
+ {
+ "errno": 25,
+ "code": "ENOBUFS",
+ "description": "no buffer space available"
+ },
+ {
+ "errno": 26,
+ "code": "ENOMEM",
+ "description": "not enough memory"
+ },
+ {
+ "errno": 27,
+ "code": "ENOTDIR",
+ "description": "not a directory"
+ },
+ {
+ "errno": 28,
+ "code": "EISDIR",
+ "description": "illegal operation on a directory"
+ },
+ {
+ "errno": 29,
+ "code": "ENONET",
+ "description": "machine is not on the network"
+ },
+ {
+ "errno": 31,
+ "code": "ENOTCONN",
+ "description": "socket is not connected"
+ },
+ {
+ "errno": 32,
+ "code": "ENOTSOCK",
+ "description": "socket operation on non-socket"
+ },
+ {
+ "errno": 33,
+ "code": "ENOTSUP",
+ "description": "operation not supported on socket"
+ },
+ {
+ "errno": 34,
+ "code": "ENOENT",
+ "description": "no such file or directory"
+ },
+ {
+ "errno": 35,
+ "code": "ENOSYS",
+ "description": "function not implemented"
+ },
+ {
+ "errno": 36,
+ "code": "EPIPE",
+ "description": "broken pipe"
+ },
+ {
+ "errno": 37,
+ "code": "EPROTO",
+ "description": "protocol error"
+ },
+ {
+ "errno": 38,
+ "code": "EPROTONOSUPPORT",
+ "description": "protocol not supported"
+ },
+ {
+ "errno": 39,
+ "code": "EPROTOTYPE",
+ "description": "protocol wrong type for socket"
+ },
+ {
+ "errno": 40,
+ "code": "ETIMEDOUT",
+ "description": "connection timed out"
+ },
+ {
+ "errno": 41,
+ "code": "ECHARSET",
+ "description": "invalid Unicode character"
+ },
+ {
+ "errno": 42,
+ "code": "EAIFAMNOSUPPORT",
+ "description": "address family for hostname not supported"
+ },
+ {
+ "errno": 44,
+ "code": "EAISERVICE",
+ "description": "servname not supported for ai_socktype"
+ },
+ {
+ "errno": 45,
+ "code": "EAISOCKTYPE",
+ "description": "ai_socktype not supported"
+ },
+ {
+ "errno": 46,
+ "code": "ESHUTDOWN",
+ "description": "cannot send after transport endpoint shutdown"
+ },
+ {
+ "errno": 47,
+ "code": "EEXIST",
+ "description": "file already exists"
+ },
+ {
+ "errno": 48,
+ "code": "ESRCH",
+ "description": "no such process"
+ },
+ {
+ "errno": 49,
+ "code": "ENAMETOOLONG",
+ "description": "name too long"
+ },
+ {
+ "errno": 50,
+ "code": "EPERM",
+ "description": "operation not permitted"
+ },
+ {
+ "errno": 51,
+ "code": "ELOOP",
+ "description": "too many symbolic links encountered"
+ },
+ {
+ "errno": 52,
+ "code": "EXDEV",
+ "description": "cross-device link not permitted"
+ },
+ {
+ "errno": 53,
+ "code": "ENOTEMPTY",
+ "description": "directory not empty"
+ },
+ {
+ "errno": 54,
+ "code": "ENOSPC",
+ "description": "no space left on device"
+ },
+ {
+ "errno": 55,
+ "code": "EIO",
+ "description": "i/o error"
+ },
+ {
+ "errno": 56,
+ "code": "EROFS",
+ "description": "read-only file system"
+ },
+ {
+ "errno": 57,
+ "code": "ENODEV",
+ "description": "no such device"
+ },
+ {
+ "errno": 58,
+ "code": "ESPIPE",
+ "description": "invalid seek"
+ },
+ {
+ "errno": 59,
+ "code": "ECANCELED",
+ "description": "operation canceled"
+ }
+]
+
+
+module.exports.errno = {
+ '-1': all[0]
+ , '0': all[1]
+ , '1': all[2]
+ , '2': all[3]
+ , '3': all[4]
+ , '4': all[5]
+ , '5': all[6]
+ , '6': all[7]
+ , '7': all[8]
+ , '8': all[9]
+ , '9': all[10]
+ , '10': all[11]
+ , '11': all[12]
+ , '12': all[13]
+ , '13': all[14]
+ , '14': all[15]
+ , '15': all[16]
+ , '16': all[17]
+ , '17': all[18]
+ , '18': all[19]
+ , '19': all[20]
+ , '20': all[21]
+ , '21': all[22]
+ , '22': all[23]
+ , '23': all[24]
+ , '24': all[25]
+ , '25': all[26]
+ , '26': all[27]
+ , '27': all[28]
+ , '28': all[29]
+ , '29': all[30]
+ , '31': all[31]
+ , '32': all[32]
+ , '33': all[33]
+ , '34': all[34]
+ , '35': all[35]
+ , '36': all[36]
+ , '37': all[37]
+ , '38': all[38]
+ , '39': all[39]
+ , '40': all[40]
+ , '41': all[41]
+ , '42': all[42]
+ , '44': all[43]
+ , '45': all[44]
+ , '46': all[45]
+ , '47': all[46]
+ , '48': all[47]
+ , '49': all[48]
+ , '50': all[49]
+ , '51': all[50]
+ , '52': all[51]
+ , '53': all[52]
+ , '54': all[53]
+ , '55': all[54]
+ , '56': all[55]
+ , '57': all[56]
+ , '58': all[57]
+ , '59': all[58]
+}
+
+
+module.exports.code = {
+ 'UNKNOWN': all[0]
+ , 'OK': all[1]
+ , 'EOF': all[2]
+ , 'EADDRINFO': all[3]
+ , 'EACCES': all[4]
+ , 'EAGAIN': all[5]
+ , 'EADDRINUSE': all[6]
+ , 'EADDRNOTAVAIL': all[7]
+ , 'EAFNOSUPPORT': all[8]
+ , 'EALREADY': all[9]
+ , 'EBADF': all[10]
+ , 'EBUSY': all[11]
+ , 'ECONNABORTED': all[12]
+ , 'ECONNREFUSED': all[13]
+ , 'ECONNRESET': all[14]
+ , 'EDESTADDRREQ': all[15]
+ , 'EFAULT': all[16]
+ , 'EHOSTUNREACH': all[17]
+ , 'EINTR': all[18]
+ , 'EINVAL': all[19]
+ , 'EISCONN': all[20]
+ , 'EMFILE': all[21]
+ , 'EMSGSIZE': all[22]
+ , 'ENETDOWN': all[23]
+ , 'ENETUNREACH': all[24]
+ , 'ENFILE': all[25]
+ , 'ENOBUFS': all[26]
+ , 'ENOMEM': all[27]
+ , 'ENOTDIR': all[28]
+ , 'EISDIR': all[29]
+ , 'ENONET': all[30]
+ , 'ENOTCONN': all[31]
+ , 'ENOTSOCK': all[32]
+ , 'ENOTSUP': all[33]
+ , 'ENOENT': all[34]
+ , 'ENOSYS': all[35]
+ , 'EPIPE': all[36]
+ , 'EPROTO': all[37]
+ , 'EPROTONOSUPPORT': all[38]
+ , 'EPROTOTYPE': all[39]
+ , 'ETIMEDOUT': all[40]
+ , 'ECHARSET': all[41]
+ , 'EAIFAMNOSUPPORT': all[42]
+ , 'EAISERVICE': all[43]
+ , 'EAISOCKTYPE': all[44]
+ , 'ESHUTDOWN': all[45]
+ , 'EEXIST': all[46]
+ , 'ESRCH': all[47]
+ , 'ENAMETOOLONG': all[48]
+ , 'EPERM': all[49]
+ , 'ELOOP': all[50]
+ , 'EXDEV': all[51]
+ , 'ENOTEMPTY': all[52]
+ , 'ENOSPC': all[53]
+ , 'EIO': all[54]
+ , 'EROFS': all[55]
+ , 'ENODEV': all[56]
+ , 'ESPIPE': all[57]
+ , 'ECANCELED': all[58]
+}
+
+
+module.exports.custom = require("./custom")(module.exports)
+module.exports.create = module.exports.custom.createError
+},{"./custom":58}],60:[function(require,module,exports){
+/*!
+ * prr
+ * (c) 2013 Rod Vagg <rod@vagg.org>
+ * https://github.com/rvagg/prr
+ * License: MIT
+ */
+
+(function (name, context, definition) {
+ if (typeof module != 'undefined' && module.exports)
+ module.exports = definition()
+ else
+ context[name] = definition()
+})('prr', this, function() {
+
+ var setProperty = typeof Object.defineProperty == 'function'
+ ? function (obj, key, options) {
+ Object.defineProperty(obj, key, options)
+ return obj
+ }
+ : function (obj, key, options) { // < es5
+ obj[key] = options.value
+ return obj
+ }
+
+ , makeOptions = function (value, options) {
+ var oo = typeof options == 'object'
+ , os = !oo && typeof options == 'string'
+ , op = function (p) {
+ return oo
+ ? !!options[p]
+ : os
+ ? options.indexOf(p[0]) > -1
+ : false
+ }
+
+ return {
+ enumerable : op('enumerable')
+ , configurable : op('configurable')
+ , writable : op('writable')
+ , value : value
+ }
+ }
+
+ , prr = function (obj, key, value, options) {
+ var k
+
+ options = makeOptions(value, options)
+
+ if (typeof key == 'object') {
+ for (k in key) {
+ if (Object.hasOwnProperty.call(key, k)) {
+ options.value = key[k]
+ setProperty(obj, k, options)
+ }
+ }
+ return obj
+ }
+
+ return setProperty(obj, key, options)
+ }
+
+ return prr
+})
+},{}],61:[function(require,module,exports){
+(function (process){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototypal inheritance, this class
+// prototypally inherits from Readable, and then parasitically from
+// Writable.
+
+module.exports = Duplex;
+
+/*<replacement>*/
+var objectKeys = Object.keys || function (obj) {
+ var keys = [];
+ for (var key in obj) keys.push(key);
+ return keys;
+}
+/*</replacement>*/
+
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+var Readable = require('./_stream_readable');
+var Writable = require('./_stream_writable');
+
+util.inherits(Duplex, Readable);
+
+forEach(objectKeys(Writable.prototype), function(method) {
+ if (!Duplex.prototype[method])
+ Duplex.prototype[method] = Writable.prototype[method];
+});
+
+function Duplex(options) {
+ if (!(this instanceof Duplex))
+ return new Duplex(options);
+
+ Readable.call(this, options);
+ Writable.call(this, options);
+
+ if (options && options.readable === false)
+ this.readable = false;
+
+ if (options && options.writable === false)
+ this.writable = false;
+
+ this.allowHalfOpen = true;
+ if (options && options.allowHalfOpen === false)
+ this.allowHalfOpen = false;
+
+ this.once('end', onend);
+}
+
+// the no-half-open enforcer
+function onend() {
+ // if we allow half-open state, or if the writable side ended,
+ // then we're ok.
+ if (this.allowHalfOpen || this._writableState.ended)
+ return;
+
+ // no more data can be written.
+ // But allow more writes to happen in this tick.
+ process.nextTick(this.end.bind(this));
+}
+
+function forEach (xs, f) {
+ for (var i = 0, l = xs.length; i < l; i++) {
+ f(xs[i], i);
+ }
+}
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"./_stream_readable":63,"./_stream_writable":65,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"core-util-is":66,"inherits":33}],62:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+
+module.exports = PassThrough;
+
+var Transform = require('./_stream_transform');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(PassThrough, Transform);
+
+function PassThrough(options) {
+ if (!(this instanceof PassThrough))
+ return new PassThrough(options);
+
+ Transform.call(this, options);
+}
+
+PassThrough.prototype._transform = function(chunk, encoding, cb) {
+ cb(null, chunk);
+};
+
+},{"./_stream_transform":64,"core-util-is":66,"inherits":33}],63:[function(require,module,exports){
+(function (process){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module.exports = Readable;
+
+/*<replacement>*/
+var isArray = require('isarray');
+/*</replacement>*/
+
+
+/*<replacement>*/
+var Buffer = require('buffer').Buffer;
+/*</replacement>*/
+
+Readable.ReadableState = ReadableState;
+
+var EE = require('events').EventEmitter;
+
+/*<replacement>*/
+if (!EE.listenerCount) EE.listenerCount = function(emitter, type) {
+ return emitter.listeners(type).length;
+};
+/*</replacement>*/
+
+var Stream = require('stream');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+var StringDecoder;
+
+util.inherits(Readable, Stream);
+
+function ReadableState(options, stream) {
+ options = options || {};
+
+ // the point at which it stops calling _read() to fill the buffer
+ // Note: 0 is a valid value, means "don't call _read preemptively ever"
+ var hwm = options.highWaterMark;
+ this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
+
+ // cast to ints.
+ this.highWaterMark = ~~this.highWaterMark;
+
+ this.buffer = [];
+ this.length = 0;
+ this.pipes = null;
+ this.pipesCount = 0;
+ this.flowing = false;
+ this.ended = false;
+ this.endEmitted = false;
+ this.reading = false;
+
+ // In streams that never have any data, and do push(null) right away,
+ // the consumer can miss the 'end' event if they do some I/O before
+ // consuming the stream. So, we don't emit('end') until some reading
+ // happens.
+ this.calledRead = false;
+
+ // a flag to be able to tell if the onwrite cb is called immediately,
+ // or on a later tick. We set this to true at first, becuase any
+ // actions that shouldn't happen until "later" should generally also
+ // not happen before the first write call.
+ this.sync = true;
+
+ // whenever we return null, then we set a flag to say
+ // that we're awaiting a 'readable' event emission.
+ this.needReadable = false;
+ this.emittedReadable = false;
+ this.readableListening = false;
+
+
+ // object stream flag. Used to make read(n) ignore n and to
+ // make all the buffer merging and length checks go away
+ this.objectMode = !!options.objectMode;
+
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+ // when piping, we only care about 'readable' events that happen
+ // after read()ing all the bytes and not getting any pushback.
+ this.ranOut = false;
+
+ // the number of writers that are awaiting a drain event in .pipe()s
+ this.awaitDrain = 0;
+
+ // if true, a maybeReadMore has been scheduled
+ this.readingMore = false;
+
+ this.decoder = null;
+ this.encoding = null;
+ if (options.encoding) {
+ if (!StringDecoder)
+ StringDecoder = require('string_decoder/').StringDecoder;
+ this.decoder = new StringDecoder(options.encoding);
+ this.encoding = options.encoding;
+ }
+}
+
+function Readable(options) {
+ if (!(this instanceof Readable))
+ return new Readable(options);
+
+ this._readableState = new ReadableState(options, this);
+
+ // legacy
+ this.readable = true;
+
+ Stream.call(this);
+}
+
+// Manually shove something into the read() buffer.
+// This returns true if the highWaterMark has not been hit yet,
+// similar to how Writable.write() returns true if you should
+// write() some more.
+Readable.prototype.push = function(chunk, encoding) {
+ var state = this._readableState;
+
+ if (typeof chunk === 'string' && !state.objectMode) {
+ encoding = encoding || state.defaultEncoding;
+ if (encoding !== state.encoding) {
+ chunk = new Buffer(chunk, encoding);
+ encoding = '';
+ }
+ }
+
+ return readableAddChunk(this, state, chunk, encoding, false);
+};
+
+// Unshift should *always* be something directly out of read()
+Readable.prototype.unshift = function(chunk) {
+ var state = this._readableState;
+ return readableAddChunk(this, state, chunk, '', true);
+};
+
+function readableAddChunk(stream, state, chunk, encoding, addToFront) {
+ var er = chunkInvalid(state, chunk);
+ if (er) {
+ stream.emit('error', er);
+ } else if (chunk === null || chunk === undefined) {
+ state.reading = false;
+ if (!state.ended)
+ onEofChunk(stream, state);
+ } else if (state.objectMode || chunk && chunk.length > 0) {
+ if (state.ended && !addToFront) {
+ var e = new Error('stream.push() after EOF');
+ stream.emit('error', e);
+ } else if (state.endEmitted && addToFront) {
+ var e = new Error('stream.unshift() after end event');
+ stream.emit('error', e);
+ } else {
+ if (state.decoder && !addToFront && !encoding)
+ chunk = state.decoder.write(chunk);
+
+ // update the buffer info.
+ state.length += state.objectMode ? 1 : chunk.length;
+ if (addToFront) {
+ state.buffer.unshift(chunk);
+ } else {
+ state.reading = false;
+ state.buffer.push(chunk);
+ }
+
+ if (state.needReadable)
+ emitReadable(stream);
+
+ maybeReadMore(stream, state);
+ }
+ } else if (!addToFront) {
+ state.reading = false;
+ }
+
+ return needMoreData(state);
+}
+
+
+
+// if it's past the high water mark, we can push in some more.
+// Also, if we have no data yet, we can stand some
+// more bytes. This is to work around cases where hwm=0,
+// such as the repl. Also, if the push() triggered a
+// readable event, and the user called read(largeNumber) such that
+// needReadable was set, then we ought to push more, so that another
+// 'readable' event will be triggered.
+function needMoreData(state) {
+ return !state.ended &&
+ (state.needReadable ||
+ state.length < state.highWaterMark ||
+ state.length === 0);
+}
+
+// backwards compatibility.
+Readable.prototype.setEncoding = function(enc) {
+ if (!StringDecoder)
+ StringDecoder = require('string_decoder/').StringDecoder;
+ this._readableState.decoder = new StringDecoder(enc);
+ this._readableState.encoding = enc;
+};
+
+// Don't raise the hwm > 128MB
+var MAX_HWM = 0x800000;
+function roundUpToNextPowerOf2(n) {
+ if (n >= MAX_HWM) {
+ n = MAX_HWM;
+ } else {
+ // Get the next highest power of 2
+ n--;
+ for (var p = 1; p < 32; p <<= 1) n |= n >> p;
+ n++;
+ }
+ return n;
+}
+
+function howMuchToRead(n, state) {
+ if (state.length === 0 && state.ended)
+ return 0;
+
+ if (state.objectMode)
+ return n === 0 ? 0 : 1;
+
+ if (isNaN(n) || n === null) {
+ // only flow one buffer at a time
+ if (state.flowing && state.buffer.length)
+ return state.buffer[0].length;
+ else
+ return state.length;
+ }
+
+ if (n <= 0)
+ return 0;
+
+ // If we're asking for more than the target buffer level,
+ // then raise the water mark. Bump up to the next highest
+ // power of 2, to prevent increasing it excessively in tiny
+ // amounts.
+ if (n > state.highWaterMark)
+ state.highWaterMark = roundUpToNextPowerOf2(n);
+
+ // don't have that much. return null, unless we've ended.
+ if (n > state.length) {
+ if (!state.ended) {
+ state.needReadable = true;
+ return 0;
+ } else
+ return state.length;
+ }
+
+ return n;
+}
+
+// you can override either this method, or the async _read(n) below.
+Readable.prototype.read = function(n) {
+ var state = this._readableState;
+ state.calledRead = true;
+ var nOrig = n;
+
+ if (typeof n !== 'number' || n > 0)
+ state.emittedReadable = false;
+
+ // if we're doing read(0) to trigger a readable event, but we
+ // already have a bunch of data in the buffer, then just trigger
+ // the 'readable' event and move on.
+ if (n === 0 &&
+ state.needReadable &&
+ (state.length >= state.highWaterMark || state.ended)) {
+ emitReadable(this);
+ return null;
+ }
+
+ n = howMuchToRead(n, state);
+
+ // if we've ended, and we're now clear, then finish it up.
+ if (n === 0 && state.ended) {
+ if (state.length === 0)
+ endReadable(this);
+ return null;
+ }
+
+ // All the actual chunk generation logic needs to be
+ // *below* the call to _read. The reason is that in certain
+ // synthetic stream cases, such as passthrough streams, _read
+ // may be a completely synchronous operation which may change
+ // the state of the read buffer, providing enough data when
+ // before there was *not* enough.
+ //
+ // So, the steps are:
+ // 1. Figure out what the state of things will be after we do
+ // a read from the buffer.
+ //
+ // 2. If that resulting state will trigger a _read, then call _read.
+ // Note that this may be asynchronous, or synchronous. Yes, it is
+ // deeply ugly to write APIs this way, but that still doesn't mean
+ // that the Readable class should behave improperly, as streams are
+ // designed to be sync/async agnostic.
+ // Take note if the _read call is sync or async (ie, if the read call
+ // has returned yet), so that we know whether or not it's safe to emit
+ // 'readable' etc.
+ //
+ // 3. Actually pull the requested chunks out of the buffer and return.
+
+ // if we need a readable event, then we need to do some reading.
+ var doRead = state.needReadable;
+
+ // if we currently have less than the highWaterMark, then also read some
+ if (state.length - n <= state.highWaterMark)
+ doRead = true;
+
+ // however, if we've ended, then there's no point, and if we're already
+ // reading, then it's unnecessary.
+ if (state.ended || state.reading)
+ doRead = false;
+
+ if (doRead) {
+ state.reading = true;
+ state.sync = true;
+ // if the length is currently zero, then we *need* a readable event.
+ if (state.length === 0)
+ state.needReadable = true;
+ // call internal read method
+ this._read(state.highWaterMark);
+ state.sync = false;
+ }
+
+ // If _read called its callback synchronously, then `reading`
+ // will be false, and we need to re-evaluate how much data we
+ // can return to the user.
+ if (doRead && !state.reading)
+ n = howMuchToRead(nOrig, state);
+
+ var ret;
+ if (n > 0)
+ ret = fromList(n, state);
+ else
+ ret = null;
+
+ if (ret === null) {
+ state.needReadable = true;
+ n = 0;
+ }
+
+ state.length -= n;
+
+ // If we have nothing in the buffer, then we want to know
+ // as soon as we *do* get something into the buffer.
+ if (state.length === 0 && !state.ended)
+ state.needReadable = true;
+
+ // If we happened to read() exactly the remaining amount in the
+ // buffer, and the EOF has been seen at this point, then make sure
+ // that we emit 'end' on the very next tick.
+ if (state.ended && !state.endEmitted && state.length === 0)
+ endReadable(this);
+
+ return ret;
+};
+
+function chunkInvalid(state, chunk) {
+ var er = null;
+ if (!Buffer.isBuffer(chunk) &&
+ 'string' !== typeof chunk &&
+ chunk !== null &&
+ chunk !== undefined &&
+ !state.objectMode &&
+ !er) {
+ er = new TypeError('Invalid non-string/buffer chunk');
+ }
+ return er;
+}
+
+
+function onEofChunk(stream, state) {
+ if (state.decoder && !state.ended) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length) {
+ state.buffer.push(chunk);
+ state.length += state.objectMode ? 1 : chunk.length;
+ }
+ }
+ state.ended = true;
+
+ // if we've ended and we have some data left, then emit
+ // 'readable' now to make sure it gets picked up.
+ if (state.length > 0)
+ emitReadable(stream);
+ else
+ endReadable(stream);
+}
+
+// Don't emit readable right away in sync mode, because this can trigger
+// another read() call => stack overflow. This way, it might trigger
+// a nextTick recursion warning, but that's not so bad.
+function emitReadable(stream) {
+ var state = stream._readableState;
+ state.needReadable = false;
+ if (state.emittedReadable)
+ return;
+
+ state.emittedReadable = true;
+ if (state.sync)
+ process.nextTick(function() {
+ emitReadable_(stream);
+ });
+ else
+ emitReadable_(stream);
+}
+
+function emitReadable_(stream) {
+ stream.emit('readable');
+}
+
+
+// at this point, the user has presumably seen the 'readable' event,
+// and called read() to consume some data. that may have triggered
+// in turn another _read(n) call, in which case reading = true if
+// it's in progress.
+// However, if we're not ended, or reading, and the length < hwm,
+// then go ahead and try to read some more preemptively.
+function maybeReadMore(stream, state) {
+ if (!state.readingMore) {
+ state.readingMore = true;
+ process.nextTick(function() {
+ maybeReadMore_(stream, state);
+ });
+ }
+}
+
+function maybeReadMore_(stream, state) {
+ var len = state.length;
+ while (!state.reading && !state.flowing && !state.ended &&
+ state.length < state.highWaterMark) {
+ stream.read(0);
+ if (len === state.length)
+ // didn't get any data, stop spinning.
+ break;
+ else
+ len = state.length;
+ }
+ state.readingMore = false;
+}
+
+// abstract method. to be overridden in specific implementation classes.
+// call cb(er, data) where data is <= n in length.
+// for virtual (non-string, non-buffer) streams, "length" is somewhat
+// arbitrary, and perhaps not very meaningful.
+Readable.prototype._read = function(n) {
+ this.emit('error', new Error('not implemented'));
+};
+
+Readable.prototype.pipe = function(dest, pipeOpts) {
+ var src = this;
+ var state = this._readableState;
+
+ switch (state.pipesCount) {
+ case 0:
+ state.pipes = dest;
+ break;
+ case 1:
+ state.pipes = [state.pipes, dest];
+ break;
+ default:
+ state.pipes.push(dest);
+ break;
+ }
+ state.pipesCount += 1;
+
+ var doEnd = (!pipeOpts || pipeOpts.end !== false) &&
+ dest !== process.stdout &&
+ dest !== process.stderr;
+
+ var endFn = doEnd ? onend : cleanup;
+ if (state.endEmitted)
+ process.nextTick(endFn);
+ else
+ src.once('end', endFn);
+
+ dest.on('unpipe', onunpipe);
+ function onunpipe(readable) {
+ if (readable !== src) return;
+ cleanup();
+ }
+
+ function onend() {
+ dest.end();
+ }
+
+ // when the dest drains, it reduces the awaitDrain counter
+ // on the source. This would be more elegant with a .once()
+ // handler in flow(), but adding and removing repeatedly is
+ // too slow.
+ var ondrain = pipeOnDrain(src);
+ dest.on('drain', ondrain);
+
+ function cleanup() {
+ // cleanup event handlers once the pipe is broken
+ dest.removeListener('close', onclose);
+ dest.removeListener('finish', onfinish);
+ dest.removeListener('drain', ondrain);
+ dest.removeListener('error', onerror);
+ dest.removeListener('unpipe', onunpipe);
+ src.removeListener('end', onend);
+ src.removeListener('end', cleanup);
+
+ // if the reader is waiting for a drain event from this
+ // specific writer, then it would cause it to never start
+ // flowing again.
+ // So, if this is awaiting a drain, then we just call it now.
+ // If we don't know, then assume that we are waiting for one.
+ if (!dest._writableState || dest._writableState.needDrain)
+ ondrain();
+ }
+
+ // if the dest has an error, then stop piping into it.
+ // however, don't suppress the throwing behavior for this.
+ function onerror(er) {
+ unpipe();
+ dest.removeListener('error', onerror);
+ if (EE.listenerCount(dest, 'error') === 0)
+ dest.emit('error', er);
+ }
+ // This is a brutally ugly hack to make sure that our error handler
+ // is attached before any userland ones. NEVER DO THIS.
+ if (!dest._events || !dest._events.error)
+ dest.on('error', onerror);
+ else if (isArray(dest._events.error))
+ dest._events.error.unshift(onerror);
+ else
+ dest._events.error = [onerror, dest._events.error];
+
+
+
+ // Both close and finish should trigger unpipe, but only once.
+ function onclose() {
+ dest.removeListener('finish', onfinish);
+ unpipe();
+ }
+ dest.once('close', onclose);
+ function onfinish() {
+ dest.removeListener('close', onclose);
+ unpipe();
+ }
+ dest.once('finish', onfinish);
+
+ function unpipe() {
+ src.unpipe(dest);
+ }
+
+ // tell the dest that it's being piped to
+ dest.emit('pipe', src);
+
+ // start the flow if it hasn't been started already.
+ if (!state.flowing) {
+ // the handler that waits for readable events after all
+ // the data gets sucked out in flow.
+ // This would be easier to follow with a .once() handler
+ // in flow(), but that is too slow.
+ this.on('readable', pipeOnReadable);
+
+ state.flowing = true;
+ process.nextTick(function() {
+ flow(src);
+ });
+ }
+
+ return dest;
+};
+
+function pipeOnDrain(src) {
+ return function() {
+ var dest = this;
+ var state = src._readableState;
+ state.awaitDrain--;
+ if (state.awaitDrain === 0)
+ flow(src);
+ };
+}
+
+function flow(src) {
+ var state = src._readableState;
+ var chunk;
+ state.awaitDrain = 0;
+
+ function write(dest, i, list) {
+ var written = dest.write(chunk);
+ if (false === written) {
+ state.awaitDrain++;
+ }
+ }
+
+ while (state.pipesCount && null !== (chunk = src.read())) {
+
+ if (state.pipesCount === 1)
+ write(state.pipes, 0, null);
+ else
+ forEach(state.pipes, write);
+
+ src.emit('data', chunk);
+
+ // if anyone needs a drain, then we have to wait for that.
+ if (state.awaitDrain > 0)
+ return;
+ }
+
+ // if every destination was unpiped, either before entering this
+ // function, or in the while loop, then stop flowing.
+ //
+ // NB: This is a pretty rare edge case.
+ if (state.pipesCount === 0) {
+ state.flowing = false;
+
+ // if there were data event listeners added, then switch to old mode.
+ if (EE.listenerCount(src, 'data') > 0)
+ emitDataEvents(src);
+ return;
+ }
+
+ // at this point, no one needed a drain, so we just ran out of data
+ // on the next readable event, start it over again.
+ state.ranOut = true;
+}
+
+function pipeOnReadable() {
+ if (this._readableState.ranOut) {
+ this._readableState.ranOut = false;
+ flow(this);
+ }
+}
+
+
+Readable.prototype.unpipe = function(dest) {
+ var state = this._readableState;
+
+ // if we're not piping anywhere, then do nothing.
+ if (state.pipesCount === 0)
+ return this;
+
+ // just one destination. most common case.
+ if (state.pipesCount === 1) {
+ // passed in one, but it's not the right one.
+ if (dest && dest !== state.pipes)
+ return this;
+
+ if (!dest)
+ dest = state.pipes;
+
+ // got a match.
+ state.pipes = null;
+ state.pipesCount = 0;
+ this.removeListener('readable', pipeOnReadable);
+ state.flowing = false;
+ if (dest)
+ dest.emit('unpipe', this);
+ return this;
+ }
+
+ // slow case. multiple pipe destinations.
+
+ if (!dest) {
+ // remove all.
+ var dests = state.pipes;
+ var len = state.pipesCount;
+ state.pipes = null;
+ state.pipesCount = 0;
+ this.removeListener('readable', pipeOnReadable);
+ state.flowing = false;
+
+ for (var i = 0; i < len; i++)
+ dests[i].emit('unpipe', this);
+ return this;
+ }
+
+ // try to find the right one.
+ var i = indexOf(state.pipes, dest);
+ if (i === -1)
+ return this;
+
+ state.pipes.splice(i, 1);
+ state.pipesCount -= 1;
+ if (state.pipesCount === 1)
+ state.pipes = state.pipes[0];
+
+ dest.emit('unpipe', this);
+
+ return this;
+};
+
+// set up data events if they are asked for
+// Ensure readable listeners eventually get something
+Readable.prototype.on = function(ev, fn) {
+ var res = Stream.prototype.on.call(this, ev, fn);
+
+ if (ev === 'data' && !this._readableState.flowing)
+ emitDataEvents(this);
+
+ if (ev === 'readable' && this.readable) {
+ var state = this._readableState;
+ if (!state.readableListening) {
+ state.readableListening = true;
+ state.emittedReadable = false;
+ state.needReadable = true;
+ if (!state.reading) {
+ this.read(0);
+ } else if (state.length) {
+ emitReadable(this, state);
+ }
+ }
+ }
+
+ return res;
+};
+Readable.prototype.addListener = Readable.prototype.on;
+
+// pause() and resume() are remnants of the legacy readable stream API
+// If the user uses them, then switch into old mode.
+Readable.prototype.resume = function() {
+ emitDataEvents(this);
+ this.read(0);
+ this.emit('resume');
+};
+
+Readable.prototype.pause = function() {
+ emitDataEvents(this, true);
+ this.emit('pause');
+};
+
+function emitDataEvents(stream, startPaused) {
+ var state = stream._readableState;
+
+ if (state.flowing) {
+ // https://github.com/isaacs/readable-stream/issues/16
+ throw new Error('Cannot switch to old mode now.');
+ }
+
+ var paused = startPaused || false;
+ var readable = false;
+
+ // convert to an old-style stream.
+ stream.readable = true;
+ stream.pipe = Stream.prototype.pipe;
+ stream.on = stream.addListener = Stream.prototype.on;
+
+ stream.on('readable', function() {
+ readable = true;
+
+ var c;
+ while (!paused && (null !== (c = stream.read())))
+ stream.emit('data', c);
+
+ if (c === null) {
+ readable = false;
+ stream._readableState.needReadable = true;
+ }
+ });
+
+ stream.pause = function() {
+ paused = true;
+ this.emit('pause');
+ };
+
+ stream.resume = function() {
+ paused = false;
+ if (readable)
+ process.nextTick(function() {
+ stream.emit('readable');
+ });
+ else
+ this.read(0);
+ this.emit('resume');
+ };
+
+ // now make it start, just in case it hadn't already.
+ stream.emit('readable');
+}
+
+// wrap an old-style stream as the async data source.
+// This is *not* part of the readable stream interface.
+// It is an ugly unfortunate mess of history.
+Readable.prototype.wrap = function(stream) {
+ var state = this._readableState;
+ var paused = false;
+
+ var self = this;
+ stream.on('end', function() {
+ if (state.decoder && !state.ended) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length)
+ self.push(chunk);
+ }
+
+ self.push(null);
+ });
+
+ stream.on('data', function(chunk) {
+ if (state.decoder)
+ chunk = state.decoder.write(chunk);
+ if (!chunk || !state.objectMode && !chunk.length)
+ return;
+
+ var ret = self.push(chunk);
+ if (!ret) {
+ paused = true;
+ stream.pause();
+ }
+ });
+
+ // proxy all the other methods.
+ // important when wrapping filters and duplexes.
+ for (var i in stream) {
+ if (typeof stream[i] === 'function' &&
+ typeof this[i] === 'undefined') {
+ this[i] = function(method) { return function() {
+ return stream[method].apply(stream, arguments);
+ }}(i);
+ }
+ }
+
+ // proxy certain important events.
+ var events = ['error', 'close', 'destroy', 'pause', 'resume'];
+ forEach(events, function(ev) {
+ stream.on(ev, self.emit.bind(self, ev));
+ });
+
+ // when we try to consume some more bytes, simply unpause the
+ // underlying stream.
+ self._read = function(n) {
+ if (paused) {
+ paused = false;
+ stream.resume();
+ }
+ };
+
+ return self;
+};
+
+
+
+// exposed for testing purposes only.
+Readable._fromList = fromList;
+
+// Pluck off n bytes from an array of buffers.
+// Length is the combined lengths of all the buffers in the list.
+function fromList(n, state) {
+ var list = state.buffer;
+ var length = state.length;
+ var stringMode = !!state.decoder;
+ var objectMode = !!state.objectMode;
+ var ret;
+
+ // nothing in the list, definitely empty.
+ if (list.length === 0)
+ return null;
+
+ if (length === 0)
+ ret = null;
+ else if (objectMode)
+ ret = list.shift();
+ else if (!n || n >= length) {
+ // read it all, truncate the array.
+ if (stringMode)
+ ret = list.join('');
+ else
+ ret = Buffer.concat(list, length);
+ list.length = 0;
+ } else {
+ // read just some of it.
+ if (n < list[0].length) {
+ // just take a part of the first list item.
+ // slice is the same for buffers and strings.
+ var buf = list[0];
+ ret = buf.slice(0, n);
+ list[0] = buf.slice(n);
+ } else if (n === list[0].length) {
+ // first list is a perfect match
+ ret = list.shift();
+ } else {
+ // complex case.
+ // we have enough to cover it, but it spans past the first buffer.
+ if (stringMode)
+ ret = '';
+ else
+ ret = new Buffer(n);
+
+ var c = 0;
+ for (var i = 0, l = list.length; i < l && c < n; i++) {
+ var buf = list[0];
+ var cpy = Math.min(n - c, buf.length);
+
+ if (stringMode)
+ ret += buf.slice(0, cpy);
+ else
+ buf.copy(ret, c, 0, cpy);
+
+ if (cpy < buf.length)
+ list[0] = buf.slice(cpy);
+ else
+ list.shift();
+
+ c += cpy;
+ }
+ }
+ }
+
+ return ret;
+}
+
+function endReadable(stream) {
+ var state = stream._readableState;
+
+ // If we get here before consuming all the bytes, then that is a
+ // bug in node. Should never happen.
+ if (state.length > 0)
+ throw new Error('endReadable called on non-empty stream');
+
+ if (!state.endEmitted && state.calledRead) {
+ state.ended = true;
+ process.nextTick(function() {
+ // Check that we didn't get one last unshift.
+ if (!state.endEmitted && state.length === 0) {
+ state.endEmitted = true;
+ stream.readable = false;
+ stream.emit('end');
+ }
+ });
+ }
+}
+
+function forEach (xs, f) {
+ for (var i = 0, l = xs.length; i < l; i++) {
+ f(xs[i], i);
+ }
+}
+
+function indexOf (xs, x) {
+ for (var i = 0, l = xs.length; i < l; i++) {
+ if (xs[i] === x) return i;
+ }
+ return -1;
+}
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"core-util-is":66,"events":18,"inherits":33,"isarray":67,"stream":24,"string_decoder/":68}],64:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+// a transform stream is a readable/writable stream where you do
+// something with the data. Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored. (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation. For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes. When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up. When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer. When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks. If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk. However,
+// a pathological inflate type of transform can cause excessive buffering
+// here. For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output. In this case, you could write a very small
+// amount of input, and end up with a very large amount of output. In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform. A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
+
+module.exports = Transform;
+
+var Duplex = require('./_stream_duplex');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(Transform, Duplex);
+
+
+function TransformState(options, stream) {
+ this.afterTransform = function(er, data) {
+ return afterTransform(stream, er, data);
+ };
+
+ this.needTransform = false;
+ this.transforming = false;
+ this.writecb = null;
+ this.writechunk = null;
+}
+
+function afterTransform(stream, er, data) {
+ var ts = stream._transformState;
+ ts.transforming = false;
+
+ var cb = ts.writecb;
+
+ if (!cb)
+ return stream.emit('error', new Error('no writecb in Transform class'));
+
+ ts.writechunk = null;
+ ts.writecb = null;
+
+ if (data !== null && data !== undefined)
+ stream.push(data);
+
+ if (cb)
+ cb(er);
+
+ var rs = stream._readableState;
+ rs.reading = false;
+ if (rs.needReadable || rs.length < rs.highWaterMark) {
+ stream._read(rs.highWaterMark);
+ }
+}
+
+
+function Transform(options) {
+ if (!(this instanceof Transform))
+ return new Transform(options);
+
+ Duplex.call(this, options);
+
+ var ts = this._transformState = new TransformState(options, this);
+
+ // when the writable side finishes, then flush out anything remaining.
+ var stream = this;
+
+ // start out asking for a readable event once data is transformed.
+ this._readableState.needReadable = true;
+
+ // we have implemented the _read method, and done the other things
+ // that Readable wants before the first _read call, so unset the
+ // sync guard flag.
+ this._readableState.sync = false;
+
+ this.once('finish', function() {
+ if ('function' === typeof this._flush)
+ this._flush(function(er) {
+ done(stream, er);
+ });
+ else
+ done(stream);
+ });
+}
+
+Transform.prototype.push = function(chunk, encoding) {
+ this._transformState.needTransform = false;
+ return Duplex.prototype.push.call(this, chunk, encoding);
+};
+
+// This is the part where you do stuff!
+// override this function in implementation classes.
+// 'chunk' is an input chunk.
+//
+// Call `push(newChunk)` to pass along transformed output
+// to the readable side. You may call 'push' zero or more times.
+//
+// Call `cb(err)` when you are done with this chunk. If you pass
+// an error, then that'll put the hurt on the whole operation. If you
+// never call cb(), then you'll never get another chunk.
+Transform.prototype._transform = function(chunk, encoding, cb) {
+ throw new Error('not implemented');
+};
+
+Transform.prototype._write = function(chunk, encoding, cb) {
+ var ts = this._transformState;
+ ts.writecb = cb;
+ ts.writechunk = chunk;
+ ts.writeencoding = encoding;
+ if (!ts.transforming) {
+ var rs = this._readableState;
+ if (ts.needTransform ||
+ rs.needReadable ||
+ rs.length < rs.highWaterMark)
+ this._read(rs.highWaterMark);
+ }
+};
+
+// Doesn't matter what the args are here.
+// _transform does all the work.
+// That we got here means that the readable side wants more data.
+Transform.prototype._read = function(n) {
+ var ts = this._transformState;
+
+ if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
+ ts.transforming = true;
+ this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+ } else {
+ // mark that we need a transform, so that any data that comes in
+ // will get processed, now that we've asked for it.
+ ts.needTransform = true;
+ }
+};
+
+
+function done(stream, er) {
+ if (er)
+ return stream.emit('error', er);
+
+ // if there's nothing in the write buffer, then that means
+ // that nothing more will ever be provided
+ var ws = stream._writableState;
+ var rs = stream._readableState;
+ var ts = stream._transformState;
+
+ if (ws.length)
+ throw new Error('calling transform done when ws.length != 0');
+
+ if (ts.transforming)
+ throw new Error('calling transform done when still transforming');
+
+ return stream.push(null);
+}
+
+},{"./_stream_duplex":61,"core-util-is":66,"inherits":33}],65:[function(require,module,exports){
+(function (process){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// A bit simpler than readable streams.
+// Implement an async ._write(chunk, cb), and it'll handle all
+// the drain event emission and buffering.
+
+module.exports = Writable;
+
+/*<replacement>*/
+var Buffer = require('buffer').Buffer;
+/*</replacement>*/
+
+Writable.WritableState = WritableState;
+
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+
+var Stream = require('stream');
+
+util.inherits(Writable, Stream);
+
+function WriteReq(chunk, encoding, cb) {
+ this.chunk = chunk;
+ this.encoding = encoding;
+ this.callback = cb;
+}
+
+function WritableState(options, stream) {
+ options = options || {};
+
+ // the point at which write() starts returning false
+ // Note: 0 is a valid value, means that we always return false if
+ // the entire buffer is not flushed immediately on write()
+ var hwm = options.highWaterMark;
+ this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
+
+ // object stream flag to indicate whether or not this stream
+ // contains buffers or objects.
+ this.objectMode = !!options.objectMode;
+
+ // cast to ints.
+ this.highWaterMark = ~~this.highWaterMark;
+
+ this.needDrain = false;
+ // at the start of calling end()
+ this.ending = false;
+ // when end() has been called, and returned
+ this.ended = false;
+ // when 'finish' is emitted
+ this.finished = false;
+
+ // should we decode strings into buffers before passing to _write?
+ // this is here so that some node-core streams can optimize string
+ // handling at a lower level.
+ var noDecode = options.decodeStrings === false;
+ this.decodeStrings = !noDecode;
+
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+ // not an actual buffer we keep track of, but a measurement
+ // of how much we're waiting to get pushed to some underlying
+ // socket or file.
+ this.length = 0;
+
+ // a flag to see when we're in the middle of a write.
+ this.writing = false;
+
+ // a flag to be able to tell if the onwrite cb is called immediately,
+ // or on a later tick. We set this to true at first, becuase any
+ // actions that shouldn't happen until "later" should generally also
+ // not happen before the first write call.
+ this.sync = true;
+
+ // a flag to know if we're processing previously buffered items, which
+ // may call the _write() callback in the same tick, so that we don't
+ // end up in an overlapped onwrite situation.
+ this.bufferProcessing = false;
+
+ // the callback that's passed to _write(chunk,cb)
+ this.onwrite = function(er) {
+ onwrite(stream, er);
+ };
+
+ // the callback that the user supplies to write(chunk,encoding,cb)
+ this.writecb = null;
+
+ // the amount that is being written when _write is called.
+ this.writelen = 0;
+
+ this.buffer = [];
+
+ // True if the error was already emitted and should not be thrown again
+ this.errorEmitted = false;
+}
+
+function Writable(options) {
+ var Duplex = require('./_stream_duplex');
+
+ // Writable ctor is applied to Duplexes, though they're not
+ // instanceof Writable, they're instanceof Readable.
+ if (!(this instanceof Writable) && !(this instanceof Duplex))
+ return new Writable(options);
+
+ this._writableState = new WritableState(options, this);
+
+ // legacy.
+ this.writable = true;
+
+ Stream.call(this);
+}
+
+// Otherwise people can pipe Writable streams, which is just wrong.
+Writable.prototype.pipe = function() {
+ this.emit('error', new Error('Cannot pipe. Not readable.'));
+};
+
+
+function writeAfterEnd(stream, state, cb) {
+ var er = new Error('write after end');
+ // TODO: defer error events consistently everywhere, not just the cb
+ stream.emit('error', er);
+ process.nextTick(function() {
+ cb(er);
+ });
+}
+
+// If we get something that is not a buffer, string, null, or undefined,
+// and we're not in objectMode, then that's an error.
+// Otherwise stream chunks are all considered to be of length=1, and the
+// watermarks determine how many objects to keep in the buffer, rather than
+// how many bytes or characters.
+function validChunk(stream, state, chunk, cb) {
+ var valid = true;
+ if (!Buffer.isBuffer(chunk) &&
+ 'string' !== typeof chunk &&
+ chunk !== null &&
+ chunk !== undefined &&
+ !state.objectMode) {
+ var er = new TypeError('Invalid non-string/buffer chunk');
+ stream.emit('error', er);
+ process.nextTick(function() {
+ cb(er);
+ });
+ valid = false;
+ }
+ return valid;
+}
+
+Writable.prototype.write = function(chunk, encoding, cb) {
+ var state = this._writableState;
+ var ret = false;
+
+ if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (Buffer.isBuffer(chunk))
+ encoding = 'buffer';
+ else if (!encoding)
+ encoding = state.defaultEncoding;
+
+ if (typeof cb !== 'function')
+ cb = function() {};
+
+ if (state.ended)
+ writeAfterEnd(this, state, cb);
+ else if (validChunk(this, state, chunk, cb))
+ ret = writeOrBuffer(this, state, chunk, encoding, cb);
+
+ return ret;
+};
+
+function decodeChunk(state, chunk, encoding) {
+ if (!state.objectMode &&
+ state.decodeStrings !== false &&
+ typeof chunk === 'string') {
+ chunk = new Buffer(chunk, encoding);
+ }
+ return chunk;
+}
+
+// if we're already writing something, then just put this
+// in the queue, and wait our turn. Otherwise, call _write
+// If we return false, then we need a drain event, so set that flag.
+function writeOrBuffer(stream, state, chunk, encoding, cb) {
+ chunk = decodeChunk(state, chunk, encoding);
+ if (Buffer.isBuffer(chunk))
+ encoding = 'buffer';
+ var len = state.objectMode ? 1 : chunk.length;
+
+ state.length += len;
+
+ var ret = state.length < state.highWaterMark;
+ // we must ensure that previous needDrain will not be reset to false.
+ if (!ret)
+ state.needDrain = true;
+
+ if (state.writing)
+ state.buffer.push(new WriteReq(chunk, encoding, cb));
+ else
+ doWrite(stream, state, len, chunk, encoding, cb);
+
+ return ret;
+}
+
+function doWrite(stream, state, len, chunk, encoding, cb) {
+ state.writelen = len;
+ state.writecb = cb;
+ state.writing = true;
+ state.sync = true;
+ stream._write(chunk, encoding, state.onwrite);
+ state.sync = false;
+}
+
+function onwriteError(stream, state, sync, er, cb) {
+ if (sync)
+ process.nextTick(function() {
+ cb(er);
+ });
+ else
+ cb(er);
+
+ stream._writableState.errorEmitted = true;
+ stream.emit('error', er);
+}
+
+function onwriteStateUpdate(state) {
+ state.writing = false;
+ state.writecb = null;
+ state.length -= state.writelen;
+ state.writelen = 0;
+}
+
+function onwrite(stream, er) {
+ var state = stream._writableState;
+ var sync = state.sync;
+ var cb = state.writecb;
+
+ onwriteStateUpdate(state);
+
+ if (er)
+ onwriteError(stream, state, sync, er, cb);
+ else {
+ // Check if we're actually ready to finish, but don't emit yet
+ var finished = needFinish(stream, state);
+
+ if (!finished && !state.bufferProcessing && state.buffer.length)
+ clearBuffer(stream, state);
+
+ if (sync) {
+ process.nextTick(function() {
+ afterWrite(stream, state, finished, cb);
+ });
+ } else {
+ afterWrite(stream, state, finished, cb);
+ }
+ }
+}
+
+function afterWrite(stream, state, finished, cb) {
+ if (!finished)
+ onwriteDrain(stream, state);
+ cb();
+ if (finished)
+ finishMaybe(stream, state);
+}
+
+// Must force callback to be called on nextTick, so that we don't
+// emit 'drain' before the write() consumer gets the 'false' return
+// value, and has a chance to attach a 'drain' listener.
+function onwriteDrain(stream, state) {
+ if (state.length === 0 && state.needDrain) {
+ state.needDrain = false;
+ stream.emit('drain');
+ }
+}
+
+
+// if there's something in the buffer waiting, then process it
+function clearBuffer(stream, state) {
+ state.bufferProcessing = true;
+
+ for (var c = 0; c < state.buffer.length; c++) {
+ var entry = state.buffer[c];
+ var chunk = entry.chunk;
+ var encoding = entry.encoding;
+ var cb = entry.callback;
+ var len = state.objectMode ? 1 : chunk.length;
+
+ doWrite(stream, state, len, chunk, encoding, cb);
+
+ // if we didn't call the onwrite immediately, then
+ // it means that we need to wait until it does.
+ // also, that means that the chunk and cb are currently
+ // being processed, so move the buffer counter past them.
+ if (state.writing) {
+ c++;
+ break;
+ }
+ }
+
+ state.bufferProcessing = false;
+ if (c < state.buffer.length)
+ state.buffer = state.buffer.slice(c);
+ else
+ state.buffer.length = 0;
+}
+
+Writable.prototype._write = function(chunk, encoding, cb) {
+ cb(new Error('not implemented'));
+};
+
+Writable.prototype.end = function(chunk, encoding, cb) {
+ var state = this._writableState;
+
+ if (typeof chunk === 'function') {
+ cb = chunk;
+ chunk = null;
+ encoding = null;
+ } else if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (typeof chunk !== 'undefined' && chunk !== null)
+ this.write(chunk, encoding);
+
+ // ignore unnecessary end() calls.
+ if (!state.ending && !state.finished)
+ endWritable(this, state, cb);
+};
+
+
+function needFinish(stream, state) {
+ return (state.ending &&
+ state.length === 0 &&
+ !state.finished &&
+ !state.writing);
+}
+
+function finishMaybe(stream, state) {
+ var need = needFinish(stream, state);
+ if (need) {
+ state.finished = true;
+ stream.emit('finish');
+ }
+ return need;
+}
+
+function endWritable(stream, state, cb) {
+ state.ending = true;
+ finishMaybe(stream, state);
+ if (cb) {
+ if (state.finished)
+ process.nextTick(cb);
+ else
+ stream.once('finish', cb);
+ }
+ state.ended = true;
+}
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"./_stream_duplex":61,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"core-util-is":66,"inherits":33,"stream":24}],66:[function(require,module,exports){
+(function (Buffer){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+function isArray(ar) {
+ return Array.isArray(ar);
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+ return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+ return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+ return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+ return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+ return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+ return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+ return isObject(re) && objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+ return isObject(d) && objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+ return isObject(e) &&
+ (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+ return arg === null ||
+ typeof arg === 'boolean' ||
+ typeof arg === 'number' ||
+ typeof arg === 'string' ||
+ typeof arg === 'symbol' || // ES6 symbol
+ typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+function isBuffer(arg) {
+ return Buffer.isBuffer(arg);
+}
+exports.isBuffer = isBuffer;
+
+function objectToString(o) {
+ return Object.prototype.toString.call(o);
+}
+}).call(this,require("buffer").Buffer)
+},{"buffer":20}],67:[function(require,module,exports){
+module.exports = Array.isArray || function (arr) {
+ return Object.prototype.toString.call(arr) == '[object Array]';
+};
+
+},{}],68:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var Buffer = require('buffer').Buffer;
+
+var isBufferEncoding = Buffer.isEncoding
+ || function(encoding) {
+ switch (encoding && encoding.toLowerCase()) {
+ case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;
+ default: return false;
+ }
+ }
+
+
+function assertEncoding(encoding) {
+ if (encoding && !isBufferEncoding(encoding)) {
+ throw new Error('Unknown encoding: ' + encoding);
+ }
+}
+
+var StringDecoder = exports.StringDecoder = function(encoding) {
+ this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
+ assertEncoding(encoding);
+ switch (this.encoding) {
+ case 'utf8':
+ // CESU-8 represents each of Surrogate Pair by 3-bytes
+ this.surrogateSize = 3;
+ break;
+ case 'ucs2':
+ case 'utf16le':
+ // UTF-16 represents each of Surrogate Pair by 2-bytes
+ this.surrogateSize = 2;
+ this.detectIncompleteChar = utf16DetectIncompleteChar;
+ break;
+ case 'base64':
+ // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
+ this.surrogateSize = 3;
+ this.detectIncompleteChar = base64DetectIncompleteChar;
+ break;
+ default:
+ this.write = passThroughWrite;
+ return;
+ }
+
+ this.charBuffer = new Buffer(6);
+ this.charReceived = 0;
+ this.charLength = 0;
+};
+
+
+StringDecoder.prototype.write = function(buffer) {
+ var charStr = '';
+ var offset = 0;
+
+ // if our last write ended with an incomplete multibyte character
+ while (this.charLength) {
+ // determine how many remaining bytes this buffer has to offer for this char
+ var i = (buffer.length >= this.charLength - this.charReceived) ?
+ this.charLength - this.charReceived :
+ buffer.length;
+
+ // add the new bytes to the char buffer
+ buffer.copy(this.charBuffer, this.charReceived, offset, i);
+ this.charReceived += (i - offset);
+ offset = i;
+
+ if (this.charReceived < this.charLength) {
+ // still not enough chars in this buffer? wait for more ...
+ return '';
+ }
+
+ // get the character that was split
+ charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
+
+ // lead surrogate (D800-DBFF) is also the incomplete character
+ var charCode = charStr.charCodeAt(charStr.length - 1);
+ if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+ this.charLength += this.surrogateSize;
+ charStr = '';
+ continue;
+ }
+ this.charReceived = this.charLength = 0;
+
+ // if there are no more bytes in this buffer, just emit our char
+ if (i == buffer.length) return charStr;
+
+ // otherwise cut off the characters end from the beginning of this buffer
+ buffer = buffer.slice(i, buffer.length);
+ break;
+ }
+
+ var lenIncomplete = this.detectIncompleteChar(buffer);
+
+ var end = buffer.length;
+ if (this.charLength) {
+ // buffer the incomplete character bytes we got
+ buffer.copy(this.charBuffer, 0, buffer.length - lenIncomplete, end);
+ this.charReceived = lenIncomplete;
+ end -= lenIncomplete;
+ }
+
+ charStr += buffer.toString(this.encoding, 0, end);
+
+ var end = charStr.length - 1;
+ var charCode = charStr.charCodeAt(end);
+ // lead surrogate (D800-DBFF) is also the incomplete character
+ if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+ var size = this.surrogateSize;
+ this.charLength += size;
+ this.charReceived += size;
+ this.charBuffer.copy(this.charBuffer, size, 0, size);
+ this.charBuffer.write(charStr.charAt(charStr.length - 1), this.encoding);
+ return charStr.substring(0, end);
+ }
+
+ // or just emit the charStr
+ return charStr;
+};
+
+StringDecoder.prototype.detectIncompleteChar = function(buffer) {
+ // determine how many bytes we have to check at the end of this buffer
+ var i = (buffer.length >= 3) ? 3 : buffer.length;
+
+ // Figure out if one of the last i bytes of our buffer announces an
+ // incomplete char.
+ for (; i > 0; i--) {
+ var c = buffer[buffer.length - i];
+
+ // See http://en.wikipedia.org/wiki/UTF-8#Description
+
+ // 110XXXXX
+ if (i == 1 && c >> 5 == 0x06) {
+ this.charLength = 2;
+ break;
+ }
+
+ // 1110XXXX
+ if (i <= 2 && c >> 4 == 0x0E) {
+ this.charLength = 3;
+ break;
+ }
+
+ // 11110XXX
+ if (i <= 3 && c >> 3 == 0x1E) {
+ this.charLength = 4;
+ break;
+ }
+ }
+
+ return i;
+};
+
+StringDecoder.prototype.end = function(buffer) {
+ var res = '';
+ if (buffer && buffer.length)
+ res = this.write(buffer);
+
+ if (this.charReceived) {
+ var cr = this.charReceived;
+ var buf = this.charBuffer;
+ var enc = this.encoding;
+ res += buf.slice(0, cr).toString(enc);
+ }
+
+ return res;
+};
+
+function passThroughWrite(buffer) {
+ return buffer.toString(this.encoding);
+}
+
+function utf16DetectIncompleteChar(buffer) {
+ var incomplete = this.charReceived = buffer.length % 2;
+ this.charLength = incomplete ? 2 : 0;
+ return incomplete;
+}
+
+function base64DetectIncompleteChar(buffer) {
+ var incomplete = this.charReceived = buffer.length % 3;
+ this.charLength = incomplete ? 3 : 0;
+ return incomplete;
+}
+
+},{"buffer":20}],69:[function(require,module,exports){
+exports = module.exports = require('./lib/_stream_readable.js');
+exports.Readable = exports;
+exports.Writable = require('./lib/_stream_writable.js');
+exports.Duplex = require('./lib/_stream_duplex.js');
+exports.Transform = require('./lib/_stream_transform.js');
+exports.PassThrough = require('./lib/_stream_passthrough.js');
+
+},{"./lib/_stream_duplex.js":61,"./lib/_stream_passthrough.js":62,"./lib/_stream_readable.js":63,"./lib/_stream_transform.js":64,"./lib/_stream_writable.js":65}],70:[function(require,module,exports){
+module.exports = extend
+
+function extend() {
+ var target = {}
+
+ for (var i = 0; i < arguments.length; i++) {
+ var source = arguments[i]
+
+ for (var key in source) {
+ if (source.hasOwnProperty(key)) {
+ target[key] = source[key]
+ }
+ }
+ }
+
+ return target
+}
+
+},{}],71:[function(require,module,exports){
+module.exports={
+ "name": "levelup",
+ "description": "Fast & simple storage - a Node.js-style LevelDB wrapper",
+ "version": "0.18.6",
+ "contributors": [
+ {
+ "name": "Rod Vagg",
+ "email": "r@va.gg",
+ "url": "https://github.com/rvagg"
+ },
+ {
+ "name": "John Chesley",
+ "email": "john@chesl.es",
+ "url": "https://github.com/chesles/"
+ },
+ {
+ "name": "Jake Verbaten",
+ "email": "raynos2@gmail.com",
+ "url": "https://github.com/raynos"
+ },
+ {
+ "name": "Dominic Tarr",
+ "email": "dominic.tarr@gmail.com",
+ "url": "https://github.com/dominictarr"
+ },
+ {
+ "name": "Max Ogden",
+ "email": "max@maxogden.com",
+ "url": "https://github.com/maxogden"
+ },
+ {
+ "name": "Lars-Magnus Skog",
+ "email": "lars.magnus.skog@gmail.com",
+ "url": "https://github.com/ralphtheninja"
+ },
+ {
+ "name": "David Björklund",
+ "email": "david.bjorklund@gmail.com",
+ "url": "https://github.com/kesla"
+ },
+ {
+ "name": "Julian Gruber",
+ "email": "julian@juliangruber.com",
+ "url": "https://github.com/juliangruber"
+ },
+ {
+ "name": "Paolo Fragomeni",
+ "email": "paolo@async.ly",
+ "url": "https://github.com/hij1nx"
+ },
+ {
+ "name": "Anton Whalley",
+ "email": "anton.whalley@nearform.com",
+ "url": "https://github.com/No9"
+ },
+ {
+ "name": "Matteo Collina",
+ "email": "matteo.collina@gmail.com",
+ "url": "https://github.com/mcollina"
+ },
+ {
+ "name": "Pedro Teixeira",
+ "email": "pedro.teixeira@gmail.com",
+ "url": "https://github.com/pgte"
+ },
+ {
+ "name": "James Halliday",
+ "email": "mail@substack.net",
+ "url": "https://github.com/substack"
+ }
+ ],
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/rvagg/node-levelup.git"
+ },
+ "homepage": "https://github.com/rvagg/node-levelup",
+ "keywords": [
+ "leveldb",
+ "stream",
+ "database",
+ "db",
+ "store",
+ "storage",
+ "json"
+ ],
+ "main": "lib/levelup.js",
+ "dependencies": {
+ "bl": "~0.8.1",
+ "deferred-leveldown": "~0.2.0",
+ "errno": "~0.1.1",
+ "prr": "~0.0.0",
+ "readable-stream": "~1.0.26",
+ "semver": "~2.3.1",
+ "xtend": "~3.0.0"
+ },
+ "devDependencies": {
+ "leveldown": "~0.10.0",
+ "bustermove": "*",
+ "tap": "*",
+ "referee": "*",
+ "rimraf": "*",
+ "async": "*",
+ "fstream": "*",
+ "tar": "*",
+ "mkfiletree": "*",
+ "readfiletree": "*",
+ "slow-stream": ">=0.0.4",
+ "delayed": "*",
+ "boganipsum": "*",
+ "du": "*",
+ "memdown": "*",
+ "msgpack-js": "*"
+ },
+ "browser": {
+ "leveldown": false,
+ "leveldown/package": false,
+ "semver": false
+ },
+ "scripts": {
+ "test": "tap test/*-test.js --stderr",
+ "functionaltests": "node ./test/functional/fstream-test.js && node ./test/functional/binary-data-test.js && node ./test/functional/compat-test.js",
+ "alltests": "npm test && npm run-script functionaltests"
+ },
+ "license": "MIT",
+ "gitHead": "213e989e2b75273e2b44c23f84f95e35bff7ea11",
+ "bugs": {
+ "url": "https://github.com/rvagg/node-levelup/issues"
+ },
+ "_id": "levelup@0.18.6",
+ "_shasum": "e6a01cb089616c8ecc0291c2a9bd3f0c44e3e5eb",
+ "_from": "levelup@~0.18.4",
+ "_npmVersion": "1.4.14",
+ "_npmUser": {
+ "name": "rvagg",
+ "email": "rod@vagg.org"
+ },
+ "maintainers": [
+ {
+ "name": "rvagg",
+ "email": "rod@vagg.org"
+ }
+ ],
+ "dist": {
+ "shasum": "e6a01cb089616c8ecc0291c2a9bd3f0c44e3e5eb",
+ "tarball": "http://127.0.0.1:5080/tarballs/levelup/0.18.6.tgz"
+ },
+ "_resolved": "http://127.0.0.1:5080/tarballs/levelup/0.18.6.tgz",
+ "readme": "ERROR: No README data found!"
+}
+
+},{}],72:[function(require,module,exports){
+'use strict';
+
+module.exports = INTERNAL;
+
+function INTERNAL() {}
+},{}],73:[function(require,module,exports){
+'use strict';
+var Promise = require('./promise');
+var reject = require('./reject');
+var resolve = require('./resolve');
+var INTERNAL = require('./INTERNAL');
+var handlers = require('./handlers');
+var noArray = reject(new TypeError('must be an array'));
+module.exports = function all(iterable) {
+ if (Object.prototype.toString.call(iterable) !== '[object Array]') {
+ return noArray;
+ }
+
+ var len = iterable.length;
+ var called = false;
+ if (!len) {
+ return resolve([]);
+ }
+
+ var values = new Array(len);
+ var resolved = 0;
+ var i = -1;
+ var promise = new Promise(INTERNAL);
+
+ while (++i < len) {
+ allResolver(iterable[i], i);
+ }
+ return promise;
+ function allResolver(value, i) {
+ resolve(value).then(resolveFromAll, function (error) {
+ if (!called) {
+ called = true;
+ handlers.reject(promise, error);
+ }
+ });
+ function resolveFromAll(outValue) {
+ values[i] = outValue;
+ if (++resolved === len & !called) {
+ called = true;
+ handlers.resolve(promise, values);
+ }
+ }
+ }
+};
+},{"./INTERNAL":72,"./handlers":74,"./promise":76,"./reject":78,"./resolve":79}],74:[function(require,module,exports){
+'use strict';
+var tryCatch = require('./tryCatch');
+var resolveThenable = require('./resolveThenable');
+var states = require('./states');
+
+exports.resolve = function (self, value) {
+ var result = tryCatch(getThen, value);
+ if (result.status === 'error') {
+ return exports.reject(self, result.value);
+ }
+ var thenable = result.value;
+
+ if (thenable) {
+ resolveThenable.safely(self, thenable);
+ } else {
+ self.state = states.FULFILLED;
+ self.outcome = value;
+ var i = -1;
+ var len = self.queue.length;
+ while (++i < len) {
+ self.queue[i].callFulfilled(value);
+ }
+ }
+ return self;
+};
+exports.reject = function (self, error) {
+ self.state = states.REJECTED;
+ self.outcome = error;
+ var i = -1;
+ var len = self.queue.length;
+ while (++i < len) {
+ self.queue[i].callRejected(error);
+ }
+ return self;
+};
+
+function getThen(obj) {
+ // Make sure we only access the accessor once as required by the spec
+ var then = obj && obj.then;
+ if (obj && typeof obj === 'object' && typeof then === 'function') {
+ return function appyThen() {
+ then.apply(obj, arguments);
+ };
+ }
+}
+},{"./resolveThenable":80,"./states":81,"./tryCatch":82}],75:[function(require,module,exports){
+module.exports = exports = require('./promise');
+
+exports.resolve = require('./resolve');
+exports.reject = require('./reject');
+exports.all = require('./all');
+},{"./all":73,"./promise":76,"./reject":78,"./resolve":79}],76:[function(require,module,exports){
+'use strict';
+
+var unwrap = require('./unwrap');
+var INTERNAL = require('./INTERNAL');
+var resolveThenable = require('./resolveThenable');
+var states = require('./states');
+var QueueItem = require('./queueItem');
+
+module.exports = Promise;
+function Promise(resolver) {
+ if (!(this instanceof Promise)) {
+ return new Promise(resolver);
+ }
+ if (typeof resolver !== 'function') {
+ throw new TypeError('reslover must be a function');
+ }
+ this.state = states.PENDING;
+ this.queue = [];
+ this.outcome = void 0;
+ if (resolver !== INTERNAL) {
+ resolveThenable.safely(this, resolver);
+ }
+}
+
+Promise.prototype['catch'] = function (onRejected) {
+ return this.then(null, onRejected);
+};
+Promise.prototype.then = function (onFulfilled, onRejected) {
+ if (typeof onFulfilled !== 'function' && this.state === states.FULFILLED ||
+ typeof onRejected !== 'function' && this.state === states.REJECTED) {
+ return this;
+ }
+ var promise = new Promise(INTERNAL);
+
+
+ if (this.state !== states.PENDING) {
+ var resolver = this.state === states.FULFILLED ? onFulfilled: onRejected;
+ unwrap(promise, resolver, this.outcome);
+ } else {
+ this.queue.push(new QueueItem(promise, onFulfilled, onRejected));
+ }
+
+ return promise;
+};
+
+},{"./INTERNAL":72,"./queueItem":77,"./resolveThenable":80,"./states":81,"./unwrap":83}],77:[function(require,module,exports){
+'use strict';
+var handlers = require('./handlers');
+var unwrap = require('./unwrap');
+
+module.exports = QueueItem;
+function QueueItem(promise, onFulfilled, onRejected) {
+ this.promise = promise;
+ if (typeof onFulfilled === 'function') {
+ this.onFulfilled = onFulfilled;
+ this.callFulfilled = this.otherCallFulfilled;
+ }
+ if (typeof onRejected === 'function') {
+ this.onRejected = onRejected;
+ this.callRejected = this.otherCallRejected;
+ }
+}
+QueueItem.prototype.callFulfilled = function (value) {
+ handlers.resolve(this.promise, value);
+};
+QueueItem.prototype.otherCallFulfilled = function (value) {
+ unwrap(this.promise, this.onFulfilled, value);
+};
+QueueItem.prototype.callRejected = function (value) {
+ handlers.reject(this.promise, value);
+};
+QueueItem.prototype.otherCallRejected = function (value) {
+ unwrap(this.promise, this.onRejected, value);
+};
+},{"./handlers":74,"./unwrap":83}],78:[function(require,module,exports){
+'use strict';
+
+var Promise = require('./promise');
+var INTERNAL = require('./INTERNAL');
+var handlers = require('./handlers');
+module.exports = reject;
+
+function reject(reason) {
+ var promise = new Promise(INTERNAL);
+ return handlers.reject(promise, reason);
+}
+},{"./INTERNAL":72,"./handlers":74,"./promise":76}],79:[function(require,module,exports){
+'use strict';
+
+var Promise = require('./promise');
+var INTERNAL = require('./INTERNAL');
+var handlers = require('./handlers');
+module.exports = resolve;
+
+var FALSE = handlers.resolve(new Promise(INTERNAL), false);
+var NULL = handlers.resolve(new Promise(INTERNAL), null);
+var UNDEFINED = handlers.resolve(new Promise(INTERNAL), void 0);
+var ZERO = handlers.resolve(new Promise(INTERNAL), 0);
+var EMPTYSTRING = handlers.resolve(new Promise(INTERNAL), '');
+
+function resolve(value) {
+ if (value) {
+ if (value instanceof Promise) {
+ return value;
+ }
+ return handlers.resolve(new Promise(INTERNAL), value);
+ }
+ var valueType = typeof value;
+ switch (valueType) {
+ case 'boolean':
+ return FALSE;
+ case 'undefined':
+ return UNDEFINED;
+ case 'object':
+ return NULL;
+ case 'number':
+ return ZERO;
+ case 'string':
+ return EMPTYSTRING;
+ }
+}
+},{"./INTERNAL":72,"./handlers":74,"./promise":76}],80:[function(require,module,exports){
+'use strict';
+var handlers = require('./handlers');
+var tryCatch = require('./tryCatch');
+function safelyResolveThenable(self, thenable) {
+ // Either fulfill, reject or reject with error
+ var called = false;
+ function onError(value) {
+ if (called) {
+ return;
+ }
+ called = true;
+ handlers.reject(self, value);
+ }
+
+ function onSuccess(value) {
+ if (called) {
+ return;
+ }
+ called = true;
+ handlers.resolve(self, value);
+ }
+
+ function tryToUnwrap() {
+ thenable(onSuccess, onError);
+ }
+
+ var result = tryCatch(tryToUnwrap);
+ if (result.status === 'error') {
+ onError(result.value);
+ }
+}
+exports.safely = safelyResolveThenable;
+},{"./handlers":74,"./tryCatch":82}],81:[function(require,module,exports){
+// Lazy man's symbols for states
+
+exports.REJECTED = ['REJECTED'];
+exports.FULFILLED = ['FULFILLED'];
+exports.PENDING = ['PENDING'];
+},{}],82:[function(require,module,exports){
+'use strict';
+
+module.exports = tryCatch;
+
+function tryCatch(func, value) {
+ var out = {};
+ try {
+ out.value = func(value);
+ out.status = 'success';
+ } catch (e) {
+ out.status = 'error';
+ out.value = e;
+ }
+ return out;
+}
+},{}],83:[function(require,module,exports){
+'use strict';
+
+var immediate = require('immediate');
+var handlers = require('./handlers');
+module.exports = unwrap;
+
+function unwrap(promise, func, value) {
+ immediate(function () {
+ var returnValue;
+ try {
+ returnValue = func(value);
+ } catch (e) {
+ return handlers.reject(promise, e);
+ }
+ if (returnValue === promise) {
+ handlers.reject(promise, new TypeError('Cannot resolve promise with itself'));
+ } else {
+ handlers.resolve(promise, returnValue);
+ }
+ });
+}
+},{"./handlers":74,"immediate":84}],84:[function(require,module,exports){
+'use strict';
+var types = [
+ require('./nextTick'),
+ require('./mutation.js'),
+ require('./messageChannel'),
+ require('./stateChange'),
+ require('./timeout')
+];
+var draining;
+var queue = [];
+function drainQueue() {
+ draining = true;
+ var i, oldQueue;
+ var len = queue.length;
+ while (len) {
+ oldQueue = queue;
+ queue = [];
+ i = -1;
+ while (++i < len) {
+ oldQueue[i]();
+ }
+ len = queue.length;
+ }
+ draining = false;
+}
+var scheduleDrain;
+var i = -1;
+var len = types.length;
+while (++ i < len) {
+ if (types[i] && types[i].test && types[i].test()) {
+ scheduleDrain = types[i].install(drainQueue);
+ break;
+ }
+}
+module.exports = immediate;
+function immediate(task) {
+ if (queue.push(task) === 1 && !draining) {
+ scheduleDrain();
+ }
+}
+},{"./messageChannel":85,"./mutation.js":86,"./nextTick":17,"./stateChange":87,"./timeout":88}],85:[function(require,module,exports){
+(function (global){
+'use strict';
+
+exports.test = function () {
+ if (global.setImmediate) {
+ // we can only get here in IE10
+ // which doesn't handel postMessage well
+ return false;
+ }
+ return typeof global.MessageChannel !== 'undefined';
+};
+
+exports.install = function (func) {
+ var channel = new global.MessageChannel();
+ channel.port1.onmessage = func;
+ return function () {
+ channel.port2.postMessage(0);
+ };
+};
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],86:[function(require,module,exports){
+(function (global){
+'use strict';
+//based off rsvp https://github.com/tildeio/rsvp.js
+//license https://github.com/tildeio/rsvp.js/blob/master/LICENSE
+//https://github.com/tildeio/rsvp.js/blob/master/lib/rsvp/asap.js
+
+var Mutation = global.MutationObserver || global.WebKitMutationObserver;
+
+exports.test = function () {
+ return Mutation;
+};
+
+exports.install = function (handle) {
+ var called = 0;
+ var observer = new Mutation(handle);
+ var element = global.document.createTextNode('');
+ observer.observe(element, {
+ characterData: true
+ });
+ return function () {
+ element.data = (called = ++called % 2);
+ };
+};
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],87:[function(require,module,exports){
+(function (global){
+'use strict';
+
+exports.test = function () {
+ return 'document' in global && 'onreadystatechange' in global.document.createElement('script');
+};
+
+exports.install = function (handle) {
+ return function () {
+
+ // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
+ // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
+ var scriptEl = global.document.createElement('script');
+ scriptEl.onreadystatechange = function () {
+ handle();
+
+ scriptEl.onreadystatechange = null;
+ scriptEl.parentNode.removeChild(scriptEl);
+ scriptEl = null;
+ };
+ global.document.documentElement.appendChild(scriptEl);
+
+ return handle;
+ };
+};
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],88:[function(require,module,exports){
+'use strict';
+exports.test = function () {
+ return true;
+};
+
+exports.install = function (t) {
+ return function () {
+ setTimeout(t, 0);
+ };
+};
+},{}],"3WVjcl":[function(require,module,exports){
+(function (process,global,Buffer){
+var util = require('util')
+ , AbstractLevelDOWN = require('abstract-leveldown').AbstractLevelDOWN
+ , AbstractIterator = require('abstract-leveldown').AbstractIterator
+ , noop = function () {}
+ , setImmediate = global.setImmediate || process.nextTick
+
+function ldIterator (db, options) {
+
+
+ AbstractIterator.call(this, db)
+ var emptybuffer = new Buffer(0)
+
+ this._dbsize = this.db.container.length();
+ this._reverse = !!options.reverse
+
+ // Test for empty buffer in end
+ if(options.end instanceof Buffer){
+ if(options.end.length = 0)
+ this._end = this.db.container.key(this._dbsize - 1)
+ }else{
+ this._end = options.end
+ }
+
+ this._limit = options.limit
+ this._count = 0
+
+ if (options.start) {
+ // if pos is more than the size of the database then set pos to the end
+ var found = false;
+ for (var i = 0; i < this._dbsize; i++) {
+ if (this.db.container.key(i) >= options.start) {
+ this._pos = i
+ //Make sure we step back for mid values e.g 49.5 test
+ if(this._reverse){
+ if(this.db.container.key(i) > options.start){
+ this._pos = i -1
+ }else{
+ this._pos = i
+ }
+ }
+ found = true;
+ break
+
+ }
+ }
+ if(!found){
+ this._pos = this._reverse ? this._dbsize - 1 : -1
+ }
+
+ } else {
+ this._pos = this._reverse ? this._dbsize - 1 : 0
+ }
+}
+
+util.inherits(ldIterator, AbstractIterator)
+
+ldIterator.prototype._next = function (callback) {
+
+ if (this._pos >= this.db.container.length() || this._pos < 0)
+ return setImmediate(callback)
+ var key = this.db.container.key(this._pos)
+ , value
+
+ if (!!this._end && (this._reverse ? key < this._end : key > this._end))
+ return setImmediate(callback)
+
+
+ if (!!this._limit && this._limit > 0 && this._count++ >= this._limit)
+ return setImmediate(callback)
+
+ value = this.db.container.getItem(key)
+ this._pos += this._reverse ? -1 : 1
+
+ setImmediate(callback.bind(null, undefined, key, value))
+}
+
+function ld (location) {
+ if (!(this instanceof ld)) return new ld(location)
+ AbstractLevelDOWN.call(this, location)
+ var wstore = require('./localstorage').localStorage;
+ this.container = new wstore(location);
+}
+
+util.inherits(ld, AbstractLevelDOWN)
+
+ld.prototype._open = function (options, callback) {
+ setImmediate(function () { callback(null, this) }.bind(this))
+
+}
+
+ld.prototype._put = function (key, value, options, callback) {
+
+ var err = checkKeyValue(key, 'key')
+
+ if (err) return callback(err)
+
+ err = checkKeyValue(value, 'value')
+
+ if (err) return callback(err)
+
+ if(typeof value == 'object' && !Buffer.isBuffer(value) && value.buffer == undefined){
+ var obj = {};
+ obj.storetype = "json";
+ obj.data = value;
+ value = JSON.stringify(obj)
+ }
+
+ this.container.setItem(key, value);
+ setImmediate(callback)
+}
+
+ld.prototype._get = function (key, options, callback) {
+
+ var err = checkKeyValue(key, 'key')
+
+ if (err) return callback(err)
+
+ if (!isBuffer(key)){
+ key = String(key)
+ }
+ var value = this.container.getItem(key);
+
+ if (value === undefined) {
+ // 'NotFound' error, consistent with LevelDOWN API
+ return setImmediate(function () { callback(new Error('NotFound: ')) })
+ }
+
+
+ if (options.asBuffer !== false && !Buffer.isBuffer(value)){
+ value = new Buffer(String(value))
+ }
+
+
+ if(options.asBuffer === false){
+ if(value.indexOf("{\"storetype\":\"json\",\"data\"") > -1){
+ var res = JSON.parse(value);
+ value = res.data;
+ }
+ }
+
+ setImmediate(function () {
+ callback(null, value)
+ })
+}
+
+ld.prototype._del = function (key, options, callback) {
+
+ var err = checkKeyValue(key, 'key')
+
+ if (err) return callback(err)
+ if (!isBuffer(key)) key = String(key)
+
+ this.container.removeItem(key);
+ setImmediate(callback)
+}
+
+ld.prototype._batch = function (array, options, callback) {
+ var err
+ , i = 0
+ , key
+ , value
+ if (Array.isArray(array)) {
+ for (; i < array.length; i++) {
+ if (array[i]) {
+ key = Buffer.isBuffer(array[i].key) ? array[i].key : String(array[i].key)
+ err = checkKeyValue(key, 'key')
+ if (err) return setImmediate(callback.bind(null, err))
+ if (array[i].type === 'del') {
+ this._del(array[i].key, options, noop)
+ } else if (array[i].type === 'put') {
+ value = Buffer.isBuffer(array[i].value) ? array[i].value : String(array[i].value)
+ err = checkKeyValue(value, 'value')
+ if (err) return setImmediate(callback.bind(null, err))
+ this._put(key, value, options, noop)
+ }
+ }
+ }
+ }
+ setImmediate(callback)
+}
+
+ld.prototype._iterator = function (options) {
+ return new ldIterator(this, options)
+}
+
+ld.destroy = function (name, callback) {
+ try {
+ Object.keys(localStorage)
+ .forEach(function (key) {
+ if (key.substring(0, name.length + 1) == (name + "!")) {
+ localStorage.removeItem(key)
+ }
+ })
+ callback()
+ } catch (e) {
+ // fail gracefully if no localStorage
+ }
+}
+
+
+function subarray(start, end) {
+ return this.slice(start, end)
+}
+
+function set_(array, offset) {
+
+ if (arguments.length < 2) offset = 0
+
+ for (var i = 0, n = array.length; i < n; ++i, ++offset)
+ this[offset] = array[i] & 0xFF
+}
+
+// we need typed arrays
+function TypedArray(arg1) {
+var result;
+ if (typeof arg1 === "number") {
+ result = new Array(arg1);
+
+ for (var i = 0; i < arg1; ++i)
+ result[i] = 0;
+ } else
+ result = arg1.slice(0)
+
+ result.subarray = subarray
+ result.buffer = result
+ result.byteLength = result.length
+ result.set = set_
+
+
+
+ if (typeof arg1 === "object" && arg1.buffer)
+ result.buffer = arg1.buffer
+
+ return result
+
+}
+
+/*
+if(!window.Uint8Array){
+ window.Uint8Array = TypedArray;
+ window.Uint16Array = TypedArray;
+ window.Uint32Array = TypedArray;
+ window.Int32Array = TypedArray;
+}
+*/
+function isBuffer(buf) {
+ return buf instanceof ArrayBuffer
+}
+
+function checkKeyValue (obj, type) {
+ if (obj === null || obj === undefined)
+ return new Error(type + ' cannot be `null` or `undefined`')
+ if (obj === null || obj === undefined)
+ return new Error(type + ' cannot be `null` or `undefined`')
+
+ if(type === 'key'){
+
+ if(obj instanceof Boolean){
+ return new Error(type + ' cannot be `null` or `undefined`')
+ }
+ if(obj === ''){
+ return new Error(type + ' cannot be empty')
+ }
+/*
+ if(isBuffer(obj)) {
+
+ return new Error(type + 'cannot be an empty Buffer')
+ }*/
+ }
+ if(obj.toString().indexOf("[object ArrayBuffer]") == 0){
+ if(obj.byteLength == 0 || obj.byteLength == undefined){
+ return new Error(type + ' cannot be an empty Buffer')
+ }
+ }
+
+ /*if(obj.toString().indexOf("[object Uint8Array]") == 0){
+ if(obj.byteLength == 0 || obj.byteLength == undefined){
+ return new Error(type + ' cannot be an empty ArrayBuffer')
+ }
+ } */
+ if (isBuffer(obj)) {
+
+
+ if (obj.length === 0)
+ return new Error(type + ' cannot be an empty Buffer')
+ } else if (String(obj) === '')
+ return new Error(type + ' cannot be an empty String')
+}
+
+
+
+module.exports = ld
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer)
+},{"./localstorage":91,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"abstract-leveldown":94,"buffer":20,"util":32}],"leveldown":[function(require,module,exports){
+module.exports=require('3WVjcl');
+},{}],91:[function(require,module,exports){
+function localStorage(dbname){
+ this._partition = dbname;
+ this._keys = [];
+
+ for (var i = 0; i < window.localStorage.length; i++){
+ if(window.localStorage.key(i).indexOf(dbname + '!') == 0)
+ this._keys.push(window.localStorage.key(i))
+ }
+ this._keys.sort();
+}
+
+//key: Returns the name of the key at the position specified.
+localStorage.prototype.key = function (keyindex){
+ var retVal = this._keys[keyindex];
+ if(typeof retVal !== 'undefined'){
+ // this needs to be a last and first;
+ return this._keys[keyindex].replace(this._partition + '!', "").replace("!bin");
+ }else{
+ return retVal;
+ }
+}
+
+//setItem: Saves and item at the key provided.
+localStorage.prototype.setItem = function (key, value){
+ key = this._partition + "!" + key;
+
+ if(value instanceof ArrayBuffer) {
+ var bencode = "ArrayBuffer:";
+ value = bencode + btoa(String.fromCharCode.apply(null, value))
+ }
+
+ if(value instanceof Uint8Array){
+ var bencode = "Uint8Array:";
+ value = bencode + btoa(String.fromCharCode.apply(null, value))
+
+ }
+
+ for (var i = 0; i < this._keys.length; i++) {
+ if (this._keys[i] === key) {
+ window.localStorage.setItem(key, value);
+ return;
+ }
+ }
+
+ this._keys.push(key)
+ this._keys.sort()
+ window.localStorage.setItem(key, value);
+
+}
+
+//getItem: Returns the item identified by it's key.
+localStorage.prototype.getItem = function (key){
+ key = this._partition + "!" + key
+ var retval = window.localStorage.getItem(key)
+ if(retval == null){
+ return undefined;
+ }
+
+ if(retval.indexOf('ArrayBuffer:') == 0) {
+ var value = retval.replace("ArrayBuffer:", "");
+ retval = new ArrayBuffer(atob(value).split('').map(function(c) {
+ return c.charCodeAt(0);
+ }));
+ return retval;
+ }
+
+ if(retval.indexOf('Uint8Array:') == 0) {
+ var value = retval.replace("Uint8Array:", "");
+ //This should be in but there seems to be a bug in TAPE?
+ /*
+ retval = new Uint8Array(atob(value).split('').map(function(c) {
+ return c.charCodeAt(0);
+ }));
+ */
+ return atob(value);
+ }
+ return retval;
+}
+
+//removeItem: Removes the item identified by it's key.
+localStorage.prototype.removeItem = function (key){
+ key = this._partition + "!" + key
+
+ for(var i = this._keys.length; i >= 0; i--) {
+ if(this._keys[i] === key) {
+ this._keys.splice(i, 1);
+ window.localStorage.removeItem(key);
+ }
+ }
+}
+
+ //clear: Removes all of the key value pairs.
+localStorage.prototype.clear = function (){
+ window.localStorage.clear()
+}
+
+localStorage.prototype.length = function(){
+
+ return this._keys.length
+}
+
+exports.localStorage = localStorage;
+
+},{}],92:[function(require,module,exports){
+module.exports=require(55)
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],93:[function(require,module,exports){
+module.exports=require(56)
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],94:[function(require,module,exports){
+arguments[4][57][0].apply(exports,arguments)
+},{"./abstract-chained-batch":92,"./abstract-iterator":93,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"xtend":96}],95:[function(require,module,exports){
+module.exports=require(40)
+},{}],96:[function(require,module,exports){
+arguments[4][41][0].apply(exports,arguments)
+},{"./has-keys":95,"object-keys":98}],97:[function(require,module,exports){
+var hasOwn = Object.prototype.hasOwnProperty;
+var toString = Object.prototype.toString;
+
+var isFunction = function (fn) {
+ var isFunc = (typeof fn === 'function' && !(fn instanceof RegExp)) || toString.call(fn) === '[object Function]';
+ if (!isFunc && typeof window !== 'undefined') {
+ isFunc = fn === window.setTimeout || fn === window.alert || fn === window.confirm || fn === window.prompt;
+ }
+ return isFunc;
+};
+
+module.exports = function forEach(obj, fn) {
+ if (!isFunction(fn)) {
+ throw new TypeError('iterator must be a function');
+ }
+ var i, k,
+ isString = typeof obj === 'string',
+ l = obj.length,
+ context = arguments.length > 2 ? arguments[2] : null;
+ if (l === +l) {
+ for (i = 0; i < l; i++) {
+ if (context === null) {
+ fn(isString ? obj.charAt(i) : obj[i], i, obj);
+ } else {
+ fn.call(context, isString ? obj.charAt(i) : obj[i], i, obj);
+ }
+ }
+ } else {
+ for (k in obj) {
+ if (hasOwn.call(obj, k)) {
+ if (context === null) {
+ fn(obj[k], k, obj);
+ } else {
+ fn.call(context, obj[k], k, obj);
+ }
+ }
+ }
+ }
+};
+
+
+},{}],98:[function(require,module,exports){
+arguments[4][42][0].apply(exports,arguments)
+},{"./shim":100}],99:[function(require,module,exports){
+var toString = Object.prototype.toString;
+
+module.exports = function isArguments(value) {
+ var str = toString.call(value);
+ var isArguments = str === '[object Arguments]';
+ if (!isArguments) {
+ isArguments = str !== '[object Array]'
+ && value !== null
+ && typeof value === 'object'
+ && typeof value.length === 'number'
+ && value.length >= 0
+ && toString.call(value.callee) === '[object Function]';
+ }
+ return isArguments;
+};
+
+
+},{}],100:[function(require,module,exports){
+(function () {
+ "use strict";
+
+ // modified from https://github.com/kriskowal/es5-shim
+ var has = Object.prototype.hasOwnProperty,
+ toString = Object.prototype.toString,
+ forEach = require('./foreach'),
+ isArgs = require('./isArguments'),
+ hasDontEnumBug = !({'toString': null}).propertyIsEnumerable('toString'),
+ hasProtoEnumBug = (function () {}).propertyIsEnumerable('prototype'),
+ dontEnums = [
+ "toString",
+ "toLocaleString",
+ "valueOf",
+ "hasOwnProperty",
+ "isPrototypeOf",
+ "propertyIsEnumerable",
+ "constructor"
+ ],
+ keysShim;
+
+ keysShim = function keys(object) {
+ var isObject = object !== null && typeof object === 'object',
+ isFunction = toString.call(object) === '[object Function]',
+ isArguments = isArgs(object),
+ theKeys = [];
+
+ if (!isObject && !isFunction && !isArguments) {
+ throw new TypeError("Object.keys called on a non-object");
+ }
+
+ if (isArguments) {
+ forEach(object, function (value) {
+ theKeys.push(value);
+ });
+ } else {
+ var name,
+ skipProto = hasProtoEnumBug && isFunction;
+
+ for (name in object) {
+ if (!(skipProto && name === 'prototype') && has.call(object, name)) {
+ theKeys.push(name);
+ }
+ }
+ }
+
+ if (hasDontEnumBug) {
+ var ctor = object.constructor,
+ skipConstructor = ctor && ctor.prototype === object;
+
+ forEach(dontEnums, function (dontEnum) {
+ if (!(skipConstructor && dontEnum === 'constructor') && has.call(object, dontEnum)) {
+ theKeys.push(dontEnum);
+ }
+ });
+ }
+ return theKeys;
+ };
+
+ module.exports = keysShim;
+}());
+
+
+},{"./foreach":97,"./isArguments":99}],101:[function(require,module,exports){
+"use strict";
+
+// Extends method
+// (taken from http://code.jquery.com/jquery-1.9.0.js)
+// Populate the class2type map
+var class2type = {};
+
+var types = [
+ "Boolean", "Number", "String", "Function", "Array",
+ "Date", "RegExp", "Object", "Error"
+];
+for (var i = 0; i < types.length; i++) {
+ var typename = types[i];
+ class2type["[object " + typename + "]"] = typename.toLowerCase();
+}
+
+var core_toString = class2type.toString;
+var core_hasOwn = class2type.hasOwnProperty;
+
+function type(obj) {
+ if (obj === null) {
+ return String(obj);
+ }
+ return typeof obj === "object" || typeof obj === "function" ?
+ class2type[core_toString.call(obj)] || "object" :
+ typeof obj;
+}
+
+function isWindow(obj) {
+ return obj !== null && obj === obj.window;
+}
+
+function isPlainObject(obj) {
+ // Must be an Object.
+ // Because of IE, we also have to check the presence of
+ // the constructor property.
+ // Make sure that DOM nodes and window objects don't pass through, as well
+ if (!obj || type(obj) !== "object" || obj.nodeType || isWindow(obj)) {
+ return false;
+ }
+
+ try {
+ // Not own constructor property must be Object
+ if (obj.constructor &&
+ !core_hasOwn.call(obj, "constructor") &&
+ !core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) {
+ return false;
+ }
+ } catch ( e ) {
+ // IE8,9 Will throw exceptions on certain host objects #9897
+ return false;
+ }
+
+ // Own properties are enumerated firstly, so to speed up,
+ // if last one is own, then all properties are own.
+ var key;
+ for (key in obj) {}
+
+ return key === undefined || core_hasOwn.call(obj, key);
+}
+
+
+function isFunction(obj) {
+ return type(obj) === "function";
+}
+
+var isArray = Array.isArray || function (obj) {
+ return type(obj) === "array";
+};
+
+function extend() {
+ var options, name, src, copy, copyIsArray, clone,
+ target = arguments[0] || {},
+ i = 1,
+ length = arguments.length,
+ deep = false;
+
+ // Handle a deep copy situation
+ if (typeof target === "boolean") {
+ deep = target;
+ target = arguments[1] || {};
+ // skip the boolean and the target
+ i = 2;
+ }
+
+ // Handle case when target is a string or something (possible in deep copy)
+ if (typeof target !== "object" && !isFunction(target)) {
+ target = {};
+ }
+
+ // extend jQuery itself if only one argument is passed
+ if (length === i) {
+ /* jshint validthis: true */
+ target = this;
+ --i;
+ }
+
+ for (; i < length; i++) {
+ // Only deal with non-null/undefined values
+ if ((options = arguments[i]) != null) {
+ // Extend the base object
+ for (name in options) {
+ //if (options.hasOwnProperty(name)) {
+ if (!(name in Object.prototype)) {
+
+ src = target[name];
+ copy = options[name];
+
+ // Prevent never-ending loop
+ if (target === copy) {
+ continue;
+ }
+
+ // Recurse if we're merging plain objects or arrays
+ if (deep && copy && (isPlainObject(copy) ||
+ (copyIsArray = isArray(copy)))) {
+ if (copyIsArray) {
+ copyIsArray = false;
+ clone = src && isArray(src) ? src : [];
+
+ } else {
+ clone = src && isPlainObject(src) ? src : {};
+ }
+
+ // Never move original objects, clone them
+ target[name] = extend(deep, clone, copy);
+
+ // Don't bring in undefined values
+ } else if (copy !== undefined) {
+ if (!(isArray(options) && isFunction(copy))) {
+ target[name] = copy;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Return the modified object
+ return target;
+}
+
+
+module.exports = extend;
+
+
+
+},{}],102:[function(require,module,exports){
+/*jshint bitwise:false*/
+/*global unescape*/
+
+(function (factory) {
+ if (typeof exports === 'object') {
+ // Node/CommonJS
+ module.exports = factory();
+ } else if (typeof define === 'function' && define.amd) {
+ // AMD
+ define(factory);
+ } else {
+ // Browser globals (with support for web workers)
+ var glob;
+ try {
+ glob = window;
+ } catch (e) {
+ glob = self;
+ }
+
+ glob.SparkMD5 = factory();
+ }
+}(function (undefined) {
+
+ 'use strict';
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ /*
+ * Fastest md5 implementation around (JKM md5)
+ * Credits: Joseph Myers
+ *
+ * @see http://www.myersdaily.org/joseph/javascript/md5-text.html
+ * @see http://jsperf.com/md5-shootout/7
+ */
+
+ /* this function is much faster,
+ so if possible we use it. Some IEs
+ are the only ones I know of that
+ need the idiotic second function,
+ generated by an if clause. */
+ var add32 = function (a, b) {
+ return (a + b) & 0xFFFFFFFF;
+ },
+
+ cmn = function (q, a, b, x, s, t) {
+ a = add32(add32(a, q), add32(x, t));
+ return add32((a << s) | (a >>> (32 - s)), b);
+ },
+
+ ff = function (a, b, c, d, x, s, t) {
+ return cmn((b & c) | ((~b) & d), a, b, x, s, t);
+ },
+
+ gg = function (a, b, c, d, x, s, t) {
+ return cmn((b & d) | (c & (~d)), a, b, x, s, t);
+ },
+
+ hh = function (a, b, c, d, x, s, t) {
+ return cmn(b ^ c ^ d, a, b, x, s, t);
+ },
+
+ ii = function (a, b, c, d, x, s, t) {
+ return cmn(c ^ (b | (~d)), a, b, x, s, t);
+ },
+
+ md5cycle = function (x, k) {
+ var a = x[0],
+ b = x[1],
+ c = x[2],
+ d = x[3];
+
+ a = ff(a, b, c, d, k[0], 7, -680876936);
+ d = ff(d, a, b, c, k[1], 12, -389564586);
+ c = ff(c, d, a, b, k[2], 17, 606105819);
+ b = ff(b, c, d, a, k[3], 22, -1044525330);
+ a = ff(a, b, c, d, k[4], 7, -176418897);
+ d = ff(d, a, b, c, k[5], 12, 1200080426);
+ c = ff(c, d, a, b, k[6], 17, -1473231341);
+ b = ff(b, c, d, a, k[7], 22, -45705983);
+ a = ff(a, b, c, d, k[8], 7, 1770035416);
+ d = ff(d, a, b, c, k[9], 12, -1958414417);
+ c = ff(c, d, a, b, k[10], 17, -42063);
+ b = ff(b, c, d, a, k[11], 22, -1990404162);
+ a = ff(a, b, c, d, k[12], 7, 1804603682);
+ d = ff(d, a, b, c, k[13], 12, -40341101);
+ c = ff(c, d, a, b, k[14], 17, -1502002290);
+ b = ff(b, c, d, a, k[15], 22, 1236535329);
+
+ a = gg(a, b, c, d, k[1], 5, -165796510);
+ d = gg(d, a, b, c, k[6], 9, -1069501632);
+ c = gg(c, d, a, b, k[11], 14, 643717713);
+ b = gg(b, c, d, a, k[0], 20, -373897302);
+ a = gg(a, b, c, d, k[5], 5, -701558691);
+ d = gg(d, a, b, c, k[10], 9, 38016083);
+ c = gg(c, d, a, b, k[15], 14, -660478335);
+ b = gg(b, c, d, a, k[4], 20, -405537848);
+ a = gg(a, b, c, d, k[9], 5, 568446438);
+ d = gg(d, a, b, c, k[14], 9, -1019803690);
+ c = gg(c, d, a, b, k[3], 14, -187363961);
+ b = gg(b, c, d, a, k[8], 20, 1163531501);
+ a = gg(a, b, c, d, k[13], 5, -1444681467);
+ d = gg(d, a, b, c, k[2], 9, -51403784);
+ c = gg(c, d, a, b, k[7], 14, 1735328473);
+ b = gg(b, c, d, a, k[12], 20, -1926607734);
+
+ a = hh(a, b, c, d, k[5], 4, -378558);
+ d = hh(d, a, b, c, k[8], 11, -2022574463);
+ c = hh(c, d, a, b, k[11], 16, 1839030562);
+ b = hh(b, c, d, a, k[14], 23, -35309556);
+ a = hh(a, b, c, d, k[1], 4, -1530992060);
+ d = hh(d, a, b, c, k[4], 11, 1272893353);
+ c = hh(c, d, a, b, k[7], 16, -155497632);
+ b = hh(b, c, d, a, k[10], 23, -1094730640);
+ a = hh(a, b, c, d, k[13], 4, 681279174);
+ d = hh(d, a, b, c, k[0], 11, -358537222);
+ c = hh(c, d, a, b, k[3], 16, -722521979);
+ b = hh(b, c, d, a, k[6], 23, 76029189);
+ a = hh(a, b, c, d, k[9], 4, -640364487);
+ d = hh(d, a, b, c, k[12], 11, -421815835);
+ c = hh(c, d, a, b, k[15], 16, 530742520);
+ b = hh(b, c, d, a, k[2], 23, -995338651);
+
+ a = ii(a, b, c, d, k[0], 6, -198630844);
+ d = ii(d, a, b, c, k[7], 10, 1126891415);
+ c = ii(c, d, a, b, k[14], 15, -1416354905);
+ b = ii(b, c, d, a, k[5], 21, -57434055);
+ a = ii(a, b, c, d, k[12], 6, 1700485571);
+ d = ii(d, a, b, c, k[3], 10, -1894986606);
+ c = ii(c, d, a, b, k[10], 15, -1051523);
+ b = ii(b, c, d, a, k[1], 21, -2054922799);
+ a = ii(a, b, c, d, k[8], 6, 1873313359);
+ d = ii(d, a, b, c, k[15], 10, -30611744);
+ c = ii(c, d, a, b, k[6], 15, -1560198380);
+ b = ii(b, c, d, a, k[13], 21, 1309151649);
+ a = ii(a, b, c, d, k[4], 6, -145523070);
+ d = ii(d, a, b, c, k[11], 10, -1120210379);
+ c = ii(c, d, a, b, k[2], 15, 718787259);
+ b = ii(b, c, d, a, k[9], 21, -343485551);
+
+ x[0] = add32(a, x[0]);
+ x[1] = add32(b, x[1]);
+ x[2] = add32(c, x[2]);
+ x[3] = add32(d, x[3]);
+ },
+
+ /* there needs to be support for Unicode here,
+ * unless we pretend that we can redefine the MD-5
+ * algorithm for multi-byte characters (perhaps
+ * by adding every four 16-bit characters and
+ * shortening the sum to 32 bits). Otherwise
+ * I suggest performing MD-5 as if every character
+ * was two bytes--e.g., 0040 0025 = @%--but then
+ * how will an ordinary MD-5 sum be matched?
+ * There is no way to standardize text to something
+ * like UTF-8 before transformation; speed cost is
+ * utterly prohibitive. The JavaScript standard
+ * itself needs to look at this: it should start
+ * providing access to strings as preformed UTF-8
+ * 8-bit unsigned value arrays.
+ */
+ md5blk = function (s) {
+ var md5blks = [],
+ i; /* Andy King said do it this way. */
+
+ for (i = 0; i < 64; i += 4) {
+ md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
+ }
+ return md5blks;
+ },
+
+ md5blk_array = function (a) {
+ var md5blks = [],
+ i; /* Andy King said do it this way. */
+
+ for (i = 0; i < 64; i += 4) {
+ md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
+ }
+ return md5blks;
+ },
+
+ md51 = function (s) {
+ var n = s.length,
+ state = [1732584193, -271733879, -1732584194, 271733878],
+ i,
+ length,
+ tail,
+ tmp,
+ lo,
+ hi;
+
+ for (i = 64; i <= n; i += 64) {
+ md5cycle(state, md5blk(s.substring(i - 64, i)));
+ }
+ s = s.substring(i - 64);
+ length = s.length;
+ tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+ for (i = 0; i < length; i += 1) {
+ tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
+ }
+ tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+ if (i > 55) {
+ md5cycle(state, tail);
+ for (i = 0; i < 16; i += 1) {
+ tail[i] = 0;
+ }
+ }
+
+ // Beware that the final length might not fit in 32 bits so we take care of that
+ tmp = n * 8;
+ tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+ lo = parseInt(tmp[2], 16);
+ hi = parseInt(tmp[1], 16) || 0;
+
+ tail[14] = lo;
+ tail[15] = hi;
+
+ md5cycle(state, tail);
+ return state;
+ },
+
+ md51_array = function (a) {
+ var n = a.length,
+ state = [1732584193, -271733879, -1732584194, 271733878],
+ i,
+ length,
+ tail,
+ tmp,
+ lo,
+ hi;
+
+ for (i = 64; i <= n; i += 64) {
+ md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
+ }
+
+ // Not sure if it is a bug, however IE10 will always produce a sub array of length 1
+ // containing the last element of the parent array if the sub array specified starts
+ // beyond the length of the parent array - weird.
+ // https://connect.microsoft.com/IE/feedback/details/771452/typed-array-subarray-issue
+ a = (i - 64) < n ? a.subarray(i - 64) : new Uint8Array(0);
+
+ length = a.length;
+ tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+ for (i = 0; i < length; i += 1) {
+ tail[i >> 2] |= a[i] << ((i % 4) << 3);
+ }
+
+ tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+ if (i > 55) {
+ md5cycle(state, tail);
+ for (i = 0; i < 16; i += 1) {
+ tail[i] = 0;
+ }
+ }
+
+ // Beware that the final length might not fit in 32 bits so we take care of that
+ tmp = n * 8;
+ tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+ lo = parseInt(tmp[2], 16);
+ hi = parseInt(tmp[1], 16) || 0;
+
+ tail[14] = lo;
+ tail[15] = hi;
+
+ md5cycle(state, tail);
+
+ return state;
+ },
+
+ hex_chr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'],
+
+ rhex = function (n) {
+ var s = '',
+ j;
+ for (j = 0; j < 4; j += 1) {
+ s += hex_chr[(n >> (j * 8 + 4)) & 0x0F] + hex_chr[(n >> (j * 8)) & 0x0F];
+ }
+ return s;
+ },
+
+ hex = function (x) {
+ var i;
+ for (i = 0; i < x.length; i += 1) {
+ x[i] = rhex(x[i]);
+ }
+ return x.join('');
+ },
+
+ md5 = function (s) {
+ return hex(md51(s));
+ },
+
+
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ /**
+ * SparkMD5 OOP implementation.
+ *
+ * Use this class to perform an incremental md5, otherwise use the
+ * static methods instead.
+ */
+ SparkMD5 = function () {
+ // call reset to init the instance
+ this.reset();
+ };
+
+
+ // In some cases the fast add32 function cannot be used..
+ if (md5('hello') !== '5d41402abc4b2a76b9719d911017c592') {
+ add32 = function (x, y) {
+ var lsw = (x & 0xFFFF) + (y & 0xFFFF),
+ msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+ return (msw << 16) | (lsw & 0xFFFF);
+ };
+ }
+
+
+ /**
+ * Appends a string.
+ * A conversion will be applied if an utf8 string is detected.
+ *
+ * @param {String} str The string to be appended
+ *
+ * @return {SparkMD5} The instance itself
+ */
+ SparkMD5.prototype.append = function (str) {
+ // converts the string to utf8 bytes if necessary
+ if (/[\u0080-\uFFFF]/.test(str)) {
+ str = unescape(encodeURIComponent(str));
+ }
+
+ // then append as binary
+ this.appendBinary(str);
+
+ return this;
+ };
+
+ /**
+ * Appends a binary string.
+ *
+ * @param {String} contents The binary string to be appended
+ *
+ * @return {SparkMD5} The instance itself
+ */
+ SparkMD5.prototype.appendBinary = function (contents) {
+ this._buff += contents;
+ this._length += contents.length;
+
+ var length = this._buff.length,
+ i;
+
+ for (i = 64; i <= length; i += 64) {
+ md5cycle(this._state, md5blk(this._buff.substring(i - 64, i)));
+ }
+
+ this._buff = this._buff.substr(i - 64);
+
+ return this;
+ };
+
+ /**
+ * Finishes the incremental computation, reseting the internal state and
+ * returning the result.
+ * Use the raw parameter to obtain the raw result instead of the hex one.
+ *
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.prototype.end = function (raw) {
+ var buff = this._buff,
+ length = buff.length,
+ i,
+ tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ ret;
+
+ for (i = 0; i < length; i += 1) {
+ tail[i >> 2] |= buff.charCodeAt(i) << ((i % 4) << 3);
+ }
+
+ this._finish(tail, length);
+ ret = !!raw ? this._state : hex(this._state);
+
+ this.reset();
+
+ return ret;
+ };
+
+ /**
+ * Finish the final calculation based on the tail.
+ *
+ * @param {Array} tail The tail (will be modified)
+ * @param {Number} length The length of the remaining buffer
+ */
+ SparkMD5.prototype._finish = function (tail, length) {
+ var i = length,
+ tmp,
+ lo,
+ hi;
+
+ tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+ if (i > 55) {
+ md5cycle(this._state, tail);
+ for (i = 0; i < 16; i += 1) {
+ tail[i] = 0;
+ }
+ }
+
+ // Do the final computation based on the tail and length
+ // Beware that the final length may not fit in 32 bits so we take care of that
+ tmp = this._length * 8;
+ tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+ lo = parseInt(tmp[2], 16);
+ hi = parseInt(tmp[1], 16) || 0;
+
+ tail[14] = lo;
+ tail[15] = hi;
+ md5cycle(this._state, tail);
+ };
+
+ /**
+ * Resets the internal state of the computation.
+ *
+ * @return {SparkMD5} The instance itself
+ */
+ SparkMD5.prototype.reset = function () {
+ this._buff = "";
+ this._length = 0;
+ this._state = [1732584193, -271733879, -1732584194, 271733878];
+
+ return this;
+ };
+
+ /**
+ * Releases memory used by the incremental buffer and other aditional
+ * resources. If you plan to use the instance again, use reset instead.
+ */
+ SparkMD5.prototype.destroy = function () {
+ delete this._state;
+ delete this._buff;
+ delete this._length;
+ };
+
+
+ /**
+ * Performs the md5 hash on a string.
+ * A conversion will be applied if utf8 string is detected.
+ *
+ * @param {String} str The string
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.hash = function (str, raw) {
+ // converts the string to utf8 bytes if necessary
+ if (/[\u0080-\uFFFF]/.test(str)) {
+ str = unescape(encodeURIComponent(str));
+ }
+
+ var hash = md51(str);
+
+ return !!raw ? hash : hex(hash);
+ };
+
+ /**
+ * Performs the md5 hash on a binary string.
+ *
+ * @param {String} content The binary string
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.hashBinary = function (content, raw) {
+ var hash = md51(content);
+
+ return !!raw ? hash : hex(hash);
+ };
+
+ /**
+ * SparkMD5 OOP implementation for array buffers.
+ *
+ * Use this class to perform an incremental md5 ONLY for array buffers.
+ */
+ SparkMD5.ArrayBuffer = function () {
+ // call reset to init the instance
+ this.reset();
+ };
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ /**
+ * Appends an array buffer.
+ *
+ * @param {ArrayBuffer} arr The array to be appended
+ *
+ * @return {SparkMD5.ArrayBuffer} The instance itself
+ */
+ SparkMD5.ArrayBuffer.prototype.append = function (arr) {
+ // TODO: we could avoid the concatenation here but the algorithm would be more complex
+ // if you find yourself needing extra performance, please make a PR.
+ var buff = this._concatArrayBuffer(this._buff, arr),
+ length = buff.length,
+ i;
+
+ this._length += arr.byteLength;
+
+ for (i = 64; i <= length; i += 64) {
+ md5cycle(this._state, md5blk_array(buff.subarray(i - 64, i)));
+ }
+
+ // Avoids IE10 weirdness (documented above)
+ this._buff = (i - 64) < length ? buff.subarray(i - 64) : new Uint8Array(0);
+
+ return this;
+ };
+
+ /**
+ * Finishes the incremental computation, reseting the internal state and
+ * returning the result.
+ * Use the raw parameter to obtain the raw result instead of the hex one.
+ *
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.ArrayBuffer.prototype.end = function (raw) {
+ var buff = this._buff,
+ length = buff.length,
+ tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ i,
+ ret;
+
+ for (i = 0; i < length; i += 1) {
+ tail[i >> 2] |= buff[i] << ((i % 4) << 3);
+ }
+
+ this._finish(tail, length);
+ ret = !!raw ? this._state : hex(this._state);
+
+ this.reset();
+
+ return ret;
+ };
+
+ SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;
+
+ /**
+ * Resets the internal state of the computation.
+ *
+ * @return {SparkMD5.ArrayBuffer} The instance itself
+ */
+ SparkMD5.ArrayBuffer.prototype.reset = function () {
+ this._buff = new Uint8Array(0);
+ this._length = 0;
+ this._state = [1732584193, -271733879, -1732584194, 271733878];
+
+ return this;
+ };
+
+ /**
+ * Releases memory used by the incremental buffer and other aditional
+ * resources. If you plan to use the instance again, use reset instead.
+ */
+ SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;
+
+ /**
+ * Concats two array buffers, returning a new one.
+ *
+ * @param {ArrayBuffer} first The first array buffer
+ * @param {ArrayBuffer} second The second array buffer
+ *
+ * @return {ArrayBuffer} The new array buffer
+ */
+ SparkMD5.ArrayBuffer.prototype._concatArrayBuffer = function (first, second) {
+ var firstLength = first.length,
+ result = new Uint8Array(firstLength + second.byteLength);
+
+ result.set(first);
+ result.set(new Uint8Array(second), firstLength);
+
+ return result;
+ };
+
+ /**
+ * Performs the md5 hash on an array buffer.
+ *
+ * @param {ArrayBuffer} arr The array buffer
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.ArrayBuffer.hash = function (arr, raw) {
+ var hash = md51_array(new Uint8Array(arr));
+
+ return !!raw ? hash : hex(hash);
+ };
+
+ return SparkMD5;
+}));
+
+},{}],103:[function(require,module,exports){
+arguments[4][61][0].apply(exports,arguments)
+},{"./_stream_readable":104,"./_stream_writable":106,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"core-util-is":107,"inherits":33}],104:[function(require,module,exports){
+module.exports=require(63)
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"core-util-is":107,"events":18,"inherits":33,"isarray":108,"stream":24,"string_decoder/":109}],105:[function(require,module,exports){
+arguments[4][64][0].apply(exports,arguments)
+},{"./_stream_duplex":103,"core-util-is":107,"inherits":33}],106:[function(require,module,exports){
+arguments[4][65][0].apply(exports,arguments)
+},{"./_stream_duplex":103,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"core-util-is":107,"inherits":33,"stream":24}],107:[function(require,module,exports){
+module.exports=require(66)
+},{"buffer":20}],108:[function(require,module,exports){
+module.exports=require(67)
+},{}],109:[function(require,module,exports){
+module.exports=require(68)
+},{"buffer":20}],110:[function(require,module,exports){
+module.exports = require("./lib/_stream_transform.js")
+
+},{"./lib/_stream_transform.js":105}],111:[function(require,module,exports){
+module.exports=require(40)
+},{}],112:[function(require,module,exports){
+arguments[4][41][0].apply(exports,arguments)
+},{"./has-keys":111,"object-keys":114}],113:[function(require,module,exports){
+module.exports=require(97)
+},{}],114:[function(require,module,exports){
+arguments[4][42][0].apply(exports,arguments)
+},{"./shim":116}],115:[function(require,module,exports){
+module.exports=require(99)
+},{}],116:[function(require,module,exports){
+module.exports=require(100)
+},{"./foreach":113,"./isArguments":115}],117:[function(require,module,exports){
+var Transform = require('readable-stream/transform')
+ , inherits = require('util').inherits
+ , xtend = require('xtend')
+
+
+// a noop _transform function
+function noop (chunk, enc, callback) {
+ callback(null, chunk)
+}
+
+
+// create a new export function, used by both the main export and
+// the .ctor export, contains common logic for dealing with arguments
+function through2 (construct) {
+ return function (options, transform, flush) {
+ if (typeof options == 'function') {
+ flush = transform
+ transform = options
+ options = {}
+ }
+
+ if (typeof transform != 'function')
+ transform = noop
+
+ if (typeof flush != 'function')
+ flush = null
+
+ return construct(options, transform, flush)
+ }
+}
+
+
+// main export, just make me a transform stream!
+module.exports = through2(function (options, transform, flush) {
+ var t2 = new Transform(options)
+
+ t2._transform = transform
+
+ if (flush)
+ t2._flush = flush
+
+ return t2
+})
+
+
+// make me a reusable prototype that I can `new`, or implicitly `new`
+// with a constructor call
+module.exports.ctor = through2(function (options, transform, flush) {
+ function Through2 (override) {
+ if (!(this instanceof Through2))
+ return new Through2(override)
+
+ this.options = xtend(options, override)
+
+ Transform.call(this, this.options)
+ }
+
+ inherits(Through2, Transform)
+
+ Through2.prototype._transform = transform
+
+ if (flush)
+ Through2.prototype._flush = flush
+
+ return Through2
+})
+
+
+module.exports.obj = through2(function (options, transform, flush) {
+ var t2 = new Transform(xtend({ objectMode: true }, options))
+
+ t2._transform = transform
+
+ if (flush)
+ t2._flush = flush
+
+ return t2
+})
+
+},{"readable-stream/transform":110,"util":32,"xtend":112}]},{},[11])
\ No newline at end of file
diff --git a/dist/pouchdb.localstorage.min.js b/dist/pouchdb.localstorage.min.js
new file mode 100644
index 0000000..1a36877
--- /dev/null
+++ b/dist/pouchdb.localstorage.min.js
@@ -0,0 +1,13 @@
+// PouchDB localStorage plugin 3.0.1
+// Based on localstorage-down: https://github.com/No9/localstorage-down
+//
+// (c) 2012-2014 Dale Harvey and the PouchDB team
+// PouchDB may be freely distributed under the Apache license, version 2.0.
+// For all details and documentation:
+// http://pouchdb.com
+require=function e(t,n,r){function i(s,a){if(!n[s]){if(!t[s]){var u="function"==typeof require&&require;if(!a&&u)return u(s,!0);if(o)return o(s,!0);throw new Error("Cannot find module '"+s+"'")}var c=n[s]={exports:{}};t[s][0].call(c.exports,function(e){var n=t[s][1][e];return i(n?n:e)},c,c.exports,e,t,n,r)}return n[s].exports}for(var o="function"==typeof require&&require,s=0;s<r.length;s++)i(r[s]);return i}({1:[function(e,t){(function(n,r,i){"use strict";function o(e,t){function x(){B.docStore=C.sublevel(p,{valueEncoding:"json"}),B.bySeqStore=C.sublevel(g,{valueEncoding:"json"}),B.attachmentStore=C.sublevel(y,{valueEncoding:"json"}),B.binaryStore=C.sublevel(v,{valueEncoding:"binary"}),B.localStore=C.sublevel(b,{valueEncoding:"json"}),B.metaStore=C.sublevel(m,{valueEncoding:"json"}),h.localAndMetaStores(C,B,function(){B.metaStore.get(E,function(e,r){"undefined"==typeof C._updateSeq&&(C._updateSeq=r||0),B.metaStore.get(k,function(e,r){C._docCountQueue.docCount=e?0:r,j(function(e){e&&N.emit("error",e),B.metaStore.get(S,function(e,r){R=e?d.uuid():r,B.metaStore.put(S,R,function(){n.nextTick(function(){t(null,N)})})})})})})})}function j(e){return C._docCountQueue.running||!C._docCountQueue.queue.length||-1===C._docCountQueue.docCount?A(0,e):C._docCountQueue.docCount}function O(){if(!C._docCountQueue.running&&C._docCountQueue.queue.length&&-1!==C._docCountQueue.docCount){C._docCountQueue.running=!0;var e=C._docCountQueue.queue.shift();return C.isClosed()?e.callback(new Error("database is closed")):void B.metaStore.get(k,function(t,n){function r(t){C._docCountQueue.docCount=n,e.callback(t,n),C._docCountQueue.running=!1,O()}n=t?0:n,0===e.delta?r():B.metaStore.put(k,n+e.delta,r)})}}function A(e,t){C._docCountQueue.queue.push({delta:e,callback:t}),O()}function L(e){return("0000000000000000"+e).slice(-16)}function I(e){return parseInt(e,10)}function T(e,t){var n=e.data;if(n._id=e.metadata.id,"_rev"in n){if(n._rev!==e.metadata.rev)return t(new Error("wrong doc returned"))}else n._rev=e.metadata.rev;t(null,{doc:n,metadata:e.metadata})}e=d.clone(e);var R,C,N=this,B={},D=e.name;"undefined"==typeof e.createIfMissing&&(e.createIfMissing=!0);var M=e.db||a;"function"!=typeof M.destroy&&(M.destroy=function(e,t){t()});var U;w.has(M.name)?U=w.get(M.name):(U=new d.Map,w.set(M.name,U)),U.has(D)?(C=U.get(D),x()):U.set(D,u(s(D,e,function(n){return n?(U["delete"](D),t(n)):(C=U.get(D),C._locks=C._locks||new d.Set,C._docCountQueue={queue:[],running:!1,docCount:-1},void(e.db||e.noMigrate?x():h.toSublevel(D,C,x)))}))),N.type=function(){return"leveldb"},N._id=function(e){e(null,R)},N._info=function(e){j(function(t,n){return t?e(t):void B.metaStore.get(E,function(t,r){return t&&(r=C._updateSeq),e(null,{doc_count:n,update_seq:r})})})},N._get=function(e,t,n){function r(e){i.push(e)}t=d.clone(t);var i=[];C.on("pouchdb-id-"+e,r),B.docStore.get(e,function(o,s){function a(e){u=e}if(C.removeListener("pouchdb-id-"+e,r),o||!s)return n(l.MISSING_DOC);if(d.isDeleted(s)&&!t.rev)return n(l.error(l.MISSING_DOC,"deleted"));var u,c=f.winningRev(s);c=t.rev?t.rev:c;var h=s.rev_map[c],p=i.filter(function(e){return e.metadata.seq===h});return p.length?T(p.pop(),n):(C.on("pouchdb-"+h,a),void B.bySeqStore.get(L(h),function(e,t){if(C.removeListener("pouchdb-"+h,a),u)return T(u,n);if(!t)return n(l.MISSING_DOC);if("_id"in t&&t._id!==s.id)return n(new Error("wrong doc returned"));if(t._id=s.id,"_rev"in t){if(t._rev!==c)return n(new Error("wrong doc returned"))}else t._rev=c;return n(null,{doc:t,metadata:s})}))})},N._getAttachment=function(e,t,o){var s=e.digest;B.binaryStore.get(s,function(s,a){var u;return s&&"NotFoundError"===s.name?(u=t.encode?"":n.browser?d.createBlob([""],{type:e.content_type}):new i(""),o(null,u)):s?o(s):(u=n.browser?t.encode?d.btoa(r.unescape(a)):d.createBlob([d.fixBinary(r.unescape(a))],{type:e.content_type}):t.encode?d.btoa(a):a,void o(null,u))})},N.lock=function(e){return C._locks.has(e)?!1:(C._locks.add(e),!0)},N.unlock=function(e){return C._locks.has(e)?(C._locks["delete"](e),!0):!1},N._bulkDocs=function(e,t,i){function s(){var e=w;if(!(S>_)){if(e>=m.length)return 0===S?p():void 0;var t=m[e];if(w++,S++,t._id&&d.isLocalId(t._id))return void N[t._deleted?"_removeLocal":"_putLocal"](t,function(t){v[e]=t?t:{},S--,s()});B.docStore.get(t.metadata.id,function(n,r){return N.lock(t.metadata.id)?void(n?"NotFoundError"===n.name?a(t,e,function(){N.unlock(t.metadata.id),S--,s()}):(n.error=!0,v[e]=n,N.unlock(t.metadata.id),S--,s()):u(r,t,e,function(){N.unlock(t.metadata.id),S--,s()})):(v[e]=g(l.REV_CONFLICT,"someobody else is accessing this"),S--,s())}),y&&s()}}function a(e,n,r){return"was_delete"in t&&d.isDeleted(e.metadata)?(v[n]=g(l.MISSING_DOC,e._bulk_seq),r()):void c(e,n,function(t){return t?r(t):d.isDeleted(e.metadata)?r():void A(1,r)})}function u(e,t,n,r){var i=f.merge(e.rev_tree,t.metadata.rev_tree[0],1e3),o=d.isDeleted(e)&&d.isDeleted(t.metadata)&&y||!d.isDeleted(e)&&y&&"new_leaf"!==i.conflicts;if(o)return v[n]=g(l.REV_CONFLICT,t._bulk_seq),r();t.metadata.rev_tree=i.tree,t.metadata.rev_map=e.rev_map;var s=0,a=d.isDeleted(e),u=d.isDeleted(t.metadata);s=a===u?0:u>a?-1:1,A(s,function(e){return e?r(e):void c(t,n,r)})}function c(e,t,o){function s(e){p||(e?(p=e,o(p)):g===y.length&&f())}function a(e){g++,s(e)}function u(e,t,n,r,i){return function(o){h(e,t+o,n,r,i)}}function c(e,t,n,i){return function(o){var s=r.escape(d.arrayBufferToBinaryString(o.target.result));d.MD5(s).then(u(e,t,n,s,i))}}function f(){var n=e.metadata.rev_map[e.metadata.rev];n||(n=++C._updateSeq),e.metadata.rev_map[e.metadata.rev]=e.metadata.seq=n;var r=L(n);C.emit("pouchdb-id-"+e.metadata.id,e),C.emit("pouchdb-"+r,e),C.batch([{key:r,value:e.data,prefix:B.bySeqStore,type:"put",valueEncoding:"json"},{key:e.metadata.id,value:e.metadata,prefix:B.docStore,type:"put",valueEncoding:"json"}],function(n){return n||(C.emit("pouchdb-id-"+e.metadata.id,e),C.emit("pouchdb-"+r,e)),B.metaStore.put(E,C._updateSeq,function(n){return v[t]=n?n:e,o()})})}var p=null,g=0;e.data._id=e.metadata.id,e.data._rev=e.metadata.rev,d.isDeleted(e.metadata)&&(e.data._deleted=!0);for(var y=e.data._attachments?Object.keys(e.data._attachments):[],b=0;b<y.length;b++){var m=y[b];if(e.data._attachments[m].stub)g++,s();else{var _,w,k=e.data._attachments[m];if("string"==typeof k.data){try{_=d.atob(k.data),n.browser&&(_=r.escape(_))}catch(S){return void i(d.extend({},l.BAD_ARG,{reason:"Attachments need to be base64 encoded"}))}w=n.browser?"md5-":""}else{if(n.browser){var x=new FileReader;return x.onloadend=c(e,"md5-",m,a),void x.readAsArrayBuffer(k.data)}_=k.data,w=""}d.MD5(_).then(u(e,w,m,_,a))}}y.length||f()}function h(e,t,n,r,i){delete e.data._attachments[n].data,e.data._attachments[n].digest=t,B.attachmentStore.get(t,function(n,o){if(n&&"NotFoundError"!==n.name)return i(n);var s=[e.metadata.id,e.metadata.rev].join("@"),a={};o?o.refs&&(a.refs=o.refs,a.refs[s]=!0):(a.refs={},a.refs[s]=!0),B.attachmentStore.put(t,a,function(e){return 0===r.length?i(e):void B.binaryStore.put(t,r,function(e){i(e)})})})}function p(){v.sort(function(e,t){return e._bulk_seq-t._bulk_seq});var e=v.map(function(e){if(e._bulk_seq)delete e._bulk_seq;else if(!Object.keys(e).length)return{ok:!0};if(e.error)return e;var t=e.metadata,n=f.winningRev(t);return{ok:!0,id:t.id,rev:n}});o.Changes.notify(D),n.nextTick(function(){i(null,e)})}function g(e,t){return e._bulk_seq=t,e}var y=t.new_edits,v=new Array(e.docs.length),b=e.docs,m=b.map(function(e,t){if(e._id&&d.isLocalId(e._id))return e;var n=d.parseDoc(e,y);return n._bulk_seq=t,n.metadata&&!n.metadata.rev_map&&(n.metadata.rev_map={}),n}),w=0,k=m.filter(function(e){return e.error});if(k.length)return i(k[0]);var S=0;s()},N._allDocs=function(e,t){e=d.clone(e),j(function(n,r){if(n)return t(n);var i={},o=e.skip||0;if(e.startkey&&(i.start=e.startkey),e.endkey&&(i.end=e.endkey),e.key&&(i.start=i.end=e.key),e.descending){i.reverse=!0;var s=i.start;i.start=i.end,i.end=s}var a;if(a="number"==typeof e.limit?e.limit:-1,0===a||"start"in i&&"end"in i&&i.start>i.end)return t(null,{total_rows:r,offset:e.skip,rows:[]});var u=[],l=B.docStore.readStream(i),h=c(function(t,n,r){function i(t,n){var i={id:t.id,key:t.id,value:{rev:f.winningRev(t)}};if(e.include_docs){i.doc=n,i.doc._rev=i.value.rev,e.conflicts&&(i.doc._conflicts=f.collectConflicts(t));for(var o in i.doc._attachments)i.doc._attachments.hasOwnProperty(o)&&(i.doc._attachments[o].stub=!0)}if(e.inclusive_end===!1&&t.id===e.endkey)return r();if(d.isDeleted(t)){if("ok"!==e.deleted)return r();i.value.deleted=!0,i.doc=null}u.push(i),r()}if(d.isDeleted(t.value)){if("ok"!==e.deleted)return void r()}else{if(o-->0)return void r();if(0===a--)return l.unpipe(),l.destroy(),void r()}var s=t.value;if(e.include_docs){var c=s.rev_map[f.winningRev(s)];B.bySeqStore.get(L(c),function(e,t){i(s,t)})}else i(s)},function(n){t(null,{total_rows:r,offset:e.skip,rows:u}),n()}).on("unpipe",function(){h.end()});l.on("error",t),l.pipe(h)})},N._changes=function(e){function t(){e.done=!0,h&&e.limit&&e.limit<s.length&&(s.length=e.limit),g.unpipe(y),g.destroy(),e.continuous||e.cancelled||e.complete(null,{results:s,last_seq:a})}if(e=d.clone(e),e.continuous){var n=D+":"+d.uuid();return o.Changes.addListener(D,n,N,e),o.Changes.notify(D),{cancel:function(){o.Changes.removeListener(D,n)}}}var r,i=e.descending,s=[],a=0,u=0,l={reverse:i};"limit"in e&&e.limit>0&&(r=e.limit),l.reverse||(l.start=L(e.since?e.since+1:0));var h,p=d.filterChange(e);h="returnDocs"in e?e.returnDocs:!0;var g=B.bySeqStore.readStream(l),y=c(function(n,i,o){return r&&u>=r?(t(),o()):e.cancelled||e.done?o():void B.docStore.get(n.value._id,function(t,r){if(e.cancelled||e.done||C.isClosed()||d.isLocalId(r.id))return o();var i=n.value;i._rev=f.winningRev(r);var c=e.processChange(i,r,e);c.seq=r.seq,a<r.seq&&(a=r.seq),I(n.key)===r.rev_map[c.doc._rev]&&p(c)&&(u++,d.call(e.onChange,c),h&&s.push(c)),o()})},function(t){return e.cancelled?t():(h&&e.limit&&e.limit<s.length&&(s.length=e.limit),void t())}).on("unpipe",function(){y.end(),t()});return g.pipe(y),{cancel:function(){e.cancelled=!0,t()}}},N._close=function(e){return C.isClosed()?e(l.NOT_OPEN):void C.close(function(t){t?e(t):(U["delete"](D),e())})},N._getRevisionTree=function(e,t){B.docStore.get(e,function(e,n){e?t(l.MISSING_DOC):t(null,n.rev_tree)})},N._doCompaction=function(e,t,n,r){B.docStore.get(e,function(e,i){if(e)return r(e);var o=i.rev_map;i.rev_tree=t,n.length||r();var s=[];s.push({key:i.id,value:i,type:"put",valueEncoding:"json",prefix:B.docStore}),n.forEach(function(e){var t=o[e];t&&s.push({key:L(t),type:"del",prefix:B.bySeqStore})}),C.batch(s,r)})},N._getLocal=function(e,t){B.localStore.get(e,function(e,n){e?t(l.MISSING_DOC):t(null,n)})},N._putLocal=function(e,t){var n=e._rev,r=e._id;B.localStore.get(r,function(i,o){return i&&n?t(l.REV_CONFLICT):o&&o._rev!==n?t(l.REV_CONFLICT):(e._rev=n?"0-"+(parseInt(n.split("-")[1],10)+1):"0-0",void B.localStore.put(r,e,function(n){if(n)return t(n);var r={ok:!0,id:e._id,rev:e._rev};t(null,r)}))})},N._removeLocal=function(e,t){B.localStore.get(e._id,function(n,r){return n?t(n):r._rev!==e._rev?t(l.REV_CONFLICT):void B.localStore.del(e._id,function(n){if(n)return t(n);var r={ok:!0,id:e._id,rev:"0-0"};t(null,r)})})}}var s=e("levelup"),a=e("leveldown"),u=e("level-sublevel"),c=e("through2").obj,l=e("../deps/errors"),f=e("../merge"),d=e("../utils"),h=e("../deps/migrate"),p="document-store",g="by-sequence",y="attach-store",v="attach-binary-store",b="local-store",m="meta-store",_=50,w=new d.Map,E="_local_last_update_seq",k="_local_doc_count",S="_local_uuid";o.valid=function(){return n&&!n.browser},o.destroy=d.toPromise(function(e,t,r){function i(e,t){"function"==typeof u.destroy?u.destroy(e,t):n.nextTick(r)}t=d.clone(t);var s,u=t.db||a;return w.has(u.name)?(s=w.get(u.name),void(s.has(e)?(o.Changes.removeAllListeners(e),s.get(e).close(function(){s["delete"](e),i(e,r)})):i(e,r))):i(e,r)}),o.use_prefix=!1,o.Changes=new d.Changes,t.exports=o}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{},e("buffer").Buffer)},{"../deps/errors":5,"../deps/migrate":"JpIkFB","../merge":8,"../utils":15,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,"level-sublevel":35,leveldown:"3WVjcl",levelup:49,through2:117}],2:[function(e,t){"use strict";function n(e,t){function n(t,n,r){if(e.binary||e.json||!e.processData||"string"==typeof t){if(!e.binary&&e.json&&"string"==typeof t)try{t=JSON.parse(t)}catch(i){return r(i)}}else t=JSON.stringify(t);Array.isArray(t)&&(t=t.map(function(e){var t;return e.ok?e:e.error&&"conflict"===e.error?(t=o.REV_CONFLICT,t.id=e.id,t):e.error&&"forbidden"===e.error?(t=o.FORBIDDEN,t.id=e.id,t.reason=e.reason,t):e.missing?(t=o.MISSING_DOC,t.missing=e.missing,t):e})),r(null,t,n)}function a(e,t){var n,r,i,s;try{n=JSON.parse(e.responseText);for(s in o)if(o.hasOwnProperty(s)&&o[s].name===n.error){i=o[s];break}i||(i=o.UNKNOWN_ERROR,e.status&&(i.status=e.status),e.statusText&&(e.name=e.statusText)),r=o.error(i,n.reason)}catch(a){for(var s in o)if(o.hasOwnProperty(s)&&o[s].status===e.status){i=o[s];break}i||(i=o.UNKNOWN_ERROR,e.status&&(i.status=e.status),e.statusText&&(e.name=e.statusText)),r=o.error(i)}e.withCredentials&&0===e.status&&(r.status=405,r.statusText="Method Not Allowed"),t(r)}var u=!1,c=s.getArguments(function(e){u||(t.apply(this,e),u=!0)});"function"==typeof e&&(c=e,e={}),e=s.clone(e);var l={method:"GET",headers:{},json:!0,processData:!0,timeout:1e4,cache:!1};if(e=s.extend(!0,l,e),"GET"===e.method&&!e.cache){var f=-1!==e.url.indexOf("?");e.url+=(f?"&":"?")+"_nonce="+s.uuid(16)}var d,h;h=e.xhr?new e.xhr:new XMLHttpRequest,h.open(e.method,e.url),h.withCredentials=!0,e.json&&(e.headers.Accept="application/json",e.headers["Content-Type"]=e.headers["Content-Type"]||"application/json",e.body&&e.processData&&"string"!=typeof e.body&&(e.body=JSON.stringify(e.body))),e.binary&&(h.responseType="arraybuffer");var p=function(e,t,n){var r="";if(n){var i=new Date;i.setTime(i.getTime()+24*n*60*60*1e3),r="; expires="+i.toGMTString()}document.cookie=e+"="+t+r+"; path=/"};for(var g in e.headers)if("Cookie"===g){var y=e.headers[g].split("=");p(y[0],y[1],10)}else h.setRequestHeader(g,e.headers[g]);"body"in e||(e.body=null);var v=function(){u||(h.abort(),a(h,c))};if(h.onreadystatechange=function(){if(4===h.readyState&&!u)if(clearTimeout(d),h.status>=200&&h.status<300){var t;t=e.binary?i([h.response||""],{type:h.getResponseHeader("Content-Type")}):h.responseText,n(t,h,c)}else a(h,c)},e.timeout>0&&(d=setTimeout(v,e.timeout),h.onprogress=function(){clearTimeout(d),d=setTimeout(v,e.timeout)},"undefined"==typeof r&&(r=-1!==Object.keys(h).indexOf("upload")),r&&(h.upload.onprogress=h.onprogress)),e.body&&e.body instanceof Blob){var b=new FileReader;b.onloadend=function(){for(var e="",t=new Uint8Array(this.result),n=t.byteLength,r=0;n>r;r++)e+=String.fromCharCode(t[r]);e=s.fixBinary(e),h.send(e)},b.readAsArrayBuffer(e.body)}else h.send(e.body);return{abort:v}}var r,i=e("./blob.js"),o=e("./errors"),s=e("../utils");t.exports=n},{"../utils":15,"./blob.js":3,"./errors":5}],3:[function(e,t){(function(e){"use strict";function n(t,n){t=t||[],n=n||{};try{return new Blob(t,n)}catch(r){if("TypeError"!==r.name)throw r;for(var i=e.BlobBuilder||e.MSBlobBuilder||e.MozBlobBuilder||e.WebKitBlobBuilder,o=new i,s=0;s<t.length;s+=1)o.append(t[s]);return o.getBlob(n.type)}}t.exports=n}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],4:[function(e,t,n){"use strict";function r(){this.store={}}function i(){this.store=new r}n.Map=r,n.Set=i,r.prototype.mangle=function(e){if("string"!=typeof e)throw new TypeError("key must be a string but Got "+e);return"$"+e},r.prototype.unmangle=function(e){return e.substring(1)},r.prototype.get=function(e){var t=this.mangle(e);return t in this.store?this.store[t]:void 0},r.prototype.set=function(e,t){var n=this.mangle(e);return this.store[n]=t,!0},r.prototype.has=function(e){var t=this.mangle(e);return t in this.store},r.prototype["delete"]=function(e){var t=this.mangle(e);return t in this.store?(delete this.store[t],!0):!1},r.prototype.forEach=function(e){var t=this,n=Object.keys(t.store);n.forEach(function(n){var r=t.store[n];n=t.unmangle(n),e(r,n)})},i.prototype.add=function(e){return this.store.set(e,!0)},i.prototype.has=function(e){return this.store.has(e)},i.prototype["delete"]=function(e){return this.store["delete"](e)}},{}],5:[function(e,t,n){"use strict";function r(e){this.status=e.status,this.name=e.error,this.message=e.reason,this.error=!0}r.prototype__proto__=Error.prototype,r.prototype.toString=function(){return JSON.stringify({status:this.status,name:this.name,message:this.message})},n.UNAUTHORIZED=new r({status:401,error:"unauthorized",reason:"Name or password is incorrect."}),n.MISSING_BULK_DOCS=new r({status:400,error:"bad_request",reason:"Missing JSON list of 'docs'"}),n.MISSING_DOC=new r({status:404,error:"not_found",reason:"missing"}),n.REV_CONFLICT=new r({status:409,error:"conflict",reason:"Document update conflict"}),n.INVALID_ID=new r({status:400,error:"invalid_id",reason:"_id field must contain a string"}),n.MISSING_ID=new r({status:412,error:"missing_id",reason:"_id is required for puts"}),n.RESERVED_ID=new r({status:400,error:"bad_request",reason:"Only reserved document ids may start with underscore."}),n.NOT_OPEN=new r({status:412,error:"precondition_failed",reason:"Database not open"}),n.UNKNOWN_ERROR=new r({status:500,error:"unknown_error",reason:"Database encountered an unknown error"}),n.BAD_ARG=new r({status:500,error:"badarg",reason:"Some query argument is invalid"}),n.INVALID_REQUEST=new r({status:400,error:"invalid_request",reason:"Request was invalid"}),n.QUERY_PARSE_ERROR=new r({status:400,error:"query_parse_error",reason:"Some query parameter is invalid"}),n.DOC_VALIDATION=new r({status:500,error:"doc_validation",reason:"Bad special document member"}),n.BAD_REQUEST=new r({status:400,error:"bad_request",reason:"Something wrong with the request"}),n.NOT_AN_OBJECT=new r({status:400,error:"bad_request",reason:"Document must be a JSON object"}),n.DB_MISSING=new r({status:404,error:"not_found",reason:"Database not found"}),n.IDB_ERROR=new r({status:500,error:"indexed_db_went_bad",reason:"unknown"}),n.WSQ_ERROR=new r({status:500,error:"web_sql_went_bad",reason:"unknown"}),n.LDB_ERROR=new r({status:500,error:"levelDB_went_went_bad",reason:"unknown"}),n.FORBIDDEN=new r({status:403,error:"forbidden",reason:"Forbidden by design doc validate_doc_update function"}),n.error=function(e,t,n){function r(){this.message=t,n&&(this.name=n)}return r.prototype=e,new r(t)}},{}],6:[function(e,t){(function(n,r){"use strict";function i(e,t,n){if("function"==typeof e.slice)return e.slice(t,n);t=Math.floor(t||0),n=Math.floor(n||0);var r=e.byteLength;if(t=0>t?Math.max(t+r,0):Math.min(r,t),n=0>n?Math.max(n+r,0):Math.min(r,n),0>=n-t)return new ArrayBuffer(0);var i=new ArrayBuffer(n-t),o=new Uint8Array(i),s=new Uint8Array(e,t,n-t);return o.set(s),i}var o=e("crypto"),s=e("spark-md5"),a=r.setImmediate||r.setTimeout;t.exports=function(e,t){function r(){var n=l*u,o=n+u;n+u>=e.size&&(o=e.size),l++,c>l?(f.append(i(e,n,o)),a(r)):(f.append(i(e,n,o)),t(null,f.end()),f.destroy())}if(!n.browser)return void t(null,o.createHash("md5").update(e).digest("hex"));var u=Math.min(524288,e.length),c=Math.ceil(e.length/u),l=0,f=new s;r()}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,crypto:17,"spark-md5":102}],7:[function(e,t){"use strict";function n(e){return 0|Math.random()*e}function r(e,t){t=t||i.length;var r="",o=-1;if(e){for(;++o<e;)r+=i[n(t)];return r}for(;++o<36;)switch(o){case 8:case 13:case 18:case 23:r+="-";break;case 19:r+=i[3&n(16)|8];break;default:r+=i[n(16)]}return r}var i="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split("");t.exports=r},{}],8:[function(e,t){"use strict";function n(e){for(var t,n=e.shift(),r=[n.id,n.opts,[]],i=r;e.length;)n=e.shift(),t=[n.id,n.opts,[]],i[2].push(t),i=t;return r}function r(e,t){for(var n=[{tree1:e,tree2:t}],r=!1;n.length>0;){var i=n.pop(),o=i.tree1,s=i.tree2;(o[1].status||s[1].status)&&(o[1].status="available"===o[1].status||"available"===s[1].status?"available":"missing");for(var a=0;a<s[2].length;a++)if(o[2][0]){for(var u=!1,c=0;c<o[2].length;c++)o[2][c][0]===s[2][a][0]&&(n.push({tree1:o[2][c],tree2:s[2][a]}),u=!0);u||(r="new_branch",o[2].push(s[2][a]),o[2].sort())}else r="new_leaf",o[2][0]=s[2][a]}return{conflicts:r,tree:e}}function i(e,t,n){var i,o=[],s=!1,a=!1;return e.length?(e.forEach(function(e){if(e.pos===t.pos&&e.ids[0]===t.ids[0])i=r(e.ids,t.ids),o.push({pos:e.pos,ids:i.tree}),s=s||i.conflicts,a=!0;else if(n!==!0){var u=e.pos<t.pos?e:t,c=e.pos<t.pos?t:e,l=c.pos-u.pos,f=[],d=[];for(d.push({ids:u.ids,diff:l,parent:null,parentIdx:null});d.length>0;){var h=d.pop();0!==h.diff?h.ids&&h.ids[2].forEach(function(e,t){d.push({ids:e,diff:h.diff-1,parent:h.ids,parentIdx:t})}):h.ids[0]===c.ids[0]&&f.push(h)}var p=f[0];p?(i=r(p.ids,c.ids),p.parent[2][p.parentIdx]=i.tree,o.push({pos:u.pos,ids:u.ids}),s=s||i.conflicts,a=!0):o.push(e)}else o.push(e)}),a||o.push(t),o.sort(function(e,t){return e.pos-t.pos}),{tree:o,conflicts:s||"internal_node"}):{tree:[t],conflicts:"new_leaf"}}function o(e,t){var r=a.rootToLeaf(e).map(function(e){var r=e.ids.slice(-t);return{pos:e.pos+(e.ids.length-r.length),ids:n(r)}});return r.reduce(function(e,t){return i(e,t,!0).tree},[r.shift()])}var s=e("pouchdb-extend"),a={};a.merge=function(e,t,n){e=s(!0,[],e),t=s(!0,{},t);var r=i(e,t);return{tree:o(r.tree,n),conflicts:r.conflicts}},a.winningRev=function(e){var t=[];return a.traverseRevTree(e.rev_tree,function(e,n,r,i,o){e&&t.push({pos:n,id:r,deleted:!!o.deleted})}),t.sort(function(e,t){return e.deleted!==t.deleted?e.deleted>t.deleted?1:-1:e.pos!==t.pos?t.pos-e.pos:e.id<t.id?1:-1}),t[0].pos+"-"+t[0].id},a.traverseRevTree=function(e,t){for(var n,r=e.slice();n=r.pop();)for(var i=n.pos,o=n.ids,s=o[2],a=t(0===s.length,i,o[0],n.ctx,o[1]),u=0,c=s.length;c>u;u++)r.push({pos:i+1,ids:s[u],ctx:a})},a.collectLeaves=function(e){var t=[];return a.traverseRevTree(e,function(e,n,r,i,o){e&&t.unshift({rev:n+"-"+r,pos:n,opts:o})}),t.sort(function(e,t){return t.pos-e.pos}),t.map(function(e){delete e.pos}),t},a.collectConflicts=function(e){var t=a.winningRev(e),n=a.collectLeaves(e.rev_tree),r=[];return n.forEach(function(e){e.rev===t||e.opts.deleted||r.push(e.rev)}),r},a.rootToLeaf=function(e){var t=[];return a.traverseRevTree(e,function(e,n,r,i,o){if(i=i?i.slice(0):[],i.push({id:r,opts:o}),e){var s=n+1-i.length;t.unshift({pos:s,ids:i})}return i}),t},t.exports=a},{"pouchdb-extend":101}],AQa8tq:[function(e,t){"use strict";t.exports={name:"localstorage",valid:function(){return"localStorage"in window},use_prefix:!0}},{}],"adapter-config":[function(e,t){t.exports=e("AQa8tq")},{}],11:[function(e){"use strict";var t=e("adapter-config"),n=t.name,r=e("./levelalt");window.PouchDB.adapter(n,r),window.PouchDB.preferredAdapters.push(n)},{"./levelalt":12,"adapter-config":"AQa8tq"}],12:[function(e,t){"use strict";function n(e,t){var n=s.extend({db:i},e);r.call(this,n,t)}var r=e("../adapters/leveldb"),i=e("leveldown"),o=e("adapter-config"),s=e("../utils");n.valid=function(){return o.valid()},n.use_prefix=o.use_prefix,n.destroy=s.toPromise(function(e,t,n){"function"==typeof t&&(n=t,t={});var o=s.extend({db:i},t);return r.destroy(e,o,n)}),t.exports=n},{"../adapters/leveldb":1,"../utils":15,"adapter-config":"AQa8tq",leveldown:"3WVjcl"}],JpIkFB:[function(e,t,n){(function(e){"use strict";n.toSublevel=function(t,n,r){e.nextTick(function(){r()})},n.localAndMetaStores=function(t,n,r){e.nextTick(function(){r()})}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],"../adapters/../deps/migrate":[function(e,t){t.exports=e("JpIkFB")},{}],15:[function(e,t,n){(function(t,r){function i(e){var t={};return e.forEach(function(e){t[e]=!0}),t}function o(){return"undefined"!=typeof chrome&&"undefined"!=typeof chrome.storage&&"undefined"!=typeof chrome.storage.local}function s(){if(!(this instanceof s))return new s;var e=this;l.call(this),this.isChrome=o(),this.listeners={},this.hasLocal=!1,this.isChrome||(this.hasLocal=n.hasLocalStorage()),this.isChrome?chrome.storage.onChanged.addListener(function(t){null!=t.db_name&&e.emit(t.dbName.newValue)}):this.hasLocal&&(r.addEventListener?r.addEventListener("storage",function(t){e.emit(t.key)}):r.attachEvent("storage",function(t){e.emit(t.key)}))}var a=e("./merge");n.extend=e("pouchdb-extend"),n.ajax=e("./deps/ajax"),n.createBlob=e("./deps/blob"),n.uuid=e("./deps/uuid"),n.getArguments=e("argsarray");var u=e("./deps/buffer"),c=e("./deps/errors"),l=e("events").EventEmitter,f=e("./deps/collections");n.Map=f.Map,n.Set=f.Set,n.Promise="function"==typeof r.Promise?r.Promise:e("bluebird");var d=n.Promise,h=i(["_id","_rev","_attachments","_deleted","_revisions","_revs_info","_conflicts","_deleted_conflicts","_local_seq","_rev_tree","_replication_id","_replication_state","_replication_state_time","_replication_state_reason","_replication_stats"]);n.clone=function(e){return n.extend(!0,{},e)},n.inherits=e("inherits"),n.invalidIdError=function(e){var t;if(e?"string"!=typeof e?(t=new TypeError(c.INVALID_ID.message),t.status=400):/^_/.test(e)&&!/^_(design|local)/.test(e)&&(t=new TypeError(c.RESERVED_ID.message),t.status=400):(t=new TypeError(c.MISSING_ID.message),t.status=412),t)throw t},n.call=n.getArguments(function(e){if(e.length){var t=e.shift();"function"==typeof t&&t.apply(this,e)}}),n.isLocalId=function(e){return/^_local/.test(e)},n.isDeleted=function(e,t){t||(t=a.winningRev(e));var n=t.indexOf("-");-1!==n&&(t=t.substring(n+1));var r=!1;return a.traverseRevTree(e.rev_tree,function(e,n,i,o,s){i===t&&(r=!!s.deleted)}),r},n.filterChange=function(e){return function(t){var n={},r=e.filter&&"function"==typeof e.filter;if(n.query=e.query_params,e.filter&&r&&!e.filter.call(this,t.doc,n))return!1;if(e.doc_ids&&-1===e.doc_ids.indexOf(t.id))return!1;if(e.include_docs)for(var i in t.doc._attachments)t.doc._attachments.hasOwnProperty(i)&&(t.doc._attachments[i].stub=!0);else delete t.doc;return!0}},n.parseDoc=function(e,t){var r,i,o,s,a={status:"available"};if(e._deleted&&(a.deleted=!0),t)if(e._id||(e._id=n.uuid()),i=n.uuid(32,16).toLowerCase(),e._rev){if(o=/^(\d+)-(.+)$/.exec(e._rev),!o){var u=new TypeError("invalid value for property '_rev'");u.status=400}e._rev_tree=[{pos:parseInt(o[1],10),ids:[o[2],{status:"missing"},[[i,a,[]]]]}],r=parseInt(o[1],10)+1}else e._rev_tree=[{pos:1,ids:[i,a,[]]}],r=1;else if(e._revisions&&(e._rev_tree=[{pos:e._revisions.start-e._revisions.ids.length+1,ids:e._revisions.ids.reduce(function(e,t){return null===e?[t,a,[]]:[t,{status:"missing"},[e]]},null)}],r=e._revisions.start,i=e._revisions.ids[0]),!e._rev_tree){if(o=/^(\d+)-(.+)$/.exec(e._rev),!o)throw s=new TypeError(c.BAD_ARG.message),s.status=c.BAD_ARG.status,s;r=parseInt(o[1],10),i=o[2],e._rev_tree=[{pos:parseInt(o[1],10),ids:[o[2],a,[]]}]}n.invalidIdError(e._id),e._id=decodeURIComponent(e._id),e._rev=[r,i].join("-");var l={metadata:{},data:{}};for(var f in e)if(e.hasOwnProperty(f)){var d="_"===f[0];if(d&&!h[f])throw s=new Error(c.DOC_VALIDATION.message+": "+f),s.status=c.DOC_VALIDATION.status,s;d&&"_attachments"!==f?l.metadata[f.slice(1)]=e[f]:l.data[f]=e[f]}return l},n.isCordova=function(){return"undefined"!=typeof cordova||"undefined"!=typeof PhoneGap||"undefined"!=typeof phonegap},n.hasLocalStorage=function(){if(o())return!1;try{return r.localStorage}catch(e){return!1}},n.Changes=s,n.inherits(s,l),s.prototype.addListener=function(e,t,r,i){function o(){r.changes({include_docs:i.include_docs,conflicts:i.conflicts,continuous:!1,descending:!1,filter:i.filter,view:i.view,since:i.since,query_params:i.query_params,onChange:function(e){e.seq>i.since&&!i.cancelled&&(i.since=e.seq,n.call(i.onChange,e))}})}this.listeners[t]||(this.listeners[t]=o,this.on(e,o))},s.prototype.removeListener=function(e,t){t in this.listeners&&l.prototype.removeListener.call(this,e,this.listeners[t])},s.prototype.notifyLocalWindows=function(e){this.isChrome?chrome.storage.local.set({dbName:e}):this.hasLocal&&(localStorage[e]="a"===localStorage[e]?"b":"a")},s.prototype.notify=function(e){this.emit(e),this.notifyLocalWindows(e)},n.atob=t.browser&&"atob"in r?function(e){return atob(e)}:function(e){var t=new u(e,"base64");if(t.toString("base64")!==e)throw"Cannot base64 encode full string";return t.toString("binary")},n.btoa=t.browser&&"btoa"in r?function(e){return btoa(e)}:function(e){return new u(e,"binary").toString("base64")},n.fixBinary=function(e){if(!t.browser)return e;for(var n=e.length,r=new ArrayBuffer(n),i=new Uint8Array(r),o=0;n>o;o++)i[o]=e.charCodeAt(o);return r},n.once=function(e){var t=!1;return n.getArguments(function(n){if(t)throw"function"==typeof console.trace&&console.trace(),new Error("once called more than once");t=!0,e.apply(this,n)})},n.toPromise=function(e){return n.getArguments(function(r){var i,o=this,s="function"==typeof r[r.length-1]?r.pop():!1;s&&(i=function(e,n){t.nextTick(function(){s(e,n)})});var a=new d(function(t,i){var s;try{var a=n.once(function(e,n){e?i(e):t(n)});r.push(a),s=e.apply(o,r),s&&"function"==typeof s.then&&t(s)}catch(u){i(u)}});return i&&a.then(function(e){i(null,e)},i),a.cancel=function(){return this},a})},n.adapterFun=function(e,t){return n.toPromise(n.getArguments(function(r){if(this._closed)return d.reject(new Error("database is closed"));var i=this;return this.taskqueue.isReady?t.apply(this,r):new n.Promise(function(t,n){i.taskqueue.addTask(function(o){o?n(o):t(i[e].apply(i,r))})})}))},n.arrayBufferToBinaryString=function(e){for(var t="",n=new Uint8Array(e),r=n.byteLength,i=0;r>i;i++)t+=String.fromCharCode(n[i]);return t},n.cancellableFun=function(e,t,r){r=r?n.clone(!0,{},r):{};var i=new l,o=r.complete||function(){},s=r.complete=n.once(function(e,t){e?o(e):(i.emit("end",t),o(null,t)),i.removeAllListeners()}),a=r.onChange||function(){},u=0;t.on("destroyed",function(){i.removeAllListeners()}),r.onChange=function(e){a(e),e.seq<=u||(u=e.seq,i.emit("change",e),e.deleted?i.emit("delete",e):1===e.changes.length&&"1-"===e.changes[0].rev.slice(0,1)?i.emit("create",e):i.emit("update",e))};var c=new d(function(e,t){r.complete=function(n,r){n?t(n):e(r)}});return c.then(function(e){s(null,e)},s),c.cancel=function(){c.isCancelled=!0,t.taskqueue.isReady&&r.complete(null,{status:"cancelled"})},t.taskqueue.isReady?e(t,r,c):t.taskqueue.addTask(function(){c.isCancelled?r.complete(null,{status:"cancelled"}):e(t,r,c)}),c.on=i.on.bind(i),c.once=i.once.bind(i),c.addListener=i.addListener.bind(i),c.removeListener=i.removeListener.bind(i),c.removeAllListeners=i.removeAllListeners.bind(i),c.setMaxListeners=i.setMaxListeners.bind(i),c.listeners=i.listeners.bind(i),c.emit=i.emit.bind(i),c},n.MD5=n.toPromise(e("./deps/md5"))}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./deps/ajax":2,"./deps/blob":3,"./deps/buffer":17,"./deps/collections":4,"./deps/errors":5,"./deps/md5":6,"./deps/uuid":7,"./merge":8,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,argsarray:16,bluebird:75,events:18,inherits:33,"pouchdb-extend":101}],16:[function(e,t){"use strict";function n(e){return function(){var t=arguments.length;
+if(t){for(var n=[],r=-1;++r<t;)n[r]=arguments[r];return e.call(this,n)}return e.call(this,[])}}t.exports=n},{}],17:[function(){},{}],18:[function(e,t){function n(){this._events=this._events||{},this._maxListeners=this._maxListeners||void 0}function r(e){return"function"==typeof e}function i(e){return"number"==typeof e}function o(e){return"object"==typeof e&&null!==e}function s(e){return void 0===e}t.exports=n,n.EventEmitter=n,n.prototype._events=void 0,n.prototype._maxListeners=void 0,n.defaultMaxListeners=10,n.prototype.setMaxListeners=function(e){if(!i(e)||0>e||isNaN(e))throw TypeError("n must be a positive number");return this._maxListeners=e,this},n.prototype.emit=function(e){var t,n,i,a,u,c;if(this._events||(this._events={}),"error"===e&&(!this._events.error||o(this._events.error)&&!this._events.error.length))throw t=arguments[1],t instanceof Error?t:TypeError('Uncaught, unspecified "error" event.');if(n=this._events[e],s(n))return!1;if(r(n))switch(arguments.length){case 1:n.call(this);break;case 2:n.call(this,arguments[1]);break;case 3:n.call(this,arguments[1],arguments[2]);break;default:for(i=arguments.length,a=new Array(i-1),u=1;i>u;u++)a[u-1]=arguments[u];n.apply(this,a)}else if(o(n)){for(i=arguments.length,a=new Array(i-1),u=1;i>u;u++)a[u-1]=arguments[u];for(c=n.slice(),i=c.length,u=0;i>u;u++)c[u].apply(this,a)}return!0},n.prototype.addListener=function(e,t){var i;if(!r(t))throw TypeError("listener must be a function");if(this._events||(this._events={}),this._events.newListener&&this.emit("newListener",e,r(t.listener)?t.listener:t),this._events[e]?o(this._events[e])?this._events[e].push(t):this._events[e]=[this._events[e],t]:this._events[e]=t,o(this._events[e])&&!this._events[e].warned){var i;i=s(this._maxListeners)?n.defaultMaxListeners:this._maxListeners,i&&i>0&&this._events[e].length>i&&(this._events[e].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[e].length),"function"==typeof console.trace&&console.trace())}return this},n.prototype.on=n.prototype.addListener,n.prototype.once=function(e,t){function n(){this.removeListener(e,n),i||(i=!0,t.apply(this,arguments))}if(!r(t))throw TypeError("listener must be a function");var i=!1;return n.listener=t,this.on(e,n),this},n.prototype.removeListener=function(e,t){var n,i,s,a;if(!r(t))throw TypeError("listener must be a function");if(!this._events||!this._events[e])return this;if(n=this._events[e],s=n.length,i=-1,n===t||r(n.listener)&&n.listener===t)delete this._events[e],this._events.removeListener&&this.emit("removeListener",e,t);else if(o(n)){for(a=s;a-->0;)if(n[a]===t||n[a].listener&&n[a].listener===t){i=a;break}if(0>i)return this;1===n.length?(n.length=0,delete this._events[e]):n.splice(i,1),this._events.removeListener&&this.emit("removeListener",e,t)}return this},n.prototype.removeAllListeners=function(e){var t,n;if(!this._events)return this;if(!this._events.removeListener)return 0===arguments.length?this._events={}:this._events[e]&&delete this._events[e],this;if(0===arguments.length){for(t in this._events)"removeListener"!==t&&this.removeAllListeners(t);return this.removeAllListeners("removeListener"),this._events={},this}if(n=this._events[e],r(n))this.removeListener(e,n);else for(;n.length;)this.removeListener(e,n[n.length-1]);return delete this._events[e],this},n.prototype.listeners=function(e){var t;return t=this._events&&this._events[e]?r(this._events[e])?[this._events[e]]:this._events[e].slice():[]},n.listenerCount=function(e,t){var n;return n=e._events&&e._events[t]?r(e._events[t])?1:e._events[t].length:0}},{}],19:[function(e,t){var n=t.exports={};n.nextTick=function(){var e="undefined"!=typeof window&&window.setImmediate,t="undefined"!=typeof window&&window.postMessage&&window.addEventListener;if(e)return function(e){return window.setImmediate(e)};if(t){var n=[];return window.addEventListener("message",function(e){var t=e.source;if((t===window||null===t)&&"process-tick"===e.data&&(e.stopPropagation(),n.length>0)){var r=n.shift();r()}},!0),function(e){n.push(e),window.postMessage("process-tick","*")}}return function(e){setTimeout(e,0)}}(),n.title="browser",n.browser=!0,n.env={},n.argv=[],n.binding=function(){throw new Error("process.binding is not supported")},n.cwd=function(){return"/"},n.chdir=function(){throw new Error("process.chdir is not supported")}},{}],20:[function(e,t,n){function r(e,t,n){if(!(this instanceof r))return new r(e,t,n);var i=typeof e;if("base64"===t&&"string"===i)for(e=j(e);e.length%4!==0;)e+="=";var o;if("number"===i)o=L(e);else if("string"===i)o=r.byteLength(e,t);else{if("object"!==i)throw new Error("First argument needs to be a number, array or string.");o=L(e.length)}var s;r._useTypedArrays?s=O(new Uint8Array(o)):(s=this,s.length=o,s._isBuffer=!0);var a;if(r._useTypedArrays&&"function"==typeof Uint8Array&&e instanceof Uint8Array)s._set(e);else if(T(e))for(a=0;o>a;a++)s[a]=r.isBuffer(e)?e.readUInt8(a):e[a];else if("string"===i)s.write(e,0,t);else if("number"===i&&!r._useTypedArrays&&!n)for(a=0;o>a;a++)s[a]=0;return s}function i(e,t,n,i){n=Number(n)||0;var o=e.length-n;i?(i=Number(i),i>o&&(i=o)):i=o;var s=t.length;q(s%2===0,"Invalid hex string"),i>s/2&&(i=s/2);for(var a=0;i>a;a++){var u=parseInt(t.substr(2*a,2),16);q(!isNaN(u),"Invalid hex string"),e[n+a]=u}return r._charsWritten=2*a,a}function o(e,t,n,i){var o=r._charsWritten=D(C(t),e,n,i);return o}function s(e,t,n,i){var o=r._charsWritten=D(N(t),e,n,i);return o}function a(e,t,n,r){return s(e,t,n,r)}function u(e,t,n,i){var o=r._charsWritten=D(B(t),e,n,i);return o}function c(e,t,n){return W.fromByteArray(0===t&&n===e.length?e:e.slice(t,n))}function l(e,t,n){var r="",i="";n=Math.min(e.length,n);for(var o=t;n>o;o++)e[o]<=127?(r+=M(i)+String.fromCharCode(e[o]),i=""):i+="%"+e[o].toString(16);return r+M(i)}function f(e,t,n){var r="";n=Math.min(e.length,n);for(var i=t;n>i;i++)r+=String.fromCharCode(e[i]);return r}function d(e,t,n){return f(e,t,n)}function h(e,t,n){var r=e.length;(!t||0>t)&&(t=0),(!n||0>n||n>r)&&(n=r);for(var i="",o=t;n>o;o++)i+=R(e[o]);return i}function p(e,t,n,r){r||(q("boolean"==typeof n,"missing or invalid endian"),q(void 0!==t&&null!==t,"missing offset"),q(t+1<e.length,"Trying to read beyond buffer length"));var i=e.length;if(!(t>=i)){var o;return n?(o=e[t],i>t+1&&(o|=e[t+1]<<8)):(o=e[t]<<8,i>t+1&&(o|=e[t+1])),o}}function g(e,t,n,r){r||(q("boolean"==typeof n,"missing or invalid endian"),q(void 0!==t&&null!==t,"missing offset"),q(t+3<e.length,"Trying to read beyond buffer length"));var i=e.length;if(!(t>=i)){var o;return n?(i>t+2&&(o=e[t+2]<<16),i>t+1&&(o|=e[t+1]<<8),o|=e[t],i>t+3&&(o+=e[t+3]<<24>>>0)):(i>t+1&&(o=e[t+1]<<16),i>t+2&&(o|=e[t+2]<<8),i>t+3&&(o|=e[t+3]),o+=e[t]<<24>>>0),o}}function y(e,t,n,r){r||(q("boolean"==typeof n,"missing or invalid endian"),q(void 0!==t&&null!==t,"missing offset"),q(t+1<e.length,"Trying to read beyond buffer length"));var i=e.length;if(!(t>=i)){var o=p(e,t,n,!0),s=32768&o;return s?-1*(65535-o+1):o}}function v(e,t,n,r){r||(q("boolean"==typeof n,"missing or invalid endian"),q(void 0!==t&&null!==t,"missing offset"),q(t+3<e.length,"Trying to read beyond buffer length"));var i=e.length;if(!(t>=i)){var o=g(e,t,n,!0),s=2147483648&o;return s?-1*(4294967295-o+1):o}}function b(e,t,n,r){return r||(q("boolean"==typeof n,"missing or invalid endian"),q(t+3<e.length,"Trying to read beyond buffer length")),V.read(e,t,n,23,4)}function m(e,t,n,r){return r||(q("boolean"==typeof n,"missing or invalid endian"),q(t+7<e.length,"Trying to read beyond buffer length")),V.read(e,t,n,52,8)}function _(e,t,n,r,i){i||(q(void 0!==t&&null!==t,"missing value"),q("boolean"==typeof r,"missing or invalid endian"),q(void 0!==n&&null!==n,"missing offset"),q(n+1<e.length,"trying to write beyond buffer length"),U(t,65535));var o=e.length;if(!(n>=o))for(var s=0,a=Math.min(o-n,2);a>s;s++)e[n+s]=(t&255<<8*(r?s:1-s))>>>8*(r?s:1-s)}function w(e,t,n,r,i){i||(q(void 0!==t&&null!==t,"missing value"),q("boolean"==typeof r,"missing or invalid endian"),q(void 0!==n&&null!==n,"missing offset"),q(n+3<e.length,"trying to write beyond buffer length"),U(t,4294967295));var o=e.length;if(!(n>=o))for(var s=0,a=Math.min(o-n,4);a>s;s++)e[n+s]=t>>>8*(r?s:3-s)&255}function E(e,t,n,r,i){i||(q(void 0!==t&&null!==t,"missing value"),q("boolean"==typeof r,"missing or invalid endian"),q(void 0!==n&&null!==n,"missing offset"),q(n+1<e.length,"Trying to write beyond buffer length"),F(t,32767,-32768));var o=e.length;n>=o||(t>=0?_(e,t,n,r,i):_(e,65535+t+1,n,r,i))}function k(e,t,n,r,i){i||(q(void 0!==t&&null!==t,"missing value"),q("boolean"==typeof r,"missing or invalid endian"),q(void 0!==n&&null!==n,"missing offset"),q(n+3<e.length,"Trying to write beyond buffer length"),F(t,2147483647,-2147483648));var o=e.length;n>=o||(t>=0?w(e,t,n,r,i):w(e,4294967295+t+1,n,r,i))}function S(e,t,n,r,i){i||(q(void 0!==t&&null!==t,"missing value"),q("boolean"==typeof r,"missing or invalid endian"),q(void 0!==n&&null!==n,"missing offset"),q(n+3<e.length,"Trying to write beyond buffer length"),P(t,3.4028234663852886e38,-3.4028234663852886e38));var o=e.length;n>=o||V.write(e,t,n,r,23,4)}function x(e,t,n,r,i){i||(q(void 0!==t&&null!==t,"missing value"),q("boolean"==typeof r,"missing or invalid endian"),q(void 0!==n&&null!==n,"missing offset"),q(n+7<e.length,"Trying to write beyond buffer length"),P(t,1.7976931348623157e308,-1.7976931348623157e308));var o=e.length;n>=o||V.write(e,t,n,r,52,8)}function j(e){return e.trim?e.trim():e.replace(/^\s+|\s+$/g,"")}function O(e){return e._isBuffer=!0,e._get=e.get,e._set=e.set,e.get=z.get,e.set=z.set,e.write=z.write,e.toString=z.toString,e.toLocaleString=z.toString,e.toJSON=z.toJSON,e.copy=z.copy,e.slice=z.slice,e.readUInt8=z.readUInt8,e.readUInt16LE=z.readUInt16LE,e.readUInt16BE=z.readUInt16BE,e.readUInt32LE=z.readUInt32LE,e.readUInt32BE=z.readUInt32BE,e.readInt8=z.readInt8,e.readInt16LE=z.readInt16LE,e.readInt16BE=z.readInt16BE,e.readInt32LE=z.readInt32LE,e.readInt32BE=z.readInt32BE,e.readFloatLE=z.readFloatLE,e.readFloatBE=z.readFloatBE,e.readDoubleLE=z.readDoubleLE,e.readDoubleBE=z.readDoubleBE,e.writeUInt8=z.writeUInt8,e.writeUInt16LE=z.writeUInt16LE,e.writeUInt16BE=z.writeUInt16BE,e.writeUInt32LE=z.writeUInt32LE,e.writeUInt32BE=z.writeUInt32BE,e.writeInt8=z.writeInt8,e.writeInt16LE=z.writeInt16LE,e.writeInt16BE=z.writeInt16BE,e.writeInt32LE=z.writeInt32LE,e.writeInt32BE=z.writeInt32BE,e.writeFloatLE=z.writeFloatLE,e.writeFloatBE=z.writeFloatBE,e.writeDoubleLE=z.writeDoubleLE,e.writeDoubleBE=z.writeDoubleBE,e.fill=z.fill,e.inspect=z.inspect,e.toArrayBuffer=z.toArrayBuffer,e}function A(e,t,n){return"number"!=typeof e?n:(e=~~e,e>=t?t:e>=0?e:(e+=t,e>=0?e:0))}function L(e){return e=~~Math.ceil(+e),0>e?0:e}function I(e){return(Array.isArray||function(e){return"[object Array]"===Object.prototype.toString.call(e)})(e)}function T(e){return I(e)||r.isBuffer(e)||e&&"object"==typeof e&&"number"==typeof e.length}function R(e){return 16>e?"0"+e.toString(16):e.toString(16)}function C(e){for(var t=[],n=0;n<e.length;n++){var r=e.charCodeAt(n);if(127>=r)t.push(e.charCodeAt(n));else{var i=n;r>=55296&&57343>=r&&n++;for(var o=encodeURIComponent(e.slice(i,n+1)).substr(1).split("%"),s=0;s<o.length;s++)t.push(parseInt(o[s],16))}}return t}function N(e){for(var t=[],n=0;n<e.length;n++)t.push(255&e.charCodeAt(n));return t}function B(e){return W.toByteArray(e)}function D(e,t,n,r){for(var i=0;r>i&&!(i+n>=t.length||i>=e.length);i++)t[i+n]=e[i];return i}function M(e){try{return decodeURIComponent(e)}catch(t){return String.fromCharCode(65533)}}function U(e,t){q("number"==typeof e,"cannot write a non-number as a number"),q(e>=0,"specified a negative value for writing an unsigned value"),q(t>=e,"value is larger than maximum value for type"),q(Math.floor(e)===e,"value has a fractional component")}function F(e,t,n){q("number"==typeof e,"cannot write a non-number as a number"),q(t>=e,"value larger than maximum allowed value"),q(e>=n,"value smaller than minimum allowed value"),q(Math.floor(e)===e,"value has a fractional component")}function P(e,t,n){q("number"==typeof e,"cannot write a non-number as a number"),q(t>=e,"value larger than maximum allowed value"),q(e>=n,"value smaller than minimum allowed value")}function q(e,t){if(!e)throw new Error(t||"Failed assertion")}var W=e("base64-js"),V=e("ieee754");n.Buffer=r,n.SlowBuffer=r,n.INSPECT_MAX_BYTES=50,r.poolSize=8192,r._useTypedArrays=function(){if("undefined"==typeof Uint8Array||"undefined"==typeof ArrayBuffer)return!1;try{var e=new Uint8Array(0);return e.foo=function(){return 42},42===e.foo()&&"function"==typeof e.subarray}catch(t){return!1}}(),r.isEncoding=function(e){switch(String(e).toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"raw":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return!0;default:return!1}},r.isBuffer=function(e){return!(null===e||void 0===e||!e._isBuffer)},r.byteLength=function(e,t){var n;switch(e+="",t||"utf8"){case"hex":n=e.length/2;break;case"utf8":case"utf-8":n=C(e).length;break;case"ascii":case"binary":case"raw":n=e.length;break;case"base64":n=B(e).length;break;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":n=2*e.length;break;default:throw new Error("Unknown encoding")}return n},r.concat=function(e,t){if(q(I(e),"Usage: Buffer.concat(list, [totalLength])\nlist should be an Array."),0===e.length)return new r(0);if(1===e.length)return e[0];var n;if("number"!=typeof t)for(t=0,n=0;n<e.length;n++)t+=e[n].length;var i=new r(t),o=0;for(n=0;n<e.length;n++){var s=e[n];s.copy(i,o),o+=s.length}return i},r.prototype.write=function(e,t,n,r){if(isFinite(t))isFinite(n)||(r=n,n=void 0);else{var c=r;r=t,t=n,n=c}t=Number(t)||0;var l=this.length-t;switch(n?(n=Number(n),n>l&&(n=l)):n=l,r=String(r||"utf8").toLowerCase()){case"hex":return i(this,e,t,n);case"utf8":case"utf-8":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return o(this,e,t,n);case"ascii":return s(this,e,t,n);case"binary":return a(this,e,t,n);case"base64":return u(this,e,t,n);default:throw new Error("Unknown encoding")}},r.prototype.toString=function(e,t,n){var r=this;if(e=String(e||"utf8").toLowerCase(),t=Number(t)||0,n=void 0!==n?Number(n):n=r.length,n===t)return"";switch(e){case"hex":return h(r,t,n);case"utf8":case"utf-8":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return l(r,t,n);case"ascii":return f(r,t,n);case"binary":return d(r,t,n);case"base64":return c(r,t,n);default:throw new Error("Unknown encoding")}},r.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}},r.prototype.copy=function(e,t,n,r){var i=this;if(n||(n=0),r||0===r||(r=this.length),t||(t=0),r!==n&&0!==e.length&&0!==i.length){q(r>=n,"sourceEnd < sourceStart"),q(t>=0&&t<e.length,"targetStart out of bounds"),q(n>=0&&n<i.length,"sourceStart out of bounds"),q(r>=0&&r<=i.length,"sourceEnd out of bounds"),r>this.length&&(r=this.length),e.length-t<r-n&&(r=e.length-t+n);for(var o=0;r-n>o;o++)e[o+t]=this[o+n]}},r.prototype.slice=function(e,t){var n=this.length;if(e=A(e,n,0),t=A(t,n,n),r._useTypedArrays)return O(this.subarray(e,t));for(var i=t-e,o=new r(i,void 0,!0),s=0;i>s;s++)o[s]=this[s+e];return o},r.prototype.get=function(e){return console.log(".get() is deprecated. Access using array indexes instead."),this.readUInt8(e)},r.prototype.set=function(e,t){return console.log(".set() is deprecated. Access using array indexes instead."),this.writeUInt8(e,t)},r.prototype.readUInt8=function(e,t){return t||(q(void 0!==e&&null!==e,"missing offset"),q(e<this.length,"Trying to read beyond buffer length")),e>=this.length?void 0:this[e]},r.prototype.readUInt16LE=function(e,t){return p(this,e,!0,t)},r.prototype.readUInt16BE=function(e,t){return p(this,e,!1,t)},r.prototype.readUInt32LE=function(e,t){return g(this,e,!0,t)},r.prototype.readUInt32BE=function(e,t){return g(this,e,!1,t)},r.prototype.readInt8=function(e,t){if(t||(q(void 0!==e&&null!==e,"missing offset"),q(e<this.length,"Trying to read beyond buffer length")),!(e>=this.length)){var n=128&this[e];return n?-1*(255-this[e]+1):this[e]}},r.prototype.readInt16LE=function(e,t){return y(this,e,!0,t)},r.prototype.readInt16BE=function(e,t){return y(this,e,!1,t)},r.prototype.readInt32LE=function(e,t){return v(this,e,!0,t)},r.prototype.readInt32BE=function(e,t){return v(this,e,!1,t)},r.prototype.readFloatLE=function(e,t){return b(this,e,!0,t)},r.prototype.readFloatBE=function(e,t){return b(this,e,!1,t)},r.prototype.readDoubleLE=function(e,t){return m(this,e,!0,t)},r.prototype.readDoubleBE=function(e,t){return m(this,e,!1,t)},r.prototype.writeUInt8=function(e,t,n){n||(q(void 0!==e&&null!==e,"missing value"),q(void 0!==t&&null!==t,"missing offset"),q(t<this.length,"trying to write beyond buffer length"),U(e,255)),t>=this.length||(this[t]=e)},r.prototype.writeUInt16LE=function(e,t,n){_(this,e,t,!0,n)},r.prototype.writeUInt16BE=function(e,t,n){_(this,e,t,!1,n)},r.prototype.writeUInt32LE=function(e,t,n){w(this,e,t,!0,n)},r.prototype.writeUInt32BE=function(e,t,n){w(this,e,t,!1,n)},r.prototype.writeInt8=function(e,t,n){n||(q(void 0!==e&&null!==e,"missing value"),q(void 0!==t&&null!==t,"missing offset"),q(t<this.length,"Trying to write beyond buffer length"),F(e,127,-128)),t>=this.length||(e>=0?this.writeUInt8(e,t,n):this.writeUInt8(255+e+1,t,n))},r.prototype.writeInt16LE=function(e,t,n){E(this,e,t,!0,n)},r.prototype.writeInt16BE=function(e,t,n){E(this,e,t,!1,n)},r.prototype.writeInt32LE=function(e,t,n){k(this,e,t,!0,n)},r.prototype.writeInt32BE=function(e,t,n){k(this,e,t,!1,n)},r.prototype.writeFloatLE=function(e,t,n){S(this,e,t,!0,n)},r.prototype.writeFloatBE=function(e,t,n){S(this,e,t,!1,n)},r.prototype.writeDoubleLE=function(e,t,n){x(this,e,t,!0,n)},r.prototype.writeDoubleBE=function(e,t,n){x(this,e,t,!1,n)},r.prototype.fill=function(e,t,n){if(e||(e=0),t||(t=0),n||(n=this.length),"string"==typeof e&&(e=e.charCodeAt(0)),q("number"==typeof e&&!isNaN(e),"value is not a number"),q(n>=t,"end < start"),n!==t&&0!==this.length){q(t>=0&&t<this.length,"start out of bounds"),q(n>=0&&n<=this.length,"end out of bounds");for(var r=t;n>r;r++)this[r]=e}},r.prototype.inspect=function(){for(var e=[],t=this.length,r=0;t>r;r++)if(e[r]=R(this[r]),r===n.INSPECT_MAX_BYTES){e[r+1]="...";break}return"<Buffer "+e.join(" ")+">"},r.prototype.toArrayBuffer=function(){if("function"==typeof Uint8Array){if(r._useTypedArrays)return new r(this).buffer;for(var e=new Uint8Array(this.length),t=0,n=e.length;n>t;t+=1)e[t]=this[t];return e.buffer}throw new Error("Buffer.toArrayBuffer not supported in this browser")};var z=r.prototype},{"base64-js":21,ieee754:22}],21:[function(e,t,n){var r="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";!function(e){"use strict";function t(e){var t=e.charCodeAt(0);return t===s?62:t===a?63:u>t?-1:u+10>t?t-u+26+26:l+26>t?t-l:c+26>t?t-c+26:void 0}function n(e){function n(e){c[f++]=e}var r,i,s,a,u,c;if(e.length%4>0)throw new Error("Invalid string. Length must be a multiple of 4");var l=e.length;u="="===e.charAt(l-2)?2:"="===e.charAt(l-1)?1:0,c=new o(3*e.length/4-u),s=u>0?e.length-4:e.length;var f=0;for(r=0,i=0;s>r;r+=4,i+=3)a=t(e.charAt(r))<<18|t(e.charAt(r+1))<<12|t(e.charAt(r+2))<<6|t(e.charAt(r+3)),n((16711680&a)>>16),n((65280&a)>>8),n(255&a);return 2===u?(a=t(e.charAt(r))<<2|t(e.charAt(r+1))>>4,n(255&a)):1===u&&(a=t(e.charAt(r))<<10|t(e.charAt(r+1))<<4|t(e.charAt(r+2))>>2,n(a>>8&255),n(255&a)),c}function i(e){function t(e){return r.charAt(e)}function n(e){return t(e>>18&63)+t(e>>12&63)+t(e>>6&63)+t(63&e)}var i,o,s,a=e.length%3,u="";for(i=0,s=e.length-a;s>i;i+=3)o=(e[i]<<16)+(e[i+1]<<8)+e[i+2],u+=n(o);switch(a){case 1:o=e[e.length-1],u+=t(o>>2),u+=t(o<<4&63),u+="==";break;case 2:o=(e[e.length-2]<<8)+e[e.length-1],u+=t(o>>10),u+=t(o>>4&63),u+=t(o<<2&63),u+="="}return u}var o="undefined"!=typeof Uint8Array?Uint8Array:Array,s="+".charCodeAt(0),a="/".charCodeAt(0),u="0".charCodeAt(0),c="a".charCodeAt(0),l="A".charCodeAt(0);e.toByteArray=n,e.fromByteArray=i}("undefined"==typeof n?this.base64js={}:n)},{}],22:[function(e,t,n){n.read=function(e,t,n,r,i){var o,s,a=8*i-r-1,u=(1<<a)-1,c=u>>1,l=-7,f=n?i-1:0,d=n?-1:1,h=e[t+f];for(f+=d,o=h&(1<<-l)-1,h>>=-l,l+=a;l>0;o=256*o+e[t+f],f+=d,l-=8);for(s=o&(1<<-l)-1,o>>=-l,l+=r;l>0;s=256*s+e[t+f],f+=d,l-=8);if(0===o)o=1-c;else{if(o===u)return s?0/0:1/0*(h?-1:1);s+=Math.pow(2,r),o-=c}return(h?-1:1)*s*Math.pow(2,o-r)},n.write=function(e,t,n,r,i,o){var s,a,u,c=8*o-i-1,l=(1<<c)-1,f=l>>1,d=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,h=r?0:o-1,p=r?1:-1,g=0>t||0===t&&0>1/t?1:0;for(t=Math.abs(t),isNaN(t)||1/0===t?(a=isNaN(t)?1:0,s=l):(s=Math.floor(Math.log(t)/Math.LN2),t*(u=Math.pow(2,-s))<1&&(s--,u*=2),t+=s+f>=1?d/u:d*Math.pow(2,1-f),t*u>=2&&(s++,u/=2),s+f>=l?(a=0,s=l):s+f>=1?(a=(t*u-1)*Math.pow(2,i),s+=f):(a=t*Math.pow(2,f-1)*Math.pow(2,i),s=0));i>=8;e[n+h]=255&a,h+=p,a/=256,i-=8);for(s=s<<i|a,c+=i;c>0;e[n+h]=255&s,h+=p,s/=256,c-=8);e[n+h-p]|=128*g}},{}],23:[function(e,t){function n(e){return this instanceof n?(s.call(this,e),a.call(this,e),e&&e.readable===!1&&(this.readable=!1),e&&e.writable===!1&&(this.writable=!1),this.allowHalfOpen=!0,e&&e.allowHalfOpen===!1&&(this.allowHalfOpen=!1),void this.once("end",r)):new n(e)}function r(){if(!this.allowHalfOpen&&!this._writableState.ended){var e=this;o(function(){e.end()})}}t.exports=n;var i=e("inherits"),o=e("process/browser.js").nextTick,s=e("./readable.js"),a=e("./writable.js");i(n,s),n.prototype.write=a.prototype.write,n.prototype.end=a.prototype.end,n.prototype._write=a.prototype._write},{"./readable.js":27,"./writable.js":29,inherits:33,"process/browser.js":25}],24:[function(e,t){function n(){r.call(this)}t.exports=n;var r=e("events").EventEmitter,i=e("inherits");i(n,r),n.Readable=e("./readable.js"),n.Writable=e("./writable.js"),n.Duplex=e("./duplex.js"),n.Transform=e("./transform.js"),n.PassThrough=e("./passthrough.js"),n.Stream=n,n.prototype.pipe=function(e,t){function n(t){e.writable&&!1===e.write(t)&&c.pause&&c.pause()}function i(){c.readable&&c.resume&&c.resume()}function o(){l||(l=!0,e.end())}function s(){l||(l=!0,"function"==typeof e.destroy&&e.destroy())}function a(e){if(u(),0===r.listenerCount(this,"error"))throw e}function u(){c.removeListener("data",n),e.removeListener("drain",i),c.removeListener("end",o),c.removeListener("close",s),c.removeListener("error",a),e.removeListener("error",a),c.removeListener("end",u),c.removeListener("close",u),e.removeListener("close",u)}var c=this;c.on("data",n),e.on("drain",i),e._isStdio||t&&t.end===!1||(c.on("end",o),c.on("close",s));var l=!1;return c.on("error",a),e.on("error",a),c.on("end",u),c.on("close",u),e.on("close",u),e.emit("pipe",c),e}},{"./duplex.js":23,"./passthrough.js":26,"./readable.js":27,"./transform.js":28,"./writable.js":29,events:18,inherits:33}],25:[function(e,t){t.exports=e(19)},{}],26:[function(e,t){function n(e){return this instanceof n?void r.call(this,e):new n(e)}t.exports=n;var r=e("./transform.js"),i=e("inherits");i(n,r),n.prototype._transform=function(e,t,n){n(null,e)}},{"./transform.js":28,inherits:33}],27:[function(e,t){(function(n){function r(t){t=t||{};var n=t.highWaterMark;this.highWaterMark=n||0===n?n:16384,this.highWaterMark=~~this.highWaterMark,this.buffer=[],this.length=0,this.pipes=null,this.pipesCount=0,this.flowing=!1,this.ended=!1,this.endEmitted=!1,this.reading=!1,this.calledRead=!1,this.sync=!0,this.needReadable=!1,this.emittedReadable=!1,this.readableListening=!1,this.objectMode=!!t.objectMode,this.defaultEncoding=t.defaultEncoding||"utf8",this.ranOut=!1,this.awaitDrain=0,this.readingMore=!1,this.decoder=null,this.encoding=null,t.encoding&&(k||(k=e("string_decoder").StringDecoder),this.decoder=new k(t.encoding),this.encoding=t.encoding)}function i(e){return this instanceof i?(this._readableState=new r(e,this),this.readable=!0,void x.call(this)):new i(e)}function o(e,t,n,r,i){var o=c(t,n);if(o)e.emit("error",o);else if(null===n||void 0===n)t.reading=!1,t.ended||l(e,t);else if(t.objectMode||n&&n.length>0)if(t.ended&&!i){var a=new Error("stream.push() after EOF");e.emit("error",a)}else if(t.endEmitted&&i){var a=new Error("stream.unshift() after end event");e.emit("error",a)}else!t.decoder||i||r||(n=t.decoder.write(n)),t.length+=t.objectMode?1:n.length,i?t.buffer.unshift(n):(t.reading=!1,t.buffer.push(n)),t.needReadable&&f(e),h(e,t);else i||(t.reading=!1);return s(t)}function s(e){return!e.ended&&(e.needReadable||e.length<e.highWaterMark||0===e.length)}function a(e){if(e>=L)e=L;else{e--;for(var t=1;32>t;t<<=1)e|=e>>t;e++}return e}function u(e,t){return 0===t.length&&t.ended?0:t.objectMode?0===e?0:1:isNaN(e)||null===e?t.flowing&&t.buffer.length?t.buffer[0].length:t.length:0>=e?0:(e>t.highWaterMark&&(t.highWaterMark=a(e)),e>t.length?t.ended?t.length:(t.needReadable=!0,0):e)}function c(e,t){var n=null;return j.isBuffer(t)||"string"==typeof t||null===t||void 0===t||e.objectMode||n||(n=new TypeError("Invalid non-string/buffer chunk")),n}function l(e,t){if(t.decoder&&!t.ended){var n=t.decoder.end();n&&n.length&&(t.buffer.push(n),t.length+=t.objectMode?1:n.length)}t.ended=!0,t.length>0?f(e):_(e)}function f(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(t.emittedReadable=!0,t.sync?O(function(){d(e)}):d(e))}function d(e){e.emit("readable")}function h(e,t){t.readingMore||(t.readingMore=!0,O(function(){p(e,t)}))}function p(e,t){for(var n=t.length;!t.reading&&!t.flowing&&!t.ended&&t.length<t.highWaterMark&&(e.read(0),n!==t.length);)n=t.length;t.readingMore=!1}function g(e){return function(){var t=e._readableState;t.awaitDrain--,0===t.awaitDrain&&y(e)}}function y(e){function t(e){var t=e.write(n);!1===t&&r.awaitDrain++}var n,r=e._readableState;for(r.awaitDrain=0;r.pipesCount&&null!==(n=e.read());)if(1===r.pipesCount?t(r.pipes,0,null):w(r.pipes,t),e.emit("data",n),r.awaitDrain>0)return;return 0===r.pipesCount?(r.flowing=!1,void(S.listenerCount(e,"data")>0&&b(e))):void(r.ranOut=!0)}function v(){this._readableState.ranOut&&(this._readableState.ranOut=!1,y(this))}function b(e,t){var n=e._readableState;if(n.flowing)throw new Error("Cannot switch to old mode now.");var r=t||!1,i=!1;e.readable=!0,e.pipe=x.prototype.pipe,e.on=e.addListener=x.prototype.on,e.on("readable",function(){i=!0;for(var t;!r&&null!==(t=e.read());)e.emit("data",t);null===t&&(i=!1,e._readableState.needReadable=!0)}),e.pause=function(){r=!0,this.emit("pause")},e.resume=function(){r=!1,i?O(function(){e.emit("readable")}):this.read(0),this.emit("resume")},e.emit("readable")}function m(e,t){var n,r=t.buffer,i=t.length,o=!!t.decoder,s=!!t.objectMode;if(0===r.length)return null;if(0===i)n=null;else if(s)n=r.shift();else if(!e||e>=i)n=o?r.join(""):j.concat(r,i),r.length=0;else if(e<r[0].length){var a=r[0];n=a.slice(0,e),r[0]=a.slice(e)}else if(e===r[0].length)n=r.shift();else{n=o?"":new j(e);for(var u=0,c=0,l=r.length;l>c&&e>u;c++){var a=r[0],f=Math.min(e-u,a.length);o?n+=a.slice(0,f):a.copy(n,u,0,f),f<a.length?r[0]=a.slice(f):r.shift(),u+=f}}return n}function _(e){var t=e._readableState;if(t.length>0)throw new Error("endReadable called on non-empty stream");!t.endEmitted&&t.calledRead&&(t.ended=!0,O(function(){t.endEmitted||0!==t.length||(t.endEmitted=!0,e.readable=!1,e.emit("end"))}))}function w(e,t){for(var n=0,r=e.length;r>n;n++)t(e[n],n)}function E(e,t){for(var n=0,r=e.length;r>n;n++)if(e[n]===t)return n;return-1}t.exports=i,i.ReadableState=r;var k,S=e("events").EventEmitter,x=e("./index.js"),j=e("buffer").Buffer,O=e("process/browser.js").nextTick,A=e("inherits");A(i,x),i.prototype.push=function(e,t){var n=this._readableState;return"string"!=typeof e||n.objectMode||(t=t||n.defaultEncoding,t!==n.encoding&&(e=new j(e,t),t="")),o(this,n,e,t,!1)},i.prototype.unshift=function(e){var t=this._readableState;return o(this,t,e,"",!0)},i.prototype.setEncoding=function(t){k||(k=e("string_decoder").StringDecoder),this._readableState.decoder=new k(t),this._readableState.encoding=t};var L=8388608;i.prototype.read=function(e){var t=this._readableState;t.calledRead=!0;var n=e;if(("number"!=typeof e||e>0)&&(t.emittedReadable=!1),0===e&&t.needReadable&&(t.length>=t.highWaterMark||t.ended))return f(this),null;if(e=u(e,t),0===e&&t.ended)return 0===t.length&&_(this),null;var r=t.needReadable;t.length-e<=t.highWaterMark&&(r=!0),(t.ended||t.reading)&&(r=!1),r&&(t.reading=!0,t.sync=!0,0===t.length&&(t.needReadable=!0),this._read(t.highWaterMark),t.sync=!1),r&&!t.reading&&(e=u(n,t));var i;return i=e>0?m(e,t):null,null===i&&(t.needReadable=!0,e=0),t.length-=e,0!==t.length||t.ended||(t.needReadable=!0),t.ended&&!t.endEmitted&&0===t.length&&_(this),i},i.prototype._read=function(){this.emit("error",new Error("not implemented"))},i.prototype.pipe=function(e,t){function r(e){e===l&&o()}function i(){e.end()}function o(){e.removeListener("close",a),e.removeListener("finish",u),e.removeListener("drain",p),e.removeListener("error",s),e.removeListener("unpipe",r),l.removeListener("end",i),l.removeListener("end",o),(!e._writableState||e._writableState.needDrain)&&p()}function s(t){c(),0===b&&0===S.listenerCount(e,"error")&&e.emit("error",t)}function a(){e.removeListener("finish",u),c()}function u(){e.removeListener("close",a),c()}function c(){l.unpipe(e)}var l=this,f=this._readableState;switch(f.pipesCount){case 0:f.pipes=e;break;case 1:f.pipes=[f.pipes,e];break;default:f.pipes.push(e)}f.pipesCount+=1;var d=(!t||t.end!==!1)&&e!==n.stdout&&e!==n.stderr,h=d?i:o;f.endEmitted?O(h):l.once("end",h),e.on("unpipe",r);var p=g(l);e.on("drain",p);var b=S.listenerCount(e,"error");return e.once("error",s),e.once("close",a),e.once("finish",u),e.emit("pipe",l),f.flowing||(this.on("readable",v),f.flowing=!0,O(function(){y(l)})),e},i.prototype.unpipe=function(e){var t=this._readableState;if(0===t.pipesCount)return this;if(1===t.pipesCount)return e&&e!==t.pipes?this:(e||(e=t.pipes),t.pipes=null,t.pipesCount=0,this.removeListener("readable",v),t.flowing=!1,e&&e.emit("unpipe",this),this);if(!e){var n=t.pipes,r=t.pipesCount;t.pipes=null,t.pipesCount=0,this.removeListener("readable",v),t.flowing=!1;for(var i=0;r>i;i++)n[i].emit("unpipe",this);return this}var i=E(t.pipes,e);return-1===i?this:(t.pipes.splice(i,1),t.pipesCount-=1,1===t.pipesCount&&(t.pipes=t.pipes[0]),e.emit("unpipe",this),this)},i.prototype.on=function(e,t){var n=x.prototype.on.call(this,e,t);if("data"!==e||this._readableState.flowing||b(this),"readable"===e&&this.readable){var r=this._readableState;r.readableListening||(r.readableListening=!0,r.emittedReadable=!1,r.needReadable=!0,r.reading?r.length&&f(this,r):this.read(0))}return n},i.prototype.addListener=i.prototype.on,i.prototype.resume=function(){b(this),this.read(0),this.emit("resume")},i.prototype.pause=function(){b(this,!0),this.emit("pause")},i.prototype.wrap=function(e){var t=this._readableState,n=!1,r=this;e.on("end",function(){if(t.decoder&&!t.ended){var e=t.decoder.end();e&&e.length&&r.push(e)}r.push(null)}),e.on("data",function(i){if(t.decoder&&(i=t.decoder.write(i)),i&&(t.objectMode||i.length)){var o=r.push(i);o||(n=!0,e.pause())}});for(var i in e)"function"==typeof e[i]&&"undefined"==typeof this[i]&&(this[i]=function(t){return function(){return e[t].apply(e,arguments)}}(i));var o=["error","close","destroy","pause","resume"];return w(o,function(t){e.on(t,function(e){return r.emit.apply(r,t,e)})}),r._read=function(){n&&(n=!1,e.resume())},r},i._fromList=m}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"./index.js":24,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,events:18,inherits:33,"process/browser.js":25,string_decoder:30}],28:[function(e,t){function n(e,t){this.afterTransform=function(e,n){return r(t,e,n)},this.needTransform=!1,this.transforming=!1,this.writecb=null,this.writechunk=null}function r(e,t,n){var r=e._transformState;r.transforming=!1;var i=r.writecb;if(!i)return e.emit("error",new Error("no writecb in Transform class"));r.writechunk=null,r.writecb=null,null!==n&&void 0!==n&&e.push(n),i&&i(t);
+var o=e._readableState;o.reading=!1,(o.needReadable||o.length<o.highWaterMark)&&e._read(o.highWaterMark)}function i(e){if(!(this instanceof i))return new i(e);s.call(this,e);var t=(this._transformState=new n(e,this),this);this._readableState.needReadable=!0,this._readableState.sync=!1,this.once("finish",function(){"function"==typeof this._flush?this._flush(function(e){o(t,e)}):o(t)})}function o(e,t){if(t)return e.emit("error",t);var n=e._writableState,r=(e._readableState,e._transformState);if(n.length)throw new Error("calling transform done when ws.length != 0");if(r.transforming)throw new Error("calling transform done when still transforming");return e.push(null)}t.exports=i;var s=e("./duplex.js"),a=e("inherits");a(i,s),i.prototype.push=function(e,t){return this._transformState.needTransform=!1,s.prototype.push.call(this,e,t)},i.prototype._transform=function(){throw new Error("not implemented")},i.prototype._write=function(e,t,n){var r=this._transformState;if(r.writecb=n,r.writechunk=e,r.writeencoding=t,!r.transforming){var i=this._readableState;(r.needTransform||i.needReadable||i.length<i.highWaterMark)&&this._read(i.highWaterMark)}},i.prototype._read=function(){var e=this._transformState;e.writechunk&&e.writecb&&!e.transforming?(e.transforming=!0,this._transform(e.writechunk,e.writeencoding,e.afterTransform)):e.needTransform=!0}},{"./duplex.js":23,inherits:33}],29:[function(e,t){function n(e,t,n){this.chunk=e,this.encoding=t,this.callback=n}function r(e,t){e=e||{};var n=e.highWaterMark;this.highWaterMark=n||0===n?n:16384,this.objectMode=!!e.objectMode,this.highWaterMark=~~this.highWaterMark,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1;var r=e.decodeStrings===!1;this.decodeStrings=!r,this.defaultEncoding=e.defaultEncoding||"utf8",this.length=0,this.writing=!1,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(e){d(t,e)},this.writecb=null,this.writelen=0,this.buffer=[]}function i(e){return this instanceof i||this instanceof E.Duplex?(this._writableState=new r(e,this),this.writable=!0,void E.call(this)):new i(e)}function o(e,t,n){var r=new Error("write after end");e.emit("error",r),k(function(){n(r)})}function s(e,t,n,r){var i=!0;if(!S.isBuffer(n)&&"string"!=typeof n&&null!==n&&void 0!==n&&!t.objectMode){var o=new TypeError("Invalid non-string/buffer chunk");e.emit("error",o),k(function(){r(o)}),i=!1}return i}function a(e,t,n){return e.objectMode||e.decodeStrings===!1||"string"!=typeof t||(t=new S(t,n)),t}function u(e,t,r,i,o){r=a(t,r,i);var s=t.objectMode?1:r.length;t.length+=s;var u=t.length<t.highWaterMark;return t.needDrain=!u,t.writing?t.buffer.push(new n(r,i,o)):c(e,t,s,r,i,o),u}function c(e,t,n,r,i,o){t.writelen=n,t.writecb=o,t.writing=!0,t.sync=!0,e._write(r,i,t.onwrite),t.sync=!1}function l(e,t,n,r,i){n?k(function(){i(r)}):i(r),e.emit("error",r)}function f(e){e.writing=!1,e.writecb=null,e.length-=e.writelen,e.writelen=0}function d(e,t){var n=e._writableState,r=n.sync,i=n.writecb;if(f(n),t)l(e,n,r,t,i);else{var o=y(e,n);o||n.bufferProcessing||!n.buffer.length||g(e,n),r?k(function(){h(e,n,o,i)}):h(e,n,o,i)}}function h(e,t,n,r){n||p(e,t),r(),n&&v(e,t)}function p(e,t){0===t.length&&t.needDrain&&(t.needDrain=!1,e.emit("drain"))}function g(e,t){t.bufferProcessing=!0;for(var n=0;n<t.buffer.length;n++){var r=t.buffer[n],i=r.chunk,o=r.encoding,s=r.callback,a=t.objectMode?1:i.length;if(c(e,t,a,i,o,s),t.writing){n++;break}}t.bufferProcessing=!1,n<t.buffer.length?t.buffer=t.buffer.slice(n):t.buffer.length=0}function y(e,t){return t.ending&&0===t.length&&!t.finished&&!t.writing}function v(e,t){var n=y(e,t);return n&&(t.finished=!0,e.emit("finish")),n}function b(e,t,n){t.ending=!0,v(e,t),n&&(t.finished?k(n):e.once("finish",n)),t.ended=!0}t.exports=i,i.WritableState=r;var m="undefined"!=typeof Uint8Array?function(e){return e instanceof Uint8Array}:function(e){return e&&e.constructor&&"Uint8Array"===e.constructor.name},_="undefined"!=typeof ArrayBuffer?function(e){return e instanceof ArrayBuffer}:function(e){return e&&e.constructor&&"ArrayBuffer"===e.constructor.name},w=e("inherits"),E=e("./index.js"),k=e("process/browser.js").nextTick,S=e("buffer").Buffer;w(i,E),i.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe. Not readable."))},i.prototype.write=function(e,t,n){var r=this._writableState,i=!1;return"function"==typeof t&&(n=t,t=null),!S.isBuffer(e)&&m(e)&&(e=new S(e)),_(e)&&"undefined"!=typeof Uint8Array&&(e=new S(new Uint8Array(e))),S.isBuffer(e)?t="buffer":t||(t=r.defaultEncoding),"function"!=typeof n&&(n=function(){}),r.ended?o(this,r,n):s(this,r,e,n)&&(i=u(this,r,e,t,n)),i},i.prototype._write=function(e,t,n){n(new Error("not implemented"))},i.prototype.end=function(e,t,n){var r=this._writableState;"function"==typeof e?(n=e,e=null,t=null):"function"==typeof t&&(n=t,t=null),"undefined"!=typeof e&&null!==e&&this.write(e,t),r.ending||r.finished||b(this,r,n)}},{"./index.js":24,buffer:20,inherits:33,"process/browser.js":25}],30:[function(e,t,n){function r(e){if(e&&!a.isEncoding(e))throw new Error("Unknown encoding: "+e)}function i(e){return e.toString(this.encoding)}function o(e){var t=this.charReceived=e.length%2;return this.charLength=t?2:0,t}function s(e){var t=this.charReceived=e.length%3;return this.charLength=t?3:0,t}var a=e("buffer").Buffer,u=n.StringDecoder=function(e){switch(this.encoding=(e||"utf8").toLowerCase().replace(/[-_]/,""),r(e),this.encoding){case"utf8":this.surrogateSize=3;break;case"ucs2":case"utf16le":this.surrogateSize=2,this.detectIncompleteChar=o;break;case"base64":this.surrogateSize=3,this.detectIncompleteChar=s;break;default:return void(this.write=i)}this.charBuffer=new a(6),this.charReceived=0,this.charLength=0};u.prototype.write=function(e){for(var t="",n=0;this.charLength;){var r=e.length>=this.charLength-this.charReceived?this.charLength-this.charReceived:e.length;if(e.copy(this.charBuffer,this.charReceived,n,r),this.charReceived+=r-n,n=r,this.charReceived<this.charLength)return"";t=this.charBuffer.slice(0,this.charLength).toString(this.encoding);var i=t.charCodeAt(t.length-1);if(!(i>=55296&&56319>=i)){if(this.charReceived=this.charLength=0,r==e.length)return t;e=e.slice(r,e.length);break}this.charLength+=this.surrogateSize,t=""}var o=this.detectIncompleteChar(e),s=e.length;this.charLength&&(e.copy(this.charBuffer,0,e.length-o,s),this.charReceived=o,s-=o),t+=e.toString(this.encoding,0,s);var s=t.length-1,i=t.charCodeAt(s);if(i>=55296&&56319>=i){var a=this.surrogateSize;return this.charLength+=a,this.charReceived+=a,this.charBuffer.copy(this.charBuffer,a,0,a),this.charBuffer.write(t.charAt(t.length-1),this.encoding),t.substring(0,s)}return t},u.prototype.detectIncompleteChar=function(e){for(var t=e.length>=3?3:e.length;t>0;t--){var n=e[e.length-t];if(1==t&&n>>5==6){this.charLength=2;break}if(2>=t&&n>>4==14){this.charLength=3;break}if(3>=t&&n>>3==30){this.charLength=4;break}}return t},u.prototype.end=function(e){var t="";if(e&&e.length&&(t=this.write(e)),this.charReceived){var n=this.charReceived,r=this.charBuffer,i=this.encoding;t+=r.slice(0,n).toString(i)}return t}},{buffer:20}],31:[function(e,t){t.exports=function(e){return e&&"object"==typeof e&&"function"==typeof e.copy&&"function"==typeof e.fill&&"function"==typeof e.readUInt8}},{}],32:[function(e,t,n){(function(t,r){function i(e,t){var r={seen:[],stylize:s};return arguments.length>=3&&(r.depth=arguments[2]),arguments.length>=4&&(r.colors=arguments[3]),g(t)?r.showHidden=t:t&&n._extend(r,t),w(r.showHidden)&&(r.showHidden=!1),w(r.depth)&&(r.depth=2),w(r.colors)&&(r.colors=!1),w(r.customInspect)&&(r.customInspect=!0),r.colors&&(r.stylize=o),u(r,e,r.depth)}function o(e,t){var n=i.styles[t];return n?"["+i.colors[n][0]+"m"+e+"["+i.colors[n][1]+"m":e}function s(e){return e}function a(e){var t={};return e.forEach(function(e){t[e]=!0}),t}function u(e,t,r){if(e.customInspect&&t&&j(t.inspect)&&t.inspect!==n.inspect&&(!t.constructor||t.constructor.prototype!==t)){var i=t.inspect(r,e);return m(i)||(i=u(e,i,r)),i}var o=c(e,t);if(o)return o;var s=Object.keys(t),g=a(s);if(e.showHidden&&(s=Object.getOwnPropertyNames(t)),x(t)&&(s.indexOf("message")>=0||s.indexOf("description")>=0))return l(t);if(0===s.length){if(j(t)){var y=t.name?": "+t.name:"";return e.stylize("[Function"+y+"]","special")}if(E(t))return e.stylize(RegExp.prototype.toString.call(t),"regexp");if(S(t))return e.stylize(Date.prototype.toString.call(t),"date");if(x(t))return l(t)}var v="",b=!1,_=["{","}"];if(p(t)&&(b=!0,_=["[","]"]),j(t)){var w=t.name?": "+t.name:"";v=" [Function"+w+"]"}if(E(t)&&(v=" "+RegExp.prototype.toString.call(t)),S(t)&&(v=" "+Date.prototype.toUTCString.call(t)),x(t)&&(v=" "+l(t)),0===s.length&&(!b||0==t.length))return _[0]+v+_[1];if(0>r)return E(t)?e.stylize(RegExp.prototype.toString.call(t),"regexp"):e.stylize("[Object]","special");e.seen.push(t);var k;return k=b?f(e,t,r,g,s):s.map(function(n){return d(e,t,r,g,n,b)}),e.seen.pop(),h(k,v,_)}function c(e,t){if(w(t))return e.stylize("undefined","undefined");if(m(t)){var n="'"+JSON.stringify(t).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return e.stylize(n,"string")}return b(t)?e.stylize(""+t,"number"):g(t)?e.stylize(""+t,"boolean"):y(t)?e.stylize("null","null"):void 0}function l(e){return"["+Error.prototype.toString.call(e)+"]"}function f(e,t,n,r,i){for(var o=[],s=0,a=t.length;a>s;++s)o.push(T(t,String(s))?d(e,t,n,r,String(s),!0):"");return i.forEach(function(i){i.match(/^\d+$/)||o.push(d(e,t,n,r,i,!0))}),o}function d(e,t,n,r,i,o){var s,a,c;if(c=Object.getOwnPropertyDescriptor(t,i)||{value:t[i]},c.get?a=c.set?e.stylize("[Getter/Setter]","special"):e.stylize("[Getter]","special"):c.set&&(a=e.stylize("[Setter]","special")),T(r,i)||(s="["+i+"]"),a||(e.seen.indexOf(c.value)<0?(a=y(n)?u(e,c.value,null):u(e,c.value,n-1),a.indexOf("\n")>-1&&(a=o?a.split("\n").map(function(e){return" "+e}).join("\n").substr(2):"\n"+a.split("\n").map(function(e){return" "+e}).join("\n"))):a=e.stylize("[Circular]","special")),w(s)){if(o&&i.match(/^\d+$/))return a;s=JSON.stringify(""+i),s.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(s=s.substr(1,s.length-2),s=e.stylize(s,"name")):(s=s.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),s=e.stylize(s,"string"))}return s+": "+a}function h(e,t,n){var r=0,i=e.reduce(function(e,t){return r++,t.indexOf("\n")>=0&&r++,e+t.replace(/\u001b\[\d\d?m/g,"").length+1},0);return i>60?n[0]+(""===t?"":t+"\n ")+" "+e.join(",\n ")+" "+n[1]:n[0]+t+" "+e.join(", ")+" "+n[1]}function p(e){return Array.isArray(e)}function g(e){return"boolean"==typeof e}function y(e){return null===e}function v(e){return null==e}function b(e){return"number"==typeof e}function m(e){return"string"==typeof e}function _(e){return"symbol"==typeof e}function w(e){return void 0===e}function E(e){return k(e)&&"[object RegExp]"===A(e)}function k(e){return"object"==typeof e&&null!==e}function S(e){return k(e)&&"[object Date]"===A(e)}function x(e){return k(e)&&("[object Error]"===A(e)||e instanceof Error)}function j(e){return"function"==typeof e}function O(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"==typeof e||"undefined"==typeof e}function A(e){return Object.prototype.toString.call(e)}function L(e){return 10>e?"0"+e.toString(10):e.toString(10)}function I(){var e=new Date,t=[L(e.getHours()),L(e.getMinutes()),L(e.getSeconds())].join(":");return[e.getDate(),B[e.getMonth()],t].join(" ")}function T(e,t){return Object.prototype.hasOwnProperty.call(e,t)}var R=/%[sdj%]/g;n.format=function(e){if(!m(e)){for(var t=[],n=0;n<arguments.length;n++)t.push(i(arguments[n]));return t.join(" ")}for(var n=1,r=arguments,o=r.length,s=String(e).replace(R,function(e){if("%%"===e)return"%";if(n>=o)return e;switch(e){case"%s":return String(r[n++]);case"%d":return Number(r[n++]);case"%j":try{return JSON.stringify(r[n++])}catch(t){return"[Circular]"}default:return e}}),a=r[n];o>n;a=r[++n])s+=y(a)||!k(a)?" "+a:" "+i(a);return s},n.deprecate=function(e,i){function o(){if(!s){if(t.throwDeprecation)throw new Error(i);t.traceDeprecation?console.trace(i):console.error(i),s=!0}return e.apply(this,arguments)}if(w(r.process))return function(){return n.deprecate(e,i).apply(this,arguments)};if(t.noDeprecation===!0)return e;var s=!1;return o};var C,N={};n.debuglog=function(e){if(w(C)&&(C=t.env.NODE_DEBUG||""),e=e.toUpperCase(),!N[e])if(new RegExp("\\b"+e+"\\b","i").test(C)){var r=t.pid;N[e]=function(){var t=n.format.apply(n,arguments);console.error("%s %d: %s",e,r,t)}}else N[e]=function(){};return N[e]},n.inspect=i,i.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]},i.styles={special:"cyan",number:"yellow","boolean":"yellow",undefined:"grey","null":"bold",string:"green",date:"magenta",regexp:"red"},n.isArray=p,n.isBoolean=g,n.isNull=y,n.isNullOrUndefined=v,n.isNumber=b,n.isString=m,n.isSymbol=_,n.isUndefined=w,n.isRegExp=E,n.isObject=k,n.isDate=S,n.isError=x,n.isFunction=j,n.isPrimitive=O,n.isBuffer=e("./support/isBuffer");var B=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];n.log=function(){console.log("%s - %s",I(),n.format.apply(n,arguments))},n.inherits=e("inherits"),n._extend=function(e,t){if(!t||!k(t))return e;for(var n=Object.keys(t),r=n.length;r--;)e[n[r]]=t[n[r]];return e}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./support/isBuffer":31,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,inherits:33}],33:[function(e,t){t.exports="function"==typeof Object.create?function(e,t){e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}})}:function(e,t){e.super_=t;var n=function(){};n.prototype=t.prototype,e.prototype=new n,e.prototype.constructor=e}},{}],34:[function(e,t){function n(e,t,n,r){var i={type:e,key:t,value:n,options:r};return r&&r.prefix&&(i.prefix=r.prefix,delete r.prefix),this._operations.push(i),this}function r(e){this._operations=[],this._sdb=e,this.put=n.bind(this,"put"),this.del=n.bind(this,"del")}var i=r.prototype;i.clear=function(){this._operations=[]},i.write=function(e){this._sdb.batch(this._operations,e)},t.exports=r},{}],35:[function(e,t){(function(n){var r=(e("events").EventEmitter,n.nextTick,e("./sub")),i=e("./batch"),o=e("level-fix-range"),s=e("level-hooks");t.exports=function(e,t){function n(){}function a(e){return function(t){return t=t||{},t=o(t),t.reverse?t.start=t.start||c:t.end=t.end||c,e.call(u,t)}}n.prototype=e;var u=new n;if(u.sublevel)return u;t=t||{};var c=t.sep=t.sep||"ÿ";u._options=t,s(u),u.sublevels={},u.sublevel=function(e,t){return u.sublevels[e]?u.sublevels[e]:new r(u,e,t||this._options)},u.methods={},u.prefix=function(e){return""+(e||"")},u.pre=function(e,t){return t||(t=e,e={max:c}),u.hooks.pre(e,t)},u.post=function(e,t){return t||(t=e,e={max:c}),u.hooks.post(e,t)},u.readStream=u.createReadStream=a(u.createReadStream),u.keyStream=u.createKeyStream=a(u.createKeyStream),u.valuesStream=u.createValueStream=a(u.createValueStream);var l=u.batch;return u.batch=function(e,t,n){return Array.isArray(e)?(e.forEach(function(e){e.prefix&&("function"==typeof e.prefix.prefix?e.key=e.prefix.prefix(e.key):"string"==typeof e.prefix&&(e.key=e.prefix+e.key))}),void l.call(u,e,t,n)):new i(u)},u}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"./batch":34,"./sub":46,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,events:18,"level-fix-range":36,"level-hooks":38}],36:[function(e,t){var n=e("clone");t.exports=function(e){e=n(e);var t=e.reverse,r=e.max||e.end,i=e.min||e.start,o=[i,r];return null!=i&&null!=r&&o.sort(),t&&(o=o.reverse()),e.start=o[0],e.end=o[1],delete e.min,delete e.max,e}},{clone:37}],37:[function(e,t){(function(e){"use strict";function n(e){return Object.prototype.toString.call(e)}function r(t,n,r,o){function s(t,r){if(null===t)return null;if(0==r)return t;var l;if("object"!=typeof t)return t;if(i.isArray(t))l=[];else if(i.isRegExp(t))l=new RegExp(t.source,i.getRegExpFlags(t)),t.lastIndex&&(l.lastIndex=t.lastIndex);else if(i.isDate(t))l=new Date(t.getTime());else{if(c&&e.isBuffer(t))return l=new e(t.length),t.copy(l),l;l=Object.create("undefined"==typeof o?Object.getPrototypeOf(t):o)}if(n){var f=a.indexOf(t);if(-1!=f)return u[f];a.push(t),u.push(l)}for(var d in t)l[d]=s(t[d],r-1);return l}var a=[],u=[],c="undefined"!=typeof e;return"undefined"==typeof n&&(n=!0),"undefined"==typeof r&&(r=1/0),s(t,r)}var i={isArray:function(e){return Array.isArray(e)||"object"==typeof e&&"[object Array]"===n(e)},isDate:function(e){return"object"==typeof e&&"[object Date]"===n(e)},isRegExp:function(e){return"object"==typeof e&&"[object RegExp]"===n(e)},getRegExpFlags:function(e){var t="";return e.global&&(t+="g"),e.ignoreCase&&(t+="i"),e.multiline&&(t+="m"),t}};"object"==typeof t&&(t.exports=r),r.clonePrototype=function(e){if(null===e)return null;var t=function(){};return t.prototype=e,new t}}).call(this,e("buffer").Buffer)},{buffer:20}],38:[function(e,t){var n=e("string-range");t.exports=function(e){function t(e){return e&&("string"==typeof e?e:"string"==typeof e.prefix?e.prefix:"function"==typeof e.prefix?e.prefix():"")}function r(e){return e&&e._getKeyEncoding?e._getKeyEncoding(e):void 0}function i(e){return e&&e._getValueEncoding?e._getValueEncoding(e):void 0}function o(e,t){return function(){var n=e.indexOf(t);return~n?(e.splice(n,1),!0):!1}}function s(e){e&&e.type&&u.forEach(function(t){t.test(e.key)&&t.hook(e)})}function a(n,o,s,a){try{o.forEach(function p(e,n){c.forEach(function(s){if(s.test(String(e.key))){var a={add:function(e,a){if("undefined"==typeof e)return this;if(e===!1)return delete o[n];var u=t(e.prefix)||t(a)||s.prefix||"";if(u&&(e.prefix=u),e.key=u+e.key,s.safe&&s.test(String(e.key)))throw new Error("prehook cannot insert into own range");var c=e.keyEncoding||r(e.prefix),l=e.valueEncoding||i(e.prefix);return c&&(e.keyEncoding=c),l&&(e.valueEncoding=l),o.push(e),p(e,o.length-1),this},put:function(e,t){return"object"==typeof e&&(e.type="put"),this.add(e,t)},del:function(e,t){return"object"==typeof e&&(e.type="del"),this.add(e,t)},veto:function(){return this.add(!1)}};s.hook.call(a,e,a.add,o)}})})}catch(u){return(a||s)(u)}if(o=o.filter(function(e){return e&&e.type}),1==o.length&&!n){var h=o[0];return"put"==h.type?l.call(e,h.key,h.value,s,a):f.call(e,h.key,s,a)}return d.call(e,o,s,a)}if(!e.hooks){var u=[],c=[];e.hooks={post:function(e,t){t||(t=e,e="");var r={test:n.checker(e),hook:t};return u.push(r),o(u,r)},pre:function(e,t){t||(t=e,e="");var r={test:n.checker(e),hook:t,safe:!1!==e.safe};return c.push(r),o(c,r)},posthooks:u,prehooks:c},e.on("put",function(e,t){s({type:"put",key:e,value:t})}),e.on("del",function(e,t){s({type:"del",key:e,value:t})}),e.on("batch",function(e){e.forEach(s)});var l=e.put,f=e.del,d=e.batch;e.put=function(e,t,n,r){var i=[{key:e,value:t,type:"put"}];return a(!1,i,n,r)},e.del=function(e,t,n){var r=[{key:e,type:"del"}];return a(!1,r,t,n)},e.batch=function(e,t,n){return a(!0,e,t,n)}}}},{"string-range":39}],39:[function(e,t,n){{var r=n.range=function(e){return null==e?{}:"string"==typeof r?{min:r,max:r+"ÿ"}:e},i=(n.prefix=function(e,t,r){e=n.range(e);var i={};return r=r||"ÿ",e instanceof RegExp||"function"==typeof e?(i.min=t,i.max=t+r,i.inner=function(n){var r=n.substring(t.length);return e.test?e.test(r):e(r)}):"object"==typeof e&&(i.min=t+(e.min||e.start||""),i.max=t+(e.max||e.end||r||"~"),i.reverse=!!e.reverse),i},n.checker=function(e){return e||(e={}),"string"==typeof e?function(t){return 0==t.indexOf(e)}:e instanceof RegExp?function(t){return e.test(t)}:"object"==typeof e?function(t){var n=e.min||e.start,r=e.max||e.end;return t=String(t),(!n||t>=n)&&(!r||r>=t)&&(!e.inner||(e.inner.test?e.inner.test(t):e.inner(t)))}:"function"==typeof e?e:void 0});n.satisfies=function(e,t){return i(t)(e)}}},{}],40:[function(e,t){function n(e){return null!==e&&("object"==typeof e||"function"==typeof e)}t.exports=n},{}],41:[function(e,t){function n(){for(var e={},t=0;t<arguments.length;t++){var n=arguments[t];if(i(n))for(var o=r(n),s=0;s<o.length;s++){var a=o[s];e[a]=n[a]}}return e}var r=e("object-keys"),i=e("./has-keys");t.exports=n},{"./has-keys":40,"object-keys":42}],42:[function(e,t){t.exports=Object.keys||e("./shim")},{"./shim":45}],43:[function(e,t){var n=Object.prototype.hasOwnProperty,r=Object.prototype.toString;t.exports=function(e,t,i){if("[object Function]"!==r.call(t))throw new TypeError("iterator must be a function");var o=e.length;if(o===+o)for(var s=0;o>s;s++)t.call(i,e[s],s,e);else for(var a in e)n.call(e,a)&&t.call(i,e[a],a,e)}},{}],44:[function(e,t){var n=Object.prototype,r=n.hasOwnProperty,i=n.toString,o=function(e){return e!==e},s={"boolean":1,number:1,string:1,undefined:1},a=t.exports={};a.a=a.type=function(e,t){return typeof e===t},a.defined=function(e){return void 0!==e},a.empty=function(e){var t,n=i.call(e);if("[object Array]"===n||"[object Arguments]"===n)return 0===e.length;if("[object Object]"===n){for(t in e)if(r.call(e,t))return!1;return!0}return"[object String]"===n?""===e:!1},a.equal=function(e,t){var n,r=i.call(e);if(r!==i.call(t))return!1;if("[object Object]"===r){for(n in e)if(!a.equal(e[n],t[n]))return!1;return!0}if("[object Array]"===r){if(n=e.length,n!==t.length)return!1;for(;--n;)if(!a.equal(e[n],t[n]))return!1;return!0}return"[object Function]"===r?e.prototype===t.prototype:"[object Date]"===r?e.getTime()===t.getTime():e===t},a.hosted=function(e,t){var n=typeof t[e];return"object"===n?!!t[e]:!s[n]},a.instance=a["instanceof"]=function(e,t){return e instanceof t},a["null"]=function(e){return null===e},a.undefined=function(e){return void 0===e},a.arguments=function(e){var t="[object Arguments]"===i.call(e),n=!a.array(e)&&a.arraylike(e)&&a.object(e)&&a.fn(e.callee);return t||n},a.array=function(e){return"[object Array]"===i.call(e)},a.arguments.empty=function(e){return a.arguments(e)&&0===e.length},a.array.empty=function(e){return a.array(e)&&0===e.length},a.arraylike=function(e){return!!e&&!a.boolean(e)&&r.call(e,"length")&&isFinite(e.length)&&a.number(e.length)&&e.length>=0},a.boolean=function(e){return"[object Boolean]"===i.call(e)},a["false"]=function(e){return a.boolean(e)&&(e===!1||e.valueOf()===!1)},a["true"]=function(e){return a.boolean(e)&&(e===!0||e.valueOf()===!0)},a.date=function(e){return"[object Date]"===i.call(e)},a.element=function(e){return void 0!==e&&"undefined"!=typeof HTMLElement&&e instanceof HTMLElement&&1===e.nodeType},a.error=function(e){return"[object Error]"===i.call(e)},a.fn=a["function"]=function(e){var t="undefined"!=typeof window&&e===window.alert;return t||"[object Function]"===i.call(e)},a.number=function(e){return"[object Number]"===i.call(e)},a.infinite=function(e){return 1/0===e||e===-1/0},a.decimal=function(e){return a.number(e)&&!o(e)&&!a.infinite(e)&&e%1!==0},a.divisibleBy=function(e,t){var n=a.infinite(e),r=a.infinite(t),i=a.number(e)&&!o(e)&&a.number(t)&&!o(t)&&0!==t;return n||r||i&&e%t===0},a.int=function(e){return a.number(e)&&!o(e)&&e%1===0},a.maximum=function(e,t){if(o(e))throw new TypeError("NaN is not a valid value");if(!a.arraylike(t))throw new TypeError("second argument must be array-like");for(var n=t.length;--n>=0;)if(e<t[n])return!1;return!0},a.minimum=function(e,t){if(o(e))throw new TypeError("NaN is not a valid value");if(!a.arraylike(t))throw new TypeError("second argument must be array-like");for(var n=t.length;--n>=0;)if(e>t[n])return!1;return!0},a.nan=function(e){return!a.number(e)||e!==e},a.even=function(e){return a.infinite(e)||a.number(e)&&e===e&&e%2===0},a.odd=function(e){return a.infinite(e)||a.number(e)&&e===e&&e%2!==0},a.ge=function(e,t){if(o(e)||o(t))throw new TypeError("NaN is not a valid value");return!a.infinite(e)&&!a.infinite(t)&&e>=t},a.gt=function(e,t){if(o(e)||o(t))throw new TypeError("NaN is not a valid value");return!a.infinite(e)&&!a.infinite(t)&&e>t},a.le=function(e,t){if(o(e)||o(t))throw new TypeError("NaN is not a valid value");return!a.infinite(e)&&!a.infinite(t)&&t>=e},a.lt=function(e,t){if(o(e)||o(t))throw new TypeError("NaN is not a valid value");return!a.infinite(e)&&!a.infinite(t)&&t>e},a.within=function(e,t,n){if(o(e)||o(t)||o(n))throw new TypeError("NaN is not a valid value");if(!a.number(e)||!a.number(t)||!a.number(n))throw new TypeError("all arguments must be numbers");var r=a.infinite(e)||a.infinite(t)||a.infinite(n);return r||e>=t&&n>=e},a.object=function(e){return e&&"[object Object]"===i.call(e)},a.hash=function(e){return a.object(e)&&e.constructor===Object&&!e.nodeType&&!e.setInterval},a.regexp=function(e){return"[object RegExp]"===i.call(e)},a.string=function(e){return"[object String]"===i.call(e)}},{}],45:[function(e,t){!function(){"use strict";var n,r=Object.prototype.hasOwnProperty,i=e("is"),o=e("foreach"),s=!{toString:null}.propertyIsEnumerable("toString"),a=["toString","toLocaleString","valueOf","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","constructor"];n=function(e){if(!i.object(e)&&!i.array(e))throw new TypeError("Object.keys called on a non-object");var t,n=[];for(t in e)r.call(e,t)&&n.push(t);return s&&o(a,function(t){r.call(e,t)&&n.push(t)}),n},t.exports=n}()},{foreach:43,is:44}],46:[function(e,t){function n(e,t,r){if("string"==typeof r&&(console.error("db.sublevel(name, seperator<string>) is depreciated"),console.error("use db.sublevel(name, {sep: separator})) if you must"),r={sep:r}),!(this instanceof n))return new n(e,t,r);if(!e)throw new Error("must provide db");if(!t)throw new Error("must provide prefix");r=r||{},r.sep=r.sep||"ÿ",this._parent=e,this._options=r,this.options=r,this._prefix=t,this._root=i(this),e.sublevels[t]=this,this.sublevels={},this.methods={};var o=this;this.hooks={pre:function(){return o.pre.apply(o,arguments)},post:function(){return o.post.apply(o,arguments)}}}function r(e,t){["valueEncoding","encoding","keyEncoding","reverse","values","keys","limit","fillCache"].forEach(function(n){t.hasOwnProperty(n)&&(e[n]=t[n])})}function i(e){return e._parent?i(e._parent):e}var o=e("events").EventEmitter,s=e("util").inherits,a=e("string-range"),u=e("level-fix-range"),c=e("xtend"),l=e("./batch");s(n,o);var f=n.prototype;f._key=function(e){var t=this._options.sep;return t+this._prefix+t+e},f._getOptsAndCb=function(e,t){return"function"==typeof e&&(t=e,e={}),{opts:c(e,this._options),cb:t}},f.sublevel=function(e,t){return this.sublevels[e]?this.sublevels[e]:new n(this,e,t||this._options)},f.put=function(e,t,n,r){var i=this._getOptsAndCb(n,r);this._root.put(this.prefix(e),t,i.opts,i.cb)},f.get=function(e,t,n){var r=this._getOptsAndCb(t,n);this._root.get(this.prefix(e),r.opts,r.cb)},f.del=function(e,t,n){var r=this._getOptsAndCb(t,n);this._root.del(this.prefix(e),r.opts,r.cb)},f.batch=function(e,t,n){if(!Array.isArray(e))return new l(this);var r=this,i=this._getOptsAndCb(t,n);e.forEach(function(e){e.key="string"==typeof e.prefix?e.prefix+e.key:(e.prefix||r).prefix(e.key),e.prefix&&(e.prefix=null)}),this._root.batch(e,i.opts,i.cb)},f._getKeyEncoding=function(){return this.options.keyEncoding?this.options.keyEncoding:this._parent&&this._parent._getKeyEncoding?this._parent._getKeyEncoding():void 0},f._getValueEncoding=function(){return this.options.valueEncoding?this.options.valueEncoding:this._parent&&this._parent._getValueEncoding?this._parent._getValueEncoding():void 0},f.prefix=function(e){var t=this._options.sep;return this._parent.prefix()+t+this._prefix+t+(e||"")},f.keyStream=f.createKeyStream=function(e){return e=e||{},e.keys=!0,e.values=!1,this.createReadStream(e)},f.valueStream=f.createValueStream=function(e){return e=e||{},e.keys=!1,e.values=!0,e.keys=!1,this.createReadStream(e)},f.readStream=f.createReadStream=function(e){e=e||{};var t=i(this),n=this.prefix(),o=a.prefix(e,n);r(o,c(e,this._options));var s=t.createReadStream(o);if(o.values===!1){var u=s.read;if(u)s.read=function(e){var t=u.call(this,e);return t&&(t=t.substring(n.length)),t};else{var l=s.emit;s.emit=function(e,t){"data"===e?l.call(this,"data",t.substring(n.length)):l.call(this,e,t)}}return s}if(o.keys===!1)return s;var u=s.read;return u?s.read=function(e){var t=u.call(this,e);return t&&(t.key=t.key.substring(n.length)),t}:s.on("data",function(e){e.key=e.key.substring(n.length)}),s},f.writeStream=f.createWriteStream=function(){var e=i(this),t=this.prefix(),n=e.createWriteStream.apply(e,arguments),r=n.write,o=this._options.encoding,s=this._options.valueEncoding,a=this._options.keyEncoding,u=!o&&!s&&!a;return n.write=u?function(e){return e.key=t+e.key,r.call(n,e)}:function(e){return e.key=t+e.key,o&&"undefined"==typeof e.encoding&&(e.encoding=o),s&&"undefined"==typeof e.valueEncoding&&(e.valueEncoding=s),a&&"undefined"==typeof e.keyEncoding&&(e.keyEncoding=a),r.call(n,e)},n},f.approximateSize=function(){var e=i(db);return e.approximateSize.apply(e,arguments)},f.pre=function(e,t){t||(t=e,e=null),e=a.prefix(e,this.prefix(),this._options.sep);var n=i(this._parent),r=this.prefix();return n.hooks.pre(u(e),function(e,n,i){t({key:e.key.substring(r.length),value:e.value,type:e.type},function(e,t){n(e,e.prefix?t:t||r)},i)})},f.post=function(e,t){t||(t=e,e=null);var n=i(this._parent),r=this.prefix();return e=a.prefix(e,r,this._options.sep),n.hooks.post(u(e),function(e){t({key:e.key.substring(r.length),value:e.value,type:e.type})})};t.exports=n},{"./batch":34,events:18,"level-fix-range":36,"string-range":39,util:32,xtend:41}],47:[function(e,t){function n(e){this._levelup=e,this.batch=e.db.batch(),this.ops=[]}var r=e("./util"),i=e("./errors").WriteError,o=r.getOptions,s=r.dispatchError;n.prototype.put=function(e,t,n){n=o(this._levelup,n);var s=r.encodeKey(e,n),a=r.encodeValue(t,n);try{this.batch.put(s,a)}catch(u){throw new i(u)}return this.ops.push({type:"put",key:s,value:a}),this},n.prototype.del=function(e,t){t=o(this._levelup,t);var n=r.encodeKey(e,t);try{this.batch.del(n)}catch(s){throw new i(s)}return this.ops.push({type:"del",key:n}),this},n.prototype.clear=function(){try{this.batch.clear()}catch(e){throw new i(e)}return this.ops=[],this},n.prototype.write=function(e){var t=this._levelup,n=this.ops;try{this.batch.write(function(r){return r?s(t,new i(r),e):(t.emit("batch",n),void(e&&e()))})}catch(r){throw new i(r)}},t.exports=n},{"./errors":48,"./util":51}],48:[function(e,t){var n=e("errno").create,r=n("LevelUPError"),i=n("NotFoundError",r);i.prototype.notFound=!0,i.prototype.status=404,t.exports={LevelUPError:r,InitializationError:n("InitializationError",r),OpenError:n("OpenError",r),ReadError:n("ReadError",r),WriteError:n("WriteError",r),NotFoundError:i,EncodingError:n("EncodingError",r)}},{errno:59}],49:[function(e,t){(function(n){function r(e,t){return"function"==typeof e?e:t}function i(e,t,r){if(!(this instanceof i))return new i(e,t,r);var o;if(s.call(this),this.setMaxListeners(1/0),"function"==typeof e?(t="object"==typeof t?t:{},t.db=e,e=null):"object"==typeof e&&"function"==typeof e.db&&(t=e,e=null),"function"==typeof t&&(r=t,t={}),(!t||"function"!=typeof t.db)&&"string"!=typeof e){if(o=new y("Must provide a location for the database"),r)return n.nextTick(function(){r(o)});throw o}t=w(this,t),this.options=u(E,t),this._status="new",c(this,"location",e,"e"),this.open(r)}function o(e){return function(t,n){k()[e](t,n||function(){})}}var s=e("events").EventEmitter,a=e("util").inherits,u=e("xtend"),c=e("prr"),l=e("deferred-leveldown"),f=e("./errors").WriteError,d=e("./errors").ReadError,h=e("./errors").NotFoundError,p=e("./errors").OpenError,g=e("./errors").EncodingError,y=e("./errors").InitializationError,v=e("./read-stream"),b=e("./write-stream"),m=e("./util"),_=e("./batch"),w=m.getOptions,E=m.defaultOptions,k=m.getLevelDOWN,S=m.dispatchError;
+a(i,s),i.prototype.open=function(e){var t,r,i=this;return this.isOpen()?(e&&n.nextTick(function(){e(null,i)}),this):this._isOpening()?e&&this.once("open",function(){e(null,i)}):(this.emit("opening"),this._status="opening",this.db=new l(this.location),t=this.options.db||k(),r=t(this.location),void r.open(this.options,function(t){return t?S(i,new p(t),e):(i.db.setDb(r),i.db=r,i._status="open",e&&e(null,i),i.emit("open"),i.emit("ready"),void 0)}))},i.prototype.close=function(e){var t=this;if(this.isOpen())this._status="closing",this.db.close(function(){t._status="closed",t.emit("closed"),e&&e.apply(null,arguments)}),this.emit("closing"),this.db=null;else{if("closed"==this._status&&e)return n.nextTick(e);"closing"==this._status&&e?this.once("closed",e):this._isOpening()&&this.once("open",function(){t.close(e)})}},i.prototype.isOpen=function(){return"open"==this._status},i.prototype._isOpening=function(){return"opening"==this._status},i.prototype.isClosed=function(){return/^clos/.test(this._status)},i.prototype.get=function(e,t,n){var i,o=this;return n=r(t,n),"function"!=typeof n?S(this,new d("get() requires key and callback arguments")):this._isOpening()||this.isOpen()?(t=m.getOptions(this,t),i=m.encodeKey(e,t),t.asBuffer=m.isValueAsBuffer(t),void this.db.get(i,t,function(r,i){if(r)return r=/notfound/i.test(r)?new h("Key not found in database ["+e+"]",r):new d(r),S(o,r,n);if(n){try{i=m.decodeValue(i,t)}catch(s){return n(new g(s))}n(null,i)}})):S(this,new d("Database is not open"),n)},i.prototype.put=function(e,t,n,i){var o,s,a=this;return i=r(n,i),null===e||void 0===e||null===t||void 0===t?S(this,new f("put() requires key and value arguments"),i):this._isOpening()||this.isOpen()?(n=w(this,n),o=m.encodeKey(e,n),s=m.encodeValue(t,n),void this.db.put(o,s,n,function(n){return n?S(a,new f(n),i):(a.emit("put",e,t),void(i&&i()))})):S(this,new f("Database is not open"),i)},i.prototype.del=function(e,t,n){var i,o=this;return n=r(t,n),null===e||void 0===e?S(this,new f("del() requires a key argument"),n):this._isOpening()||this.isOpen()?(t=w(this,t),i=m.encodeKey(e,t),void this.db.del(i,t,function(t){return t?S(o,new f(t),n):(o.emit("del",e),void(n&&n()))})):S(this,new f("Database is not open"),n)},i.prototype.batch=function(e,t,n){var i,o,s,a=this;return arguments.length?(n=r(t,n),Array.isArray(e)?this._isOpening()||this.isOpen()?(t=w(this,t),i=t.keyEncoding,o=t.valueEncoding,s=e.map(function(e){if(void 0===e.type||void 0===e.key)return{};var n,r=e.keyEncoding||i,s=e.valueEncoding||e.encoding||o;return"utf8"!=r&&"binary"!=r||"utf8"!=s&&"binary"!=s?(n={type:e.type,key:m.encodeKey(e.key,t,e)},void 0!==e.value&&(n.value=m.encodeValue(e.value,t,e)),n):e}),void this.db.batch(s,t,function(t){return t?S(a,new f(t),n):(a.emit("batch",e),void(n&&n()))})):S(this,new f("Database is not open"),n):S(this,new f("batch() requires an array argument"),n)):new _(this)},i.prototype.approximateSize=function(e,t,n){var r,i,o=this;return null===e||void 0===e||null===t||void 0===t||"function"!=typeof n?S(this,new d("approximateSize() requires start, end and callback arguments"),n):(r=m.encodeKey(e,this.options),i=m.encodeKey(t,this.options),this._isOpening()||this.isOpen()?void this.db.approximateSize(r,i,function(e,t){return e?S(o,new p(e),n):void(n&&n(null,t))}):S(this,new f("Database is not open"),n))},i.prototype.readStream=i.prototype.createReadStream=function(e){var t=this;return e=u(this.options,e),new v(e,this,function(e){return t.db.iterator(e)})},i.prototype.keyStream=i.prototype.createKeyStream=function(e){return this.createReadStream(u(e,{keys:!0,values:!1}))},i.prototype.valueStream=i.prototype.createValueStream=function(e){return this.createReadStream(u(e,{keys:!1,values:!0}))},i.prototype.writeStream=i.prototype.createWriteStream=function(e){return new b(u(e),this)},i.prototype.toString=function(){return"LevelUP"},t.exports=i,t.exports.copy=m.copy,t.exports.destroy=o("destroy"),t.exports.repair=o("repair")}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"./batch":47,"./errors":48,"./read-stream":50,"./util":51,"./write-stream":52,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"deferred-leveldown":54,events:18,prr:60,util:32,xtend:70}],50:[function(e,t){function n(e,t,i){if(!(this instanceof n))return new n(e,t,i);r.call(this,{objectMode:!0,highWaterMark:e.highWaterMark}),this._db=t,e=this._options=o(u,e),this._keyEncoding=e.keyEncoding||e.encoding,this._valueEncoding=e.valueEncoding||e.encoding,"undefined"!=typeof this._options.start&&(this._options.start=a.encodeKey(this._options.start,this._options)),"undefined"!=typeof this._options.end&&(this._options.end=a.encodeKey(this._options.end,this._options)),"number"!=typeof this._options.limit&&(this._options.limit=-1),this._options.keyAsBuffer=a.isKeyAsBuffer(this._options),this._options.valueAsBuffer=a.isValueAsBuffer(this._options),this._makeData=this._options.keys&&this._options.values?c:this._options.keys?l:this._options.values?f:d;var s=this;this._db.isOpen()?this._iterator=i(this._options):this._db.once("ready",function(){s._destroyed||(s._iterator=i(s._options))})}var r=e("readable-stream").Readable,i=e("util").inherits,o=e("xtend"),s=e("./errors").EncodingError,a=e("./util"),u={keys:!0,values:!0},c=function(e,t){return{key:a.decodeKey(e,this._options),value:a.decodeValue(t,this._options)}},l=function(e){return a.decodeKey(e,this._options)},f=function(e,t){return a.decodeValue(t,this._options)},d=function(){return null};i(n,r),n.prototype._read=function h(){var e=this;return e._db.isOpen()?void(e._destroyed||e._iterator.next(function(t,n,r){if(t||void 0===n&&void 0===r)return t||e._destroyed||e.push(null),e._cleanup(t);try{r=e._makeData(n,r)}catch(i){return e._cleanup(new s(i))}e._destroyed||e.push(r)})):e._db.once("ready",function(){h.call(e)})},n.prototype._cleanup=function(e){if(!this._destroyed){this._destroyed=!0;var t=this;e&&t.emit("error",e),t._iterator?t._iterator.end(function(){t._iterator=null,t.emit("close")}):t.emit("close")}},n.prototype.destroy=function(){this._cleanup()},n.prototype.toString=function(){return"LevelUP.ReadStream"},t.exports=n},{"./errors":48,"./util":51,"readable-stream":69,util:32,xtend:70}],51:[function(e,t){(function(n,r){function i(e,t,n){e.readStream().pipe(t.writeStream()).on("close",n?n:function(){}).on("error",n?n:function(e){throw e})}function o(e,t){var n="string"==typeof t;return!n&&t&&t.encoding&&!t.valueEncoding&&(t.valueEncoding=t.encoding),v(e&&e.options||{},n?E[t]||E[_.valueEncoding]:t)}function s(){if(y)return y;var t,n=e("../package.json").devDependencies.leveldown,r="Could not locate LevelDOWN, try `npm install leveldown`";try{t=e("leveldown/package").version}catch(i){throw new b(r)}if(!e("semver").satisfies(t,n))throw new b("Installed version of LevelDOWN ("+t+") does not match required version ("+n+")");try{return y=e("leveldown")}catch(i){throw new b(r)}}function a(e,t,n){return"function"==typeof n?n(t):e.emit("error",t)}function u(e,t){var n=t&&t.keyEncoding||e.keyEncoding||"utf8";return w[n]||n}function c(e,t){var n=t&&(t.valueEncoding||t.encoding)||e.valueEncoding||e.encoding||"utf8";return w[n]||n}function l(e,t,n){return u(t,n).encode(e)}function f(e,t,n){return c(t,n).encode(e)}function d(e,t){return u(t).decode(e)}function h(e,t){return c(t).decode(e)}function p(e,t){return c(e,t).buffer}function g(e,t){return u(e,t).buffer}var y,v=e("xtend"),b=e("./errors").LevelUPError,m=["hex","utf8","utf-8","ascii","binary","base64","ucs2","ucs-2","utf16le","utf-16le"],_={createIfMissing:!0,errorIfExists:!1,keyEncoding:"utf8",valueEncoding:"utf8",compression:!0},w=function(){function e(e){return void 0===e||null===e||r.isBuffer(e)}var t={};return t.utf8=t["utf-8"]={encode:function(t){return e(t)?t:String(t)},decode:function(e){return e},buffer:!1,type:"utf8"},t.json={encode:JSON.stringify,decode:JSON.parse,buffer:!1,type:"json"},m.forEach(function(i){t[i]||(t[i]={encode:function(t){return e(t)?t:new r(t,i)},decode:function(e){return n.browser?e.toString(i):e},buffer:!0,type:i})}),t}(),E=function(){var e={};return m.forEach(function(t){e[t]={valueEncoding:t}}),e}();t.exports={defaultOptions:_,copy:i,getOptions:o,getLevelDOWN:s,dispatchError:a,encodeKey:l,encodeValue:f,isValueAsBuffer:p,isKeyAsBuffer:g,decodeValue:h,decodeKey:d}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),e("buffer").Buffer)},{"../package.json":71,"./errors":48,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,leveldown:"3WVjcl","leveldown/package":17,semver:17,xtend:70}],52:[function(e,t){(function(n,r){function i(e,t){if(!(this instanceof i))return new i(e,t);o.call(this),this._options=a(f,l(t,e)),this._db=t,this._buffer=[],this._status="init",this._end=!1,this.writable=!0,this.readable=!1;var n=this,r=function(){n.writable&&(n._status="ready",n.emit("ready"),n._process())};t.isOpen()?c(r):t.once("ready",r)}var o=e("stream").Stream,s=e("util").inherits,a=e("xtend"),u=e("bl"),c=r.setImmediate||n.nextTick,l=e("./util").getOptions,f={type:"put"};s(i,o),i.prototype.write=function(e){return this.writable?(this._buffer.push(e),"init"!=this._status&&this._processDelayed(),this._options.maxBufferLength&&this._buffer.length>this._options.maxBufferLength?(this._writeBlock=!0,!1):!0):!1},i.prototype.end=function(e){var t=this;e&&this.write(e),c(function(){t._end=!0,t._process()})},i.prototype.destroy=function(){this.writable=!1,this.end()},i.prototype.destroySoon=function(){this.end()},i.prototype.add=function(e){return e.props?(e.props.Directory?e.pipe(this._db.writeStream(this._options)):(e.props.File||e.File||"File"==e.type)&&this._write(e),!0):void 0},i.prototype._processDelayed=function(){var e=this;c(function(){e._process()})},i.prototype._process=function(){var e,t=this,n=function(e){return t.writable?("closed"!=t._status&&(t._status="ready"),e?(t.writable=!1,t.emit("error",e)):void t._process()):void 0};return"ready"!=t._status&&t.writable?void(t._buffer.length&&"closed"!=t._status&&t._processDelayed()):t._buffer.length&&t.writable?(t._status="writing",e=t._buffer,t._buffer=[],t._db.batch(e.map(function(e){return{type:e.type||t._options.type,key:e.key,value:e.value,keyEncoding:e.keyEncoding||t._options.keyEncoding,valueEncoding:e.valueEncoding||e.encoding||t._options.valueEncoding}}),n),void(t._writeBlock&&(t._writeBlock=!1,t.emit("drain")))):void(t._end&&"closed"!=t._status&&(t._status="closed",t.writable=!1,t.emit("close")))},i.prototype._write=function(e){var t=e.path||e.props.path,n=this;t&&e.pipe(u(function(e,r){return e?(n.writable=!1,n.emit("error",e)):(n._options.fstreamRoot&&t.indexOf(n._options.fstreamRoot)>-1&&(t=t.substr(n._options.fstreamRoot.length+1)),void n.write({key:t,value:r.slice(0)}))}))},i.prototype.toString=function(){return"LevelUP.WriteStream"},t.exports=i}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./util":51,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,bl:53,stream:24,util:32,xtend:70}],53:[function(e,t){(function(n){function r(e){if(!(this instanceof r))return new r(e);if(this._bufs=[],this.length=0,"function"==typeof e){this._callback=e;var t=function(e){this._callback&&(this._callback(e),this._callback=null)}.bind(this);this.on("pipe",function(e){e.on("error",t)}),this.on("unpipe",function(e){e.removeListener("error",t)})}else n.isBuffer(e)?this.append(e):Array.isArray(e)&&e.forEach(function(e){n.isBuffer(e)&&this.append(e)}.bind(this));i.call(this)}var i=e("readable-stream").Duplex,o=e("util");o.inherits(r,i),r.prototype._offset=function(e){for(var t,n=0,r=0;r<this._bufs.length;r++){if(t=n+this._bufs[r].length,t>e)return[r,e-n];n=t}},r.prototype.append=function(e){return this._bufs.push(n.isBuffer(e)?e:new n(e)),this.length+=e.length,this},r.prototype._write=function(e,t,n){this.append(e),n&&n()},r.prototype._read=function(e){return this.length?(e=Math.min(e,this.length),this.push(this.slice(0,e)),void this.consume(e)):this.push(null)},r.prototype.end=function(e){i.prototype.end.call(this,e),this._callback&&(this._callback(null,this.slice()),this._callback=null)},r.prototype.get=function(e){return this.slice(e,e+1)[0]},r.prototype.slice=function(e,t){return this.copy(null,0,e,t)},r.prototype.copy=function(e,t,r,i){if(("number"!=typeof r||0>r)&&(r=0),("number"!=typeof i||i>this.length)&&(i=this.length),r>=this.length)return e||new n(0);if(0>=i)return e||new n(0);var o,s,a=!!e,u=this._offset(r),c=i-r,l=c,f=a&&t||0,d=u[1];if(0===r&&i==this.length){if(!a)return n.concat(this._bufs);for(s=0;s<this._bufs.length;s++)this._bufs[s].copy(e,f),f+=this._bufs[s].length;return e}if(l<=this._bufs[u[0]].length-d)return a?this._bufs[u[0]].copy(e,t,d,d+l):this._bufs[u[0]].slice(d,d+l);for(a||(e=new n(c)),s=u[0];s<this._bufs.length;s++){if(o=this._bufs[s].length-d,!(l>o)){this._bufs[s].copy(e,f,d,d+l);break}this._bufs[s].copy(e,f,d),f+=o,l-=o,d&&(d=0)}return e},r.prototype.toString=function(e,t,n){return this.slice(t,n).toString(e)},r.prototype.consume=function(e){for(;this._bufs.length;){if(!(e>this._bufs[0].length)){this._bufs[0]=this._bufs[0].slice(e),this.length-=e;break}e-=this._bufs[0].length,this.length-=this._bufs[0].length,this._bufs.shift()}return this},r.prototype.duplicate=function(){for(var e=0,t=new r;e<this._bufs.length;e++)t.append(this._bufs[e]);return t},r.prototype.destroy=function(){this._bufs.length=0,this.length=0,this.push(null)},function(){var e={readDoubleBE:8,readDoubleLE:8,readFloatBE:4,readFloatLE:4,readInt32BE:4,readInt32LE:4,readUInt32BE:4,readUInt32LE:4,readInt16BE:2,readInt16LE:2,readUInt16BE:2,readUInt16LE:2,readInt8:1,readUInt8:1};for(var t in e)!function(t){r.prototype[t]=function(n){return this.slice(n,n+e[t])[t](0)}}(t)}(),t.exports=r}).call(this,e("buffer").Buffer)},{buffer:20,"readable-stream":69,util:32}],54:[function(e,t){(function(n,r){function i(e){s.call(this,"string"==typeof e?e:""),this._db=void 0,this._operations=[]}var o=e("util"),s=e("abstract-leveldown").AbstractLevelDOWN;o.inherits(i,s),i.prototype.setDb=function(e){this._db=e,this._operations.forEach(function(t){e[t.method].apply(e,t.args)})},i.prototype._open=function(e,t){return n.nextTick(t)},i.prototype._operation=function(e,t){return this._db?this._db[e].apply(this._db,t):void this._operations.push({method:e,args:t})},"put get del batch approximateSize".split(" ").forEach(function(e){i.prototype["_"+e]=function(){this._operation(e,arguments)}}),i.prototype._isBuffer=function(e){return r.isBuffer(e)},i.prototype._iterator=function(){throw new TypeError("not implemented")},t.exports=i}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),e("buffer").Buffer)},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"abstract-leveldown":57,buffer:20,util:32}],55:[function(e,t){(function(e){function n(e){this._db=e,this._operations=[],this._written=!1}n.prototype._checkWritten=function(){if(this._written)throw new Error("write() already called on this batch")},n.prototype.put=function(e,t){this._checkWritten();var n=this._db._checkKeyValue(e,"key",this._db._isBuffer);if(n)throw n;if(n=this._db._checkKeyValue(t,"value",this._db._isBuffer))throw n;return this._db._isBuffer(e)||(e=String(e)),this._db._isBuffer(t)||(t=String(t)),"function"==typeof this._put?this._put(e,t):this._operations.push({type:"put",key:e,value:t}),this},n.prototype.del=function(e){this._checkWritten();var t=this._db._checkKeyValue(e,"key",this._db._isBuffer);if(t)throw t;return this._db._isBuffer(e)||(e=String(e)),"function"==typeof this._del?this._del(e):this._operations.push({type:"del",key:e}),this},n.prototype.clear=function(){return this._checkWritten(),this._operations=[],"function"==typeof this._clear&&this._clear(),this},n.prototype.write=function(t,n){if(this._checkWritten(),"function"==typeof t&&(n=t),"function"!=typeof n)throw new Error("write() requires a callback argument");return"object"!=typeof t&&(t={}),this._written=!0,"function"==typeof this._write?this._write(n):"function"==typeof this._db._batch?this._db._batch(this._operations,t,n):void e.nextTick(n)},t.exports=n}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],56:[function(e,t){(function(e){function n(e){this.db=e,this._ended=!1,this._nexting=!1}n.prototype.next=function(t){var n=this;if("function"!=typeof t)throw new Error("next() requires a callback argument");return n._ended?t(new Error("cannot call next() after end()")):n._nexting?t(new Error("cannot call next() before previous next() has completed")):(n._nexting=!0,"function"==typeof n._next?n._next(function(){n._nexting=!1,t.apply(null,arguments)}):void e.nextTick(function(){n._nexting=!1,t()}))},n.prototype.end=function(t){if("function"!=typeof t)throw new Error("end() requires a callback argument");return this._ended?t(new Error("end() already called on iterator")):(this._ended=!0,"function"==typeof this._end?this._end(t):void e.nextTick(t))},t.exports=n}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],57:[function(e,t){(function(n,r){function i(e){if(!arguments.length||void 0===e)throw new Error("constructor requires at least a location argument");if("string"!=typeof e)throw new Error("constructor requires a location string argument");this.location=e}var o=e("xtend"),s=e("./abstract-iterator"),a=e("./abstract-chained-batch");i.prototype.open=function(e,t){if("function"==typeof e&&(t=e),"function"!=typeof t)throw new Error("open() requires a callback argument");return"object"!=typeof e&&(e={}),"function"==typeof this._open?this._open(e,t):void n.nextTick(t)},i.prototype.close=function(e){if("function"!=typeof e)throw new Error("close() requires a callback argument");return"function"==typeof this._close?this._close(e):void n.nextTick(e)},i.prototype.get=function(e,t,r){var i;if("function"==typeof t&&(r=t),"function"!=typeof r)throw new Error("get() requires a callback argument");return(i=this._checkKeyValue(e,"key",this._isBuffer))?r(i):(this._isBuffer(e)||(e=String(e)),"object"!=typeof t&&(t={}),"function"==typeof this._get?this._get(e,t,r):void n.nextTick(function(){r(new Error("NotFound"))}))},i.prototype.put=function(e,t,r,i){var o;if("function"==typeof r&&(i=r),"function"!=typeof i)throw new Error("put() requires a callback argument");return(o=this._checkKeyValue(e,"key",this._isBuffer))?i(o):(o=this._checkKeyValue(t,"value",this._isBuffer))?i(o):(this._isBuffer(e)||(e=String(e)),this._isBuffer(t)||n.browser||(t=String(t)),"object"!=typeof r&&(r={}),"function"==typeof this._put?this._put(e,t,r,i):void n.nextTick(i))},i.prototype.del=function(e,t,r){var i;if("function"==typeof t&&(r=t),"function"!=typeof r)throw new Error("del() requires a callback argument");return(i=this._checkKeyValue(e,"key",this._isBuffer))?r(i):(this._isBuffer(e)||(e=String(e)),"object"!=typeof t&&(t={}),"function"==typeof this._del?this._del(e,t,r):void n.nextTick(r))},i.prototype.batch=function(e,t,r){if(!arguments.length)return this._chainedBatch();if("function"==typeof t&&(r=t),"function"!=typeof r)throw new Error("batch(array) requires a callback argument");if(!Array.isArray(e))return r(new Error("batch(array) requires an array argument"));"object"!=typeof t&&(t={});for(var i,o,s=0,a=e.length;a>s;s++)if(i=e[s],"object"==typeof i){if(o=this._checkKeyValue(i.type,"type",this._isBuffer))return r(o);if(o=this._checkKeyValue(i.key,"key",this._isBuffer))return r(o);if("put"==i.type&&(o=this._checkKeyValue(i.value,"value",this._isBuffer)))return r(o)}return"function"==typeof this._batch?this._batch(e,t,r):void n.nextTick(r)},i.prototype.approximateSize=function(e,t,r){if(null==e||null==t||"function"==typeof e||"function"==typeof t)throw new Error("approximateSize() requires valid `start`, `end` and `callback` arguments");if("function"!=typeof r)throw new Error("approximateSize() requires a callback argument");return this._isBuffer(e)||(e=String(e)),this._isBuffer(t)||(t=String(t)),"function"==typeof this._approximateSize?this._approximateSize(e,t,r):void n.nextTick(function(){r(null,0)})},i.prototype._setupIteratorOptions=function(e){var t=this;return e=o(e),["start","end","gt","gte","lt","lte"].forEach(function(n){e[n]&&t._isBuffer(e[n])&&0===e[n].length&&delete e[n]}),e.reverse=!!e.reverse,e.reverse&&e.lt&&(e.start=e.lt),e.reverse&&e.lte&&(e.start=e.lte),!e.reverse&&e.gt&&(e.start=e.gt),!e.reverse&&e.gte&&(e.start=e.gte),(e.reverse&&e.lt&&!e.lte||!e.reverse&&e.gt&&!e.gte)&&(e.exclusiveStart=!0),e},i.prototype.iterator=function(e){return"object"!=typeof e&&(e={}),e=this._setupIteratorOptions(e),"function"==typeof this._iterator?this._iterator(e):new s(this)},i.prototype._chainedBatch=function(){return new a(this)},i.prototype._isBuffer=function(e){return r.isBuffer(e)},i.prototype._checkKeyValue=function(e,t){if(null===e||void 0===e)return new Error(t+" cannot be `null` or `undefined`");if(null===e||void 0===e)return new Error(t+" cannot be `null` or `undefined`");if(this._isBuffer(e)){if(0===e.length)return new Error(t+" cannot be an empty Buffer")}else if(""===String(e))return new Error(t+" cannot be an empty String")},t.exports.AbstractLevelDOWN=i,t.exports.AbstractIterator=s,t.exports.AbstractChainedBatch=a}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),e("buffer").Buffer)},{"./abstract-chained-batch":55,"./abstract-iterator":56,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,xtend:70}],58:[function(e,t){function n(e,t,n){o(this,{type:e,name:e,cause:"string"!=typeof t?t:n,message:t&&"string"!=typeof t?t.message:t},"ewr")}function r(e,t){Error.call(this),Error.captureStackTrace&&Error.captureStackTrace(this,arguments.callee),n.call(this,"CustomError",e,t)}function i(e,t,i){var o=function(r,i){n.call(this,t,r,i),"FilesystemError"==t&&(this.code=this.cause.code,this.path=this.cause.path,this.errno=this.cause.errno,this.message=(e.errno[this.cause.errno]?e.errno[this.cause.errno].description:this.cause.message)+(this.cause.path?" ["+this.cause.path+"]":"")),Error.call(this),Error.captureStackTrace&&Error.captureStackTrace(this,arguments.callee)};return o.prototype=i?new i:new r,o}var o=e("prr");r.prototype=new Error,t.exports=function(e){var t=function(t,n){return i(e,t,n)};return{CustomError:r,FilesystemError:t("FilesystemError"),createError:t}}},{prr:60}],59:[function(e,t){var n=t.exports.all=[{errno:-1,code:"UNKNOWN",description:"unknown error"},{errno:0,code:"OK",description:"success"},{errno:1,code:"EOF",description:"end of file"},{errno:2,code:"EADDRINFO",description:"getaddrinfo error"},{errno:3,code:"EACCES",description:"permission denied"},{errno:4,code:"EAGAIN",description:"resource temporarily unavailable"},{errno:5,code:"EADDRINUSE",description:"address already in use"},{errno:6,code:"EADDRNOTAVAIL",description:"address not available"},{errno:7,code:"EAFNOSUPPORT",description:"address family not supported"},{errno:8,code:"EALREADY",description:"connection already in progress"},{errno:9,code:"EBADF",description:"bad file descriptor"},{errno:10,code:"EBUSY",description:"resource busy or locked"},{errno:11,code:"ECONNABORTED",description:"software caused connection abort"},{errno:12,code:"ECONNREFUSED",description:"connection refused"},{errno:13,code:"ECONNRESET",description:"connection reset by peer"},{errno:14,code:"EDESTADDRREQ",description:"destination address required"},{errno:15,code:"EFAULT",description:"bad address in system call argument"},{errno:16,code:"EHOSTUNREACH",description:"host is unreachable"},{errno:17,code:"EINTR",description:"interrupted system call"},{errno:18,code:"EINVAL",description:"invalid argument"},{errno:19,code:"EISCONN",description:"socket is already connected"},{errno:20,code:"EMFILE",description:"too many open files"},{errno:21,code:"EMSGSIZE",description:"message too long"},{errno:22,code:"ENETDOWN",description:"network is down"},{errno:23,code:"ENETUNREACH",description:"network is unreachable"},{errno:24,code:"ENFILE",description:"file table overflow"},{errno:25,code:"ENOBUFS",description:"no buffer space available"},{errno:26,code:"ENOMEM",description:"not enough memory"},{errno:27,code:"ENOTDIR",description:"not a directory"},{errno:28,code:"EISDIR",description:"illegal operation on a directory"},{errno:29,code:"ENONET",description:"machine is not on the network"},{errno:31,code:"ENOTCONN",description:"socket is not connected"},{errno:32,code:"ENOTSOCK",description:"socket operation on non-socket"},{errno:33,code:"ENOTSUP",description:"operation not supported on socket"},{errno:34,code:"ENOENT",description:"no such file or directory"},{errno:35,code:"ENOSYS",description:"function not implemented"},{errno:36,code:"EPIPE",description:"broken pipe"},{errno:37,code:"EPROTO",description:"protocol error"},{errno:38,code:"EPROTONOSUPPORT",description:"protocol not supported"},{errno:39,code:"EPROTOTYPE",description:"protocol wrong type for socket"},{errno:40,code:"ETIMEDOUT",description:"connection timed out"},{errno:41,code:"ECHARSET",description:"invalid Unicode character"},{errno:42,code:"EAIFAMNOSUPPORT",description:"address family for hostname not supported"},{errno:44,code:"EAISERVICE",description:"servname not supported for ai_socktype"},{errno:45,code:"EAISOCKTYPE",description:"ai_socktype not supported"},{errno:46,code:"ESHUTDOWN",description:"cannot send after transport endpoint shutdown"},{errno:47,code:"EEXIST",description:"file already exists"},{errno:48,code:"ESRCH",description:"no such process"},{errno:49,code:"ENAMETOOLONG",description:"name too long"},{errno:50,code:"EPERM",description:"operation not permitted"},{errno:51,code:"ELOOP",description:"too many symbolic links encountered"},{errno:52,code:"EXDEV",description:"cross-device link not permitted"},{errno:53,code:"ENOTEMPTY",description:"directory not empty"},{errno:54,code:"ENOSPC",description:"no space left on device"},{errno:55,code:"EIO",description:"i/o error"},{errno:56,code:"EROFS",description:"read-only file system"},{errno:57,code:"ENODEV",description:"no such device"},{errno:58,code:"ESPIPE",description:"invalid seek"},{errno:59,code:"ECANCELED",description:"operation canceled"}];t.exports.errno={"-1":n[0],0:n[1],1:n[2],2:n[3],3:n[4],4:n[5],5:n[6],6:n[7],7:n[8],8:n[9],9:n[10],10:n[11],11:n[12],12:n[13],13:n[14],14:n[15],15:n[16],16:n[17],17:n[18],18:n[19],19:n[20],20:n[21],21:n[22],22:n[23],23:n[24],24:n[25],25:n[26],26:n[27],27:n[28],28:n[29],29:n[30],31:n[31],32:n[32],33:n[33],34:n[34],35:n[35],36:n[36],37:n[37],38:n[38],39:n[39],40:n[40],41:n[41],42:n[42],44:n[43],45:n[44],46:n[45],47:n[46],48:n[47],49:n[48],50:n[49],51:n[50],52:n[51],53:n[52],54:n[53],55:n[54],56:n[55],57:n[56],58:n[57],59:n[58]},t.exports.code={UNKNOWN:n[0],OK:n[1],EOF:n[2],EADDRINFO:n[3],EACCES:n[4],EAGAIN:n[5],EADDRINUSE:n[6],EADDRNOTAVAIL:n[7],EAFNOSUPPORT:n[8],EALREADY:n[9],EBADF:n[10],EBUSY:n[11],ECONNABORTED:n[12],ECONNREFUSED:n[13],ECONNRESET:n[14],EDESTADDRREQ:n[15],EFAULT:n[16],EHOSTUNREACH:n[17],EINTR:n[18],EINVAL:n[19],EISCONN:n[20],EMFILE:n[21],EMSGSIZE:n[22],ENETDOWN:n[23],ENETUNREACH:n[24],ENFILE:n[25],ENOBUFS:n[26],ENOMEM:n[27],ENOTDIR:n[28],EISDIR:n[29],ENONET:n[30],ENOTCONN:n[31],ENOTSOCK:n[32],ENOTSUP:n[33],ENOENT:n[34],ENOSYS:n[35],EPIPE:n[36],EPROTO:n[37],EPROTONOSUPPORT:n[38],EPROTOTYPE:n[39],ETIMEDOUT:n[40],ECHARSET:n[41],EAIFAMNOSUPPORT:n[42],EAISERVICE:n[43],EAISOCKTYPE:n[44],ESHUTDOWN:n[45],EEXIST:n[46],ESRCH:n[47],ENAMETOOLONG:n[48],EPERM:n[49],ELOOP:n[50],EXDEV:n[51],ENOTEMPTY:n[52],ENOSPC:n[53],EIO:n[54],EROFS:n[55],ENODEV:n[56],ESPIPE:n[57],ECANCELED:n[58]},t.exports.custom=e("./custom")(t.exports),t.exports.create=t.exports.custom.createError},{"./custom":58}],60:[function(e,t){!function(e,n,r){"undefined"!=typeof t&&t.exports?t.exports=r():n[e]=r()}("prr",this,function(){var e="function"==typeof Object.defineProperty?function(e,t,n){return Object.defineProperty(e,t,n),e}:function(e,t,n){return e[t]=n.value,e},t=function(e,t){var n="object"==typeof t,r=!n&&"string"==typeof t,i=function(e){return n?!!t[e]:r?t.indexOf(e[0])>-1:!1};return{enumerable:i("enumerable"),configurable:i("configurable"),writable:i("writable"),value:e}},n=function(n,r,i,o){var s;if(o=t(i,o),"object"==typeof r){for(s in r)Object.hasOwnProperty.call(r,s)&&(o.value=r[s],e(n,s,o));return n}return e(n,r,o)};return n})},{}],61:[function(e,t){(function(n){function r(e){return this instanceof r?(u.call(this,e),c.call(this,e),e&&e.readable===!1&&(this.readable=!1),e&&e.writable===!1&&(this.writable=!1),this.allowHalfOpen=!0,e&&e.allowHalfOpen===!1&&(this.allowHalfOpen=!1),void this.once("end",i)):new r(e)}function i(){this.allowHalfOpen||this._writableState.ended||n.nextTick(this.end.bind(this))}function o(e,t){for(var n=0,r=e.length;r>n;n++)t(e[n],n)}t.exports=r;var s=Object.keys||function(e){var t=[];for(var n in e)t.push(n);return t},a=e("core-util-is");a.inherits=e("inherits");var u=e("./_stream_readable"),c=e("./_stream_writable");a.inherits(r,u),o(s(c.prototype),function(e){r.prototype[e]||(r.prototype[e]=c.prototype[e])})}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"./_stream_readable":63,"./_stream_writable":65,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"core-util-is":66,inherits:33}],62:[function(e,t){function n(e){return this instanceof n?void r.call(this,e):new n(e)}t.exports=n;var r=e("./_stream_transform"),i=e("core-util-is");i.inherits=e("inherits"),i.inherits(n,r),n.prototype._transform=function(e,t,n){n(null,e)}},{"./_stream_transform":64,"core-util-is":66,inherits:33}],63:[function(e,t){(function(n){function r(t){t=t||{};var n=t.highWaterMark;this.highWaterMark=n||0===n?n:16384,this.highWaterMark=~~this.highWaterMark,this.buffer=[],this.length=0,this.pipes=null,this.pipesCount=0,this.flowing=!1,this.ended=!1,this.endEmitted=!1,this.reading=!1,this.calledRead=!1,this.sync=!0,this.needReadable=!1,this.emittedReadable=!1,this.readableListening=!1,this.objectMode=!!t.objectMode,this.defaultEncoding=t.defaultEncoding||"utf8",this.ranOut=!1,this.awaitDrain=0,this.readingMore=!1,this.decoder=null,this.encoding=null,t.encoding&&(A||(A=e("string_decoder/").StringDecoder),this.decoder=new A(t.encoding),this.encoding=t.encoding)}function i(e){return this instanceof i?(this._readableState=new r(e,this),this.readable=!0,void j.call(this)):new i(e)}function o(e,t,n,r,i){var o=c(t,n);if(o)e.emit("error",o);else if(null===n||void 0===n)t.reading=!1,t.ended||l(e,t);else if(t.objectMode||n&&n.length>0)if(t.ended&&!i){var a=new Error("stream.push() after EOF");e.emit("error",a)}else if(t.endEmitted&&i){var a=new Error("stream.unshift() after end event");e.emit("error",a)}else!t.decoder||i||r||(n=t.decoder.write(n)),t.length+=t.objectMode?1:n.length,i?t.buffer.unshift(n):(t.reading=!1,t.buffer.push(n)),t.needReadable&&f(e),h(e,t);
+else i||(t.reading=!1);return s(t)}function s(e){return!e.ended&&(e.needReadable||e.length<e.highWaterMark||0===e.length)}function a(e){if(e>=L)e=L;else{e--;for(var t=1;32>t;t<<=1)e|=e>>t;e++}return e}function u(e,t){return 0===t.length&&t.ended?0:t.objectMode?0===e?0:1:isNaN(e)||null===e?t.flowing&&t.buffer.length?t.buffer[0].length:t.length:0>=e?0:(e>t.highWaterMark&&(t.highWaterMark=a(e)),e>t.length?t.ended?t.length:(t.needReadable=!0,0):e)}function c(e,t){var n=null;return S.isBuffer(t)||"string"==typeof t||null===t||void 0===t||e.objectMode||n||(n=new TypeError("Invalid non-string/buffer chunk")),n}function l(e,t){if(t.decoder&&!t.ended){var n=t.decoder.end();n&&n.length&&(t.buffer.push(n),t.length+=t.objectMode?1:n.length)}t.ended=!0,t.length>0?f(e):_(e)}function f(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(t.emittedReadable=!0,t.sync?n.nextTick(function(){d(e)}):d(e))}function d(e){e.emit("readable")}function h(e,t){t.readingMore||(t.readingMore=!0,n.nextTick(function(){p(e,t)}))}function p(e,t){for(var n=t.length;!t.reading&&!t.flowing&&!t.ended&&t.length<t.highWaterMark&&(e.read(0),n!==t.length);)n=t.length;t.readingMore=!1}function g(e){return function(){var t=e._readableState;t.awaitDrain--,0===t.awaitDrain&&y(e)}}function y(e){function t(e){var t=e.write(n);!1===t&&r.awaitDrain++}var n,r=e._readableState;for(r.awaitDrain=0;r.pipesCount&&null!==(n=e.read());)if(1===r.pipesCount?t(r.pipes,0,null):w(r.pipes,t),e.emit("data",n),r.awaitDrain>0)return;return 0===r.pipesCount?(r.flowing=!1,void(x.listenerCount(e,"data")>0&&b(e))):void(r.ranOut=!0)}function v(){this._readableState.ranOut&&(this._readableState.ranOut=!1,y(this))}function b(e,t){var r=e._readableState;if(r.flowing)throw new Error("Cannot switch to old mode now.");var i=t||!1,o=!1;e.readable=!0,e.pipe=j.prototype.pipe,e.on=e.addListener=j.prototype.on,e.on("readable",function(){o=!0;for(var t;!i&&null!==(t=e.read());)e.emit("data",t);null===t&&(o=!1,e._readableState.needReadable=!0)}),e.pause=function(){i=!0,this.emit("pause")},e.resume=function(){i=!1,o?n.nextTick(function(){e.emit("readable")}):this.read(0),this.emit("resume")},e.emit("readable")}function m(e,t){var n,r=t.buffer,i=t.length,o=!!t.decoder,s=!!t.objectMode;if(0===r.length)return null;if(0===i)n=null;else if(s)n=r.shift();else if(!e||e>=i)n=o?r.join(""):S.concat(r,i),r.length=0;else if(e<r[0].length){var a=r[0];n=a.slice(0,e),r[0]=a.slice(e)}else if(e===r[0].length)n=r.shift();else{n=o?"":new S(e);for(var u=0,c=0,l=r.length;l>c&&e>u;c++){var a=r[0],f=Math.min(e-u,a.length);o?n+=a.slice(0,f):a.copy(n,u,0,f),f<a.length?r[0]=a.slice(f):r.shift(),u+=f}}return n}function _(e){var t=e._readableState;if(t.length>0)throw new Error("endReadable called on non-empty stream");!t.endEmitted&&t.calledRead&&(t.ended=!0,n.nextTick(function(){t.endEmitted||0!==t.length||(t.endEmitted=!0,e.readable=!1,e.emit("end"))}))}function w(e,t){for(var n=0,r=e.length;r>n;n++)t(e[n],n)}function E(e,t){for(var n=0,r=e.length;r>n;n++)if(e[n]===t)return n;return-1}t.exports=i;var k=e("isarray"),S=e("buffer").Buffer;i.ReadableState=r;var x=e("events").EventEmitter;x.listenerCount||(x.listenerCount=function(e,t){return e.listeners(t).length});var j=e("stream"),O=e("core-util-is");O.inherits=e("inherits");var A;O.inherits(i,j),i.prototype.push=function(e,t){var n=this._readableState;return"string"!=typeof e||n.objectMode||(t=t||n.defaultEncoding,t!==n.encoding&&(e=new S(e,t),t="")),o(this,n,e,t,!1)},i.prototype.unshift=function(e){var t=this._readableState;return o(this,t,e,"",!0)},i.prototype.setEncoding=function(t){A||(A=e("string_decoder/").StringDecoder),this._readableState.decoder=new A(t),this._readableState.encoding=t};var L=8388608;i.prototype.read=function(e){var t=this._readableState;t.calledRead=!0;var n=e;if(("number"!=typeof e||e>0)&&(t.emittedReadable=!1),0===e&&t.needReadable&&(t.length>=t.highWaterMark||t.ended))return f(this),null;if(e=u(e,t),0===e&&t.ended)return 0===t.length&&_(this),null;var r=t.needReadable;t.length-e<=t.highWaterMark&&(r=!0),(t.ended||t.reading)&&(r=!1),r&&(t.reading=!0,t.sync=!0,0===t.length&&(t.needReadable=!0),this._read(t.highWaterMark),t.sync=!1),r&&!t.reading&&(e=u(n,t));var i;return i=e>0?m(e,t):null,null===i&&(t.needReadable=!0,e=0),t.length-=e,0!==t.length||t.ended||(t.needReadable=!0),t.ended&&!t.endEmitted&&0===t.length&&_(this),i},i.prototype._read=function(){this.emit("error",new Error("not implemented"))},i.prototype.pipe=function(e,t){function r(e){e===l&&o()}function i(){e.end()}function o(){e.removeListener("close",a),e.removeListener("finish",u),e.removeListener("drain",p),e.removeListener("error",s),e.removeListener("unpipe",r),l.removeListener("end",i),l.removeListener("end",o),(!e._writableState||e._writableState.needDrain)&&p()}function s(t){c(),e.removeListener("error",s),0===x.listenerCount(e,"error")&&e.emit("error",t)}function a(){e.removeListener("finish",u),c()}function u(){e.removeListener("close",a),c()}function c(){l.unpipe(e)}var l=this,f=this._readableState;switch(f.pipesCount){case 0:f.pipes=e;break;case 1:f.pipes=[f.pipes,e];break;default:f.pipes.push(e)}f.pipesCount+=1;var d=(!t||t.end!==!1)&&e!==n.stdout&&e!==n.stderr,h=d?i:o;f.endEmitted?n.nextTick(h):l.once("end",h),e.on("unpipe",r);var p=g(l);return e.on("drain",p),e._events&&e._events.error?k(e._events.error)?e._events.error.unshift(s):e._events.error=[s,e._events.error]:e.on("error",s),e.once("close",a),e.once("finish",u),e.emit("pipe",l),f.flowing||(this.on("readable",v),f.flowing=!0,n.nextTick(function(){y(l)})),e},i.prototype.unpipe=function(e){var t=this._readableState;if(0===t.pipesCount)return this;if(1===t.pipesCount)return e&&e!==t.pipes?this:(e||(e=t.pipes),t.pipes=null,t.pipesCount=0,this.removeListener("readable",v),t.flowing=!1,e&&e.emit("unpipe",this),this);if(!e){var n=t.pipes,r=t.pipesCount;t.pipes=null,t.pipesCount=0,this.removeListener("readable",v),t.flowing=!1;for(var i=0;r>i;i++)n[i].emit("unpipe",this);return this}var i=E(t.pipes,e);return-1===i?this:(t.pipes.splice(i,1),t.pipesCount-=1,1===t.pipesCount&&(t.pipes=t.pipes[0]),e.emit("unpipe",this),this)},i.prototype.on=function(e,t){var n=j.prototype.on.call(this,e,t);if("data"!==e||this._readableState.flowing||b(this),"readable"===e&&this.readable){var r=this._readableState;r.readableListening||(r.readableListening=!0,r.emittedReadable=!1,r.needReadable=!0,r.reading?r.length&&f(this,r):this.read(0))}return n},i.prototype.addListener=i.prototype.on,i.prototype.resume=function(){b(this),this.read(0),this.emit("resume")},i.prototype.pause=function(){b(this,!0),this.emit("pause")},i.prototype.wrap=function(e){var t=this._readableState,n=!1,r=this;e.on("end",function(){if(t.decoder&&!t.ended){var e=t.decoder.end();e&&e.length&&r.push(e)}r.push(null)}),e.on("data",function(i){if(t.decoder&&(i=t.decoder.write(i)),i&&(t.objectMode||i.length)){var o=r.push(i);o||(n=!0,e.pause())}});for(var i in e)"function"==typeof e[i]&&"undefined"==typeof this[i]&&(this[i]=function(t){return function(){return e[t].apply(e,arguments)}}(i));var o=["error","close","destroy","pause","resume"];return w(o,function(t){e.on(t,r.emit.bind(r,t))}),r._read=function(){n&&(n=!1,e.resume())},r},i._fromList=m}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,"core-util-is":66,events:18,inherits:33,isarray:67,stream:24,"string_decoder/":68}],64:[function(e,t){function n(e,t){this.afterTransform=function(e,n){return r(t,e,n)},this.needTransform=!1,this.transforming=!1,this.writecb=null,this.writechunk=null}function r(e,t,n){var r=e._transformState;r.transforming=!1;var i=r.writecb;if(!i)return e.emit("error",new Error("no writecb in Transform class"));r.writechunk=null,r.writecb=null,null!==n&&void 0!==n&&e.push(n),i&&i(t);var o=e._readableState;o.reading=!1,(o.needReadable||o.length<o.highWaterMark)&&e._read(o.highWaterMark)}function i(e){if(!(this instanceof i))return new i(e);s.call(this,e);var t=(this._transformState=new n(e,this),this);this._readableState.needReadable=!0,this._readableState.sync=!1,this.once("finish",function(){"function"==typeof this._flush?this._flush(function(e){o(t,e)}):o(t)})}function o(e,t){if(t)return e.emit("error",t);var n=e._writableState,r=(e._readableState,e._transformState);if(n.length)throw new Error("calling transform done when ws.length != 0");if(r.transforming)throw new Error("calling transform done when still transforming");return e.push(null)}t.exports=i;var s=e("./_stream_duplex"),a=e("core-util-is");a.inherits=e("inherits"),a.inherits(i,s),i.prototype.push=function(e,t){return this._transformState.needTransform=!1,s.prototype.push.call(this,e,t)},i.prototype._transform=function(){throw new Error("not implemented")},i.prototype._write=function(e,t,n){var r=this._transformState;if(r.writecb=n,r.writechunk=e,r.writeencoding=t,!r.transforming){var i=this._readableState;(r.needTransform||i.needReadable||i.length<i.highWaterMark)&&this._read(i.highWaterMark)}},i.prototype._read=function(){var e=this._transformState;null!==e.writechunk&&e.writecb&&!e.transforming?(e.transforming=!0,this._transform(e.writechunk,e.writeencoding,e.afterTransform)):e.needTransform=!0}},{"./_stream_duplex":61,"core-util-is":66,inherits:33}],65:[function(e,t){(function(n){function r(e,t,n){this.chunk=e,this.encoding=t,this.callback=n}function i(e,t){e=e||{};var n=e.highWaterMark;this.highWaterMark=n||0===n?n:16384,this.objectMode=!!e.objectMode,this.highWaterMark=~~this.highWaterMark,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1;var r=e.decodeStrings===!1;this.decodeStrings=!r,this.defaultEncoding=e.defaultEncoding||"utf8",this.length=0,this.writing=!1,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(e){h(t,e)},this.writecb=null,this.writelen=0,this.buffer=[],this.errorEmitted=!1}function o(t){var n=e("./_stream_duplex");return this instanceof o||this instanceof n?(this._writableState=new i(t,this),this.writable=!0,void E.call(this)):new o(t)}function s(e,t,r){var i=new Error("write after end");e.emit("error",i),n.nextTick(function(){r(i)})}function a(e,t,r,i){var o=!0;if(!_.isBuffer(r)&&"string"!=typeof r&&null!==r&&void 0!==r&&!t.objectMode){var s=new TypeError("Invalid non-string/buffer chunk");e.emit("error",s),n.nextTick(function(){i(s)}),o=!1}return o}function u(e,t,n){return e.objectMode||e.decodeStrings===!1||"string"!=typeof t||(t=new _(t,n)),t}function c(e,t,n,i,o){n=u(t,n,i),_.isBuffer(n)&&(i="buffer");var s=t.objectMode?1:n.length;t.length+=s;var a=t.length<t.highWaterMark;return a||(t.needDrain=!0),t.writing?t.buffer.push(new r(n,i,o)):l(e,t,s,n,i,o),a}function l(e,t,n,r,i,o){t.writelen=n,t.writecb=o,t.writing=!0,t.sync=!0,e._write(r,i,t.onwrite),t.sync=!1}function f(e,t,r,i,o){r?n.nextTick(function(){o(i)}):o(i),e._writableState.errorEmitted=!0,e.emit("error",i)}function d(e){e.writing=!1,e.writecb=null,e.length-=e.writelen,e.writelen=0}function h(e,t){var r=e._writableState,i=r.sync,o=r.writecb;if(d(r),t)f(e,r,i,t,o);else{var s=v(e,r);s||r.bufferProcessing||!r.buffer.length||y(e,r),i?n.nextTick(function(){p(e,r,s,o)}):p(e,r,s,o)}}function p(e,t,n,r){n||g(e,t),r(),n&&b(e,t)}function g(e,t){0===t.length&&t.needDrain&&(t.needDrain=!1,e.emit("drain"))}function y(e,t){t.bufferProcessing=!0;for(var n=0;n<t.buffer.length;n++){var r=t.buffer[n],i=r.chunk,o=r.encoding,s=r.callback,a=t.objectMode?1:i.length;if(l(e,t,a,i,o,s),t.writing){n++;break}}t.bufferProcessing=!1,n<t.buffer.length?t.buffer=t.buffer.slice(n):t.buffer.length=0}function v(e,t){return t.ending&&0===t.length&&!t.finished&&!t.writing}function b(e,t){var n=v(e,t);return n&&(t.finished=!0,e.emit("finish")),n}function m(e,t,r){t.ending=!0,b(e,t),r&&(t.finished?n.nextTick(r):e.once("finish",r)),t.ended=!0}t.exports=o;var _=e("buffer").Buffer;o.WritableState=i;var w=e("core-util-is");w.inherits=e("inherits");var E=e("stream");w.inherits(o,E),o.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe. Not readable."))},o.prototype.write=function(e,t,n){var r=this._writableState,i=!1;return"function"==typeof t&&(n=t,t=null),_.isBuffer(e)?t="buffer":t||(t=r.defaultEncoding),"function"!=typeof n&&(n=function(){}),r.ended?s(this,r,n):a(this,r,e,n)&&(i=c(this,r,e,t,n)),i},o.prototype._write=function(e,t,n){n(new Error("not implemented"))},o.prototype.end=function(e,t,n){var r=this._writableState;"function"==typeof e?(n=e,e=null,t=null):"function"==typeof t&&(n=t,t=null),"undefined"!=typeof e&&null!==e&&this.write(e,t),r.ending||r.finished||m(this,r,n)}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"./_stream_duplex":61,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,"core-util-is":66,inherits:33,stream:24}],66:[function(e,t,n){(function(e){function t(e){return Array.isArray(e)}function r(e){return"boolean"==typeof e}function i(e){return null===e}function o(e){return null==e}function s(e){return"number"==typeof e}function a(e){return"string"==typeof e}function u(e){return"symbol"==typeof e}function c(e){return void 0===e}function l(e){return f(e)&&"[object RegExp]"===v(e)}function f(e){return"object"==typeof e&&null!==e}function d(e){return f(e)&&"[object Date]"===v(e)}function h(e){return f(e)&&("[object Error]"===v(e)||e instanceof Error)}function p(e){return"function"==typeof e}function g(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"==typeof e||"undefined"==typeof e}function y(t){return e.isBuffer(t)}function v(e){return Object.prototype.toString.call(e)}n.isArray=t,n.isBoolean=r,n.isNull=i,n.isNullOrUndefined=o,n.isNumber=s,n.isString=a,n.isSymbol=u,n.isUndefined=c,n.isRegExp=l,n.isObject=f,n.isDate=d,n.isError=h,n.isFunction=p,n.isPrimitive=g,n.isBuffer=y}).call(this,e("buffer").Buffer)},{buffer:20}],67:[function(e,t){t.exports=Array.isArray||function(e){return"[object Array]"==Object.prototype.toString.call(e)}},{}],68:[function(e,t,n){function r(e){if(e&&!u(e))throw new Error("Unknown encoding: "+e)}function i(e){return e.toString(this.encoding)}function o(e){var t=this.charReceived=e.length%2;return this.charLength=t?2:0,t}function s(e){var t=this.charReceived=e.length%3;return this.charLength=t?3:0,t}var a=e("buffer").Buffer,u=a.isEncoding||function(e){switch(e&&e.toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":case"raw":return!0;default:return!1}},c=n.StringDecoder=function(e){switch(this.encoding=(e||"utf8").toLowerCase().replace(/[-_]/,""),r(e),this.encoding){case"utf8":this.surrogateSize=3;break;case"ucs2":case"utf16le":this.surrogateSize=2,this.detectIncompleteChar=o;break;case"base64":this.surrogateSize=3,this.detectIncompleteChar=s;break;default:return void(this.write=i)}this.charBuffer=new a(6),this.charReceived=0,this.charLength=0};c.prototype.write=function(e){for(var t="",n=0;this.charLength;){var r=e.length>=this.charLength-this.charReceived?this.charLength-this.charReceived:e.length;if(e.copy(this.charBuffer,this.charReceived,n,r),this.charReceived+=r-n,n=r,this.charReceived<this.charLength)return"";t=this.charBuffer.slice(0,this.charLength).toString(this.encoding);var i=t.charCodeAt(t.length-1);if(!(i>=55296&&56319>=i)){if(this.charReceived=this.charLength=0,r==e.length)return t;e=e.slice(r,e.length);break}this.charLength+=this.surrogateSize,t=""}var o=this.detectIncompleteChar(e),s=e.length;this.charLength&&(e.copy(this.charBuffer,0,e.length-o,s),this.charReceived=o,s-=o),t+=e.toString(this.encoding,0,s);var s=t.length-1,i=t.charCodeAt(s);if(i>=55296&&56319>=i){var a=this.surrogateSize;return this.charLength+=a,this.charReceived+=a,this.charBuffer.copy(this.charBuffer,a,0,a),this.charBuffer.write(t.charAt(t.length-1),this.encoding),t.substring(0,s)}return t},c.prototype.detectIncompleteChar=function(e){for(var t=e.length>=3?3:e.length;t>0;t--){var n=e[e.length-t];if(1==t&&n>>5==6){this.charLength=2;break}if(2>=t&&n>>4==14){this.charLength=3;break}if(3>=t&&n>>3==30){this.charLength=4;break}}return t},c.prototype.end=function(e){var t="";if(e&&e.length&&(t=this.write(e)),this.charReceived){var n=this.charReceived,r=this.charBuffer,i=this.encoding;t+=r.slice(0,n).toString(i)}return t}},{buffer:20}],69:[function(e,t,n){n=t.exports=e("./lib/_stream_readable.js"),n.Readable=n,n.Writable=e("./lib/_stream_writable.js"),n.Duplex=e("./lib/_stream_duplex.js"),n.Transform=e("./lib/_stream_transform.js"),n.PassThrough=e("./lib/_stream_passthrough.js")},{"./lib/_stream_duplex.js":61,"./lib/_stream_passthrough.js":62,"./lib/_stream_readable.js":63,"./lib/_stream_transform.js":64,"./lib/_stream_writable.js":65}],70:[function(e,t){function n(){for(var e={},t=0;t<arguments.length;t++){var n=arguments[t];for(var r in n)n.hasOwnProperty(r)&&(e[r]=n[r])}return e}t.exports=n},{}],71:[function(e,t){t.exports={name:"levelup",description:"Fast & simple storage - a Node.js-style LevelDB wrapper",version:"0.18.6",contributors:[{name:"Rod Vagg",email:"r@va.gg",url:"https://github.com/rvagg"},{name:"John Chesley",email:"john@chesl.es",url:"https://github.com/chesles/"},{name:"Jake Verbaten",email:"raynos2@gmail.com",url:"https://github.com/raynos"},{name:"Dominic Tarr",email:"dominic.tarr@gmail.com",url:"https://github.com/dominictarr"},{name:"Max Ogden",email:"max@maxogden.com",url:"https://github.com/maxogden"},{name:"Lars-Magnus Skog",email:"lars.magnus.skog@gmail.com",url:"https://github.com/ralphtheninja"},{name:"David Björklund",email:"david.bjorklund@gmail.com",url:"https://github.com/kesla"},{name:"Julian Gruber",email:"julian@juliangruber.com",url:"https://github.com/juliangruber"},{name:"Paolo Fragomeni",email:"paolo@async.ly",url:"https://github.com/hij1nx"},{name:"Anton Whalley",email:"anton.whalley@nearform.com",url:"https://github.com/No9"},{name:"Matteo Collina",email:"matteo.collina@gmail.com",url:"https://github.com/mcollina"},{name:"Pedro Teixeira",email:"pedro.teixeira@gmail.com",url:"https://github.com/pgte"},{name:"James Halliday",email:"mail@substack.net",url:"https://github.com/substack"}],repository:{type:"git",url:"https://github.com/rvagg/node-levelup.git"},homepage:"https://github.com/rvagg/node-levelup",keywords:["leveldb","stream","database","db","store","storage","json"],main:"lib/levelup.js",dependencies:{bl:"~0.8.1","deferred-leveldown":"~0.2.0",errno:"~0.1.1",prr:"~0.0.0","readable-stream":"~1.0.26",semver:"~2.3.1",xtend:"~3.0.0"},devDependencies:{leveldown:"~0.10.0",bustermove:"*",tap:"*",referee:"*",rimraf:"*",async:"*",fstream:"*",tar:"*",mkfiletree:"*",readfiletree:"*","slow-stream":">=0.0.4",delayed:"*",boganipsum:"*",du:"*",memdown:"*","msgpack-js":"*"},browser:{leveldown:!1,"leveldown/package":!1,semver:!1},scripts:{test:"tap test/*-test.js --stderr",functionaltests:"node ./test/functional/fstream-test.js && node ./test/functional/binary-data-test.js && node ./test/functional/compat-test.js",alltests:"npm test && npm run-script functionaltests"},license:"MIT",gitHead:"213e989e2b75273e2b44c23f84f95e35bff7ea11",bugs:{url:"https://github.com/rvagg/node-levelup/issues"},_id:"levelup@0.18.6",_shasum:"e6a01cb089616c8ecc0291c2a9bd3f0c44e3e5eb",_from:"levelup@~0.18.4",_npmVersion:"1.4.14",_npmUser:{name:"rvagg",email:"rod@vagg.org"},maintainers:[{name:"rvagg",email:"rod@vagg.org"}],dist:{shasum:"e6a01cb089616c8ecc0291c2a9bd3f0c44e3e5eb",tarball:"http://127.0.0.1:5080/tarballs/levelup/0.18.6.tgz"},_resolved:"http://127.0.0.1:5080/tarballs/levelup/0.18.6.tgz",readme:"ERROR: No README data found!"}},{}],72:[function(e,t){"use strict";function n(){}t.exports=n},{}],73:[function(e,t){"use strict";var n=e("./promise"),r=e("./reject"),i=e("./resolve"),o=e("./INTERNAL"),s=e("./handlers"),a=r(new TypeError("must be an array"));t.exports=function(e){function t(e,t){function n(e){c[t]=e,++l===r&!u&&(u=!0,s.resolve(d,c))}i(e).then(n,function(e){u||(u=!0,s.reject(d,e))})}if("[object Array]"!==Object.prototype.toString.call(e))return a;var r=e.length,u=!1;if(!r)return i([]);for(var c=new Array(r),l=0,f=-1,d=new n(o);++f<r;)t(e[f],f);return d}},{"./INTERNAL":72,"./handlers":74,"./promise":76,"./reject":78,"./resolve":79}],74:[function(e,t,n){"use strict";function r(e){var t=e&&e.then;return e&&"object"==typeof e&&"function"==typeof t?function(){t.apply(e,arguments)}:void 0}var i=e("./tryCatch"),o=e("./resolveThenable"),s=e("./states");n.resolve=function(e,t){var a=i(r,t);if("error"===a.status)return n.reject(e,a.value);var u=a.value;if(u)o.safely(e,u);else{e.state=s.FULFILLED,e.outcome=t;for(var c=-1,l=e.queue.length;++c<l;)e.queue[c].callFulfilled(t)}return e},n.reject=function(e,t){e.state=s.REJECTED,e.outcome=t;for(var n=-1,r=e.queue.length;++n<r;)e.queue[n].callRejected(t);return e}},{"./resolveThenable":80,"./states":81,"./tryCatch":82}],75:[function(e,t,n){t.exports=n=e("./promise"),n.resolve=e("./resolve"),n.reject=e("./reject"),n.all=e("./all")},{"./all":73,"./promise":76,"./reject":78,"./resolve":79}],76:[function(e,t){"use strict";function n(e){if(!(this instanceof n))return new n(e);if("function"!=typeof e)throw new TypeError("reslover must be a function");this.state=s.PENDING,this.queue=[],this.outcome=void 0,e!==i&&o.safely(this,e)}var r=e("./unwrap"),i=e("./INTERNAL"),o=e("./resolveThenable"),s=e("./states"),a=e("./queueItem");t.exports=n,n.prototype["catch"]=function(e){return this.then(null,e)},n.prototype.then=function(e,t){if("function"!=typeof e&&this.state===s.FULFILLED||"function"!=typeof t&&this.state===s.REJECTED)return this;var o=new n(i);if(this.state!==s.PENDING){var u=this.state===s.FULFILLED?e:t;r(o,u,this.outcome)}else this.queue.push(new a(o,e,t));return o}},{"./INTERNAL":72,"./queueItem":77,"./resolveThenable":80,"./states":81,"./unwrap":83}],77:[function(e,t){"use strict";function n(e,t,n){this.promise=e,"function"==typeof t&&(this.onFulfilled=t,this.callFulfilled=this.otherCallFulfilled),"function"==typeof n&&(this.onRejected=n,this.callRejected=this.otherCallRejected)}var r=e("./handlers"),i=e("./unwrap");t.exports=n,n.prototype.callFulfilled=function(e){r.resolve(this.promise,e)},n.prototype.otherCallFulfilled=function(e){i(this.promise,this.onFulfilled,e)},n.prototype.callRejected=function(e){r.reject(this.promise,e)},n.prototype.otherCallRejected=function(e){i(this.promise,this.onRejected,e)}},{"./handlers":74,"./unwrap":83}],78:[function(e,t){"use strict";function n(e){var t=new r(i);return o.reject(t,e)}var r=e("./promise"),i=e("./INTERNAL"),o=e("./handlers");t.exports=n},{"./INTERNAL":72,"./handlers":74,"./promise":76}],79:[function(e,t){"use strict";function n(e){if(e)return e instanceof r?e:o.resolve(new r(i),e);var t=typeof e;switch(t){case"boolean":return s;case"undefined":return u;case"object":return a;case"number":return c;case"string":return l}}var r=e("./promise"),i=e("./INTERNAL"),o=e("./handlers");t.exports=n;var s=o.resolve(new r(i),!1),a=o.resolve(new r(i),null),u=o.resolve(new r(i),void 0),c=o.resolve(new r(i),0),l=o.resolve(new r(i),"")},{"./INTERNAL":72,"./handlers":74,"./promise":76}],80:[function(e,t,n){"use strict";function r(e,t){function n(t){a||(a=!0,i.reject(e,t))}function r(t){a||(a=!0,i.resolve(e,t))}function s(){t(r,n)}var a=!1,u=o(s);"error"===u.status&&n(u.value)}var i=e("./handlers"),o=e("./tryCatch");n.safely=r},{"./handlers":74,"./tryCatch":82}],81:[function(e,t,n){n.REJECTED=["REJECTED"],n.FULFILLED=["FULFILLED"],n.PENDING=["PENDING"]},{}],82:[function(e,t){"use strict";function n(e,t){var n={};try{n.value=e(t),n.status="success"}catch(r){n.status="error",n.value=r}return n}t.exports=n},{}],83:[function(e,t){"use strict";function n(e,t,n){r(function(){var r;try{r=t(n)}catch(o){return i.reject(e,o)}r===e?i.reject(e,new TypeError("Cannot resolve promise with itself")):i.resolve(e,r)})}var r=e("immediate"),i=e("./handlers");t.exports=n},{"./handlers":74,immediate:84}],84:[function(e,t){"use strict";function n(){i=!0;for(var e,t,n=a.length;n;){for(t=a,a=[],e=-1;++e<n;)t[e]();n=a.length}i=!1}function r(e){1!==a.push(e)||i||o()}for(var i,o,s=[e("./nextTick"),e("./mutation.js"),e("./messageChannel"),e("./stateChange"),e("./timeout")],a=[],u=-1,c=s.length;++u<c;)if(s[u]&&s[u].test&&s[u].test()){o=s[u].install(n);break}t.exports=r},{"./messageChannel":85,"./mutation.js":86,"./nextTick":17,"./stateChange":87,"./timeout":88}],85:[function(e,t,n){(function(e){"use strict";n.test=function(){return e.setImmediate?!1:"undefined"!=typeof e.MessageChannel},n.install=function(t){var n=new e.MessageChannel;return n.port1.onmessage=t,function(){n.port2.postMessage(0)}}}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],86:[function(e,t,n){(function(e){"use strict";var t=e.MutationObserver||e.WebKitMutationObserver;n.test=function(){return t},n.install=function(n){var r=0,i=new t(n),o=e.document.createTextNode("");return i.observe(o,{characterData:!0}),function(){o.data=r=++r%2}}}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],87:[function(e,t,n){(function(e){"use strict";n.test=function(){return"document"in e&&"onreadystatechange"in e.document.createElement("script")},n.install=function(t){return function(){var n=e.document.createElement("script");return n.onreadystatechange=function(){t(),n.onreadystatechange=null,n.parentNode.removeChild(n),n=null},e.document.documentElement.appendChild(n),t}}}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],88:[function(e,t,n){"use strict";n.test=function(){return!0},n.install=function(e){return function(){setTimeout(e,0)}}},{}],"3WVjcl":[function(e,t){(function(n,r,i){function o(e,t){f.call(this,e);new i(0);if(this._dbsize=this.db.container.length(),this._reverse=!!t.reverse,t.end instanceof i?(t.end.length=0)&&(this._end=this.db.container.key(this._dbsize-1)):this._end=t.end,this._limit=t.limit,this._count=0,t.start){for(var n=!1,r=0;r<this._dbsize;r++)if(this.db.container.key(r)>=t.start){this._pos=r,this._reverse&&(this._pos=this.db.container.key(r)>t.start?r-1:r),n=!0;break}n||(this._pos=this._reverse?this._dbsize-1:-1)}else this._pos=this._reverse?this._dbsize-1:0}function s(t){if(!(this instanceof s))return new s(t);l.call(this,t);var n=e("./localstorage").localStorage;this.container=new n(t)}function a(e){return e instanceof ArrayBuffer}function u(e,t){if(null===e||void 0===e)return new Error(t+" cannot be `null` or `undefined`");if(null===e||void 0===e)return new Error(t+" cannot be `null` or `undefined`");if("key"===t){if(e instanceof Boolean)return new Error(t+" cannot be `null` or `undefined`");if(""===e)return new Error(t+" cannot be empty")}if(0==e.toString().indexOf("[object ArrayBuffer]")&&(0==e.byteLength||void 0==e.byteLength))return new Error(t+" cannot be an empty Buffer");if(a(e)){if(0===e.length)return new Error(t+" cannot be an empty Buffer")}else if(""===String(e))return new Error(t+" cannot be an empty String")}var c=e("util"),l=e("abstract-leveldown").AbstractLevelDOWN,f=e("abstract-leveldown").AbstractIterator,d=function(){},h=r.setImmediate||n.nextTick;c.inherits(o,f),o.prototype._next=function(e){if(this._pos>=this.db.container.length()||this._pos<0)return h(e);var t,n=this.db.container.key(this._pos);return this._end&&(this._reverse?n<this._end:n>this._end)?h(e):this._limit&&this._limit>0&&this._count++>=this._limit?h(e):(t=this.db.container.getItem(n),this._pos+=this._reverse?-1:1,void h(e.bind(null,void 0,n,t)))},c.inherits(s,l),s.prototype._open=function(e,t){h(function(){t(null,this)}.bind(this))},s.prototype._put=function(e,t,n,r){var o=u(e,"key");if(o)return r(o);if(o=u(t,"value"))return r(o);if("object"==typeof t&&!i.isBuffer(t)&&void 0==t.buffer){var s={};s.storetype="json",s.data=t,t=JSON.stringify(s)}this.container.setItem(e,t),h(r)},s.prototype._get=function(e,t,n){var r=u(e,"key");if(r)return n(r);a(e)||(e=String(e));var o=this.container.getItem(e);if(void 0===o)return h(function(){n(new Error("NotFound: "))});if(t.asBuffer===!1||i.isBuffer(o)||(o=new i(String(o))),t.asBuffer===!1&&o.indexOf('{"storetype":"json","data"')>-1){var s=JSON.parse(o);o=s.data}h(function(){n(null,o)})},s.prototype._del=function(e,t,n){var r=u(e,"key");return r?n(r):(a(e)||(e=String(e)),this.container.removeItem(e),void h(n))},s.prototype._batch=function(e,t,n){var r,o,s,a=0;if(Array.isArray(e))for(;a<e.length;a++)if(e[a]){if(o=i.isBuffer(e[a].key)?e[a].key:String(e[a].key),r=u(o,"key"))return h(n.bind(null,r));if("del"===e[a].type)this._del(e[a].key,t,d);else if("put"===e[a].type){if(s=i.isBuffer(e[a].value)?e[a].value:String(e[a].value),r=u(s,"value"))return h(n.bind(null,r));this._put(o,s,t,d)}}h(n)},s.prototype._iterator=function(e){return new o(this,e)},s.destroy=function(e,t){try{Object.keys(localStorage).forEach(function(t){t.substring(0,e.length+1)==e+"!"&&localStorage.removeItem(t)}),t()}catch(n){}},t.exports=s}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{},e("buffer").Buffer)},{"./localstorage":91,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"abstract-leveldown":94,buffer:20,util:32}],leveldown:[function(e,t){t.exports=e("3WVjcl")},{}],91:[function(e,t,n){function r(e){this._partition=e,this._keys=[];for(var t=0;t<window.localStorage.length;t++)0==window.localStorage.key(t).indexOf(e+"!")&&this._keys.push(window.localStorage.key(t));this._keys.sort()}r.prototype.key=function(e){var t=this._keys[e];return"undefined"!=typeof t?this._keys[e].replace(this._partition+"!","").replace("!bin"):t},r.prototype.setItem=function(e,t){if(e=this._partition+"!"+e,t instanceof ArrayBuffer){var n="ArrayBuffer:";t=n+btoa(String.fromCharCode.apply(null,t))}if(t instanceof Uint8Array){var n="Uint8Array:";t=n+btoa(String.fromCharCode.apply(null,t))}for(var r=0;r<this._keys.length;r++)if(this._keys[r]===e)return void window.localStorage.setItem(e,t);this._keys.push(e),this._keys.sort(),window.localStorage.setItem(e,t)},r.prototype.getItem=function(e){e=this._partition+"!"+e;var t=window.localStorage.getItem(e);if(null==t)return void 0;if(0==t.indexOf("ArrayBuffer:")){var n=t.replace("ArrayBuffer:","");return t=new ArrayBuffer(atob(n).split("").map(function(e){return e.charCodeAt(0)}))}if(0==t.indexOf("Uint8Array:")){var n=t.replace("Uint8Array:","");return atob(n)}return t},r.prototype.removeItem=function(e){e=this._partition+"!"+e;for(var t=this._keys.length;t>=0;t--)this._keys[t]===e&&(this._keys.splice(t,1),window.localStorage.removeItem(e))},r.prototype.clear=function(){window.localStorage.clear()},r.prototype.length=function(){return this._keys.length},n.localStorage=r},{}],92:[function(e,t){t.exports=e(55)},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],93:[function(e,t){t.exports=e(56)},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],94:[function(e,t,n){arguments[4][57][0].apply(n,arguments)},{"./abstract-chained-batch":92,"./abstract-iterator":93,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,xtend:96}],95:[function(e,t){t.exports=e(40)},{}],96:[function(e,t,n){arguments[4][41][0].apply(n,arguments)},{"./has-keys":95,"object-keys":98}],97:[function(e,t){var n=Object.prototype.hasOwnProperty,r=Object.prototype.toString,i=function(e){var t="function"==typeof e&&!(e instanceof RegExp)||"[object Function]"===r.call(e);return t||"undefined"==typeof window||(t=e===window.setTimeout||e===window.alert||e===window.confirm||e===window.prompt),t
+};t.exports=function(e,t){if(!i(t))throw new TypeError("iterator must be a function");var r,o,s="string"==typeof e,a=e.length,u=arguments.length>2?arguments[2]:null;if(a===+a)for(r=0;a>r;r++)null===u?t(s?e.charAt(r):e[r],r,e):t.call(u,s?e.charAt(r):e[r],r,e);else for(o in e)n.call(e,o)&&(null===u?t(e[o],o,e):t.call(u,e[o],o,e))}},{}],98:[function(e,t,n){arguments[4][42][0].apply(n,arguments)},{"./shim":100}],99:[function(e,t){var n=Object.prototype.toString;t.exports=function r(e){var t=n.call(e),r="[object Arguments]"===t;return r||(r="[object Array]"!==t&&null!==e&&"object"==typeof e&&"number"==typeof e.length&&e.length>=0&&"[object Function]"===n.call(e.callee)),r}},{}],100:[function(e,t){!function(){"use strict";var n,r=Object.prototype.hasOwnProperty,i=Object.prototype.toString,o=e("./foreach"),s=e("./isArguments"),a=!{toString:null}.propertyIsEnumerable("toString"),u=function(){}.propertyIsEnumerable("prototype"),c=["toString","toLocaleString","valueOf","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","constructor"];n=function(e){var t=null!==e&&"object"==typeof e,n="[object Function]"===i.call(e),l=s(e),f=[];if(!t&&!n&&!l)throw new TypeError("Object.keys called on a non-object");if(l)o(e,function(e){f.push(e)});else{var d,h=u&&n;for(d in e)h&&"prototype"===d||!r.call(e,d)||f.push(d)}if(a){var p=e.constructor,g=p&&p.prototype===e;o(c,function(t){g&&"constructor"===t||!r.call(e,t)||f.push(t)})}return f},t.exports=n}()},{"./foreach":97,"./isArguments":99}],101:[function(e,t){"use strict";function n(e){return null===e?String(e):"object"==typeof e||"function"==typeof e?a[f.call(e)]||"object":typeof e}function r(e){return null!==e&&e===e.window}function i(e){if(!e||"object"!==n(e)||e.nodeType||r(e))return!1;try{if(e.constructor&&!d.call(e,"constructor")&&!d.call(e.constructor.prototype,"isPrototypeOf"))return!1}catch(t){return!1}var i;for(i in e);return void 0===i||d.call(e,i)}function o(e){return"function"===n(e)}function s(){var e,t,n,r,a,u,c=arguments[0]||{},l=1,f=arguments.length,d=!1;for("boolean"==typeof c&&(d=c,c=arguments[1]||{},l=2),"object"==typeof c||o(c)||(c={}),f===l&&(c=this,--l);f>l;l++)if(null!=(e=arguments[l]))for(t in e)if(!(t in Object.prototype)){if(n=c[t],r=e[t],c===r)continue;d&&r&&(i(r)||(a=h(r)))?(a?(a=!1,u=n&&h(n)?n:[]):u=n&&i(n)?n:{},c[t]=s(d,u,r)):void 0!==r&&(h(e)&&o(r)||(c[t]=r))}return c}for(var a={},u=["Boolean","Number","String","Function","Array","Date","RegExp","Object","Error"],c=0;c<u.length;c++){var l=u[c];a["[object "+l+"]"]=l.toLowerCase()}var f=a.toString,d=a.hasOwnProperty,h=Array.isArray||function(e){return"array"===n(e)};t.exports=s},{}],102:[function(e,t,n){!function(e){if("object"==typeof n)t.exports=e();else if("function"==typeof define&&define.amd)define(e);else{var r;try{r=window}catch(i){r=self}r.SparkMD5=e()}}(function(){"use strict";var e=function(e,t){return e+t&4294967295},t=function(t,n,r,i,o,s){return n=e(e(n,t),e(i,s)),e(n<<o|n>>>32-o,r)},n=function(e,n,r,i,o,s,a){return t(n&r|~n&i,e,n,o,s,a)},r=function(e,n,r,i,o,s,a){return t(n&i|r&~i,e,n,o,s,a)},i=function(e,n,r,i,o,s,a){return t(n^r^i,e,n,o,s,a)},o=function(e,n,r,i,o,s,a){return t(r^(n|~i),e,n,o,s,a)},s=function(t,s){var a=t[0],u=t[1],c=t[2],l=t[3];a=n(a,u,c,l,s[0],7,-680876936),l=n(l,a,u,c,s[1],12,-389564586),c=n(c,l,a,u,s[2],17,606105819),u=n(u,c,l,a,s[3],22,-1044525330),a=n(a,u,c,l,s[4],7,-176418897),l=n(l,a,u,c,s[5],12,1200080426),c=n(c,l,a,u,s[6],17,-1473231341),u=n(u,c,l,a,s[7],22,-45705983),a=n(a,u,c,l,s[8],7,1770035416),l=n(l,a,u,c,s[9],12,-1958414417),c=n(c,l,a,u,s[10],17,-42063),u=n(u,c,l,a,s[11],22,-1990404162),a=n(a,u,c,l,s[12],7,1804603682),l=n(l,a,u,c,s[13],12,-40341101),c=n(c,l,a,u,s[14],17,-1502002290),u=n(u,c,l,a,s[15],22,1236535329),a=r(a,u,c,l,s[1],5,-165796510),l=r(l,a,u,c,s[6],9,-1069501632),c=r(c,l,a,u,s[11],14,643717713),u=r(u,c,l,a,s[0],20,-373897302),a=r(a,u,c,l,s[5],5,-701558691),l=r(l,a,u,c,s[10],9,38016083),c=r(c,l,a,u,s[15],14,-660478335),u=r(u,c,l,a,s[4],20,-405537848),a=r(a,u,c,l,s[9],5,568446438),l=r(l,a,u,c,s[14],9,-1019803690),c=r(c,l,a,u,s[3],14,-187363961),u=r(u,c,l,a,s[8],20,1163531501),a=r(a,u,c,l,s[13],5,-1444681467),l=r(l,a,u,c,s[2],9,-51403784),c=r(c,l,a,u,s[7],14,1735328473),u=r(u,c,l,a,s[12],20,-1926607734),a=i(a,u,c,l,s[5],4,-378558),l=i(l,a,u,c,s[8],11,-2022574463),c=i(c,l,a,u,s[11],16,1839030562),u=i(u,c,l,a,s[14],23,-35309556),a=i(a,u,c,l,s[1],4,-1530992060),l=i(l,a,u,c,s[4],11,1272893353),c=i(c,l,a,u,s[7],16,-155497632),u=i(u,c,l,a,s[10],23,-1094730640),a=i(a,u,c,l,s[13],4,681279174),l=i(l,a,u,c,s[0],11,-358537222),c=i(c,l,a,u,s[3],16,-722521979),u=i(u,c,l,a,s[6],23,76029189),a=i(a,u,c,l,s[9],4,-640364487),l=i(l,a,u,c,s[12],11,-421815835),c=i(c,l,a,u,s[15],16,530742520),u=i(u,c,l,a,s[2],23,-995338651),a=o(a,u,c,l,s[0],6,-198630844),l=o(l,a,u,c,s[7],10,1126891415),c=o(c,l,a,u,s[14],15,-1416354905),u=o(u,c,l,a,s[5],21,-57434055),a=o(a,u,c,l,s[12],6,1700485571),l=o(l,a,u,c,s[3],10,-1894986606),c=o(c,l,a,u,s[10],15,-1051523),u=o(u,c,l,a,s[1],21,-2054922799),a=o(a,u,c,l,s[8],6,1873313359),l=o(l,a,u,c,s[15],10,-30611744),c=o(c,l,a,u,s[6],15,-1560198380),u=o(u,c,l,a,s[13],21,1309151649),a=o(a,u,c,l,s[4],6,-145523070),l=o(l,a,u,c,s[11],10,-1120210379),c=o(c,l,a,u,s[2],15,718787259),u=o(u,c,l,a,s[9],21,-343485551),t[0]=e(a,t[0]),t[1]=e(u,t[1]),t[2]=e(c,t[2]),t[3]=e(l,t[3])},a=function(e){var t,n=[];for(t=0;64>t;t+=4)n[t>>2]=e.charCodeAt(t)+(e.charCodeAt(t+1)<<8)+(e.charCodeAt(t+2)<<16)+(e.charCodeAt(t+3)<<24);return n},u=function(e){var t,n=[];for(t=0;64>t;t+=4)n[t>>2]=e[t]+(e[t+1]<<8)+(e[t+2]<<16)+(e[t+3]<<24);return n},c=function(e){var t,n,r,i,o,u,c=e.length,l=[1732584193,-271733879,-1732584194,271733878];for(t=64;c>=t;t+=64)s(l,a(e.substring(t-64,t)));for(e=e.substring(t-64),n=e.length,r=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],t=0;n>t;t+=1)r[t>>2]|=e.charCodeAt(t)<<(t%4<<3);if(r[t>>2]|=128<<(t%4<<3),t>55)for(s(l,r),t=0;16>t;t+=1)r[t]=0;return i=8*c,i=i.toString(16).match(/(.*?)(.{0,8})$/),o=parseInt(i[2],16),u=parseInt(i[1],16)||0,r[14]=o,r[15]=u,s(l,r),l},l=function(e){var t,n,r,i,o,a,c=e.length,l=[1732584193,-271733879,-1732584194,271733878];for(t=64;c>=t;t+=64)s(l,u(e.subarray(t-64,t)));for(e=c>t-64?e.subarray(t-64):new Uint8Array(0),n=e.length,r=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],t=0;n>t;t+=1)r[t>>2]|=e[t]<<(t%4<<3);if(r[t>>2]|=128<<(t%4<<3),t>55)for(s(l,r),t=0;16>t;t+=1)r[t]=0;return i=8*c,i=i.toString(16).match(/(.*?)(.{0,8})$/),o=parseInt(i[2],16),a=parseInt(i[1],16)||0,r[14]=o,r[15]=a,s(l,r),l},f=["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"],d=function(e){var t,n="";for(t=0;4>t;t+=1)n+=f[e>>8*t+4&15]+f[e>>8*t&15];return n},h=function(e){var t;for(t=0;t<e.length;t+=1)e[t]=d(e[t]);return e.join("")},p=function(e){return h(c(e))},g=function(){this.reset()};return"5d41402abc4b2a76b9719d911017c592"!==p("hello")&&(e=function(e,t){var n=(65535&e)+(65535&t),r=(e>>16)+(t>>16)+(n>>16);return r<<16|65535&n}),g.prototype.append=function(e){return/[\u0080-\uFFFF]/.test(e)&&(e=unescape(encodeURIComponent(e))),this.appendBinary(e),this},g.prototype.appendBinary=function(e){this._buff+=e,this._length+=e.length;var t,n=this._buff.length;for(t=64;n>=t;t+=64)s(this._state,a(this._buff.substring(t-64,t)));return this._buff=this._buff.substr(t-64),this},g.prototype.end=function(e){var t,n,r=this._buff,i=r.length,o=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];for(t=0;i>t;t+=1)o[t>>2]|=r.charCodeAt(t)<<(t%4<<3);return this._finish(o,i),n=e?this._state:h(this._state),this.reset(),n},g.prototype._finish=function(e,t){var n,r,i,o=t;if(e[o>>2]|=128<<(o%4<<3),o>55)for(s(this._state,e),o=0;16>o;o+=1)e[o]=0;n=8*this._length,n=n.toString(16).match(/(.*?)(.{0,8})$/),r=parseInt(n[2],16),i=parseInt(n[1],16)||0,e[14]=r,e[15]=i,s(this._state,e)},g.prototype.reset=function(){return this._buff="",this._length=0,this._state=[1732584193,-271733879,-1732584194,271733878],this},g.prototype.destroy=function(){delete this._state,delete this._buff,delete this._length},g.hash=function(e,t){/[\u0080-\uFFFF]/.test(e)&&(e=unescape(encodeURIComponent(e)));var n=c(e);return t?n:h(n)},g.hashBinary=function(e,t){var n=c(e);return t?n:h(n)},g.ArrayBuffer=function(){this.reset()},g.ArrayBuffer.prototype.append=function(e){var t,n=this._concatArrayBuffer(this._buff,e),r=n.length;for(this._length+=e.byteLength,t=64;r>=t;t+=64)s(this._state,u(n.subarray(t-64,t)));return this._buff=r>t-64?n.subarray(t-64):new Uint8Array(0),this},g.ArrayBuffer.prototype.end=function(e){var t,n,r=this._buff,i=r.length,o=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];for(t=0;i>t;t+=1)o[t>>2]|=r[t]<<(t%4<<3);return this._finish(o,i),n=e?this._state:h(this._state),this.reset(),n},g.ArrayBuffer.prototype._finish=g.prototype._finish,g.ArrayBuffer.prototype.reset=function(){return this._buff=new Uint8Array(0),this._length=0,this._state=[1732584193,-271733879,-1732584194,271733878],this},g.ArrayBuffer.prototype.destroy=g.prototype.destroy,g.ArrayBuffer.prototype._concatArrayBuffer=function(e,t){var n=e.length,r=new Uint8Array(n+t.byteLength);return r.set(e),r.set(new Uint8Array(t),n),r},g.ArrayBuffer.hash=function(e,t){var n=l(new Uint8Array(e));return t?n:h(n)},g})},{}],103:[function(e,t,n){arguments[4][61][0].apply(n,arguments)},{"./_stream_readable":104,"./_stream_writable":106,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"core-util-is":107,inherits:33}],104:[function(e,t){t.exports=e(63)},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,"core-util-is":107,events:18,inherits:33,isarray:108,stream:24,"string_decoder/":109}],105:[function(e,t,n){arguments[4][64][0].apply(n,arguments)},{"./_stream_duplex":103,"core-util-is":107,inherits:33}],106:[function(e,t,n){arguments[4][65][0].apply(n,arguments)},{"./_stream_duplex":103,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,"core-util-is":107,inherits:33,stream:24}],107:[function(e,t){t.exports=e(66)},{buffer:20}],108:[function(e,t){t.exports=e(67)},{}],109:[function(e,t){t.exports=e(68)},{buffer:20}],110:[function(e,t){t.exports=e("./lib/_stream_transform.js")},{"./lib/_stream_transform.js":105}],111:[function(e,t){t.exports=e(40)},{}],112:[function(e,t,n){arguments[4][41][0].apply(n,arguments)},{"./has-keys":111,"object-keys":114}],113:[function(e,t){t.exports=e(97)},{}],114:[function(e,t,n){arguments[4][42][0].apply(n,arguments)},{"./shim":116}],115:[function(e,t){t.exports=e(99)},{}],116:[function(e,t){t.exports=e(100)},{"./foreach":113,"./isArguments":115}],117:[function(e,t){function n(e,t,n){n(null,e)}function r(e){return function(t,r,i){return"function"==typeof t&&(i=r,r=t,t={}),"function"!=typeof r&&(r=n),"function"!=typeof i&&(i=null),e(t,r,i)}}var i=e("readable-stream/transform"),o=e("util").inherits,s=e("xtend");t.exports=r(function(e,t,n){var r=new i(e);return r._transform=t,n&&(r._flush=n),r}),t.exports.ctor=r(function(e,t,n){function r(t){return this instanceof r?(this.options=s(e,t),void i.call(this,this.options)):new r(t)}return o(r,i),r.prototype._transform=t,n&&(r.prototype._flush=n),r}),t.exports.obj=r(function(e,t,n){var r=new i(s({objectMode:!0},e));return r._transform=t,n&&(r._flush=n),r})},{"readable-stream/transform":110,util:32,xtend:112}]},{},[11]);
\ No newline at end of file
diff --git a/dist/pouchdb.memory.js b/dist/pouchdb.memory.js
new file mode 100644
index 0000000..c413725
--- /dev/null
+++ b/dist/pouchdb.memory.js
@@ -0,0 +1,14519 @@
+// PouchDB in-memory plugin 3.0.1
+// Based on MemDOWN: https://github.com/rvagg/memdown
+//
+// (c) 2012-2014 Dale Harvey and the PouchDB team
+// PouchDB may be freely distributed under the Apache license, version 2.0.
+// For all details and documentation:
+// http://pouchdb.com
+require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+(function (process,global,Buffer){
+'use strict';
+
+var levelup = require('levelup');
+var originalLeveldown = require('leveldown');
+var sublevel = require('level-sublevel');
+var through = require('through2').obj;
+
+var errors = require('../deps/errors');
+var merge = require('../merge');
+var utils = require('../utils');
+var migrate = require('../deps/migrate');
+
+var DOC_STORE = 'document-store';
+var BY_SEQ_STORE = 'by-sequence';
+var ATTACHMENT_STORE = 'attach-store';
+var BINARY_STORE = 'attach-binary-store';
+var LOCAL_STORE = 'local-store';
+var META_STORE = 'meta-store';
+var BATCH_SIZE = 50;
+
+// leveldb barks if we try to open a db multiple times
+// so we cache opened connections here for initstore()
+var dbStores = new utils.Map();
+
+// store the value of update_seq in the by-sequence store the key name will
+// never conflict, since the keys in the by-sequence store are integers
+var UPDATE_SEQ_KEY = '_local_last_update_seq';
+var DOC_COUNT_KEY = '_local_doc_count';
+var UUID_KEY = '_local_uuid';
+
+function LevelPouch(opts, callback) {
+ opts = utils.clone(opts);
+ var api = this;
+ var instanceId;
+ var stores = {};
+ var db;
+ var name = opts.name;
+ if (typeof opts.createIfMissing === 'undefined') {
+ opts.createIfMissing = true;
+ }
+
+ var leveldown = opts.db || originalLeveldown;
+ if (typeof leveldown.destroy !== 'function') {
+ leveldown.destroy = function (name, cb) { cb(); };
+ }
+ var dbStore;
+ if (dbStores.has(leveldown.name)) {
+ dbStore = dbStores.get(leveldown.name);
+ } else {
+ dbStore = new utils.Map();
+ dbStores.set(leveldown.name, dbStore);
+ }
+ if (dbStore.has(name)) {
+ db = dbStore.get(name);
+ afterDBCreated();
+ } else {
+ dbStore.set(name, sublevel(levelup(name, opts, function (err) {
+ if (err) {
+ dbStore["delete"](name);
+ return callback(err);
+ }
+ db = dbStore.get(name);
+ db._locks = db._locks || new utils.Set();
+ db._docCountQueue = {
+ queue : [],
+ running : false,
+ docCount : -1
+ };
+ if (opts.db || opts.noMigrate) {
+ afterDBCreated();
+ } else {
+ migrate.toSublevel(name, db, afterDBCreated);
+ }
+ })));
+ }
+
+ function afterDBCreated() {
+ stores.docStore = db.sublevel(DOC_STORE, {valueEncoding: 'json'});
+ stores.bySeqStore = db.sublevel(BY_SEQ_STORE, {valueEncoding: 'json'});
+ stores.attachmentStore =
+ db.sublevel(ATTACHMENT_STORE, {valueEncoding: 'json'});
+ stores.binaryStore = db.sublevel(BINARY_STORE, {valueEncoding: 'binary'});
+ stores.localStore = db.sublevel(LOCAL_STORE, {valueEncoding: 'json'});
+ stores.metaStore = db.sublevel(META_STORE, {valueEncoding: 'json'});
+ migrate.localAndMetaStores(db, stores, function () {
+ stores.metaStore.get(UPDATE_SEQ_KEY, function (err, value) {
+ if (typeof db._updateSeq === 'undefined') {
+ db._updateSeq = value || 0;
+ }
+ stores.metaStore.get(DOC_COUNT_KEY, function (err, value) {
+ db._docCountQueue.docCount = !err ? value : 0;
+ countDocs(function (err) { // notify queue that the docCount is ready
+ if (err) {
+ api.emit('error', err);
+ }
+ stores.metaStore.get(UUID_KEY, function (err, value) {
+ instanceId = !err ? value : utils.uuid();
+ stores.metaStore.put(UUID_KEY, instanceId, function (err, value) {
+ process.nextTick(function () {
+ callback(null, api);
+ });
+ });
+ });
+ });
+ });
+ });
+ });
+ }
+
+ function countDocs(callback) {
+ if (db._docCountQueue.running || !db._docCountQueue.queue.length ||
+ db._docCountQueue.docCount === -1) {
+ return incrementDocCount(0, callback); // wait for fresh data
+ }
+ return db._docCountQueue.docCount; // use cached value
+ }
+
+ function applyNextDocCountDelta() {
+ if (db._docCountQueue.running || !db._docCountQueue.queue.length ||
+ db._docCountQueue.docCount === -1) {
+ return;
+ }
+ db._docCountQueue.running = true;
+ var item = db._docCountQueue.queue.shift();
+ if (db.isClosed()) {
+ return item.callback(new Error('database is closed'));
+ }
+ stores.metaStore.get(DOC_COUNT_KEY, function (err, docCount) {
+ docCount = !err ? docCount : 0;
+
+ function complete(err) {
+ db._docCountQueue.docCount = docCount;
+ item.callback(err, docCount);
+ db._docCountQueue.running = false;
+ applyNextDocCountDelta();
+ }
+
+ if (item.delta === 0) {
+ complete();
+ } else {
+ stores.metaStore.put(DOC_COUNT_KEY, docCount + item.delta, complete);
+ }
+ });
+ }
+
+ function incrementDocCount(delta, callback) {
+ db._docCountQueue.queue.push({delta : delta, callback : callback});
+ applyNextDocCountDelta();
+ }
+
+ api.type = function () {
+ return 'leveldb';
+ };
+
+ api._id = function (callback) {
+ callback(null, instanceId);
+ };
+
+ api._info = function (callback) {
+ countDocs(function (err, docCount) {
+ if (err) {
+ return callback(err);
+ }
+ stores.metaStore.get(UPDATE_SEQ_KEY, function (err, otherUpdateSeq) {
+ if (err) {
+ otherUpdateSeq = db._updateSeq;
+ }
+
+ return callback(null, {
+ doc_count: docCount,
+ update_seq: otherUpdateSeq
+ });
+ });
+ });
+ };
+
+ function formatSeq(n) {
+ return ('0000000000000000' + n).slice(-16);
+ }
+
+ function parseSeq(s) {
+ return parseInt(s, 10);
+ }
+
+ function makeDoc(rawDoc, callback) {
+ var doc = rawDoc.data;
+ doc._id = rawDoc.metadata.id;
+ if ('_rev' in doc) {
+ if (doc._rev !== rawDoc.metadata.rev) {
+ return callback(new Error('wrong doc returned'));
+ }
+ } else {
+ // we didn't always store rev
+ doc._rev = rawDoc.metadata.rev;
+ }
+ callback(null, {doc: doc, metadata: rawDoc.metadata});
+ }
+
+ api._get = function (id, opts, callback) {
+ opts = utils.clone(opts);
+ var docChanged = [];
+
+ function didDocChange(doc) {
+ docChanged.push(doc);
+ }
+
+ db.on('pouchdb-id-' + id, didDocChange);
+
+ stores.docStore.get(id, function (err, metadata) {
+ db.removeListener('pouchdb-id-' + id, didDocChange);
+
+ if (err || !metadata) {
+ return callback(errors.MISSING_DOC);
+ }
+
+ if (utils.isDeleted(metadata) && !opts.rev) {
+ return callback(errors.error(errors.MISSING_DOC, "deleted"));
+ }
+
+ var updated;
+
+ function ifUpdate(doc) {
+ updated = doc;
+ }
+
+ var rev = merge.winningRev(metadata);
+ rev = opts.rev ? opts.rev : rev;
+
+ var seq = metadata.rev_map[rev];
+
+ var anyChanged = docChanged.filter(function (doc) {
+ return doc.metadata.seq === seq;
+ });
+
+ if (anyChanged.length) {
+ return makeDoc(anyChanged.pop(), callback);
+ }
+
+ db.on('pouchdb-' + seq, ifUpdate);
+
+ stores.bySeqStore.get(formatSeq(seq), function (err, doc) {
+ db.removeListener('pouchdb-' + seq, ifUpdate);
+ if (updated) {
+ return makeDoc(updated, callback);
+
+ }
+
+ if (!doc) {
+ return callback(errors.MISSING_DOC);
+ }
+ if ('_id' in doc && doc._id !== metadata.id) {
+ // this failing implies something very wrong
+ return callback(new Error('wrong doc returned'));
+ }
+ doc._id = metadata.id;
+ if ('_rev' in doc) {
+ if (doc._rev !== rev) {
+ // this failing implies something very wrong
+ return callback(new Error('wrong doc returned'));
+ }
+ } else {
+ // we didn't always store this
+ doc._rev = rev;
+ }
+ return callback(null, {doc: doc, metadata: metadata});
+ });
+ });
+ };
+
+ // not technically part of the spec, but if putAttachment has its own
+ // method...
+ api._getAttachment = function (attachment, opts, callback) {
+ var digest = attachment.digest;
+
+ stores.binaryStore.get(digest, function (err, attach) {
+ var data;
+
+ if (err && err.name === 'NotFoundError') {
+ // Empty attachment
+ data = opts.encode ? '' : process.browser ?
+ utils.createBlob([''], {type: attachment.content_type}) :
+ new Buffer('');
+ return callback(null, data);
+ }
+
+ if (err) {
+ return callback(err);
+ }
+
+ if (process.browser) {
+ if (opts.encode) {
+ data = utils.btoa(global.unescape(attach));
+ } else {
+ data = utils.createBlob([utils.fixBinary(global.unescape(attach))],
+ {type: attachment.content_type});
+ }
+ } else {
+ data = opts.encode ? utils.btoa(attach) : attach;
+ }
+ callback(null, data);
+ });
+ };
+ api.lock = function (id) {
+ if (db._locks.has(id)) {
+ return false;
+ } else {
+ db._locks.add(id);
+ return true;
+ }
+ };
+
+ api.unlock = function (id) {
+ if (db._locks.has(id)) {
+ db._locks["delete"](id);
+ return true;
+ }
+ return false;
+ };
+
+ api._bulkDocs = function (req, opts, callback) {
+ var newEdits = opts.new_edits;
+ var results = new Array(req.docs.length);
+
+ // parse the docs and give each a sequence number
+ var userDocs = req.docs;
+ var info = userDocs.map(function (doc, i) {
+ if (doc._id && utils.isLocalId(doc._id)) {
+ return doc;
+ }
+ var newDoc = utils.parseDoc(doc, newEdits);
+ newDoc._bulk_seq = i;
+
+ if (newDoc.metadata && !newDoc.metadata.rev_map) {
+ newDoc.metadata.rev_map = {};
+ }
+
+ return newDoc;
+ });
+ var current = 0;
+ var infoErrors = info.filter(function (doc) {
+ return doc.error;
+ });
+
+ if (infoErrors.length) {
+ return callback(infoErrors[0]);
+ }
+ var inProgress = 0;
+ function processDocs() {
+ var index = current;
+ if (inProgress > BATCH_SIZE) {
+ return;
+ }
+ if (index >= info.length) {
+ if (inProgress === 0) {
+ return complete();
+ } else {
+ return;
+ }
+ }
+ var currentDoc = info[index];
+ current++;
+ inProgress++;
+ if (currentDoc._id && utils.isLocalId(currentDoc._id)) {
+ api[currentDoc._deleted ? '_removeLocal' : '_putLocal'](
+ currentDoc, function (err, resp) {
+ if (err) {
+ results[index] = err;
+ } else {
+ results[index] = {};
+ }
+ inProgress--;
+ processDocs();
+ });
+ return;
+ }
+ stores.docStore.get(currentDoc.metadata.id, function (err, oldDoc) {
+ if (!api.lock(currentDoc.metadata.id)) {
+ results[index] = makeErr(errors.REV_CONFLICT,
+ 'someobody else is accessing this');
+ inProgress--;
+ return processDocs();
+ }
+ if (err) {
+ if (err.name === 'NotFoundError') {
+ insertDoc(currentDoc, index, function () {
+ api.unlock(currentDoc.metadata.id);
+ inProgress--;
+ processDocs();
+ });
+ } else {
+ err.error = true;
+ results[index] = err;
+ api.unlock(currentDoc.metadata.id);
+ inProgress--;
+ processDocs();
+ }
+ } else {
+ updateDoc(oldDoc, currentDoc, index, function () {
+ api.unlock(currentDoc.metadata.id);
+ inProgress--;
+ processDocs();
+ });
+ }
+ });
+ if (newEdits) {
+ processDocs();
+ }
+ }
+
+ function insertDoc(doc, index, callback) {
+ // Can't insert new deleted documents
+ if ('was_delete' in opts && utils.isDeleted(doc.metadata)) {
+ results[index] = makeErr(errors.MISSING_DOC, doc._bulk_seq);
+ return callback();
+ }
+ writeDoc(doc, index, function (err) {
+ if (err) {
+ return callback(err);
+ }
+ if (utils.isDeleted(doc.metadata)) {
+ return callback();
+ }
+ incrementDocCount(1, callback);
+ });
+ }
+
+ function updateDoc(oldDoc, docInfo, index, callback) {
+ var merged =
+ merge.merge(oldDoc.rev_tree, docInfo.metadata.rev_tree[0], 1000);
+
+ var conflict = (utils.isDeleted(oldDoc) &&
+ utils.isDeleted(docInfo.metadata) &&
+ newEdits) ||
+ (!utils.isDeleted(oldDoc) &&
+ newEdits && merged.conflicts !== 'new_leaf');
+
+
+ if (conflict) {
+ results[index] = makeErr(errors.REV_CONFLICT, docInfo._bulk_seq);
+ return callback();
+ }
+ docInfo.metadata.rev_tree = merged.tree;
+ docInfo.metadata.rev_map = oldDoc.rev_map;
+ var delta = 0;
+ var oldDeleted = utils.isDeleted(oldDoc);
+ var newDeleted = utils.isDeleted(docInfo.metadata);
+ delta = (oldDeleted === newDeleted) ? 0 :
+ oldDeleted < newDeleted ? -1 : 1;
+ incrementDocCount(delta, function (err) {
+ if (err) {
+ return callback(err);
+ }
+ writeDoc(docInfo, index, callback);
+ });
+
+ }
+
+ function writeDoc(doc, index, callback2) {
+ var err = null;
+ var recv = 0;
+
+ doc.data._id = doc.metadata.id;
+ doc.data._rev = doc.metadata.rev;
+
+ if (utils.isDeleted(doc.metadata)) {
+ doc.data._deleted = true;
+ }
+
+ var attachments = doc.data._attachments ?
+ Object.keys(doc.data._attachments) :
+ [];
+
+ function collectResults(attachmentErr) {
+ if (!err) {
+ if (attachmentErr) {
+ err = attachmentErr;
+ callback2(err);
+ } else if (recv === attachments.length) {
+ finish();
+ }
+ }
+ }
+
+ function attachmentSaved(err) {
+ recv++;
+ collectResults(err);
+ }
+
+ function onMD5Load(doc, prefix, key, data, attachmentSaved) {
+ return function (result) {
+ saveAttachment(doc, prefix + result, key, data, attachmentSaved);
+ };
+ }
+
+ function onLoadEnd(doc, prefix, key, attachmentSaved) {
+ return function (e) {
+ var data = global.escape(
+ utils.arrayBufferToBinaryString(e.target.result));
+ utils.MD5(data).then(
+ onMD5Load(doc, prefix, key, data, attachmentSaved)
+ );
+ };
+ }
+
+ for (var i = 0; i < attachments.length; i++) {
+ var key = attachments[i];
+
+ if (doc.data._attachments[key].stub) {
+ recv++;
+ collectResults();
+ continue;
+ }
+ var att = doc.data._attachments[key];
+ var data;
+ var prefix;
+ if (typeof att.data === 'string') {
+ try {
+ data = utils.atob(att.data);
+ if (process.browser) {
+ data = global.escape(data);
+ }
+ } catch (e) {
+ callback(utils.extend({}, errors.BAD_ARG,
+ {reason: "Attachments need to be base64 encoded"}));
+ return;
+ }
+ prefix = process.browser ? 'md5-' : '';
+ } else if (!process.browser) {
+ data = att.data;
+ prefix = '';
+ } else { // browser
+ var reader = new FileReader();
+ reader.onloadend = onLoadEnd(doc, 'md5-', key, attachmentSaved);
+ reader.readAsArrayBuffer(att.data);
+ return;
+ }
+ utils.MD5(data).then(
+ onMD5Load(doc, prefix, key, data, attachmentSaved)
+ );
+ }
+
+ function finish() {
+ var seq = doc.metadata.rev_map[doc.metadata.rev];
+ if (!seq) {
+ // check that there aren't any existing revisions with the same
+ // reivision id, else we shouldn't increment updateSeq
+ seq = ++db._updateSeq;
+ }
+ doc.metadata.rev_map[doc.metadata.rev] = doc.metadata.seq = seq;
+ var seqKey = formatSeq(seq);
+ db.emit('pouchdb-id-' + doc.metadata.id, doc);
+ db.emit('pouchdb-' + seqKey, doc);
+ db.batch([{
+ key: seqKey,
+ value: doc.data,
+ prefix: stores.bySeqStore,
+ type: 'put',
+ valueEncoding: 'json'
+ }, {
+ key: doc.metadata.id,
+ value: doc.metadata,
+ prefix: stores.docStore,
+ type: 'put',
+ valueEncoding: 'json'
+ }], function (err) {
+ if (!err) {
+ db.emit('pouchdb-id-' + doc.metadata.id, doc);
+ db.emit('pouchdb-' + seqKey, doc);
+ }
+ return stores.metaStore.put(UPDATE_SEQ_KEY, db._updateSeq,
+ function (err) {
+ if (err) {
+ results[index] = err;
+ } else {
+ results[index] = doc;
+ }
+ return callback2();
+ });
+ });
+ }
+
+ if (!attachments.length) {
+ finish();
+ }
+ }
+
+ function saveAttachment(docInfo, digest, key, data, callback) {
+ delete docInfo.data._attachments[key].data;
+ docInfo.data._attachments[key].digest = digest;
+ stores.attachmentStore.get(digest, function (err, oldAtt) {
+ if (err && err.name !== 'NotFoundError') {
+ return callback(err);
+ }
+
+ var ref = [docInfo.metadata.id, docInfo.metadata.rev].join('@');
+ var newAtt = {};
+
+ if (oldAtt) {
+ if (oldAtt.refs) {
+ // only update references if this attachment already has them
+ // since we cannot migrate old style attachments here without
+ // doing a full db scan for references
+ newAtt.refs = oldAtt.refs;
+ newAtt.refs[ref] = true;
+ }
+ } else {
+ newAtt.refs = {};
+ newAtt.refs[ref] = true;
+ }
+
+ stores.attachmentStore.put(digest, newAtt, function (err) {
+ // do not try to store empty attachments
+ if (data.length === 0) {
+ return callback(err);
+ }
+ // doing this in batch causes a test to fail, wtf?
+ stores.binaryStore.put(digest, data, function (err) {
+ callback(err);
+ });
+ });
+ });
+ }
+
+ function complete() {
+ results.sort(function (a, b) { return a._bulk_seq - b._bulk_seq; });
+ var aresults = results.map(function (result) {
+ if (result._bulk_seq) {
+ delete result._bulk_seq;
+ } else if (!Object.keys(result).length) {
+ return {
+ ok: true
+ };
+ }
+ if (result.error) {
+ return result;
+ }
+
+ var metadata = result.metadata;
+ var rev = merge.winningRev(metadata);
+
+ return {
+ ok: true,
+ id: metadata.id,
+ rev: rev
+ };
+ });
+ LevelPouch.Changes.notify(name);
+ process.nextTick(function () { callback(null, aresults); });
+ }
+
+ function makeErr(err, seq) {
+ err._bulk_seq = seq;
+ return err;
+ }
+
+ processDocs();
+ };
+
+ api._allDocs = function (opts, callback) {
+ opts = utils.clone(opts);
+ countDocs(function (err, docCount) {
+ if (err) {
+ return callback(err);
+ }
+ var readstreamOpts = {};
+ var skip = opts.skip || 0;
+ if (opts.startkey) {
+ readstreamOpts.start = opts.startkey;
+ }
+ if (opts.endkey) {
+ readstreamOpts.end = opts.endkey;
+ }
+ if (opts.key) {
+ readstreamOpts.start = readstreamOpts.end = opts.key;
+ }
+ if (opts.descending) {
+ readstreamOpts.reverse = true;
+ // switch start and ends
+ var tmp = readstreamOpts.start;
+ readstreamOpts.start = readstreamOpts.end;
+ readstreamOpts.end = tmp;
+ }
+ var limit;
+ if (typeof opts.limit === 'number') {
+ limit = opts.limit;
+ } else {
+ limit = -1;
+ }
+ if (limit === 0 ||
+ ('start' in readstreamOpts && 'end' in readstreamOpts &&
+ readstreamOpts.start > readstreamOpts.end)) {
+ // should return 0 results when start is greater than end.
+ // normally level would "fix" this for us by reversing the order,
+ // so short-circuit instead
+ return callback(null, {
+ total_rows: docCount,
+ offset: opts.skip,
+ rows: []
+ });
+ }
+ var results = [];
+ var docstream = stores.docStore.readStream(readstreamOpts);
+
+ var throughStream = through(function (entry, _, next) {
+ if (!utils.isDeleted(entry.value)) {
+ if (skip-- > 0) {
+ next();
+ return;
+ } else if (limit-- === 0) {
+ docstream.unpipe();
+ docstream.destroy();
+ next();
+ return;
+ }
+ } else if (opts.deleted !== 'ok') {
+ next();
+ return;
+ }
+ function allDocsInner(metadata, data) {
+ var doc = {
+ id: metadata.id,
+ key: metadata.id,
+ value: {
+ rev: merge.winningRev(metadata)
+ }
+ };
+ if (opts.include_docs) {
+ doc.doc = data;
+ doc.doc._rev = doc.value.rev;
+ if (opts.conflicts) {
+ doc.doc._conflicts = merge.collectConflicts(metadata);
+ }
+ for (var att in doc.doc._attachments) {
+ if (doc.doc._attachments.hasOwnProperty(att)) {
+ doc.doc._attachments[att].stub = true;
+ }
+ }
+ }
+ if (opts.inclusive_end === false && metadata.id === opts.endkey) {
+ return next();
+ } else if (utils.isDeleted(metadata)) {
+ if (opts.deleted === 'ok') {
+ doc.value.deleted = true;
+ doc.doc = null;
+ } else {
+ return next();
+ }
+ }
+ results.push(doc);
+ next();
+ }
+ var metadata = entry.value;
+ if (opts.include_docs) {
+ var seq = metadata.rev_map[merge.winningRev(metadata)];
+ stores.bySeqStore.get(formatSeq(seq), function (err, data) {
+ allDocsInner(metadata, data);
+ });
+ }
+ else {
+ allDocsInner(metadata);
+ }
+ }, function (next) {
+ callback(null, {
+ total_rows: docCount,
+ offset: opts.skip,
+ rows: results
+ });
+ next();
+ }).on('unpipe', function () {
+ throughStream.end();
+ });
+
+ docstream.on('error', callback);
+
+ docstream.pipe(throughStream);
+ });
+ };
+
+ api._changes = function (opts) {
+ opts = utils.clone(opts);
+
+ if (opts.continuous) {
+ var id = name + ':' + utils.uuid();
+ LevelPouch.Changes.addListener(name, id, api, opts);
+ LevelPouch.Changes.notify(name);
+ return {
+ cancel: function () {
+ LevelPouch.Changes.removeListener(name, id);
+ }
+ };
+ }
+
+ var descending = opts.descending;
+ var results = [];
+ var last_seq = 0;
+ var called = 0;
+ var streamOpts = {
+ reverse: descending
+ };
+ var limit;
+ if ('limit' in opts && opts.limit > 0) {
+ limit = opts.limit;
+ }
+ if (!streamOpts.reverse) {
+ streamOpts.start = formatSeq(opts.since ? opts.since + 1 : 0);
+ }
+ var filter = utils.filterChange(opts);
+ var returnDocs;
+ if ('returnDocs' in opts) {
+ returnDocs = opts.returnDocs;
+ } else {
+ returnDocs = true;
+ }
+
+ function complete() {
+ opts.done = true;
+ if (returnDocs && opts.limit) {
+ if (opts.limit < results.length) {
+ results.length = opts.limit;
+ }
+ }
+ changeStream.unpipe(throughStream);
+ changeStream.destroy();
+ if (!opts.continuous && !opts.cancelled) {
+ opts.complete(null, {results: results, last_seq: last_seq});
+ }
+ }
+ var changeStream = stores.bySeqStore.readStream(streamOpts);
+ var throughStream = through(function (data, _, next) {
+ if (limit && called >= limit) {
+ complete();
+ return next();
+ }
+ if (opts.cancelled || opts.done) {
+ return next();
+ }
+
+ stores.docStore.get(data.value._id, function (err, metadata) {
+ if (opts.cancelled || opts.done || db.isClosed() ||
+ utils.isLocalId(metadata.id)) {
+ return next();
+ }
+ var doc = data.value;
+ doc._rev = merge.winningRev(metadata);
+ var change = opts.processChange(doc, metadata, opts);
+ change.seq = metadata.seq;
+
+ if (last_seq < metadata.seq) {
+ last_seq = metadata.seq;
+ }
+
+ // Ensure duplicated dont overwrite winning rev
+ if (parseSeq(data.key) === metadata.rev_map[change.doc._rev] &&
+ filter(change)) {
+ called++;
+
+ utils.call(opts.onChange, change);
+
+ if (returnDocs) {
+ results.push(change);
+ }
+ }
+ next();
+ });
+ }, function (next) {
+ if (opts.cancelled) {
+ return next();
+ }
+ if (returnDocs && opts.limit) {
+ if (opts.limit < results.length) {
+ results.length = opts.limit;
+ }
+ }
+
+ next();
+ }).on('unpipe', function () {
+ throughStream.end();
+ complete();
+ });
+ changeStream.pipe(throughStream);
+ return {
+ cancel: function () {
+ opts.cancelled = true;
+ complete();
+ }
+ };
+ };
+
+ api._close = function (callback) {
+ if (db.isClosed()) {
+ return callback(errors.NOT_OPEN);
+ }
+ db.close(function (err) {
+ if (err) {
+ callback(err);
+ } else {
+ dbStore["delete"](name);
+ callback();
+ }
+ });
+ };
+
+ api._getRevisionTree = function (docId, callback) {
+ stores.docStore.get(docId, function (err, metadata) {
+ if (err) {
+ callback(errors.MISSING_DOC);
+ } else {
+ callback(null, metadata.rev_tree);
+ }
+ });
+ };
+
+ api._doCompaction = function (docId, rev_tree, revs, callback) {
+ stores.docStore.get(docId, function (err, metadata) {
+ if (err) {
+ return callback(err);
+ }
+ var seqs = metadata.rev_map; // map from rev to seq
+ metadata.rev_tree = rev_tree;
+ if (!revs.length) {
+ callback();
+ }
+ var batch = [];
+ batch.push({
+ key: metadata.id,
+ value: metadata,
+ type: 'put',
+ valueEncoding: 'json',
+ prefix: stores.docStore
+ });
+ revs.forEach(function (rev) {
+ var seq = seqs[rev];
+ if (!seq) {
+ return;
+ }
+ batch.push({
+ key: formatSeq(seq),
+ type: 'del',
+ prefix: stores.bySeqStore
+ });
+ });
+ db.batch(batch, callback);
+ });
+ };
+
+ api._getLocal = function (id, callback) {
+ stores.localStore.get(id, function (err, doc) {
+ if (err) {
+ callback(errors.MISSING_DOC);
+ } else {
+ callback(null, doc);
+ }
+ });
+ };
+
+ api._putLocal = function (doc, callback) {
+ var oldRev = doc._rev;
+ var id = doc._id;
+ stores.localStore.get(id, function (err, resp) {
+ if (err) {
+ if (oldRev) {
+ return callback(errors.REV_CONFLICT);
+ }
+ }
+ if (resp && resp._rev !== oldRev) {
+ return callback(errors.REV_CONFLICT);
+ }
+ if (!oldRev) {
+ doc._rev = '0-0';
+ } else {
+ doc._rev = '0-' + (parseInt(oldRev.split('-')[1], 10) + 1);
+ }
+ stores.localStore.put(id, doc, function (err) {
+ if (err) {
+ return callback(err);
+ }
+ var ret = {ok: true, id: doc._id, rev: doc._rev};
+ callback(null, ret);
+ });
+ });
+ };
+
+ api._removeLocal = function (doc, callback) {
+ stores.localStore.get(doc._id, function (err, resp) {
+ if (err) {
+ return callback(err);
+ }
+ if (resp._rev !== doc._rev) {
+ return callback(errors.REV_CONFLICT);
+ }
+ stores.localStore.del(doc._id, function (err) {
+ if (err) {
+ return callback(err);
+ }
+ var ret = {ok: true, id: doc._id, rev: '0-0'};
+ callback(null, ret);
+ });
+ });
+ };
+}
+
+LevelPouch.valid = function () {
+ return process && !process.browser;
+};
+
+// close and delete open leveldb stores
+LevelPouch.destroy = utils.toPromise(function (name, opts, callback) {
+ opts = utils.clone(opts);
+
+ var leveldown = opts.db || originalLeveldown;
+ function callDestroy(name, cb) {
+ if (typeof leveldown.destroy === 'function') {
+ leveldown.destroy(name, cb);
+ } else {
+ process.nextTick(callback);
+ }
+ }
+
+ var dbStore;
+ if (dbStores.has(leveldown.name)) {
+ dbStore = dbStores.get(leveldown.name);
+ } else {
+ return callDestroy(name, callback);
+ }
+
+ if (dbStore.has(name)) {
+
+ LevelPouch.Changes.removeAllListeners(name);
+
+ dbStore.get(name).close(function () {
+ dbStore["delete"](name);
+ callDestroy(name, callback);
+ });
+ } else {
+ callDestroy(name, callback);
+ }
+});
+
+LevelPouch.use_prefix = false;
+
+LevelPouch.Changes = new utils.Changes();
+
+module.exports = LevelPouch;
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer)
+},{"../deps/errors":5,"../deps/migrate":"JpIkFB","../merge":8,"../utils":15,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"level-sublevel":35,"leveldown":"RQL87X","levelup":49,"through2":111}],2:[function(require,module,exports){
+"use strict";
+
+var createBlob = require('./blob.js');
+var errors = require('./errors');
+var utils = require("../utils");
+var hasUpload;
+
+function ajax(options, adapterCallback) {
+
+ var requestCompleted = false;
+ var callback = utils.getArguments(function (args) {
+ if (requestCompleted) {
+ return;
+ }
+ adapterCallback.apply(this, args);
+ requestCompleted = true;
+ });
+
+ if (typeof options === "function") {
+ callback = options;
+ options = {};
+ }
+
+ options = utils.clone(options);
+
+ var defaultOptions = {
+ method : "GET",
+ headers: {},
+ json: true,
+ processData: true,
+ timeout: 10000,
+ cache: false
+ };
+
+ options = utils.extend(true, defaultOptions, options);
+
+ // cache-buster, specifically designed to work around IE's aggressive caching
+ // see http://www.dashbay.com/2011/05/internet-explorer-caches-ajax/
+ if (options.method === 'GET' && !options.cache) {
+ var hasArgs = options.url.indexOf('?') !== -1;
+ options.url += (hasArgs ? '&' : '?') + '_nonce=' + utils.uuid(16);
+ }
+
+ function onSuccess(obj, resp, cb) {
+ if (!options.binary && !options.json && options.processData &&
+ typeof obj !== 'string') {
+ obj = JSON.stringify(obj);
+ } else if (!options.binary && options.json && typeof obj === 'string') {
+ try {
+ obj = JSON.parse(obj);
+ } catch (e) {
+ // Probably a malformed JSON from server
+ return cb(e);
+ }
+ }
+ if (Array.isArray(obj)) {
+ obj = obj.map(function (v) {
+ var obj;
+ if (v.ok) {
+ return v;
+ } else if (v.error && v.error === 'conflict') {
+ obj = errors.REV_CONFLICT;
+ obj.id = v.id;
+ return obj;
+ } else if (v.error && v.error === 'forbidden') {
+ obj = errors.FORBIDDEN;
+ obj.id = v.id;
+ obj.reason = v.reason;
+ return obj;
+ } else if (v.missing) {
+ obj = errors.MISSING_DOC;
+ obj.missing = v.missing;
+ return obj;
+ } else {
+ return v;
+ }
+ });
+ }
+ cb(null, obj, resp);
+ }
+
+ function onError(err, cb) {
+ var errParsed, errObj, errType, key;
+ try {
+ errParsed = JSON.parse(err.responseText);
+ //would prefer not to have a try/catch clause
+ for (key in errors) {
+ if (errors.hasOwnProperty(key) &&
+ errors[key].name === errParsed.error) {
+ errType = errors[key];
+ break;
+ }
+ }
+ if (!errType) {
+ errType = errors.UNKNOWN_ERROR;
+ if (err.status) {
+ errType.status = err.status;
+ }
+ if (err.statusText) {
+ err.name = err.statusText;
+ }
+ }
+ errObj = errors.error(errType, errParsed.reason);
+ } catch (e) {
+ for (var key in errors) {
+ if (errors.hasOwnProperty(key) && errors[key].status === err.status) {
+ errType = errors[key];
+ break;
+ }
+ }
+ if (!errType) {
+ errType = errors.UNKNOWN_ERROR;
+ if (err.status) {
+ errType.status = err.status;
+ }
+ if (err.statusText) {
+ err.name = err.statusText;
+ }
+ }
+ errObj = errors.error(errType);
+ }
+ if (err.withCredentials && err.status === 0) {
+ // apparently this is what we get when the method
+ // is reported as not allowed by CORS. so fudge it
+ errObj.status = 405;
+ errObj.statusText = "Method Not Allowed";
+ }
+ cb(errObj);
+ }
+
+ var timer;
+ var xhr;
+ if (options.xhr) {
+ xhr = new options.xhr();
+ } else {
+ xhr = new XMLHttpRequest();
+ }
+ xhr.open(options.method, options.url);
+ xhr.withCredentials = true;
+
+ if (options.json) {
+ options.headers.Accept = 'application/json';
+ options.headers['Content-Type'] = options.headers['Content-Type'] ||
+ 'application/json';
+ if (options.body &&
+ options.processData &&
+ typeof options.body !== "string") {
+ options.body = JSON.stringify(options.body);
+ }
+ }
+
+ if (options.binary) {
+ xhr.responseType = 'arraybuffer';
+ }
+
+ var createCookie = function (name, value, days) {
+ var expires = "";
+ if (days) {
+ var date = new Date();
+ date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+ expires = "; expires=" + date.toGMTString();
+ }
+ document.cookie = name + "=" + value + expires + "; path=/";
+ };
+
+ for (var key in options.headers) {
+ if (key === 'Cookie') {
+ var cookie = options.headers[key].split('=');
+ createCookie(cookie[0], cookie[1], 10);
+ } else {
+ xhr.setRequestHeader(key, options.headers[key]);
+ }
+ }
+
+ if (!("body" in options)) {
+ options.body = null;
+ }
+
+ var abortReq = function () {
+ if (requestCompleted) {
+ return;
+ }
+ xhr.abort();
+ onError(xhr, callback);
+ };
+
+ xhr.onreadystatechange = function () {
+ if (xhr.readyState !== 4 || requestCompleted) {
+ return;
+ }
+ clearTimeout(timer);
+ if (xhr.status >= 200 && xhr.status < 300) {
+ var data;
+ if (options.binary) {
+ data = createBlob([xhr.response || ''], {
+ type: xhr.getResponseHeader('Content-Type')
+ });
+ } else {
+ data = xhr.responseText;
+ }
+ onSuccess(data, xhr, callback);
+ } else {
+ onError(xhr, callback);
+ }
+ };
+
+ if (options.timeout > 0) {
+ timer = setTimeout(abortReq, options.timeout);
+ xhr.onprogress = function () {
+ clearTimeout(timer);
+ timer = setTimeout(abortReq, options.timeout);
+ };
+ if (typeof hasUpload === 'undefined') {
+ // IE throws an error if you try to access it directly
+ hasUpload = Object.keys(xhr).indexOf('upload') !== -1;
+ }
+ if (hasUpload) { // does not exist in ie9
+ xhr.upload.onprogress = xhr.onprogress;
+ }
+ }
+ if (options.body && (options.body instanceof Blob)) {
+ var reader = new FileReader();
+ reader.onloadend = function (e) {
+
+ var binary = "";
+ var bytes = new Uint8Array(this.result);
+ var length = bytes.byteLength;
+
+ for (var i = 0; i < length; i++) {
+ binary += String.fromCharCode(bytes[i]);
+ }
+
+ binary = utils.fixBinary(binary);
+ xhr.send(binary);
+ };
+ reader.readAsArrayBuffer(options.body);
+ } else {
+ xhr.send(options.body);
+ }
+ return {abort: abortReq};
+}
+
+module.exports = ajax;
+
+},{"../utils":15,"./blob.js":3,"./errors":5}],3:[function(require,module,exports){
+(function (global){
+"use strict";
+
+//Abstracts constructing a Blob object, so it also works in older
+//browsers that don't support the native Blob constructor. (i.e.
+//old QtWebKit versions, at least).
+function createBlob(parts, properties) {
+ parts = parts || [];
+ properties = properties || {};
+ try {
+ return new Blob(parts, properties);
+ } catch (e) {
+ if (e.name !== "TypeError") {
+ throw e;
+ }
+ var BlobBuilder = global.BlobBuilder ||
+ global.MSBlobBuilder ||
+ global.MozBlobBuilder ||
+ global.WebKitBlobBuilder;
+ var builder = new BlobBuilder();
+ for (var i = 0; i < parts.length; i += 1) {
+ builder.append(parts[i]);
+ }
+ return builder.getBlob(properties.type);
+ }
+}
+
+module.exports = createBlob;
+
+
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],4:[function(require,module,exports){
+'use strict';
+exports.Map = LazyMap; // TODO: use ES6 map
+exports.Set = LazySet; // TODO: use ES6 set
+// based on https://github.com/montagejs/collections
+function LazyMap() {
+ this.store = {};
+}
+LazyMap.prototype.mangle = function (key) {
+ if (typeof key !== "string") {
+ throw new TypeError("key must be a string but Got " + key);
+ }
+ return '$' + key;
+};
+LazyMap.prototype.unmangle = function (key) {
+ return key.substring(1);
+};
+LazyMap.prototype.get = function (key) {
+ var mangled = this.mangle(key);
+ if (mangled in this.store) {
+ return this.store[mangled];
+ } else {
+ return void 0;
+ }
+};
+LazyMap.prototype.set = function (key, value) {
+ var mangled = this.mangle(key);
+ this.store[mangled] = value;
+ return true;
+};
+LazyMap.prototype.has = function (key) {
+ var mangled = this.mangle(key);
+ return mangled in this.store;
+};
+LazyMap.prototype["delete"] = function (key) {
+ var mangled = this.mangle(key);
+ if (mangled in this.store) {
+ delete this.store[mangled];
+ return true;
+ }
+ return false;
+};
+LazyMap.prototype.forEach = function (cb) {
+ var self = this;
+ var keys = Object.keys(self.store);
+ keys.forEach(function (key) {
+ var value = self.store[key];
+ key = self.unmangle(key);
+ cb(value, key);
+ });
+};
+
+function LazySet() {
+ this.store = new LazyMap();
+}
+LazySet.prototype.add = function (key) {
+ return this.store.set(key, true);
+};
+LazySet.prototype.has = function (key) {
+ return this.store.has(key);
+};
+LazySet.prototype["delete"] = function (key) {
+ return this.store["delete"](key);
+};
+},{}],5:[function(require,module,exports){
+"use strict";
+
+function PouchError(opts) {
+ this.status = opts.status;
+ this.name = opts.error;
+ this.message = opts.reason;
+ this.error = true;
+}
+
+PouchError.prototype__proto__ = Error.prototype;
+
+PouchError.prototype.toString = function () {
+ return JSON.stringify({
+ status: this.status,
+ name: this.name,
+ message: this.message
+ });
+};
+
+exports.UNAUTHORIZED = new PouchError({
+ status: 401,
+ error: 'unauthorized',
+ reason: "Name or password is incorrect."
+});
+exports.MISSING_BULK_DOCS = new PouchError({
+ status: 400,
+ error: 'bad_request',
+ reason: "Missing JSON list of 'docs'"
+});
+exports.MISSING_DOC = new PouchError({
+ status: 404,
+ error: 'not_found',
+ reason: 'missing'
+});
+exports.REV_CONFLICT = new PouchError({
+ status: 409,
+ error: 'conflict',
+ reason: 'Document update conflict'
+});
+exports.INVALID_ID = new PouchError({
+ status: 400,
+ error: 'invalid_id',
+ reason: '_id field must contain a string'
+});
+exports.MISSING_ID = new PouchError({
+ status: 412,
+ error: 'missing_id',
+ reason: '_id is required for puts'
+});
+exports.RESERVED_ID = new PouchError({
+ status: 400,
+ error: 'bad_request',
+ reason: 'Only reserved document ids may start with underscore.'
+});
+exports.NOT_OPEN = new PouchError({
+ status: 412,
+ error: 'precondition_failed',
+ reason: 'Database not open'
+});
+exports.UNKNOWN_ERROR = new PouchError({
+ status: 500,
+ error: 'unknown_error',
+ reason: 'Database encountered an unknown error'
+});
+exports.BAD_ARG = new PouchError({
+ status: 500,
+ error: 'badarg',
+ reason: 'Some query argument is invalid'
+});
+exports.INVALID_REQUEST = new PouchError({
+ status: 400,
+ error: 'invalid_request',
+ reason: 'Request was invalid'
+});
+exports.QUERY_PARSE_ERROR = new PouchError({
+ status: 400,
+ error: 'query_parse_error',
+ reason: 'Some query parameter is invalid'
+});
+exports.DOC_VALIDATION = new PouchError({
+ status: 500,
+ error: 'doc_validation',
+ reason: 'Bad special document member'
+});
+exports.BAD_REQUEST = new PouchError({
+ status: 400,
+ error: 'bad_request',
+ reason: 'Something wrong with the request'
+});
+exports.NOT_AN_OBJECT = new PouchError({
+ status: 400,
+ error: 'bad_request',
+ reason: 'Document must be a JSON object'
+});
+exports.DB_MISSING = new PouchError({
+ status: 404,
+ error: 'not_found',
+ reason: 'Database not found'
+});
+exports.IDB_ERROR = new PouchError({
+ status: 500,
+ error: 'indexed_db_went_bad',
+ reason: 'unknown'
+});
+exports.WSQ_ERROR = new PouchError({
+ status: 500,
+ error: 'web_sql_went_bad',
+ reason: 'unknown'
+});
+exports.LDB_ERROR = new PouchError({
+ status: 500,
+ error: 'levelDB_went_went_bad',
+ reason: 'unknown'
+});
+exports.FORBIDDEN = new PouchError({
+ status: 403,
+ error: 'forbidden',
+ reason: 'Forbidden by design doc validate_doc_update function'
+});
+exports.error = function (error, reason, name) {
+ function CustomPouchError(msg) {
+ this.message = reason;
+ if (name) {
+ this.name = name;
+ }
+ }
+ CustomPouchError.prototype = error;
+ return new CustomPouchError(reason);
+};
+
+},{}],6:[function(require,module,exports){
+(function (process,global){
+'use strict';
+
+var crypto = require('crypto');
+var Md5 = require('spark-md5');
+var setImmediateShim = global.setImmediate || global.setTimeout;
+
+function sliceShim(arrayBuffer, begin, end) {
+ if (typeof arrayBuffer.slice === 'function') {
+ return arrayBuffer.slice(begin, end);
+ }
+ //
+ // shim for IE courtesy of http://stackoverflow.com/a/21440217
+ //
+
+ //If `begin`/`end` is unspecified, Chrome assumes 0, so we do the same
+ //Chrome also converts the values to integers via flooring
+ begin = Math.floor(begin || 0);
+ end = Math.floor(end || 0);
+
+ var len = arrayBuffer.byteLength;
+
+ //If either `begin` or `end` is negative, it refers to an
+ //index from the end of the array, as opposed to from the beginning.
+ //The range specified by the `begin` and `end` values is clamped to the
+ //valid index range for the current array.
+ begin = begin < 0 ? Math.max(begin + len, 0) : Math.min(len, begin);
+ end = end < 0 ? Math.max(end + len, 0) : Math.min(len, end);
+
+ //If the computed length of the new ArrayBuffer would be negative, it
+ //is clamped to zero.
+ if (end - begin <= 0) {
+ return new ArrayBuffer(0);
+ }
+
+ var result = new ArrayBuffer(end - begin);
+ var resultBytes = new Uint8Array(result);
+ var sourceBytes = new Uint8Array(arrayBuffer, begin, end - begin);
+
+ resultBytes.set(sourceBytes);
+
+ return result;
+}
+
+module.exports = function (data, callback) {
+ if (!process.browser) {
+ callback(null, crypto.createHash('md5').update(data).digest('hex'));
+ return;
+ }
+ var chunkSize = Math.min(524288, data.length);
+ var chunks = Math.ceil(data.length / chunkSize);
+ var currentChunk = 0;
+ var buffer = new Md5();
+ function loadNextChunk() {
+ var start = currentChunk * chunkSize;
+ var end = start + chunkSize;
+ if ((start + chunkSize) >= data.size) {
+ end = data.size;
+ }
+ currentChunk++;
+ if (currentChunk < chunks) {
+ buffer.append(sliceShim(data, start, end));
+ setImmediateShim(loadNextChunk);
+ } else {
+ buffer.append(sliceShim(data, start, end));
+ callback(null, buffer.end());
+ buffer.destroy();
+ }
+ }
+ loadNextChunk();
+};
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"crypto":17,"spark-md5":96}],7:[function(require,module,exports){
+"use strict";
+
+// BEGIN Math.uuid.js
+
+/*!
+Math.uuid.js (v1.4)
+http://www.broofa.com
+mailto:robert@broofa.com
+
+Copyright (c) 2010 Robert Kieffer
+Dual licensed under the MIT and GPL licenses.
+*/
+
+/*
+ * Generate a random uuid.
+ *
+ * USAGE: Math.uuid(length, radix)
+ * length - the desired number of characters
+ * radix - the number of allowable values for each character.
+ *
+ * EXAMPLES:
+ * // No arguments - returns RFC4122, version 4 ID
+ * >>> Math.uuid()
+ * "92329D39-6F5C-4520-ABFC-AAB64544E172"
+ *
+ * // One argument - returns ID of the specified length
+ * >>> Math.uuid(15) // 15 character ID (default base=62)
+ * "VcydxgltxrVZSTV"
+ *
+ * // Two arguments - returns ID of the specified length, and radix.
+ * // (Radix must be <= 62)
+ * >>> Math.uuid(8, 2) // 8 character ID (base=2)
+ * "01001010"
+ * >>> Math.uuid(8, 10) // 8 character ID (base=10)
+ * "47473046"
+ * >>> Math.uuid(8, 16) // 8 character ID (base=16)
+ * "098F4D35"
+ */
+var chars = (
+ '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ' +
+ 'abcdefghijklmnopqrstuvwxyz'
+).split('');
+function getValue(radix) {
+ return 0 | Math.random() * radix;
+}
+function uuid(len, radix) {
+ radix = radix || chars.length;
+ var out = '';
+ var i = -1;
+
+ if (len) {
+ // Compact form
+ while (++i < len) {
+ out += chars[getValue(radix)];
+ }
+ return out;
+ }
+ // rfc4122, version 4 form
+ // Fill in random data. At i==19 set the high bits of clock sequence as
+ // per rfc4122, sec. 4.1.5
+ while (++i < 36) {
+ switch (i) {
+ case 8:
+ case 13:
+ case 18:
+ case 23:
+ out += '-';
+ break;
+ case 19:
+ out += chars[(getValue(16) & 0x3) | 0x8];
+ break;
+ default:
+ out += chars[getValue(16)];
+ }
+ }
+
+ return out;
+}
+
+
+
+module.exports = uuid;
+
+
+},{}],8:[function(require,module,exports){
+'use strict';
+var extend = require('pouchdb-extend');
+
+
+// for a better overview of what this is doing, read:
+// https://github.com/apache/couchdb/blob/master/src/couchdb/couch_key_tree.erl
+//
+// But for a quick intro, CouchDB uses a revision tree to store a documents
+// history, A -> B -> C, when a document has conflicts, that is a branch in the
+// tree, A -> (B1 | B2 -> C), We store these as a nested array in the format
+//
+// KeyTree = [Path ... ]
+// Path = {pos: position_from_root, ids: Tree}
+// Tree = [Key, Opts, [Tree, ...]], in particular single node: [Key, []]
+
+// Turn a path as a flat array into a tree with a single branch
+function pathToTree(path) {
+ var doc = path.shift();
+ var root = [doc.id, doc.opts, []];
+ var leaf = root;
+ var nleaf;
+
+ while (path.length) {
+ doc = path.shift();
+ nleaf = [doc.id, doc.opts, []];
+ leaf[2].push(nleaf);
+ leaf = nleaf;
+ }
+ return root;
+}
+
+// Merge two trees together
+// The roots of tree1 and tree2 must be the same revision
+function mergeTree(in_tree1, in_tree2) {
+ var queue = [{tree1: in_tree1, tree2: in_tree2}];
+ var conflicts = false;
+ while (queue.length > 0) {
+ var item = queue.pop();
+ var tree1 = item.tree1;
+ var tree2 = item.tree2;
+
+ if (tree1[1].status || tree2[1].status) {
+ tree1[1].status =
+ (tree1[1].status === 'available' ||
+ tree2[1].status === 'available') ? 'available' : 'missing';
+ }
+
+ for (var i = 0; i < tree2[2].length; i++) {
+ if (!tree1[2][0]) {
+ conflicts = 'new_leaf';
+ tree1[2][0] = tree2[2][i];
+ continue;
+ }
+
+ var merged = false;
+ for (var j = 0; j < tree1[2].length; j++) {
+ if (tree1[2][j][0] === tree2[2][i][0]) {
+ queue.push({tree1: tree1[2][j], tree2: tree2[2][i]});
+ merged = true;
+ }
+ }
+ if (!merged) {
+ conflicts = 'new_branch';
+ tree1[2].push(tree2[2][i]);
+ tree1[2].sort();
+ }
+ }
+ }
+ return {conflicts: conflicts, tree: in_tree1};
+}
+
+function doMerge(tree, path, dontExpand) {
+ var restree = [];
+ var conflicts = false;
+ var merged = false;
+ var res;
+
+ if (!tree.length) {
+ return {tree: [path], conflicts: 'new_leaf'};
+ }
+
+ tree.forEach(function (branch) {
+ if (branch.pos === path.pos && branch.ids[0] === path.ids[0]) {
+ // Paths start at the same position and have the same root, so they need
+ // merged
+ res = mergeTree(branch.ids, path.ids);
+ restree.push({pos: branch.pos, ids: res.tree});
+ conflicts = conflicts || res.conflicts;
+ merged = true;
+ } else if (dontExpand !== true) {
+ // The paths start at a different position, take the earliest path and
+ // traverse up until it as at the same point from root as the path we
+ // want to merge. If the keys match we return the longer path with the
+ // other merged After stemming we dont want to expand the trees
+
+ var t1 = branch.pos < path.pos ? branch : path;
+ var t2 = branch.pos < path.pos ? path : branch;
+ var diff = t2.pos - t1.pos;
+
+ var candidateParents = [];
+
+ var trees = [];
+ trees.push({ids: t1.ids, diff: diff, parent: null, parentIdx: null});
+ while (trees.length > 0) {
+ var item = trees.pop();
+ if (item.diff === 0) {
+ if (item.ids[0] === t2.ids[0]) {
+ candidateParents.push(item);
+ }
+ continue;
+ }
+ if (!item.ids) {
+ continue;
+ }
+ /*jshint loopfunc:true */
+ item.ids[2].forEach(function (el, idx) {
+ trees.push(
+ {ids: el, diff: item.diff - 1, parent: item.ids, parentIdx: idx});
+ });
+ }
+
+ var el = candidateParents[0];
+
+ if (!el) {
+ restree.push(branch);
+ } else {
+ res = mergeTree(el.ids, t2.ids);
+ el.parent[2][el.parentIdx] = res.tree;
+ restree.push({pos: t1.pos, ids: t1.ids});
+ conflicts = conflicts || res.conflicts;
+ merged = true;
+ }
+ } else {
+ restree.push(branch);
+ }
+ });
+
+ // We didnt find
+ if (!merged) {
+ restree.push(path);
+ }
+
+ restree.sort(function (a, b) {
+ return a.pos - b.pos;
+ });
+
+ return {
+ tree: restree,
+ conflicts: conflicts || 'internal_node'
+ };
+}
+
+// To ensure we dont grow the revision tree infinitely, we stem old revisions
+function stem(tree, depth) {
+ // First we break out the tree into a complete list of root to leaf paths,
+ // we cut off the start of the path and generate a new set of flat trees
+ var stemmedPaths = PouchMerge.rootToLeaf(tree).map(function (path) {
+ var stemmed = path.ids.slice(-depth);
+ return {
+ pos: path.pos + (path.ids.length - stemmed.length),
+ ids: pathToTree(stemmed)
+ };
+ });
+ // Then we remerge all those flat trees together, ensuring that we dont
+ // connect trees that would go beyond the depth limit
+ return stemmedPaths.reduce(function (prev, current, i, arr) {
+ return doMerge(prev, current, true).tree;
+ }, [stemmedPaths.shift()]);
+}
+
+var PouchMerge = {};
+
+PouchMerge.merge = function (tree, path, depth) {
+ // Ugh, nicer way to not modify arguments in place?
+ tree = extend(true, [], tree);
+ path = extend(true, {}, path);
+ var newTree = doMerge(tree, path);
+ return {
+ tree: stem(newTree.tree, depth),
+ conflicts: newTree.conflicts
+ };
+};
+
+// We fetch all leafs of the revision tree, and sort them based on tree length
+// and whether they were deleted, undeleted documents with the longest revision
+// tree (most edits) win
+// The final sort algorithm is slightly documented in a sidebar here:
+// http://guide.couchdb.org/draft/conflicts.html
+PouchMerge.winningRev = function (metadata) {
+ var leafs = [];
+ PouchMerge.traverseRevTree(metadata.rev_tree,
+ function (isLeaf, pos, id, something, opts) {
+ if (isLeaf) {
+ leafs.push({pos: pos, id: id, deleted: !!opts.deleted});
+ }
+ });
+ leafs.sort(function (a, b) {
+ if (a.deleted !== b.deleted) {
+ return a.deleted > b.deleted ? 1 : -1;
+ }
+ if (a.pos !== b.pos) {
+ return b.pos - a.pos;
+ }
+ return a.id < b.id ? 1 : -1;
+ });
+
+ return leafs[0].pos + '-' + leafs[0].id;
+};
+
+// Pretty much all below can be combined into a higher order function to
+// traverse revisions
+// The return value from the callback will be passed as context to all
+// children of that node
+PouchMerge.traverseRevTree = function (revs, callback) {
+ var toVisit = revs.slice();
+
+ var node;
+ while ((node = toVisit.pop())) {
+ var pos = node.pos;
+ var tree = node.ids;
+ var branches = tree[2];
+ var newCtx =
+ callback(branches.length === 0, pos, tree[0], node.ctx, tree[1]);
+ for (var i = 0, len = branches.length; i < len; i++) {
+ toVisit.push({pos: pos + 1, ids: branches[i], ctx: newCtx});
+ }
+ }
+};
+
+PouchMerge.collectLeaves = function (revs) {
+ var leaves = [];
+ PouchMerge.traverseRevTree(revs, function (isLeaf, pos, id, acc, opts) {
+ if (isLeaf) {
+ leaves.unshift({rev: pos + "-" + id, pos: pos, opts: opts});
+ }
+ });
+ leaves.sort(function (a, b) {
+ return b.pos - a.pos;
+ });
+ leaves.map(function (leaf) { delete leaf.pos; });
+ return leaves;
+};
+
+// returns revs of all conflicts that is leaves such that
+// 1. are not deleted and
+// 2. are different than winning revision
+PouchMerge.collectConflicts = function (metadata) {
+ var win = PouchMerge.winningRev(metadata);
+ var leaves = PouchMerge.collectLeaves(metadata.rev_tree);
+ var conflicts = [];
+ leaves.forEach(function (leaf) {
+ if (leaf.rev !== win && !leaf.opts.deleted) {
+ conflicts.push(leaf.rev);
+ }
+ });
+ return conflicts;
+};
+
+PouchMerge.rootToLeaf = function (tree) {
+ var paths = [];
+ PouchMerge.traverseRevTree(tree, function (isLeaf, pos, id, history, opts) {
+ history = history ? history.slice(0) : [];
+ history.push({id: id, opts: opts});
+ if (isLeaf) {
+ var rootPos = pos + 1 - history.length;
+ paths.unshift({pos: rootPos, ids: history});
+ }
+ return history;
+ });
+ return paths;
+};
+
+
+module.exports = PouchMerge;
+
+},{"pouchdb-extend":95}],"adapter-config":[function(require,module,exports){
+module.exports=require('kPrcxC');
+},{}],"kPrcxC":[function(require,module,exports){
+'use strict';
+
+module.exports = {
+ name: 'memory',
+ valid: function () {
+ return true;
+ },
+ use_prefix: false
+};
+},{}],11:[function(require,module,exports){
+"use strict";
+
+var adapterConfig = require('adapter-config');
+var adapterName = adapterConfig.name;
+var adapter = require('./levelalt');
+
+window.PouchDB.adapter(adapterName, adapter);
+window.PouchDB.preferredAdapters.push(adapterName);
+
+},{"./levelalt":12,"adapter-config":"kPrcxC"}],12:[function(require,module,exports){
+'use strict';
+
+var LevelPouch = require('../adapters/leveldb');
+var leveldown = require('leveldown');
+var adapterConfig = require('adapter-config');
+var utils = require('../utils');
+
+function LevelPouchAlt(opts, callback) {
+ var _opts = utils.extend({
+ db: leveldown
+ }, opts);
+
+ LevelPouch.call(this, _opts, callback);
+}
+
+// overrides for normal LevelDB behavior on Node
+LevelPouchAlt.valid = function () {
+ return adapterConfig.valid();
+};
+LevelPouchAlt.use_prefix = adapterConfig.use_prefix;
+
+LevelPouchAlt.destroy = utils.toPromise(function (name, opts, callback) {
+ if (typeof opts === 'function') {
+ callback = opts;
+ opts = {};
+ }
+ var _opts = utils.extend({
+ db: leveldown
+ }, opts);
+
+ return LevelPouch.destroy(name, _opts, callback);
+});
+
+module.exports = LevelPouchAlt;
+
+},{"../adapters/leveldb":1,"../utils":15,"adapter-config":"kPrcxC","leveldown":"RQL87X"}],"JpIkFB":[function(require,module,exports){
+(function (process){
+'use strict';
+// LevelAlt doesn't need the pre-2.2.0 LevelDB-specific migrations
+exports.toSublevel = function (name, db, callback) {
+ process.nextTick(function () {
+ callback();
+ });
+};
+
+exports.localAndMetaStores = function (db, stores, callback) {
+ process.nextTick(function () {
+ callback();
+ });
+};
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],"../adapters/../deps/migrate":[function(require,module,exports){
+module.exports=require('JpIkFB');
+},{}],15:[function(require,module,exports){
+(function (process,global){
+/*jshint strict: false */
+/*global chrome */
+var merge = require('./merge');
+exports.extend = require('pouchdb-extend');
+exports.ajax = require('./deps/ajax');
+exports.createBlob = require('./deps/blob');
+exports.uuid = require('./deps/uuid');
+exports.getArguments = require('argsarray');
+var buffer = require('./deps/buffer');
+var errors = require('./deps/errors');
+var EventEmitter = require('events').EventEmitter;
+var collections = require('./deps/collections');
+exports.Map = collections.Map;
+exports.Set = collections.Set;
+
+if (typeof global.Promise === 'function') {
+ exports.Promise = global.Promise;
+} else {
+ exports.Promise = require('bluebird');
+}
+var Promise = exports.Promise;
+
+function toObject(array) {
+ var obj = {};
+ array.forEach(function (item) { obj[item] = true; });
+ return obj;
+}
+// List of top level reserved words for doc
+var reservedWords = toObject([
+ '_id',
+ '_rev',
+ '_attachments',
+ '_deleted',
+ '_revisions',
+ '_revs_info',
+ '_conflicts',
+ '_deleted_conflicts',
+ '_local_seq',
+ '_rev_tree',
+ //replication documents
+ '_replication_id',
+ '_replication_state',
+ '_replication_state_time',
+ '_replication_state_reason',
+ '_replication_stats'
+]);
+exports.clone = function (obj) {
+ return exports.extend(true, {}, obj);
+};
+exports.inherits = require('inherits');
+// Determine id an ID is valid
+// - invalid IDs begin with an underescore that does not begin '_design' or
+// '_local'
+// - any other string value is a valid id
+// Returns the specific error object for each case
+exports.invalidIdError = function (id) {
+ var err;
+ if (!id) {
+ err = new TypeError(errors.MISSING_ID.message);
+ err.status = 412;
+ } else if (typeof id !== 'string') {
+ err = new TypeError(errors.INVALID_ID.message);
+ err.status = 400;
+ } else if (/^_/.test(id) && !(/^_(design|local)/).test(id)) {
+ err = new TypeError(errors.RESERVED_ID.message);
+ err.status = 400;
+ }
+ if (err) {
+ throw err;
+ }
+};
+
+function isChromeApp() {
+ return (typeof chrome !== "undefined" &&
+ typeof chrome.storage !== "undefined" &&
+ typeof chrome.storage.local !== "undefined");
+}
+
+// Pretty dumb name for a function, just wraps callback calls so we dont
+// to if (callback) callback() everywhere
+exports.call = exports.getArguments(function (args) {
+ if (!args.length) {
+ return;
+ }
+ var fun = args.shift();
+ if (typeof fun === 'function') {
+ fun.apply(this, args);
+ }
+});
+
+exports.isLocalId = function (id) {
+ return (/^_local/).test(id);
+};
+
+// check if a specific revision of a doc has been deleted
+// - metadata: the metadata object from the doc store
+// - rev: (optional) the revision to check. defaults to winning revision
+exports.isDeleted = function (metadata, rev) {
+ if (!rev) {
+ rev = merge.winningRev(metadata);
+ }
+ var dashIndex = rev.indexOf('-');
+ if (dashIndex !== -1) {
+ rev = rev.substring(dashIndex + 1);
+ }
+ var deleted = false;
+ merge.traverseRevTree(metadata.rev_tree,
+ function (isLeaf, pos, id, acc, opts) {
+ if (id === rev) {
+ deleted = !!opts.deleted;
+ }
+ });
+
+ return deleted;
+};
+
+exports.filterChange = function (opts) {
+ return function (change) {
+ var req = {};
+ var hasFilter = opts.filter && typeof opts.filter === 'function';
+
+ req.query = opts.query_params;
+ if (opts.filter && hasFilter && !opts.filter.call(this, change.doc, req)) {
+ return false;
+ }
+ if (opts.doc_ids && opts.doc_ids.indexOf(change.id) === -1) {
+ return false;
+ }
+ if (!opts.include_docs) {
+ delete change.doc;
+ } else {
+ for (var att in change.doc._attachments) {
+ if (change.doc._attachments.hasOwnProperty(att)) {
+ change.doc._attachments[att].stub = true;
+ }
+ }
+ }
+ return true;
+ };
+};
+
+// Preprocess documents, parse their revisions, assign an id and a
+// revision for new writes that are missing them, etc
+exports.parseDoc = function (doc, newEdits) {
+ var nRevNum;
+ var newRevId;
+ var revInfo;
+ var error;
+ var opts = {status: 'available'};
+ if (doc._deleted) {
+ opts.deleted = true;
+ }
+
+ if (newEdits) {
+ if (!doc._id) {
+ doc._id = exports.uuid();
+ }
+ newRevId = exports.uuid(32, 16).toLowerCase();
+ if (doc._rev) {
+ revInfo = /^(\d+)-(.+)$/.exec(doc._rev);
+ if (!revInfo) {
+ var err = new TypeError("invalid value for property '_rev'");
+ err.status = 400;
+ }
+ doc._rev_tree = [{
+ pos: parseInt(revInfo[1], 10),
+ ids: [revInfo[2], {status: 'missing'}, [[newRevId, opts, []]]]
+ }];
+ nRevNum = parseInt(revInfo[1], 10) + 1;
+ } else {
+ doc._rev_tree = [{
+ pos: 1,
+ ids : [newRevId, opts, []]
+ }];
+ nRevNum = 1;
+ }
+ } else {
+ if (doc._revisions) {
+ doc._rev_tree = [{
+ pos: doc._revisions.start - doc._revisions.ids.length + 1,
+ ids: doc._revisions.ids.reduce(function (acc, x) {
+ if (acc === null) {
+ return [x, opts, []];
+ } else {
+ return [x, {status: 'missing'}, [acc]];
+ }
+ }, null)
+ }];
+ nRevNum = doc._revisions.start;
+ newRevId = doc._revisions.ids[0];
+ }
+ if (!doc._rev_tree) {
+ revInfo = /^(\d+)-(.+)$/.exec(doc._rev);
+ if (!revInfo) {
+ error = new TypeError(errors.BAD_ARG.message);
+ error.status = errors.BAD_ARG.status;
+ throw error;
+ }
+ nRevNum = parseInt(revInfo[1], 10);
+ newRevId = revInfo[2];
+ doc._rev_tree = [{
+ pos: parseInt(revInfo[1], 10),
+ ids: [revInfo[2], opts, []]
+ }];
+ }
+ }
+
+ exports.invalidIdError(doc._id);
+
+ doc._id = decodeURIComponent(doc._id);
+ doc._rev = [nRevNum, newRevId].join('-');
+
+ var result = {metadata : {}, data : {}};
+ for (var key in doc) {
+ if (doc.hasOwnProperty(key)) {
+ var specialKey = key[0] === '_';
+ if (specialKey && !reservedWords[key]) {
+ error = new Error(errors.DOC_VALIDATION.message + ': ' + key);
+ error.status = errors.DOC_VALIDATION.status;
+ throw error;
+ } else if (specialKey && key !== '_attachments') {
+ result.metadata[key.slice(1)] = doc[key];
+ } else {
+ result.data[key] = doc[key];
+ }
+ }
+ }
+ return result;
+};
+
+exports.isCordova = function () {
+ return (typeof cordova !== "undefined" ||
+ typeof PhoneGap !== "undefined" ||
+ typeof phonegap !== "undefined");
+};
+
+exports.hasLocalStorage = function () {
+ if (isChromeApp()) {
+ return false;
+ }
+ try {
+ return global.localStorage;
+ } catch (e) {
+ return false;
+ }
+};
+exports.Changes = Changes;
+exports.inherits(Changes, EventEmitter);
+function Changes() {
+ if (!(this instanceof Changes)) {
+ return new Changes();
+ }
+ var self = this;
+ EventEmitter.call(this);
+ this.isChrome = isChromeApp();
+ this.listeners = {};
+ this.hasLocal = false;
+ if (!this.isChrome) {
+ this.hasLocal = exports.hasLocalStorage();
+ }
+ if (this.isChrome) {
+ chrome.storage.onChanged.addListener(function (e) {
+ // make sure it's event addressed to us
+ if (e.db_name != null) {
+ //object only has oldValue, newValue members
+ self.emit(e.dbName.newValue);
+ }
+ });
+ } else if (this.hasLocal) {
+ if (global.addEventListener) {
+ global.addEventListener("storage", function (e) {
+ self.emit(e.key);
+ });
+ } else {
+ global.attachEvent("storage", function (e) {
+ self.emit(e.key);
+ });
+ }
+ }
+
+}
+Changes.prototype.addListener = function (dbName, id, db, opts) {
+ if (this.listeners[id]) {
+ return;
+ }
+ function eventFunction() {
+ db.changes({
+ include_docs: opts.include_docs,
+ conflicts: opts.conflicts,
+ continuous: false,
+ descending: false,
+ filter: opts.filter,
+ view: opts.view,
+ since: opts.since,
+ query_params: opts.query_params,
+ onChange: function (c) {
+ if (c.seq > opts.since && !opts.cancelled) {
+ opts.since = c.seq;
+ exports.call(opts.onChange, c);
+ }
+ }
+ });
+ }
+ this.listeners[id] = eventFunction;
+ this.on(dbName, eventFunction);
+};
+
+Changes.prototype.removeListener = function (dbName, id) {
+ if (!(id in this.listeners)) {
+ return;
+ }
+ EventEmitter.prototype.removeListener.call(this, dbName,
+ this.listeners[id]);
+};
+
+
+Changes.prototype.notifyLocalWindows = function (dbName) {
+ //do a useless change on a storage thing
+ //in order to get other windows's listeners to activate
+ if (this.isChrome) {
+ chrome.storage.local.set({dbName: dbName});
+ } else if (this.hasLocal) {
+ localStorage[dbName] = (localStorage[dbName] === "a") ? "b" : "a";
+ }
+};
+
+Changes.prototype.notify = function (dbName) {
+ this.emit(dbName);
+ this.notifyLocalWindows(dbName);
+};
+
+if (!process.browser || !('atob' in global)) {
+ exports.atob = function (str) {
+ var base64 = new buffer(str, 'base64');
+ // Node.js will just skip the characters it can't encode instead of
+ // throwing and exception
+ if (base64.toString('base64') !== str) {
+ throw ("Cannot base64 encode full string");
+ }
+ return base64.toString('binary');
+ };
+} else {
+ exports.atob = function (str) {
+ return atob(str);
+ };
+}
+
+if (!process.browser || !('btoa' in global)) {
+ exports.btoa = function (str) {
+ return new buffer(str, 'binary').toString('base64');
+ };
+} else {
+ exports.btoa = function (str) {
+ return btoa(str);
+ };
+}
+
+// From http://stackoverflow.com/questions/14967647/ (continues on next line)
+// encode-decode-image-with-base64-breaks-image (2013-04-21)
+exports.fixBinary = function (bin) {
+ if (!process.browser) {
+ // don't need to do this in Node
+ return bin;
+ }
+
+ var length = bin.length;
+ var buf = new ArrayBuffer(length);
+ var arr = new Uint8Array(buf);
+ for (var i = 0; i < length; i++) {
+ arr[i] = bin.charCodeAt(i);
+ }
+ return buf;
+};
+
+exports.once = function (fun) {
+ var called = false;
+ return exports.getArguments(function (args) {
+ if (called) {
+ if (typeof console.trace === 'function') {
+ console.trace();
+ }
+ throw new Error('once called more than once');
+ } else {
+ called = true;
+ fun.apply(this, args);
+ }
+ });
+};
+
+exports.toPromise = function (func) {
+ //create the function we will be returning
+ return exports.getArguments(function (args) {
+ var self = this;
+ var tempCB =
+ (typeof args[args.length - 1] === 'function') ? args.pop() : false;
+ // if the last argument is a function, assume its a callback
+ var usedCB;
+ if (tempCB) {
+ // if it was a callback, create a new callback which calls it,
+ // but do so async so we don't trap any errors
+ usedCB = function (err, resp) {
+ process.nextTick(function () {
+ tempCB(err, resp);
+ });
+ };
+ }
+ var promise = new Promise(function (fulfill, reject) {
+ var resp;
+ try {
+ var callback = exports.once(function (err, mesg) {
+ if (err) {
+ reject(err);
+ } else {
+ fulfill(mesg);
+ }
+ });
+ // create a callback for this invocation
+ // apply the function in the orig context
+ args.push(callback);
+ resp = func.apply(self, args);
+ if (resp && typeof resp.then === 'function') {
+ fulfill(resp);
+ }
+ } catch (e) {
+ reject(e);
+ }
+ });
+ // if there is a callback, call it back
+ if (usedCB) {
+ promise.then(function (result) {
+ usedCB(null, result);
+ }, usedCB);
+ }
+ promise.cancel = function () {
+ return this;
+ };
+ return promise;
+ });
+};
+
+exports.adapterFun = function (name, callback) {
+ return exports.toPromise(exports.getArguments(function (args) {
+ if (this._closed) {
+ return Promise.reject(new Error('database is closed'));
+ }
+ var self = this;
+ if (!this.taskqueue.isReady) {
+ return new exports.Promise(function (fulfill, reject) {
+ self.taskqueue.addTask(function (failed) {
+ if (failed) {
+ reject(failed);
+ } else {
+ fulfill(self[name].apply(self, args));
+ }
+ });
+ });
+ }
+ return callback.apply(this, args);
+ }));
+};
+//Can't find original post, but this is close
+//http://stackoverflow.com/questions/6965107/ (continues on next line)
+//converting-between-strings-and-arraybuffers
+exports.arrayBufferToBinaryString = function (buffer) {
+ var binary = "";
+ var bytes = new Uint8Array(buffer);
+ var length = bytes.byteLength;
+ for (var i = 0; i < length; i++) {
+ binary += String.fromCharCode(bytes[i]);
+ }
+ return binary;
+};
+
+exports.cancellableFun = function (fun, self, opts) {
+
+ opts = opts ? exports.clone(true, {}, opts) : {};
+
+ var emitter = new EventEmitter();
+ var oldComplete = opts.complete || function () { };
+ var complete = opts.complete = exports.once(function (err, resp) {
+ if (err) {
+ oldComplete(err);
+ } else {
+ emitter.emit('end', resp);
+ oldComplete(null, resp);
+ }
+ emitter.removeAllListeners();
+ });
+ var oldOnChange = opts.onChange || function () {};
+ var lastChange = 0;
+ self.on('destroyed', function () {
+ emitter.removeAllListeners();
+ });
+ opts.onChange = function (change) {
+ oldOnChange(change);
+ if (change.seq <= lastChange) {
+ return;
+ }
+ lastChange = change.seq;
+ emitter.emit('change', change);
+ if (change.deleted) {
+ emitter.emit('delete', change);
+ } else if (change.changes.length === 1 &&
+ change.changes[0].rev.slice(0, 1) === '1-') {
+ emitter.emit('create', change);
+ } else {
+ emitter.emit('update', change);
+ }
+ };
+ var promise = new Promise(function (fulfill, reject) {
+ opts.complete = function (err, res) {
+ if (err) {
+ reject(err);
+ } else {
+ fulfill(res);
+ }
+ };
+ });
+
+ promise.then(function (result) {
+ complete(null, result);
+ }, complete);
+
+ // this needs to be overwridden by caller, dont fire complete until
+ // the task is ready
+ promise.cancel = function () {
+ promise.isCancelled = true;
+ if (self.taskqueue.isReady) {
+ opts.complete(null, {status: 'cancelled'});
+ }
+ };
+
+ if (!self.taskqueue.isReady) {
+ self.taskqueue.addTask(function () {
+ if (promise.isCancelled) {
+ opts.complete(null, {status: 'cancelled'});
+ } else {
+ fun(self, opts, promise);
+ }
+ });
+ } else {
+ fun(self, opts, promise);
+ }
+ promise.on = emitter.on.bind(emitter);
+ promise.once = emitter.once.bind(emitter);
+ promise.addListener = emitter.addListener.bind(emitter);
+ promise.removeListener = emitter.removeListener.bind(emitter);
+ promise.removeAllListeners = emitter.removeAllListeners.bind(emitter);
+ promise.setMaxListeners = emitter.setMaxListeners.bind(emitter);
+ promise.listeners = emitter.listeners.bind(emitter);
+ promise.emit = emitter.emit.bind(emitter);
+ return promise;
+};
+
+exports.MD5 = exports.toPromise(require('./deps/md5'));
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./deps/ajax":2,"./deps/blob":3,"./deps/buffer":17,"./deps/collections":4,"./deps/errors":5,"./deps/md5":6,"./deps/uuid":7,"./merge":8,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"argsarray":16,"bluebird":75,"events":18,"inherits":33,"pouchdb-extend":95}],16:[function(require,module,exports){
+'use strict';
+
+module.exports = argsArray;
+
+function argsArray(fun) {
+ return function () {
+ var len = arguments.length;
+ if (len) {
+ var args = [];
+ var i = -1;
+ while (++i < len) {
+ args[i] = arguments[i];
+ }
+ return fun.call(this, args);
+ } else {
+ return fun.call(this, []);
+ }
+ };
+}
+},{}],17:[function(require,module,exports){
+
+},{}],18:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+function EventEmitter() {
+ this._events = this._events || {};
+ this._maxListeners = this._maxListeners || undefined;
+}
+module.exports = EventEmitter;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+EventEmitter.defaultMaxListeners = 10;
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function(n) {
+ if (!isNumber(n) || n < 0 || isNaN(n))
+ throw TypeError('n must be a positive number');
+ this._maxListeners = n;
+ return this;
+};
+
+EventEmitter.prototype.emit = function(type) {
+ var er, handler, len, args, i, listeners;
+
+ if (!this._events)
+ this._events = {};
+
+ // If there is no 'error' event listener then throw.
+ if (type === 'error') {
+ if (!this._events.error ||
+ (isObject(this._events.error) && !this._events.error.length)) {
+ er = arguments[1];
+ if (er instanceof Error) {
+ throw er; // Unhandled 'error' event
+ } else {
+ throw TypeError('Uncaught, unspecified "error" event.');
+ }
+ return false;
+ }
+ }
+
+ handler = this._events[type];
+
+ if (isUndefined(handler))
+ return false;
+
+ if (isFunction(handler)) {
+ switch (arguments.length) {
+ // fast cases
+ case 1:
+ handler.call(this);
+ break;
+ case 2:
+ handler.call(this, arguments[1]);
+ break;
+ case 3:
+ handler.call(this, arguments[1], arguments[2]);
+ break;
+ // slower
+ default:
+ len = arguments.length;
+ args = new Array(len - 1);
+ for (i = 1; i < len; i++)
+ args[i - 1] = arguments[i];
+ handler.apply(this, args);
+ }
+ } else if (isObject(handler)) {
+ len = arguments.length;
+ args = new Array(len - 1);
+ for (i = 1; i < len; i++)
+ args[i - 1] = arguments[i];
+
+ listeners = handler.slice();
+ len = listeners.length;
+ for (i = 0; i < len; i++)
+ listeners[i].apply(this, args);
+ }
+
+ return true;
+};
+
+EventEmitter.prototype.addListener = function(type, listener) {
+ var m;
+
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ if (!this._events)
+ this._events = {};
+
+ // To avoid recursion in the case that type === "newListener"! Before
+ // adding it to the listeners, first emit "newListener".
+ if (this._events.newListener)
+ this.emit('newListener', type,
+ isFunction(listener.listener) ?
+ listener.listener : listener);
+
+ if (!this._events[type])
+ // Optimize the case of one listener. Don't need the extra array object.
+ this._events[type] = listener;
+ else if (isObject(this._events[type]))
+ // If we've already got an array, just append.
+ this._events[type].push(listener);
+ else
+ // Adding the second element, need to change to array.
+ this._events[type] = [this._events[type], listener];
+
+ // Check for listener leak
+ if (isObject(this._events[type]) && !this._events[type].warned) {
+ var m;
+ if (!isUndefined(this._maxListeners)) {
+ m = this._maxListeners;
+ } else {
+ m = EventEmitter.defaultMaxListeners;
+ }
+
+ if (m && m > 0 && this._events[type].length > m) {
+ this._events[type].warned = true;
+ console.error('(node) warning: possible EventEmitter memory ' +
+ 'leak detected. %d listeners added. ' +
+ 'Use emitter.setMaxListeners() to increase limit.',
+ this._events[type].length);
+ if (typeof console.trace === 'function') {
+ // not supported in IE 10
+ console.trace();
+ }
+ }
+ }
+
+ return this;
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.once = function(type, listener) {
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ var fired = false;
+
+ function g() {
+ this.removeListener(type, g);
+
+ if (!fired) {
+ fired = true;
+ listener.apply(this, arguments);
+ }
+ }
+
+ g.listener = listener;
+ this.on(type, g);
+
+ return this;
+};
+
+// emits a 'removeListener' event iff the listener was removed
+EventEmitter.prototype.removeListener = function(type, listener) {
+ var list, position, length, i;
+
+ if (!isFunction(listener))
+ throw TypeError('listener must be a function');
+
+ if (!this._events || !this._events[type])
+ return this;
+
+ list = this._events[type];
+ length = list.length;
+ position = -1;
+
+ if (list === listener ||
+ (isFunction(list.listener) && list.listener === listener)) {
+ delete this._events[type];
+ if (this._events.removeListener)
+ this.emit('removeListener', type, listener);
+
+ } else if (isObject(list)) {
+ for (i = length; i-- > 0;) {
+ if (list[i] === listener ||
+ (list[i].listener && list[i].listener === listener)) {
+ position = i;
+ break;
+ }
+ }
+
+ if (position < 0)
+ return this;
+
+ if (list.length === 1) {
+ list.length = 0;
+ delete this._events[type];
+ } else {
+ list.splice(position, 1);
+ }
+
+ if (this._events.removeListener)
+ this.emit('removeListener', type, listener);
+ }
+
+ return this;
+};
+
+EventEmitter.prototype.removeAllListeners = function(type) {
+ var key, listeners;
+
+ if (!this._events)
+ return this;
+
+ // not listening for removeListener, no need to emit
+ if (!this._events.removeListener) {
+ if (arguments.length === 0)
+ this._events = {};
+ else if (this._events[type])
+ delete this._events[type];
+ return this;
+ }
+
+ // emit removeListener for all listeners on all events
+ if (arguments.length === 0) {
+ for (key in this._events) {
+ if (key === 'removeListener') continue;
+ this.removeAllListeners(key);
+ }
+ this.removeAllListeners('removeListener');
+ this._events = {};
+ return this;
+ }
+
+ listeners = this._events[type];
+
+ if (isFunction(listeners)) {
+ this.removeListener(type, listeners);
+ } else {
+ // LIFO order
+ while (listeners.length)
+ this.removeListener(type, listeners[listeners.length - 1]);
+ }
+ delete this._events[type];
+
+ return this;
+};
+
+EventEmitter.prototype.listeners = function(type) {
+ var ret;
+ if (!this._events || !this._events[type])
+ ret = [];
+ else if (isFunction(this._events[type]))
+ ret = [this._events[type]];
+ else
+ ret = this._events[type].slice();
+ return ret;
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+ var ret;
+ if (!emitter._events || !emitter._events[type])
+ ret = 0;
+ else if (isFunction(emitter._events[type]))
+ ret = 1;
+ else
+ ret = emitter._events[type].length;
+ return ret;
+};
+
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+
+function isUndefined(arg) {
+ return arg === void 0;
+}
+
+},{}],19:[function(require,module,exports){
+// shim for using process in browser
+
+var process = module.exports = {};
+
+process.nextTick = (function () {
+ var canSetImmediate = typeof window !== 'undefined'
+ && window.setImmediate;
+ var canPost = typeof window !== 'undefined'
+ && window.postMessage && window.addEventListener
+ ;
+
+ if (canSetImmediate) {
+ return function (f) { return window.setImmediate(f) };
+ }
+
+ if (canPost) {
+ var queue = [];
+ window.addEventListener('message', function (ev) {
+ var source = ev.source;
+ if ((source === window || source === null) && ev.data === 'process-tick') {
+ ev.stopPropagation();
+ if (queue.length > 0) {
+ var fn = queue.shift();
+ fn();
+ }
+ }
+ }, true);
+
+ return function nextTick(fn) {
+ queue.push(fn);
+ window.postMessage('process-tick', '*');
+ };
+ }
+
+ return function nextTick(fn) {
+ setTimeout(fn, 0);
+ };
+})();
+
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+
+process.binding = function (name) {
+ throw new Error('process.binding is not supported');
+}
+
+// TODO(shtylman)
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+ throw new Error('process.chdir is not supported');
+};
+
+},{}],20:[function(require,module,exports){
+var base64 = require('base64-js')
+var ieee754 = require('ieee754')
+
+exports.Buffer = Buffer
+exports.SlowBuffer = Buffer
+exports.INSPECT_MAX_BYTES = 50
+Buffer.poolSize = 8192
+
+/**
+ * If `Buffer._useTypedArrays`:
+ * === true Use Uint8Array implementation (fastest)
+ * === false Use Object implementation (compatible down to IE6)
+ */
+Buffer._useTypedArrays = (function () {
+ // Detect if browser supports Typed Arrays. Supported browsers are IE 10+,
+ // Firefox 4+, Chrome 7+, Safari 5.1+, Opera 11.6+, iOS 4.2+.
+ if (typeof Uint8Array === 'undefined' || typeof ArrayBuffer === 'undefined')
+ return false
+
+ // Does the browser support adding properties to `Uint8Array` instances? If
+ // not, then that's the same as no `Uint8Array` support. We need to be able to
+ // add all the node Buffer API methods.
+ // Relevant Firefox bug: https://bugzilla.mozilla.org/show_bug.cgi?id=695438
+ try {
+ var arr = new Uint8Array(0)
+ arr.foo = function () { return 42 }
+ return 42 === arr.foo() &&
+ typeof arr.subarray === 'function' // Chrome 9-10 lack `subarray`
+ } catch (e) {
+ return false
+ }
+})()
+
+/**
+ * Class: Buffer
+ * =============
+ *
+ * The Buffer constructor returns instances of `Uint8Array` that are augmented
+ * with function properties for all the node `Buffer` API functions. We use
+ * `Uint8Array` so that square bracket notation works as expected -- it returns
+ * a single octet.
+ *
+ * By augmenting the instances, we can avoid modifying the `Uint8Array`
+ * prototype.
+ */
+function Buffer (subject, encoding, noZero) {
+ if (!(this instanceof Buffer))
+ return new Buffer(subject, encoding, noZero)
+
+ var type = typeof subject
+
+ // Workaround: node's base64 implementation allows for non-padded strings
+ // while base64-js does not.
+ if (encoding === 'base64' && type === 'string') {
+ subject = stringtrim(subject)
+ while (subject.length % 4 !== 0) {
+ subject = subject + '='
+ }
+ }
+
+ // Find the length
+ var length
+ if (type === 'number')
+ length = coerce(subject)
+ else if (type === 'string')
+ length = Buffer.byteLength(subject, encoding)
+ else if (type === 'object')
+ length = coerce(subject.length) // Assume object is an array
+ else
+ throw new Error('First argument needs to be a number, array or string.')
+
+ var buf
+ if (Buffer._useTypedArrays) {
+ // Preferred: Return an augmented `Uint8Array` instance for best performance
+ buf = augment(new Uint8Array(length))
+ } else {
+ // Fallback: Return THIS instance of Buffer (created by `new`)
+ buf = this
+ buf.length = length
+ buf._isBuffer = true
+ }
+
+ var i
+ if (Buffer._useTypedArrays && typeof Uint8Array === 'function' &&
+ subject instanceof Uint8Array) {
+ // Speed optimization -- use set if we're copying from a Uint8Array
+ buf._set(subject)
+ } else if (isArrayish(subject)) {
+ // Treat array-ish objects as a byte array
+ for (i = 0; i < length; i++) {
+ if (Buffer.isBuffer(subject))
+ buf[i] = subject.readUInt8(i)
+ else
+ buf[i] = subject[i]
+ }
+ } else if (type === 'string') {
+ buf.write(subject, 0, encoding)
+ } else if (type === 'number' && !Buffer._useTypedArrays && !noZero) {
+ for (i = 0; i < length; i++) {
+ buf[i] = 0
+ }
+ }
+
+ return buf
+}
+
+// STATIC METHODS
+// ==============
+
+Buffer.isEncoding = function (encoding) {
+ switch (String(encoding).toLowerCase()) {
+ case 'hex':
+ case 'utf8':
+ case 'utf-8':
+ case 'ascii':
+ case 'binary':
+ case 'base64':
+ case 'raw':
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return true
+ default:
+ return false
+ }
+}
+
+Buffer.isBuffer = function (b) {
+ return !!(b !== null && b !== undefined && b._isBuffer)
+}
+
+Buffer.byteLength = function (str, encoding) {
+ var ret
+ str = str + ''
+ switch (encoding || 'utf8') {
+ case 'hex':
+ ret = str.length / 2
+ break
+ case 'utf8':
+ case 'utf-8':
+ ret = utf8ToBytes(str).length
+ break
+ case 'ascii':
+ case 'binary':
+ case 'raw':
+ ret = str.length
+ break
+ case 'base64':
+ ret = base64ToBytes(str).length
+ break
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ ret = str.length * 2
+ break
+ default:
+ throw new Error('Unknown encoding')
+ }
+ return ret
+}
+
+Buffer.concat = function (list, totalLength) {
+ assert(isArray(list), 'Usage: Buffer.concat(list, [totalLength])\n' +
+ 'list should be an Array.')
+
+ if (list.length === 0) {
+ return new Buffer(0)
+ } else if (list.length === 1) {
+ return list[0]
+ }
+
+ var i
+ if (typeof totalLength !== 'number') {
+ totalLength = 0
+ for (i = 0; i < list.length; i++) {
+ totalLength += list[i].length
+ }
+ }
+
+ var buf = new Buffer(totalLength)
+ var pos = 0
+ for (i = 0; i < list.length; i++) {
+ var item = list[i]
+ item.copy(buf, pos)
+ pos += item.length
+ }
+ return buf
+}
+
+// BUFFER INSTANCE METHODS
+// =======================
+
+function _hexWrite (buf, string, offset, length) {
+ offset = Number(offset) || 0
+ var remaining = buf.length - offset
+ if (!length) {
+ length = remaining
+ } else {
+ length = Number(length)
+ if (length > remaining) {
+ length = remaining
+ }
+ }
+
+ // must be an even number of digits
+ var strLen = string.length
+ assert(strLen % 2 === 0, 'Invalid hex string')
+
+ if (length > strLen / 2) {
+ length = strLen / 2
+ }
+ for (var i = 0; i < length; i++) {
+ var byte = parseInt(string.substr(i * 2, 2), 16)
+ assert(!isNaN(byte), 'Invalid hex string')
+ buf[offset + i] = byte
+ }
+ Buffer._charsWritten = i * 2
+ return i
+}
+
+function _utf8Write (buf, string, offset, length) {
+ var charsWritten = Buffer._charsWritten =
+ blitBuffer(utf8ToBytes(string), buf, offset, length)
+ return charsWritten
+}
+
+function _asciiWrite (buf, string, offset, length) {
+ var charsWritten = Buffer._charsWritten =
+ blitBuffer(asciiToBytes(string), buf, offset, length)
+ return charsWritten
+}
+
+function _binaryWrite (buf, string, offset, length) {
+ return _asciiWrite(buf, string, offset, length)
+}
+
+function _base64Write (buf, string, offset, length) {
+ var charsWritten = Buffer._charsWritten =
+ blitBuffer(base64ToBytes(string), buf, offset, length)
+ return charsWritten
+}
+
+Buffer.prototype.write = function (string, offset, length, encoding) {
+ // Support both (string, offset, length, encoding)
+ // and the legacy (string, encoding, offset, length)
+ if (isFinite(offset)) {
+ if (!isFinite(length)) {
+ encoding = length
+ length = undefined
+ }
+ } else { // legacy
+ var swap = encoding
+ encoding = offset
+ offset = length
+ length = swap
+ }
+
+ offset = Number(offset) || 0
+ var remaining = this.length - offset
+ if (!length) {
+ length = remaining
+ } else {
+ length = Number(length)
+ if (length > remaining) {
+ length = remaining
+ }
+ }
+ encoding = String(encoding || 'utf8').toLowerCase()
+
+ switch (encoding) {
+ case 'hex':
+ return _hexWrite(this, string, offset, length)
+ case 'utf8':
+ case 'utf-8':
+ case 'ucs2': // TODO: No support for ucs2 or utf16le encodings yet
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return _utf8Write(this, string, offset, length)
+ case 'ascii':
+ return _asciiWrite(this, string, offset, length)
+ case 'binary':
+ return _binaryWrite(this, string, offset, length)
+ case 'base64':
+ return _base64Write(this, string, offset, length)
+ default:
+ throw new Error('Unknown encoding')
+ }
+}
+
+Buffer.prototype.toString = function (encoding, start, end) {
+ var self = this
+
+ encoding = String(encoding || 'utf8').toLowerCase()
+ start = Number(start) || 0
+ end = (end !== undefined)
+ ? Number(end)
+ : end = self.length
+
+ // Fastpath empty strings
+ if (end === start)
+ return ''
+
+ switch (encoding) {
+ case 'hex':
+ return _hexSlice(self, start, end)
+ case 'utf8':
+ case 'utf-8':
+ case 'ucs2': // TODO: No support for ucs2 or utf16le encodings yet
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return _utf8Slice(self, start, end)
+ case 'ascii':
+ return _asciiSlice(self, start, end)
+ case 'binary':
+ return _binarySlice(self, start, end)
+ case 'base64':
+ return _base64Slice(self, start, end)
+ default:
+ throw new Error('Unknown encoding')
+ }
+}
+
+Buffer.prototype.toJSON = function () {
+ return {
+ type: 'Buffer',
+ data: Array.prototype.slice.call(this._arr || this, 0)
+ }
+}
+
+// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
+Buffer.prototype.copy = function (target, target_start, start, end) {
+ var source = this
+
+ if (!start) start = 0
+ if (!end && end !== 0) end = this.length
+ if (!target_start) target_start = 0
+
+ // Copy 0 bytes; we're done
+ if (end === start) return
+ if (target.length === 0 || source.length === 0) return
+
+ // Fatal error conditions
+ assert(end >= start, 'sourceEnd < sourceStart')
+ assert(target_start >= 0 && target_start < target.length,
+ 'targetStart out of bounds')
+ assert(start >= 0 && start < source.length, 'sourceStart out of bounds')
+ assert(end >= 0 && end <= source.length, 'sourceEnd out of bounds')
+
+ // Are we oob?
+ if (end > this.length)
+ end = this.length
+ if (target.length - target_start < end - start)
+ end = target.length - target_start + start
+
+ // copy!
+ for (var i = 0; i < end - start; i++)
+ target[i + target_start] = this[i + start]
+}
+
+function _base64Slice (buf, start, end) {
+ if (start === 0 && end === buf.length) {
+ return base64.fromByteArray(buf)
+ } else {
+ return base64.fromByteArray(buf.slice(start, end))
+ }
+}
+
+function _utf8Slice (buf, start, end) {
+ var res = ''
+ var tmp = ''
+ end = Math.min(buf.length, end)
+
+ for (var i = start; i < end; i++) {
+ if (buf[i] <= 0x7F) {
+ res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i])
+ tmp = ''
+ } else {
+ tmp += '%' + buf[i].toString(16)
+ }
+ }
+
+ return res + decodeUtf8Char(tmp)
+}
+
+function _asciiSlice (buf, start, end) {
+ var ret = ''
+ end = Math.min(buf.length, end)
+
+ for (var i = start; i < end; i++)
+ ret += String.fromCharCode(buf[i])
+ return ret
+}
+
+function _binarySlice (buf, start, end) {
+ return _asciiSlice(buf, start, end)
+}
+
+function _hexSlice (buf, start, end) {
+ var len = buf.length
+
+ if (!start || start < 0) start = 0
+ if (!end || end < 0 || end > len) end = len
+
+ var out = ''
+ for (var i = start; i < end; i++) {
+ out += toHex(buf[i])
+ }
+ return out
+}
+
+// http://nodejs.org/api/buffer.html#buffer_buf_slice_start_end
+Buffer.prototype.slice = function (start, end) {
+ var len = this.length
+ start = clamp(start, len, 0)
+ end = clamp(end, len, len)
+
+ if (Buffer._useTypedArrays) {
+ return augment(this.subarray(start, end))
+ } else {
+ var sliceLen = end - start
+ var newBuf = new Buffer(sliceLen, undefined, true)
+ for (var i = 0; i < sliceLen; i++) {
+ newBuf[i] = this[i + start]
+ }
+ return newBuf
+ }
+}
+
+// `get` will be removed in Node 0.13+
+Buffer.prototype.get = function (offset) {
+ console.log('.get() is deprecated. Access using array indexes instead.')
+ return this.readUInt8(offset)
+}
+
+// `set` will be removed in Node 0.13+
+Buffer.prototype.set = function (v, offset) {
+ console.log('.set() is deprecated. Access using array indexes instead.')
+ return this.writeUInt8(v, offset)
+}
+
+Buffer.prototype.readUInt8 = function (offset, noAssert) {
+ if (!noAssert) {
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset < this.length, 'Trying to read beyond buffer length')
+ }
+
+ if (offset >= this.length)
+ return
+
+ return this[offset]
+}
+
+function _readUInt16 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val
+ if (littleEndian) {
+ val = buf[offset]
+ if (offset + 1 < len)
+ val |= buf[offset + 1] << 8
+ } else {
+ val = buf[offset] << 8
+ if (offset + 1 < len)
+ val |= buf[offset + 1]
+ }
+ return val
+}
+
+Buffer.prototype.readUInt16LE = function (offset, noAssert) {
+ return _readUInt16(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readUInt16BE = function (offset, noAssert) {
+ return _readUInt16(this, offset, false, noAssert)
+}
+
+function _readUInt32 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val
+ if (littleEndian) {
+ if (offset + 2 < len)
+ val = buf[offset + 2] << 16
+ if (offset + 1 < len)
+ val |= buf[offset + 1] << 8
+ val |= buf[offset]
+ if (offset + 3 < len)
+ val = val + (buf[offset + 3] << 24 >>> 0)
+ } else {
+ if (offset + 1 < len)
+ val = buf[offset + 1] << 16
+ if (offset + 2 < len)
+ val |= buf[offset + 2] << 8
+ if (offset + 3 < len)
+ val |= buf[offset + 3]
+ val = val + (buf[offset] << 24 >>> 0)
+ }
+ return val
+}
+
+Buffer.prototype.readUInt32LE = function (offset, noAssert) {
+ return _readUInt32(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readUInt32BE = function (offset, noAssert) {
+ return _readUInt32(this, offset, false, noAssert)
+}
+
+Buffer.prototype.readInt8 = function (offset, noAssert) {
+ if (!noAssert) {
+ assert(offset !== undefined && offset !== null,
+ 'missing offset')
+ assert(offset < this.length, 'Trying to read beyond buffer length')
+ }
+
+ if (offset >= this.length)
+ return
+
+ var neg = this[offset] & 0x80
+ if (neg)
+ return (0xff - this[offset] + 1) * -1
+ else
+ return this[offset]
+}
+
+function _readInt16 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val = _readUInt16(buf, offset, littleEndian, true)
+ var neg = val & 0x8000
+ if (neg)
+ return (0xffff - val + 1) * -1
+ else
+ return val
+}
+
+Buffer.prototype.readInt16LE = function (offset, noAssert) {
+ return _readInt16(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readInt16BE = function (offset, noAssert) {
+ return _readInt16(this, offset, false, noAssert)
+}
+
+function _readInt32 (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ var val = _readUInt32(buf, offset, littleEndian, true)
+ var neg = val & 0x80000000
+ if (neg)
+ return (0xffffffff - val + 1) * -1
+ else
+ return val
+}
+
+Buffer.prototype.readInt32LE = function (offset, noAssert) {
+ return _readInt32(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readInt32BE = function (offset, noAssert) {
+ return _readInt32(this, offset, false, noAssert)
+}
+
+function _readFloat (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ return ieee754.read(buf, offset, littleEndian, 23, 4)
+}
+
+Buffer.prototype.readFloatLE = function (offset, noAssert) {
+ return _readFloat(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readFloatBE = function (offset, noAssert) {
+ return _readFloat(this, offset, false, noAssert)
+}
+
+function _readDouble (buf, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset + 7 < buf.length, 'Trying to read beyond buffer length')
+ }
+
+ return ieee754.read(buf, offset, littleEndian, 52, 8)
+}
+
+Buffer.prototype.readDoubleLE = function (offset, noAssert) {
+ return _readDouble(this, offset, true, noAssert)
+}
+
+Buffer.prototype.readDoubleBE = function (offset, noAssert) {
+ return _readDouble(this, offset, false, noAssert)
+}
+
+Buffer.prototype.writeUInt8 = function (value, offset, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset < this.length, 'trying to write beyond buffer length')
+ verifuint(value, 0xff)
+ }
+
+ if (offset >= this.length) return
+
+ this[offset] = value
+}
+
+function _writeUInt16 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'trying to write beyond buffer length')
+ verifuint(value, 0xffff)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ for (var i = 0, j = Math.min(len - offset, 2); i < j; i++) {
+ buf[offset + i] =
+ (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
+ (littleEndian ? i : 1 - i) * 8
+ }
+}
+
+Buffer.prototype.writeUInt16LE = function (value, offset, noAssert) {
+ _writeUInt16(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeUInt16BE = function (value, offset, noAssert) {
+ _writeUInt16(this, value, offset, false, noAssert)
+}
+
+function _writeUInt32 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'trying to write beyond buffer length')
+ verifuint(value, 0xffffffff)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ for (var i = 0, j = Math.min(len - offset, 4); i < j; i++) {
+ buf[offset + i] =
+ (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
+ }
+}
+
+Buffer.prototype.writeUInt32LE = function (value, offset, noAssert) {
+ _writeUInt32(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeUInt32BE = function (value, offset, noAssert) {
+ _writeUInt32(this, value, offset, false, noAssert)
+}
+
+Buffer.prototype.writeInt8 = function (value, offset, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset < this.length, 'Trying to write beyond buffer length')
+ verifsint(value, 0x7f, -0x80)
+ }
+
+ if (offset >= this.length)
+ return
+
+ if (value >= 0)
+ this.writeUInt8(value, offset, noAssert)
+ else
+ this.writeUInt8(0xff + value + 1, offset, noAssert)
+}
+
+function _writeInt16 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 1 < buf.length, 'Trying to write beyond buffer length')
+ verifsint(value, 0x7fff, -0x8000)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ if (value >= 0)
+ _writeUInt16(buf, value, offset, littleEndian, noAssert)
+ else
+ _writeUInt16(buf, 0xffff + value + 1, offset, littleEndian, noAssert)
+}
+
+Buffer.prototype.writeInt16LE = function (value, offset, noAssert) {
+ _writeInt16(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeInt16BE = function (value, offset, noAssert) {
+ _writeInt16(this, value, offset, false, noAssert)
+}
+
+function _writeInt32 (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')
+ verifsint(value, 0x7fffffff, -0x80000000)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ if (value >= 0)
+ _writeUInt32(buf, value, offset, littleEndian, noAssert)
+ else
+ _writeUInt32(buf, 0xffffffff + value + 1, offset, littleEndian, noAssert)
+}
+
+Buffer.prototype.writeInt32LE = function (value, offset, noAssert) {
+ _writeInt32(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeInt32BE = function (value, offset, noAssert) {
+ _writeInt32(this, value, offset, false, noAssert)
+}
+
+function _writeFloat (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')
+ verifIEEE754(value, 3.4028234663852886e+38, -3.4028234663852886e+38)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ ieee754.write(buf, value, offset, littleEndian, 23, 4)
+}
+
+Buffer.prototype.writeFloatLE = function (value, offset, noAssert) {
+ _writeFloat(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeFloatBE = function (value, offset, noAssert) {
+ _writeFloat(this, value, offset, false, noAssert)
+}
+
+function _writeDouble (buf, value, offset, littleEndian, noAssert) {
+ if (!noAssert) {
+ assert(value !== undefined && value !== null, 'missing value')
+ assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
+ assert(offset !== undefined && offset !== null, 'missing offset')
+ assert(offset + 7 < buf.length,
+ 'Trying to write beyond buffer length')
+ verifIEEE754(value, 1.7976931348623157E+308, -1.7976931348623157E+308)
+ }
+
+ var len = buf.length
+ if (offset >= len)
+ return
+
+ ieee754.write(buf, value, offset, littleEndian, 52, 8)
+}
+
+Buffer.prototype.writeDoubleLE = function (value, offset, noAssert) {
+ _writeDouble(this, value, offset, true, noAssert)
+}
+
+Buffer.prototype.writeDoubleBE = function (value, offset, noAssert) {
+ _writeDouble(this, value, offset, false, noAssert)
+}
+
+// fill(value, start=0, end=buffer.length)
+Buffer.prototype.fill = function (value, start, end) {
+ if (!value) value = 0
+ if (!start) start = 0
+ if (!end) end = this.length
+
+ if (typeof value === 'string') {
+ value = value.charCodeAt(0)
+ }
+
+ assert(typeof value === 'number' && !isNaN(value), 'value is not a number')
+ assert(end >= start, 'end < start')
+
+ // Fill 0 bytes; we're done
+ if (end === start) return
+ if (this.length === 0) return
+
+ assert(start >= 0 && start < this.length, 'start out of bounds')
+ assert(end >= 0 && end <= this.length, 'end out of bounds')
+
+ for (var i = start; i < end; i++) {
+ this[i] = value
+ }
+}
+
+Buffer.prototype.inspect = function () {
+ var out = []
+ var len = this.length
+ for (var i = 0; i < len; i++) {
+ out[i] = toHex(this[i])
+ if (i === exports.INSPECT_MAX_BYTES) {
+ out[i + 1] = '...'
+ break
+ }
+ }
+ return '<Buffer ' + out.join(' ') + '>'
+}
+
+/**
+ * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.
+ * Added in Node 0.12. Only available in browsers that support ArrayBuffer.
+ */
+Buffer.prototype.toArrayBuffer = function () {
+ if (typeof Uint8Array === 'function') {
+ if (Buffer._useTypedArrays) {
+ return (new Buffer(this)).buffer
+ } else {
+ var buf = new Uint8Array(this.length)
+ for (var i = 0, len = buf.length; i < len; i += 1)
+ buf[i] = this[i]
+ return buf.buffer
+ }
+ } else {
+ throw new Error('Buffer.toArrayBuffer not supported in this browser')
+ }
+}
+
+// HELPER FUNCTIONS
+// ================
+
+function stringtrim (str) {
+ if (str.trim) return str.trim()
+ return str.replace(/^\s+|\s+$/g, '')
+}
+
+var BP = Buffer.prototype
+
+/**
+ * Augment the Uint8Array *instance* (not the class!) with Buffer methods
+ */
+function augment (arr) {
+ arr._isBuffer = true
+
+ // save reference to original Uint8Array get/set methods before overwriting
+ arr._get = arr.get
+ arr._set = arr.set
+
+ // deprecated, will be removed in node 0.13+
+ arr.get = BP.get
+ arr.set = BP.set
+
+ arr.write = BP.write
+ arr.toString = BP.toString
+ arr.toLocaleString = BP.toString
+ arr.toJSON = BP.toJSON
+ arr.copy = BP.copy
+ arr.slice = BP.slice
+ arr.readUInt8 = BP.readUInt8
+ arr.readUInt16LE = BP.readUInt16LE
+ arr.readUInt16BE = BP.readUInt16BE
+ arr.readUInt32LE = BP.readUInt32LE
+ arr.readUInt32BE = BP.readUInt32BE
+ arr.readInt8 = BP.readInt8
+ arr.readInt16LE = BP.readInt16LE
+ arr.readInt16BE = BP.readInt16BE
+ arr.readInt32LE = BP.readInt32LE
+ arr.readInt32BE = BP.readInt32BE
+ arr.readFloatLE = BP.readFloatLE
+ arr.readFloatBE = BP.readFloatBE
+ arr.readDoubleLE = BP.readDoubleLE
+ arr.readDoubleBE = BP.readDoubleBE
+ arr.writeUInt8 = BP.writeUInt8
+ arr.writeUInt16LE = BP.writeUInt16LE
+ arr.writeUInt16BE = BP.writeUInt16BE
+ arr.writeUInt32LE = BP.writeUInt32LE
+ arr.writeUInt32BE = BP.writeUInt32BE
+ arr.writeInt8 = BP.writeInt8
+ arr.writeInt16LE = BP.writeInt16LE
+ arr.writeInt16BE = BP.writeInt16BE
+ arr.writeInt32LE = BP.writeInt32LE
+ arr.writeInt32BE = BP.writeInt32BE
+ arr.writeFloatLE = BP.writeFloatLE
+ arr.writeFloatBE = BP.writeFloatBE
+ arr.writeDoubleLE = BP.writeDoubleLE
+ arr.writeDoubleBE = BP.writeDoubleBE
+ arr.fill = BP.fill
+ arr.inspect = BP.inspect
+ arr.toArrayBuffer = BP.toArrayBuffer
+
+ return arr
+}
+
+// slice(start, end)
+function clamp (index, len, defaultValue) {
+ if (typeof index !== 'number') return defaultValue
+ index = ~~index; // Coerce to integer.
+ if (index >= len) return len
+ if (index >= 0) return index
+ index += len
+ if (index >= 0) return index
+ return 0
+}
+
+function coerce (length) {
+ // Coerce length to a number (possibly NaN), round up
+ // in case it's fractional (e.g. 123.456) then do a
+ // double negate to coerce a NaN to 0. Easy, right?
+ length = ~~Math.ceil(+length)
+ return length < 0 ? 0 : length
+}
+
+function isArray (subject) {
+ return (Array.isArray || function (subject) {
+ return Object.prototype.toString.call(subject) === '[object Array]'
+ })(subject)
+}
+
+function isArrayish (subject) {
+ return isArray(subject) || Buffer.isBuffer(subject) ||
+ subject && typeof subject === 'object' &&
+ typeof subject.length === 'number'
+}
+
+function toHex (n) {
+ if (n < 16) return '0' + n.toString(16)
+ return n.toString(16)
+}
+
+function utf8ToBytes (str) {
+ var byteArray = []
+ for (var i = 0; i < str.length; i++) {
+ var b = str.charCodeAt(i)
+ if (b <= 0x7F)
+ byteArray.push(str.charCodeAt(i))
+ else {
+ var start = i
+ if (b >= 0xD800 && b <= 0xDFFF) i++
+ var h = encodeURIComponent(str.slice(start, i+1)).substr(1).split('%')
+ for (var j = 0; j < h.length; j++)
+ byteArray.push(parseInt(h[j], 16))
+ }
+ }
+ return byteArray
+}
+
+function asciiToBytes (str) {
+ var byteArray = []
+ for (var i = 0; i < str.length; i++) {
+ // Node's code seems to be doing this and not & 0x7F..
+ byteArray.push(str.charCodeAt(i) & 0xFF)
+ }
+ return byteArray
+}
+
+function base64ToBytes (str) {
+ return base64.toByteArray(str)
+}
+
+function blitBuffer (src, dst, offset, length) {
+ var pos
+ for (var i = 0; i < length; i++) {
+ if ((i + offset >= dst.length) || (i >= src.length))
+ break
+ dst[i + offset] = src[i]
+ }
+ return i
+}
+
+function decodeUtf8Char (str) {
+ try {
+ return decodeURIComponent(str)
+ } catch (err) {
+ return String.fromCharCode(0xFFFD) // UTF 8 invalid char
+ }
+}
+
+/*
+ * We have to make sure that the value is a valid integer. This means that it
+ * is non-negative. It has no fractional component and that it does not
+ * exceed the maximum allowed value.
+ */
+function verifuint (value, max) {
+ assert(typeof value == 'number', 'cannot write a non-number as a number')
+ assert(value >= 0,
+ 'specified a negative value for writing an unsigned value')
+ assert(value <= max, 'value is larger than maximum value for type')
+ assert(Math.floor(value) === value, 'value has a fractional component')
+}
+
+function verifsint(value, max, min) {
+ assert(typeof value == 'number', 'cannot write a non-number as a number')
+ assert(value <= max, 'value larger than maximum allowed value')
+ assert(value >= min, 'value smaller than minimum allowed value')
+ assert(Math.floor(value) === value, 'value has a fractional component')
+}
+
+function verifIEEE754(value, max, min) {
+ assert(typeof value == 'number', 'cannot write a non-number as a number')
+ assert(value <= max, 'value larger than maximum allowed value')
+ assert(value >= min, 'value smaller than minimum allowed value')
+}
+
+function assert (test, message) {
+ if (!test) throw new Error(message || 'Failed assertion')
+}
+
+},{"base64-js":21,"ieee754":22}],21:[function(require,module,exports){
+var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+;(function (exports) {
+ 'use strict';
+
+ var Arr = (typeof Uint8Array !== 'undefined')
+ ? Uint8Array
+ : Array
+
+ var PLUS = '+'.charCodeAt(0)
+ var SLASH = '/'.charCodeAt(0)
+ var NUMBER = '0'.charCodeAt(0)
+ var LOWER = 'a'.charCodeAt(0)
+ var UPPER = 'A'.charCodeAt(0)
+
+ function decode (elt) {
+ var code = elt.charCodeAt(0)
+ if (code === PLUS)
+ return 62 // '+'
+ if (code === SLASH)
+ return 63 // '/'
+ if (code < NUMBER)
+ return -1 //no match
+ if (code < NUMBER + 10)
+ return code - NUMBER + 26 + 26
+ if (code < UPPER + 26)
+ return code - UPPER
+ if (code < LOWER + 26)
+ return code - LOWER + 26
+ }
+
+ function b64ToByteArray (b64) {
+ var i, j, l, tmp, placeHolders, arr
+
+ if (b64.length % 4 > 0) {
+ throw new Error('Invalid string. Length must be a multiple of 4')
+ }
+
+ // the number of equal signs (place holders)
+ // if there are two placeholders, than the two characters before it
+ // represent one byte
+ // if there is only one, then the three characters before it represent 2 bytes
+ // this is just a cheap hack to not do indexOf twice
+ var len = b64.length
+ placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0
+
+ // base64 is 4/3 + up to two characters of the original data
+ arr = new Arr(b64.length * 3 / 4 - placeHolders)
+
+ // if there are placeholders, only get up to the last complete 4 chars
+ l = placeHolders > 0 ? b64.length - 4 : b64.length
+
+ var L = 0
+
+ function push (v) {
+ arr[L++] = v
+ }
+
+ for (i = 0, j = 0; i < l; i += 4, j += 3) {
+ tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))
+ push((tmp & 0xFF0000) >> 16)
+ push((tmp & 0xFF00) >> 8)
+ push(tmp & 0xFF)
+ }
+
+ if (placeHolders === 2) {
+ tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)
+ push(tmp & 0xFF)
+ } else if (placeHolders === 1) {
+ tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)
+ push((tmp >> 8) & 0xFF)
+ push(tmp & 0xFF)
+ }
+
+ return arr
+ }
+
+ function uint8ToBase64 (uint8) {
+ var i,
+ extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
+ output = "",
+ temp, length
+
+ function encode (num) {
+ return lookup.charAt(num)
+ }
+
+ function tripletToBase64 (num) {
+ return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)
+ }
+
+ // go through the array every three bytes, we'll deal with trailing stuff later
+ for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
+ temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
+ output += tripletToBase64(temp)
+ }
+
+ // pad the end with zeros, but make sure to not forget the extra bytes
+ switch (extraBytes) {
+ case 1:
+ temp = uint8[uint8.length - 1]
+ output += encode(temp >> 2)
+ output += encode((temp << 4) & 0x3F)
+ output += '=='
+ break
+ case 2:
+ temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])
+ output += encode(temp >> 10)
+ output += encode((temp >> 4) & 0x3F)
+ output += encode((temp << 2) & 0x3F)
+ output += '='
+ break
+ }
+
+ return output
+ }
+
+ exports.toByteArray = b64ToByteArray
+ exports.fromByteArray = uint8ToBase64
+}(typeof exports === 'undefined' ? (this.base64js = {}) : exports))
+
+},{}],22:[function(require,module,exports){
+exports.read = function(buffer, offset, isLE, mLen, nBytes) {
+ var e, m,
+ eLen = nBytes * 8 - mLen - 1,
+ eMax = (1 << eLen) - 1,
+ eBias = eMax >> 1,
+ nBits = -7,
+ i = isLE ? (nBytes - 1) : 0,
+ d = isLE ? -1 : 1,
+ s = buffer[offset + i];
+
+ i += d;
+
+ e = s & ((1 << (-nBits)) - 1);
+ s >>= (-nBits);
+ nBits += eLen;
+ for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);
+
+ m = e & ((1 << (-nBits)) - 1);
+ e >>= (-nBits);
+ nBits += mLen;
+ for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);
+
+ if (e === 0) {
+ e = 1 - eBias;
+ } else if (e === eMax) {
+ return m ? NaN : ((s ? -1 : 1) * Infinity);
+ } else {
+ m = m + Math.pow(2, mLen);
+ e = e - eBias;
+ }
+ return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+};
+
+exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
+ var e, m, c,
+ eLen = nBytes * 8 - mLen - 1,
+ eMax = (1 << eLen) - 1,
+ eBias = eMax >> 1,
+ rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),
+ i = isLE ? 0 : (nBytes - 1),
+ d = isLE ? 1 : -1,
+ s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
+
+ value = Math.abs(value);
+
+ if (isNaN(value) || value === Infinity) {
+ m = isNaN(value) ? 1 : 0;
+ e = eMax;
+ } else {
+ e = Math.floor(Math.log(value) / Math.LN2);
+ if (value * (c = Math.pow(2, -e)) < 1) {
+ e--;
+ c *= 2;
+ }
+ if (e + eBias >= 1) {
+ value += rt / c;
+ } else {
+ value += rt * Math.pow(2, 1 - eBias);
+ }
+ if (value * c >= 2) {
+ e++;
+ c /= 2;
+ }
+
+ if (e + eBias >= eMax) {
+ m = 0;
+ e = eMax;
+ } else if (e + eBias >= 1) {
+ m = (value * c - 1) * Math.pow(2, mLen);
+ e = e + eBias;
+ } else {
+ m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+ e = 0;
+ }
+ }
+
+ for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8);
+
+ e = (e << mLen) | m;
+ eLen += mLen;
+ for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8);
+
+ buffer[offset + i - d] |= s * 128;
+};
+
+},{}],23:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototypal inheritance, this class
+// prototypally inherits from Readable, and then parasitically from
+// Writable.
+
+module.exports = Duplex;
+var inherits = require('inherits');
+var setImmediate = require('process/browser.js').nextTick;
+var Readable = require('./readable.js');
+var Writable = require('./writable.js');
+
+inherits(Duplex, Readable);
+
+Duplex.prototype.write = Writable.prototype.write;
+Duplex.prototype.end = Writable.prototype.end;
+Duplex.prototype._write = Writable.prototype._write;
+
+function Duplex(options) {
+ if (!(this instanceof Duplex))
+ return new Duplex(options);
+
+ Readable.call(this, options);
+ Writable.call(this, options);
+
+ if (options && options.readable === false)
+ this.readable = false;
+
+ if (options && options.writable === false)
+ this.writable = false;
+
+ this.allowHalfOpen = true;
+ if (options && options.allowHalfOpen === false)
+ this.allowHalfOpen = false;
+
+ this.once('end', onend);
+}
+
+// the no-half-open enforcer
+function onend() {
+ // if we allow half-open state, or if the writable side ended,
+ // then we're ok.
+ if (this.allowHalfOpen || this._writableState.ended)
+ return;
+
+ // no more data can be written.
+ // But allow more writes to happen in this tick.
+ var self = this;
+ setImmediate(function () {
+ self.end();
+ });
+}
+
+},{"./readable.js":27,"./writable.js":29,"inherits":33,"process/browser.js":25}],24:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module.exports = Stream;
+
+var EE = require('events').EventEmitter;
+var inherits = require('inherits');
+
+inherits(Stream, EE);
+Stream.Readable = require('./readable.js');
+Stream.Writable = require('./writable.js');
+Stream.Duplex = require('./duplex.js');
+Stream.Transform = require('./transform.js');
+Stream.PassThrough = require('./passthrough.js');
+
+// Backwards-compat with node 0.4.x
+Stream.Stream = Stream;
+
+
+
+// old-style streams. Note that the pipe method (the only relevant
+// part of this class) is overridden in the Readable class.
+
+function Stream() {
+ EE.call(this);
+}
+
+Stream.prototype.pipe = function(dest, options) {
+ var source = this;
+
+ function ondata(chunk) {
+ if (dest.writable) {
+ if (false === dest.write(chunk) && source.pause) {
+ source.pause();
+ }
+ }
+ }
+
+ source.on('data', ondata);
+
+ function ondrain() {
+ if (source.readable && source.resume) {
+ source.resume();
+ }
+ }
+
+ dest.on('drain', ondrain);
+
+ // If the 'end' option is not supplied, dest.end() will be called when
+ // source gets the 'end' or 'close' events. Only dest.end() once.
+ if (!dest._isStdio && (!options || options.end !== false)) {
+ source.on('end', onend);
+ source.on('close', onclose);
+ }
+
+ var didOnEnd = false;
+ function onend() {
+ if (didOnEnd) return;
+ didOnEnd = true;
+
+ dest.end();
+ }
+
+
+ function onclose() {
+ if (didOnEnd) return;
+ didOnEnd = true;
+
+ if (typeof dest.destroy === 'function') dest.destroy();
+ }
+
+ // don't leave dangling pipes when there are errors.
+ function onerror(er) {
+ cleanup();
+ if (EE.listenerCount(this, 'error') === 0) {
+ throw er; // Unhandled stream error in pipe.
+ }
+ }
+
+ source.on('error', onerror);
+ dest.on('error', onerror);
+
+ // remove all the event listeners that were added.
+ function cleanup() {
+ source.removeListener('data', ondata);
+ dest.removeListener('drain', ondrain);
+
+ source.removeListener('end', onend);
+ source.removeListener('close', onclose);
+
+ source.removeListener('error', onerror);
+ dest.removeListener('error', onerror);
+
+ source.removeListener('end', cleanup);
+ source.removeListener('close', cleanup);
+
+ dest.removeListener('close', cleanup);
+ }
+
+ source.on('end', cleanup);
+ source.on('close', cleanup);
+
+ dest.on('close', cleanup);
+
+ dest.emit('pipe', source);
+
+ // Allow for unix-like usage: A.pipe(B).pipe(C)
+ return dest;
+};
+
+},{"./duplex.js":23,"./passthrough.js":26,"./readable.js":27,"./transform.js":28,"./writable.js":29,"events":18,"inherits":33}],25:[function(require,module,exports){
+module.exports=require(19)
+},{}],26:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+
+module.exports = PassThrough;
+
+var Transform = require('./transform.js');
+var inherits = require('inherits');
+inherits(PassThrough, Transform);
+
+function PassThrough(options) {
+ if (!(this instanceof PassThrough))
+ return new PassThrough(options);
+
+ Transform.call(this, options);
+}
+
+PassThrough.prototype._transform = function(chunk, encoding, cb) {
+ cb(null, chunk);
+};
+
+},{"./transform.js":28,"inherits":33}],27:[function(require,module,exports){
+(function (process){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module.exports = Readable;
+Readable.ReadableState = ReadableState;
+
+var EE = require('events').EventEmitter;
+var Stream = require('./index.js');
+var Buffer = require('buffer').Buffer;
+var setImmediate = require('process/browser.js').nextTick;
+var StringDecoder;
+
+var inherits = require('inherits');
+inherits(Readable, Stream);
+
+function ReadableState(options, stream) {
+ options = options || {};
+
+ // the point at which it stops calling _read() to fill the buffer
+ // Note: 0 is a valid value, means "don't call _read preemptively ever"
+ var hwm = options.highWaterMark;
+ this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
+
+ // cast to ints.
+ this.highWaterMark = ~~this.highWaterMark;
+
+ this.buffer = [];
+ this.length = 0;
+ this.pipes = null;
+ this.pipesCount = 0;
+ this.flowing = false;
+ this.ended = false;
+ this.endEmitted = false;
+ this.reading = false;
+
+ // In streams that never have any data, and do push(null) right away,
+ // the consumer can miss the 'end' event if they do some I/O before
+ // consuming the stream. So, we don't emit('end') until some reading
+ // happens.
+ this.calledRead = false;
+
+ // a flag to be able to tell if the onwrite cb is called immediately,
+ // or on a later tick. We set this to true at first, becuase any
+ // actions that shouldn't happen until "later" should generally also
+ // not happen before the first write call.
+ this.sync = true;
+
+ // whenever we return null, then we set a flag to say
+ // that we're awaiting a 'readable' event emission.
+ this.needReadable = false;
+ this.emittedReadable = false;
+ this.readableListening = false;
+
+
+ // object stream flag. Used to make read(n) ignore n and to
+ // make all the buffer merging and length checks go away
+ this.objectMode = !!options.objectMode;
+
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+ // when piping, we only care about 'readable' events that happen
+ // after read()ing all the bytes and not getting any pushback.
+ this.ranOut = false;
+
+ // the number of writers that are awaiting a drain event in .pipe()s
+ this.awaitDrain = 0;
+
+ // if true, a maybeReadMore has been scheduled
+ this.readingMore = false;
+
+ this.decoder = null;
+ this.encoding = null;
+ if (options.encoding) {
+ if (!StringDecoder)
+ StringDecoder = require('string_decoder').StringDecoder;
+ this.decoder = new StringDecoder(options.encoding);
+ this.encoding = options.encoding;
+ }
+}
+
+function Readable(options) {
+ if (!(this instanceof Readable))
+ return new Readable(options);
+
+ this._readableState = new ReadableState(options, this);
+
+ // legacy
+ this.readable = true;
+
+ Stream.call(this);
+}
+
+// Manually shove something into the read() buffer.
+// This returns true if the highWaterMark has not been hit yet,
+// similar to how Writable.write() returns true if you should
+// write() some more.
+Readable.prototype.push = function(chunk, encoding) {
+ var state = this._readableState;
+
+ if (typeof chunk === 'string' && !state.objectMode) {
+ encoding = encoding || state.defaultEncoding;
+ if (encoding !== state.encoding) {
+ chunk = new Buffer(chunk, encoding);
+ encoding = '';
+ }
+ }
+
+ return readableAddChunk(this, state, chunk, encoding, false);
+};
+
+// Unshift should *always* be something directly out of read()
+Readable.prototype.unshift = function(chunk) {
+ var state = this._readableState;
+ return readableAddChunk(this, state, chunk, '', true);
+};
+
+function readableAddChunk(stream, state, chunk, encoding, addToFront) {
+ var er = chunkInvalid(state, chunk);
+ if (er) {
+ stream.emit('error', er);
+ } else if (chunk === null || chunk === undefined) {
+ state.reading = false;
+ if (!state.ended)
+ onEofChunk(stream, state);
+ } else if (state.objectMode || chunk && chunk.length > 0) {
+ if (state.ended && !addToFront) {
+ var e = new Error('stream.push() after EOF');
+ stream.emit('error', e);
+ } else if (state.endEmitted && addToFront) {
+ var e = new Error('stream.unshift() after end event');
+ stream.emit('error', e);
+ } else {
+ if (state.decoder && !addToFront && !encoding)
+ chunk = state.decoder.write(chunk);
+
+ // update the buffer info.
+ state.length += state.objectMode ? 1 : chunk.length;
+ if (addToFront) {
+ state.buffer.unshift(chunk);
+ } else {
+ state.reading = false;
+ state.buffer.push(chunk);
+ }
+
+ if (state.needReadable)
+ emitReadable(stream);
+
+ maybeReadMore(stream, state);
+ }
+ } else if (!addToFront) {
+ state.reading = false;
+ }
+
+ return needMoreData(state);
+}
+
+
+
+// if it's past the high water mark, we can push in some more.
+// Also, if we have no data yet, we can stand some
+// more bytes. This is to work around cases where hwm=0,
+// such as the repl. Also, if the push() triggered a
+// readable event, and the user called read(largeNumber) such that
+// needReadable was set, then we ought to push more, so that another
+// 'readable' event will be triggered.
+function needMoreData(state) {
+ return !state.ended &&
+ (state.needReadable ||
+ state.length < state.highWaterMark ||
+ state.length === 0);
+}
+
+// backwards compatibility.
+Readable.prototype.setEncoding = function(enc) {
+ if (!StringDecoder)
+ StringDecoder = require('string_decoder').StringDecoder;
+ this._readableState.decoder = new StringDecoder(enc);
+ this._readableState.encoding = enc;
+};
+
+// Don't raise the hwm > 128MB
+var MAX_HWM = 0x800000;
+function roundUpToNextPowerOf2(n) {
+ if (n >= MAX_HWM) {
+ n = MAX_HWM;
+ } else {
+ // Get the next highest power of 2
+ n--;
+ for (var p = 1; p < 32; p <<= 1) n |= n >> p;
+ n++;
+ }
+ return n;
+}
+
+function howMuchToRead(n, state) {
+ if (state.length === 0 && state.ended)
+ return 0;
+
+ if (state.objectMode)
+ return n === 0 ? 0 : 1;
+
+ if (isNaN(n) || n === null) {
+ // only flow one buffer at a time
+ if (state.flowing && state.buffer.length)
+ return state.buffer[0].length;
+ else
+ return state.length;
+ }
+
+ if (n <= 0)
+ return 0;
+
+ // If we're asking for more than the target buffer level,
+ // then raise the water mark. Bump up to the next highest
+ // power of 2, to prevent increasing it excessively in tiny
+ // amounts.
+ if (n > state.highWaterMark)
+ state.highWaterMark = roundUpToNextPowerOf2(n);
+
+ // don't have that much. return null, unless we've ended.
+ if (n > state.length) {
+ if (!state.ended) {
+ state.needReadable = true;
+ return 0;
+ } else
+ return state.length;
+ }
+
+ return n;
+}
+
+// you can override either this method, or the async _read(n) below.
+Readable.prototype.read = function(n) {
+ var state = this._readableState;
+ state.calledRead = true;
+ var nOrig = n;
+
+ if (typeof n !== 'number' || n > 0)
+ state.emittedReadable = false;
+
+ // if we're doing read(0) to trigger a readable event, but we
+ // already have a bunch of data in the buffer, then just trigger
+ // the 'readable' event and move on.
+ if (n === 0 &&
+ state.needReadable &&
+ (state.length >= state.highWaterMark || state.ended)) {
+ emitReadable(this);
+ return null;
+ }
+
+ n = howMuchToRead(n, state);
+
+ // if we've ended, and we're now clear, then finish it up.
+ if (n === 0 && state.ended) {
+ if (state.length === 0)
+ endReadable(this);
+ return null;
+ }
+
+ // All the actual chunk generation logic needs to be
+ // *below* the call to _read. The reason is that in certain
+ // synthetic stream cases, such as passthrough streams, _read
+ // may be a completely synchronous operation which may change
+ // the state of the read buffer, providing enough data when
+ // before there was *not* enough.
+ //
+ // So, the steps are:
+ // 1. Figure out what the state of things will be after we do
+ // a read from the buffer.
+ //
+ // 2. If that resulting state will trigger a _read, then call _read.
+ // Note that this may be asynchronous, or synchronous. Yes, it is
+ // deeply ugly to write APIs this way, but that still doesn't mean
+ // that the Readable class should behave improperly, as streams are
+ // designed to be sync/async agnostic.
+ // Take note if the _read call is sync or async (ie, if the read call
+ // has returned yet), so that we know whether or not it's safe to emit
+ // 'readable' etc.
+ //
+ // 3. Actually pull the requested chunks out of the buffer and return.
+
+ // if we need a readable event, then we need to do some reading.
+ var doRead = state.needReadable;
+
+ // if we currently have less than the highWaterMark, then also read some
+ if (state.length - n <= state.highWaterMark)
+ doRead = true;
+
+ // however, if we've ended, then there's no point, and if we're already
+ // reading, then it's unnecessary.
+ if (state.ended || state.reading)
+ doRead = false;
+
+ if (doRead) {
+ state.reading = true;
+ state.sync = true;
+ // if the length is currently zero, then we *need* a readable event.
+ if (state.length === 0)
+ state.needReadable = true;
+ // call internal read method
+ this._read(state.highWaterMark);
+ state.sync = false;
+ }
+
+ // If _read called its callback synchronously, then `reading`
+ // will be false, and we need to re-evaluate how much data we
+ // can return to the user.
+ if (doRead && !state.reading)
+ n = howMuchToRead(nOrig, state);
+
+ var ret;
+ if (n > 0)
+ ret = fromList(n, state);
+ else
+ ret = null;
+
+ if (ret === null) {
+ state.needReadable = true;
+ n = 0;
+ }
+
+ state.length -= n;
+
+ // If we have nothing in the buffer, then we want to know
+ // as soon as we *do* get something into the buffer.
+ if (state.length === 0 && !state.ended)
+ state.needReadable = true;
+
+ // If we happened to read() exactly the remaining amount in the
+ // buffer, and the EOF has been seen at this point, then make sure
+ // that we emit 'end' on the very next tick.
+ if (state.ended && !state.endEmitted && state.length === 0)
+ endReadable(this);
+
+ return ret;
+};
+
+function chunkInvalid(state, chunk) {
+ var er = null;
+ if (!Buffer.isBuffer(chunk) &&
+ 'string' !== typeof chunk &&
+ chunk !== null &&
+ chunk !== undefined &&
+ !state.objectMode &&
+ !er) {
+ er = new TypeError('Invalid non-string/buffer chunk');
+ }
+ return er;
+}
+
+
+function onEofChunk(stream, state) {
+ if (state.decoder && !state.ended) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length) {
+ state.buffer.push(chunk);
+ state.length += state.objectMode ? 1 : chunk.length;
+ }
+ }
+ state.ended = true;
+
+ // if we've ended and we have some data left, then emit
+ // 'readable' now to make sure it gets picked up.
+ if (state.length > 0)
+ emitReadable(stream);
+ else
+ endReadable(stream);
+}
+
+// Don't emit readable right away in sync mode, because this can trigger
+// another read() call => stack overflow. This way, it might trigger
+// a nextTick recursion warning, but that's not so bad.
+function emitReadable(stream) {
+ var state = stream._readableState;
+ state.needReadable = false;
+ if (state.emittedReadable)
+ return;
+
+ state.emittedReadable = true;
+ if (state.sync)
+ setImmediate(function() {
+ emitReadable_(stream);
+ });
+ else
+ emitReadable_(stream);
+}
+
+function emitReadable_(stream) {
+ stream.emit('readable');
+}
+
+
+// at this point, the user has presumably seen the 'readable' event,
+// and called read() to consume some data. that may have triggered
+// in turn another _read(n) call, in which case reading = true if
+// it's in progress.
+// However, if we're not ended, or reading, and the length < hwm,
+// then go ahead and try to read some more preemptively.
+function maybeReadMore(stream, state) {
+ if (!state.readingMore) {
+ state.readingMore = true;
+ setImmediate(function() {
+ maybeReadMore_(stream, state);
+ });
+ }
+}
+
+function maybeReadMore_(stream, state) {
+ var len = state.length;
+ while (!state.reading && !state.flowing && !state.ended &&
+ state.length < state.highWaterMark) {
+ stream.read(0);
+ if (len === state.length)
+ // didn't get any data, stop spinning.
+ break;
+ else
+ len = state.length;
+ }
+ state.readingMore = false;
+}
+
+// abstract method. to be overridden in specific implementation classes.
+// call cb(er, data) where data is <= n in length.
+// for virtual (non-string, non-buffer) streams, "length" is somewhat
+// arbitrary, and perhaps not very meaningful.
+Readable.prototype._read = function(n) {
+ this.emit('error', new Error('not implemented'));
+};
+
+Readable.prototype.pipe = function(dest, pipeOpts) {
+ var src = this;
+ var state = this._readableState;
+
+ switch (state.pipesCount) {
+ case 0:
+ state.pipes = dest;
+ break;
+ case 1:
+ state.pipes = [state.pipes, dest];
+ break;
+ default:
+ state.pipes.push(dest);
+ break;
+ }
+ state.pipesCount += 1;
+
+ var doEnd = (!pipeOpts || pipeOpts.end !== false) &&
+ dest !== process.stdout &&
+ dest !== process.stderr;
+
+ var endFn = doEnd ? onend : cleanup;
+ if (state.endEmitted)
+ setImmediate(endFn);
+ else
+ src.once('end', endFn);
+
+ dest.on('unpipe', onunpipe);
+ function onunpipe(readable) {
+ if (readable !== src) return;
+ cleanup();
+ }
+
+ function onend() {
+ dest.end();
+ }
+
+ // when the dest drains, it reduces the awaitDrain counter
+ // on the source. This would be more elegant with a .once()
+ // handler in flow(), but adding and removing repeatedly is
+ // too slow.
+ var ondrain = pipeOnDrain(src);
+ dest.on('drain', ondrain);
+
+ function cleanup() {
+ // cleanup event handlers once the pipe is broken
+ dest.removeListener('close', onclose);
+ dest.removeListener('finish', onfinish);
+ dest.removeListener('drain', ondrain);
+ dest.removeListener('error', onerror);
+ dest.removeListener('unpipe', onunpipe);
+ src.removeListener('end', onend);
+ src.removeListener('end', cleanup);
+
+ // if the reader is waiting for a drain event from this
+ // specific writer, then it would cause it to never start
+ // flowing again.
+ // So, if this is awaiting a drain, then we just call it now.
+ // If we don't know, then assume that we are waiting for one.
+ if (!dest._writableState || dest._writableState.needDrain)
+ ondrain();
+ }
+
+ // if the dest has an error, then stop piping into it.
+ // however, don't suppress the throwing behavior for this.
+ // check for listeners before emit removes one-time listeners.
+ var errListeners = EE.listenerCount(dest, 'error');
+ function onerror(er) {
+ unpipe();
+ if (errListeners === 0 && EE.listenerCount(dest, 'error') === 0)
+ dest.emit('error', er);
+ }
+ dest.once('error', onerror);
+
+ // Both close and finish should trigger unpipe, but only once.
+ function onclose() {
+ dest.removeListener('finish', onfinish);
+ unpipe();
+ }
+ dest.once('close', onclose);
+ function onfinish() {
+ dest.removeListener('close', onclose);
+ unpipe();
+ }
+ dest.once('finish', onfinish);
+
+ function unpipe() {
+ src.unpipe(dest);
+ }
+
+ // tell the dest that it's being piped to
+ dest.emit('pipe', src);
+
+ // start the flow if it hasn't been started already.
+ if (!state.flowing) {
+ // the handler that waits for readable events after all
+ // the data gets sucked out in flow.
+ // This would be easier to follow with a .once() handler
+ // in flow(), but that is too slow.
+ this.on('readable', pipeOnReadable);
+
+ state.flowing = true;
+ setImmediate(function() {
+ flow(src);
+ });
+ }
+
+ return dest;
+};
+
+function pipeOnDrain(src) {
+ return function() {
+ var dest = this;
+ var state = src._readableState;
+ state.awaitDrain--;
+ if (state.awaitDrain === 0)
+ flow(src);
+ };
+}
+
+function flow(src) {
+ var state = src._readableState;
+ var chunk;
+ state.awaitDrain = 0;
+
+ function write(dest, i, list) {
+ var written = dest.write(chunk);
+ if (false === written) {
+ state.awaitDrain++;
+ }
+ }
+
+ while (state.pipesCount && null !== (chunk = src.read())) {
+
+ if (state.pipesCount === 1)
+ write(state.pipes, 0, null);
+ else
+ forEach(state.pipes, write);
+
+ src.emit('data', chunk);
+
+ // if anyone needs a drain, then we have to wait for that.
+ if (state.awaitDrain > 0)
+ return;
+ }
+
+ // if every destination was unpiped, either before entering this
+ // function, or in the while loop, then stop flowing.
+ //
+ // NB: This is a pretty rare edge case.
+ if (state.pipesCount === 0) {
+ state.flowing = false;
+
+ // if there were data event listeners added, then switch to old mode.
+ if (EE.listenerCount(src, 'data') > 0)
+ emitDataEvents(src);
+ return;
+ }
+
+ // at this point, no one needed a drain, so we just ran out of data
+ // on the next readable event, start it over again.
+ state.ranOut = true;
+}
+
+function pipeOnReadable() {
+ if (this._readableState.ranOut) {
+ this._readableState.ranOut = false;
+ flow(this);
+ }
+}
+
+
+Readable.prototype.unpipe = function(dest) {
+ var state = this._readableState;
+
+ // if we're not piping anywhere, then do nothing.
+ if (state.pipesCount === 0)
+ return this;
+
+ // just one destination. most common case.
+ if (state.pipesCount === 1) {
+ // passed in one, but it's not the right one.
+ if (dest && dest !== state.pipes)
+ return this;
+
+ if (!dest)
+ dest = state.pipes;
+
+ // got a match.
+ state.pipes = null;
+ state.pipesCount = 0;
+ this.removeListener('readable', pipeOnReadable);
+ state.flowing = false;
+ if (dest)
+ dest.emit('unpipe', this);
+ return this;
+ }
+
+ // slow case. multiple pipe destinations.
+
+ if (!dest) {
+ // remove all.
+ var dests = state.pipes;
+ var len = state.pipesCount;
+ state.pipes = null;
+ state.pipesCount = 0;
+ this.removeListener('readable', pipeOnReadable);
+ state.flowing = false;
+
+ for (var i = 0; i < len; i++)
+ dests[i].emit('unpipe', this);
+ return this;
+ }
+
+ // try to find the right one.
+ var i = indexOf(state.pipes, dest);
+ if (i === -1)
+ return this;
+
+ state.pipes.splice(i, 1);
+ state.pipesCount -= 1;
+ if (state.pipesCount === 1)
+ state.pipes = state.pipes[0];
+
+ dest.emit('unpipe', this);
+
+ return this;
+};
+
+// set up data events if they are asked for
+// Ensure readable listeners eventually get something
+Readable.prototype.on = function(ev, fn) {
+ var res = Stream.prototype.on.call(this, ev, fn);
+
+ if (ev === 'data' && !this._readableState.flowing)
+ emitDataEvents(this);
+
+ if (ev === 'readable' && this.readable) {
+ var state = this._readableState;
+ if (!state.readableListening) {
+ state.readableListening = true;
+ state.emittedReadable = false;
+ state.needReadable = true;
+ if (!state.reading) {
+ this.read(0);
+ } else if (state.length) {
+ emitReadable(this, state);
+ }
+ }
+ }
+
+ return res;
+};
+Readable.prototype.addListener = Readable.prototype.on;
+
+// pause() and resume() are remnants of the legacy readable stream API
+// If the user uses them, then switch into old mode.
+Readable.prototype.resume = function() {
+ emitDataEvents(this);
+ this.read(0);
+ this.emit('resume');
+};
+
+Readable.prototype.pause = function() {
+ emitDataEvents(this, true);
+ this.emit('pause');
+};
+
+function emitDataEvents(stream, startPaused) {
+ var state = stream._readableState;
+
+ if (state.flowing) {
+ // https://github.com/isaacs/readable-stream/issues/16
+ throw new Error('Cannot switch to old mode now.');
+ }
+
+ var paused = startPaused || false;
+ var readable = false;
+
+ // convert to an old-style stream.
+ stream.readable = true;
+ stream.pipe = Stream.prototype.pipe;
+ stream.on = stream.addListener = Stream.prototype.on;
+
+ stream.on('readable', function() {
+ readable = true;
+
+ var c;
+ while (!paused && (null !== (c = stream.read())))
+ stream.emit('data', c);
+
+ if (c === null) {
+ readable = false;
+ stream._readableState.needReadable = true;
+ }
+ });
+
+ stream.pause = function() {
+ paused = true;
+ this.emit('pause');
+ };
+
+ stream.resume = function() {
+ paused = false;
+ if (readable)
+ setImmediate(function() {
+ stream.emit('readable');
+ });
+ else
+ this.read(0);
+ this.emit('resume');
+ };
+
+ // now make it start, just in case it hadn't already.
+ stream.emit('readable');
+}
+
+// wrap an old-style stream as the async data source.
+// This is *not* part of the readable stream interface.
+// It is an ugly unfortunate mess of history.
+Readable.prototype.wrap = function(stream) {
+ var state = this._readableState;
+ var paused = false;
+
+ var self = this;
+ stream.on('end', function() {
+ if (state.decoder && !state.ended) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length)
+ self.push(chunk);
+ }
+
+ self.push(null);
+ });
+
+ stream.on('data', function(chunk) {
+ if (state.decoder)
+ chunk = state.decoder.write(chunk);
+ if (!chunk || !state.objectMode && !chunk.length)
+ return;
+
+ var ret = self.push(chunk);
+ if (!ret) {
+ paused = true;
+ stream.pause();
+ }
+ });
+
+ // proxy all the other methods.
+ // important when wrapping filters and duplexes.
+ for (var i in stream) {
+ if (typeof stream[i] === 'function' &&
+ typeof this[i] === 'undefined') {
+ this[i] = function(method) { return function() {
+ return stream[method].apply(stream, arguments);
+ }}(i);
+ }
+ }
+
+ // proxy certain important events.
+ var events = ['error', 'close', 'destroy', 'pause', 'resume'];
+ forEach(events, function(ev) {
+ stream.on(ev, function (x) {
+ return self.emit.apply(self, ev, x);
+ });
+ });
+
+ // when we try to consume some more bytes, simply unpause the
+ // underlying stream.
+ self._read = function(n) {
+ if (paused) {
+ paused = false;
+ stream.resume();
+ }
+ };
+
+ return self;
+};
+
+
+
+// exposed for testing purposes only.
+Readable._fromList = fromList;
+
+// Pluck off n bytes from an array of buffers.
+// Length is the combined lengths of all the buffers in the list.
+function fromList(n, state) {
+ var list = state.buffer;
+ var length = state.length;
+ var stringMode = !!state.decoder;
+ var objectMode = !!state.objectMode;
+ var ret;
+
+ // nothing in the list, definitely empty.
+ if (list.length === 0)
+ return null;
+
+ if (length === 0)
+ ret = null;
+ else if (objectMode)
+ ret = list.shift();
+ else if (!n || n >= length) {
+ // read it all, truncate the array.
+ if (stringMode)
+ ret = list.join('');
+ else
+ ret = Buffer.concat(list, length);
+ list.length = 0;
+ } else {
+ // read just some of it.
+ if (n < list[0].length) {
+ // just take a part of the first list item.
+ // slice is the same for buffers and strings.
+ var buf = list[0];
+ ret = buf.slice(0, n);
+ list[0] = buf.slice(n);
+ } else if (n === list[0].length) {
+ // first list is a perfect match
+ ret = list.shift();
+ } else {
+ // complex case.
+ // we have enough to cover it, but it spans past the first buffer.
+ if (stringMode)
+ ret = '';
+ else
+ ret = new Buffer(n);
+
+ var c = 0;
+ for (var i = 0, l = list.length; i < l && c < n; i++) {
+ var buf = list[0];
+ var cpy = Math.min(n - c, buf.length);
+
+ if (stringMode)
+ ret += buf.slice(0, cpy);
+ else
+ buf.copy(ret, c, 0, cpy);
+
+ if (cpy < buf.length)
+ list[0] = buf.slice(cpy);
+ else
+ list.shift();
+
+ c += cpy;
+ }
+ }
+ }
+
+ return ret;
+}
+
+function endReadable(stream) {
+ var state = stream._readableState;
+
+ // If we get here before consuming all the bytes, then that is a
+ // bug in node. Should never happen.
+ if (state.length > 0)
+ throw new Error('endReadable called on non-empty stream');
+
+ if (!state.endEmitted && state.calledRead) {
+ state.ended = true;
+ setImmediate(function() {
+ // Check that we didn't get one last unshift.
+ if (!state.endEmitted && state.length === 0) {
+ state.endEmitted = true;
+ stream.readable = false;
+ stream.emit('end');
+ }
+ });
+ }
+}
+
+function forEach (xs, f) {
+ for (var i = 0, l = xs.length; i < l; i++) {
+ f(xs[i], i);
+ }
+}
+
+function indexOf (xs, x) {
+ for (var i = 0, l = xs.length; i < l; i++) {
+ if (xs[i] === x) return i;
+ }
+ return -1;
+}
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"./index.js":24,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"events":18,"inherits":33,"process/browser.js":25,"string_decoder":30}],28:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a transform stream is a readable/writable stream where you do
+// something with the data. Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored. (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation. For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes. When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up. When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer. When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks. If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk. However,
+// a pathological inflate type of transform can cause excessive buffering
+// here. For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output. In this case, you could write a very small
+// amount of input, and end up with a very large amount of output. In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform. A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
+
+module.exports = Transform;
+
+var Duplex = require('./duplex.js');
+var inherits = require('inherits');
+inherits(Transform, Duplex);
+
+
+function TransformState(options, stream) {
+ this.afterTransform = function(er, data) {
+ return afterTransform(stream, er, data);
+ };
+
+ this.needTransform = false;
+ this.transforming = false;
+ this.writecb = null;
+ this.writechunk = null;
+}
+
+function afterTransform(stream, er, data) {
+ var ts = stream._transformState;
+ ts.transforming = false;
+
+ var cb = ts.writecb;
+
+ if (!cb)
+ return stream.emit('error', new Error('no writecb in Transform class'));
+
+ ts.writechunk = null;
+ ts.writecb = null;
+
+ if (data !== null && data !== undefined)
+ stream.push(data);
+
+ if (cb)
+ cb(er);
+
+ var rs = stream._readableState;
+ rs.reading = false;
+ if (rs.needReadable || rs.length < rs.highWaterMark) {
+ stream._read(rs.highWaterMark);
+ }
+}
+
+
+function Transform(options) {
+ if (!(this instanceof Transform))
+ return new Transform(options);
+
+ Duplex.call(this, options);
+
+ var ts = this._transformState = new TransformState(options, this);
+
+ // when the writable side finishes, then flush out anything remaining.
+ var stream = this;
+
+ // start out asking for a readable event once data is transformed.
+ this._readableState.needReadable = true;
+
+ // we have implemented the _read method, and done the other things
+ // that Readable wants before the first _read call, so unset the
+ // sync guard flag.
+ this._readableState.sync = false;
+
+ this.once('finish', function() {
+ if ('function' === typeof this._flush)
+ this._flush(function(er) {
+ done(stream, er);
+ });
+ else
+ done(stream);
+ });
+}
+
+Transform.prototype.push = function(chunk, encoding) {
+ this._transformState.needTransform = false;
+ return Duplex.prototype.push.call(this, chunk, encoding);
+};
+
+// This is the part where you do stuff!
+// override this function in implementation classes.
+// 'chunk' is an input chunk.
+//
+// Call `push(newChunk)` to pass along transformed output
+// to the readable side. You may call 'push' zero or more times.
+//
+// Call `cb(err)` when you are done with this chunk. If you pass
+// an error, then that'll put the hurt on the whole operation. If you
+// never call cb(), then you'll never get another chunk.
+Transform.prototype._transform = function(chunk, encoding, cb) {
+ throw new Error('not implemented');
+};
+
+Transform.prototype._write = function(chunk, encoding, cb) {
+ var ts = this._transformState;
+ ts.writecb = cb;
+ ts.writechunk = chunk;
+ ts.writeencoding = encoding;
+ if (!ts.transforming) {
+ var rs = this._readableState;
+ if (ts.needTransform ||
+ rs.needReadable ||
+ rs.length < rs.highWaterMark)
+ this._read(rs.highWaterMark);
+ }
+};
+
+// Doesn't matter what the args are here.
+// _transform does all the work.
+// That we got here means that the readable side wants more data.
+Transform.prototype._read = function(n) {
+ var ts = this._transformState;
+
+ if (ts.writechunk && ts.writecb && !ts.transforming) {
+ ts.transforming = true;
+ this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+ } else {
+ // mark that we need a transform, so that any data that comes in
+ // will get processed, now that we've asked for it.
+ ts.needTransform = true;
+ }
+};
+
+
+function done(stream, er) {
+ if (er)
+ return stream.emit('error', er);
+
+ // if there's nothing in the write buffer, then that means
+ // that nothing more will ever be provided
+ var ws = stream._writableState;
+ var rs = stream._readableState;
+ var ts = stream._transformState;
+
+ if (ws.length)
+ throw new Error('calling transform done when ws.length != 0');
+
+ if (ts.transforming)
+ throw new Error('calling transform done when still transforming');
+
+ return stream.push(null);
+}
+
+},{"./duplex.js":23,"inherits":33}],29:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// A bit simpler than readable streams.
+// Implement an async ._write(chunk, cb), and it'll handle all
+// the drain event emission and buffering.
+
+module.exports = Writable;
+Writable.WritableState = WritableState;
+
+var isUint8Array = typeof Uint8Array !== 'undefined'
+ ? function (x) { return x instanceof Uint8Array }
+ : function (x) {
+ return x && x.constructor && x.constructor.name === 'Uint8Array'
+ }
+;
+var isArrayBuffer = typeof ArrayBuffer !== 'undefined'
+ ? function (x) { return x instanceof ArrayBuffer }
+ : function (x) {
+ return x && x.constructor && x.constructor.name === 'ArrayBuffer'
+ }
+;
+
+var inherits = require('inherits');
+var Stream = require('./index.js');
+var setImmediate = require('process/browser.js').nextTick;
+var Buffer = require('buffer').Buffer;
+
+inherits(Writable, Stream);
+
+function WriteReq(chunk, encoding, cb) {
+ this.chunk = chunk;
+ this.encoding = encoding;
+ this.callback = cb;
+}
+
+function WritableState(options, stream) {
+ options = options || {};
+
+ // the point at which write() starts returning false
+ // Note: 0 is a valid value, means that we always return false if
+ // the entire buffer is not flushed immediately on write()
+ var hwm = options.highWaterMark;
+ this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
+
+ // object stream flag to indicate whether or not this stream
+ // contains buffers or objects.
+ this.objectMode = !!options.objectMode;
+
+ // cast to ints.
+ this.highWaterMark = ~~this.highWaterMark;
+
+ this.needDrain = false;
+ // at the start of calling end()
+ this.ending = false;
+ // when end() has been called, and returned
+ this.ended = false;
+ // when 'finish' is emitted
+ this.finished = false;
+
+ // should we decode strings into buffers before passing to _write?
+ // this is here so that some node-core streams can optimize string
+ // handling at a lower level.
+ var noDecode = options.decodeStrings === false;
+ this.decodeStrings = !noDecode;
+
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+ // not an actual buffer we keep track of, but a measurement
+ // of how much we're waiting to get pushed to some underlying
+ // socket or file.
+ this.length = 0;
+
+ // a flag to see when we're in the middle of a write.
+ this.writing = false;
+
+ // a flag to be able to tell if the onwrite cb is called immediately,
+ // or on a later tick. We set this to true at first, becuase any
+ // actions that shouldn't happen until "later" should generally also
+ // not happen before the first write call.
+ this.sync = true;
+
+ // a flag to know if we're processing previously buffered items, which
+ // may call the _write() callback in the same tick, so that we don't
+ // end up in an overlapped onwrite situation.
+ this.bufferProcessing = false;
+
+ // the callback that's passed to _write(chunk,cb)
+ this.onwrite = function(er) {
+ onwrite(stream, er);
+ };
+
+ // the callback that the user supplies to write(chunk,encoding,cb)
+ this.writecb = null;
+
+ // the amount that is being written when _write is called.
+ this.writelen = 0;
+
+ this.buffer = [];
+}
+
+function Writable(options) {
+ // Writable ctor is applied to Duplexes, though they're not
+ // instanceof Writable, they're instanceof Readable.
+ if (!(this instanceof Writable) && !(this instanceof Stream.Duplex))
+ return new Writable(options);
+
+ this._writableState = new WritableState(options, this);
+
+ // legacy.
+ this.writable = true;
+
+ Stream.call(this);
+}
+
+// Otherwise people can pipe Writable streams, which is just wrong.
+Writable.prototype.pipe = function() {
+ this.emit('error', new Error('Cannot pipe. Not readable.'));
+};
+
+
+function writeAfterEnd(stream, state, cb) {
+ var er = new Error('write after end');
+ // TODO: defer error events consistently everywhere, not just the cb
+ stream.emit('error', er);
+ setImmediate(function() {
+ cb(er);
+ });
+}
+
+// If we get something that is not a buffer, string, null, or undefined,
+// and we're not in objectMode, then that's an error.
+// Otherwise stream chunks are all considered to be of length=1, and the
+// watermarks determine how many objects to keep in the buffer, rather than
+// how many bytes or characters.
+function validChunk(stream, state, chunk, cb) {
+ var valid = true;
+ if (!Buffer.isBuffer(chunk) &&
+ 'string' !== typeof chunk &&
+ chunk !== null &&
+ chunk !== undefined &&
+ !state.objectMode) {
+ var er = new TypeError('Invalid non-string/buffer chunk');
+ stream.emit('error', er);
+ setImmediate(function() {
+ cb(er);
+ });
+ valid = false;
+ }
+ return valid;
+}
+
+Writable.prototype.write = function(chunk, encoding, cb) {
+ var state = this._writableState;
+ var ret = false;
+
+ if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (!Buffer.isBuffer(chunk) && isUint8Array(chunk))
+ chunk = new Buffer(chunk);
+ if (isArrayBuffer(chunk) && typeof Uint8Array !== 'undefined')
+ chunk = new Buffer(new Uint8Array(chunk));
+
+ if (Buffer.isBuffer(chunk))
+ encoding = 'buffer';
+ else if (!encoding)
+ encoding = state.defaultEncoding;
+
+ if (typeof cb !== 'function')
+ cb = function() {};
+
+ if (state.ended)
+ writeAfterEnd(this, state, cb);
+ else if (validChunk(this, state, chunk, cb))
+ ret = writeOrBuffer(this, state, chunk, encoding, cb);
+
+ return ret;
+};
+
+function decodeChunk(state, chunk, encoding) {
+ if (!state.objectMode &&
+ state.decodeStrings !== false &&
+ typeof chunk === 'string') {
+ chunk = new Buffer(chunk, encoding);
+ }
+ return chunk;
+}
+
+// if we're already writing something, then just put this
+// in the queue, and wait our turn. Otherwise, call _write
+// If we return false, then we need a drain event, so set that flag.
+function writeOrBuffer(stream, state, chunk, encoding, cb) {
+ chunk = decodeChunk(state, chunk, encoding);
+ var len = state.objectMode ? 1 : chunk.length;
+
+ state.length += len;
+
+ var ret = state.length < state.highWaterMark;
+ state.needDrain = !ret;
+
+ if (state.writing)
+ state.buffer.push(new WriteReq(chunk, encoding, cb));
+ else
+ doWrite(stream, state, len, chunk, encoding, cb);
+
+ return ret;
+}
+
+function doWrite(stream, state, len, chunk, encoding, cb) {
+ state.writelen = len;
+ state.writecb = cb;
+ state.writing = true;
+ state.sync = true;
+ stream._write(chunk, encoding, state.onwrite);
+ state.sync = false;
+}
+
+function onwriteError(stream, state, sync, er, cb) {
+ if (sync)
+ setImmediate(function() {
+ cb(er);
+ });
+ else
+ cb(er);
+
+ stream.emit('error', er);
+}
+
+function onwriteStateUpdate(state) {
+ state.writing = false;
+ state.writecb = null;
+ state.length -= state.writelen;
+ state.writelen = 0;
+}
+
+function onwrite(stream, er) {
+ var state = stream._writableState;
+ var sync = state.sync;
+ var cb = state.writecb;
+
+ onwriteStateUpdate(state);
+
+ if (er)
+ onwriteError(stream, state, sync, er, cb);
+ else {
+ // Check if we're actually ready to finish, but don't emit yet
+ var finished = needFinish(stream, state);
+
+ if (!finished && !state.bufferProcessing && state.buffer.length)
+ clearBuffer(stream, state);
+
+ if (sync) {
+ setImmediate(function() {
+ afterWrite(stream, state, finished, cb);
+ });
+ } else {
+ afterWrite(stream, state, finished, cb);
+ }
+ }
+}
+
+function afterWrite(stream, state, finished, cb) {
+ if (!finished)
+ onwriteDrain(stream, state);
+ cb();
+ if (finished)
+ finishMaybe(stream, state);
+}
+
+// Must force callback to be called on nextTick, so that we don't
+// emit 'drain' before the write() consumer gets the 'false' return
+// value, and has a chance to attach a 'drain' listener.
+function onwriteDrain(stream, state) {
+ if (state.length === 0 && state.needDrain) {
+ state.needDrain = false;
+ stream.emit('drain');
+ }
+}
+
+
+// if there's something in the buffer waiting, then process it
+function clearBuffer(stream, state) {
+ state.bufferProcessing = true;
+
+ for (var c = 0; c < state.buffer.length; c++) {
+ var entry = state.buffer[c];
+ var chunk = entry.chunk;
+ var encoding = entry.encoding;
+ var cb = entry.callback;
+ var len = state.objectMode ? 1 : chunk.length;
+
+ doWrite(stream, state, len, chunk, encoding, cb);
+
+ // if we didn't call the onwrite immediately, then
+ // it means that we need to wait until it does.
+ // also, that means that the chunk and cb are currently
+ // being processed, so move the buffer counter past them.
+ if (state.writing) {
+ c++;
+ break;
+ }
+ }
+
+ state.bufferProcessing = false;
+ if (c < state.buffer.length)
+ state.buffer = state.buffer.slice(c);
+ else
+ state.buffer.length = 0;
+}
+
+Writable.prototype._write = function(chunk, encoding, cb) {
+ cb(new Error('not implemented'));
+};
+
+Writable.prototype.end = function(chunk, encoding, cb) {
+ var state = this._writableState;
+
+ if (typeof chunk === 'function') {
+ cb = chunk;
+ chunk = null;
+ encoding = null;
+ } else if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (typeof chunk !== 'undefined' && chunk !== null)
+ this.write(chunk, encoding);
+
+ // ignore unnecessary end() calls.
+ if (!state.ending && !state.finished)
+ endWritable(this, state, cb);
+};
+
+
+function needFinish(stream, state) {
+ return (state.ending &&
+ state.length === 0 &&
+ !state.finished &&
+ !state.writing);
+}
+
+function finishMaybe(stream, state) {
+ var need = needFinish(stream, state);
+ if (need) {
+ state.finished = true;
+ stream.emit('finish');
+ }
+ return need;
+}
+
+function endWritable(stream, state, cb) {
+ state.ending = true;
+ finishMaybe(stream, state);
+ if (cb) {
+ if (state.finished)
+ setImmediate(cb);
+ else
+ stream.once('finish', cb);
+ }
+ state.ended = true;
+}
+
+},{"./index.js":24,"buffer":20,"inherits":33,"process/browser.js":25}],30:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var Buffer = require('buffer').Buffer;
+
+function assertEncoding(encoding) {
+ if (encoding && !Buffer.isEncoding(encoding)) {
+ throw new Error('Unknown encoding: ' + encoding);
+ }
+}
+
+var StringDecoder = exports.StringDecoder = function(encoding) {
+ this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
+ assertEncoding(encoding);
+ switch (this.encoding) {
+ case 'utf8':
+ // CESU-8 represents each of Surrogate Pair by 3-bytes
+ this.surrogateSize = 3;
+ break;
+ case 'ucs2':
+ case 'utf16le':
+ // UTF-16 represents each of Surrogate Pair by 2-bytes
+ this.surrogateSize = 2;
+ this.detectIncompleteChar = utf16DetectIncompleteChar;
+ break;
+ case 'base64':
+ // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
+ this.surrogateSize = 3;
+ this.detectIncompleteChar = base64DetectIncompleteChar;
+ break;
+ default:
+ this.write = passThroughWrite;
+ return;
+ }
+
+ this.charBuffer = new Buffer(6);
+ this.charReceived = 0;
+ this.charLength = 0;
+};
+
+
+StringDecoder.prototype.write = function(buffer) {
+ var charStr = '';
+ var offset = 0;
+
+ // if our last write ended with an incomplete multibyte character
+ while (this.charLength) {
+ // determine how many remaining bytes this buffer has to offer for this char
+ var i = (buffer.length >= this.charLength - this.charReceived) ?
+ this.charLength - this.charReceived :
+ buffer.length;
+
+ // add the new bytes to the char buffer
+ buffer.copy(this.charBuffer, this.charReceived, offset, i);
+ this.charReceived += (i - offset);
+ offset = i;
+
+ if (this.charReceived < this.charLength) {
+ // still not enough chars in this buffer? wait for more ...
+ return '';
+ }
+
+ // get the character that was split
+ charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
+
+ // lead surrogate (D800-DBFF) is also the incomplete character
+ var charCode = charStr.charCodeAt(charStr.length - 1);
+ if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+ this.charLength += this.surrogateSize;
+ charStr = '';
+ continue;
+ }
+ this.charReceived = this.charLength = 0;
+
+ // if there are no more bytes in this buffer, just emit our char
+ if (i == buffer.length) return charStr;
+
+ // otherwise cut off the characters end from the beginning of this buffer
+ buffer = buffer.slice(i, buffer.length);
+ break;
+ }
+
+ var lenIncomplete = this.detectIncompleteChar(buffer);
+
+ var end = buffer.length;
+ if (this.charLength) {
+ // buffer the incomplete character bytes we got
+ buffer.copy(this.charBuffer, 0, buffer.length - lenIncomplete, end);
+ this.charReceived = lenIncomplete;
+ end -= lenIncomplete;
+ }
+
+ charStr += buffer.toString(this.encoding, 0, end);
+
+ var end = charStr.length - 1;
+ var charCode = charStr.charCodeAt(end);
+ // lead surrogate (D800-DBFF) is also the incomplete character
+ if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+ var size = this.surrogateSize;
+ this.charLength += size;
+ this.charReceived += size;
+ this.charBuffer.copy(this.charBuffer, size, 0, size);
+ this.charBuffer.write(charStr.charAt(charStr.length - 1), this.encoding);
+ return charStr.substring(0, end);
+ }
+
+ // or just emit the charStr
+ return charStr;
+};
+
+StringDecoder.prototype.detectIncompleteChar = function(buffer) {
+ // determine how many bytes we have to check at the end of this buffer
+ var i = (buffer.length >= 3) ? 3 : buffer.length;
+
+ // Figure out if one of the last i bytes of our buffer announces an
+ // incomplete char.
+ for (; i > 0; i--) {
+ var c = buffer[buffer.length - i];
+
+ // See http://en.wikipedia.org/wiki/UTF-8#Description
+
+ // 110XXXXX
+ if (i == 1 && c >> 5 == 0x06) {
+ this.charLength = 2;
+ break;
+ }
+
+ // 1110XXXX
+ if (i <= 2 && c >> 4 == 0x0E) {
+ this.charLength = 3;
+ break;
+ }
+
+ // 11110XXX
+ if (i <= 3 && c >> 3 == 0x1E) {
+ this.charLength = 4;
+ break;
+ }
+ }
+
+ return i;
+};
+
+StringDecoder.prototype.end = function(buffer) {
+ var res = '';
+ if (buffer && buffer.length)
+ res = this.write(buffer);
+
+ if (this.charReceived) {
+ var cr = this.charReceived;
+ var buf = this.charBuffer;
+ var enc = this.encoding;
+ res += buf.slice(0, cr).toString(enc);
+ }
+
+ return res;
+};
+
+function passThroughWrite(buffer) {
+ return buffer.toString(this.encoding);
+}
+
+function utf16DetectIncompleteChar(buffer) {
+ var incomplete = this.charReceived = buffer.length % 2;
+ this.charLength = incomplete ? 2 : 0;
+ return incomplete;
+}
+
+function base64DetectIncompleteChar(buffer) {
+ var incomplete = this.charReceived = buffer.length % 3;
+ this.charLength = incomplete ? 3 : 0;
+ return incomplete;
+}
+
+},{"buffer":20}],31:[function(require,module,exports){
+module.exports = function isBuffer(arg) {
+ return arg && typeof arg === 'object'
+ && typeof arg.copy === 'function'
+ && typeof arg.fill === 'function'
+ && typeof arg.readUInt8 === 'function';
+}
+},{}],32:[function(require,module,exports){
+(function (process,global){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var formatRegExp = /%[sdj%]/g;
+exports.format = function(f) {
+ if (!isString(f)) {
+ var objects = [];
+ for (var i = 0; i < arguments.length; i++) {
+ objects.push(inspect(arguments[i]));
+ }
+ return objects.join(' ');
+ }
+
+ var i = 1;
+ var args = arguments;
+ var len = args.length;
+ var str = String(f).replace(formatRegExp, function(x) {
+ if (x === '%%') return '%';
+ if (i >= len) return x;
+ switch (x) {
+ case '%s': return String(args[i++]);
+ case '%d': return Number(args[i++]);
+ case '%j':
+ try {
+ return JSON.stringify(args[i++]);
+ } catch (_) {
+ return '[Circular]';
+ }
+ default:
+ return x;
+ }
+ });
+ for (var x = args[i]; i < len; x = args[++i]) {
+ if (isNull(x) || !isObject(x)) {
+ str += ' ' + x;
+ } else {
+ str += ' ' + inspect(x);
+ }
+ }
+ return str;
+};
+
+
+// Mark that a method should not be used.
+// Returns a modified function which warns once by default.
+// If --no-deprecation is set, then it is a no-op.
+exports.deprecate = function(fn, msg) {
+ // Allow for deprecating things in the process of starting up.
+ if (isUndefined(global.process)) {
+ return function() {
+ return exports.deprecate(fn, msg).apply(this, arguments);
+ };
+ }
+
+ if (process.noDeprecation === true) {
+ return fn;
+ }
+
+ var warned = false;
+ function deprecated() {
+ if (!warned) {
+ if (process.throwDeprecation) {
+ throw new Error(msg);
+ } else if (process.traceDeprecation) {
+ console.trace(msg);
+ } else {
+ console.error(msg);
+ }
+ warned = true;
+ }
+ return fn.apply(this, arguments);
+ }
+
+ return deprecated;
+};
+
+
+var debugs = {};
+var debugEnviron;
+exports.debuglog = function(set) {
+ if (isUndefined(debugEnviron))
+ debugEnviron = process.env.NODE_DEBUG || '';
+ set = set.toUpperCase();
+ if (!debugs[set]) {
+ if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
+ var pid = process.pid;
+ debugs[set] = function() {
+ var msg = exports.format.apply(exports, arguments);
+ console.error('%s %d: %s', set, pid, msg);
+ };
+ } else {
+ debugs[set] = function() {};
+ }
+ }
+ return debugs[set];
+};
+
+
+/**
+ * Echos the value of a value. Trys to print the value out
+ * in the best way possible given the different types.
+ *
+ * @param {Object} obj The object to print out.
+ * @param {Object} opts Optional options object that alters the output.
+ */
+/* legacy: obj, showHidden, depth, colors*/
+function inspect(obj, opts) {
+ // default options
+ var ctx = {
+ seen: [],
+ stylize: stylizeNoColor
+ };
+ // legacy...
+ if (arguments.length >= 3) ctx.depth = arguments[2];
+ if (arguments.length >= 4) ctx.colors = arguments[3];
+ if (isBoolean(opts)) {
+ // legacy...
+ ctx.showHidden = opts;
+ } else if (opts) {
+ // got an "options" object
+ exports._extend(ctx, opts);
+ }
+ // set default options
+ if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+ if (isUndefined(ctx.depth)) ctx.depth = 2;
+ if (isUndefined(ctx.colors)) ctx.colors = false;
+ if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+ if (ctx.colors) ctx.stylize = stylizeWithColor;
+ return formatValue(ctx, obj, ctx.depth);
+}
+exports.inspect = inspect;
+
+
+// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+inspect.colors = {
+ 'bold' : [1, 22],
+ 'italic' : [3, 23],
+ 'underline' : [4, 24],
+ 'inverse' : [7, 27],
+ 'white' : [37, 39],
+ 'grey' : [90, 39],
+ 'black' : [30, 39],
+ 'blue' : [34, 39],
+ 'cyan' : [36, 39],
+ 'green' : [32, 39],
+ 'magenta' : [35, 39],
+ 'red' : [31, 39],
+ 'yellow' : [33, 39]
+};
+
+// Don't use 'blue' not visible on cmd.exe
+inspect.styles = {
+ 'special': 'cyan',
+ 'number': 'yellow',
+ 'boolean': 'yellow',
+ 'undefined': 'grey',
+ 'null': 'bold',
+ 'string': 'green',
+ 'date': 'magenta',
+ // "name": intentionally not styling
+ 'regexp': 'red'
+};
+
+
+function stylizeWithColor(str, styleType) {
+ var style = inspect.styles[styleType];
+
+ if (style) {
+ return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+ '\u001b[' + inspect.colors[style][1] + 'm';
+ } else {
+ return str;
+ }
+}
+
+
+function stylizeNoColor(str, styleType) {
+ return str;
+}
+
+
+function arrayToHash(array) {
+ var hash = {};
+
+ array.forEach(function(val, idx) {
+ hash[val] = true;
+ });
+
+ return hash;
+}
+
+
+function formatValue(ctx, value, recurseTimes) {
+ // Provide a hook for user-specified inspect functions.
+ // Check that value is an object with an inspect function on it
+ if (ctx.customInspect &&
+ value &&
+ isFunction(value.inspect) &&
+ // Filter out the util module, it's inspect function is special
+ value.inspect !== exports.inspect &&
+ // Also filter out any prototype objects using the circular check.
+ !(value.constructor && value.constructor.prototype === value)) {
+ var ret = value.inspect(recurseTimes, ctx);
+ if (!isString(ret)) {
+ ret = formatValue(ctx, ret, recurseTimes);
+ }
+ return ret;
+ }
+
+ // Primitive types cannot have properties
+ var primitive = formatPrimitive(ctx, value);
+ if (primitive) {
+ return primitive;
+ }
+
+ // Look up the keys of the object.
+ var keys = Object.keys(value);
+ var visibleKeys = arrayToHash(keys);
+
+ if (ctx.showHidden) {
+ keys = Object.getOwnPropertyNames(value);
+ }
+
+ // IE doesn't make error fields non-enumerable
+ // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
+ if (isError(value)
+ && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+ return formatError(value);
+ }
+
+ // Some type of object without properties can be shortcutted.
+ if (keys.length === 0) {
+ if (isFunction(value)) {
+ var name = value.name ? ': ' + value.name : '';
+ return ctx.stylize('[Function' + name + ']', 'special');
+ }
+ if (isRegExp(value)) {
+ return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+ }
+ if (isDate(value)) {
+ return ctx.stylize(Date.prototype.toString.call(value), 'date');
+ }
+ if (isError(value)) {
+ return formatError(value);
+ }
+ }
+
+ var base = '', array = false, braces = ['{', '}'];
+
+ // Make Array say that they are Array
+ if (isArray(value)) {
+ array = true;
+ braces = ['[', ']'];
+ }
+
+ // Make functions say that they are functions
+ if (isFunction(value)) {
+ var n = value.name ? ': ' + value.name : '';
+ base = ' [Function' + n + ']';
+ }
+
+ // Make RegExps say that they are RegExps
+ if (isRegExp(value)) {
+ base = ' ' + RegExp.prototype.toString.call(value);
+ }
+
+ // Make dates with properties first say the date
+ if (isDate(value)) {
+ base = ' ' + Date.prototype.toUTCString.call(value);
+ }
+
+ // Make error with message first say the error
+ if (isError(value)) {
+ base = ' ' + formatError(value);
+ }
+
+ if (keys.length === 0 && (!array || value.length == 0)) {
+ return braces[0] + base + braces[1];
+ }
+
+ if (recurseTimes < 0) {
+ if (isRegExp(value)) {
+ return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+ } else {
+ return ctx.stylize('[Object]', 'special');
+ }
+ }
+
+ ctx.seen.push(value);
+
+ var output;
+ if (array) {
+ output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+ } else {
+ output = keys.map(function(key) {
+ return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+ });
+ }
+
+ ctx.seen.pop();
+
+ return reduceToSingleString(output, base, braces);
+}
+
+
+function formatPrimitive(ctx, value) {
+ if (isUndefined(value))
+ return ctx.stylize('undefined', 'undefined');
+ if (isString(value)) {
+ var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+ .replace(/'/g, "\\'")
+ .replace(/\\"/g, '"') + '\'';
+ return ctx.stylize(simple, 'string');
+ }
+ if (isNumber(value))
+ return ctx.stylize('' + value, 'number');
+ if (isBoolean(value))
+ return ctx.stylize('' + value, 'boolean');
+ // For some reason typeof null is "object", so special case here.
+ if (isNull(value))
+ return ctx.stylize('null', 'null');
+}
+
+
+function formatError(value) {
+ return '[' + Error.prototype.toString.call(value) + ']';
+}
+
+
+function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+ var output = [];
+ for (var i = 0, l = value.length; i < l; ++i) {
+ if (hasOwnProperty(value, String(i))) {
+ output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+ String(i), true));
+ } else {
+ output.push('');
+ }
+ }
+ keys.forEach(function(key) {
+ if (!key.match(/^\d+$/)) {
+ output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+ key, true));
+ }
+ });
+ return output;
+}
+
+
+function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+ var name, str, desc;
+ desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+ if (desc.get) {
+ if (desc.set) {
+ str = ctx.stylize('[Getter/Setter]', 'special');
+ } else {
+ str = ctx.stylize('[Getter]', 'special');
+ }
+ } else {
+ if (desc.set) {
+ str = ctx.stylize('[Setter]', 'special');
+ }
+ }
+ if (!hasOwnProperty(visibleKeys, key)) {
+ name = '[' + key + ']';
+ }
+ if (!str) {
+ if (ctx.seen.indexOf(desc.value) < 0) {
+ if (isNull(recurseTimes)) {
+ str = formatValue(ctx, desc.value, null);
+ } else {
+ str = formatValue(ctx, desc.value, recurseTimes - 1);
+ }
+ if (str.indexOf('\n') > -1) {
+ if (array) {
+ str = str.split('\n').map(function(line) {
+ return ' ' + line;
+ }).join('\n').substr(2);
+ } else {
+ str = '\n' + str.split('\n').map(function(line) {
+ return ' ' + line;
+ }).join('\n');
+ }
+ }
+ } else {
+ str = ctx.stylize('[Circular]', 'special');
+ }
+ }
+ if (isUndefined(name)) {
+ if (array && key.match(/^\d+$/)) {
+ return str;
+ }
+ name = JSON.stringify('' + key);
+ if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+ name = name.substr(1, name.length - 2);
+ name = ctx.stylize(name, 'name');
+ } else {
+ name = name.replace(/'/g, "\\'")
+ .replace(/\\"/g, '"')
+ .replace(/(^"|"$)/g, "'");
+ name = ctx.stylize(name, 'string');
+ }
+ }
+
+ return name + ': ' + str;
+}
+
+
+function reduceToSingleString(output, base, braces) {
+ var numLinesEst = 0;
+ var length = output.reduce(function(prev, cur) {
+ numLinesEst++;
+ if (cur.indexOf('\n') >= 0) numLinesEst++;
+ return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+ }, 0);
+
+ if (length > 60) {
+ return braces[0] +
+ (base === '' ? '' : base + '\n ') +
+ ' ' +
+ output.join(',\n ') +
+ ' ' +
+ braces[1];
+ }
+
+ return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+}
+
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+function isArray(ar) {
+ return Array.isArray(ar);
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+ return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+ return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+ return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+ return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+ return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+ return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+ return isObject(re) && objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+ return isObject(d) && objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+ return isObject(e) &&
+ (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+ return arg === null ||
+ typeof arg === 'boolean' ||
+ typeof arg === 'number' ||
+ typeof arg === 'string' ||
+ typeof arg === 'symbol' || // ES6 symbol
+ typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+exports.isBuffer = require('./support/isBuffer');
+
+function objectToString(o) {
+ return Object.prototype.toString.call(o);
+}
+
+
+function pad(n) {
+ return n < 10 ? '0' + n.toString(10) : n.toString(10);
+}
+
+
+var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+ 'Oct', 'Nov', 'Dec'];
+
+// 26 Feb 16:19:34
+function timestamp() {
+ var d = new Date();
+ var time = [pad(d.getHours()),
+ pad(d.getMinutes()),
+ pad(d.getSeconds())].join(':');
+ return [d.getDate(), months[d.getMonth()], time].join(' ');
+}
+
+
+// log is just a thin wrapper to console.log that prepends a timestamp
+exports.log = function() {
+ console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+};
+
+
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * The Function.prototype.inherits from lang.js rewritten as a standalone
+ * function (not on Function.prototype). NOTE: If this file is to be loaded
+ * during bootstrapping this function needs to be rewritten using some native
+ * functions as prototype setup using normal JavaScript does not work as
+ * expected during bootstrapping (see mirror.js in r114903).
+ *
+ * @param {function} ctor Constructor function which needs to inherit the
+ * prototype.
+ * @param {function} superCtor Constructor function to inherit prototype from.
+ */
+exports.inherits = require('inherits');
+
+exports._extend = function(origin, add) {
+ // Don't do anything if add isn't an object
+ if (!add || !isObject(add)) return origin;
+
+ var keys = Object.keys(add);
+ var i = keys.length;
+ while (i--) {
+ origin[keys[i]] = add[keys[i]];
+ }
+ return origin;
+};
+
+function hasOwnProperty(obj, prop) {
+ return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./support/isBuffer":31,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"inherits":33}],33:[function(require,module,exports){
+if (typeof Object.create === 'function') {
+ // implementation from standard node.js 'util' module
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor
+ ctor.prototype = Object.create(superCtor.prototype, {
+ constructor: {
+ value: ctor,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ });
+ };
+} else {
+ // old school shim for old browsers
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor
+ var TempCtor = function () {}
+ TempCtor.prototype = superCtor.prototype
+ ctor.prototype = new TempCtor()
+ ctor.prototype.constructor = ctor
+ }
+}
+
+},{}],34:[function(require,module,exports){
+function addOperation (type, key, value, options) {
+ var operation = {
+ type: type,
+ key: key,
+ value: value,
+ options: options
+ }
+
+ if (options && options.prefix) {
+ operation.prefix = options.prefix
+ delete options.prefix
+ }
+
+ this._operations.push(operation)
+
+ return this
+}
+
+function Batch(sdb) {
+ this._operations = []
+ this._sdb = sdb
+
+ this.put = addOperation.bind(this, 'put')
+ this.del = addOperation.bind(this, 'del')
+}
+
+var B = Batch.prototype
+
+
+B.clear = function () {
+ this._operations = []
+}
+
+B.write = function (cb) {
+ this._sdb.batch(this._operations, cb)
+}
+
+module.exports = Batch
+
+},{}],35:[function(require,module,exports){
+(function (process){
+var EventEmitter = require('events').EventEmitter
+var next = process.nextTick
+var SubDb = require('./sub')
+var Batch = require('./batch')
+var fixRange = require('level-fix-range')
+
+var Hooks = require('level-hooks')
+
+module.exports = function (_db, options) {
+ function DB () {}
+ DB.prototype = _db
+ var db = new DB()
+
+ if (db.sublevel) return db
+
+ options = options || {}
+
+ //use \xff (255) as the seperator,
+ //so that sections of the database will sort after the regular keys
+ var sep = options.sep = options.sep || '\xff'
+ db._options = options
+
+ Hooks(db)
+
+ db.sublevels = {}
+
+ db.sublevel = function (prefix, options) {
+ if(db.sublevels[prefix])
+ return db.sublevels[prefix]
+ return new SubDb(db, prefix, options || this._options)
+ }
+
+ db.methods = {}
+
+ db.prefix = function (key) {
+ return '' + (key || '')
+ }
+
+ db.pre = function (range, hook) {
+ if(!hook)
+ hook = range, range = {
+ max : sep
+ }
+ return db.hooks.pre(range, hook)
+ }
+
+ db.post = function (range, hook) {
+ if(!hook)
+ hook = range, range = {
+ max : sep
+ }
+ return db.hooks.post(range, hook)
+ }
+
+ function safeRange(fun) {
+ return function (opts) {
+ opts = opts || {}
+ opts = fixRange(opts)
+
+ if(opts.reverse) opts.start = opts.start || sep
+ else opts.end = opts.end || sep
+
+ return fun.call(db, opts)
+ }
+ }
+
+ db.readStream =
+ db.createReadStream = safeRange(db.createReadStream)
+ db.keyStream =
+ db.createKeyStream = safeRange(db.createKeyStream)
+ db.valuesStream =
+ db.createValueStream = safeRange(db.createValueStream)
+
+ var batch = db.batch
+ db.batch = function (changes, opts, cb) {
+ if(!Array.isArray(changes))
+ return new Batch(db)
+ changes.forEach(function (e) {
+ if(e.prefix) {
+ if('function' === typeof e.prefix.prefix)
+ e.key = e.prefix.prefix(e.key)
+ else if('string' === typeof e.prefix)
+ e.key = e.prefix + e.key
+ }
+ })
+ batch.call(db, changes, opts, cb)
+ }
+ return db
+}
+
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"./batch":34,"./sub":46,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"events":18,"level-fix-range":36,"level-hooks":38}],36:[function(require,module,exports){
+var clone = require('clone')
+
+module.exports =
+function fixRange(opts) {
+ opts = clone(opts)
+
+ var reverse = opts.reverse
+ var end = opts.max || opts.end
+ var start = opts.min || opts.start
+
+ var range = [start, end]
+ if(start != null && end != null)
+ range.sort()
+ if(reverse)
+ range = range.reverse()
+
+ opts.start = range[0]
+ opts.end = range[1]
+
+ delete opts.min
+ delete opts.max
+
+ return opts
+}
+
+},{"clone":37}],37:[function(require,module,exports){
+(function (Buffer){
+'use strict';
+
+function objectToString(o) {
+ return Object.prototype.toString.call(o);
+}
+
+// shim for Node's 'util' package
+// DO NOT REMOVE THIS! It is required for compatibility with EnderJS (http://enderjs.com/).
+var util = {
+ isArray: function (ar) {
+ return Array.isArray(ar) || (typeof ar === 'object' && objectToString(ar) === '[object Array]');
+ },
+ isDate: function (d) {
+ return typeof d === 'object' && objectToString(d) === '[object Date]';
+ },
+ isRegExp: function (re) {
+ return typeof re === 'object' && objectToString(re) === '[object RegExp]';
+ },
+ getRegExpFlags: function (re) {
+ var flags = '';
+ re.global && (flags += 'g');
+ re.ignoreCase && (flags += 'i');
+ re.multiline && (flags += 'm');
+ return flags;
+ }
+};
+
+
+if (typeof module === 'object')
+ module.exports = clone;
+
+/**
+ * Clones (copies) an Object using deep copying.
+ *
+ * This function supports circular references by default, but if you are certain
+ * there are no circular references in your object, you can save some CPU time
+ * by calling clone(obj, false).
+ *
+ * Caution: if `circular` is false and `parent` contains circular references,
+ * your program may enter an infinite loop and crash.
+ *
+ * @param `parent` - the object to be cloned
+ * @param `circular` - set to true if the object to be cloned may contain
+ * circular references. (optional - true by default)
+ * @param `depth` - set to a number if the object is only to be cloned to
+ * a particular depth. (optional - defaults to Infinity)
+ * @param `prototype` - sets the prototype to be used when cloning an object.
+ * (optional - defaults to parent prototype).
+*/
+
+function clone(parent, circular, depth, prototype) {
+ // maintain two arrays for circular references, where corresponding parents
+ // and children have the same index
+ var allParents = [];
+ var allChildren = [];
+
+ var useBuffer = typeof Buffer != 'undefined';
+
+ if (typeof circular == 'undefined')
+ circular = true;
+
+ if (typeof depth == 'undefined')
+ depth = Infinity;
+
+ // recurse this function so we don't reset allParents and allChildren
+ function _clone(parent, depth) {
+ // cloning null always returns null
+ if (parent === null)
+ return null;
+
+ if (depth == 0)
+ return parent;
+
+ var child;
+ if (typeof parent != 'object') {
+ return parent;
+ }
+
+ if (util.isArray(parent)) {
+ child = [];
+ } else if (util.isRegExp(parent)) {
+ child = new RegExp(parent.source, util.getRegExpFlags(parent));
+ if (parent.lastIndex) child.lastIndex = parent.lastIndex;
+ } else if (util.isDate(parent)) {
+ child = new Date(parent.getTime());
+ } else if (useBuffer && Buffer.isBuffer(parent)) {
+ child = new Buffer(parent.length);
+ parent.copy(child);
+ return child;
+ } else {
+ if (typeof prototype == 'undefined') child = Object.create(Object.getPrototypeOf(parent));
+ else child = Object.create(prototype);
+ }
+
+ if (circular) {
+ var index = allParents.indexOf(parent);
+
+ if (index != -1) {
+ return allChildren[index];
+ }
+ allParents.push(parent);
+ allChildren.push(child);
+ }
+
+ for (var i in parent) {
+ child[i] = _clone(parent[i], depth - 1);
+ }
+
+ return child;
+ }
+
+ return _clone(parent, depth);
+}
+
+/**
+ * Simple flat clone using prototype, accepts only objects, usefull for property
+ * override on FLAT configuration object (no nested props).
+ *
+ * USE WITH CAUTION! This may not behave as you wish if you do not know how this
+ * works.
+ */
+clone.clonePrototype = function(parent) {
+ if (parent === null)
+ return null;
+
+ var c = function () {};
+ c.prototype = parent;
+ return new c();
+};
+
+}).call(this,require("buffer").Buffer)
+},{"buffer":20}],38:[function(require,module,exports){
+var ranges = require('string-range')
+
+module.exports = function (db) {
+
+ if(db.hooks) {
+ return
+ }
+
+ var posthooks = []
+ var prehooks = []
+
+ function getPrefix (p) {
+ return p && (
+ 'string' === typeof p ? p
+ : 'string' === typeof p.prefix ? p.prefix
+ : 'function' === typeof p.prefix ? p.prefix()
+ : ''
+ )
+ }
+
+ function getKeyEncoding (db) {
+ if(db && db._getKeyEncoding)
+ return db._getKeyEncoding(db)
+ }
+
+ function getValueEncoding (db) {
+ if(db && db._getValueEncoding)
+ return db._getValueEncoding(db)
+ }
+
+ function remover (array, item) {
+ return function () {
+ var i = array.indexOf(item)
+ if(!~i) return false
+ array.splice(i, 1)
+ return true
+ }
+ }
+
+ db.hooks = {
+ post: function (prefix, hook) {
+ if(!hook) hook = prefix, prefix = ''
+ var h = {test: ranges.checker(prefix), hook: hook}
+ posthooks.push(h)
+ return remover(posthooks, h)
+ },
+ pre: function (prefix, hook) {
+ if(!hook) hook = prefix, prefix = ''
+ var h = {
+ test: ranges.checker(prefix),
+ hook: hook,
+ safe: false !== prefix.safe
+ }
+ prehooks.push(h)
+ return remover(prehooks, h)
+ },
+ posthooks: posthooks,
+ prehooks: prehooks
+ }
+
+ //POST HOOKS
+
+ function each (e) {
+ if(e && e.type) {
+ posthooks.forEach(function (h) {
+ if(h.test(e.key)) h.hook(e)
+ })
+ }
+ }
+
+ db.on('put', function (key, val) {
+ each({type: 'put', key: key, value: val})
+ })
+ db.on('del', function (key, val) {
+ each({type: 'del', key: key, value: val})
+ })
+ db.on('batch', function onBatch (ary) {
+ ary.forEach(each)
+ })
+
+ //PRE HOOKS
+
+ var put = db.put
+ var del = db.del
+ var batch = db.batch
+
+ function callHooks (isBatch, b, opts, cb) {
+ try {
+ b.forEach(function hook(e, i) {
+ prehooks.forEach(function (h) {
+ if(h.test(String(e.key))) {
+ //optimize this?
+ //maybe faster to not create a new object each time?
+ //have one object and expose scope to it?
+ var context = {
+ add: function (ch, db) {
+ if(typeof ch === 'undefined') {
+ return this
+ }
+ if(ch === false)
+ return delete b[i]
+ var prefix = (
+ getPrefix(ch.prefix) ||
+ getPrefix(db) ||
+ h.prefix || ''
+ )
+ //don't leave a circular json object there incase using multilevel.
+ if(prefix) ch.prefix = prefix
+ ch.key = prefix + ch.key
+ if(h.safe && h.test(String(ch.key))) {
+ //this usually means a stack overflow.
+ throw new Error('prehook cannot insert into own range')
+ }
+ var ke = ch.keyEncoding || getKeyEncoding(ch.prefix)
+ var ve = ch.valueEncoding || getValueEncoding(ch.prefix)
+ if(ke) ch.keyEncoding = ke
+ if(ve) ch.valueEncoding = ve
+
+ b.push(ch)
+ hook(ch, b.length - 1)
+ return this
+ },
+ put: function (ch, db) {
+ if('object' === typeof ch) ch.type = 'put'
+ return this.add(ch, db)
+ },
+ del: function (ch, db) {
+ if('object' === typeof ch) ch.type = 'del'
+ return this.add(ch, db)
+ },
+ veto: function () {
+ return this.add(false)
+ }
+ }
+ h.hook.call(context, e, context.add, b)
+ }
+ })
+ })
+ } catch (err) {
+ return (cb || opts)(err)
+ }
+ b = b.filter(function (e) {
+ return e && e.type //filter out empty items
+ })
+
+ if(b.length == 1 && !isBatch) {
+ var change = b[0]
+ return change.type == 'put'
+ ? put.call(db, change.key, change.value, opts, cb)
+ : del.call(db, change.key, opts, cb)
+ }
+ return batch.call(db, b, opts, cb)
+ }
+
+ db.put = function (key, value, opts, cb ) {
+ var batch = [{key: key, value: value, type: 'put'}]
+ return callHooks(false, batch, opts, cb)
+ }
+
+ db.del = function (key, opts, cb) {
+ var batch = [{key: key, type: 'del'}]
+ return callHooks(false, batch, opts, cb)
+ }
+
+ db.batch = function (batch, opts, cb) {
+ return callHooks(true, batch, opts, cb)
+ }
+}
+
+},{"string-range":39}],39:[function(require,module,exports){
+
+//force to a valid range
+var range = exports.range = function (obj) {
+ return null == obj ? {} : 'string' === typeof range ? {
+ min: range, max: range + '\xff'
+ } : obj
+}
+
+//turn into a sub range.
+var prefix = exports.prefix = function (range, within, term) {
+ range = exports.range(range)
+ var _range = {}
+ term = term || '\xff'
+ if(range instanceof RegExp || 'function' == typeof range) {
+ _range.min = within
+ _range.max = within + term,
+ _range.inner = function (k) {
+ var j = k.substring(within.length)
+ if(range.test)
+ return range.test(j)
+ return range(j)
+ }
+ }
+ else if('object' === typeof range) {
+ _range.min = within + (range.min || range.start || '')
+ _range.max = within + (range.max || range.end || (term || '~'))
+ _range.reverse = !!range.reverse
+ }
+ return _range
+}
+
+//return a function that checks a range
+var checker = exports.checker = function (range) {
+ if(!range) range = {}
+
+ if ('string' === typeof range)
+ return function (key) {
+ return key.indexOf(range) == 0
+ }
+ else if(range instanceof RegExp)
+ return function (key) {
+ return range.test(key)
+ }
+ else if('object' === typeof range)
+ return function (key) {
+ var min = range.min || range.start
+ var max = range.max || range.end
+
+ // fixes keys passed as ints from sublevels
+ key = String(key)
+
+ return (
+ !min || key >= min
+ ) && (
+ !max || key <= max
+ ) && (
+ !range.inner || (
+ range.inner.test
+ ? range.inner.test(key)
+ : range.inner(key)
+ )
+ )
+ }
+ else if('function' === typeof range)
+ return range
+}
+//check if a key is within a range.
+var satifies = exports.satisfies = function (key, range) {
+ return checker(range)(key)
+}
+
+
+
+},{}],40:[function(require,module,exports){
+module.exports = hasKeys
+
+function hasKeys(source) {
+ return source !== null &&
+ (typeof source === "object" ||
+ typeof source === "function")
+}
+
+},{}],41:[function(require,module,exports){
+var Keys = require("object-keys")
+var hasKeys = require("./has-keys")
+
+module.exports = extend
+
+function extend() {
+ var target = {}
+
+ for (var i = 0; i < arguments.length; i++) {
+ var source = arguments[i]
+
+ if (!hasKeys(source)) {
+ continue
+ }
+
+ var keys = Keys(source)
+
+ for (var j = 0; j < keys.length; j++) {
+ var name = keys[j]
+ target[name] = source[name]
+ }
+ }
+
+ return target
+}
+
+},{"./has-keys":40,"object-keys":42}],42:[function(require,module,exports){
+module.exports = Object.keys || require('./shim');
+
+
+},{"./shim":45}],43:[function(require,module,exports){
+
+var hasOwn = Object.prototype.hasOwnProperty;
+var toString = Object.prototype.toString;
+
+module.exports = function forEach (obj, fn, ctx) {
+ if (toString.call(fn) !== '[object Function]') {
+ throw new TypeError('iterator must be a function');
+ }
+ var l = obj.length;
+ if (l === +l) {
+ for (var i = 0; i < l; i++) {
+ fn.call(ctx, obj[i], i, obj);
+ }
+ } else {
+ for (var k in obj) {
+ if (hasOwn.call(obj, k)) {
+ fn.call(ctx, obj[k], k, obj);
+ }
+ }
+ }
+};
+
+
+},{}],44:[function(require,module,exports){
+
+/**!
+ * is
+ * the definitive JavaScript type testing library
+ *
+ * @copyright 2013 Enrico Marino
+ * @license MIT
+ */
+
+var objProto = Object.prototype;
+var owns = objProto.hasOwnProperty;
+var toString = objProto.toString;
+var isActualNaN = function (value) {
+ return value !== value;
+};
+var NON_HOST_TYPES = {
+ "boolean": 1,
+ "number": 1,
+ "string": 1,
+ "undefined": 1
+};
+
+/**
+ * Expose `is`
+ */
+
+var is = module.exports = {};
+
+/**
+ * Test general.
+ */
+
+/**
+ * is.type
+ * Test if `value` is a type of `type`.
+ *
+ * @param {Mixed} value value to test
+ * @param {String} type type
+ * @return {Boolean} true if `value` is a type of `type`, false otherwise
+ * @api public
+ */
+
+is.a =
+is.type = function (value, type) {
+ return typeof value === type;
+};
+
+/**
+ * is.defined
+ * Test if `value` is defined.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if 'value' is defined, false otherwise
+ * @api public
+ */
+
+is.defined = function (value) {
+ return value !== undefined;
+};
+
+/**
+ * is.empty
+ * Test if `value` is empty.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is empty, false otherwise
+ * @api public
+ */
+
+is.empty = function (value) {
+ var type = toString.call(value);
+ var key;
+
+ if ('[object Array]' === type || '[object Arguments]' === type) {
+ return value.length === 0;
+ }
+
+ if ('[object Object]' === type) {
+ for (key in value) if (owns.call(value, key)) return false;
+ return true;
+ }
+
+ if ('[object String]' === type) {
+ return '' === value;
+ }
+
+ return false;
+};
+
+/**
+ * is.equal
+ * Test if `value` is equal to `other`.
+ *
+ * @param {Mixed} value value to test
+ * @param {Mixed} other value to compare with
+ * @return {Boolean} true if `value` is equal to `other`, false otherwise
+ */
+
+is.equal = function (value, other) {
+ var type = toString.call(value)
+ var key;
+
+ if (type !== toString.call(other)) {
+ return false;
+ }
+
+ if ('[object Object]' === type) {
+ for (key in value) {
+ if (!is.equal(value[key], other[key])) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ if ('[object Array]' === type) {
+ key = value.length;
+ if (key !== other.length) {
+ return false;
+ }
+ while (--key) {
+ if (!is.equal(value[key], other[key])) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ if ('[object Function]' === type) {
+ return value.prototype === other.prototype;
+ }
+
+ if ('[object Date]' === type) {
+ return value.getTime() === other.getTime();
+ }
+
+ return value === other;
+};
+
+/**
+ * is.hosted
+ * Test if `value` is hosted by `host`.
+ *
+ * @param {Mixed} value to test
+ * @param {Mixed} host host to test with
+ * @return {Boolean} true if `value` is hosted by `host`, false otherwise
+ * @api public
+ */
+
+is.hosted = function (value, host) {
+ var type = typeof host[value];
+ return type === 'object' ? !!host[value] : !NON_HOST_TYPES[type];
+};
+
+/**
+ * is.instance
+ * Test if `value` is an instance of `constructor`.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an instance of `constructor`
+ * @api public
+ */
+
+is.instance = is['instanceof'] = function (value, constructor) {
+ return value instanceof constructor;
+};
+
+/**
+ * is.null
+ * Test if `value` is null.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is null, false otherwise
+ * @api public
+ */
+
+is['null'] = function (value) {
+ return value === null;
+};
+
+/**
+ * is.undefined
+ * Test if `value` is undefined.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is undefined, false otherwise
+ * @api public
+ */
+
+is.undefined = function (value) {
+ return value === undefined;
+};
+
+/**
+ * Test arguments.
+ */
+
+/**
+ * is.arguments
+ * Test if `value` is an arguments object.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an arguments object, false otherwise
+ * @api public
+ */
+
+is.arguments = function (value) {
+ var isStandardArguments = '[object Arguments]' === toString.call(value);
+ var isOldArguments = !is.array(value) && is.arraylike(value) && is.object(value) && is.fn(value.callee);
+ return isStandardArguments || isOldArguments;
+};
+
+/**
+ * Test array.
+ */
+
+/**
+ * is.array
+ * Test if 'value' is an array.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an array, false otherwise
+ * @api public
+ */
+
+is.array = function (value) {
+ return '[object Array]' === toString.call(value);
+};
+
+/**
+ * is.arguments.empty
+ * Test if `value` is an empty arguments object.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an empty arguments object, false otherwise
+ * @api public
+ */
+is.arguments.empty = function (value) {
+ return is.arguments(value) && value.length === 0;
+};
+
+/**
+ * is.array.empty
+ * Test if `value` is an empty array.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an empty array, false otherwise
+ * @api public
+ */
+is.array.empty = function (value) {
+ return is.array(value) && value.length === 0;
+};
+
+/**
+ * is.arraylike
+ * Test if `value` is an arraylike object.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an arguments object, false otherwise
+ * @api public
+ */
+
+is.arraylike = function (value) {
+ return !!value && !is.boolean(value)
+ && owns.call(value, 'length')
+ && isFinite(value.length)
+ && is.number(value.length)
+ && value.length >= 0;
+};
+
+/**
+ * Test boolean.
+ */
+
+/**
+ * is.boolean
+ * Test if `value` is a boolean.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a boolean, false otherwise
+ * @api public
+ */
+
+is.boolean = function (value) {
+ return '[object Boolean]' === toString.call(value);
+};
+
+/**
+ * is.false
+ * Test if `value` is false.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is false, false otherwise
+ * @api public
+ */
+
+is['false'] = function (value) {
+ return is.boolean(value) && (value === false || value.valueOf() === false);
+};
+
+/**
+ * is.true
+ * Test if `value` is true.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is true, false otherwise
+ * @api public
+ */
+
+is['true'] = function (value) {
+ return is.boolean(value) && (value === true || value.valueOf() === true);
+};
+
+/**
+ * Test date.
+ */
+
+/**
+ * is.date
+ * Test if `value` is a date.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a date, false otherwise
+ * @api public
+ */
+
+is.date = function (value) {
+ return '[object Date]' === toString.call(value);
+};
+
+/**
+ * Test element.
+ */
+
+/**
+ * is.element
+ * Test if `value` is an html element.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an HTML Element, false otherwise
+ * @api public
+ */
+
+is.element = function (value) {
+ return value !== undefined
+ && typeof HTMLElement !== 'undefined'
+ && value instanceof HTMLElement
+ && value.nodeType === 1;
+};
+
+/**
+ * Test error.
+ */
+
+/**
+ * is.error
+ * Test if `value` is an error object.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an error object, false otherwise
+ * @api public
+ */
+
+is.error = function (value) {
+ return '[object Error]' === toString.call(value);
+};
+
+/**
+ * Test function.
+ */
+
+/**
+ * is.fn / is.function (deprecated)
+ * Test if `value` is a function.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a function, false otherwise
+ * @api public
+ */
+
+is.fn = is['function'] = function (value) {
+ var isAlert = typeof window !== 'undefined' && value === window.alert;
+ return isAlert || '[object Function]' === toString.call(value);
+};
+
+/**
+ * Test number.
+ */
+
+/**
+ * is.number
+ * Test if `value` is a number.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a number, false otherwise
+ * @api public
+ */
+
+is.number = function (value) {
+ return '[object Number]' === toString.call(value);
+};
+
+/**
+ * is.infinite
+ * Test if `value` is positive or negative infinity.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is positive or negative Infinity, false otherwise
+ * @api public
+ */
+is.infinite = function (value) {
+ return value === Infinity || value === -Infinity;
+};
+
+/**
+ * is.decimal
+ * Test if `value` is a decimal number.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a decimal number, false otherwise
+ * @api public
+ */
+
+is.decimal = function (value) {
+ return is.number(value) && !isActualNaN(value) && !is.infinite(value) && value % 1 !== 0;
+};
+
+/**
+ * is.divisibleBy
+ * Test if `value` is divisible by `n`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} n dividend
+ * @return {Boolean} true if `value` is divisible by `n`, false otherwise
+ * @api public
+ */
+
+is.divisibleBy = function (value, n) {
+ var isDividendInfinite = is.infinite(value);
+ var isDivisorInfinite = is.infinite(n);
+ var isNonZeroNumber = is.number(value) && !isActualNaN(value) && is.number(n) && !isActualNaN(n) && n !== 0;
+ return isDividendInfinite || isDivisorInfinite || (isNonZeroNumber && value % n === 0);
+};
+
+/**
+ * is.int
+ * Test if `value` is an integer.
+ *
+ * @param value to test
+ * @return {Boolean} true if `value` is an integer, false otherwise
+ * @api public
+ */
+
+is.int = function (value) {
+ return is.number(value) && !isActualNaN(value) && value % 1 === 0;
+};
+
+/**
+ * is.maximum
+ * Test if `value` is greater than 'others' values.
+ *
+ * @param {Number} value value to test
+ * @param {Array} others values to compare with
+ * @return {Boolean} true if `value` is greater than `others` values
+ * @api public
+ */
+
+is.maximum = function (value, others) {
+ if (isActualNaN(value)) {
+ throw new TypeError('NaN is not a valid value');
+ } else if (!is.arraylike(others)) {
+ throw new TypeError('second argument must be array-like');
+ }
+ var len = others.length;
+
+ while (--len >= 0) {
+ if (value < others[len]) {
+ return false;
+ }
+ }
+
+ return true;
+};
+
+/**
+ * is.minimum
+ * Test if `value` is less than `others` values.
+ *
+ * @param {Number} value value to test
+ * @param {Array} others values to compare with
+ * @return {Boolean} true if `value` is less than `others` values
+ * @api public
+ */
+
+is.minimum = function (value, others) {
+ if (isActualNaN(value)) {
+ throw new TypeError('NaN is not a valid value');
+ } else if (!is.arraylike(others)) {
+ throw new TypeError('second argument must be array-like');
+ }
+ var len = others.length;
+
+ while (--len >= 0) {
+ if (value > others[len]) {
+ return false;
+ }
+ }
+
+ return true;
+};
+
+/**
+ * is.nan
+ * Test if `value` is not a number.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is not a number, false otherwise
+ * @api public
+ */
+
+is.nan = function (value) {
+ return !is.number(value) || value !== value;
+};
+
+/**
+ * is.even
+ * Test if `value` is an even number.
+ *
+ * @param {Number} value value to test
+ * @return {Boolean} true if `value` is an even number, false otherwise
+ * @api public
+ */
+
+is.even = function (value) {
+ return is.infinite(value) || (is.number(value) && value === value && value % 2 === 0);
+};
+
+/**
+ * is.odd
+ * Test if `value` is an odd number.
+ *
+ * @param {Number} value value to test
+ * @return {Boolean} true if `value` is an odd number, false otherwise
+ * @api public
+ */
+
+is.odd = function (value) {
+ return is.infinite(value) || (is.number(value) && value === value && value % 2 !== 0);
+};
+
+/**
+ * is.ge
+ * Test if `value` is greater than or equal to `other`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} other value to compare with
+ * @return {Boolean}
+ * @api public
+ */
+
+is.ge = function (value, other) {
+ if (isActualNaN(value) || isActualNaN(other)) {
+ throw new TypeError('NaN is not a valid value');
+ }
+ return !is.infinite(value) && !is.infinite(other) && value >= other;
+};
+
+/**
+ * is.gt
+ * Test if `value` is greater than `other`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} other value to compare with
+ * @return {Boolean}
+ * @api public
+ */
+
+is.gt = function (value, other) {
+ if (isActualNaN(value) || isActualNaN(other)) {
+ throw new TypeError('NaN is not a valid value');
+ }
+ return !is.infinite(value) && !is.infinite(other) && value > other;
+};
+
+/**
+ * is.le
+ * Test if `value` is less than or equal to `other`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} other value to compare with
+ * @return {Boolean} if 'value' is less than or equal to 'other'
+ * @api public
+ */
+
+is.le = function (value, other) {
+ if (isActualNaN(value) || isActualNaN(other)) {
+ throw new TypeError('NaN is not a valid value');
+ }
+ return !is.infinite(value) && !is.infinite(other) && value <= other;
+};
+
+/**
+ * is.lt
+ * Test if `value` is less than `other`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} other value to compare with
+ * @return {Boolean} if `value` is less than `other`
+ * @api public
+ */
+
+is.lt = function (value, other) {
+ if (isActualNaN(value) || isActualNaN(other)) {
+ throw new TypeError('NaN is not a valid value');
+ }
+ return !is.infinite(value) && !is.infinite(other) && value < other;
+};
+
+/**
+ * is.within
+ * Test if `value` is within `start` and `finish`.
+ *
+ * @param {Number} value value to test
+ * @param {Number} start lower bound
+ * @param {Number} finish upper bound
+ * @return {Boolean} true if 'value' is is within 'start' and 'finish'
+ * @api public
+ */
+is.within = function (value, start, finish) {
+ if (isActualNaN(value) || isActualNaN(start) || isActualNaN(finish)) {
+ throw new TypeError('NaN is not a valid value');
+ } else if (!is.number(value) || !is.number(start) || !is.number(finish)) {
+ throw new TypeError('all arguments must be numbers');
+ }
+ var isAnyInfinite = is.infinite(value) || is.infinite(start) || is.infinite(finish);
+ return isAnyInfinite || (value >= start && value <= finish);
+};
+
+/**
+ * Test object.
+ */
+
+/**
+ * is.object
+ * Test if `value` is an object.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is an object, false otherwise
+ * @api public
+ */
+
+is.object = function (value) {
+ return value && '[object Object]' === toString.call(value);
+};
+
+/**
+ * is.hash
+ * Test if `value` is a hash - a plain object literal.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a hash, false otherwise
+ * @api public
+ */
+
+is.hash = function (value) {
+ return is.object(value) && value.constructor === Object && !value.nodeType && !value.setInterval;
+};
+
+/**
+ * Test regexp.
+ */
+
+/**
+ * is.regexp
+ * Test if `value` is a regular expression.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if `value` is a regexp, false otherwise
+ * @api public
+ */
+
+is.regexp = function (value) {
+ return '[object RegExp]' === toString.call(value);
+};
+
+/**
+ * Test string.
+ */
+
+/**
+ * is.string
+ * Test if `value` is a string.
+ *
+ * @param {Mixed} value value to test
+ * @return {Boolean} true if 'value' is a string, false otherwise
+ * @api public
+ */
+
+is.string = function (value) {
+ return '[object String]' === toString.call(value);
+};
+
+
+},{}],45:[function(require,module,exports){
+(function () {
+ "use strict";
+
+ // modified from https://github.com/kriskowal/es5-shim
+ var has = Object.prototype.hasOwnProperty,
+ is = require('is'),
+ forEach = require('foreach'),
+ hasDontEnumBug = !({'toString': null}).propertyIsEnumerable('toString'),
+ dontEnums = [
+ "toString",
+ "toLocaleString",
+ "valueOf",
+ "hasOwnProperty",
+ "isPrototypeOf",
+ "propertyIsEnumerable",
+ "constructor"
+ ],
+ keysShim;
+
+ keysShim = function keys(object) {
+ if (!is.object(object) && !is.array(object)) {
+ throw new TypeError("Object.keys called on a non-object");
+ }
+
+ var name, theKeys = [];
+ for (name in object) {
+ if (has.call(object, name)) {
+ theKeys.push(name);
+ }
+ }
+
+ if (hasDontEnumBug) {
+ forEach(dontEnums, function (dontEnum) {
+ if (has.call(object, dontEnum)) {
+ theKeys.push(dontEnum);
+ }
+ });
+ }
+ return theKeys;
+ };
+
+ module.exports = keysShim;
+}());
+
+
+},{"foreach":43,"is":44}],46:[function(require,module,exports){
+var EventEmitter = require('events').EventEmitter
+var inherits = require('util').inherits
+var ranges = require('string-range')
+var fixRange = require('level-fix-range')
+var xtend = require('xtend')
+var Batch = require('./batch')
+
+inherits(SubDB, EventEmitter)
+
+function SubDB (db, prefix, options) {
+ if('string' === typeof options) {
+ console.error('db.sublevel(name, seperator<string>) is depreciated')
+ console.error('use db.sublevel(name, {sep: separator})) if you must')
+ options = {sep: options}
+ }
+ if(!(this instanceof SubDB)) return new SubDB(db, prefix, options)
+ if(!db) throw new Error('must provide db')
+ if(!prefix) throw new Error('must provide prefix')
+
+ options = options || {}
+ options.sep = options.sep || '\xff'
+
+ this._parent = db
+ this._options = options
+ this.options = options
+ this._prefix = prefix
+ this._root = root(this)
+ db.sublevels[prefix] = this
+ this.sublevels = {}
+ this.methods = {}
+ var self = this
+ this.hooks = {
+ pre: function () {
+ return self.pre.apply(self, arguments)
+ },
+ post: function () {
+ return self.post.apply(self, arguments)
+ }
+ }
+}
+
+var SDB = SubDB.prototype
+
+SDB._key = function (key) {
+ var sep = this._options.sep
+ return sep
+ + this._prefix
+ + sep
+ + key
+}
+
+SDB._getOptsAndCb = function (opts, cb) {
+ if (typeof opts == 'function') {
+ cb = opts
+ opts = {}
+ }
+ return { opts: xtend(opts, this._options), cb: cb }
+}
+
+SDB.sublevel = function (prefix, options) {
+ if(this.sublevels[prefix])
+ return this.sublevels[prefix]
+ return new SubDB(this, prefix, options || this._options)
+}
+
+SDB.put = function (key, value, opts, cb) {
+ var res = this._getOptsAndCb(opts, cb)
+ this._root.put(this.prefix(key), value, res.opts, res.cb)
+}
+
+SDB.get = function (key, opts, cb) {
+ var res = this._getOptsAndCb(opts, cb)
+ this._root.get(this.prefix(key), res.opts, res.cb)
+}
+
+SDB.del = function (key, opts, cb) {
+ var res = this._getOptsAndCb(opts, cb)
+ this._root.del(this.prefix(key), res.opts, res.cb)
+}
+
+SDB.batch = function (changes, opts, cb) {
+ if(!Array.isArray(changes))
+ return new Batch(this)
+ var self = this,
+ res = this._getOptsAndCb(opts, cb)
+ changes.forEach(function (ch) {
+
+ //OH YEAH, WE NEED TO VALIDATE THAT UPDATING THIS KEY/PREFIX IS ALLOWED
+ if('string' === typeof ch.prefix)
+ ch.key = ch.prefix + ch.key
+ else
+ ch.key = (ch.prefix || self).prefix(ch.key)
+
+ if(ch.prefix) ch.prefix = null
+ })
+ this._root.batch(changes, res.opts, res.cb)
+}
+
+SDB._getKeyEncoding = function () {
+ if(this.options.keyEncoding)
+ return this.options.keyEncoding
+ if(this._parent && this._parent._getKeyEncoding)
+ return this._parent._getKeyEncoding()
+}
+
+SDB._getValueEncoding = function () {
+ if(this.options.valueEncoding)
+ return this.options.valueEncoding
+ if(this._parent && this._parent._getValueEncoding)
+ return this._parent._getValueEncoding()
+}
+
+SDB.prefix = function (key) {
+ var sep = this._options.sep
+ return this._parent.prefix() + sep + this._prefix + sep + (key || '')
+}
+
+SDB.keyStream =
+SDB.createKeyStream = function (opts) {
+ opts = opts || {}
+ opts.keys = true
+ opts.values = false
+ return this.createReadStream(opts)
+}
+
+SDB.valueStream =
+SDB.createValueStream = function (opts) {
+ opts = opts || {}
+ opts.keys = false
+ opts.values = true
+ opts.keys = false
+ return this.createReadStream(opts)
+}
+
+function selectivelyMerge(_opts, opts) {
+ [ 'valueEncoding'
+ , 'encoding'
+ , 'keyEncoding'
+ , 'reverse'
+ , 'values'
+ , 'keys'
+ , 'limit'
+ , 'fillCache'
+ ]
+ .forEach(function (k) {
+ if (opts.hasOwnProperty(k)) _opts[k] = opts[k]
+ })
+}
+
+SDB.readStream =
+SDB.createReadStream = function (opts) {
+ opts = opts || {}
+ var r = root(this)
+ var p = this.prefix()
+
+ var _opts = ranges.prefix(opts, p)
+ selectivelyMerge(_opts, xtend(opts, this._options))
+
+ var s = r.createReadStream(_opts)
+
+ if(_opts.values === false) {
+ var read = s.read
+ if (read) {
+ s.read = function (size) {
+ var val = read.call(this, size)
+ if (val) val = val.substring(p.length)
+ return val
+ }
+ } else {
+ var emit = s.emit
+ s.emit = function (event, val) {
+ if(event === 'data') {
+ emit.call(this, 'data', val.substring(p.length))
+ } else
+ emit.call(this, event, val)
+ }
+ }
+ return s
+ } else if(_opts.keys === false)
+ return s
+ else {
+ var read = s.read
+ if (read) {
+ s.read = function (size) {
+ var d = read.call(this, size)
+ if (d) d.key = d.key.substring(p.length)
+ return d
+ }
+ } else {
+ s.on('data', function (d) {
+ //mutate the prefix!
+ //this doesn't work for createKeyStream admittedly.
+ d.key = d.key.substring(p.length)
+ })
+ }
+ return s
+ }
+}
+
+
+SDB.writeStream =
+SDB.createWriteStream = function () {
+ var r = root(this)
+ var p = this.prefix()
+ var ws = r.createWriteStream.apply(r, arguments)
+ var write = ws.write
+
+ var encoding = this._options.encoding
+ var valueEncoding = this._options.valueEncoding
+ var keyEncoding = this._options.keyEncoding
+
+ // slight optimization, if no encoding was specified at all,
+ // which will be the case most times, make write not check at all
+ var nocheck = !encoding && !valueEncoding && !keyEncoding
+
+ ws.write = nocheck
+ ? function (data) {
+ data.key = p + data.key
+ return write.call(ws, data)
+ }
+ : function (data) {
+ data.key = p + data.key
+
+ // not merging all options here since this happens on every write and things could get slowed down
+ // at this point we only consider encoding important to propagate
+ if (encoding && typeof data.encoding === 'undefined')
+ data.encoding = encoding
+ if (valueEncoding && typeof data.valueEncoding === 'undefined')
+ data.valueEncoding = valueEncoding
+ if (keyEncoding && typeof data.keyEncoding === 'undefined')
+ data.keyEncoding = keyEncoding
+
+ return write.call(ws, data)
+ }
+ return ws
+}
+
+SDB.approximateSize = function () {
+ var r = root(db)
+ return r.approximateSize.apply(r, arguments)
+}
+
+function root(db) {
+ if(!db._parent) return db
+ return root(db._parent)
+}
+
+SDB.pre = function (range, hook) {
+ if(!hook) hook = range, range = null
+ range = ranges.prefix(range, this.prefix(), this._options.sep)
+ var r = root(this._parent)
+ var p = this.prefix()
+ return r.hooks.pre(fixRange(range), function (ch, add, batch) {
+ hook({
+ key: ch.key.substring(p.length),
+ value: ch.value,
+ type: ch.type
+ }, function (ch, _p) {
+ //maybe remove the second add arg now
+ //that op can have prefix?
+ add(ch, ch.prefix ? _p : (_p || p))
+ }, batch)
+ })
+}
+
+SDB.post = function (range, hook) {
+ if(!hook) hook = range, range = null
+ var r = root(this._parent)
+ var p = this.prefix()
+ range = ranges.prefix(range, p, this._options.sep)
+ return r.hooks.post(fixRange(range), function (data) {
+ hook({key: data.key.substring(p.length), value: data.value, type: data.type})
+ })
+}
+
+var exports = module.exports = SubDB
+
+
+},{"./batch":34,"events":18,"level-fix-range":36,"string-range":39,"util":32,"xtend":41}],47:[function(require,module,exports){
+/* Copyright (c) 2012-2014 LevelUP contributors
+ * See list at <https://github.com/rvagg/node-levelup#contributing>
+ * MIT License
+ * <https://github.com/rvagg/node-levelup/blob/master/LICENSE.md>
+ */
+
+var util = require('./util')
+ , WriteError = require('./errors').WriteError
+
+ , getOptions = util.getOptions
+ , dispatchError = util.dispatchError
+
+function Batch (levelup) {
+ this._levelup = levelup
+ this.batch = levelup.db.batch()
+ this.ops = []
+}
+
+Batch.prototype.put = function (key_, value_, options) {
+ options = getOptions(this._levelup, options)
+
+ var key = util.encodeKey(key_, options)
+ , value = util.encodeValue(value_, options)
+
+ try {
+ this.batch.put(key, value)
+ } catch (e) {
+ throw new WriteError(e)
+ }
+ this.ops.push({ type : 'put', key : key, value : value })
+
+ return this
+}
+
+Batch.prototype.del = function (key_, options) {
+ options = getOptions(this._levelup, options)
+
+ var key = util.encodeKey(key_, options)
+
+ try {
+ this.batch.del(key)
+ } catch (err) {
+ throw new WriteError(err)
+ }
+ this.ops.push({ type : 'del', key : key })
+
+ return this
+}
+
+Batch.prototype.clear = function () {
+ try {
+ this.batch.clear()
+ } catch (err) {
+ throw new WriteError(err)
+ }
+
+ this.ops = []
+ return this
+}
+
+Batch.prototype.write = function (callback) {
+ var levelup = this._levelup
+ , ops = this.ops
+
+ try {
+ this.batch.write(function (err) {
+ if (err)
+ return dispatchError(levelup, new WriteError(err), callback)
+ levelup.emit('batch', ops)
+ if (callback)
+ callback()
+ })
+ } catch (err) {
+ throw new WriteError(err)
+ }
+}
+
+module.exports = Batch
+
+},{"./errors":48,"./util":51}],48:[function(require,module,exports){
+/* Copyright (c) 2012-2014 LevelUP contributors
+ * See list at <https://github.com/rvagg/node-levelup#contributing>
+ * MIT License
+ * <https://github.com/rvagg/node-levelup/blob/master/LICENSE.md>
+ */
+
+var createError = require('errno').create
+ , LevelUPError = createError('LevelUPError')
+ , NotFoundError = createError('NotFoundError', LevelUPError)
+
+NotFoundError.prototype.notFound = true
+NotFoundError.prototype.status = 404
+
+module.exports = {
+ LevelUPError : LevelUPError
+ , InitializationError : createError('InitializationError', LevelUPError)
+ , OpenError : createError('OpenError', LevelUPError)
+ , ReadError : createError('ReadError', LevelUPError)
+ , WriteError : createError('WriteError', LevelUPError)
+ , NotFoundError : NotFoundError
+ , EncodingError : createError('EncodingError', LevelUPError)
+}
+
+},{"errno":59}],49:[function(require,module,exports){
+(function (process){
+/* Copyright (c) 2012-2014 LevelUP contributors
+ * See list at <https://github.com/rvagg/node-levelup#contributing>
+ * MIT License
+ * <https://github.com/rvagg/node-levelup/blob/master/LICENSE.md>
+ */
+
+var EventEmitter = require('events').EventEmitter
+ , inherits = require('util').inherits
+ , extend = require('xtend')
+ , prr = require('prr')
+ , DeferredLevelDOWN = require('deferred-leveldown')
+
+ , WriteError = require('./errors').WriteError
+ , ReadError = require('./errors').ReadError
+ , NotFoundError = require('./errors').NotFoundError
+ , OpenError = require('./errors').OpenError
+ , EncodingError = require('./errors').EncodingError
+ , InitializationError = require('./errors').InitializationError
+
+ , ReadStream = require('./read-stream')
+ , WriteStream = require('./write-stream')
+ , util = require('./util')
+ , Batch = require('./batch')
+
+ , getOptions = util.getOptions
+ , defaultOptions = util.defaultOptions
+ , getLevelDOWN = util.getLevelDOWN
+ , dispatchError = util.dispatchError
+
+function getCallback (options, callback) {
+ return typeof options == 'function' ? options : callback
+}
+
+// Possible LevelUP#_status values:
+// - 'new' - newly created, not opened or closed
+// - 'opening' - waiting for the database to be opened, post open()
+// - 'open' - successfully opened the database, available for use
+// - 'closing' - waiting for the database to be closed, post close()
+// - 'closed' - database has been successfully closed, should not be
+// used except for another open() operation
+
+function LevelUP (location, options, callback) {
+ if (!(this instanceof LevelUP))
+ return new LevelUP(location, options, callback)
+
+ var error
+
+ EventEmitter.call(this)
+ this.setMaxListeners(Infinity)
+
+ if (typeof location == 'function') {
+ options = typeof options == 'object' ? options : {}
+ options.db = location
+ location = null
+ } else if (typeof location == 'object' && typeof location.db == 'function') {
+ options = location
+ location = null
+ }
+
+ if (typeof options == 'function') {
+ callback = options
+ options = {}
+ }
+
+ if ((!options || typeof options.db != 'function') && typeof location != 'string') {
+ error = new InitializationError(
+ 'Must provide a location for the database')
+ if (callback) {
+ return process.nextTick(function () {
+ callback(error)
+ })
+ }
+ throw error
+ }
+
+ options = getOptions(this, options)
+ this.options = extend(defaultOptions, options)
+ this._status = 'new'
+ // set this.location as enumerable but not configurable or writable
+ prr(this, 'location', location, 'e')
+
+ this.open(callback)
+}
+
+inherits(LevelUP, EventEmitter)
+
+LevelUP.prototype.open = function (callback) {
+ var self = this
+ , dbFactory
+ , db
+
+ if (this.isOpen()) {
+ if (callback)
+ process.nextTick(function () { callback(null, self) })
+ return this
+ }
+
+ if (this._isOpening()) {
+ return callback && this.once(
+ 'open'
+ , function () { callback(null, self) }
+ )
+ }
+
+ this.emit('opening')
+
+ this._status = 'opening'
+ this.db = new DeferredLevelDOWN(this.location)
+ dbFactory = this.options.db || getLevelDOWN()
+ db = dbFactory(this.location)
+
+ db.open(this.options, function (err) {
+ if (err) {
+ return dispatchError(self, new OpenError(err), callback)
+ } else {
+ self.db.setDb(db)
+ self.db = db
+ self._status = 'open'
+ if (callback)
+ callback(null, self)
+ self.emit('open')
+ self.emit('ready')
+ }
+ })
+}
+
+LevelUP.prototype.close = function (callback) {
+ var self = this
+
+ if (this.isOpen()) {
+ this._status = 'closing'
+ this.db.close(function () {
+ self._status = 'closed'
+ self.emit('closed')
+ if (callback)
+ callback.apply(null, arguments)
+ })
+ this.emit('closing')
+ this.db = null
+ } else if (this._status == 'closed' && callback) {
+ return process.nextTick(callback)
+ } else if (this._status == 'closing' && callback) {
+ this.once('closed', callback)
+ } else if (this._isOpening()) {
+ this.once('open', function () {
+ self.close(callback)
+ })
+ }
+}
+
+LevelUP.prototype.isOpen = function () {
+ return this._status == 'open'
+}
+
+LevelUP.prototype._isOpening = function () {
+ return this._status == 'opening'
+}
+
+LevelUP.prototype.isClosed = function () {
+ return (/^clos/).test(this._status)
+}
+
+LevelUP.prototype.get = function (key_, options, callback) {
+ var self = this
+ , key
+
+ callback = getCallback(options, callback)
+
+ if (typeof callback != 'function') {
+ return dispatchError(
+ this
+ , new ReadError('get() requires key and callback arguments')
+ )
+ }
+
+ if (!this._isOpening() && !this.isOpen()) {
+ return dispatchError(
+ this
+ , new ReadError('Database is not open')
+ , callback
+ )
+ }
+
+ options = util.getOptions(this, options)
+ key = util.encodeKey(key_, options)
+
+ options.asBuffer = util.isValueAsBuffer(options)
+
+ this.db.get(key, options, function (err, value) {
+ if (err) {
+ if ((/notfound/i).test(err)) {
+ err = new NotFoundError(
+ 'Key not found in database [' + key_ + ']', err)
+ } else {
+ err = new ReadError(err)
+ }
+ return dispatchError(self, err, callback)
+ }
+ if (callback) {
+ try {
+ value = util.decodeValue(value, options)
+ } catch (e) {
+ return callback(new EncodingError(e))
+ }
+ callback(null, value)
+ }
+ })
+}
+
+LevelUP.prototype.put = function (key_, value_, options, callback) {
+ var self = this
+ , key
+ , value
+
+ callback = getCallback(options, callback)
+
+ if (key_ === null || key_ === undefined
+ || value_ === null || value_ === undefined) {
+ return dispatchError(
+ this
+ , new WriteError('put() requires key and value arguments')
+ , callback
+ )
+ }
+
+ if (!this._isOpening() && !this.isOpen()) {
+ return dispatchError(
+ this
+ , new WriteError('Database is not open')
+ , callback
+ )
+ }
+
+ options = getOptions(this, options)
+ key = util.encodeKey(key_, options)
+ value = util.encodeValue(value_, options)
+
+ this.db.put(key, value, options, function (err) {
+ if (err) {
+ return dispatchError(self, new WriteError(err), callback)
+ } else {
+ self.emit('put', key_, value_)
+ if (callback)
+ callback()
+ }
+ })
+}
+
+LevelUP.prototype.del = function (key_, options, callback) {
+ var self = this
+ , key
+
+ callback = getCallback(options, callback)
+
+ if (key_ === null || key_ === undefined) {
+ return dispatchError(
+ this
+ , new WriteError('del() requires a key argument')
+ , callback
+ )
+ }
+
+ if (!this._isOpening() && !this.isOpen()) {
+ return dispatchError(
+ this
+ , new WriteError('Database is not open')
+ , callback
+ )
+ }
+
+ options = getOptions(this, options)
+ key = util.encodeKey(key_, options)
+
+ this.db.del(key, options, function (err) {
+ if (err) {
+ return dispatchError(self, new WriteError(err), callback)
+ } else {
+ self.emit('del', key_)
+ if (callback)
+ callback()
+ }
+ })
+}
+
+LevelUP.prototype.batch = function (arr_, options, callback) {
+ var self = this
+ , keyEnc
+ , valueEnc
+ , arr
+
+ if (!arguments.length)
+ return new Batch(this)
+
+ callback = getCallback(options, callback)
+
+ if (!Array.isArray(arr_)) {
+ return dispatchError(
+ this
+ , new WriteError('batch() requires an array argument')
+ , callback
+ )
+ }
+
+ if (!this._isOpening() && !this.isOpen()) {
+ return dispatchError(
+ this
+ , new WriteError('Database is not open')
+ , callback
+ )
+ }
+
+ options = getOptions(this, options)
+ keyEnc = options.keyEncoding
+ valueEnc = options.valueEncoding
+
+ arr = arr_.map(function (e) {
+ if (e.type === undefined || e.key === undefined)
+ return {}
+
+ // inherit encoding
+ var kEnc = e.keyEncoding || keyEnc
+ , vEnc = e.valueEncoding || e.encoding || valueEnc
+ , o
+
+ // If we're not dealing with plain utf8 strings or plain
+ // Buffers then we have to do some work on the array to
+ // encode the keys and/or values. This includes JSON types.
+
+ if (kEnc != 'utf8' && kEnc != 'binary'
+ || vEnc != 'utf8' && vEnc != 'binary') {
+ o = {
+ type: e.type
+ , key: util.encodeKey(e.key, options, e)
+ }
+
+ if (e.value !== undefined)
+ o.value = util.encodeValue(e.value, options, e)
+
+ return o
+ } else {
+ return e
+ }
+ })
+
+ this.db.batch(arr, options, function (err) {
+ if (err) {
+ return dispatchError(self, new WriteError(err), callback)
+ } else {
+ self.emit('batch', arr_)
+ if (callback)
+ callback()
+ }
+ })
+}
+
+// DEPRECATED: prefer accessing LevelDOWN for this: db.db.approximateSize()
+LevelUP.prototype.approximateSize = function (start_, end_, callback) {
+ var self = this
+ , start
+ , end
+
+ if (start_ === null || start_ === undefined
+ || end_ === null || end_ === undefined
+ || typeof callback != 'function') {
+ return dispatchError(
+ this
+ , new ReadError('approximateSize() requires start, end and callback arguments')
+ , callback
+ )
+ }
+
+ start = util.encodeKey(start_, this.options)
+ end = util.encodeKey(end_, this.options)
+
+ if (!this._isOpening() && !this.isOpen()) {
+ return dispatchError(
+ this
+ , new WriteError('Database is not open')
+ , callback
+ )
+ }
+
+ this.db.approximateSize(start, end, function (err, size) {
+ if (err) {
+ return dispatchError(self, new OpenError(err), callback)
+ } else if (callback) {
+ callback(null, size)
+ }
+ })
+}
+
+LevelUP.prototype.readStream =
+LevelUP.prototype.createReadStream = function (options) {
+ var self = this
+ options = extend(this.options, options)
+ return new ReadStream(
+ options
+ , this
+ , function (options) {
+ return self.db.iterator(options)
+ }
+ )
+}
+
+LevelUP.prototype.keyStream =
+LevelUP.prototype.createKeyStream = function (options) {
+ return this.createReadStream(extend(options, { keys: true, values: false }))
+}
+
+LevelUP.prototype.valueStream =
+LevelUP.prototype.createValueStream = function (options) {
+ return this.createReadStream(extend(options, { keys: false, values: true }))
+}
+
+LevelUP.prototype.writeStream =
+LevelUP.prototype.createWriteStream = function (options) {
+ return new WriteStream(extend(options), this)
+}
+
+LevelUP.prototype.toString = function () {
+ return 'LevelUP'
+}
+
+function utilStatic (name) {
+ return function (location, callback) {
+ getLevelDOWN()[name](location, callback || function () {})
+ }
+}
+
+module.exports = LevelUP
+module.exports.copy = util.copy
+// DEPRECATED: prefer accessing LevelDOWN for this: require('leveldown').destroy()
+module.exports.destroy = utilStatic('destroy')
+// DEPRECATED: prefer accessing LevelDOWN for this: require('leveldown').repair()
+module.exports.repair = utilStatic('repair')
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"./batch":47,"./errors":48,"./read-stream":50,"./util":51,"./write-stream":52,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"deferred-leveldown":54,"events":18,"prr":60,"util":32,"xtend":70}],50:[function(require,module,exports){
+/* Copyright (c) 2012-2014 LevelUP contributors
+ * See list at <https://github.com/rvagg/node-levelup#contributing>
+ * MIT License <https://github.com/rvagg/node-levelup/blob/master/LICENSE.md>
+ */
+
+// NOTE: we are fixed to readable-stream@1.0.x for now
+// for pure Streams2 across Node versions
+var Readable = require('readable-stream').Readable
+ , inherits = require('util').inherits
+ , extend = require('xtend')
+ , EncodingError = require('./errors').EncodingError
+ , util = require('./util')
+
+ , defaultOptions = { keys: true, values: true }
+
+ , makeKeyValueData = function (key, value) {
+ return {
+ key: util.decodeKey(key, this._options)
+ , value: util.decodeValue(value, this._options)
+ }
+ }
+ , makeKeyData = function (key) {
+ return util.decodeKey(key, this._options)
+ }
+ , makeValueData = function (_, value) {
+ return util.decodeValue(value, this._options)
+ }
+ , makeNoData = function () { return null }
+
+function ReadStream (options, db, iteratorFactory) {
+ if (!(this instanceof ReadStream))
+ return new ReadStream(options, db, iteratorFactory)
+
+ Readable.call(this, { objectMode: true, highWaterMark: options.highWaterMark })
+
+ // purely to keep `db` around until we're done so it's not GCed if the user doesn't keep a ref
+ this._db = db
+
+ options = this._options = extend(defaultOptions, options)
+
+ this._keyEncoding = options.keyEncoding || options.encoding
+ this._valueEncoding = options.valueEncoding || options.encoding
+
+ if (typeof this._options.start != 'undefined')
+ this._options.start = util.encodeKey(this._options.start, this._options)
+ if (typeof this._options.end != 'undefined')
+ this._options.end = util.encodeKey(this._options.end, this._options)
+ if (typeof this._options.limit != 'number')
+ this._options.limit = -1
+
+ this._options.keyAsBuffer = util.isKeyAsBuffer(this._options)
+
+ this._options.valueAsBuffer = util.isValueAsBuffer(this._options)
+
+ this._makeData = this._options.keys && this._options.values
+ ? makeKeyValueData : this._options.keys
+ ? makeKeyData : this._options.values
+ ? makeValueData : makeNoData
+
+ var self = this
+ if (!this._db.isOpen()) {
+ this._db.once('ready', function () {
+ if (!self._destroyed) {
+ self._iterator = iteratorFactory(self._options)
+ }
+ })
+ } else
+ this._iterator = iteratorFactory(this._options)
+}
+
+inherits(ReadStream, Readable)
+
+ReadStream.prototype._read = function read () {
+ var self = this
+ if (!self._db.isOpen()) {
+ return self._db.once('ready', function () { read.call(self) })
+ }
+ if (self._destroyed)
+ return
+
+ self._iterator.next(function(err, key, value) {
+ if (err || (key === undefined && value === undefined)) {
+ if (!err && !self._destroyed)
+ self.push(null)
+ return self._cleanup(err)
+ }
+
+ try {
+ value = self._makeData(key, value)
+ } catch (e) {
+ return self._cleanup(new EncodingError(e))
+ }
+ if (!self._destroyed)
+ self.push(value)
+ })
+}
+
+ReadStream.prototype._cleanup = function (err) {
+ if (this._destroyed)
+ return
+
+ this._destroyed = true
+
+ var self = this
+ if (err)
+ self.emit('error', err)
+
+ if (self._iterator) {
+ self._iterator.end(function () {
+ self._iterator = null
+ self.emit('close')
+ })
+ } else {
+ self.emit('close')
+ }
+}
+
+ReadStream.prototype.destroy = function () {
+ this._cleanup()
+}
+
+ReadStream.prototype.toString = function () {
+ return 'LevelUP.ReadStream'
+}
+
+module.exports = ReadStream
+
+},{"./errors":48,"./util":51,"readable-stream":69,"util":32,"xtend":70}],51:[function(require,module,exports){
+(function (process,Buffer){
+/* Copyright (c) 2012-2014 LevelUP contributors
+ * See list at <https://github.com/rvagg/node-levelup#contributing>
+ * MIT License
+ * <https://github.com/rvagg/node-levelup/blob/master/LICENSE.md>
+ */
+
+var extend = require('xtend')
+ , LevelUPError = require('./errors').LevelUPError
+
+ , encodingNames = [
+ 'hex'
+ , 'utf8'
+ , 'utf-8'
+ , 'ascii'
+ , 'binary'
+ , 'base64'
+ , 'ucs2'
+ , 'ucs-2'
+ , 'utf16le'
+ , 'utf-16le'
+ ]
+
+ , defaultOptions = {
+ createIfMissing : true
+ , errorIfExists : false
+ , keyEncoding : 'utf8'
+ , valueEncoding : 'utf8'
+ , compression : true
+ }
+
+ , leveldown
+
+ , encodings = (function () {
+ function isBinary (data) {
+ return data === undefined || data === null || Buffer.isBuffer(data)
+ }
+
+ var encodings = {}
+ encodings.utf8 = encodings['utf-8'] = {
+ encode : function (data) {
+ return isBinary(data) ? data : String(data)
+ }
+ , decode : function (data) {
+ return data
+ }
+ , buffer : false
+ , type : 'utf8'
+ }
+ encodings.json = {
+ encode : JSON.stringify
+ , decode : JSON.parse
+ , buffer : false
+ , type : 'json'
+ }
+ encodingNames.forEach(function (type) {
+ if (encodings[type])
+ return
+ encodings[type] = {
+ encode : function (data) {
+ return isBinary(data) ? data : new Buffer(data, type)
+ }
+ , decode : function (buffer) {
+ return process.browser ? buffer.toString(type) : buffer;
+ }
+ , buffer : true
+ , type : type // useful for debugging purposes
+ }
+ })
+ return encodings
+ })()
+
+ , encodingOpts = (function () {
+ var eo = {}
+ encodingNames.forEach(function (e) {
+ eo[e] = { valueEncoding : e }
+ })
+ return eo
+ }())
+
+function copy (srcdb, dstdb, callback) {
+ srcdb.readStream()
+ .pipe(dstdb.writeStream())
+ .on('close', callback ? callback : function () {})
+ .on('error', callback ? callback : function (err) { throw err })
+}
+
+function getOptions (levelup, options) {
+ var s = typeof options == 'string' // just an encoding
+ if (!s && options && options.encoding && !options.valueEncoding)
+ options.valueEncoding = options.encoding
+ return extend(
+ (levelup && levelup.options) || {}
+ , s ? encodingOpts[options] || encodingOpts[defaultOptions.valueEncoding]
+ : options
+ )
+}
+
+function getLevelDOWN () {
+ if (leveldown)
+ return leveldown
+
+ var requiredVersion = require('../package.json').devDependencies.leveldown
+ , missingLevelDOWNError = 'Could not locate LevelDOWN, try `npm install leveldown`'
+ , leveldownVersion
+
+ try {
+ leveldownVersion = require('leveldown/package').version
+ } catch (e) {
+ throw new LevelUPError(missingLevelDOWNError)
+ }
+
+ if (!require('semver').satisfies(leveldownVersion, requiredVersion)) {
+ throw new LevelUPError(
+ 'Installed version of LevelDOWN ('
+ + leveldownVersion
+ + ') does not match required version ('
+ + requiredVersion
+ + ')'
+ )
+ }
+
+ try {
+ return leveldown = require('leveldown')
+ } catch (e) {
+ throw new LevelUPError(missingLevelDOWNError)
+ }
+}
+
+function dispatchError (levelup, error, callback) {
+ return typeof callback == 'function'
+ ? callback(error)
+ : levelup.emit('error', error)
+}
+
+function getKeyEncoder (options, op) {
+ var type = ((op && op.keyEncoding) || options.keyEncoding) || 'utf8'
+ return encodings[type] || type
+}
+
+function getValueEncoder (options, op) {
+ var type = (((op && (op.valueEncoding || op.encoding))
+ || options.valueEncoding || options.encoding)) || 'utf8'
+ return encodings[type] || type
+}
+
+function encodeKey (key, options, op) {
+ return getKeyEncoder(options, op).encode(key)
+}
+
+function encodeValue (value, options, op) {
+ return getValueEncoder(options, op).encode(value)
+}
+
+function decodeKey (key, options) {
+ return getKeyEncoder(options).decode(key)
+}
+
+function decodeValue (value, options) {
+ return getValueEncoder(options).decode(value)
+}
+
+function isValueAsBuffer (options, op) {
+ return getValueEncoder(options, op).buffer
+}
+
+function isKeyAsBuffer (options, op) {
+ return getKeyEncoder(options, op).buffer
+}
+
+module.exports = {
+ defaultOptions : defaultOptions
+ , copy : copy
+ , getOptions : getOptions
+ , getLevelDOWN : getLevelDOWN
+ , dispatchError : dispatchError
+ , encodeKey : encodeKey
+ , encodeValue : encodeValue
+ , isValueAsBuffer : isValueAsBuffer
+ , isKeyAsBuffer : isKeyAsBuffer
+ , decodeValue : decodeValue
+ , decodeKey : decodeKey
+}
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),require("buffer").Buffer)
+},{"../package.json":71,"./errors":48,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"leveldown":"RQL87X","leveldown/package":17,"semver":17,"xtend":70}],52:[function(require,module,exports){
+(function (process,global){
+/* Copyright (c) 2012-2014 LevelUP contributors
+ * See list at <https://github.com/rvagg/node-levelup#contributing>
+ * MIT License
+ * <https://github.com/rvagg/node-levelup/blob/master/LICENSE.md>
+ */
+
+var Stream = require('stream').Stream
+ , inherits = require('util').inherits
+ , extend = require('xtend')
+ , bl = require('bl')
+
+ , setImmediate = global.setImmediate || process.nextTick
+
+ , getOptions = require('./util').getOptions
+
+ , defaultOptions = { type: 'put' }
+
+function WriteStream (options, db) {
+ if (!(this instanceof WriteStream))
+ return new WriteStream(options, db)
+
+ Stream.call(this)
+ this._options = extend(defaultOptions, getOptions(db, options))
+ this._db = db
+ this._buffer = []
+ this._status = 'init'
+ this._end = false
+ this.writable = true
+ this.readable = false
+
+ var self = this
+ , ready = function () {
+ if (!self.writable)
+ return
+ self._status = 'ready'
+ self.emit('ready')
+ self._process()
+ }
+
+ if (db.isOpen())
+ setImmediate(ready)
+ else
+ db.once('ready', ready)
+}
+
+inherits(WriteStream, Stream)
+
+WriteStream.prototype.write = function (data) {
+ if (!this.writable)
+ return false
+ this._buffer.push(data)
+ if (this._status != 'init')
+ this._processDelayed()
+ if (this._options.maxBufferLength &&
+ this._buffer.length > this._options.maxBufferLength) {
+ this._writeBlock = true
+ return false
+ }
+ return true
+}
+
+WriteStream.prototype.end = function (data) {
+ var self = this
+ if (data)
+ this.write(data)
+ setImmediate(function () {
+ self._end = true
+ self._process()
+ })
+}
+
+WriteStream.prototype.destroy = function () {
+ this.writable = false
+ this.end()
+}
+
+WriteStream.prototype.destroySoon = function () {
+ this.end()
+}
+
+WriteStream.prototype.add = function (entry) {
+ if (!entry.props)
+ return
+ if (entry.props.Directory)
+ entry.pipe(this._db.writeStream(this._options))
+ else if (entry.props.File || entry.File || entry.type == 'File')
+ this._write(entry)
+ return true
+}
+
+WriteStream.prototype._processDelayed = function () {
+ var self = this
+ setImmediate(function () {
+ self._process()
+ })
+}
+
+WriteStream.prototype._process = function () {
+ var buffer
+ , self = this
+
+ , cb = function (err) {
+ if (!self.writable)
+ return
+ if (self._status != 'closed')
+ self._status = 'ready'
+ if (err) {
+ self.writable = false
+ return self.emit('error', err)
+ }
+ self._process()
+ }
+
+ if (self._status != 'ready' && self.writable) {
+ if (self._buffer.length && self._status != 'closed')
+ self._processDelayed()
+ return
+ }
+
+ if (self._buffer.length && self.writable) {
+ self._status = 'writing'
+ buffer = self._buffer
+ self._buffer = []
+
+ self._db.batch(buffer.map(function (d) {
+ return {
+ type : d.type || self._options.type
+ , key : d.key
+ , value : d.value
+ , keyEncoding : d.keyEncoding || self._options.keyEncoding
+ , valueEncoding : d.valueEncoding
+ || d.encoding
+ || self._options.valueEncoding
+ }
+ }), cb)
+
+ if (self._writeBlock) {
+ self._writeBlock = false
+ self.emit('drain')
+ }
+
+ // don't allow close until callback has returned
+ return
+ }
+
+ if (self._end && self._status != 'closed') {
+ self._status = 'closed'
+ self.writable = false
+ self.emit('close')
+ }
+}
+
+WriteStream.prototype._write = function (entry) {
+ var key = entry.path || entry.props.path
+ , self = this
+
+ if (!key)
+ return
+
+ entry.pipe(bl(function (err, data) {
+ if (err) {
+ self.writable = false
+ return self.emit('error', err)
+ }
+
+ if (self._options.fstreamRoot &&
+ key.indexOf(self._options.fstreamRoot) > -1)
+ key = key.substr(self._options.fstreamRoot.length + 1)
+
+ self.write({ key: key, value: data.slice(0) })
+ }))
+}
+
+WriteStream.prototype.toString = function () {
+ return 'LevelUP.WriteStream'
+}
+
+module.exports = WriteStream
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./util":51,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"bl":53,"stream":24,"util":32,"xtend":70}],53:[function(require,module,exports){
+(function (Buffer){
+var DuplexStream = require('readable-stream').Duplex
+ , util = require('util')
+
+function BufferList (callback) {
+ if (!(this instanceof BufferList))
+ return new BufferList(callback)
+
+ this._bufs = []
+ this.length = 0
+
+ if (typeof callback == 'function') {
+ this._callback = callback
+
+ var piper = function (err) {
+ if (this._callback) {
+ this._callback(err)
+ this._callback = null
+ }
+ }.bind(this)
+
+ this.on('pipe', function (src) {
+ src.on('error', piper)
+ })
+ this.on('unpipe', function (src) {
+ src.removeListener('error', piper)
+ })
+ }
+ else if (Buffer.isBuffer(callback))
+ this.append(callback)
+ else if (Array.isArray(callback)) {
+ callback.forEach(function (b) {
+ Buffer.isBuffer(b) && this.append(b)
+ }.bind(this))
+ }
+
+ DuplexStream.call(this)
+}
+
+util.inherits(BufferList, DuplexStream)
+
+BufferList.prototype._offset = function (offset) {
+ var tot = 0, i = 0, _t
+ for (; i < this._bufs.length; i++) {
+ _t = tot + this._bufs[i].length
+ if (offset < _t)
+ return [ i, offset - tot ]
+ tot = _t
+ }
+}
+
+BufferList.prototype.append = function (buf) {
+ this._bufs.push(Buffer.isBuffer(buf) ? buf : new Buffer(buf))
+ this.length += buf.length
+ return this
+}
+
+BufferList.prototype._write = function (buf, encoding, callback) {
+ this.append(buf)
+ if (callback)
+ callback()
+}
+
+BufferList.prototype._read = function (size) {
+ if (!this.length)
+ return this.push(null)
+ size = Math.min(size, this.length)
+ this.push(this.slice(0, size))
+ this.consume(size)
+}
+
+BufferList.prototype.end = function (chunk) {
+ DuplexStream.prototype.end.call(this, chunk)
+
+ if (this._callback) {
+ this._callback(null, this.slice())
+ this._callback = null
+ }
+}
+
+BufferList.prototype.get = function (index) {
+ return this.slice(index, index + 1)[0]
+}
+
+BufferList.prototype.slice = function (start, end) {
+ return this.copy(null, 0, start, end)
+}
+
+BufferList.prototype.copy = function (dst, dstStart, srcStart, srcEnd) {
+ if (typeof srcStart != 'number' || srcStart < 0)
+ srcStart = 0
+ if (typeof srcEnd != 'number' || srcEnd > this.length)
+ srcEnd = this.length
+ if (srcStart >= this.length)
+ return dst || new Buffer(0)
+ if (srcEnd <= 0)
+ return dst || new Buffer(0)
+
+ var copy = !!dst
+ , off = this._offset(srcStart)
+ , len = srcEnd - srcStart
+ , bytes = len
+ , bufoff = (copy && dstStart) || 0
+ , start = off[1]
+ , l
+ , i
+
+ // copy/slice everything
+ if (srcStart === 0 && srcEnd == this.length) {
+ if (!copy) // slice, just return a full concat
+ return Buffer.concat(this._bufs)
+
+ // copy, need to copy individual buffers
+ for (i = 0; i < this._bufs.length; i++) {
+ this._bufs[i].copy(dst, bufoff)
+ bufoff += this._bufs[i].length
+ }
+
+ return dst
+ }
+
+ // easy, cheap case where it's a subset of one of the buffers
+ if (bytes <= this._bufs[off[0]].length - start) {
+ return copy
+ ? this._bufs[off[0]].copy(dst, dstStart, start, start + bytes)
+ : this._bufs[off[0]].slice(start, start + bytes)
+ }
+
+ if (!copy) // a slice, we need something to copy in to
+ dst = new Buffer(len)
+
+ for (i = off[0]; i < this._bufs.length; i++) {
+ l = this._bufs[i].length - start
+
+ if (bytes > l) {
+ this._bufs[i].copy(dst, bufoff, start)
+ } else {
+ this._bufs[i].copy(dst, bufoff, start, start + bytes)
+ break
+ }
+
+ bufoff += l
+ bytes -= l
+
+ if (start)
+ start = 0
+ }
+
+ return dst
+}
+
+BufferList.prototype.toString = function (encoding, start, end) {
+ return this.slice(start, end).toString(encoding)
+}
+
+BufferList.prototype.consume = function (bytes) {
+ while (this._bufs.length) {
+ if (bytes > this._bufs[0].length) {
+ bytes -= this._bufs[0].length
+ this.length -= this._bufs[0].length
+ this._bufs.shift()
+ } else {
+ this._bufs[0] = this._bufs[0].slice(bytes)
+ this.length -= bytes
+ break
+ }
+ }
+ return this
+}
+
+BufferList.prototype.duplicate = function () {
+ var i = 0
+ , copy = new BufferList()
+
+ for (; i < this._bufs.length; i++)
+ copy.append(this._bufs[i])
+
+ return copy
+}
+
+BufferList.prototype.destroy = function () {
+ this._bufs.length = 0;
+ this.length = 0;
+ this.push(null);
+}
+
+;(function () {
+ var methods = {
+ 'readDoubleBE' : 8
+ , 'readDoubleLE' : 8
+ , 'readFloatBE' : 4
+ , 'readFloatLE' : 4
+ , 'readInt32BE' : 4
+ , 'readInt32LE' : 4
+ , 'readUInt32BE' : 4
+ , 'readUInt32LE' : 4
+ , 'readInt16BE' : 2
+ , 'readInt16LE' : 2
+ , 'readUInt16BE' : 2
+ , 'readUInt16LE' : 2
+ , 'readInt8' : 1
+ , 'readUInt8' : 1
+ }
+
+ for (var m in methods) {
+ (function (m) {
+ BufferList.prototype[m] = function (offset) {
+ return this.slice(offset, offset + methods[m])[m](0)
+ }
+ }(m))
+ }
+}())
+
+module.exports = BufferList
+
+}).call(this,require("buffer").Buffer)
+},{"buffer":20,"readable-stream":69,"util":32}],54:[function(require,module,exports){
+(function (process,Buffer){
+var util = require('util')
+ , AbstractLevelDOWN = require('abstract-leveldown').AbstractLevelDOWN
+
+function DeferredLevelDOWN (location) {
+ AbstractLevelDOWN.call(this, typeof location == 'string' ? location : '') // optional location, who cares?
+ this._db = undefined
+ this._operations = []
+}
+
+util.inherits(DeferredLevelDOWN, AbstractLevelDOWN)
+
+// called by LevelUP when we have a real DB to take its place
+DeferredLevelDOWN.prototype.setDb = function (db) {
+ this._db = db
+ this._operations.forEach(function (op) {
+ db[op.method].apply(db, op.args)
+ })
+}
+
+DeferredLevelDOWN.prototype._open = function (options, callback) {
+ return process.nextTick(callback)
+}
+
+// queue a new deferred operation
+DeferredLevelDOWN.prototype._operation = function (method, args) {
+ if (this._db)
+ return this._db[method].apply(this._db, args)
+ this._operations.push({ method: method, args: args })
+}
+
+// deferrables
+'put get del batch approximateSize'.split(' ').forEach(function (m) {
+ DeferredLevelDOWN.prototype['_' + m] = function () {
+ this._operation(m, arguments)
+ }
+})
+
+DeferredLevelDOWN.prototype._isBuffer = function (obj) {
+ return Buffer.isBuffer(obj)
+}
+
+// don't need to implement this as LevelUP's ReadStream checks for 'ready' state
+DeferredLevelDOWN.prototype._iterator = function () {
+ throw new TypeError('not implemented')
+}
+
+module.exports = DeferredLevelDOWN
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),require("buffer").Buffer)
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"abstract-leveldown":57,"buffer":20,"util":32}],55:[function(require,module,exports){
+(function (process){
+/* Copyright (c) 2013 Rod Vagg, MIT License */
+
+function AbstractChainedBatch (db) {
+ this._db = db
+ this._operations = []
+ this._written = false
+}
+
+AbstractChainedBatch.prototype._checkWritten = function () {
+ if (this._written)
+ throw new Error('write() already called on this batch')
+}
+
+AbstractChainedBatch.prototype.put = function (key, value) {
+ this._checkWritten()
+
+ var err = this._db._checkKeyValue(key, 'key', this._db._isBuffer)
+ if (err) throw err
+ err = this._db._checkKeyValue(value, 'value', this._db._isBuffer)
+ if (err) throw err
+
+ if (!this._db._isBuffer(key)) key = String(key)
+ if (!this._db._isBuffer(value)) value = String(value)
+
+ if (typeof this._put == 'function' )
+ this._put(key, value)
+ else
+ this._operations.push({ type: 'put', key: key, value: value })
+
+ return this
+}
+
+AbstractChainedBatch.prototype.del = function (key) {
+ this._checkWritten()
+
+ var err = this._db._checkKeyValue(key, 'key', this._db._isBuffer)
+ if (err) throw err
+
+ if (!this._db._isBuffer(key)) key = String(key)
+
+ if (typeof this._del == 'function' )
+ this._del(key)
+ else
+ this._operations.push({ type: 'del', key: key })
+
+ return this
+}
+
+AbstractChainedBatch.prototype.clear = function () {
+ this._checkWritten()
+
+ this._operations = []
+
+ if (typeof this._clear == 'function' )
+ this._clear()
+
+ return this
+}
+
+AbstractChainedBatch.prototype.write = function (options, callback) {
+ this._checkWritten()
+
+ if (typeof options == 'function')
+ callback = options
+ if (typeof callback != 'function')
+ throw new Error('write() requires a callback argument')
+ if (typeof options != 'object')
+ options = {}
+
+ this._written = true
+
+ if (typeof this._write == 'function' )
+ return this._write(callback)
+
+ if (typeof this._db._batch == 'function')
+ return this._db._batch(this._operations, options, callback)
+
+ process.nextTick(callback)
+}
+
+module.exports = AbstractChainedBatch
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],56:[function(require,module,exports){
+(function (process){
+/* Copyright (c) 2013 Rod Vagg, MIT License */
+
+function AbstractIterator (db) {
+ this.db = db
+ this._ended = false
+ this._nexting = false
+}
+
+AbstractIterator.prototype.next = function (callback) {
+ var self = this
+
+ if (typeof callback != 'function')
+ throw new Error('next() requires a callback argument')
+
+ if (self._ended)
+ return callback(new Error('cannot call next() after end()'))
+ if (self._nexting)
+ return callback(new Error('cannot call next() before previous next() has completed'))
+
+ self._nexting = true
+ if (typeof self._next == 'function') {
+ return self._next(function () {
+ self._nexting = false
+ callback.apply(null, arguments)
+ })
+ }
+
+ process.nextTick(function () {
+ self._nexting = false
+ callback()
+ })
+}
+
+AbstractIterator.prototype.end = function (callback) {
+ if (typeof callback != 'function')
+ throw new Error('end() requires a callback argument')
+
+ if (this._ended)
+ return callback(new Error('end() already called on iterator'))
+
+ this._ended = true
+
+ if (typeof this._end == 'function')
+ return this._end(callback)
+
+ process.nextTick(callback)
+}
+
+module.exports = AbstractIterator
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],57:[function(require,module,exports){
+(function (process,Buffer){
+/* Copyright (c) 2013 Rod Vagg, MIT License */
+
+var xtend = require('xtend')
+ , AbstractIterator = require('./abstract-iterator')
+ , AbstractChainedBatch = require('./abstract-chained-batch')
+
+function AbstractLevelDOWN (location) {
+ if (!arguments.length || location === undefined)
+ throw new Error('constructor requires at least a location argument')
+
+ if (typeof location != 'string')
+ throw new Error('constructor requires a location string argument')
+
+ this.location = location
+}
+
+AbstractLevelDOWN.prototype.open = function (options, callback) {
+ if (typeof options == 'function')
+ callback = options
+
+ if (typeof callback != 'function')
+ throw new Error('open() requires a callback argument')
+
+ if (typeof options != 'object')
+ options = {}
+
+ if (typeof this._open == 'function')
+ return this._open(options, callback)
+
+ process.nextTick(callback)
+}
+
+AbstractLevelDOWN.prototype.close = function (callback) {
+ if (typeof callback != 'function')
+ throw new Error('close() requires a callback argument')
+
+ if (typeof this._close == 'function')
+ return this._close(callback)
+
+ process.nextTick(callback)
+}
+
+AbstractLevelDOWN.prototype.get = function (key, options, callback) {
+ var err
+
+ if (typeof options == 'function')
+ callback = options
+
+ if (typeof callback != 'function')
+ throw new Error('get() requires a callback argument')
+
+ if (err = this._checkKeyValue(key, 'key', this._isBuffer))
+ return callback(err)
+
+ if (!this._isBuffer(key))
+ key = String(key)
+
+ if (typeof options != 'object')
+ options = {}
+
+ if (typeof this._get == 'function')
+ return this._get(key, options, callback)
+
+ process.nextTick(function () { callback(new Error('NotFound')) })
+}
+
+AbstractLevelDOWN.prototype.put = function (key, value, options, callback) {
+ var err
+
+ if (typeof options == 'function')
+ callback = options
+
+ if (typeof callback != 'function')
+ throw new Error('put() requires a callback argument')
+
+ if (err = this._checkKeyValue(key, 'key', this._isBuffer))
+ return callback(err)
+
+ if (err = this._checkKeyValue(value, 'value', this._isBuffer))
+ return callback(err)
+
+ if (!this._isBuffer(key))
+ key = String(key)
+
+ // coerce value to string in node, don't touch it in browser
+ // (indexeddb can store any JS type)
+ if (!this._isBuffer(value) && !process.browser)
+ value = String(value)
+
+ if (typeof options != 'object')
+ options = {}
+
+ if (typeof this._put == 'function')
+ return this._put(key, value, options, callback)
+
+ process.nextTick(callback)
+}
+
+AbstractLevelDOWN.prototype.del = function (key, options, callback) {
+ var err
+
+ if (typeof options == 'function')
+ callback = options
+
+ if (typeof callback != 'function')
+ throw new Error('del() requires a callback argument')
+
+ if (err = this._checkKeyValue(key, 'key', this._isBuffer))
+ return callback(err)
+
+ if (!this._isBuffer(key))
+ key = String(key)
+
+ if (typeof options != 'object')
+ options = {}
+
+ if (typeof this._del == 'function')
+ return this._del(key, options, callback)
+
+ process.nextTick(callback)
+}
+
+AbstractLevelDOWN.prototype.batch = function (array, options, callback) {
+ if (!arguments.length)
+ return this._chainedBatch()
+
+ if (typeof options == 'function')
+ callback = options
+
+ if (typeof callback != 'function')
+ throw new Error('batch(array) requires a callback argument')
+
+ if (!Array.isArray(array))
+ return callback(new Error('batch(array) requires an array argument'))
+
+ if (typeof options != 'object')
+ options = {}
+
+ var i = 0
+ , l = array.length
+ , e
+ , err
+
+ for (; i < l; i++) {
+ e = array[i]
+ if (typeof e != 'object')
+ continue
+
+ if (err = this._checkKeyValue(e.type, 'type', this._isBuffer))
+ return callback(err)
+
+ if (err = this._checkKeyValue(e.key, 'key', this._isBuffer))
+ return callback(err)
+
+ if (e.type == 'put') {
+ if (err = this._checkKeyValue(e.value, 'value', this._isBuffer))
+ return callback(err)
+ }
+ }
+
+ if (typeof this._batch == 'function')
+ return this._batch(array, options, callback)
+
+ process.nextTick(callback)
+}
+
+//TODO: remove from here, not a necessary primitive
+AbstractLevelDOWN.prototype.approximateSize = function (start, end, callback) {
+ if ( start == null
+ || end == null
+ || typeof start == 'function'
+ || typeof end == 'function') {
+ throw new Error('approximateSize() requires valid `start`, `end` and `callback` arguments')
+ }
+
+ if (typeof callback != 'function')
+ throw new Error('approximateSize() requires a callback argument')
+
+ if (!this._isBuffer(start))
+ start = String(start)
+
+ if (!this._isBuffer(end))
+ end = String(end)
+
+ if (typeof this._approximateSize == 'function')
+ return this._approximateSize(start, end, callback)
+
+ process.nextTick(function () {
+ callback(null, 0)
+ })
+}
+
+AbstractLevelDOWN.prototype._setupIteratorOptions = function (options) {
+ var self = this
+
+ options = xtend(options)
+
+ ;[ 'start', 'end', 'gt', 'gte', 'lt', 'lte' ].forEach(function (o) {
+ if (options[o] && self._isBuffer(options[o]) && options[o].length === 0)
+ delete options[o]
+ })
+
+ options.reverse = !!options.reverse
+
+ // fix `start` so it takes into account gt, gte, lt, lte as appropriate
+ if (options.reverse && options.lt)
+ options.start = options.lt
+ if (options.reverse && options.lte)
+ options.start = options.lte
+ if (!options.reverse && options.gt)
+ options.start = options.gt
+ if (!options.reverse && options.gte)
+ options.start = options.gte
+
+ if ((options.reverse && options.lt && !options.lte)
+ || (!options.reverse && options.gt && !options.gte))
+ options.exclusiveStart = true // start should *not* include matching key
+
+ return options
+}
+
+AbstractLevelDOWN.prototype.iterator = function (options) {
+ if (typeof options != 'object')
+ options = {}
+
+ options = this._setupIteratorOptions(options)
+
+ if (typeof this._iterator == 'function')
+ return this._iterator(options)
+
+ return new AbstractIterator(this)
+}
+
+AbstractLevelDOWN.prototype._chainedBatch = function () {
+ return new AbstractChainedBatch(this)
+}
+
+AbstractLevelDOWN.prototype._isBuffer = function (obj) {
+ return Buffer.isBuffer(obj)
+}
+
+AbstractLevelDOWN.prototype._checkKeyValue = function (obj, type) {
+ if (obj === null || obj === undefined)
+ return new Error(type + ' cannot be `null` or `undefined`')
+
+ if (obj === null || obj === undefined)
+ return new Error(type + ' cannot be `null` or `undefined`')
+
+ if (this._isBuffer(obj)) {
+ if (obj.length === 0)
+ return new Error(type + ' cannot be an empty Buffer')
+ } else if (String(obj) === '')
+ return new Error(type + ' cannot be an empty String')
+}
+
+module.exports.AbstractLevelDOWN = AbstractLevelDOWN
+module.exports.AbstractIterator = AbstractIterator
+module.exports.AbstractChainedBatch = AbstractChainedBatch
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),require("buffer").Buffer)
+},{"./abstract-chained-batch":55,"./abstract-iterator":56,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"xtend":70}],58:[function(require,module,exports){
+var prr = require('prr')
+
+function init (type, message, cause) {
+ prr(this, {
+ type : type
+ , name : type
+ // can be passed just a 'cause'
+ , cause : typeof message != 'string' ? message : cause
+ , message : !!message && typeof message != 'string' ? message.message : message
+
+ }, 'ewr')
+}
+
+// generic prototype, not intended to be actually used - helpful for `instanceof`
+function CustomError (message, cause) {
+ Error.call(this)
+ if (Error.captureStackTrace)
+ Error.captureStackTrace(this, arguments.callee)
+ init.call(this, 'CustomError', message, cause)
+}
+
+CustomError.prototype = new Error()
+
+function createError (errno, type, proto) {
+ var err = function (message, cause) {
+ init.call(this, type, message, cause)
+ //TODO: the specificity here is stupid, errno should be available everywhere
+ if (type == 'FilesystemError') {
+ this.code = this.cause.code
+ this.path = this.cause.path
+ this.errno = this.cause.errno
+ this.message =
+ (errno.errno[this.cause.errno]
+ ? errno.errno[this.cause.errno].description
+ : this.cause.message)
+ + (this.cause.path ? ' [' + this.cause.path + ']' : '')
+ }
+ Error.call(this)
+ if (Error.captureStackTrace)
+ Error.captureStackTrace(this, arguments.callee)
+ }
+ err.prototype = !!proto ? new proto() : new CustomError()
+ return err
+}
+
+module.exports = function (errno) {
+ var ce = function (type, proto) {
+ return createError(errno, type, proto)
+ }
+ return {
+ CustomError : CustomError
+ , FilesystemError : ce('FilesystemError')
+ , createError : ce
+ }
+}
+
+},{"prr":60}],59:[function(require,module,exports){
+var all = module.exports.all = [
+ {
+ "errno": -1,
+ "code": "UNKNOWN",
+ "description": "unknown error"
+ },
+ {
+ "errno": 0,
+ "code": "OK",
+ "description": "success"
+ },
+ {
+ "errno": 1,
+ "code": "EOF",
+ "description": "end of file"
+ },
+ {
+ "errno": 2,
+ "code": "EADDRINFO",
+ "description": "getaddrinfo error"
+ },
+ {
+ "errno": 3,
+ "code": "EACCES",
+ "description": "permission denied"
+ },
+ {
+ "errno": 4,
+ "code": "EAGAIN",
+ "description": "resource temporarily unavailable"
+ },
+ {
+ "errno": 5,
+ "code": "EADDRINUSE",
+ "description": "address already in use"
+ },
+ {
+ "errno": 6,
+ "code": "EADDRNOTAVAIL",
+ "description": "address not available"
+ },
+ {
+ "errno": 7,
+ "code": "EAFNOSUPPORT",
+ "description": "address family not supported"
+ },
+ {
+ "errno": 8,
+ "code": "EALREADY",
+ "description": "connection already in progress"
+ },
+ {
+ "errno": 9,
+ "code": "EBADF",
+ "description": "bad file descriptor"
+ },
+ {
+ "errno": 10,
+ "code": "EBUSY",
+ "description": "resource busy or locked"
+ },
+ {
+ "errno": 11,
+ "code": "ECONNABORTED",
+ "description": "software caused connection abort"
+ },
+ {
+ "errno": 12,
+ "code": "ECONNREFUSED",
+ "description": "connection refused"
+ },
+ {
+ "errno": 13,
+ "code": "ECONNRESET",
+ "description": "connection reset by peer"
+ },
+ {
+ "errno": 14,
+ "code": "EDESTADDRREQ",
+ "description": "destination address required"
+ },
+ {
+ "errno": 15,
+ "code": "EFAULT",
+ "description": "bad address in system call argument"
+ },
+ {
+ "errno": 16,
+ "code": "EHOSTUNREACH",
+ "description": "host is unreachable"
+ },
+ {
+ "errno": 17,
+ "code": "EINTR",
+ "description": "interrupted system call"
+ },
+ {
+ "errno": 18,
+ "code": "EINVAL",
+ "description": "invalid argument"
+ },
+ {
+ "errno": 19,
+ "code": "EISCONN",
+ "description": "socket is already connected"
+ },
+ {
+ "errno": 20,
+ "code": "EMFILE",
+ "description": "too many open files"
+ },
+ {
+ "errno": 21,
+ "code": "EMSGSIZE",
+ "description": "message too long"
+ },
+ {
+ "errno": 22,
+ "code": "ENETDOWN",
+ "description": "network is down"
+ },
+ {
+ "errno": 23,
+ "code": "ENETUNREACH",
+ "description": "network is unreachable"
+ },
+ {
+ "errno": 24,
+ "code": "ENFILE",
+ "description": "file table overflow"
+ },
+ {
+ "errno": 25,
+ "code": "ENOBUFS",
+ "description": "no buffer space available"
+ },
+ {
+ "errno": 26,
+ "code": "ENOMEM",
+ "description": "not enough memory"
+ },
+ {
+ "errno": 27,
+ "code": "ENOTDIR",
+ "description": "not a directory"
+ },
+ {
+ "errno": 28,
+ "code": "EISDIR",
+ "description": "illegal operation on a directory"
+ },
+ {
+ "errno": 29,
+ "code": "ENONET",
+ "description": "machine is not on the network"
+ },
+ {
+ "errno": 31,
+ "code": "ENOTCONN",
+ "description": "socket is not connected"
+ },
+ {
+ "errno": 32,
+ "code": "ENOTSOCK",
+ "description": "socket operation on non-socket"
+ },
+ {
+ "errno": 33,
+ "code": "ENOTSUP",
+ "description": "operation not supported on socket"
+ },
+ {
+ "errno": 34,
+ "code": "ENOENT",
+ "description": "no such file or directory"
+ },
+ {
+ "errno": 35,
+ "code": "ENOSYS",
+ "description": "function not implemented"
+ },
+ {
+ "errno": 36,
+ "code": "EPIPE",
+ "description": "broken pipe"
+ },
+ {
+ "errno": 37,
+ "code": "EPROTO",
+ "description": "protocol error"
+ },
+ {
+ "errno": 38,
+ "code": "EPROTONOSUPPORT",
+ "description": "protocol not supported"
+ },
+ {
+ "errno": 39,
+ "code": "EPROTOTYPE",
+ "description": "protocol wrong type for socket"
+ },
+ {
+ "errno": 40,
+ "code": "ETIMEDOUT",
+ "description": "connection timed out"
+ },
+ {
+ "errno": 41,
+ "code": "ECHARSET",
+ "description": "invalid Unicode character"
+ },
+ {
+ "errno": 42,
+ "code": "EAIFAMNOSUPPORT",
+ "description": "address family for hostname not supported"
+ },
+ {
+ "errno": 44,
+ "code": "EAISERVICE",
+ "description": "servname not supported for ai_socktype"
+ },
+ {
+ "errno": 45,
+ "code": "EAISOCKTYPE",
+ "description": "ai_socktype not supported"
+ },
+ {
+ "errno": 46,
+ "code": "ESHUTDOWN",
+ "description": "cannot send after transport endpoint shutdown"
+ },
+ {
+ "errno": 47,
+ "code": "EEXIST",
+ "description": "file already exists"
+ },
+ {
+ "errno": 48,
+ "code": "ESRCH",
+ "description": "no such process"
+ },
+ {
+ "errno": 49,
+ "code": "ENAMETOOLONG",
+ "description": "name too long"
+ },
+ {
+ "errno": 50,
+ "code": "EPERM",
+ "description": "operation not permitted"
+ },
+ {
+ "errno": 51,
+ "code": "ELOOP",
+ "description": "too many symbolic links encountered"
+ },
+ {
+ "errno": 52,
+ "code": "EXDEV",
+ "description": "cross-device link not permitted"
+ },
+ {
+ "errno": 53,
+ "code": "ENOTEMPTY",
+ "description": "directory not empty"
+ },
+ {
+ "errno": 54,
+ "code": "ENOSPC",
+ "description": "no space left on device"
+ },
+ {
+ "errno": 55,
+ "code": "EIO",
+ "description": "i/o error"
+ },
+ {
+ "errno": 56,
+ "code": "EROFS",
+ "description": "read-only file system"
+ },
+ {
+ "errno": 57,
+ "code": "ENODEV",
+ "description": "no such device"
+ },
+ {
+ "errno": 58,
+ "code": "ESPIPE",
+ "description": "invalid seek"
+ },
+ {
+ "errno": 59,
+ "code": "ECANCELED",
+ "description": "operation canceled"
+ }
+]
+
+
+module.exports.errno = {
+ '-1': all[0]
+ , '0': all[1]
+ , '1': all[2]
+ , '2': all[3]
+ , '3': all[4]
+ , '4': all[5]
+ , '5': all[6]
+ , '6': all[7]
+ , '7': all[8]
+ , '8': all[9]
+ , '9': all[10]
+ , '10': all[11]
+ , '11': all[12]
+ , '12': all[13]
+ , '13': all[14]
+ , '14': all[15]
+ , '15': all[16]
+ , '16': all[17]
+ , '17': all[18]
+ , '18': all[19]
+ , '19': all[20]
+ , '20': all[21]
+ , '21': all[22]
+ , '22': all[23]
+ , '23': all[24]
+ , '24': all[25]
+ , '25': all[26]
+ , '26': all[27]
+ , '27': all[28]
+ , '28': all[29]
+ , '29': all[30]
+ , '31': all[31]
+ , '32': all[32]
+ , '33': all[33]
+ , '34': all[34]
+ , '35': all[35]
+ , '36': all[36]
+ , '37': all[37]
+ , '38': all[38]
+ , '39': all[39]
+ , '40': all[40]
+ , '41': all[41]
+ , '42': all[42]
+ , '44': all[43]
+ , '45': all[44]
+ , '46': all[45]
+ , '47': all[46]
+ , '48': all[47]
+ , '49': all[48]
+ , '50': all[49]
+ , '51': all[50]
+ , '52': all[51]
+ , '53': all[52]
+ , '54': all[53]
+ , '55': all[54]
+ , '56': all[55]
+ , '57': all[56]
+ , '58': all[57]
+ , '59': all[58]
+}
+
+
+module.exports.code = {
+ 'UNKNOWN': all[0]
+ , 'OK': all[1]
+ , 'EOF': all[2]
+ , 'EADDRINFO': all[3]
+ , 'EACCES': all[4]
+ , 'EAGAIN': all[5]
+ , 'EADDRINUSE': all[6]
+ , 'EADDRNOTAVAIL': all[7]
+ , 'EAFNOSUPPORT': all[8]
+ , 'EALREADY': all[9]
+ , 'EBADF': all[10]
+ , 'EBUSY': all[11]
+ , 'ECONNABORTED': all[12]
+ , 'ECONNREFUSED': all[13]
+ , 'ECONNRESET': all[14]
+ , 'EDESTADDRREQ': all[15]
+ , 'EFAULT': all[16]
+ , 'EHOSTUNREACH': all[17]
+ , 'EINTR': all[18]
+ , 'EINVAL': all[19]
+ , 'EISCONN': all[20]
+ , 'EMFILE': all[21]
+ , 'EMSGSIZE': all[22]
+ , 'ENETDOWN': all[23]
+ , 'ENETUNREACH': all[24]
+ , 'ENFILE': all[25]
+ , 'ENOBUFS': all[26]
+ , 'ENOMEM': all[27]
+ , 'ENOTDIR': all[28]
+ , 'EISDIR': all[29]
+ , 'ENONET': all[30]
+ , 'ENOTCONN': all[31]
+ , 'ENOTSOCK': all[32]
+ , 'ENOTSUP': all[33]
+ , 'ENOENT': all[34]
+ , 'ENOSYS': all[35]
+ , 'EPIPE': all[36]
+ , 'EPROTO': all[37]
+ , 'EPROTONOSUPPORT': all[38]
+ , 'EPROTOTYPE': all[39]
+ , 'ETIMEDOUT': all[40]
+ , 'ECHARSET': all[41]
+ , 'EAIFAMNOSUPPORT': all[42]
+ , 'EAISERVICE': all[43]
+ , 'EAISOCKTYPE': all[44]
+ , 'ESHUTDOWN': all[45]
+ , 'EEXIST': all[46]
+ , 'ESRCH': all[47]
+ , 'ENAMETOOLONG': all[48]
+ , 'EPERM': all[49]
+ , 'ELOOP': all[50]
+ , 'EXDEV': all[51]
+ , 'ENOTEMPTY': all[52]
+ , 'ENOSPC': all[53]
+ , 'EIO': all[54]
+ , 'EROFS': all[55]
+ , 'ENODEV': all[56]
+ , 'ESPIPE': all[57]
+ , 'ECANCELED': all[58]
+}
+
+
+module.exports.custom = require("./custom")(module.exports)
+module.exports.create = module.exports.custom.createError
+},{"./custom":58}],60:[function(require,module,exports){
+/*!
+ * prr
+ * (c) 2013 Rod Vagg <rod@vagg.org>
+ * https://github.com/rvagg/prr
+ * License: MIT
+ */
+
+(function (name, context, definition) {
+ if (typeof module != 'undefined' && module.exports)
+ module.exports = definition()
+ else
+ context[name] = definition()
+})('prr', this, function() {
+
+ var setProperty = typeof Object.defineProperty == 'function'
+ ? function (obj, key, options) {
+ Object.defineProperty(obj, key, options)
+ return obj
+ }
+ : function (obj, key, options) { // < es5
+ obj[key] = options.value
+ return obj
+ }
+
+ , makeOptions = function (value, options) {
+ var oo = typeof options == 'object'
+ , os = !oo && typeof options == 'string'
+ , op = function (p) {
+ return oo
+ ? !!options[p]
+ : os
+ ? options.indexOf(p[0]) > -1
+ : false
+ }
+
+ return {
+ enumerable : op('enumerable')
+ , configurable : op('configurable')
+ , writable : op('writable')
+ , value : value
+ }
+ }
+
+ , prr = function (obj, key, value, options) {
+ var k
+
+ options = makeOptions(value, options)
+
+ if (typeof key == 'object') {
+ for (k in key) {
+ if (Object.hasOwnProperty.call(key, k)) {
+ options.value = key[k]
+ setProperty(obj, k, options)
+ }
+ }
+ return obj
+ }
+
+ return setProperty(obj, key, options)
+ }
+
+ return prr
+})
+},{}],61:[function(require,module,exports){
+(function (process){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototypal inheritance, this class
+// prototypally inherits from Readable, and then parasitically from
+// Writable.
+
+module.exports = Duplex;
+
+/*<replacement>*/
+var objectKeys = Object.keys || function (obj) {
+ var keys = [];
+ for (var key in obj) keys.push(key);
+ return keys;
+}
+/*</replacement>*/
+
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+var Readable = require('./_stream_readable');
+var Writable = require('./_stream_writable');
+
+util.inherits(Duplex, Readable);
+
+forEach(objectKeys(Writable.prototype), function(method) {
+ if (!Duplex.prototype[method])
+ Duplex.prototype[method] = Writable.prototype[method];
+});
+
+function Duplex(options) {
+ if (!(this instanceof Duplex))
+ return new Duplex(options);
+
+ Readable.call(this, options);
+ Writable.call(this, options);
+
+ if (options && options.readable === false)
+ this.readable = false;
+
+ if (options && options.writable === false)
+ this.writable = false;
+
+ this.allowHalfOpen = true;
+ if (options && options.allowHalfOpen === false)
+ this.allowHalfOpen = false;
+
+ this.once('end', onend);
+}
+
+// the no-half-open enforcer
+function onend() {
+ // if we allow half-open state, or if the writable side ended,
+ // then we're ok.
+ if (this.allowHalfOpen || this._writableState.ended)
+ return;
+
+ // no more data can be written.
+ // But allow more writes to happen in this tick.
+ process.nextTick(this.end.bind(this));
+}
+
+function forEach (xs, f) {
+ for (var i = 0, l = xs.length; i < l; i++) {
+ f(xs[i], i);
+ }
+}
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"./_stream_readable":63,"./_stream_writable":65,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"core-util-is":66,"inherits":33}],62:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+
+module.exports = PassThrough;
+
+var Transform = require('./_stream_transform');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(PassThrough, Transform);
+
+function PassThrough(options) {
+ if (!(this instanceof PassThrough))
+ return new PassThrough(options);
+
+ Transform.call(this, options);
+}
+
+PassThrough.prototype._transform = function(chunk, encoding, cb) {
+ cb(null, chunk);
+};
+
+},{"./_stream_transform":64,"core-util-is":66,"inherits":33}],63:[function(require,module,exports){
+(function (process){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module.exports = Readable;
+
+/*<replacement>*/
+var isArray = require('isarray');
+/*</replacement>*/
+
+
+/*<replacement>*/
+var Buffer = require('buffer').Buffer;
+/*</replacement>*/
+
+Readable.ReadableState = ReadableState;
+
+var EE = require('events').EventEmitter;
+
+/*<replacement>*/
+if (!EE.listenerCount) EE.listenerCount = function(emitter, type) {
+ return emitter.listeners(type).length;
+};
+/*</replacement>*/
+
+var Stream = require('stream');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+var StringDecoder;
+
+util.inherits(Readable, Stream);
+
+function ReadableState(options, stream) {
+ options = options || {};
+
+ // the point at which it stops calling _read() to fill the buffer
+ // Note: 0 is a valid value, means "don't call _read preemptively ever"
+ var hwm = options.highWaterMark;
+ this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
+
+ // cast to ints.
+ this.highWaterMark = ~~this.highWaterMark;
+
+ this.buffer = [];
+ this.length = 0;
+ this.pipes = null;
+ this.pipesCount = 0;
+ this.flowing = false;
+ this.ended = false;
+ this.endEmitted = false;
+ this.reading = false;
+
+ // In streams that never have any data, and do push(null) right away,
+ // the consumer can miss the 'end' event if they do some I/O before
+ // consuming the stream. So, we don't emit('end') until some reading
+ // happens.
+ this.calledRead = false;
+
+ // a flag to be able to tell if the onwrite cb is called immediately,
+ // or on a later tick. We set this to true at first, becuase any
+ // actions that shouldn't happen until "later" should generally also
+ // not happen before the first write call.
+ this.sync = true;
+
+ // whenever we return null, then we set a flag to say
+ // that we're awaiting a 'readable' event emission.
+ this.needReadable = false;
+ this.emittedReadable = false;
+ this.readableListening = false;
+
+
+ // object stream flag. Used to make read(n) ignore n and to
+ // make all the buffer merging and length checks go away
+ this.objectMode = !!options.objectMode;
+
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+ // when piping, we only care about 'readable' events that happen
+ // after read()ing all the bytes and not getting any pushback.
+ this.ranOut = false;
+
+ // the number of writers that are awaiting a drain event in .pipe()s
+ this.awaitDrain = 0;
+
+ // if true, a maybeReadMore has been scheduled
+ this.readingMore = false;
+
+ this.decoder = null;
+ this.encoding = null;
+ if (options.encoding) {
+ if (!StringDecoder)
+ StringDecoder = require('string_decoder/').StringDecoder;
+ this.decoder = new StringDecoder(options.encoding);
+ this.encoding = options.encoding;
+ }
+}
+
+function Readable(options) {
+ if (!(this instanceof Readable))
+ return new Readable(options);
+
+ this._readableState = new ReadableState(options, this);
+
+ // legacy
+ this.readable = true;
+
+ Stream.call(this);
+}
+
+// Manually shove something into the read() buffer.
+// This returns true if the highWaterMark has not been hit yet,
+// similar to how Writable.write() returns true if you should
+// write() some more.
+Readable.prototype.push = function(chunk, encoding) {
+ var state = this._readableState;
+
+ if (typeof chunk === 'string' && !state.objectMode) {
+ encoding = encoding || state.defaultEncoding;
+ if (encoding !== state.encoding) {
+ chunk = new Buffer(chunk, encoding);
+ encoding = '';
+ }
+ }
+
+ return readableAddChunk(this, state, chunk, encoding, false);
+};
+
+// Unshift should *always* be something directly out of read()
+Readable.prototype.unshift = function(chunk) {
+ var state = this._readableState;
+ return readableAddChunk(this, state, chunk, '', true);
+};
+
+function readableAddChunk(stream, state, chunk, encoding, addToFront) {
+ var er = chunkInvalid(state, chunk);
+ if (er) {
+ stream.emit('error', er);
+ } else if (chunk === null || chunk === undefined) {
+ state.reading = false;
+ if (!state.ended)
+ onEofChunk(stream, state);
+ } else if (state.objectMode || chunk && chunk.length > 0) {
+ if (state.ended && !addToFront) {
+ var e = new Error('stream.push() after EOF');
+ stream.emit('error', e);
+ } else if (state.endEmitted && addToFront) {
+ var e = new Error('stream.unshift() after end event');
+ stream.emit('error', e);
+ } else {
+ if (state.decoder && !addToFront && !encoding)
+ chunk = state.decoder.write(chunk);
+
+ // update the buffer info.
+ state.length += state.objectMode ? 1 : chunk.length;
+ if (addToFront) {
+ state.buffer.unshift(chunk);
+ } else {
+ state.reading = false;
+ state.buffer.push(chunk);
+ }
+
+ if (state.needReadable)
+ emitReadable(stream);
+
+ maybeReadMore(stream, state);
+ }
+ } else if (!addToFront) {
+ state.reading = false;
+ }
+
+ return needMoreData(state);
+}
+
+
+
+// if it's past the high water mark, we can push in some more.
+// Also, if we have no data yet, we can stand some
+// more bytes. This is to work around cases where hwm=0,
+// such as the repl. Also, if the push() triggered a
+// readable event, and the user called read(largeNumber) such that
+// needReadable was set, then we ought to push more, so that another
+// 'readable' event will be triggered.
+function needMoreData(state) {
+ return !state.ended &&
+ (state.needReadable ||
+ state.length < state.highWaterMark ||
+ state.length === 0);
+}
+
+// backwards compatibility.
+Readable.prototype.setEncoding = function(enc) {
+ if (!StringDecoder)
+ StringDecoder = require('string_decoder/').StringDecoder;
+ this._readableState.decoder = new StringDecoder(enc);
+ this._readableState.encoding = enc;
+};
+
+// Don't raise the hwm > 128MB
+var MAX_HWM = 0x800000;
+function roundUpToNextPowerOf2(n) {
+ if (n >= MAX_HWM) {
+ n = MAX_HWM;
+ } else {
+ // Get the next highest power of 2
+ n--;
+ for (var p = 1; p < 32; p <<= 1) n |= n >> p;
+ n++;
+ }
+ return n;
+}
+
+function howMuchToRead(n, state) {
+ if (state.length === 0 && state.ended)
+ return 0;
+
+ if (state.objectMode)
+ return n === 0 ? 0 : 1;
+
+ if (isNaN(n) || n === null) {
+ // only flow one buffer at a time
+ if (state.flowing && state.buffer.length)
+ return state.buffer[0].length;
+ else
+ return state.length;
+ }
+
+ if (n <= 0)
+ return 0;
+
+ // If we're asking for more than the target buffer level,
+ // then raise the water mark. Bump up to the next highest
+ // power of 2, to prevent increasing it excessively in tiny
+ // amounts.
+ if (n > state.highWaterMark)
+ state.highWaterMark = roundUpToNextPowerOf2(n);
+
+ // don't have that much. return null, unless we've ended.
+ if (n > state.length) {
+ if (!state.ended) {
+ state.needReadable = true;
+ return 0;
+ } else
+ return state.length;
+ }
+
+ return n;
+}
+
+// you can override either this method, or the async _read(n) below.
+Readable.prototype.read = function(n) {
+ var state = this._readableState;
+ state.calledRead = true;
+ var nOrig = n;
+
+ if (typeof n !== 'number' || n > 0)
+ state.emittedReadable = false;
+
+ // if we're doing read(0) to trigger a readable event, but we
+ // already have a bunch of data in the buffer, then just trigger
+ // the 'readable' event and move on.
+ if (n === 0 &&
+ state.needReadable &&
+ (state.length >= state.highWaterMark || state.ended)) {
+ emitReadable(this);
+ return null;
+ }
+
+ n = howMuchToRead(n, state);
+
+ // if we've ended, and we're now clear, then finish it up.
+ if (n === 0 && state.ended) {
+ if (state.length === 0)
+ endReadable(this);
+ return null;
+ }
+
+ // All the actual chunk generation logic needs to be
+ // *below* the call to _read. The reason is that in certain
+ // synthetic stream cases, such as passthrough streams, _read
+ // may be a completely synchronous operation which may change
+ // the state of the read buffer, providing enough data when
+ // before there was *not* enough.
+ //
+ // So, the steps are:
+ // 1. Figure out what the state of things will be after we do
+ // a read from the buffer.
+ //
+ // 2. If that resulting state will trigger a _read, then call _read.
+ // Note that this may be asynchronous, or synchronous. Yes, it is
+ // deeply ugly to write APIs this way, but that still doesn't mean
+ // that the Readable class should behave improperly, as streams are
+ // designed to be sync/async agnostic.
+ // Take note if the _read call is sync or async (ie, if the read call
+ // has returned yet), so that we know whether or not it's safe to emit
+ // 'readable' etc.
+ //
+ // 3. Actually pull the requested chunks out of the buffer and return.
+
+ // if we need a readable event, then we need to do some reading.
+ var doRead = state.needReadable;
+
+ // if we currently have less than the highWaterMark, then also read some
+ if (state.length - n <= state.highWaterMark)
+ doRead = true;
+
+ // however, if we've ended, then there's no point, and if we're already
+ // reading, then it's unnecessary.
+ if (state.ended || state.reading)
+ doRead = false;
+
+ if (doRead) {
+ state.reading = true;
+ state.sync = true;
+ // if the length is currently zero, then we *need* a readable event.
+ if (state.length === 0)
+ state.needReadable = true;
+ // call internal read method
+ this._read(state.highWaterMark);
+ state.sync = false;
+ }
+
+ // If _read called its callback synchronously, then `reading`
+ // will be false, and we need to re-evaluate how much data we
+ // can return to the user.
+ if (doRead && !state.reading)
+ n = howMuchToRead(nOrig, state);
+
+ var ret;
+ if (n > 0)
+ ret = fromList(n, state);
+ else
+ ret = null;
+
+ if (ret === null) {
+ state.needReadable = true;
+ n = 0;
+ }
+
+ state.length -= n;
+
+ // If we have nothing in the buffer, then we want to know
+ // as soon as we *do* get something into the buffer.
+ if (state.length === 0 && !state.ended)
+ state.needReadable = true;
+
+ // If we happened to read() exactly the remaining amount in the
+ // buffer, and the EOF has been seen at this point, then make sure
+ // that we emit 'end' on the very next tick.
+ if (state.ended && !state.endEmitted && state.length === 0)
+ endReadable(this);
+
+ return ret;
+};
+
+function chunkInvalid(state, chunk) {
+ var er = null;
+ if (!Buffer.isBuffer(chunk) &&
+ 'string' !== typeof chunk &&
+ chunk !== null &&
+ chunk !== undefined &&
+ !state.objectMode &&
+ !er) {
+ er = new TypeError('Invalid non-string/buffer chunk');
+ }
+ return er;
+}
+
+
+function onEofChunk(stream, state) {
+ if (state.decoder && !state.ended) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length) {
+ state.buffer.push(chunk);
+ state.length += state.objectMode ? 1 : chunk.length;
+ }
+ }
+ state.ended = true;
+
+ // if we've ended and we have some data left, then emit
+ // 'readable' now to make sure it gets picked up.
+ if (state.length > 0)
+ emitReadable(stream);
+ else
+ endReadable(stream);
+}
+
+// Don't emit readable right away in sync mode, because this can trigger
+// another read() call => stack overflow. This way, it might trigger
+// a nextTick recursion warning, but that's not so bad.
+function emitReadable(stream) {
+ var state = stream._readableState;
+ state.needReadable = false;
+ if (state.emittedReadable)
+ return;
+
+ state.emittedReadable = true;
+ if (state.sync)
+ process.nextTick(function() {
+ emitReadable_(stream);
+ });
+ else
+ emitReadable_(stream);
+}
+
+function emitReadable_(stream) {
+ stream.emit('readable');
+}
+
+
+// at this point, the user has presumably seen the 'readable' event,
+// and called read() to consume some data. that may have triggered
+// in turn another _read(n) call, in which case reading = true if
+// it's in progress.
+// However, if we're not ended, or reading, and the length < hwm,
+// then go ahead and try to read some more preemptively.
+function maybeReadMore(stream, state) {
+ if (!state.readingMore) {
+ state.readingMore = true;
+ process.nextTick(function() {
+ maybeReadMore_(stream, state);
+ });
+ }
+}
+
+function maybeReadMore_(stream, state) {
+ var len = state.length;
+ while (!state.reading && !state.flowing && !state.ended &&
+ state.length < state.highWaterMark) {
+ stream.read(0);
+ if (len === state.length)
+ // didn't get any data, stop spinning.
+ break;
+ else
+ len = state.length;
+ }
+ state.readingMore = false;
+}
+
+// abstract method. to be overridden in specific implementation classes.
+// call cb(er, data) where data is <= n in length.
+// for virtual (non-string, non-buffer) streams, "length" is somewhat
+// arbitrary, and perhaps not very meaningful.
+Readable.prototype._read = function(n) {
+ this.emit('error', new Error('not implemented'));
+};
+
+Readable.prototype.pipe = function(dest, pipeOpts) {
+ var src = this;
+ var state = this._readableState;
+
+ switch (state.pipesCount) {
+ case 0:
+ state.pipes = dest;
+ break;
+ case 1:
+ state.pipes = [state.pipes, dest];
+ break;
+ default:
+ state.pipes.push(dest);
+ break;
+ }
+ state.pipesCount += 1;
+
+ var doEnd = (!pipeOpts || pipeOpts.end !== false) &&
+ dest !== process.stdout &&
+ dest !== process.stderr;
+
+ var endFn = doEnd ? onend : cleanup;
+ if (state.endEmitted)
+ process.nextTick(endFn);
+ else
+ src.once('end', endFn);
+
+ dest.on('unpipe', onunpipe);
+ function onunpipe(readable) {
+ if (readable !== src) return;
+ cleanup();
+ }
+
+ function onend() {
+ dest.end();
+ }
+
+ // when the dest drains, it reduces the awaitDrain counter
+ // on the source. This would be more elegant with a .once()
+ // handler in flow(), but adding and removing repeatedly is
+ // too slow.
+ var ondrain = pipeOnDrain(src);
+ dest.on('drain', ondrain);
+
+ function cleanup() {
+ // cleanup event handlers once the pipe is broken
+ dest.removeListener('close', onclose);
+ dest.removeListener('finish', onfinish);
+ dest.removeListener('drain', ondrain);
+ dest.removeListener('error', onerror);
+ dest.removeListener('unpipe', onunpipe);
+ src.removeListener('end', onend);
+ src.removeListener('end', cleanup);
+
+ // if the reader is waiting for a drain event from this
+ // specific writer, then it would cause it to never start
+ // flowing again.
+ // So, if this is awaiting a drain, then we just call it now.
+ // If we don't know, then assume that we are waiting for one.
+ if (!dest._writableState || dest._writableState.needDrain)
+ ondrain();
+ }
+
+ // if the dest has an error, then stop piping into it.
+ // however, don't suppress the throwing behavior for this.
+ function onerror(er) {
+ unpipe();
+ dest.removeListener('error', onerror);
+ if (EE.listenerCount(dest, 'error') === 0)
+ dest.emit('error', er);
+ }
+ // This is a brutally ugly hack to make sure that our error handler
+ // is attached before any userland ones. NEVER DO THIS.
+ if (!dest._events || !dest._events.error)
+ dest.on('error', onerror);
+ else if (isArray(dest._events.error))
+ dest._events.error.unshift(onerror);
+ else
+ dest._events.error = [onerror, dest._events.error];
+
+
+
+ // Both close and finish should trigger unpipe, but only once.
+ function onclose() {
+ dest.removeListener('finish', onfinish);
+ unpipe();
+ }
+ dest.once('close', onclose);
+ function onfinish() {
+ dest.removeListener('close', onclose);
+ unpipe();
+ }
+ dest.once('finish', onfinish);
+
+ function unpipe() {
+ src.unpipe(dest);
+ }
+
+ // tell the dest that it's being piped to
+ dest.emit('pipe', src);
+
+ // start the flow if it hasn't been started already.
+ if (!state.flowing) {
+ // the handler that waits for readable events after all
+ // the data gets sucked out in flow.
+ // This would be easier to follow with a .once() handler
+ // in flow(), but that is too slow.
+ this.on('readable', pipeOnReadable);
+
+ state.flowing = true;
+ process.nextTick(function() {
+ flow(src);
+ });
+ }
+
+ return dest;
+};
+
+function pipeOnDrain(src) {
+ return function() {
+ var dest = this;
+ var state = src._readableState;
+ state.awaitDrain--;
+ if (state.awaitDrain === 0)
+ flow(src);
+ };
+}
+
+function flow(src) {
+ var state = src._readableState;
+ var chunk;
+ state.awaitDrain = 0;
+
+ function write(dest, i, list) {
+ var written = dest.write(chunk);
+ if (false === written) {
+ state.awaitDrain++;
+ }
+ }
+
+ while (state.pipesCount && null !== (chunk = src.read())) {
+
+ if (state.pipesCount === 1)
+ write(state.pipes, 0, null);
+ else
+ forEach(state.pipes, write);
+
+ src.emit('data', chunk);
+
+ // if anyone needs a drain, then we have to wait for that.
+ if (state.awaitDrain > 0)
+ return;
+ }
+
+ // if every destination was unpiped, either before entering this
+ // function, or in the while loop, then stop flowing.
+ //
+ // NB: This is a pretty rare edge case.
+ if (state.pipesCount === 0) {
+ state.flowing = false;
+
+ // if there were data event listeners added, then switch to old mode.
+ if (EE.listenerCount(src, 'data') > 0)
+ emitDataEvents(src);
+ return;
+ }
+
+ // at this point, no one needed a drain, so we just ran out of data
+ // on the next readable event, start it over again.
+ state.ranOut = true;
+}
+
+function pipeOnReadable() {
+ if (this._readableState.ranOut) {
+ this._readableState.ranOut = false;
+ flow(this);
+ }
+}
+
+
+Readable.prototype.unpipe = function(dest) {
+ var state = this._readableState;
+
+ // if we're not piping anywhere, then do nothing.
+ if (state.pipesCount === 0)
+ return this;
+
+ // just one destination. most common case.
+ if (state.pipesCount === 1) {
+ // passed in one, but it's not the right one.
+ if (dest && dest !== state.pipes)
+ return this;
+
+ if (!dest)
+ dest = state.pipes;
+
+ // got a match.
+ state.pipes = null;
+ state.pipesCount = 0;
+ this.removeListener('readable', pipeOnReadable);
+ state.flowing = false;
+ if (dest)
+ dest.emit('unpipe', this);
+ return this;
+ }
+
+ // slow case. multiple pipe destinations.
+
+ if (!dest) {
+ // remove all.
+ var dests = state.pipes;
+ var len = state.pipesCount;
+ state.pipes = null;
+ state.pipesCount = 0;
+ this.removeListener('readable', pipeOnReadable);
+ state.flowing = false;
+
+ for (var i = 0; i < len; i++)
+ dests[i].emit('unpipe', this);
+ return this;
+ }
+
+ // try to find the right one.
+ var i = indexOf(state.pipes, dest);
+ if (i === -1)
+ return this;
+
+ state.pipes.splice(i, 1);
+ state.pipesCount -= 1;
+ if (state.pipesCount === 1)
+ state.pipes = state.pipes[0];
+
+ dest.emit('unpipe', this);
+
+ return this;
+};
+
+// set up data events if they are asked for
+// Ensure readable listeners eventually get something
+Readable.prototype.on = function(ev, fn) {
+ var res = Stream.prototype.on.call(this, ev, fn);
+
+ if (ev === 'data' && !this._readableState.flowing)
+ emitDataEvents(this);
+
+ if (ev === 'readable' && this.readable) {
+ var state = this._readableState;
+ if (!state.readableListening) {
+ state.readableListening = true;
+ state.emittedReadable = false;
+ state.needReadable = true;
+ if (!state.reading) {
+ this.read(0);
+ } else if (state.length) {
+ emitReadable(this, state);
+ }
+ }
+ }
+
+ return res;
+};
+Readable.prototype.addListener = Readable.prototype.on;
+
+// pause() and resume() are remnants of the legacy readable stream API
+// If the user uses them, then switch into old mode.
+Readable.prototype.resume = function() {
+ emitDataEvents(this);
+ this.read(0);
+ this.emit('resume');
+};
+
+Readable.prototype.pause = function() {
+ emitDataEvents(this, true);
+ this.emit('pause');
+};
+
+function emitDataEvents(stream, startPaused) {
+ var state = stream._readableState;
+
+ if (state.flowing) {
+ // https://github.com/isaacs/readable-stream/issues/16
+ throw new Error('Cannot switch to old mode now.');
+ }
+
+ var paused = startPaused || false;
+ var readable = false;
+
+ // convert to an old-style stream.
+ stream.readable = true;
+ stream.pipe = Stream.prototype.pipe;
+ stream.on = stream.addListener = Stream.prototype.on;
+
+ stream.on('readable', function() {
+ readable = true;
+
+ var c;
+ while (!paused && (null !== (c = stream.read())))
+ stream.emit('data', c);
+
+ if (c === null) {
+ readable = false;
+ stream._readableState.needReadable = true;
+ }
+ });
+
+ stream.pause = function() {
+ paused = true;
+ this.emit('pause');
+ };
+
+ stream.resume = function() {
+ paused = false;
+ if (readable)
+ process.nextTick(function() {
+ stream.emit('readable');
+ });
+ else
+ this.read(0);
+ this.emit('resume');
+ };
+
+ // now make it start, just in case it hadn't already.
+ stream.emit('readable');
+}
+
+// wrap an old-style stream as the async data source.
+// This is *not* part of the readable stream interface.
+// It is an ugly unfortunate mess of history.
+Readable.prototype.wrap = function(stream) {
+ var state = this._readableState;
+ var paused = false;
+
+ var self = this;
+ stream.on('end', function() {
+ if (state.decoder && !state.ended) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length)
+ self.push(chunk);
+ }
+
+ self.push(null);
+ });
+
+ stream.on('data', function(chunk) {
+ if (state.decoder)
+ chunk = state.decoder.write(chunk);
+ if (!chunk || !state.objectMode && !chunk.length)
+ return;
+
+ var ret = self.push(chunk);
+ if (!ret) {
+ paused = true;
+ stream.pause();
+ }
+ });
+
+ // proxy all the other methods.
+ // important when wrapping filters and duplexes.
+ for (var i in stream) {
+ if (typeof stream[i] === 'function' &&
+ typeof this[i] === 'undefined') {
+ this[i] = function(method) { return function() {
+ return stream[method].apply(stream, arguments);
+ }}(i);
+ }
+ }
+
+ // proxy certain important events.
+ var events = ['error', 'close', 'destroy', 'pause', 'resume'];
+ forEach(events, function(ev) {
+ stream.on(ev, self.emit.bind(self, ev));
+ });
+
+ // when we try to consume some more bytes, simply unpause the
+ // underlying stream.
+ self._read = function(n) {
+ if (paused) {
+ paused = false;
+ stream.resume();
+ }
+ };
+
+ return self;
+};
+
+
+
+// exposed for testing purposes only.
+Readable._fromList = fromList;
+
+// Pluck off n bytes from an array of buffers.
+// Length is the combined lengths of all the buffers in the list.
+function fromList(n, state) {
+ var list = state.buffer;
+ var length = state.length;
+ var stringMode = !!state.decoder;
+ var objectMode = !!state.objectMode;
+ var ret;
+
+ // nothing in the list, definitely empty.
+ if (list.length === 0)
+ return null;
+
+ if (length === 0)
+ ret = null;
+ else if (objectMode)
+ ret = list.shift();
+ else if (!n || n >= length) {
+ // read it all, truncate the array.
+ if (stringMode)
+ ret = list.join('');
+ else
+ ret = Buffer.concat(list, length);
+ list.length = 0;
+ } else {
+ // read just some of it.
+ if (n < list[0].length) {
+ // just take a part of the first list item.
+ // slice is the same for buffers and strings.
+ var buf = list[0];
+ ret = buf.slice(0, n);
+ list[0] = buf.slice(n);
+ } else if (n === list[0].length) {
+ // first list is a perfect match
+ ret = list.shift();
+ } else {
+ // complex case.
+ // we have enough to cover it, but it spans past the first buffer.
+ if (stringMode)
+ ret = '';
+ else
+ ret = new Buffer(n);
+
+ var c = 0;
+ for (var i = 0, l = list.length; i < l && c < n; i++) {
+ var buf = list[0];
+ var cpy = Math.min(n - c, buf.length);
+
+ if (stringMode)
+ ret += buf.slice(0, cpy);
+ else
+ buf.copy(ret, c, 0, cpy);
+
+ if (cpy < buf.length)
+ list[0] = buf.slice(cpy);
+ else
+ list.shift();
+
+ c += cpy;
+ }
+ }
+ }
+
+ return ret;
+}
+
+function endReadable(stream) {
+ var state = stream._readableState;
+
+ // If we get here before consuming all the bytes, then that is a
+ // bug in node. Should never happen.
+ if (state.length > 0)
+ throw new Error('endReadable called on non-empty stream');
+
+ if (!state.endEmitted && state.calledRead) {
+ state.ended = true;
+ process.nextTick(function() {
+ // Check that we didn't get one last unshift.
+ if (!state.endEmitted && state.length === 0) {
+ state.endEmitted = true;
+ stream.readable = false;
+ stream.emit('end');
+ }
+ });
+ }
+}
+
+function forEach (xs, f) {
+ for (var i = 0, l = xs.length; i < l; i++) {
+ f(xs[i], i);
+ }
+}
+
+function indexOf (xs, x) {
+ for (var i = 0, l = xs.length; i < l; i++) {
+ if (xs[i] === x) return i;
+ }
+ return -1;
+}
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"core-util-is":66,"events":18,"inherits":33,"isarray":67,"stream":24,"string_decoder/":68}],64:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+// a transform stream is a readable/writable stream where you do
+// something with the data. Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored. (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation. For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes. When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up. When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer. When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks. If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk. However,
+// a pathological inflate type of transform can cause excessive buffering
+// here. For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output. In this case, you could write a very small
+// amount of input, and end up with a very large amount of output. In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform. A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
+
+module.exports = Transform;
+
+var Duplex = require('./_stream_duplex');
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+util.inherits(Transform, Duplex);
+
+
+function TransformState(options, stream) {
+ this.afterTransform = function(er, data) {
+ return afterTransform(stream, er, data);
+ };
+
+ this.needTransform = false;
+ this.transforming = false;
+ this.writecb = null;
+ this.writechunk = null;
+}
+
+function afterTransform(stream, er, data) {
+ var ts = stream._transformState;
+ ts.transforming = false;
+
+ var cb = ts.writecb;
+
+ if (!cb)
+ return stream.emit('error', new Error('no writecb in Transform class'));
+
+ ts.writechunk = null;
+ ts.writecb = null;
+
+ if (data !== null && data !== undefined)
+ stream.push(data);
+
+ if (cb)
+ cb(er);
+
+ var rs = stream._readableState;
+ rs.reading = false;
+ if (rs.needReadable || rs.length < rs.highWaterMark) {
+ stream._read(rs.highWaterMark);
+ }
+}
+
+
+function Transform(options) {
+ if (!(this instanceof Transform))
+ return new Transform(options);
+
+ Duplex.call(this, options);
+
+ var ts = this._transformState = new TransformState(options, this);
+
+ // when the writable side finishes, then flush out anything remaining.
+ var stream = this;
+
+ // start out asking for a readable event once data is transformed.
+ this._readableState.needReadable = true;
+
+ // we have implemented the _read method, and done the other things
+ // that Readable wants before the first _read call, so unset the
+ // sync guard flag.
+ this._readableState.sync = false;
+
+ this.once('finish', function() {
+ if ('function' === typeof this._flush)
+ this._flush(function(er) {
+ done(stream, er);
+ });
+ else
+ done(stream);
+ });
+}
+
+Transform.prototype.push = function(chunk, encoding) {
+ this._transformState.needTransform = false;
+ return Duplex.prototype.push.call(this, chunk, encoding);
+};
+
+// This is the part where you do stuff!
+// override this function in implementation classes.
+// 'chunk' is an input chunk.
+//
+// Call `push(newChunk)` to pass along transformed output
+// to the readable side. You may call 'push' zero or more times.
+//
+// Call `cb(err)` when you are done with this chunk. If you pass
+// an error, then that'll put the hurt on the whole operation. If you
+// never call cb(), then you'll never get another chunk.
+Transform.prototype._transform = function(chunk, encoding, cb) {
+ throw new Error('not implemented');
+};
+
+Transform.prototype._write = function(chunk, encoding, cb) {
+ var ts = this._transformState;
+ ts.writecb = cb;
+ ts.writechunk = chunk;
+ ts.writeencoding = encoding;
+ if (!ts.transforming) {
+ var rs = this._readableState;
+ if (ts.needTransform ||
+ rs.needReadable ||
+ rs.length < rs.highWaterMark)
+ this._read(rs.highWaterMark);
+ }
+};
+
+// Doesn't matter what the args are here.
+// _transform does all the work.
+// That we got here means that the readable side wants more data.
+Transform.prototype._read = function(n) {
+ var ts = this._transformState;
+
+ if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
+ ts.transforming = true;
+ this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+ } else {
+ // mark that we need a transform, so that any data that comes in
+ // will get processed, now that we've asked for it.
+ ts.needTransform = true;
+ }
+};
+
+
+function done(stream, er) {
+ if (er)
+ return stream.emit('error', er);
+
+ // if there's nothing in the write buffer, then that means
+ // that nothing more will ever be provided
+ var ws = stream._writableState;
+ var rs = stream._readableState;
+ var ts = stream._transformState;
+
+ if (ws.length)
+ throw new Error('calling transform done when ws.length != 0');
+
+ if (ts.transforming)
+ throw new Error('calling transform done when still transforming');
+
+ return stream.push(null);
+}
+
+},{"./_stream_duplex":61,"core-util-is":66,"inherits":33}],65:[function(require,module,exports){
+(function (process){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// A bit simpler than readable streams.
+// Implement an async ._write(chunk, cb), and it'll handle all
+// the drain event emission and buffering.
+
+module.exports = Writable;
+
+/*<replacement>*/
+var Buffer = require('buffer').Buffer;
+/*</replacement>*/
+
+Writable.WritableState = WritableState;
+
+
+/*<replacement>*/
+var util = require('core-util-is');
+util.inherits = require('inherits');
+/*</replacement>*/
+
+
+var Stream = require('stream');
+
+util.inherits(Writable, Stream);
+
+function WriteReq(chunk, encoding, cb) {
+ this.chunk = chunk;
+ this.encoding = encoding;
+ this.callback = cb;
+}
+
+function WritableState(options, stream) {
+ options = options || {};
+
+ // the point at which write() starts returning false
+ // Note: 0 is a valid value, means that we always return false if
+ // the entire buffer is not flushed immediately on write()
+ var hwm = options.highWaterMark;
+ this.highWaterMark = (hwm || hwm === 0) ? hwm : 16 * 1024;
+
+ // object stream flag to indicate whether or not this stream
+ // contains buffers or objects.
+ this.objectMode = !!options.objectMode;
+
+ // cast to ints.
+ this.highWaterMark = ~~this.highWaterMark;
+
+ this.needDrain = false;
+ // at the start of calling end()
+ this.ending = false;
+ // when end() has been called, and returned
+ this.ended = false;
+ // when 'finish' is emitted
+ this.finished = false;
+
+ // should we decode strings into buffers before passing to _write?
+ // this is here so that some node-core streams can optimize string
+ // handling at a lower level.
+ var noDecode = options.decodeStrings === false;
+ this.decodeStrings = !noDecode;
+
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
+
+ // not an actual buffer we keep track of, but a measurement
+ // of how much we're waiting to get pushed to some underlying
+ // socket or file.
+ this.length = 0;
+
+ // a flag to see when we're in the middle of a write.
+ this.writing = false;
+
+ // a flag to be able to tell if the onwrite cb is called immediately,
+ // or on a later tick. We set this to true at first, becuase any
+ // actions that shouldn't happen until "later" should generally also
+ // not happen before the first write call.
+ this.sync = true;
+
+ // a flag to know if we're processing previously buffered items, which
+ // may call the _write() callback in the same tick, so that we don't
+ // end up in an overlapped onwrite situation.
+ this.bufferProcessing = false;
+
+ // the callback that's passed to _write(chunk,cb)
+ this.onwrite = function(er) {
+ onwrite(stream, er);
+ };
+
+ // the callback that the user supplies to write(chunk,encoding,cb)
+ this.writecb = null;
+
+ // the amount that is being written when _write is called.
+ this.writelen = 0;
+
+ this.buffer = [];
+
+ // True if the error was already emitted and should not be thrown again
+ this.errorEmitted = false;
+}
+
+function Writable(options) {
+ var Duplex = require('./_stream_duplex');
+
+ // Writable ctor is applied to Duplexes, though they're not
+ // instanceof Writable, they're instanceof Readable.
+ if (!(this instanceof Writable) && !(this instanceof Duplex))
+ return new Writable(options);
+
+ this._writableState = new WritableState(options, this);
+
+ // legacy.
+ this.writable = true;
+
+ Stream.call(this);
+}
+
+// Otherwise people can pipe Writable streams, which is just wrong.
+Writable.prototype.pipe = function() {
+ this.emit('error', new Error('Cannot pipe. Not readable.'));
+};
+
+
+function writeAfterEnd(stream, state, cb) {
+ var er = new Error('write after end');
+ // TODO: defer error events consistently everywhere, not just the cb
+ stream.emit('error', er);
+ process.nextTick(function() {
+ cb(er);
+ });
+}
+
+// If we get something that is not a buffer, string, null, or undefined,
+// and we're not in objectMode, then that's an error.
+// Otherwise stream chunks are all considered to be of length=1, and the
+// watermarks determine how many objects to keep in the buffer, rather than
+// how many bytes or characters.
+function validChunk(stream, state, chunk, cb) {
+ var valid = true;
+ if (!Buffer.isBuffer(chunk) &&
+ 'string' !== typeof chunk &&
+ chunk !== null &&
+ chunk !== undefined &&
+ !state.objectMode) {
+ var er = new TypeError('Invalid non-string/buffer chunk');
+ stream.emit('error', er);
+ process.nextTick(function() {
+ cb(er);
+ });
+ valid = false;
+ }
+ return valid;
+}
+
+Writable.prototype.write = function(chunk, encoding, cb) {
+ var state = this._writableState;
+ var ret = false;
+
+ if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (Buffer.isBuffer(chunk))
+ encoding = 'buffer';
+ else if (!encoding)
+ encoding = state.defaultEncoding;
+
+ if (typeof cb !== 'function')
+ cb = function() {};
+
+ if (state.ended)
+ writeAfterEnd(this, state, cb);
+ else if (validChunk(this, state, chunk, cb))
+ ret = writeOrBuffer(this, state, chunk, encoding, cb);
+
+ return ret;
+};
+
+function decodeChunk(state, chunk, encoding) {
+ if (!state.objectMode &&
+ state.decodeStrings !== false &&
+ typeof chunk === 'string') {
+ chunk = new Buffer(chunk, encoding);
+ }
+ return chunk;
+}
+
+// if we're already writing something, then just put this
+// in the queue, and wait our turn. Otherwise, call _write
+// If we return false, then we need a drain event, so set that flag.
+function writeOrBuffer(stream, state, chunk, encoding, cb) {
+ chunk = decodeChunk(state, chunk, encoding);
+ if (Buffer.isBuffer(chunk))
+ encoding = 'buffer';
+ var len = state.objectMode ? 1 : chunk.length;
+
+ state.length += len;
+
+ var ret = state.length < state.highWaterMark;
+ // we must ensure that previous needDrain will not be reset to false.
+ if (!ret)
+ state.needDrain = true;
+
+ if (state.writing)
+ state.buffer.push(new WriteReq(chunk, encoding, cb));
+ else
+ doWrite(stream, state, len, chunk, encoding, cb);
+
+ return ret;
+}
+
+function doWrite(stream, state, len, chunk, encoding, cb) {
+ state.writelen = len;
+ state.writecb = cb;
+ state.writing = true;
+ state.sync = true;
+ stream._write(chunk, encoding, state.onwrite);
+ state.sync = false;
+}
+
+function onwriteError(stream, state, sync, er, cb) {
+ if (sync)
+ process.nextTick(function() {
+ cb(er);
+ });
+ else
+ cb(er);
+
+ stream._writableState.errorEmitted = true;
+ stream.emit('error', er);
+}
+
+function onwriteStateUpdate(state) {
+ state.writing = false;
+ state.writecb = null;
+ state.length -= state.writelen;
+ state.writelen = 0;
+}
+
+function onwrite(stream, er) {
+ var state = stream._writableState;
+ var sync = state.sync;
+ var cb = state.writecb;
+
+ onwriteStateUpdate(state);
+
+ if (er)
+ onwriteError(stream, state, sync, er, cb);
+ else {
+ // Check if we're actually ready to finish, but don't emit yet
+ var finished = needFinish(stream, state);
+
+ if (!finished && !state.bufferProcessing && state.buffer.length)
+ clearBuffer(stream, state);
+
+ if (sync) {
+ process.nextTick(function() {
+ afterWrite(stream, state, finished, cb);
+ });
+ } else {
+ afterWrite(stream, state, finished, cb);
+ }
+ }
+}
+
+function afterWrite(stream, state, finished, cb) {
+ if (!finished)
+ onwriteDrain(stream, state);
+ cb();
+ if (finished)
+ finishMaybe(stream, state);
+}
+
+// Must force callback to be called on nextTick, so that we don't
+// emit 'drain' before the write() consumer gets the 'false' return
+// value, and has a chance to attach a 'drain' listener.
+function onwriteDrain(stream, state) {
+ if (state.length === 0 && state.needDrain) {
+ state.needDrain = false;
+ stream.emit('drain');
+ }
+}
+
+
+// if there's something in the buffer waiting, then process it
+function clearBuffer(stream, state) {
+ state.bufferProcessing = true;
+
+ for (var c = 0; c < state.buffer.length; c++) {
+ var entry = state.buffer[c];
+ var chunk = entry.chunk;
+ var encoding = entry.encoding;
+ var cb = entry.callback;
+ var len = state.objectMode ? 1 : chunk.length;
+
+ doWrite(stream, state, len, chunk, encoding, cb);
+
+ // if we didn't call the onwrite immediately, then
+ // it means that we need to wait until it does.
+ // also, that means that the chunk and cb are currently
+ // being processed, so move the buffer counter past them.
+ if (state.writing) {
+ c++;
+ break;
+ }
+ }
+
+ state.bufferProcessing = false;
+ if (c < state.buffer.length)
+ state.buffer = state.buffer.slice(c);
+ else
+ state.buffer.length = 0;
+}
+
+Writable.prototype._write = function(chunk, encoding, cb) {
+ cb(new Error('not implemented'));
+};
+
+Writable.prototype.end = function(chunk, encoding, cb) {
+ var state = this._writableState;
+
+ if (typeof chunk === 'function') {
+ cb = chunk;
+ chunk = null;
+ encoding = null;
+ } else if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
+ }
+
+ if (typeof chunk !== 'undefined' && chunk !== null)
+ this.write(chunk, encoding);
+
+ // ignore unnecessary end() calls.
+ if (!state.ending && !state.finished)
+ endWritable(this, state, cb);
+};
+
+
+function needFinish(stream, state) {
+ return (state.ending &&
+ state.length === 0 &&
+ !state.finished &&
+ !state.writing);
+}
+
+function finishMaybe(stream, state) {
+ var need = needFinish(stream, state);
+ if (need) {
+ state.finished = true;
+ stream.emit('finish');
+ }
+ return need;
+}
+
+function endWritable(stream, state, cb) {
+ state.ending = true;
+ finishMaybe(stream, state);
+ if (cb) {
+ if (state.finished)
+ process.nextTick(cb);
+ else
+ stream.once('finish', cb);
+ }
+ state.ended = true;
+}
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))
+},{"./_stream_duplex":61,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"core-util-is":66,"inherits":33,"stream":24}],66:[function(require,module,exports){
+(function (Buffer){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+function isArray(ar) {
+ return Array.isArray(ar);
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+ return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+ return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+ return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+ return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+ return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+ return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+ return isObject(re) && objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+ return isObject(d) && objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+ return isObject(e) &&
+ (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+ return arg === null ||
+ typeof arg === 'boolean' ||
+ typeof arg === 'number' ||
+ typeof arg === 'string' ||
+ typeof arg === 'symbol' || // ES6 symbol
+ typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+function isBuffer(arg) {
+ return Buffer.isBuffer(arg);
+}
+exports.isBuffer = isBuffer;
+
+function objectToString(o) {
+ return Object.prototype.toString.call(o);
+}
+}).call(this,require("buffer").Buffer)
+},{"buffer":20}],67:[function(require,module,exports){
+module.exports = Array.isArray || function (arr) {
+ return Object.prototype.toString.call(arr) == '[object Array]';
+};
+
+},{}],68:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+var Buffer = require('buffer').Buffer;
+
+var isBufferEncoding = Buffer.isEncoding
+ || function(encoding) {
+ switch (encoding && encoding.toLowerCase()) {
+ case 'hex': case 'utf8': case 'utf-8': case 'ascii': case 'binary': case 'base64': case 'ucs2': case 'ucs-2': case 'utf16le': case 'utf-16le': case 'raw': return true;
+ default: return false;
+ }
+ }
+
+
+function assertEncoding(encoding) {
+ if (encoding && !isBufferEncoding(encoding)) {
+ throw new Error('Unknown encoding: ' + encoding);
+ }
+}
+
+var StringDecoder = exports.StringDecoder = function(encoding) {
+ this.encoding = (encoding || 'utf8').toLowerCase().replace(/[-_]/, '');
+ assertEncoding(encoding);
+ switch (this.encoding) {
+ case 'utf8':
+ // CESU-8 represents each of Surrogate Pair by 3-bytes
+ this.surrogateSize = 3;
+ break;
+ case 'ucs2':
+ case 'utf16le':
+ // UTF-16 represents each of Surrogate Pair by 2-bytes
+ this.surrogateSize = 2;
+ this.detectIncompleteChar = utf16DetectIncompleteChar;
+ break;
+ case 'base64':
+ // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
+ this.surrogateSize = 3;
+ this.detectIncompleteChar = base64DetectIncompleteChar;
+ break;
+ default:
+ this.write = passThroughWrite;
+ return;
+ }
+
+ this.charBuffer = new Buffer(6);
+ this.charReceived = 0;
+ this.charLength = 0;
+};
+
+
+StringDecoder.prototype.write = function(buffer) {
+ var charStr = '';
+ var offset = 0;
+
+ // if our last write ended with an incomplete multibyte character
+ while (this.charLength) {
+ // determine how many remaining bytes this buffer has to offer for this char
+ var i = (buffer.length >= this.charLength - this.charReceived) ?
+ this.charLength - this.charReceived :
+ buffer.length;
+
+ // add the new bytes to the char buffer
+ buffer.copy(this.charBuffer, this.charReceived, offset, i);
+ this.charReceived += (i - offset);
+ offset = i;
+
+ if (this.charReceived < this.charLength) {
+ // still not enough chars in this buffer? wait for more ...
+ return '';
+ }
+
+ // get the character that was split
+ charStr = this.charBuffer.slice(0, this.charLength).toString(this.encoding);
+
+ // lead surrogate (D800-DBFF) is also the incomplete character
+ var charCode = charStr.charCodeAt(charStr.length - 1);
+ if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+ this.charLength += this.surrogateSize;
+ charStr = '';
+ continue;
+ }
+ this.charReceived = this.charLength = 0;
+
+ // if there are no more bytes in this buffer, just emit our char
+ if (i == buffer.length) return charStr;
+
+ // otherwise cut off the characters end from the beginning of this buffer
+ buffer = buffer.slice(i, buffer.length);
+ break;
+ }
+
+ var lenIncomplete = this.detectIncompleteChar(buffer);
+
+ var end = buffer.length;
+ if (this.charLength) {
+ // buffer the incomplete character bytes we got
+ buffer.copy(this.charBuffer, 0, buffer.length - lenIncomplete, end);
+ this.charReceived = lenIncomplete;
+ end -= lenIncomplete;
+ }
+
+ charStr += buffer.toString(this.encoding, 0, end);
+
+ var end = charStr.length - 1;
+ var charCode = charStr.charCodeAt(end);
+ // lead surrogate (D800-DBFF) is also the incomplete character
+ if (charCode >= 0xD800 && charCode <= 0xDBFF) {
+ var size = this.surrogateSize;
+ this.charLength += size;
+ this.charReceived += size;
+ this.charBuffer.copy(this.charBuffer, size, 0, size);
+ this.charBuffer.write(charStr.charAt(charStr.length - 1), this.encoding);
+ return charStr.substring(0, end);
+ }
+
+ // or just emit the charStr
+ return charStr;
+};
+
+StringDecoder.prototype.detectIncompleteChar = function(buffer) {
+ // determine how many bytes we have to check at the end of this buffer
+ var i = (buffer.length >= 3) ? 3 : buffer.length;
+
+ // Figure out if one of the last i bytes of our buffer announces an
+ // incomplete char.
+ for (; i > 0; i--) {
+ var c = buffer[buffer.length - i];
+
+ // See http://en.wikipedia.org/wiki/UTF-8#Description
+
+ // 110XXXXX
+ if (i == 1 && c >> 5 == 0x06) {
+ this.charLength = 2;
+ break;
+ }
+
+ // 1110XXXX
+ if (i <= 2 && c >> 4 == 0x0E) {
+ this.charLength = 3;
+ break;
+ }
+
+ // 11110XXX
+ if (i <= 3 && c >> 3 == 0x1E) {
+ this.charLength = 4;
+ break;
+ }
+ }
+
+ return i;
+};
+
+StringDecoder.prototype.end = function(buffer) {
+ var res = '';
+ if (buffer && buffer.length)
+ res = this.write(buffer);
+
+ if (this.charReceived) {
+ var cr = this.charReceived;
+ var buf = this.charBuffer;
+ var enc = this.encoding;
+ res += buf.slice(0, cr).toString(enc);
+ }
+
+ return res;
+};
+
+function passThroughWrite(buffer) {
+ return buffer.toString(this.encoding);
+}
+
+function utf16DetectIncompleteChar(buffer) {
+ var incomplete = this.charReceived = buffer.length % 2;
+ this.charLength = incomplete ? 2 : 0;
+ return incomplete;
+}
+
+function base64DetectIncompleteChar(buffer) {
+ var incomplete = this.charReceived = buffer.length % 3;
+ this.charLength = incomplete ? 3 : 0;
+ return incomplete;
+}
+
+},{"buffer":20}],69:[function(require,module,exports){
+exports = module.exports = require('./lib/_stream_readable.js');
+exports.Readable = exports;
+exports.Writable = require('./lib/_stream_writable.js');
+exports.Duplex = require('./lib/_stream_duplex.js');
+exports.Transform = require('./lib/_stream_transform.js');
+exports.PassThrough = require('./lib/_stream_passthrough.js');
+
+},{"./lib/_stream_duplex.js":61,"./lib/_stream_passthrough.js":62,"./lib/_stream_readable.js":63,"./lib/_stream_transform.js":64,"./lib/_stream_writable.js":65}],70:[function(require,module,exports){
+module.exports = extend
+
+function extend() {
+ var target = {}
+
+ for (var i = 0; i < arguments.length; i++) {
+ var source = arguments[i]
+
+ for (var key in source) {
+ if (source.hasOwnProperty(key)) {
+ target[key] = source[key]
+ }
+ }
+ }
+
+ return target
+}
+
+},{}],71:[function(require,module,exports){
+module.exports={
+ "name": "levelup",
+ "description": "Fast & simple storage - a Node.js-style LevelDB wrapper",
+ "version": "0.18.6",
+ "contributors": [
+ {
+ "name": "Rod Vagg",
+ "email": "r@va.gg",
+ "url": "https://github.com/rvagg"
+ },
+ {
+ "name": "John Chesley",
+ "email": "john@chesl.es",
+ "url": "https://github.com/chesles/"
+ },
+ {
+ "name": "Jake Verbaten",
+ "email": "raynos2@gmail.com",
+ "url": "https://github.com/raynos"
+ },
+ {
+ "name": "Dominic Tarr",
+ "email": "dominic.tarr@gmail.com",
+ "url": "https://github.com/dominictarr"
+ },
+ {
+ "name": "Max Ogden",
+ "email": "max@maxogden.com",
+ "url": "https://github.com/maxogden"
+ },
+ {
+ "name": "Lars-Magnus Skog",
+ "email": "lars.magnus.skog@gmail.com",
+ "url": "https://github.com/ralphtheninja"
+ },
+ {
+ "name": "David Björklund",
+ "email": "david.bjorklund@gmail.com",
+ "url": "https://github.com/kesla"
+ },
+ {
+ "name": "Julian Gruber",
+ "email": "julian@juliangruber.com",
+ "url": "https://github.com/juliangruber"
+ },
+ {
+ "name": "Paolo Fragomeni",
+ "email": "paolo@async.ly",
+ "url": "https://github.com/hij1nx"
+ },
+ {
+ "name": "Anton Whalley",
+ "email": "anton.whalley@nearform.com",
+ "url": "https://github.com/No9"
+ },
+ {
+ "name": "Matteo Collina",
+ "email": "matteo.collina@gmail.com",
+ "url": "https://github.com/mcollina"
+ },
+ {
+ "name": "Pedro Teixeira",
+ "email": "pedro.teixeira@gmail.com",
+ "url": "https://github.com/pgte"
+ },
+ {
+ "name": "James Halliday",
+ "email": "mail@substack.net",
+ "url": "https://github.com/substack"
+ }
+ ],
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/rvagg/node-levelup.git"
+ },
+ "homepage": "https://github.com/rvagg/node-levelup",
+ "keywords": [
+ "leveldb",
+ "stream",
+ "database",
+ "db",
+ "store",
+ "storage",
+ "json"
+ ],
+ "main": "lib/levelup.js",
+ "dependencies": {
+ "bl": "~0.8.1",
+ "deferred-leveldown": "~0.2.0",
+ "errno": "~0.1.1",
+ "prr": "~0.0.0",
+ "readable-stream": "~1.0.26",
+ "semver": "~2.3.1",
+ "xtend": "~3.0.0"
+ },
+ "devDependencies": {
+ "leveldown": "~0.10.0",
+ "bustermove": "*",
+ "tap": "*",
+ "referee": "*",
+ "rimraf": "*",
+ "async": "*",
+ "fstream": "*",
+ "tar": "*",
+ "mkfiletree": "*",
+ "readfiletree": "*",
+ "slow-stream": ">=0.0.4",
+ "delayed": "*",
+ "boganipsum": "*",
+ "du": "*",
+ "memdown": "*",
+ "msgpack-js": "*"
+ },
+ "browser": {
+ "leveldown": false,
+ "leveldown/package": false,
+ "semver": false
+ },
+ "scripts": {
+ "test": "tap test/*-test.js --stderr",
+ "functionaltests": "node ./test/functional/fstream-test.js && node ./test/functional/binary-data-test.js && node ./test/functional/compat-test.js",
+ "alltests": "npm test && npm run-script functionaltests"
+ },
+ "license": "MIT",
+ "gitHead": "213e989e2b75273e2b44c23f84f95e35bff7ea11",
+ "bugs": {
+ "url": "https://github.com/rvagg/node-levelup/issues"
+ },
+ "_id": "levelup@0.18.6",
+ "_shasum": "e6a01cb089616c8ecc0291c2a9bd3f0c44e3e5eb",
+ "_from": "levelup@~0.18.4",
+ "_npmVersion": "1.4.14",
+ "_npmUser": {
+ "name": "rvagg",
+ "email": "rod@vagg.org"
+ },
+ "maintainers": [
+ {
+ "name": "rvagg",
+ "email": "rod@vagg.org"
+ }
+ ],
+ "dist": {
+ "shasum": "e6a01cb089616c8ecc0291c2a9bd3f0c44e3e5eb",
+ "tarball": "http://127.0.0.1:5080/tarballs/levelup/0.18.6.tgz"
+ },
+ "_resolved": "http://127.0.0.1:5080/tarballs/levelup/0.18.6.tgz",
+ "readme": "ERROR: No README data found!"
+}
+
+},{}],72:[function(require,module,exports){
+'use strict';
+
+module.exports = INTERNAL;
+
+function INTERNAL() {}
+},{}],73:[function(require,module,exports){
+'use strict';
+var Promise = require('./promise');
+var reject = require('./reject');
+var resolve = require('./resolve');
+var INTERNAL = require('./INTERNAL');
+var handlers = require('./handlers');
+var noArray = reject(new TypeError('must be an array'));
+module.exports = function all(iterable) {
+ if (Object.prototype.toString.call(iterable) !== '[object Array]') {
+ return noArray;
+ }
+
+ var len = iterable.length;
+ var called = false;
+ if (!len) {
+ return resolve([]);
+ }
+
+ var values = new Array(len);
+ var resolved = 0;
+ var i = -1;
+ var promise = new Promise(INTERNAL);
+
+ while (++i < len) {
+ allResolver(iterable[i], i);
+ }
+ return promise;
+ function allResolver(value, i) {
+ resolve(value).then(resolveFromAll, function (error) {
+ if (!called) {
+ called = true;
+ handlers.reject(promise, error);
+ }
+ });
+ function resolveFromAll(outValue) {
+ values[i] = outValue;
+ if (++resolved === len & !called) {
+ called = true;
+ handlers.resolve(promise, values);
+ }
+ }
+ }
+};
+},{"./INTERNAL":72,"./handlers":74,"./promise":76,"./reject":78,"./resolve":79}],74:[function(require,module,exports){
+'use strict';
+var tryCatch = require('./tryCatch');
+var resolveThenable = require('./resolveThenable');
+var states = require('./states');
+
+exports.resolve = function (self, value) {
+ var result = tryCatch(getThen, value);
+ if (result.status === 'error') {
+ return exports.reject(self, result.value);
+ }
+ var thenable = result.value;
+
+ if (thenable) {
+ resolveThenable.safely(self, thenable);
+ } else {
+ self.state = states.FULFILLED;
+ self.outcome = value;
+ var i = -1;
+ var len = self.queue.length;
+ while (++i < len) {
+ self.queue[i].callFulfilled(value);
+ }
+ }
+ return self;
+};
+exports.reject = function (self, error) {
+ self.state = states.REJECTED;
+ self.outcome = error;
+ var i = -1;
+ var len = self.queue.length;
+ while (++i < len) {
+ self.queue[i].callRejected(error);
+ }
+ return self;
+};
+
+function getThen(obj) {
+ // Make sure we only access the accessor once as required by the spec
+ var then = obj && obj.then;
+ if (obj && typeof obj === 'object' && typeof then === 'function') {
+ return function appyThen() {
+ then.apply(obj, arguments);
+ };
+ }
+}
+},{"./resolveThenable":80,"./states":81,"./tryCatch":82}],75:[function(require,module,exports){
+module.exports = exports = require('./promise');
+
+exports.resolve = require('./resolve');
+exports.reject = require('./reject');
+exports.all = require('./all');
+},{"./all":73,"./promise":76,"./reject":78,"./resolve":79}],76:[function(require,module,exports){
+'use strict';
+
+var unwrap = require('./unwrap');
+var INTERNAL = require('./INTERNAL');
+var resolveThenable = require('./resolveThenable');
+var states = require('./states');
+var QueueItem = require('./queueItem');
+
+module.exports = Promise;
+function Promise(resolver) {
+ if (!(this instanceof Promise)) {
+ return new Promise(resolver);
+ }
+ if (typeof resolver !== 'function') {
+ throw new TypeError('reslover must be a function');
+ }
+ this.state = states.PENDING;
+ this.queue = [];
+ this.outcome = void 0;
+ if (resolver !== INTERNAL) {
+ resolveThenable.safely(this, resolver);
+ }
+}
+
+Promise.prototype['catch'] = function (onRejected) {
+ return this.then(null, onRejected);
+};
+Promise.prototype.then = function (onFulfilled, onRejected) {
+ if (typeof onFulfilled !== 'function' && this.state === states.FULFILLED ||
+ typeof onRejected !== 'function' && this.state === states.REJECTED) {
+ return this;
+ }
+ var promise = new Promise(INTERNAL);
+
+
+ if (this.state !== states.PENDING) {
+ var resolver = this.state === states.FULFILLED ? onFulfilled: onRejected;
+ unwrap(promise, resolver, this.outcome);
+ } else {
+ this.queue.push(new QueueItem(promise, onFulfilled, onRejected));
+ }
+
+ return promise;
+};
+
+},{"./INTERNAL":72,"./queueItem":77,"./resolveThenable":80,"./states":81,"./unwrap":83}],77:[function(require,module,exports){
+'use strict';
+var handlers = require('./handlers');
+var unwrap = require('./unwrap');
+
+module.exports = QueueItem;
+function QueueItem(promise, onFulfilled, onRejected) {
+ this.promise = promise;
+ if (typeof onFulfilled === 'function') {
+ this.onFulfilled = onFulfilled;
+ this.callFulfilled = this.otherCallFulfilled;
+ }
+ if (typeof onRejected === 'function') {
+ this.onRejected = onRejected;
+ this.callRejected = this.otherCallRejected;
+ }
+}
+QueueItem.prototype.callFulfilled = function (value) {
+ handlers.resolve(this.promise, value);
+};
+QueueItem.prototype.otherCallFulfilled = function (value) {
+ unwrap(this.promise, this.onFulfilled, value);
+};
+QueueItem.prototype.callRejected = function (value) {
+ handlers.reject(this.promise, value);
+};
+QueueItem.prototype.otherCallRejected = function (value) {
+ unwrap(this.promise, this.onRejected, value);
+};
+},{"./handlers":74,"./unwrap":83}],78:[function(require,module,exports){
+'use strict';
+
+var Promise = require('./promise');
+var INTERNAL = require('./INTERNAL');
+var handlers = require('./handlers');
+module.exports = reject;
+
+function reject(reason) {
+ var promise = new Promise(INTERNAL);
+ return handlers.reject(promise, reason);
+}
+},{"./INTERNAL":72,"./handlers":74,"./promise":76}],79:[function(require,module,exports){
+'use strict';
+
+var Promise = require('./promise');
+var INTERNAL = require('./INTERNAL');
+var handlers = require('./handlers');
+module.exports = resolve;
+
+var FALSE = handlers.resolve(new Promise(INTERNAL), false);
+var NULL = handlers.resolve(new Promise(INTERNAL), null);
+var UNDEFINED = handlers.resolve(new Promise(INTERNAL), void 0);
+var ZERO = handlers.resolve(new Promise(INTERNAL), 0);
+var EMPTYSTRING = handlers.resolve(new Promise(INTERNAL), '');
+
+function resolve(value) {
+ if (value) {
+ if (value instanceof Promise) {
+ return value;
+ }
+ return handlers.resolve(new Promise(INTERNAL), value);
+ }
+ var valueType = typeof value;
+ switch (valueType) {
+ case 'boolean':
+ return FALSE;
+ case 'undefined':
+ return UNDEFINED;
+ case 'object':
+ return NULL;
+ case 'number':
+ return ZERO;
+ case 'string':
+ return EMPTYSTRING;
+ }
+}
+},{"./INTERNAL":72,"./handlers":74,"./promise":76}],80:[function(require,module,exports){
+'use strict';
+var handlers = require('./handlers');
+var tryCatch = require('./tryCatch');
+function safelyResolveThenable(self, thenable) {
+ // Either fulfill, reject or reject with error
+ var called = false;
+ function onError(value) {
+ if (called) {
+ return;
+ }
+ called = true;
+ handlers.reject(self, value);
+ }
+
+ function onSuccess(value) {
+ if (called) {
+ return;
+ }
+ called = true;
+ handlers.resolve(self, value);
+ }
+
+ function tryToUnwrap() {
+ thenable(onSuccess, onError);
+ }
+
+ var result = tryCatch(tryToUnwrap);
+ if (result.status === 'error') {
+ onError(result.value);
+ }
+}
+exports.safely = safelyResolveThenable;
+},{"./handlers":74,"./tryCatch":82}],81:[function(require,module,exports){
+// Lazy man's symbols for states
+
+exports.REJECTED = ['REJECTED'];
+exports.FULFILLED = ['FULFILLED'];
+exports.PENDING = ['PENDING'];
+},{}],82:[function(require,module,exports){
+'use strict';
+
+module.exports = tryCatch;
+
+function tryCatch(func, value) {
+ var out = {};
+ try {
+ out.value = func(value);
+ out.status = 'success';
+ } catch (e) {
+ out.status = 'error';
+ out.value = e;
+ }
+ return out;
+}
+},{}],83:[function(require,module,exports){
+'use strict';
+
+var immediate = require('immediate');
+var handlers = require('./handlers');
+module.exports = unwrap;
+
+function unwrap(promise, func, value) {
+ immediate(function () {
+ var returnValue;
+ try {
+ returnValue = func(value);
+ } catch (e) {
+ return handlers.reject(promise, e);
+ }
+ if (returnValue === promise) {
+ handlers.reject(promise, new TypeError('Cannot resolve promise with itself'));
+ } else {
+ handlers.resolve(promise, returnValue);
+ }
+ });
+}
+},{"./handlers":74,"immediate":84}],84:[function(require,module,exports){
+'use strict';
+var types = [
+ require('./nextTick'),
+ require('./mutation.js'),
+ require('./messageChannel'),
+ require('./stateChange'),
+ require('./timeout')
+];
+var draining;
+var queue = [];
+function drainQueue() {
+ draining = true;
+ var i, oldQueue;
+ var len = queue.length;
+ while (len) {
+ oldQueue = queue;
+ queue = [];
+ i = -1;
+ while (++i < len) {
+ oldQueue[i]();
+ }
+ len = queue.length;
+ }
+ draining = false;
+}
+var scheduleDrain;
+var i = -1;
+var len = types.length;
+while (++ i < len) {
+ if (types[i] && types[i].test && types[i].test()) {
+ scheduleDrain = types[i].install(drainQueue);
+ break;
+ }
+}
+module.exports = immediate;
+function immediate(task) {
+ if (queue.push(task) === 1 && !draining) {
+ scheduleDrain();
+ }
+}
+},{"./messageChannel":85,"./mutation.js":86,"./nextTick":17,"./stateChange":87,"./timeout":88}],85:[function(require,module,exports){
+(function (global){
+'use strict';
+
+exports.test = function () {
+ if (global.setImmediate) {
+ // we can only get here in IE10
+ // which doesn't handel postMessage well
+ return false;
+ }
+ return typeof global.MessageChannel !== 'undefined';
+};
+
+exports.install = function (func) {
+ var channel = new global.MessageChannel();
+ channel.port1.onmessage = func;
+ return function () {
+ channel.port2.postMessage(0);
+ };
+};
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],86:[function(require,module,exports){
+(function (global){
+'use strict';
+//based off rsvp https://github.com/tildeio/rsvp.js
+//license https://github.com/tildeio/rsvp.js/blob/master/LICENSE
+//https://github.com/tildeio/rsvp.js/blob/master/lib/rsvp/asap.js
+
+var Mutation = global.MutationObserver || global.WebKitMutationObserver;
+
+exports.test = function () {
+ return Mutation;
+};
+
+exports.install = function (handle) {
+ var called = 0;
+ var observer = new Mutation(handle);
+ var element = global.document.createTextNode('');
+ observer.observe(element, {
+ characterData: true
+ });
+ return function () {
+ element.data = (called = ++called % 2);
+ };
+};
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],87:[function(require,module,exports){
+(function (global){
+'use strict';
+
+exports.test = function () {
+ return 'document' in global && 'onreadystatechange' in global.document.createElement('script');
+};
+
+exports.install = function (handle) {
+ return function () {
+
+ // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
+ // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
+ var scriptEl = global.document.createElement('script');
+ scriptEl.onreadystatechange = function () {
+ handle();
+
+ scriptEl.onreadystatechange = null;
+ scriptEl.parentNode.removeChild(scriptEl);
+ scriptEl = null;
+ };
+ global.document.documentElement.appendChild(scriptEl);
+
+ return handle;
+ };
+};
+}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],88:[function(require,module,exports){
+'use strict';
+exports.test = function () {
+ return true;
+};
+
+exports.install = function (t) {
+ return function () {
+ setTimeout(t, 0);
+ };
+};
+},{}],"RQL87X":[function(require,module,exports){
+(function (process,global,Buffer){
+var util = require('util')
+ , AbstractLevelDOWN = require('abstract-leveldown').AbstractLevelDOWN
+ , AbstractIterator = require('abstract-leveldown').AbstractIterator
+ , noop = function () {}
+ , setImmediate = global.setImmediate || process.nextTick
+
+function toKey (key) {
+ return typeof key == 'string' ? '$' + key : JSON.stringify(key)
+}
+
+function sortedIndexOf (arr, item) {
+ var low = 0, high = arr.length, mid
+ while (low < high) {
+ mid = (low + high) >>> 1
+ arr[mid] < item ? low = mid + 1 : high = mid
+ }
+ return low
+}
+
+function MemIterator (db, options) {
+ AbstractIterator.call(this, db)
+ this._reverse = options.reverse
+ this._limit = options.limit
+ this._count = 0
+ this._end = options.end
+ this._start = options.start
+ this._gt = options.gt
+ this._gte = options.gte
+ this._lt = options.lt
+ this._lte = options.lte
+ this._keys = []
+
+ var i
+
+ if (this._start) {
+ for (i = 0; i < this.db._keys.length; i++) {
+ if (this.db._keys[i] >= this._start) {
+ this._pos = i
+ if (this.db._keys[i] != this._start) {
+ if (this._reverse) {
+ // going backwards and key doesn't match, jump back one
+ --this._pos
+ }
+ } else {
+ if (options.exclusiveStart) {
+ // key matches but it's a gt or lt
+ this._pos += (this._reverse ? -1 : 1)
+ }
+ }
+ break
+ }
+ }
+
+ if (this._pos == null && !this._reverse) // no matching keys, non starter
+ this._pos = -1
+ }
+
+ if (!options.start || this._pos === undefined)
+ this._pos = this._reverse ? this.db._keys.length - 1 : 0
+
+ // copy the keys that we need so that they're not affected by puts/deletes
+ if (this._pos >= 0) {
+ this._keys = this._reverse ? this.db._keys.slice(0, this._pos + 1) : this.db._keys.slice(this._pos)
+ this._pos = this._reverse ? this._keys.length - 1 : 0
+ }
+}
+
+util.inherits(MemIterator, AbstractIterator)
+
+MemIterator.prototype._next = function (callback) {
+ var self = this
+ , key = self._keys[self._pos]
+ , value
+
+ if (self._pos >= self._keys.length || self._pos < 0)
+ return setImmediate(callback)
+
+ if (!!self._end && (self._reverse ? key < self._end : key > self._end))
+ return setImmediate(callback)
+
+
+ if (!!self._limit && self._limit > 0 && self._count++ >= self._limit)
+ return setImmediate(callback)
+
+ if ( (this._lt && key >= this._lt)
+ || (this._lte && key > this._lte)
+ || (this._gt && key <= this._gt)
+ || (this._gte && key < this._gte))
+ return setImmediate(callback)
+
+ value = self.db._store[toKey(key)]
+ self._pos += self._reverse ? -1 : 1
+
+ setImmediate(function () { callback(null, key, value) })
+}
+
+function MemDOWN (location) {
+ if (!(this instanceof MemDOWN))
+ return new MemDOWN(location)
+
+ AbstractLevelDOWN.call(this, typeof location == 'string' ? location : '')
+ this._store = {}
+ this._keys = []
+}
+
+util.inherits(MemDOWN, AbstractLevelDOWN)
+
+MemDOWN.prototype._open = function (options, callback) {
+ var self = this
+ setImmediate(function () { callback(null, self) })
+}
+
+MemDOWN.prototype._put = function (key, value, options, callback) {
+ var ix = sortedIndexOf(this._keys, key)
+ if (this._keys[ix] != key)
+ this._keys.splice(ix, 0, key)
+ key = toKey(key) // safety, to avoid key='__proto__'-type skullduggery
+ this._store[key] = value
+ setImmediate(callback)
+}
+
+MemDOWN.prototype._get = function (key, options, callback) {
+ var value = this._store[toKey(key)]
+ if (value === undefined) {
+ // 'NotFound' error, consistent with LevelDOWN API
+ return setImmediate(function () { callback(new Error('NotFound')) })
+ }
+ if (options.asBuffer !== false && !Buffer.isBuffer(value))
+ value = new Buffer(String(value))
+ setImmediate(function () {
+ callback(null, value)
+ })
+}
+
+MemDOWN.prototype._del = function (key, options, callback) {
+ var ix = sortedIndexOf(this._keys, key)
+ if (this._keys[ix] == key)
+ this._keys.splice(ix, 1)
+ delete this._store[toKey(key)]
+ setImmediate(callback)
+}
+
+MemDOWN.prototype._batch = function (array, options, callback) {
+ var err
+ , i = 0
+ , key
+ , value
+
+ if (Array.isArray(array)) {
+ for (; i < array.length; i++) {
+ if (array[i]) {
+ key = Buffer.isBuffer(array[i].key) ? array[i].key : String(array[i].key)
+ err = this._checkKeyValue(key, 'key')
+ if (err) return setImmediate(function () { callback(err) })
+ if (array[i].type === 'del') {
+ this._del(array[i].key, options, noop)
+ } else if (array[i].type === 'put') {
+ value = Buffer.isBuffer(array[i].value) ? array[i].value : String(array[i].value)
+ err = this._checkKeyValue(value, 'value')
+ if (err) return setImmediate(function () { callback(err) })
+ this._put(key, value, options, noop)
+ }
+ }
+ }
+ }
+ setImmediate(callback)
+}
+
+MemDOWN.prototype._iterator = function (options) {
+ return new MemIterator(this, options)
+}
+
+MemDOWN.prototype._isBuffer = function (obj) {
+ return Buffer.isBuffer(obj)
+}
+
+module.exports = MemDOWN
+
+}).call(this,require("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("buffer").Buffer)
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"abstract-leveldown":93,"buffer":20,"util":32}],"leveldown":[function(require,module,exports){
+module.exports=require('RQL87X');
+},{}],91:[function(require,module,exports){
+module.exports=require(55)
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],92:[function(require,module,exports){
+module.exports=require(56)
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],93:[function(require,module,exports){
+module.exports=require(57)
+},{"./abstract-chained-batch":91,"./abstract-iterator":92,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"xtend":94}],94:[function(require,module,exports){
+module.exports=require(70)
+},{}],95:[function(require,module,exports){
+"use strict";
+
+// Extends method
+// (taken from http://code.jquery.com/jquery-1.9.0.js)
+// Populate the class2type map
+var class2type = {};
+
+var types = [
+ "Boolean", "Number", "String", "Function", "Array",
+ "Date", "RegExp", "Object", "Error"
+];
+for (var i = 0; i < types.length; i++) {
+ var typename = types[i];
+ class2type["[object " + typename + "]"] = typename.toLowerCase();
+}
+
+var core_toString = class2type.toString;
+var core_hasOwn = class2type.hasOwnProperty;
+
+function type(obj) {
+ if (obj === null) {
+ return String(obj);
+ }
+ return typeof obj === "object" || typeof obj === "function" ?
+ class2type[core_toString.call(obj)] || "object" :
+ typeof obj;
+}
+
+function isWindow(obj) {
+ return obj !== null && obj === obj.window;
+}
+
+function isPlainObject(obj) {
+ // Must be an Object.
+ // Because of IE, we also have to check the presence of
+ // the constructor property.
+ // Make sure that DOM nodes and window objects don't pass through, as well
+ if (!obj || type(obj) !== "object" || obj.nodeType || isWindow(obj)) {
+ return false;
+ }
+
+ try {
+ // Not own constructor property must be Object
+ if (obj.constructor &&
+ !core_hasOwn.call(obj, "constructor") &&
+ !core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) {
+ return false;
+ }
+ } catch ( e ) {
+ // IE8,9 Will throw exceptions on certain host objects #9897
+ return false;
+ }
+
+ // Own properties are enumerated firstly, so to speed up,
+ // if last one is own, then all properties are own.
+ var key;
+ for (key in obj) {}
+
+ return key === undefined || core_hasOwn.call(obj, key);
+}
+
+
+function isFunction(obj) {
+ return type(obj) === "function";
+}
+
+var isArray = Array.isArray || function (obj) {
+ return type(obj) === "array";
+};
+
+function extend() {
+ var options, name, src, copy, copyIsArray, clone,
+ target = arguments[0] || {},
+ i = 1,
+ length = arguments.length,
+ deep = false;
+
+ // Handle a deep copy situation
+ if (typeof target === "boolean") {
+ deep = target;
+ target = arguments[1] || {};
+ // skip the boolean and the target
+ i = 2;
+ }
+
+ // Handle case when target is a string or something (possible in deep copy)
+ if (typeof target !== "object" && !isFunction(target)) {
+ target = {};
+ }
+
+ // extend jQuery itself if only one argument is passed
+ if (length === i) {
+ /* jshint validthis: true */
+ target = this;
+ --i;
+ }
+
+ for (; i < length; i++) {
+ // Only deal with non-null/undefined values
+ if ((options = arguments[i]) != null) {
+ // Extend the base object
+ for (name in options) {
+ //if (options.hasOwnProperty(name)) {
+ if (!(name in Object.prototype)) {
+
+ src = target[name];
+ copy = options[name];
+
+ // Prevent never-ending loop
+ if (target === copy) {
+ continue;
+ }
+
+ // Recurse if we're merging plain objects or arrays
+ if (deep && copy && (isPlainObject(copy) ||
+ (copyIsArray = isArray(copy)))) {
+ if (copyIsArray) {
+ copyIsArray = false;
+ clone = src && isArray(src) ? src : [];
+
+ } else {
+ clone = src && isPlainObject(src) ? src : {};
+ }
+
+ // Never move original objects, clone them
+ target[name] = extend(deep, clone, copy);
+
+ // Don't bring in undefined values
+ } else if (copy !== undefined) {
+ if (!(isArray(options) && isFunction(copy))) {
+ target[name] = copy;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Return the modified object
+ return target;
+}
+
+
+module.exports = extend;
+
+
+
+},{}],96:[function(require,module,exports){
+/*jshint bitwise:false*/
+/*global unescape*/
+
+(function (factory) {
+ if (typeof exports === 'object') {
+ // Node/CommonJS
+ module.exports = factory();
+ } else if (typeof define === 'function' && define.amd) {
+ // AMD
+ define(factory);
+ } else {
+ // Browser globals (with support for web workers)
+ var glob;
+ try {
+ glob = window;
+ } catch (e) {
+ glob = self;
+ }
+
+ glob.SparkMD5 = factory();
+ }
+}(function (undefined) {
+
+ 'use strict';
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ /*
+ * Fastest md5 implementation around (JKM md5)
+ * Credits: Joseph Myers
+ *
+ * @see http://www.myersdaily.org/joseph/javascript/md5-text.html
+ * @see http://jsperf.com/md5-shootout/7
+ */
+
+ /* this function is much faster,
+ so if possible we use it. Some IEs
+ are the only ones I know of that
+ need the idiotic second function,
+ generated by an if clause. */
+ var add32 = function (a, b) {
+ return (a + b) & 0xFFFFFFFF;
+ },
+
+ cmn = function (q, a, b, x, s, t) {
+ a = add32(add32(a, q), add32(x, t));
+ return add32((a << s) | (a >>> (32 - s)), b);
+ },
+
+ ff = function (a, b, c, d, x, s, t) {
+ return cmn((b & c) | ((~b) & d), a, b, x, s, t);
+ },
+
+ gg = function (a, b, c, d, x, s, t) {
+ return cmn((b & d) | (c & (~d)), a, b, x, s, t);
+ },
+
+ hh = function (a, b, c, d, x, s, t) {
+ return cmn(b ^ c ^ d, a, b, x, s, t);
+ },
+
+ ii = function (a, b, c, d, x, s, t) {
+ return cmn(c ^ (b | (~d)), a, b, x, s, t);
+ },
+
+ md5cycle = function (x, k) {
+ var a = x[0],
+ b = x[1],
+ c = x[2],
+ d = x[3];
+
+ a = ff(a, b, c, d, k[0], 7, -680876936);
+ d = ff(d, a, b, c, k[1], 12, -389564586);
+ c = ff(c, d, a, b, k[2], 17, 606105819);
+ b = ff(b, c, d, a, k[3], 22, -1044525330);
+ a = ff(a, b, c, d, k[4], 7, -176418897);
+ d = ff(d, a, b, c, k[5], 12, 1200080426);
+ c = ff(c, d, a, b, k[6], 17, -1473231341);
+ b = ff(b, c, d, a, k[7], 22, -45705983);
+ a = ff(a, b, c, d, k[8], 7, 1770035416);
+ d = ff(d, a, b, c, k[9], 12, -1958414417);
+ c = ff(c, d, a, b, k[10], 17, -42063);
+ b = ff(b, c, d, a, k[11], 22, -1990404162);
+ a = ff(a, b, c, d, k[12], 7, 1804603682);
+ d = ff(d, a, b, c, k[13], 12, -40341101);
+ c = ff(c, d, a, b, k[14], 17, -1502002290);
+ b = ff(b, c, d, a, k[15], 22, 1236535329);
+
+ a = gg(a, b, c, d, k[1], 5, -165796510);
+ d = gg(d, a, b, c, k[6], 9, -1069501632);
+ c = gg(c, d, a, b, k[11], 14, 643717713);
+ b = gg(b, c, d, a, k[0], 20, -373897302);
+ a = gg(a, b, c, d, k[5], 5, -701558691);
+ d = gg(d, a, b, c, k[10], 9, 38016083);
+ c = gg(c, d, a, b, k[15], 14, -660478335);
+ b = gg(b, c, d, a, k[4], 20, -405537848);
+ a = gg(a, b, c, d, k[9], 5, 568446438);
+ d = gg(d, a, b, c, k[14], 9, -1019803690);
+ c = gg(c, d, a, b, k[3], 14, -187363961);
+ b = gg(b, c, d, a, k[8], 20, 1163531501);
+ a = gg(a, b, c, d, k[13], 5, -1444681467);
+ d = gg(d, a, b, c, k[2], 9, -51403784);
+ c = gg(c, d, a, b, k[7], 14, 1735328473);
+ b = gg(b, c, d, a, k[12], 20, -1926607734);
+
+ a = hh(a, b, c, d, k[5], 4, -378558);
+ d = hh(d, a, b, c, k[8], 11, -2022574463);
+ c = hh(c, d, a, b, k[11], 16, 1839030562);
+ b = hh(b, c, d, a, k[14], 23, -35309556);
+ a = hh(a, b, c, d, k[1], 4, -1530992060);
+ d = hh(d, a, b, c, k[4], 11, 1272893353);
+ c = hh(c, d, a, b, k[7], 16, -155497632);
+ b = hh(b, c, d, a, k[10], 23, -1094730640);
+ a = hh(a, b, c, d, k[13], 4, 681279174);
+ d = hh(d, a, b, c, k[0], 11, -358537222);
+ c = hh(c, d, a, b, k[3], 16, -722521979);
+ b = hh(b, c, d, a, k[6], 23, 76029189);
+ a = hh(a, b, c, d, k[9], 4, -640364487);
+ d = hh(d, a, b, c, k[12], 11, -421815835);
+ c = hh(c, d, a, b, k[15], 16, 530742520);
+ b = hh(b, c, d, a, k[2], 23, -995338651);
+
+ a = ii(a, b, c, d, k[0], 6, -198630844);
+ d = ii(d, a, b, c, k[7], 10, 1126891415);
+ c = ii(c, d, a, b, k[14], 15, -1416354905);
+ b = ii(b, c, d, a, k[5], 21, -57434055);
+ a = ii(a, b, c, d, k[12], 6, 1700485571);
+ d = ii(d, a, b, c, k[3], 10, -1894986606);
+ c = ii(c, d, a, b, k[10], 15, -1051523);
+ b = ii(b, c, d, a, k[1], 21, -2054922799);
+ a = ii(a, b, c, d, k[8], 6, 1873313359);
+ d = ii(d, a, b, c, k[15], 10, -30611744);
+ c = ii(c, d, a, b, k[6], 15, -1560198380);
+ b = ii(b, c, d, a, k[13], 21, 1309151649);
+ a = ii(a, b, c, d, k[4], 6, -145523070);
+ d = ii(d, a, b, c, k[11], 10, -1120210379);
+ c = ii(c, d, a, b, k[2], 15, 718787259);
+ b = ii(b, c, d, a, k[9], 21, -343485551);
+
+ x[0] = add32(a, x[0]);
+ x[1] = add32(b, x[1]);
+ x[2] = add32(c, x[2]);
+ x[3] = add32(d, x[3]);
+ },
+
+ /* there needs to be support for Unicode here,
+ * unless we pretend that we can redefine the MD-5
+ * algorithm for multi-byte characters (perhaps
+ * by adding every four 16-bit characters and
+ * shortening the sum to 32 bits). Otherwise
+ * I suggest performing MD-5 as if every character
+ * was two bytes--e.g., 0040 0025 = @%--but then
+ * how will an ordinary MD-5 sum be matched?
+ * There is no way to standardize text to something
+ * like UTF-8 before transformation; speed cost is
+ * utterly prohibitive. The JavaScript standard
+ * itself needs to look at this: it should start
+ * providing access to strings as preformed UTF-8
+ * 8-bit unsigned value arrays.
+ */
+ md5blk = function (s) {
+ var md5blks = [],
+ i; /* Andy King said do it this way. */
+
+ for (i = 0; i < 64; i += 4) {
+ md5blks[i >> 2] = s.charCodeAt(i) + (s.charCodeAt(i + 1) << 8) + (s.charCodeAt(i + 2) << 16) + (s.charCodeAt(i + 3) << 24);
+ }
+ return md5blks;
+ },
+
+ md5blk_array = function (a) {
+ var md5blks = [],
+ i; /* Andy King said do it this way. */
+
+ for (i = 0; i < 64; i += 4) {
+ md5blks[i >> 2] = a[i] + (a[i + 1] << 8) + (a[i + 2] << 16) + (a[i + 3] << 24);
+ }
+ return md5blks;
+ },
+
+ md51 = function (s) {
+ var n = s.length,
+ state = [1732584193, -271733879, -1732584194, 271733878],
+ i,
+ length,
+ tail,
+ tmp,
+ lo,
+ hi;
+
+ for (i = 64; i <= n; i += 64) {
+ md5cycle(state, md5blk(s.substring(i - 64, i)));
+ }
+ s = s.substring(i - 64);
+ length = s.length;
+ tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+ for (i = 0; i < length; i += 1) {
+ tail[i >> 2] |= s.charCodeAt(i) << ((i % 4) << 3);
+ }
+ tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+ if (i > 55) {
+ md5cycle(state, tail);
+ for (i = 0; i < 16; i += 1) {
+ tail[i] = 0;
+ }
+ }
+
+ // Beware that the final length might not fit in 32 bits so we take care of that
+ tmp = n * 8;
+ tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+ lo = parseInt(tmp[2], 16);
+ hi = parseInt(tmp[1], 16) || 0;
+
+ tail[14] = lo;
+ tail[15] = hi;
+
+ md5cycle(state, tail);
+ return state;
+ },
+
+ md51_array = function (a) {
+ var n = a.length,
+ state = [1732584193, -271733879, -1732584194, 271733878],
+ i,
+ length,
+ tail,
+ tmp,
+ lo,
+ hi;
+
+ for (i = 64; i <= n; i += 64) {
+ md5cycle(state, md5blk_array(a.subarray(i - 64, i)));
+ }
+
+ // Not sure if it is a bug, however IE10 will always produce a sub array of length 1
+ // containing the last element of the parent array if the sub array specified starts
+ // beyond the length of the parent array - weird.
+ // https://connect.microsoft.com/IE/feedback/details/771452/typed-array-subarray-issue
+ a = (i - 64) < n ? a.subarray(i - 64) : new Uint8Array(0);
+
+ length = a.length;
+ tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+ for (i = 0; i < length; i += 1) {
+ tail[i >> 2] |= a[i] << ((i % 4) << 3);
+ }
+
+ tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+ if (i > 55) {
+ md5cycle(state, tail);
+ for (i = 0; i < 16; i += 1) {
+ tail[i] = 0;
+ }
+ }
+
+ // Beware that the final length might not fit in 32 bits so we take care of that
+ tmp = n * 8;
+ tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+ lo = parseInt(tmp[2], 16);
+ hi = parseInt(tmp[1], 16) || 0;
+
+ tail[14] = lo;
+ tail[15] = hi;
+
+ md5cycle(state, tail);
+
+ return state;
+ },
+
+ hex_chr = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'],
+
+ rhex = function (n) {
+ var s = '',
+ j;
+ for (j = 0; j < 4; j += 1) {
+ s += hex_chr[(n >> (j * 8 + 4)) & 0x0F] + hex_chr[(n >> (j * 8)) & 0x0F];
+ }
+ return s;
+ },
+
+ hex = function (x) {
+ var i;
+ for (i = 0; i < x.length; i += 1) {
+ x[i] = rhex(x[i]);
+ }
+ return x.join('');
+ },
+
+ md5 = function (s) {
+ return hex(md51(s));
+ },
+
+
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ /**
+ * SparkMD5 OOP implementation.
+ *
+ * Use this class to perform an incremental md5, otherwise use the
+ * static methods instead.
+ */
+ SparkMD5 = function () {
+ // call reset to init the instance
+ this.reset();
+ };
+
+
+ // In some cases the fast add32 function cannot be used..
+ if (md5('hello') !== '5d41402abc4b2a76b9719d911017c592') {
+ add32 = function (x, y) {
+ var lsw = (x & 0xFFFF) + (y & 0xFFFF),
+ msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+ return (msw << 16) | (lsw & 0xFFFF);
+ };
+ }
+
+
+ /**
+ * Appends a string.
+ * A conversion will be applied if an utf8 string is detected.
+ *
+ * @param {String} str The string to be appended
+ *
+ * @return {SparkMD5} The instance itself
+ */
+ SparkMD5.prototype.append = function (str) {
+ // converts the string to utf8 bytes if necessary
+ if (/[\u0080-\uFFFF]/.test(str)) {
+ str = unescape(encodeURIComponent(str));
+ }
+
+ // then append as binary
+ this.appendBinary(str);
+
+ return this;
+ };
+
+ /**
+ * Appends a binary string.
+ *
+ * @param {String} contents The binary string to be appended
+ *
+ * @return {SparkMD5} The instance itself
+ */
+ SparkMD5.prototype.appendBinary = function (contents) {
+ this._buff += contents;
+ this._length += contents.length;
+
+ var length = this._buff.length,
+ i;
+
+ for (i = 64; i <= length; i += 64) {
+ md5cycle(this._state, md5blk(this._buff.substring(i - 64, i)));
+ }
+
+ this._buff = this._buff.substr(i - 64);
+
+ return this;
+ };
+
+ /**
+ * Finishes the incremental computation, reseting the internal state and
+ * returning the result.
+ * Use the raw parameter to obtain the raw result instead of the hex one.
+ *
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.prototype.end = function (raw) {
+ var buff = this._buff,
+ length = buff.length,
+ i,
+ tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ ret;
+
+ for (i = 0; i < length; i += 1) {
+ tail[i >> 2] |= buff.charCodeAt(i) << ((i % 4) << 3);
+ }
+
+ this._finish(tail, length);
+ ret = !!raw ? this._state : hex(this._state);
+
+ this.reset();
+
+ return ret;
+ };
+
+ /**
+ * Finish the final calculation based on the tail.
+ *
+ * @param {Array} tail The tail (will be modified)
+ * @param {Number} length The length of the remaining buffer
+ */
+ SparkMD5.prototype._finish = function (tail, length) {
+ var i = length,
+ tmp,
+ lo,
+ hi;
+
+ tail[i >> 2] |= 0x80 << ((i % 4) << 3);
+ if (i > 55) {
+ md5cycle(this._state, tail);
+ for (i = 0; i < 16; i += 1) {
+ tail[i] = 0;
+ }
+ }
+
+ // Do the final computation based on the tail and length
+ // Beware that the final length may not fit in 32 bits so we take care of that
+ tmp = this._length * 8;
+ tmp = tmp.toString(16).match(/(.*?)(.{0,8})$/);
+ lo = parseInt(tmp[2], 16);
+ hi = parseInt(tmp[1], 16) || 0;
+
+ tail[14] = lo;
+ tail[15] = hi;
+ md5cycle(this._state, tail);
+ };
+
+ /**
+ * Resets the internal state of the computation.
+ *
+ * @return {SparkMD5} The instance itself
+ */
+ SparkMD5.prototype.reset = function () {
+ this._buff = "";
+ this._length = 0;
+ this._state = [1732584193, -271733879, -1732584194, 271733878];
+
+ return this;
+ };
+
+ /**
+ * Releases memory used by the incremental buffer and other aditional
+ * resources. If you plan to use the instance again, use reset instead.
+ */
+ SparkMD5.prototype.destroy = function () {
+ delete this._state;
+ delete this._buff;
+ delete this._length;
+ };
+
+
+ /**
+ * Performs the md5 hash on a string.
+ * A conversion will be applied if utf8 string is detected.
+ *
+ * @param {String} str The string
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.hash = function (str, raw) {
+ // converts the string to utf8 bytes if necessary
+ if (/[\u0080-\uFFFF]/.test(str)) {
+ str = unescape(encodeURIComponent(str));
+ }
+
+ var hash = md51(str);
+
+ return !!raw ? hash : hex(hash);
+ };
+
+ /**
+ * Performs the md5 hash on a binary string.
+ *
+ * @param {String} content The binary string
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.hashBinary = function (content, raw) {
+ var hash = md51(content);
+
+ return !!raw ? hash : hex(hash);
+ };
+
+ /**
+ * SparkMD5 OOP implementation for array buffers.
+ *
+ * Use this class to perform an incremental md5 ONLY for array buffers.
+ */
+ SparkMD5.ArrayBuffer = function () {
+ // call reset to init the instance
+ this.reset();
+ };
+
+ ////////////////////////////////////////////////////////////////////////////
+
+ /**
+ * Appends an array buffer.
+ *
+ * @param {ArrayBuffer} arr The array to be appended
+ *
+ * @return {SparkMD5.ArrayBuffer} The instance itself
+ */
+ SparkMD5.ArrayBuffer.prototype.append = function (arr) {
+ // TODO: we could avoid the concatenation here but the algorithm would be more complex
+ // if you find yourself needing extra performance, please make a PR.
+ var buff = this._concatArrayBuffer(this._buff, arr),
+ length = buff.length,
+ i;
+
+ this._length += arr.byteLength;
+
+ for (i = 64; i <= length; i += 64) {
+ md5cycle(this._state, md5blk_array(buff.subarray(i - 64, i)));
+ }
+
+ // Avoids IE10 weirdness (documented above)
+ this._buff = (i - 64) < length ? buff.subarray(i - 64) : new Uint8Array(0);
+
+ return this;
+ };
+
+ /**
+ * Finishes the incremental computation, reseting the internal state and
+ * returning the result.
+ * Use the raw parameter to obtain the raw result instead of the hex one.
+ *
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.ArrayBuffer.prototype.end = function (raw) {
+ var buff = this._buff,
+ length = buff.length,
+ tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+ i,
+ ret;
+
+ for (i = 0; i < length; i += 1) {
+ tail[i >> 2] |= buff[i] << ((i % 4) << 3);
+ }
+
+ this._finish(tail, length);
+ ret = !!raw ? this._state : hex(this._state);
+
+ this.reset();
+
+ return ret;
+ };
+
+ SparkMD5.ArrayBuffer.prototype._finish = SparkMD5.prototype._finish;
+
+ /**
+ * Resets the internal state of the computation.
+ *
+ * @return {SparkMD5.ArrayBuffer} The instance itself
+ */
+ SparkMD5.ArrayBuffer.prototype.reset = function () {
+ this._buff = new Uint8Array(0);
+ this._length = 0;
+ this._state = [1732584193, -271733879, -1732584194, 271733878];
+
+ return this;
+ };
+
+ /**
+ * Releases memory used by the incremental buffer and other aditional
+ * resources. If you plan to use the instance again, use reset instead.
+ */
+ SparkMD5.ArrayBuffer.prototype.destroy = SparkMD5.prototype.destroy;
+
+ /**
+ * Concats two array buffers, returning a new one.
+ *
+ * @param {ArrayBuffer} first The first array buffer
+ * @param {ArrayBuffer} second The second array buffer
+ *
+ * @return {ArrayBuffer} The new array buffer
+ */
+ SparkMD5.ArrayBuffer.prototype._concatArrayBuffer = function (first, second) {
+ var firstLength = first.length,
+ result = new Uint8Array(firstLength + second.byteLength);
+
+ result.set(first);
+ result.set(new Uint8Array(second), firstLength);
+
+ return result;
+ };
+
+ /**
+ * Performs the md5 hash on an array buffer.
+ *
+ * @param {ArrayBuffer} arr The array buffer
+ * @param {Boolean} raw True to get the raw result, false to get the hex result
+ *
+ * @return {String|Array} The result
+ */
+ SparkMD5.ArrayBuffer.hash = function (arr, raw) {
+ var hash = md51_array(new Uint8Array(arr));
+
+ return !!raw ? hash : hex(hash);
+ };
+
+ return SparkMD5;
+}));
+
+},{}],97:[function(require,module,exports){
+arguments[4][61][0].apply(exports,arguments)
+},{"./_stream_readable":98,"./_stream_writable":100,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"core-util-is":101,"inherits":33}],98:[function(require,module,exports){
+module.exports=require(63)
+},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"core-util-is":101,"events":18,"inherits":33,"isarray":102,"stream":24,"string_decoder/":103}],99:[function(require,module,exports){
+arguments[4][64][0].apply(exports,arguments)
+},{"./_stream_duplex":97,"core-util-is":101,"inherits":33}],100:[function(require,module,exports){
+arguments[4][65][0].apply(exports,arguments)
+},{"./_stream_duplex":97,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"buffer":20,"core-util-is":101,"inherits":33,"stream":24}],101:[function(require,module,exports){
+module.exports=require(66)
+},{"buffer":20}],102:[function(require,module,exports){
+module.exports=require(67)
+},{}],103:[function(require,module,exports){
+module.exports=require(68)
+},{"buffer":20}],104:[function(require,module,exports){
+module.exports = require("./lib/_stream_transform.js")
+
+},{"./lib/_stream_transform.js":99}],105:[function(require,module,exports){
+module.exports=require(40)
+},{}],106:[function(require,module,exports){
+arguments[4][41][0].apply(exports,arguments)
+},{"./has-keys":105,"object-keys":108}],107:[function(require,module,exports){
+var hasOwn = Object.prototype.hasOwnProperty;
+var toString = Object.prototype.toString;
+
+var isFunction = function (fn) {
+ var isFunc = (typeof fn === 'function' && !(fn instanceof RegExp)) || toString.call(fn) === '[object Function]';
+ if (!isFunc && typeof window !== 'undefined') {
+ isFunc = fn === window.setTimeout || fn === window.alert || fn === window.confirm || fn === window.prompt;
+ }
+ return isFunc;
+};
+
+module.exports = function forEach(obj, fn) {
+ if (!isFunction(fn)) {
+ throw new TypeError('iterator must be a function');
+ }
+ var i, k,
+ isString = typeof obj === 'string',
+ l = obj.length,
+ context = arguments.length > 2 ? arguments[2] : null;
+ if (l === +l) {
+ for (i = 0; i < l; i++) {
+ if (context === null) {
+ fn(isString ? obj.charAt(i) : obj[i], i, obj);
+ } else {
+ fn.call(context, isString ? obj.charAt(i) : obj[i], i, obj);
+ }
+ }
+ } else {
+ for (k in obj) {
+ if (hasOwn.call(obj, k)) {
+ if (context === null) {
+ fn(obj[k], k, obj);
+ } else {
+ fn.call(context, obj[k], k, obj);
+ }
+ }
+ }
+ }
+};
+
+
+},{}],108:[function(require,module,exports){
+arguments[4][42][0].apply(exports,arguments)
+},{"./shim":110}],109:[function(require,module,exports){
+var toString = Object.prototype.toString;
+
+module.exports = function isArguments(value) {
+ var str = toString.call(value);
+ var isArguments = str === '[object Arguments]';
+ if (!isArguments) {
+ isArguments = str !== '[object Array]'
+ && value !== null
+ && typeof value === 'object'
+ && typeof value.length === 'number'
+ && value.length >= 0
+ && toString.call(value.callee) === '[object Function]';
+ }
+ return isArguments;
+};
+
+
+},{}],110:[function(require,module,exports){
+(function () {
+ "use strict";
+
+ // modified from https://github.com/kriskowal/es5-shim
+ var has = Object.prototype.hasOwnProperty,
+ toString = Object.prototype.toString,
+ forEach = require('./foreach'),
+ isArgs = require('./isArguments'),
+ hasDontEnumBug = !({'toString': null}).propertyIsEnumerable('toString'),
+ hasProtoEnumBug = (function () {}).propertyIsEnumerable('prototype'),
+ dontEnums = [
+ "toString",
+ "toLocaleString",
+ "valueOf",
+ "hasOwnProperty",
+ "isPrototypeOf",
+ "propertyIsEnumerable",
+ "constructor"
+ ],
+ keysShim;
+
+ keysShim = function keys(object) {
+ var isObject = object !== null && typeof object === 'object',
+ isFunction = toString.call(object) === '[object Function]',
+ isArguments = isArgs(object),
+ theKeys = [];
+
+ if (!isObject && !isFunction && !isArguments) {
+ throw new TypeError("Object.keys called on a non-object");
+ }
+
+ if (isArguments) {
+ forEach(object, function (value) {
+ theKeys.push(value);
+ });
+ } else {
+ var name,
+ skipProto = hasProtoEnumBug && isFunction;
+
+ for (name in object) {
+ if (!(skipProto && name === 'prototype') && has.call(object, name)) {
+ theKeys.push(name);
+ }
+ }
+ }
+
+ if (hasDontEnumBug) {
+ var ctor = object.constructor,
+ skipConstructor = ctor && ctor.prototype === object;
+
+ forEach(dontEnums, function (dontEnum) {
+ if (!(skipConstructor && dontEnum === 'constructor') && has.call(object, dontEnum)) {
+ theKeys.push(dontEnum);
+ }
+ });
+ }
+ return theKeys;
+ };
+
+ module.exports = keysShim;
+}());
+
+
+},{"./foreach":107,"./isArguments":109}],111:[function(require,module,exports){
+var Transform = require('readable-stream/transform')
+ , inherits = require('util').inherits
+ , xtend = require('xtend')
+
+
+// a noop _transform function
+function noop (chunk, enc, callback) {
+ callback(null, chunk)
+}
+
+
+// create a new export function, used by both the main export and
+// the .ctor export, contains common logic for dealing with arguments
+function through2 (construct) {
+ return function (options, transform, flush) {
+ if (typeof options == 'function') {
+ flush = transform
+ transform = options
+ options = {}
+ }
+
+ if (typeof transform != 'function')
+ transform = noop
+
+ if (typeof flush != 'function')
+ flush = null
+
+ return construct(options, transform, flush)
+ }
+}
+
+
+// main export, just make me a transform stream!
+module.exports = through2(function (options, transform, flush) {
+ var t2 = new Transform(options)
+
+ t2._transform = transform
+
+ if (flush)
+ t2._flush = flush
+
+ return t2
+})
+
+
+// make me a reusable prototype that I can `new`, or implicitly `new`
+// with a constructor call
+module.exports.ctor = through2(function (options, transform, flush) {
+ function Through2 (override) {
+ if (!(this instanceof Through2))
+ return new Through2(override)
+
+ this.options = xtend(options, override)
+
+ Transform.call(this, this.options)
+ }
+
+ inherits(Through2, Transform)
+
+ Through2.prototype._transform = transform
+
+ if (flush)
+ Through2.prototype._flush = flush
+
+ return Through2
+})
+
+
+module.exports.obj = through2(function (options, transform, flush) {
+ var t2 = new Transform(xtend({ objectMode: true }, options))
+
+ t2._transform = transform
+
+ if (flush)
+ t2._flush = flush
+
+ return t2
+})
+
+},{"readable-stream/transform":104,"util":32,"xtend":106}]},{},[11])
\ No newline at end of file
diff --git a/dist/pouchdb.memory.min.js b/dist/pouchdb.memory.min.js
new file mode 100644
index 0000000..e6e6da3
--- /dev/null
+++ b/dist/pouchdb.memory.min.js
@@ -0,0 +1,13 @@
+// PouchDB in-memory plugin 3.0.1
+// Based on MemDOWN: https://github.com/rvagg/memdown
+//
+// (c) 2012-2014 Dale Harvey and the PouchDB team
+// PouchDB may be freely distributed under the Apache license, version 2.0.
+// For all details and documentation:
+// http://pouchdb.com
+require=function e(t,n,r){function i(s,a){if(!n[s]){if(!t[s]){var u="function"==typeof require&&require;if(!a&&u)return u(s,!0);if(o)return o(s,!0);throw new Error("Cannot find module '"+s+"'")}var c=n[s]={exports:{}};t[s][0].call(c.exports,function(e){var n=t[s][1][e];return i(n?n:e)},c,c.exports,e,t,n,r)}return n[s].exports}for(var o="function"==typeof require&&require,s=0;s<r.length;s++)i(r[s]);return i}({1:[function(e,t){(function(n,r,i){"use strict";function o(e,t){function x(){B.docStore=C.sublevel(p,{valueEncoding:"json"}),B.bySeqStore=C.sublevel(g,{valueEncoding:"json"}),B.attachmentStore=C.sublevel(v,{valueEncoding:"json"}),B.binaryStore=C.sublevel(b,{valueEncoding:"binary"}),B.localStore=C.sublevel(y,{valueEncoding:"json"}),B.metaStore=C.sublevel(m,{valueEncoding:"json"}),h.localAndMetaStores(C,B,function(){B.metaStore.get(E,function(e,r){"undefined"==typeof C._updateSeq&&(C._updateSeq=r||0),B.metaStore.get(k,function(e,r){C._docCountQueue.docCount=e?0:r,j(function(e){e&&N.emit("error",e),B.metaStore.get(S,function(e,r){T=e?d.uuid():r,B.metaStore.put(S,T,function(){n.nextTick(function(){t(null,N)})})})})})})})}function j(e){return C._docCountQueue.running||!C._docCountQueue.queue.length||-1===C._docCountQueue.docCount?L(0,e):C._docCountQueue.docCount}function O(){if(!C._docCountQueue.running&&C._docCountQueue.queue.length&&-1!==C._docCountQueue.docCount){C._docCountQueue.running=!0;var e=C._docCountQueue.queue.shift();return C.isClosed()?e.callback(new Error("database is closed")):void B.metaStore.get(k,function(t,n){function r(t){C._docCountQueue.docCount=n,e.callback(t,n),C._docCountQueue.running=!1,O()}n=t?0:n,0===e.delta?r():B.metaStore.put(k,n+e.delta,r)})}}function L(e,t){C._docCountQueue.queue.push({delta:e,callback:t}),O()}function A(e){return("0000000000000000"+e).slice(-16)}function I(e){return parseInt(e,10)}function R(e,t){var n=e.data;if(n._id=e.metadata.id,"_rev"in n){if(n._rev!==e.metadata.rev)return t(new Error("wrong doc returned"))}else n._rev=e.metadata.rev;t(null,{doc:n,metadata:e.metadata})}e=d.clone(e);var T,C,N=this,B={},D=e.name;"undefined"==typeof e.createIfMissing&&(e.createIfMissing=!0);var M=e.db||a;"function"!=typeof M.destroy&&(M.destroy=function(e,t){t()});var U;w.has(M.name)?U=w.get(M.name):(U=new d.Map,w.set(M.name,U)),U.has(D)?(C=U.get(D),x()):U.set(D,u(s(D,e,function(n){return n?(U["delete"](D),t(n)):(C=U.get(D),C._locks=C._locks||new d.Set,C._docCountQueue={queue:[],running:!1,docCount:-1},void(e.db||e.noMigrate?x():h.toSublevel(D,C,x)))}))),N.type=function(){return"leveldb"},N._id=function(e){e(null,T)},N._info=function(e){j(function(t,n){return t?e(t):void B.metaStore.get(E,function(t,r){return t&&(r=C._updateSeq),e(null,{doc_count:n,update_seq:r})})})},N._get=function(e,t,n){function r(e){i.push(e)}t=d.clone(t);var i=[];C.on("pouchdb-id-"+e,r),B.docStore.get(e,function(o,s){function a(e){u=e}if(C.removeListener("pouchdb-id-"+e,r),o||!s)return n(l.MISSING_DOC);if(d.isDeleted(s)&&!t.rev)return n(l.error(l.MISSING_DOC,"deleted"));var u,c=f.winningRev(s);c=t.rev?t.rev:c;var h=s.rev_map[c],p=i.filter(function(e){return e.metadata.seq===h});return p.length?R(p.pop(),n):(C.on("pouchdb-"+h,a),void B.bySeqStore.get(A(h),function(e,t){if(C.removeListener("pouchdb-"+h,a),u)return R(u,n);if(!t)return n(l.MISSING_DOC);if("_id"in t&&t._id!==s.id)return n(new Error("wrong doc returned"));if(t._id=s.id,"_rev"in t){if(t._rev!==c)return n(new Error("wrong doc returned"))}else t._rev=c;return n(null,{doc:t,metadata:s})}))})},N._getAttachment=function(e,t,o){var s=e.digest;B.binaryStore.get(s,function(s,a){var u;return s&&"NotFoundError"===s.name?(u=t.encode?"":n.browser?d.createBlob([""],{type:e.content_type}):new i(""),o(null,u)):s?o(s):(u=n.browser?t.encode?d.btoa(r.unescape(a)):d.createBlob([d.fixBinary(r.unescape(a))],{type:e.content_type}):t.encode?d.btoa(a):a,void o(null,u))})},N.lock=function(e){return C._locks.has(e)?!1:(C._locks.add(e),!0)},N.unlock=function(e){return C._locks.has(e)?(C._locks["delete"](e),!0):!1},N._bulkDocs=function(e,t,i){function s(){var e=w;if(!(S>_)){if(e>=m.length)return 0===S?p():void 0;var t=m[e];if(w++,S++,t._id&&d.isLocalId(t._id))return void N[t._deleted?"_removeLocal":"_putLocal"](t,function(t){b[e]=t?t:{},S--,s()});B.docStore.get(t.metadata.id,function(n,r){return N.lock(t.metadata.id)?void(n?"NotFoundError"===n.name?a(t,e,function(){N.unlock(t.metadata.id),S--,s()}):(n.error=!0,b[e]=n,N.unlock(t.metadata.id),S--,s()):u(r,t,e,function(){N.unlock(t.metadata.id),S--,s()})):(b[e]=g(l.REV_CONFLICT,"someobody else is accessing this"),S--,s())}),v&&s()}}function a(e,n,r){return"was_delete"in t&&d.isDeleted(e.metadata)?(b[n]=g(l.MISSING_DOC,e._bulk_seq),r()):void c(e,n,function(t){return t?r(t):d.isDeleted(e.metadata)?r():void L(1,r)})}function u(e,t,n,r){var i=f.merge(e.rev_tree,t.metadata.rev_tree[0],1e3),o=d.isDeleted(e)&&d.isDeleted(t.metadata)&&v||!d.isDeleted(e)&&v&&"new_leaf"!==i.conflicts;if(o)return b[n]=g(l.REV_CONFLICT,t._bulk_seq),r();t.metadata.rev_tree=i.tree,t.metadata.rev_map=e.rev_map;var s=0,a=d.isDeleted(e),u=d.isDeleted(t.metadata);s=a===u?0:u>a?-1:1,L(s,function(e){return e?r(e):void c(t,n,r)})}function c(e,t,o){function s(e){p||(e?(p=e,o(p)):g===v.length&&f())}function a(e){g++,s(e)}function u(e,t,n,r,i){return function(o){h(e,t+o,n,r,i)}}function c(e,t,n,i){return function(o){var s=r.escape(d.arrayBufferToBinaryString(o.target.result));d.MD5(s).then(u(e,t,n,s,i))}}function f(){var n=e.metadata.rev_map[e.metadata.rev];n||(n=++C._updateSeq),e.metadata.rev_map[e.metadata.rev]=e.metadata.seq=n;var r=A(n);C.emit("pouchdb-id-"+e.metadata.id,e),C.emit("pouchdb-"+r,e),C.batch([{key:r,value:e.data,prefix:B.bySeqStore,type:"put",valueEncoding:"json"},{key:e.metadata.id,value:e.metadata,prefix:B.docStore,type:"put",valueEncoding:"json"}],function(n){return n||(C.emit("pouchdb-id-"+e.metadata.id,e),C.emit("pouchdb-"+r,e)),B.metaStore.put(E,C._updateSeq,function(n){return b[t]=n?n:e,o()})})}var p=null,g=0;e.data._id=e.metadata.id,e.data._rev=e.metadata.rev,d.isDeleted(e.metadata)&&(e.data._deleted=!0);for(var v=e.data._attachments?Object.keys(e.data._attachments):[],y=0;y<v.length;y++){var m=v[y];if(e.data._attachments[m].stub)g++,s();else{var _,w,k=e.data._attachments[m];if("string"==typeof k.data){try{_=d.atob(k.data),n.browser&&(_=r.escape(_))}catch(S){return void i(d.extend({},l.BAD_ARG,{reason:"Attachments need to be base64 encoded"}))}w=n.browser?"md5-":""}else{if(n.browser){var x=new FileReader;return x.onloadend=c(e,"md5-",m,a),void x.readAsArrayBuffer(k.data)}_=k.data,w=""}d.MD5(_).then(u(e,w,m,_,a))}}v.length||f()}function h(e,t,n,r,i){delete e.data._attachments[n].data,e.data._attachments[n].digest=t,B.attachmentStore.get(t,function(n,o){if(n&&"NotFoundError"!==n.name)return i(n);var s=[e.metadata.id,e.metadata.rev].join("@"),a={};o?o.refs&&(a.refs=o.refs,a.refs[s]=!0):(a.refs={},a.refs[s]=!0),B.attachmentStore.put(t,a,function(e){return 0===r.length?i(e):void B.binaryStore.put(t,r,function(e){i(e)})})})}function p(){b.sort(function(e,t){return e._bulk_seq-t._bulk_seq});var e=b.map(function(e){if(e._bulk_seq)delete e._bulk_seq;else if(!Object.keys(e).length)return{ok:!0};if(e.error)return e;var t=e.metadata,n=f.winningRev(t);return{ok:!0,id:t.id,rev:n}});o.Changes.notify(D),n.nextTick(function(){i(null,e)})}function g(e,t){return e._bulk_seq=t,e}var v=t.new_edits,b=new Array(e.docs.length),y=e.docs,m=y.map(function(e,t){if(e._id&&d.isLocalId(e._id))return e;var n=d.parseDoc(e,v);return n._bulk_seq=t,n.metadata&&!n.metadata.rev_map&&(n.metadata.rev_map={}),n}),w=0,k=m.filter(function(e){return e.error});if(k.length)return i(k[0]);var S=0;s()},N._allDocs=function(e,t){e=d.clone(e),j(function(n,r){if(n)return t(n);var i={},o=e.skip||0;if(e.startkey&&(i.start=e.startkey),e.endkey&&(i.end=e.endkey),e.key&&(i.start=i.end=e.key),e.descending){i.reverse=!0;var s=i.start;i.start=i.end,i.end=s}var a;if(a="number"==typeof e.limit?e.limit:-1,0===a||"start"in i&&"end"in i&&i.start>i.end)return t(null,{total_rows:r,offset:e.skip,rows:[]});var u=[],l=B.docStore.readStream(i),h=c(function(t,n,r){function i(t,n){var i={id:t.id,key:t.id,value:{rev:f.winningRev(t)}};if(e.include_docs){i.doc=n,i.doc._rev=i.value.rev,e.conflicts&&(i.doc._conflicts=f.collectConflicts(t));for(var o in i.doc._attachments)i.doc._attachments.hasOwnProperty(o)&&(i.doc._attachments[o].stub=!0)}if(e.inclusive_end===!1&&t.id===e.endkey)return r();if(d.isDeleted(t)){if("ok"!==e.deleted)return r();i.value.deleted=!0,i.doc=null}u.push(i),r()}if(d.isDeleted(t.value)){if("ok"!==e.deleted)return void r()}else{if(o-->0)return void r();if(0===a--)return l.unpipe(),l.destroy(),void r()}var s=t.value;if(e.include_docs){var c=s.rev_map[f.winningRev(s)];B.bySeqStore.get(A(c),function(e,t){i(s,t)})}else i(s)},function(n){t(null,{total_rows:r,offset:e.skip,rows:u}),n()}).on("unpipe",function(){h.end()});l.on("error",t),l.pipe(h)})},N._changes=function(e){function t(){e.done=!0,h&&e.limit&&e.limit<s.length&&(s.length=e.limit),g.unpipe(v),g.destroy(),e.continuous||e.cancelled||e.complete(null,{results:s,last_seq:a})}if(e=d.clone(e),e.continuous){var n=D+":"+d.uuid();return o.Changes.addListener(D,n,N,e),o.Changes.notify(D),{cancel:function(){o.Changes.removeListener(D,n)}}}var r,i=e.descending,s=[],a=0,u=0,l={reverse:i};"limit"in e&&e.limit>0&&(r=e.limit),l.reverse||(l.start=A(e.since?e.since+1:0));var h,p=d.filterChange(e);h="returnDocs"in e?e.returnDocs:!0;var g=B.bySeqStore.readStream(l),v=c(function(n,i,o){return r&&u>=r?(t(),o()):e.cancelled||e.done?o():void B.docStore.get(n.value._id,function(t,r){if(e.cancelled||e.done||C.isClosed()||d.isLocalId(r.id))return o();var i=n.value;i._rev=f.winningRev(r);var c=e.processChange(i,r,e);c.seq=r.seq,a<r.seq&&(a=r.seq),I(n.key)===r.rev_map[c.doc._rev]&&p(c)&&(u++,d.call(e.onChange,c),h&&s.push(c)),o()})},function(t){return e.cancelled?t():(h&&e.limit&&e.limit<s.length&&(s.length=e.limit),void t())}).on("unpipe",function(){v.end(),t()});return g.pipe(v),{cancel:function(){e.cancelled=!0,t()}}},N._close=function(e){return C.isClosed()?e(l.NOT_OPEN):void C.close(function(t){t?e(t):(U["delete"](D),e())})},N._getRevisionTree=function(e,t){B.docStore.get(e,function(e,n){e?t(l.MISSING_DOC):t(null,n.rev_tree)})},N._doCompaction=function(e,t,n,r){B.docStore.get(e,function(e,i){if(e)return r(e);var o=i.rev_map;i.rev_tree=t,n.length||r();var s=[];s.push({key:i.id,value:i,type:"put",valueEncoding:"json",prefix:B.docStore}),n.forEach(function(e){var t=o[e];t&&s.push({key:A(t),type:"del",prefix:B.bySeqStore})}),C.batch(s,r)})},N._getLocal=function(e,t){B.localStore.get(e,function(e,n){e?t(l.MISSING_DOC):t(null,n)})},N._putLocal=function(e,t){var n=e._rev,r=e._id;B.localStore.get(r,function(i,o){return i&&n?t(l.REV_CONFLICT):o&&o._rev!==n?t(l.REV_CONFLICT):(e._rev=n?"0-"+(parseInt(n.split("-")[1],10)+1):"0-0",void B.localStore.put(r,e,function(n){if(n)return t(n);var r={ok:!0,id:e._id,rev:e._rev};t(null,r)}))})},N._removeLocal=function(e,t){B.localStore.get(e._id,function(n,r){return n?t(n):r._rev!==e._rev?t(l.REV_CONFLICT):void B.localStore.del(e._id,function(n){if(n)return t(n);var r={ok:!0,id:e._id,rev:"0-0"};t(null,r)})})}}var s=e("levelup"),a=e("leveldown"),u=e("level-sublevel"),c=e("through2").obj,l=e("../deps/errors"),f=e("../merge"),d=e("../utils"),h=e("../deps/migrate"),p="document-store",g="by-sequence",v="attach-store",b="attach-binary-store",y="local-store",m="meta-store",_=50,w=new d.Map,E="_local_last_update_seq",k="_local_doc_count",S="_local_uuid";o.valid=function(){return n&&!n.browser},o.destroy=d.toPromise(function(e,t,r){function i(e,t){"function"==typeof u.destroy?u.destroy(e,t):n.nextTick(r)}t=d.clone(t);var s,u=t.db||a;return w.has(u.name)?(s=w.get(u.name),void(s.has(e)?(o.Changes.removeAllListeners(e),s.get(e).close(function(){s["delete"](e),i(e,r)})):i(e,r))):i(e,r)}),o.use_prefix=!1,o.Changes=new d.Changes,t.exports=o}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{},e("buffer").Buffer)},{"../deps/errors":5,"../deps/migrate":"JpIkFB","../merge":8,"../utils":15,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,"level-sublevel":35,leveldown:"RQL87X",levelup:49,through2:111}],2:[function(e,t){"use strict";function n(e,t){function n(t,n,r){if(e.binary||e.json||!e.processData||"string"==typeof t){if(!e.binary&&e.json&&"string"==typeof t)try{t=JSON.parse(t)}catch(i){return r(i)}}else t=JSON.stringify(t);Array.isArray(t)&&(t=t.map(function(e){var t;return e.ok?e:e.error&&"conflict"===e.error?(t=o.REV_CONFLICT,t.id=e.id,t):e.error&&"forbidden"===e.error?(t=o.FORBIDDEN,t.id=e.id,t.reason=e.reason,t):e.missing?(t=o.MISSING_DOC,t.missing=e.missing,t):e})),r(null,t,n)}function a(e,t){var n,r,i,s;try{n=JSON.parse(e.responseText);for(s in o)if(o.hasOwnProperty(s)&&o[s].name===n.error){i=o[s];break}i||(i=o.UNKNOWN_ERROR,e.status&&(i.status=e.status),e.statusText&&(e.name=e.statusText)),r=o.error(i,n.reason)}catch(a){for(var s in o)if(o.hasOwnProperty(s)&&o[s].status===e.status){i=o[s];break}i||(i=o.UNKNOWN_ERROR,e.status&&(i.status=e.status),e.statusText&&(e.name=e.statusText)),r=o.error(i)}e.withCredentials&&0===e.status&&(r.status=405,r.statusText="Method Not Allowed"),t(r)}var u=!1,c=s.getArguments(function(e){u||(t.apply(this,e),u=!0)});"function"==typeof e&&(c=e,e={}),e=s.clone(e);var l={method:"GET",headers:{},json:!0,processData:!0,timeout:1e4,cache:!1};if(e=s.extend(!0,l,e),"GET"===e.method&&!e.cache){var f=-1!==e.url.indexOf("?");e.url+=(f?"&":"?")+"_nonce="+s.uuid(16)}var d,h;h=e.xhr?new e.xhr:new XMLHttpRequest,h.open(e.method,e.url),h.withCredentials=!0,e.json&&(e.headers.Accept="application/json",e.headers["Content-Type"]=e.headers["Content-Type"]||"application/json",e.body&&e.processData&&"string"!=typeof e.body&&(e.body=JSON.stringify(e.body))),e.binary&&(h.responseType="arraybuffer");var p=function(e,t,n){var r="";if(n){var i=new Date;i.setTime(i.getTime()+24*n*60*60*1e3),r="; expires="+i.toGMTString()}document.cookie=e+"="+t+r+"; path=/"};for(var g in e.headers)if("Cookie"===g){var v=e.headers[g].split("=");p(v[0],v[1],10)}else h.setRequestHeader(g,e.headers[g]);"body"in e||(e.body=null);var b=function(){u||(h.abort(),a(h,c))};if(h.onreadystatechange=function(){if(4===h.readyState&&!u)if(clearTimeout(d),h.status>=200&&h.status<300){var t;t=e.binary?i([h.response||""],{type:h.getResponseHeader("Content-Type")}):h.responseText,n(t,h,c)}else a(h,c)},e.timeout>0&&(d=setTimeout(b,e.timeout),h.onprogress=function(){clearTimeout(d),d=setTimeout(b,e.timeout)},"undefined"==typeof r&&(r=-1!==Object.keys(h).indexOf("upload")),r&&(h.upload.onprogress=h.onprogress)),e.body&&e.body instanceof Blob){var y=new FileReader;y.onloadend=function(){for(var e="",t=new Uint8Array(this.result),n=t.byteLength,r=0;n>r;r++)e+=String.fromCharCode(t[r]);e=s.fixBinary(e),h.send(e)},y.readAsArrayBuffer(e.body)}else h.send(e.body);return{abort:b}}var r,i=e("./blob.js"),o=e("./errors"),s=e("../utils");t.exports=n},{"../utils":15,"./blob.js":3,"./errors":5}],3:[function(e,t){(function(e){"use strict";function n(t,n){t=t||[],n=n||{};try{return new Blob(t,n)}catch(r){if("TypeError"!==r.name)throw r;for(var i=e.BlobBuilder||e.MSBlobBuilder||e.MozBlobBuilder||e.WebKitBlobBuilder,o=new i,s=0;s<t.length;s+=1)o.append(t[s]);return o.getBlob(n.type)}}t.exports=n}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],4:[function(e,t,n){"use strict";function r(){this.store={}}function i(){this.store=new r}n.Map=r,n.Set=i,r.prototype.mangle=function(e){if("string"!=typeof e)throw new TypeError("key must be a string but Got "+e);return"$"+e},r.prototype.unmangle=function(e){return e.substring(1)},r.prototype.get=function(e){var t=this.mangle(e);return t in this.store?this.store[t]:void 0},r.prototype.set=function(e,t){var n=this.mangle(e);return this.store[n]=t,!0},r.prototype.has=function(e){var t=this.mangle(e);return t in this.store},r.prototype["delete"]=function(e){var t=this.mangle(e);return t in this.store?(delete this.store[t],!0):!1},r.prototype.forEach=function(e){var t=this,n=Object.keys(t.store);n.forEach(function(n){var r=t.store[n];n=t.unmangle(n),e(r,n)})},i.prototype.add=function(e){return this.store.set(e,!0)},i.prototype.has=function(e){return this.store.has(e)},i.prototype["delete"]=function(e){return this.store["delete"](e)}},{}],5:[function(e,t,n){"use strict";function r(e){this.status=e.status,this.name=e.error,this.message=e.reason,this.error=!0}r.prototype__proto__=Error.prototype,r.prototype.toString=function(){return JSON.stringify({status:this.status,name:this.name,message:this.message})},n.UNAUTHORIZED=new r({status:401,error:"unauthorized",reason:"Name or password is incorrect."}),n.MISSING_BULK_DOCS=new r({status:400,error:"bad_request",reason:"Missing JSON list of 'docs'"}),n.MISSING_DOC=new r({status:404,error:"not_found",reason:"missing"}),n.REV_CONFLICT=new r({status:409,error:"conflict",reason:"Document update conflict"}),n.INVALID_ID=new r({status:400,error:"invalid_id",reason:"_id field must contain a string"}),n.MISSING_ID=new r({status:412,error:"missing_id",reason:"_id is required for puts"}),n.RESERVED_ID=new r({status:400,error:"bad_request",reason:"Only reserved document ids may start with underscore."}),n.NOT_OPEN=new r({status:412,error:"precondition_failed",reason:"Database not open"}),n.UNKNOWN_ERROR=new r({status:500,error:"unknown_error",reason:"Database encountered an unknown error"}),n.BAD_ARG=new r({status:500,error:"badarg",reason:"Some query argument is invalid"}),n.INVALID_REQUEST=new r({status:400,error:"invalid_request",reason:"Request was invalid"}),n.QUERY_PARSE_ERROR=new r({status:400,error:"query_parse_error",reason:"Some query parameter is invalid"}),n.DOC_VALIDATION=new r({status:500,error:"doc_validation",reason:"Bad special document member"}),n.BAD_REQUEST=new r({status:400,error:"bad_request",reason:"Something wrong with the request"}),n.NOT_AN_OBJECT=new r({status:400,error:"bad_request",reason:"Document must be a JSON object"}),n.DB_MISSING=new r({status:404,error:"not_found",reason:"Database not found"}),n.IDB_ERROR=new r({status:500,error:"indexed_db_went_bad",reason:"unknown"}),n.WSQ_ERROR=new r({status:500,error:"web_sql_went_bad",reason:"unknown"}),n.LDB_ERROR=new r({status:500,error:"levelDB_went_went_bad",reason:"unknown"}),n.FORBIDDEN=new r({status:403,error:"forbidden",reason:"Forbidden by design doc validate_doc_update function"}),n.error=function(e,t,n){function r(){this.message=t,n&&(this.name=n)}return r.prototype=e,new r(t)}},{}],6:[function(e,t){(function(n,r){"use strict";function i(e,t,n){if("function"==typeof e.slice)return e.slice(t,n);t=Math.floor(t||0),n=Math.floor(n||0);var r=e.byteLength;if(t=0>t?Math.max(t+r,0):Math.min(r,t),n=0>n?Math.max(n+r,0):Math.min(r,n),0>=n-t)return new ArrayBuffer(0);var i=new ArrayBuffer(n-t),o=new Uint8Array(i),s=new Uint8Array(e,t,n-t);return o.set(s),i}var o=e("crypto"),s=e("spark-md5"),a=r.setImmediate||r.setTimeout;t.exports=function(e,t){function r(){var n=l*u,o=n+u;n+u>=e.size&&(o=e.size),l++,c>l?(f.append(i(e,n,o)),a(r)):(f.append(i(e,n,o)),t(null,f.end()),f.destroy())}if(!n.browser)return void t(null,o.createHash("md5").update(e).digest("hex"));var u=Math.min(524288,e.length),c=Math.ceil(e.length/u),l=0,f=new s;r()}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,crypto:17,"spark-md5":96}],7:[function(e,t){"use strict";function n(e){return 0|Math.random()*e}function r(e,t){t=t||i.length;var r="",o=-1;if(e){for(;++o<e;)r+=i[n(t)];return r}for(;++o<36;)switch(o){case 8:case 13:case 18:case 23:r+="-";break;case 19:r+=i[3&n(16)|8];break;default:r+=i[n(16)]}return r}var i="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split("");t.exports=r},{}],8:[function(e,t){"use strict";function n(e){for(var t,n=e.shift(),r=[n.id,n.opts,[]],i=r;e.length;)n=e.shift(),t=[n.id,n.opts,[]],i[2].push(t),i=t;return r}function r(e,t){for(var n=[{tree1:e,tree2:t}],r=!1;n.length>0;){var i=n.pop(),o=i.tree1,s=i.tree2;(o[1].status||s[1].status)&&(o[1].status="available"===o[1].status||"available"===s[1].status?"available":"missing");for(var a=0;a<s[2].length;a++)if(o[2][0]){for(var u=!1,c=0;c<o[2].length;c++)o[2][c][0]===s[2][a][0]&&(n.push({tree1:o[2][c],tree2:s[2][a]}),u=!0);u||(r="new_branch",o[2].push(s[2][a]),o[2].sort())}else r="new_leaf",o[2][0]=s[2][a]}return{conflicts:r,tree:e}}function i(e,t,n){var i,o=[],s=!1,a=!1;return e.length?(e.forEach(function(e){if(e.pos===t.pos&&e.ids[0]===t.ids[0])i=r(e.ids,t.ids),o.push({pos:e.pos,ids:i.tree}),s=s||i.conflicts,a=!0;else if(n!==!0){var u=e.pos<t.pos?e:t,c=e.pos<t.pos?t:e,l=c.pos-u.pos,f=[],d=[];for(d.push({ids:u.ids,diff:l,parent:null,parentIdx:null});d.length>0;){var h=d.pop();0!==h.diff?h.ids&&h.ids[2].forEach(function(e,t){d.push({ids:e,diff:h.diff-1,parent:h.ids,parentIdx:t})}):h.ids[0]===c.ids[0]&&f.push(h)}var p=f[0];p?(i=r(p.ids,c.ids),p.parent[2][p.parentIdx]=i.tree,o.push({pos:u.pos,ids:u.ids}),s=s||i.conflicts,a=!0):o.push(e)}else o.push(e)}),a||o.push(t),o.sort(function(e,t){return e.pos-t.pos}),{tree:o,conflicts:s||"internal_node"}):{tree:[t],conflicts:"new_leaf"}}function o(e,t){var r=a.rootToLeaf(e).map(function(e){var r=e.ids.slice(-t);return{pos:e.pos+(e.ids.length-r.length),ids:n(r)}});return r.reduce(function(e,t){return i(e,t,!0).tree},[r.shift()])}var s=e("pouchdb-extend"),a={};a.merge=function(e,t,n){e=s(!0,[],e),t=s(!0,{},t);var r=i(e,t);return{tree:o(r.tree,n),conflicts:r.conflicts}},a.winningRev=function(e){var t=[];return a.traverseRevTree(e.rev_tree,function(e,n,r,i,o){e&&t.push({pos:n,id:r,deleted:!!o.deleted})}),t.sort(function(e,t){return e.deleted!==t.deleted?e.deleted>t.deleted?1:-1:e.pos!==t.pos?t.pos-e.pos:e.id<t.id?1:-1}),t[0].pos+"-"+t[0].id},a.traverseRevTree=function(e,t){for(var n,r=e.slice();n=r.pop();)for(var i=n.pos,o=n.ids,s=o[2],a=t(0===s.length,i,o[0],n.ctx,o[1]),u=0,c=s.length;c>u;u++)r.push({pos:i+1,ids:s[u],ctx:a})},a.collectLeaves=function(e){var t=[];return a.traverseRevTree(e,function(e,n,r,i,o){e&&t.unshift({rev:n+"-"+r,pos:n,opts:o})}),t.sort(function(e,t){return t.pos-e.pos}),t.map(function(e){delete e.pos}),t},a.collectConflicts=function(e){var t=a.winningRev(e),n=a.collectLeaves(e.rev_tree),r=[];return n.forEach(function(e){e.rev===t||e.opts.deleted||r.push(e.rev)}),r},a.rootToLeaf=function(e){var t=[];return a.traverseRevTree(e,function(e,n,r,i,o){if(i=i?i.slice(0):[],i.push({id:r,opts:o}),e){var s=n+1-i.length;t.unshift({pos:s,ids:i})}return i}),t},t.exports=a},{"pouchdb-extend":95}],"adapter-config":[function(e,t){t.exports=e("kPrcxC")},{}],kPrcxC:[function(e,t){"use strict";t.exports={name:"memory",valid:function(){return!0},use_prefix:!1}},{}],11:[function(e){"use strict";var t=e("adapter-config"),n=t.name,r=e("./levelalt");window.PouchDB.adapter(n,r),window.PouchDB.preferredAdapters.push(n)},{"./levelalt":12,"adapter-config":"kPrcxC"}],12:[function(e,t){"use strict";function n(e,t){var n=s.extend({db:i},e);r.call(this,n,t)}var r=e("../adapters/leveldb"),i=e("leveldown"),o=e("adapter-config"),s=e("../utils");n.valid=function(){return o.valid()},n.use_prefix=o.use_prefix,n.destroy=s.toPromise(function(e,t,n){"function"==typeof t&&(n=t,t={});var o=s.extend({db:i},t);return r.destroy(e,o,n)}),t.exports=n},{"../adapters/leveldb":1,"../utils":15,"adapter-config":"kPrcxC",leveldown:"RQL87X"}],JpIkFB:[function(e,t,n){(function(e){"use strict";n.toSublevel=function(t,n,r){e.nextTick(function(){r()})},n.localAndMetaStores=function(t,n,r){e.nextTick(function(){r()})}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],"../adapters/../deps/migrate":[function(e,t){t.exports=e("JpIkFB")},{}],15:[function(e,t,n){(function(t,r){function i(e){var t={};return e.forEach(function(e){t[e]=!0}),t}function o(){return"undefined"!=typeof chrome&&"undefined"!=typeof chrome.storage&&"undefined"!=typeof chrome.storage.local}function s(){if(!(this instanceof s))return new s;var e=this;l.call(this),this.isChrome=o(),this.listeners={},this.hasLocal=!1,this.isChrome||(this.hasLocal=n.hasLocalStorage()),this.isChrome?chrome.storage.onChanged.addListener(function(t){null!=t.db_name&&e.emit(t.dbName.newValue)}):this.hasLocal&&(r.addEventListener?r.addEventListener("storage",function(t){e.emit(t.key)}):r.attachEvent("storage",function(t){e.emit(t.key)}))}var a=e("./merge");n.extend=e("pouchdb-extend"),n.ajax=e("./deps/ajax"),n.createBlob=e("./deps/blob"),n.uuid=e("./deps/uuid"),n.getArguments=e("argsarray");var u=e("./deps/buffer"),c=e("./deps/errors"),l=e("events").EventEmitter,f=e("./deps/collections");n.Map=f.Map,n.Set=f.Set,n.Promise="function"==typeof r.Promise?r.Promise:e("bluebird");var d=n.Promise,h=i(["_id","_rev","_attachments","_deleted","_revisions","_revs_info","_conflicts","_deleted_conflicts","_local_seq","_rev_tree","_replication_id","_replication_state","_replication_state_time","_replication_state_reason","_replication_stats"]);n.clone=function(e){return n.extend(!0,{},e)},n.inherits=e("inherits"),n.invalidIdError=function(e){var t;if(e?"string"!=typeof e?(t=new TypeError(c.INVALID_ID.message),t.status=400):/^_/.test(e)&&!/^_(design|local)/.test(e)&&(t=new TypeError(c.RESERVED_ID.message),t.status=400):(t=new TypeError(c.MISSING_ID.message),t.status=412),t)throw t},n.call=n.getArguments(function(e){if(e.length){var t=e.shift();"function"==typeof t&&t.apply(this,e)}}),n.isLocalId=function(e){return/^_local/.test(e)},n.isDeleted=function(e,t){t||(t=a.winningRev(e));var n=t.indexOf("-");-1!==n&&(t=t.substring(n+1));var r=!1;return a.traverseRevTree(e.rev_tree,function(e,n,i,o,s){i===t&&(r=!!s.deleted)}),r},n.filterChange=function(e){return function(t){var n={},r=e.filter&&"function"==typeof e.filter;if(n.query=e.query_params,e.filter&&r&&!e.filter.call(this,t.doc,n))return!1;if(e.doc_ids&&-1===e.doc_ids.indexOf(t.id))return!1;if(e.include_docs)for(var i in t.doc._attachments)t.doc._attachments.hasOwnProperty(i)&&(t.doc._attachments[i].stub=!0);else delete t.doc;return!0}},n.parseDoc=function(e,t){var r,i,o,s,a={status:"available"};if(e._deleted&&(a.deleted=!0),t)if(e._id||(e._id=n.uuid()),i=n.uuid(32,16).toLowerCase(),e._rev){if(o=/^(\d+)-(.+)$/.exec(e._rev),!o){var u=new TypeError("invalid value for property '_rev'");u.status=400}e._rev_tree=[{pos:parseInt(o[1],10),ids:[o[2],{status:"missing"},[[i,a,[]]]]}],r=parseInt(o[1],10)+1}else e._rev_tree=[{pos:1,ids:[i,a,[]]}],r=1;else if(e._revisions&&(e._rev_tree=[{pos:e._revisions.start-e._revisions.ids.length+1,ids:e._revisions.ids.reduce(function(e,t){return null===e?[t,a,[]]:[t,{status:"missing"},[e]]},null)}],r=e._revisions.start,i=e._revisions.ids[0]),!e._rev_tree){if(o=/^(\d+)-(.+)$/.exec(e._rev),!o)throw s=new TypeError(c.BAD_ARG.message),s.status=c.BAD_ARG.status,s;r=parseInt(o[1],10),i=o[2],e._rev_tree=[{pos:parseInt(o[1],10),ids:[o[2],a,[]]}]}n.invalidIdError(e._id),e._id=decodeURIComponent(e._id),e._rev=[r,i].join("-");var l={metadata:{},data:{}};for(var f in e)if(e.hasOwnProperty(f)){var d="_"===f[0];if(d&&!h[f])throw s=new Error(c.DOC_VALIDATION.message+": "+f),s.status=c.DOC_VALIDATION.status,s;d&&"_attachments"!==f?l.metadata[f.slice(1)]=e[f]:l.data[f]=e[f]}return l},n.isCordova=function(){return"undefined"!=typeof cordova||"undefined"!=typeof PhoneGap||"undefined"!=typeof phonegap},n.hasLocalStorage=function(){if(o())return!1;try{return r.localStorage}catch(e){return!1}},n.Changes=s,n.inherits(s,l),s.prototype.addListener=function(e,t,r,i){function o(){r.changes({include_docs:i.include_docs,conflicts:i.conflicts,continuous:!1,descending:!1,filter:i.filter,view:i.view,since:i.since,query_params:i.query_params,onChange:function(e){e.seq>i.since&&!i.cancelled&&(i.since=e.seq,n.call(i.onChange,e))}})}this.listeners[t]||(this.listeners[t]=o,this.on(e,o))},s.prototype.removeListener=function(e,t){t in this.listeners&&l.prototype.removeListener.call(this,e,this.listeners[t])},s.prototype.notifyLocalWindows=function(e){this.isChrome?chrome.storage.local.set({dbName:e}):this.hasLocal&&(localStorage[e]="a"===localStorage[e]?"b":"a")},s.prototype.notify=function(e){this.emit(e),this.notifyLocalWindows(e)},n.atob=t.browser&&"atob"in r?function(e){return atob(e)}:function(e){var t=new u(e,"base64");if(t.toString("base64")!==e)throw"Cannot base64 encode full string";return t.toString("binary")},n.btoa=t.browser&&"btoa"in r?function(e){return btoa(e)}:function(e){return new u(e,"binary").toString("base64")},n.fixBinary=function(e){if(!t.browser)return e;for(var n=e.length,r=new ArrayBuffer(n),i=new Uint8Array(r),o=0;n>o;o++)i[o]=e.charCodeAt(o);return r},n.once=function(e){var t=!1;return n.getArguments(function(n){if(t)throw"function"==typeof console.trace&&console.trace(),new Error("once called more than once");t=!0,e.apply(this,n)})},n.toPromise=function(e){return n.getArguments(function(r){var i,o=this,s="function"==typeof r[r.length-1]?r.pop():!1;s&&(i=function(e,n){t.nextTick(function(){s(e,n)})});var a=new d(function(t,i){var s;try{var a=n.once(function(e,n){e?i(e):t(n)});r.push(a),s=e.apply(o,r),s&&"function"==typeof s.then&&t(s)}catch(u){i(u)}});return i&&a.then(function(e){i(null,e)},i),a.cancel=function(){return this},a})},n.adapterFun=function(e,t){return n.toPromise(n.getArguments(function(r){if(this._closed)return d.reject(new Error("database is closed"));var i=this;return this.taskqueue.isReady?t.apply(this,r):new n.Promise(function(t,n){i.taskqueue.addTask(function(o){o?n(o):t(i[e].apply(i,r))})})}))},n.arrayBufferToBinaryString=function(e){for(var t="",n=new Uint8Array(e),r=n.byteLength,i=0;r>i;i++)t+=String.fromCharCode(n[i]);return t},n.cancellableFun=function(e,t,r){r=r?n.clone(!0,{},r):{};var i=new l,o=r.complete||function(){},s=r.complete=n.once(function(e,t){e?o(e):(i.emit("end",t),o(null,t)),i.removeAllListeners()}),a=r.onChange||function(){},u=0;t.on("destroyed",function(){i.removeAllListeners()}),r.onChange=function(e){a(e),e.seq<=u||(u=e.seq,i.emit("change",e),e.deleted?i.emit("delete",e):1===e.changes.length&&"1-"===e.changes[0].rev.slice(0,1)?i.emit("create",e):i.emit("update",e))};var c=new d(function(e,t){r.complete=function(n,r){n?t(n):e(r)}});return c.then(function(e){s(null,e)},s),c.cancel=function(){c.isCancelled=!0,t.taskqueue.isReady&&r.complete(null,{status:"cancelled"})},t.taskqueue.isReady?e(t,r,c):t.taskqueue.addTask(function(){c.isCancelled?r.complete(null,{status:"cancelled"}):e(t,r,c)}),c.on=i.on.bind(i),c.once=i.once.bind(i),c.addListener=i.addListener.bind(i),c.removeListener=i.removeListener.bind(i),c.removeAllListeners=i.removeAllListeners.bind(i),c.setMaxListeners=i.setMaxListeners.bind(i),c.listeners=i.listeners.bind(i),c.emit=i.emit.bind(i),c},n.MD5=n.toPromise(e("./deps/md5"))}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./deps/ajax":2,"./deps/blob":3,"./deps/buffer":17,"./deps/collections":4,"./deps/errors":5,"./deps/md5":6,"./deps/uuid":7,"./merge":8,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,argsarray:16,bluebird:75,events:18,inherits:33,"pouchdb-extend":95}],16:[function(e,t){"use strict";function n(e){return function(){var t=arguments.length;
+if(t){for(var n=[],r=-1;++r<t;)n[r]=arguments[r];return e.call(this,n)}return e.call(this,[])}}t.exports=n},{}],17:[function(){},{}],18:[function(e,t){function n(){this._events=this._events||{},this._maxListeners=this._maxListeners||void 0}function r(e){return"function"==typeof e}function i(e){return"number"==typeof e}function o(e){return"object"==typeof e&&null!==e}function s(e){return void 0===e}t.exports=n,n.EventEmitter=n,n.prototype._events=void 0,n.prototype._maxListeners=void 0,n.defaultMaxListeners=10,n.prototype.setMaxListeners=function(e){if(!i(e)||0>e||isNaN(e))throw TypeError("n must be a positive number");return this._maxListeners=e,this},n.prototype.emit=function(e){var t,n,i,a,u,c;if(this._events||(this._events={}),"error"===e&&(!this._events.error||o(this._events.error)&&!this._events.error.length))throw t=arguments[1],t instanceof Error?t:TypeError('Uncaught, unspecified "error" event.');if(n=this._events[e],s(n))return!1;if(r(n))switch(arguments.length){case 1:n.call(this);break;case 2:n.call(this,arguments[1]);break;case 3:n.call(this,arguments[1],arguments[2]);break;default:for(i=arguments.length,a=new Array(i-1),u=1;i>u;u++)a[u-1]=arguments[u];n.apply(this,a)}else if(o(n)){for(i=arguments.length,a=new Array(i-1),u=1;i>u;u++)a[u-1]=arguments[u];for(c=n.slice(),i=c.length,u=0;i>u;u++)c[u].apply(this,a)}return!0},n.prototype.addListener=function(e,t){var i;if(!r(t))throw TypeError("listener must be a function");if(this._events||(this._events={}),this._events.newListener&&this.emit("newListener",e,r(t.listener)?t.listener:t),this._events[e]?o(this._events[e])?this._events[e].push(t):this._events[e]=[this._events[e],t]:this._events[e]=t,o(this._events[e])&&!this._events[e].warned){var i;i=s(this._maxListeners)?n.defaultMaxListeners:this._maxListeners,i&&i>0&&this._events[e].length>i&&(this._events[e].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[e].length),"function"==typeof console.trace&&console.trace())}return this},n.prototype.on=n.prototype.addListener,n.prototype.once=function(e,t){function n(){this.removeListener(e,n),i||(i=!0,t.apply(this,arguments))}if(!r(t))throw TypeError("listener must be a function");var i=!1;return n.listener=t,this.on(e,n),this},n.prototype.removeListener=function(e,t){var n,i,s,a;if(!r(t))throw TypeError("listener must be a function");if(!this._events||!this._events[e])return this;if(n=this._events[e],s=n.length,i=-1,n===t||r(n.listener)&&n.listener===t)delete this._events[e],this._events.removeListener&&this.emit("removeListener",e,t);else if(o(n)){for(a=s;a-->0;)if(n[a]===t||n[a].listener&&n[a].listener===t){i=a;break}if(0>i)return this;1===n.length?(n.length=0,delete this._events[e]):n.splice(i,1),this._events.removeListener&&this.emit("removeListener",e,t)}return this},n.prototype.removeAllListeners=function(e){var t,n;if(!this._events)return this;if(!this._events.removeListener)return 0===arguments.length?this._events={}:this._events[e]&&delete this._events[e],this;if(0===arguments.length){for(t in this._events)"removeListener"!==t&&this.removeAllListeners(t);return this.removeAllListeners("removeListener"),this._events={},this}if(n=this._events[e],r(n))this.removeListener(e,n);else for(;n.length;)this.removeListener(e,n[n.length-1]);return delete this._events[e],this},n.prototype.listeners=function(e){var t;return t=this._events&&this._events[e]?r(this._events[e])?[this._events[e]]:this._events[e].slice():[]},n.listenerCount=function(e,t){var n;return n=e._events&&e._events[t]?r(e._events[t])?1:e._events[t].length:0}},{}],19:[function(e,t){var n=t.exports={};n.nextTick=function(){var e="undefined"!=typeof window&&window.setImmediate,t="undefined"!=typeof window&&window.postMessage&&window.addEventListener;if(e)return function(e){return window.setImmediate(e)};if(t){var n=[];return window.addEventListener("message",function(e){var t=e.source;if((t===window||null===t)&&"process-tick"===e.data&&(e.stopPropagation(),n.length>0)){var r=n.shift();r()}},!0),function(e){n.push(e),window.postMessage("process-tick","*")}}return function(e){setTimeout(e,0)}}(),n.title="browser",n.browser=!0,n.env={},n.argv=[],n.binding=function(){throw new Error("process.binding is not supported")},n.cwd=function(){return"/"},n.chdir=function(){throw new Error("process.chdir is not supported")}},{}],20:[function(e,t,n){function r(e,t,n){if(!(this instanceof r))return new r(e,t,n);var i=typeof e;if("base64"===t&&"string"===i)for(e=j(e);e.length%4!==0;)e+="=";var o;if("number"===i)o=A(e);else if("string"===i)o=r.byteLength(e,t);else{if("object"!==i)throw new Error("First argument needs to be a number, array or string.");o=A(e.length)}var s;r._useTypedArrays?s=O(new Uint8Array(o)):(s=this,s.length=o,s._isBuffer=!0);var a;if(r._useTypedArrays&&"function"==typeof Uint8Array&&e instanceof Uint8Array)s._set(e);else if(R(e))for(a=0;o>a;a++)s[a]=r.isBuffer(e)?e.readUInt8(a):e[a];else if("string"===i)s.write(e,0,t);else if("number"===i&&!r._useTypedArrays&&!n)for(a=0;o>a;a++)s[a]=0;return s}function i(e,t,n,i){n=Number(n)||0;var o=e.length-n;i?(i=Number(i),i>o&&(i=o)):i=o;var s=t.length;q(s%2===0,"Invalid hex string"),i>s/2&&(i=s/2);for(var a=0;i>a;a++){var u=parseInt(t.substr(2*a,2),16);q(!isNaN(u),"Invalid hex string"),e[n+a]=u}return r._charsWritten=2*a,a}function o(e,t,n,i){var o=r._charsWritten=D(C(t),e,n,i);return o}function s(e,t,n,i){var o=r._charsWritten=D(N(t),e,n,i);return o}function a(e,t,n,r){return s(e,t,n,r)}function u(e,t,n,i){var o=r._charsWritten=D(B(t),e,n,i);return o}function c(e,t,n){return W.fromByteArray(0===t&&n===e.length?e:e.slice(t,n))}function l(e,t,n){var r="",i="";n=Math.min(e.length,n);for(var o=t;n>o;o++)e[o]<=127?(r+=M(i)+String.fromCharCode(e[o]),i=""):i+="%"+e[o].toString(16);return r+M(i)}function f(e,t,n){var r="";n=Math.min(e.length,n);for(var i=t;n>i;i++)r+=String.fromCharCode(e[i]);return r}function d(e,t,n){return f(e,t,n)}function h(e,t,n){var r=e.length;(!t||0>t)&&(t=0),(!n||0>n||n>r)&&(n=r);for(var i="",o=t;n>o;o++)i+=T(e[o]);return i}function p(e,t,n,r){r||(q("boolean"==typeof n,"missing or invalid endian"),q(void 0!==t&&null!==t,"missing offset"),q(t+1<e.length,"Trying to read beyond buffer length"));var i=e.length;if(!(t>=i)){var o;return n?(o=e[t],i>t+1&&(o|=e[t+1]<<8)):(o=e[t]<<8,i>t+1&&(o|=e[t+1])),o}}function g(e,t,n,r){r||(q("boolean"==typeof n,"missing or invalid endian"),q(void 0!==t&&null!==t,"missing offset"),q(t+3<e.length,"Trying to read beyond buffer length"));var i=e.length;if(!(t>=i)){var o;return n?(i>t+2&&(o=e[t+2]<<16),i>t+1&&(o|=e[t+1]<<8),o|=e[t],i>t+3&&(o+=e[t+3]<<24>>>0)):(i>t+1&&(o=e[t+1]<<16),i>t+2&&(o|=e[t+2]<<8),i>t+3&&(o|=e[t+3]),o+=e[t]<<24>>>0),o}}function v(e,t,n,r){r||(q("boolean"==typeof n,"missing or invalid endian"),q(void 0!==t&&null!==t,"missing offset"),q(t+1<e.length,"Trying to read beyond buffer length"));var i=e.length;if(!(t>=i)){var o=p(e,t,n,!0),s=32768&o;return s?-1*(65535-o+1):o}}function b(e,t,n,r){r||(q("boolean"==typeof n,"missing or invalid endian"),q(void 0!==t&&null!==t,"missing offset"),q(t+3<e.length,"Trying to read beyond buffer length"));var i=e.length;if(!(t>=i)){var o=g(e,t,n,!0),s=2147483648&o;return s?-1*(4294967295-o+1):o}}function y(e,t,n,r){return r||(q("boolean"==typeof n,"missing or invalid endian"),q(t+3<e.length,"Trying to read beyond buffer length")),V.read(e,t,n,23,4)}function m(e,t,n,r){return r||(q("boolean"==typeof n,"missing or invalid endian"),q(t+7<e.length,"Trying to read beyond buffer length")),V.read(e,t,n,52,8)}function _(e,t,n,r,i){i||(q(void 0!==t&&null!==t,"missing value"),q("boolean"==typeof r,"missing or invalid endian"),q(void 0!==n&&null!==n,"missing offset"),q(n+1<e.length,"trying to write beyond buffer length"),U(t,65535));var o=e.length;if(!(n>=o))for(var s=0,a=Math.min(o-n,2);a>s;s++)e[n+s]=(t&255<<8*(r?s:1-s))>>>8*(r?s:1-s)}function w(e,t,n,r,i){i||(q(void 0!==t&&null!==t,"missing value"),q("boolean"==typeof r,"missing or invalid endian"),q(void 0!==n&&null!==n,"missing offset"),q(n+3<e.length,"trying to write beyond buffer length"),U(t,4294967295));var o=e.length;if(!(n>=o))for(var s=0,a=Math.min(o-n,4);a>s;s++)e[n+s]=t>>>8*(r?s:3-s)&255}function E(e,t,n,r,i){i||(q(void 0!==t&&null!==t,"missing value"),q("boolean"==typeof r,"missing or invalid endian"),q(void 0!==n&&null!==n,"missing offset"),q(n+1<e.length,"Trying to write beyond buffer length"),F(t,32767,-32768));var o=e.length;n>=o||(t>=0?_(e,t,n,r,i):_(e,65535+t+1,n,r,i))}function k(e,t,n,r,i){i||(q(void 0!==t&&null!==t,"missing value"),q("boolean"==typeof r,"missing or invalid endian"),q(void 0!==n&&null!==n,"missing offset"),q(n+3<e.length,"Trying to write beyond buffer length"),F(t,2147483647,-2147483648));var o=e.length;n>=o||(t>=0?w(e,t,n,r,i):w(e,4294967295+t+1,n,r,i))}function S(e,t,n,r,i){i||(q(void 0!==t&&null!==t,"missing value"),q("boolean"==typeof r,"missing or invalid endian"),q(void 0!==n&&null!==n,"missing offset"),q(n+3<e.length,"Trying to write beyond buffer length"),P(t,3.4028234663852886e38,-3.4028234663852886e38));var o=e.length;n>=o||V.write(e,t,n,r,23,4)}function x(e,t,n,r,i){i||(q(void 0!==t&&null!==t,"missing value"),q("boolean"==typeof r,"missing or invalid endian"),q(void 0!==n&&null!==n,"missing offset"),q(n+7<e.length,"Trying to write beyond buffer length"),P(t,1.7976931348623157e308,-1.7976931348623157e308));var o=e.length;n>=o||V.write(e,t,n,r,52,8)}function j(e){return e.trim?e.trim():e.replace(/^\s+|\s+$/g,"")}function O(e){return e._isBuffer=!0,e._get=e.get,e._set=e.set,e.get=K.get,e.set=K.set,e.write=K.write,e.toString=K.toString,e.toLocaleString=K.toString,e.toJSON=K.toJSON,e.copy=K.copy,e.slice=K.slice,e.readUInt8=K.readUInt8,e.readUInt16LE=K.readUInt16LE,e.readUInt16BE=K.readUInt16BE,e.readUInt32LE=K.readUInt32LE,e.readUInt32BE=K.readUInt32BE,e.readInt8=K.readInt8,e.readInt16LE=K.readInt16LE,e.readInt16BE=K.readInt16BE,e.readInt32LE=K.readInt32LE,e.readInt32BE=K.readInt32BE,e.readFloatLE=K.readFloatLE,e.readFloatBE=K.readFloatBE,e.readDoubleLE=K.readDoubleLE,e.readDoubleBE=K.readDoubleBE,e.writeUInt8=K.writeUInt8,e.writeUInt16LE=K.writeUInt16LE,e.writeUInt16BE=K.writeUInt16BE,e.writeUInt32LE=K.writeUInt32LE,e.writeUInt32BE=K.writeUInt32BE,e.writeInt8=K.writeInt8,e.writeInt16LE=K.writeInt16LE,e.writeInt16BE=K.writeInt16BE,e.writeInt32LE=K.writeInt32LE,e.writeInt32BE=K.writeInt32BE,e.writeFloatLE=K.writeFloatLE,e.writeFloatBE=K.writeFloatBE,e.writeDoubleLE=K.writeDoubleLE,e.writeDoubleBE=K.writeDoubleBE,e.fill=K.fill,e.inspect=K.inspect,e.toArrayBuffer=K.toArrayBuffer,e}function L(e,t,n){return"number"!=typeof e?n:(e=~~e,e>=t?t:e>=0?e:(e+=t,e>=0?e:0))}function A(e){return e=~~Math.ceil(+e),0>e?0:e}function I(e){return(Array.isArray||function(e){return"[object Array]"===Object.prototype.toString.call(e)})(e)}function R(e){return I(e)||r.isBuffer(e)||e&&"object"==typeof e&&"number"==typeof e.length}function T(e){return 16>e?"0"+e.toString(16):e.toString(16)}function C(e){for(var t=[],n=0;n<e.length;n++){var r=e.charCodeAt(n);if(127>=r)t.push(e.charCodeAt(n));else{var i=n;r>=55296&&57343>=r&&n++;for(var o=encodeURIComponent(e.slice(i,n+1)).substr(1).split("%"),s=0;s<o.length;s++)t.push(parseInt(o[s],16))}}return t}function N(e){for(var t=[],n=0;n<e.length;n++)t.push(255&e.charCodeAt(n));return t}function B(e){return W.toByteArray(e)}function D(e,t,n,r){for(var i=0;r>i&&!(i+n>=t.length||i>=e.length);i++)t[i+n]=e[i];return i}function M(e){try{return decodeURIComponent(e)}catch(t){return String.fromCharCode(65533)}}function U(e,t){q("number"==typeof e,"cannot write a non-number as a number"),q(e>=0,"specified a negative value for writing an unsigned value"),q(t>=e,"value is larger than maximum value for type"),q(Math.floor(e)===e,"value has a fractional component")}function F(e,t,n){q("number"==typeof e,"cannot write a non-number as a number"),q(t>=e,"value larger than maximum allowed value"),q(e>=n,"value smaller than minimum allowed value"),q(Math.floor(e)===e,"value has a fractional component")}function P(e,t,n){q("number"==typeof e,"cannot write a non-number as a number"),q(t>=e,"value larger than maximum allowed value"),q(e>=n,"value smaller than minimum allowed value")}function q(e,t){if(!e)throw new Error(t||"Failed assertion")}var W=e("base64-js"),V=e("ieee754");n.Buffer=r,n.SlowBuffer=r,n.INSPECT_MAX_BYTES=50,r.poolSize=8192,r._useTypedArrays=function(){if("undefined"==typeof Uint8Array||"undefined"==typeof ArrayBuffer)return!1;try{var e=new Uint8Array(0);return e.foo=function(){return 42},42===e.foo()&&"function"==typeof e.subarray}catch(t){return!1}}(),r.isEncoding=function(e){switch(String(e).toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"raw":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return!0;default:return!1}},r.isBuffer=function(e){return!(null===e||void 0===e||!e._isBuffer)},r.byteLength=function(e,t){var n;switch(e+="",t||"utf8"){case"hex":n=e.length/2;break;case"utf8":case"utf-8":n=C(e).length;break;case"ascii":case"binary":case"raw":n=e.length;break;case"base64":n=B(e).length;break;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":n=2*e.length;break;default:throw new Error("Unknown encoding")}return n},r.concat=function(e,t){if(q(I(e),"Usage: Buffer.concat(list, [totalLength])\nlist should be an Array."),0===e.length)return new r(0);if(1===e.length)return e[0];var n;if("number"!=typeof t)for(t=0,n=0;n<e.length;n++)t+=e[n].length;var i=new r(t),o=0;for(n=0;n<e.length;n++){var s=e[n];s.copy(i,o),o+=s.length}return i},r.prototype.write=function(e,t,n,r){if(isFinite(t))isFinite(n)||(r=n,n=void 0);else{var c=r;r=t,t=n,n=c}t=Number(t)||0;var l=this.length-t;switch(n?(n=Number(n),n>l&&(n=l)):n=l,r=String(r||"utf8").toLowerCase()){case"hex":return i(this,e,t,n);case"utf8":case"utf-8":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return o(this,e,t,n);case"ascii":return s(this,e,t,n);case"binary":return a(this,e,t,n);case"base64":return u(this,e,t,n);default:throw new Error("Unknown encoding")}},r.prototype.toString=function(e,t,n){var r=this;if(e=String(e||"utf8").toLowerCase(),t=Number(t)||0,n=void 0!==n?Number(n):n=r.length,n===t)return"";switch(e){case"hex":return h(r,t,n);case"utf8":case"utf-8":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return l(r,t,n);case"ascii":return f(r,t,n);case"binary":return d(r,t,n);case"base64":return c(r,t,n);default:throw new Error("Unknown encoding")}},r.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}},r.prototype.copy=function(e,t,n,r){var i=this;if(n||(n=0),r||0===r||(r=this.length),t||(t=0),r!==n&&0!==e.length&&0!==i.length){q(r>=n,"sourceEnd < sourceStart"),q(t>=0&&t<e.length,"targetStart out of bounds"),q(n>=0&&n<i.length,"sourceStart out of bounds"),q(r>=0&&r<=i.length,"sourceEnd out of bounds"),r>this.length&&(r=this.length),e.length-t<r-n&&(r=e.length-t+n);for(var o=0;r-n>o;o++)e[o+t]=this[o+n]}},r.prototype.slice=function(e,t){var n=this.length;if(e=L(e,n,0),t=L(t,n,n),r._useTypedArrays)return O(this.subarray(e,t));for(var i=t-e,o=new r(i,void 0,!0),s=0;i>s;s++)o[s]=this[s+e];return o},r.prototype.get=function(e){return console.log(".get() is deprecated. Access using array indexes instead."),this.readUInt8(e)},r.prototype.set=function(e,t){return console.log(".set() is deprecated. Access using array indexes instead."),this.writeUInt8(e,t)},r.prototype.readUInt8=function(e,t){return t||(q(void 0!==e&&null!==e,"missing offset"),q(e<this.length,"Trying to read beyond buffer length")),e>=this.length?void 0:this[e]},r.prototype.readUInt16LE=function(e,t){return p(this,e,!0,t)},r.prototype.readUInt16BE=function(e,t){return p(this,e,!1,t)},r.prototype.readUInt32LE=function(e,t){return g(this,e,!0,t)},r.prototype.readUInt32BE=function(e,t){return g(this,e,!1,t)},r.prototype.readInt8=function(e,t){if(t||(q(void 0!==e&&null!==e,"missing offset"),q(e<this.length,"Trying to read beyond buffer length")),!(e>=this.length)){var n=128&this[e];return n?-1*(255-this[e]+1):this[e]}},r.prototype.readInt16LE=function(e,t){return v(this,e,!0,t)},r.prototype.readInt16BE=function(e,t){return v(this,e,!1,t)},r.prototype.readInt32LE=function(e,t){return b(this,e,!0,t)},r.prototype.readInt32BE=function(e,t){return b(this,e,!1,t)},r.prototype.readFloatLE=function(e,t){return y(this,e,!0,t)},r.prototype.readFloatBE=function(e,t){return y(this,e,!1,t)},r.prototype.readDoubleLE=function(e,t){return m(this,e,!0,t)},r.prototype.readDoubleBE=function(e,t){return m(this,e,!1,t)},r.prototype.writeUInt8=function(e,t,n){n||(q(void 0!==e&&null!==e,"missing value"),q(void 0!==t&&null!==t,"missing offset"),q(t<this.length,"trying to write beyond buffer length"),U(e,255)),t>=this.length||(this[t]=e)},r.prototype.writeUInt16LE=function(e,t,n){_(this,e,t,!0,n)},r.prototype.writeUInt16BE=function(e,t,n){_(this,e,t,!1,n)},r.prototype.writeUInt32LE=function(e,t,n){w(this,e,t,!0,n)},r.prototype.writeUInt32BE=function(e,t,n){w(this,e,t,!1,n)},r.prototype.writeInt8=function(e,t,n){n||(q(void 0!==e&&null!==e,"missing value"),q(void 0!==t&&null!==t,"missing offset"),q(t<this.length,"Trying to write beyond buffer length"),F(e,127,-128)),t>=this.length||(e>=0?this.writeUInt8(e,t,n):this.writeUInt8(255+e+1,t,n))},r.prototype.writeInt16LE=function(e,t,n){E(this,e,t,!0,n)},r.prototype.writeInt16BE=function(e,t,n){E(this,e,t,!1,n)},r.prototype.writeInt32LE=function(e,t,n){k(this,e,t,!0,n)},r.prototype.writeInt32BE=function(e,t,n){k(this,e,t,!1,n)},r.prototype.writeFloatLE=function(e,t,n){S(this,e,t,!0,n)},r.prototype.writeFloatBE=function(e,t,n){S(this,e,t,!1,n)},r.prototype.writeDoubleLE=function(e,t,n){x(this,e,t,!0,n)},r.prototype.writeDoubleBE=function(e,t,n){x(this,e,t,!1,n)},r.prototype.fill=function(e,t,n){if(e||(e=0),t||(t=0),n||(n=this.length),"string"==typeof e&&(e=e.charCodeAt(0)),q("number"==typeof e&&!isNaN(e),"value is not a number"),q(n>=t,"end < start"),n!==t&&0!==this.length){q(t>=0&&t<this.length,"start out of bounds"),q(n>=0&&n<=this.length,"end out of bounds");for(var r=t;n>r;r++)this[r]=e}},r.prototype.inspect=function(){for(var e=[],t=this.length,r=0;t>r;r++)if(e[r]=T(this[r]),r===n.INSPECT_MAX_BYTES){e[r+1]="...";break}return"<Buffer "+e.join(" ")+">"},r.prototype.toArrayBuffer=function(){if("function"==typeof Uint8Array){if(r._useTypedArrays)return new r(this).buffer;for(var e=new Uint8Array(this.length),t=0,n=e.length;n>t;t+=1)e[t]=this[t];return e.buffer}throw new Error("Buffer.toArrayBuffer not supported in this browser")};var K=r.prototype},{"base64-js":21,ieee754:22}],21:[function(e,t,n){var r="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";!function(e){"use strict";function t(e){var t=e.charCodeAt(0);return t===s?62:t===a?63:u>t?-1:u+10>t?t-u+26+26:l+26>t?t-l:c+26>t?t-c+26:void 0}function n(e){function n(e){c[f++]=e}var r,i,s,a,u,c;if(e.length%4>0)throw new Error("Invalid string. Length must be a multiple of 4");var l=e.length;u="="===e.charAt(l-2)?2:"="===e.charAt(l-1)?1:0,c=new o(3*e.length/4-u),s=u>0?e.length-4:e.length;var f=0;for(r=0,i=0;s>r;r+=4,i+=3)a=t(e.charAt(r))<<18|t(e.charAt(r+1))<<12|t(e.charAt(r+2))<<6|t(e.charAt(r+3)),n((16711680&a)>>16),n((65280&a)>>8),n(255&a);return 2===u?(a=t(e.charAt(r))<<2|t(e.charAt(r+1))>>4,n(255&a)):1===u&&(a=t(e.charAt(r))<<10|t(e.charAt(r+1))<<4|t(e.charAt(r+2))>>2,n(a>>8&255),n(255&a)),c}function i(e){function t(e){return r.charAt(e)}function n(e){return t(e>>18&63)+t(e>>12&63)+t(e>>6&63)+t(63&e)}var i,o,s,a=e.length%3,u="";for(i=0,s=e.length-a;s>i;i+=3)o=(e[i]<<16)+(e[i+1]<<8)+e[i+2],u+=n(o);switch(a){case 1:o=e[e.length-1],u+=t(o>>2),u+=t(o<<4&63),u+="==";break;case 2:o=(e[e.length-2]<<8)+e[e.length-1],u+=t(o>>10),u+=t(o>>4&63),u+=t(o<<2&63),u+="="}return u}var o="undefined"!=typeof Uint8Array?Uint8Array:Array,s="+".charCodeAt(0),a="/".charCodeAt(0),u="0".charCodeAt(0),c="a".charCodeAt(0),l="A".charCodeAt(0);e.toByteArray=n,e.fromByteArray=i}("undefined"==typeof n?this.base64js={}:n)},{}],22:[function(e,t,n){n.read=function(e,t,n,r,i){var o,s,a=8*i-r-1,u=(1<<a)-1,c=u>>1,l=-7,f=n?i-1:0,d=n?-1:1,h=e[t+f];for(f+=d,o=h&(1<<-l)-1,h>>=-l,l+=a;l>0;o=256*o+e[t+f],f+=d,l-=8);for(s=o&(1<<-l)-1,o>>=-l,l+=r;l>0;s=256*s+e[t+f],f+=d,l-=8);if(0===o)o=1-c;else{if(o===u)return s?0/0:1/0*(h?-1:1);s+=Math.pow(2,r),o-=c}return(h?-1:1)*s*Math.pow(2,o-r)},n.write=function(e,t,n,r,i,o){var s,a,u,c=8*o-i-1,l=(1<<c)-1,f=l>>1,d=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,h=r?0:o-1,p=r?1:-1,g=0>t||0===t&&0>1/t?1:0;for(t=Math.abs(t),isNaN(t)||1/0===t?(a=isNaN(t)?1:0,s=l):(s=Math.floor(Math.log(t)/Math.LN2),t*(u=Math.pow(2,-s))<1&&(s--,u*=2),t+=s+f>=1?d/u:d*Math.pow(2,1-f),t*u>=2&&(s++,u/=2),s+f>=l?(a=0,s=l):s+f>=1?(a=(t*u-1)*Math.pow(2,i),s+=f):(a=t*Math.pow(2,f-1)*Math.pow(2,i),s=0));i>=8;e[n+h]=255&a,h+=p,a/=256,i-=8);for(s=s<<i|a,c+=i;c>0;e[n+h]=255&s,h+=p,s/=256,c-=8);e[n+h-p]|=128*g}},{}],23:[function(e,t){function n(e){return this instanceof n?(s.call(this,e),a.call(this,e),e&&e.readable===!1&&(this.readable=!1),e&&e.writable===!1&&(this.writable=!1),this.allowHalfOpen=!0,e&&e.allowHalfOpen===!1&&(this.allowHalfOpen=!1),void this.once("end",r)):new n(e)}function r(){if(!this.allowHalfOpen&&!this._writableState.ended){var e=this;o(function(){e.end()})}}t.exports=n;var i=e("inherits"),o=e("process/browser.js").nextTick,s=e("./readable.js"),a=e("./writable.js");i(n,s),n.prototype.write=a.prototype.write,n.prototype.end=a.prototype.end,n.prototype._write=a.prototype._write},{"./readable.js":27,"./writable.js":29,inherits:33,"process/browser.js":25}],24:[function(e,t){function n(){r.call(this)}t.exports=n;var r=e("events").EventEmitter,i=e("inherits");i(n,r),n.Readable=e("./readable.js"),n.Writable=e("./writable.js"),n.Duplex=e("./duplex.js"),n.Transform=e("./transform.js"),n.PassThrough=e("./passthrough.js"),n.Stream=n,n.prototype.pipe=function(e,t){function n(t){e.writable&&!1===e.write(t)&&c.pause&&c.pause()}function i(){c.readable&&c.resume&&c.resume()}function o(){l||(l=!0,e.end())}function s(){l||(l=!0,"function"==typeof e.destroy&&e.destroy())}function a(e){if(u(),0===r.listenerCount(this,"error"))throw e}function u(){c.removeListener("data",n),e.removeListener("drain",i),c.removeListener("end",o),c.removeListener("close",s),c.removeListener("error",a),e.removeListener("error",a),c.removeListener("end",u),c.removeListener("close",u),e.removeListener("close",u)}var c=this;c.on("data",n),e.on("drain",i),e._isStdio||t&&t.end===!1||(c.on("end",o),c.on("close",s));var l=!1;return c.on("error",a),e.on("error",a),c.on("end",u),c.on("close",u),e.on("close",u),e.emit("pipe",c),e}},{"./duplex.js":23,"./passthrough.js":26,"./readable.js":27,"./transform.js":28,"./writable.js":29,events:18,inherits:33}],25:[function(e,t){t.exports=e(19)},{}],26:[function(e,t){function n(e){return this instanceof n?void r.call(this,e):new n(e)}t.exports=n;var r=e("./transform.js"),i=e("inherits");i(n,r),n.prototype._transform=function(e,t,n){n(null,e)}},{"./transform.js":28,inherits:33}],27:[function(e,t){(function(n){function r(t){t=t||{};var n=t.highWaterMark;this.highWaterMark=n||0===n?n:16384,this.highWaterMark=~~this.highWaterMark,this.buffer=[],this.length=0,this.pipes=null,this.pipesCount=0,this.flowing=!1,this.ended=!1,this.endEmitted=!1,this.reading=!1,this.calledRead=!1,this.sync=!0,this.needReadable=!1,this.emittedReadable=!1,this.readableListening=!1,this.objectMode=!!t.objectMode,this.defaultEncoding=t.defaultEncoding||"utf8",this.ranOut=!1,this.awaitDrain=0,this.readingMore=!1,this.decoder=null,this.encoding=null,t.encoding&&(k||(k=e("string_decoder").StringDecoder),this.decoder=new k(t.encoding),this.encoding=t.encoding)}function i(e){return this instanceof i?(this._readableState=new r(e,this),this.readable=!0,void x.call(this)):new i(e)}function o(e,t,n,r,i){var o=c(t,n);if(o)e.emit("error",o);else if(null===n||void 0===n)t.reading=!1,t.ended||l(e,t);else if(t.objectMode||n&&n.length>0)if(t.ended&&!i){var a=new Error("stream.push() after EOF");e.emit("error",a)}else if(t.endEmitted&&i){var a=new Error("stream.unshift() after end event");e.emit("error",a)}else!t.decoder||i||r||(n=t.decoder.write(n)),t.length+=t.objectMode?1:n.length,i?t.buffer.unshift(n):(t.reading=!1,t.buffer.push(n)),t.needReadable&&f(e),h(e,t);else i||(t.reading=!1);return s(t)}function s(e){return!e.ended&&(e.needReadable||e.length<e.highWaterMark||0===e.length)}function a(e){if(e>=A)e=A;else{e--;for(var t=1;32>t;t<<=1)e|=e>>t;e++}return e}function u(e,t){return 0===t.length&&t.ended?0:t.objectMode?0===e?0:1:isNaN(e)||null===e?t.flowing&&t.buffer.length?t.buffer[0].length:t.length:0>=e?0:(e>t.highWaterMark&&(t.highWaterMark=a(e)),e>t.length?t.ended?t.length:(t.needReadable=!0,0):e)}function c(e,t){var n=null;return j.isBuffer(t)||"string"==typeof t||null===t||void 0===t||e.objectMode||n||(n=new TypeError("Invalid non-string/buffer chunk")),n}function l(e,t){if(t.decoder&&!t.ended){var n=t.decoder.end();n&&n.length&&(t.buffer.push(n),t.length+=t.objectMode?1:n.length)}t.ended=!0,t.length>0?f(e):_(e)}function f(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(t.emittedReadable=!0,t.sync?O(function(){d(e)}):d(e))}function d(e){e.emit("readable")}function h(e,t){t.readingMore||(t.readingMore=!0,O(function(){p(e,t)}))}function p(e,t){for(var n=t.length;!t.reading&&!t.flowing&&!t.ended&&t.length<t.highWaterMark&&(e.read(0),n!==t.length);)n=t.length;t.readingMore=!1}function g(e){return function(){var t=e._readableState;t.awaitDrain--,0===t.awaitDrain&&v(e)}}function v(e){function t(e){var t=e.write(n);!1===t&&r.awaitDrain++}var n,r=e._readableState;for(r.awaitDrain=0;r.pipesCount&&null!==(n=e.read());)if(1===r.pipesCount?t(r.pipes,0,null):w(r.pipes,t),e.emit("data",n),r.awaitDrain>0)return;return 0===r.pipesCount?(r.flowing=!1,void(S.listenerCount(e,"data")>0&&y(e))):void(r.ranOut=!0)}function b(){this._readableState.ranOut&&(this._readableState.ranOut=!1,v(this))}function y(e,t){var n=e._readableState;if(n.flowing)throw new Error("Cannot switch to old mode now.");var r=t||!1,i=!1;e.readable=!0,e.pipe=x.prototype.pipe,e.on=e.addListener=x.prototype.on,e.on("readable",function(){i=!0;for(var t;!r&&null!==(t=e.read());)e.emit("data",t);null===t&&(i=!1,e._readableState.needReadable=!0)}),e.pause=function(){r=!0,this.emit("pause")},e.resume=function(){r=!1,i?O(function(){e.emit("readable")}):this.read(0),this.emit("resume")},e.emit("readable")}function m(e,t){var n,r=t.buffer,i=t.length,o=!!t.decoder,s=!!t.objectMode;if(0===r.length)return null;if(0===i)n=null;else if(s)n=r.shift();else if(!e||e>=i)n=o?r.join(""):j.concat(r,i),r.length=0;else if(e<r[0].length){var a=r[0];n=a.slice(0,e),r[0]=a.slice(e)}else if(e===r[0].length)n=r.shift();else{n=o?"":new j(e);for(var u=0,c=0,l=r.length;l>c&&e>u;c++){var a=r[0],f=Math.min(e-u,a.length);o?n+=a.slice(0,f):a.copy(n,u,0,f),f<a.length?r[0]=a.slice(f):r.shift(),u+=f}}return n}function _(e){var t=e._readableState;if(t.length>0)throw new Error("endReadable called on non-empty stream");!t.endEmitted&&t.calledRead&&(t.ended=!0,O(function(){t.endEmitted||0!==t.length||(t.endEmitted=!0,e.readable=!1,e.emit("end"))}))}function w(e,t){for(var n=0,r=e.length;r>n;n++)t(e[n],n)}function E(e,t){for(var n=0,r=e.length;r>n;n++)if(e[n]===t)return n;return-1}t.exports=i,i.ReadableState=r;var k,S=e("events").EventEmitter,x=e("./index.js"),j=e("buffer").Buffer,O=e("process/browser.js").nextTick,L=e("inherits");L(i,x),i.prototype.push=function(e,t){var n=this._readableState;return"string"!=typeof e||n.objectMode||(t=t||n.defaultEncoding,t!==n.encoding&&(e=new j(e,t),t="")),o(this,n,e,t,!1)},i.prototype.unshift=function(e){var t=this._readableState;return o(this,t,e,"",!0)},i.prototype.setEncoding=function(t){k||(k=e("string_decoder").StringDecoder),this._readableState.decoder=new k(t),this._readableState.encoding=t};var A=8388608;i.prototype.read=function(e){var t=this._readableState;t.calledRead=!0;var n=e;if(("number"!=typeof e||e>0)&&(t.emittedReadable=!1),0===e&&t.needReadable&&(t.length>=t.highWaterMark||t.ended))return f(this),null;if(e=u(e,t),0===e&&t.ended)return 0===t.length&&_(this),null;var r=t.needReadable;t.length-e<=t.highWaterMark&&(r=!0),(t.ended||t.reading)&&(r=!1),r&&(t.reading=!0,t.sync=!0,0===t.length&&(t.needReadable=!0),this._read(t.highWaterMark),t.sync=!1),r&&!t.reading&&(e=u(n,t));var i;return i=e>0?m(e,t):null,null===i&&(t.needReadable=!0,e=0),t.length-=e,0!==t.length||t.ended||(t.needReadable=!0),t.ended&&!t.endEmitted&&0===t.length&&_(this),i},i.prototype._read=function(){this.emit("error",new Error("not implemented"))},i.prototype.pipe=function(e,t){function r(e){e===l&&o()}function i(){e.end()}function o(){e.removeListener("close",a),e.removeListener("finish",u),e.removeListener("drain",p),e.removeListener("error",s),e.removeListener("unpipe",r),l.removeListener("end",i),l.removeListener("end",o),(!e._writableState||e._writableState.needDrain)&&p()}function s(t){c(),0===y&&0===S.listenerCount(e,"error")&&e.emit("error",t)}function a(){e.removeListener("finish",u),c()}function u(){e.removeListener("close",a),c()}function c(){l.unpipe(e)}var l=this,f=this._readableState;switch(f.pipesCount){case 0:f.pipes=e;break;case 1:f.pipes=[f.pipes,e];break;default:f.pipes.push(e)}f.pipesCount+=1;var d=(!t||t.end!==!1)&&e!==n.stdout&&e!==n.stderr,h=d?i:o;f.endEmitted?O(h):l.once("end",h),e.on("unpipe",r);var p=g(l);e.on("drain",p);var y=S.listenerCount(e,"error");return e.once("error",s),e.once("close",a),e.once("finish",u),e.emit("pipe",l),f.flowing||(this.on("readable",b),f.flowing=!0,O(function(){v(l)})),e},i.prototype.unpipe=function(e){var t=this._readableState;if(0===t.pipesCount)return this;if(1===t.pipesCount)return e&&e!==t.pipes?this:(e||(e=t.pipes),t.pipes=null,t.pipesCount=0,this.removeListener("readable",b),t.flowing=!1,e&&e.emit("unpipe",this),this);if(!e){var n=t.pipes,r=t.pipesCount;t.pipes=null,t.pipesCount=0,this.removeListener("readable",b),t.flowing=!1;for(var i=0;r>i;i++)n[i].emit("unpipe",this);return this}var i=E(t.pipes,e);return-1===i?this:(t.pipes.splice(i,1),t.pipesCount-=1,1===t.pipesCount&&(t.pipes=t.pipes[0]),e.emit("unpipe",this),this)},i.prototype.on=function(e,t){var n=x.prototype.on.call(this,e,t);if("data"!==e||this._readableState.flowing||y(this),"readable"===e&&this.readable){var r=this._readableState;r.readableListening||(r.readableListening=!0,r.emittedReadable=!1,r.needReadable=!0,r.reading?r.length&&f(this,r):this.read(0))}return n},i.prototype.addListener=i.prototype.on,i.prototype.resume=function(){y(this),this.read(0),this.emit("resume")},i.prototype.pause=function(){y(this,!0),this.emit("pause")},i.prototype.wrap=function(e){var t=this._readableState,n=!1,r=this;e.on("end",function(){if(t.decoder&&!t.ended){var e=t.decoder.end();e&&e.length&&r.push(e)}r.push(null)}),e.on("data",function(i){if(t.decoder&&(i=t.decoder.write(i)),i&&(t.objectMode||i.length)){var o=r.push(i);o||(n=!0,e.pause())}});for(var i in e)"function"==typeof e[i]&&"undefined"==typeof this[i]&&(this[i]=function(t){return function(){return e[t].apply(e,arguments)}}(i));var o=["error","close","destroy","pause","resume"];return w(o,function(t){e.on(t,function(e){return r.emit.apply(r,t,e)})}),r._read=function(){n&&(n=!1,e.resume())},r},i._fromList=m}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"./index.js":24,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,events:18,inherits:33,"process/browser.js":25,string_decoder:30}],28:[function(e,t){function n(e,t){this.afterTransform=function(e,n){return r(t,e,n)},this.needTransform=!1,this.transforming=!1,this.writecb=null,this.writechunk=null}function r(e,t,n){var r=e._transformState;r.transforming=!1;var i=r.writecb;if(!i)return e.emit("error",new Error("no writecb in Transform class"));r.writechunk=null,r.writecb=null,null!==n&&void 0!==n&&e.push(n),i&&i(t);
+var o=e._readableState;o.reading=!1,(o.needReadable||o.length<o.highWaterMark)&&e._read(o.highWaterMark)}function i(e){if(!(this instanceof i))return new i(e);s.call(this,e);var t=(this._transformState=new n(e,this),this);this._readableState.needReadable=!0,this._readableState.sync=!1,this.once("finish",function(){"function"==typeof this._flush?this._flush(function(e){o(t,e)}):o(t)})}function o(e,t){if(t)return e.emit("error",t);var n=e._writableState,r=(e._readableState,e._transformState);if(n.length)throw new Error("calling transform done when ws.length != 0");if(r.transforming)throw new Error("calling transform done when still transforming");return e.push(null)}t.exports=i;var s=e("./duplex.js"),a=e("inherits");a(i,s),i.prototype.push=function(e,t){return this._transformState.needTransform=!1,s.prototype.push.call(this,e,t)},i.prototype._transform=function(){throw new Error("not implemented")},i.prototype._write=function(e,t,n){var r=this._transformState;if(r.writecb=n,r.writechunk=e,r.writeencoding=t,!r.transforming){var i=this._readableState;(r.needTransform||i.needReadable||i.length<i.highWaterMark)&&this._read(i.highWaterMark)}},i.prototype._read=function(){var e=this._transformState;e.writechunk&&e.writecb&&!e.transforming?(e.transforming=!0,this._transform(e.writechunk,e.writeencoding,e.afterTransform)):e.needTransform=!0}},{"./duplex.js":23,inherits:33}],29:[function(e,t){function n(e,t,n){this.chunk=e,this.encoding=t,this.callback=n}function r(e,t){e=e||{};var n=e.highWaterMark;this.highWaterMark=n||0===n?n:16384,this.objectMode=!!e.objectMode,this.highWaterMark=~~this.highWaterMark,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1;var r=e.decodeStrings===!1;this.decodeStrings=!r,this.defaultEncoding=e.defaultEncoding||"utf8",this.length=0,this.writing=!1,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(e){d(t,e)},this.writecb=null,this.writelen=0,this.buffer=[]}function i(e){return this instanceof i||this instanceof E.Duplex?(this._writableState=new r(e,this),this.writable=!0,void E.call(this)):new i(e)}function o(e,t,n){var r=new Error("write after end");e.emit("error",r),k(function(){n(r)})}function s(e,t,n,r){var i=!0;if(!S.isBuffer(n)&&"string"!=typeof n&&null!==n&&void 0!==n&&!t.objectMode){var o=new TypeError("Invalid non-string/buffer chunk");e.emit("error",o),k(function(){r(o)}),i=!1}return i}function a(e,t,n){return e.objectMode||e.decodeStrings===!1||"string"!=typeof t||(t=new S(t,n)),t}function u(e,t,r,i,o){r=a(t,r,i);var s=t.objectMode?1:r.length;t.length+=s;var u=t.length<t.highWaterMark;return t.needDrain=!u,t.writing?t.buffer.push(new n(r,i,o)):c(e,t,s,r,i,o),u}function c(e,t,n,r,i,o){t.writelen=n,t.writecb=o,t.writing=!0,t.sync=!0,e._write(r,i,t.onwrite),t.sync=!1}function l(e,t,n,r,i){n?k(function(){i(r)}):i(r),e.emit("error",r)}function f(e){e.writing=!1,e.writecb=null,e.length-=e.writelen,e.writelen=0}function d(e,t){var n=e._writableState,r=n.sync,i=n.writecb;if(f(n),t)l(e,n,r,t,i);else{var o=v(e,n);o||n.bufferProcessing||!n.buffer.length||g(e,n),r?k(function(){h(e,n,o,i)}):h(e,n,o,i)}}function h(e,t,n,r){n||p(e,t),r(),n&&b(e,t)}function p(e,t){0===t.length&&t.needDrain&&(t.needDrain=!1,e.emit("drain"))}function g(e,t){t.bufferProcessing=!0;for(var n=0;n<t.buffer.length;n++){var r=t.buffer[n],i=r.chunk,o=r.encoding,s=r.callback,a=t.objectMode?1:i.length;if(c(e,t,a,i,o,s),t.writing){n++;break}}t.bufferProcessing=!1,n<t.buffer.length?t.buffer=t.buffer.slice(n):t.buffer.length=0}function v(e,t){return t.ending&&0===t.length&&!t.finished&&!t.writing}function b(e,t){var n=v(e,t);return n&&(t.finished=!0,e.emit("finish")),n}function y(e,t,n){t.ending=!0,b(e,t),n&&(t.finished?k(n):e.once("finish",n)),t.ended=!0}t.exports=i,i.WritableState=r;var m="undefined"!=typeof Uint8Array?function(e){return e instanceof Uint8Array}:function(e){return e&&e.constructor&&"Uint8Array"===e.constructor.name},_="undefined"!=typeof ArrayBuffer?function(e){return e instanceof ArrayBuffer}:function(e){return e&&e.constructor&&"ArrayBuffer"===e.constructor.name},w=e("inherits"),E=e("./index.js"),k=e("process/browser.js").nextTick,S=e("buffer").Buffer;w(i,E),i.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe. Not readable."))},i.prototype.write=function(e,t,n){var r=this._writableState,i=!1;return"function"==typeof t&&(n=t,t=null),!S.isBuffer(e)&&m(e)&&(e=new S(e)),_(e)&&"undefined"!=typeof Uint8Array&&(e=new S(new Uint8Array(e))),S.isBuffer(e)?t="buffer":t||(t=r.defaultEncoding),"function"!=typeof n&&(n=function(){}),r.ended?o(this,r,n):s(this,r,e,n)&&(i=u(this,r,e,t,n)),i},i.prototype._write=function(e,t,n){n(new Error("not implemented"))},i.prototype.end=function(e,t,n){var r=this._writableState;"function"==typeof e?(n=e,e=null,t=null):"function"==typeof t&&(n=t,t=null),"undefined"!=typeof e&&null!==e&&this.write(e,t),r.ending||r.finished||y(this,r,n)}},{"./index.js":24,buffer:20,inherits:33,"process/browser.js":25}],30:[function(e,t,n){function r(e){if(e&&!a.isEncoding(e))throw new Error("Unknown encoding: "+e)}function i(e){return e.toString(this.encoding)}function o(e){var t=this.charReceived=e.length%2;return this.charLength=t?2:0,t}function s(e){var t=this.charReceived=e.length%3;return this.charLength=t?3:0,t}var a=e("buffer").Buffer,u=n.StringDecoder=function(e){switch(this.encoding=(e||"utf8").toLowerCase().replace(/[-_]/,""),r(e),this.encoding){case"utf8":this.surrogateSize=3;break;case"ucs2":case"utf16le":this.surrogateSize=2,this.detectIncompleteChar=o;break;case"base64":this.surrogateSize=3,this.detectIncompleteChar=s;break;default:return void(this.write=i)}this.charBuffer=new a(6),this.charReceived=0,this.charLength=0};u.prototype.write=function(e){for(var t="",n=0;this.charLength;){var r=e.length>=this.charLength-this.charReceived?this.charLength-this.charReceived:e.length;if(e.copy(this.charBuffer,this.charReceived,n,r),this.charReceived+=r-n,n=r,this.charReceived<this.charLength)return"";t=this.charBuffer.slice(0,this.charLength).toString(this.encoding);var i=t.charCodeAt(t.length-1);if(!(i>=55296&&56319>=i)){if(this.charReceived=this.charLength=0,r==e.length)return t;e=e.slice(r,e.length);break}this.charLength+=this.surrogateSize,t=""}var o=this.detectIncompleteChar(e),s=e.length;this.charLength&&(e.copy(this.charBuffer,0,e.length-o,s),this.charReceived=o,s-=o),t+=e.toString(this.encoding,0,s);var s=t.length-1,i=t.charCodeAt(s);if(i>=55296&&56319>=i){var a=this.surrogateSize;return this.charLength+=a,this.charReceived+=a,this.charBuffer.copy(this.charBuffer,a,0,a),this.charBuffer.write(t.charAt(t.length-1),this.encoding),t.substring(0,s)}return t},u.prototype.detectIncompleteChar=function(e){for(var t=e.length>=3?3:e.length;t>0;t--){var n=e[e.length-t];if(1==t&&n>>5==6){this.charLength=2;break}if(2>=t&&n>>4==14){this.charLength=3;break}if(3>=t&&n>>3==30){this.charLength=4;break}}return t},u.prototype.end=function(e){var t="";if(e&&e.length&&(t=this.write(e)),this.charReceived){var n=this.charReceived,r=this.charBuffer,i=this.encoding;t+=r.slice(0,n).toString(i)}return t}},{buffer:20}],31:[function(e,t){t.exports=function(e){return e&&"object"==typeof e&&"function"==typeof e.copy&&"function"==typeof e.fill&&"function"==typeof e.readUInt8}},{}],32:[function(e,t,n){(function(t,r){function i(e,t){var r={seen:[],stylize:s};return arguments.length>=3&&(r.depth=arguments[2]),arguments.length>=4&&(r.colors=arguments[3]),g(t)?r.showHidden=t:t&&n._extend(r,t),w(r.showHidden)&&(r.showHidden=!1),w(r.depth)&&(r.depth=2),w(r.colors)&&(r.colors=!1),w(r.customInspect)&&(r.customInspect=!0),r.colors&&(r.stylize=o),u(r,e,r.depth)}function o(e,t){var n=i.styles[t];return n?"["+i.colors[n][0]+"m"+e+"["+i.colors[n][1]+"m":e}function s(e){return e}function a(e){var t={};return e.forEach(function(e){t[e]=!0}),t}function u(e,t,r){if(e.customInspect&&t&&j(t.inspect)&&t.inspect!==n.inspect&&(!t.constructor||t.constructor.prototype!==t)){var i=t.inspect(r,e);return m(i)||(i=u(e,i,r)),i}var o=c(e,t);if(o)return o;var s=Object.keys(t),g=a(s);if(e.showHidden&&(s=Object.getOwnPropertyNames(t)),x(t)&&(s.indexOf("message")>=0||s.indexOf("description")>=0))return l(t);if(0===s.length){if(j(t)){var v=t.name?": "+t.name:"";return e.stylize("[Function"+v+"]","special")}if(E(t))return e.stylize(RegExp.prototype.toString.call(t),"regexp");if(S(t))return e.stylize(Date.prototype.toString.call(t),"date");if(x(t))return l(t)}var b="",y=!1,_=["{","}"];if(p(t)&&(y=!0,_=["[","]"]),j(t)){var w=t.name?": "+t.name:"";b=" [Function"+w+"]"}if(E(t)&&(b=" "+RegExp.prototype.toString.call(t)),S(t)&&(b=" "+Date.prototype.toUTCString.call(t)),x(t)&&(b=" "+l(t)),0===s.length&&(!y||0==t.length))return _[0]+b+_[1];if(0>r)return E(t)?e.stylize(RegExp.prototype.toString.call(t),"regexp"):e.stylize("[Object]","special");e.seen.push(t);var k;return k=y?f(e,t,r,g,s):s.map(function(n){return d(e,t,r,g,n,y)}),e.seen.pop(),h(k,b,_)}function c(e,t){if(w(t))return e.stylize("undefined","undefined");if(m(t)){var n="'"+JSON.stringify(t).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return e.stylize(n,"string")}return y(t)?e.stylize(""+t,"number"):g(t)?e.stylize(""+t,"boolean"):v(t)?e.stylize("null","null"):void 0}function l(e){return"["+Error.prototype.toString.call(e)+"]"}function f(e,t,n,r,i){for(var o=[],s=0,a=t.length;a>s;++s)o.push(R(t,String(s))?d(e,t,n,r,String(s),!0):"");return i.forEach(function(i){i.match(/^\d+$/)||o.push(d(e,t,n,r,i,!0))}),o}function d(e,t,n,r,i,o){var s,a,c;if(c=Object.getOwnPropertyDescriptor(t,i)||{value:t[i]},c.get?a=c.set?e.stylize("[Getter/Setter]","special"):e.stylize("[Getter]","special"):c.set&&(a=e.stylize("[Setter]","special")),R(r,i)||(s="["+i+"]"),a||(e.seen.indexOf(c.value)<0?(a=v(n)?u(e,c.value,null):u(e,c.value,n-1),a.indexOf("\n")>-1&&(a=o?a.split("\n").map(function(e){return" "+e}).join("\n").substr(2):"\n"+a.split("\n").map(function(e){return" "+e}).join("\n"))):a=e.stylize("[Circular]","special")),w(s)){if(o&&i.match(/^\d+$/))return a;s=JSON.stringify(""+i),s.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(s=s.substr(1,s.length-2),s=e.stylize(s,"name")):(s=s.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),s=e.stylize(s,"string"))}return s+": "+a}function h(e,t,n){var r=0,i=e.reduce(function(e,t){return r++,t.indexOf("\n")>=0&&r++,e+t.replace(/\u001b\[\d\d?m/g,"").length+1},0);return i>60?n[0]+(""===t?"":t+"\n ")+" "+e.join(",\n ")+" "+n[1]:n[0]+t+" "+e.join(", ")+" "+n[1]}function p(e){return Array.isArray(e)}function g(e){return"boolean"==typeof e}function v(e){return null===e}function b(e){return null==e}function y(e){return"number"==typeof e}function m(e){return"string"==typeof e}function _(e){return"symbol"==typeof e}function w(e){return void 0===e}function E(e){return k(e)&&"[object RegExp]"===L(e)}function k(e){return"object"==typeof e&&null!==e}function S(e){return k(e)&&"[object Date]"===L(e)}function x(e){return k(e)&&("[object Error]"===L(e)||e instanceof Error)}function j(e){return"function"==typeof e}function O(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"==typeof e||"undefined"==typeof e}function L(e){return Object.prototype.toString.call(e)}function A(e){return 10>e?"0"+e.toString(10):e.toString(10)}function I(){var e=new Date,t=[A(e.getHours()),A(e.getMinutes()),A(e.getSeconds())].join(":");return[e.getDate(),B[e.getMonth()],t].join(" ")}function R(e,t){return Object.prototype.hasOwnProperty.call(e,t)}var T=/%[sdj%]/g;n.format=function(e){if(!m(e)){for(var t=[],n=0;n<arguments.length;n++)t.push(i(arguments[n]));return t.join(" ")}for(var n=1,r=arguments,o=r.length,s=String(e).replace(T,function(e){if("%%"===e)return"%";if(n>=o)return e;switch(e){case"%s":return String(r[n++]);case"%d":return Number(r[n++]);case"%j":try{return JSON.stringify(r[n++])}catch(t){return"[Circular]"}default:return e}}),a=r[n];o>n;a=r[++n])s+=v(a)||!k(a)?" "+a:" "+i(a);return s},n.deprecate=function(e,i){function o(){if(!s){if(t.throwDeprecation)throw new Error(i);t.traceDeprecation?console.trace(i):console.error(i),s=!0}return e.apply(this,arguments)}if(w(r.process))return function(){return n.deprecate(e,i).apply(this,arguments)};if(t.noDeprecation===!0)return e;var s=!1;return o};var C,N={};n.debuglog=function(e){if(w(C)&&(C=t.env.NODE_DEBUG||""),e=e.toUpperCase(),!N[e])if(new RegExp("\\b"+e+"\\b","i").test(C)){var r=t.pid;N[e]=function(){var t=n.format.apply(n,arguments);console.error("%s %d: %s",e,r,t)}}else N[e]=function(){};return N[e]},n.inspect=i,i.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]},i.styles={special:"cyan",number:"yellow","boolean":"yellow",undefined:"grey","null":"bold",string:"green",date:"magenta",regexp:"red"},n.isArray=p,n.isBoolean=g,n.isNull=v,n.isNullOrUndefined=b,n.isNumber=y,n.isString=m,n.isSymbol=_,n.isUndefined=w,n.isRegExp=E,n.isObject=k,n.isDate=S,n.isError=x,n.isFunction=j,n.isPrimitive=O,n.isBuffer=e("./support/isBuffer");var B=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];n.log=function(){console.log("%s - %s",I(),n.format.apply(n,arguments))},n.inherits=e("inherits"),n._extend=function(e,t){if(!t||!k(t))return e;for(var n=Object.keys(t),r=n.length;r--;)e[n[r]]=t[n[r]];return e}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./support/isBuffer":31,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,inherits:33}],33:[function(e,t){t.exports="function"==typeof Object.create?function(e,t){e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}})}:function(e,t){e.super_=t;var n=function(){};n.prototype=t.prototype,e.prototype=new n,e.prototype.constructor=e}},{}],34:[function(e,t){function n(e,t,n,r){var i={type:e,key:t,value:n,options:r};return r&&r.prefix&&(i.prefix=r.prefix,delete r.prefix),this._operations.push(i),this}function r(e){this._operations=[],this._sdb=e,this.put=n.bind(this,"put"),this.del=n.bind(this,"del")}var i=r.prototype;i.clear=function(){this._operations=[]},i.write=function(e){this._sdb.batch(this._operations,e)},t.exports=r},{}],35:[function(e,t){(function(n){var r=(e("events").EventEmitter,n.nextTick,e("./sub")),i=e("./batch"),o=e("level-fix-range"),s=e("level-hooks");t.exports=function(e,t){function n(){}function a(e){return function(t){return t=t||{},t=o(t),t.reverse?t.start=t.start||c:t.end=t.end||c,e.call(u,t)}}n.prototype=e;var u=new n;if(u.sublevel)return u;t=t||{};var c=t.sep=t.sep||"ÿ";u._options=t,s(u),u.sublevels={},u.sublevel=function(e,t){return u.sublevels[e]?u.sublevels[e]:new r(u,e,t||this._options)},u.methods={},u.prefix=function(e){return""+(e||"")},u.pre=function(e,t){return t||(t=e,e={max:c}),u.hooks.pre(e,t)},u.post=function(e,t){return t||(t=e,e={max:c}),u.hooks.post(e,t)},u.readStream=u.createReadStream=a(u.createReadStream),u.keyStream=u.createKeyStream=a(u.createKeyStream),u.valuesStream=u.createValueStream=a(u.createValueStream);var l=u.batch;return u.batch=function(e,t,n){return Array.isArray(e)?(e.forEach(function(e){e.prefix&&("function"==typeof e.prefix.prefix?e.key=e.prefix.prefix(e.key):"string"==typeof e.prefix&&(e.key=e.prefix+e.key))}),void l.call(u,e,t,n)):new i(u)},u}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"./batch":34,"./sub":46,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,events:18,"level-fix-range":36,"level-hooks":38}],36:[function(e,t){var n=e("clone");t.exports=function(e){e=n(e);var t=e.reverse,r=e.max||e.end,i=e.min||e.start,o=[i,r];return null!=i&&null!=r&&o.sort(),t&&(o=o.reverse()),e.start=o[0],e.end=o[1],delete e.min,delete e.max,e}},{clone:37}],37:[function(e,t){(function(e){"use strict";function n(e){return Object.prototype.toString.call(e)}function r(t,n,r,o){function s(t,r){if(null===t)return null;if(0==r)return t;var l;if("object"!=typeof t)return t;if(i.isArray(t))l=[];else if(i.isRegExp(t))l=new RegExp(t.source,i.getRegExpFlags(t)),t.lastIndex&&(l.lastIndex=t.lastIndex);else if(i.isDate(t))l=new Date(t.getTime());else{if(c&&e.isBuffer(t))return l=new e(t.length),t.copy(l),l;l=Object.create("undefined"==typeof o?Object.getPrototypeOf(t):o)}if(n){var f=a.indexOf(t);if(-1!=f)return u[f];a.push(t),u.push(l)}for(var d in t)l[d]=s(t[d],r-1);return l}var a=[],u=[],c="undefined"!=typeof e;return"undefined"==typeof n&&(n=!0),"undefined"==typeof r&&(r=1/0),s(t,r)}var i={isArray:function(e){return Array.isArray(e)||"object"==typeof e&&"[object Array]"===n(e)},isDate:function(e){return"object"==typeof e&&"[object Date]"===n(e)},isRegExp:function(e){return"object"==typeof e&&"[object RegExp]"===n(e)},getRegExpFlags:function(e){var t="";return e.global&&(t+="g"),e.ignoreCase&&(t+="i"),e.multiline&&(t+="m"),t}};"object"==typeof t&&(t.exports=r),r.clonePrototype=function(e){if(null===e)return null;var t=function(){};return t.prototype=e,new t}}).call(this,e("buffer").Buffer)},{buffer:20}],38:[function(e,t){var n=e("string-range");t.exports=function(e){function t(e){return e&&("string"==typeof e?e:"string"==typeof e.prefix?e.prefix:"function"==typeof e.prefix?e.prefix():"")}function r(e){return e&&e._getKeyEncoding?e._getKeyEncoding(e):void 0}function i(e){return e&&e._getValueEncoding?e._getValueEncoding(e):void 0}function o(e,t){return function(){var n=e.indexOf(t);return~n?(e.splice(n,1),!0):!1}}function s(e){e&&e.type&&u.forEach(function(t){t.test(e.key)&&t.hook(e)})}function a(n,o,s,a){try{o.forEach(function p(e,n){c.forEach(function(s){if(s.test(String(e.key))){var a={add:function(e,a){if("undefined"==typeof e)return this;if(e===!1)return delete o[n];var u=t(e.prefix)||t(a)||s.prefix||"";if(u&&(e.prefix=u),e.key=u+e.key,s.safe&&s.test(String(e.key)))throw new Error("prehook cannot insert into own range");var c=e.keyEncoding||r(e.prefix),l=e.valueEncoding||i(e.prefix);return c&&(e.keyEncoding=c),l&&(e.valueEncoding=l),o.push(e),p(e,o.length-1),this},put:function(e,t){return"object"==typeof e&&(e.type="put"),this.add(e,t)},del:function(e,t){return"object"==typeof e&&(e.type="del"),this.add(e,t)},veto:function(){return this.add(!1)}};s.hook.call(a,e,a.add,o)}})})}catch(u){return(a||s)(u)}if(o=o.filter(function(e){return e&&e.type}),1==o.length&&!n){var h=o[0];return"put"==h.type?l.call(e,h.key,h.value,s,a):f.call(e,h.key,s,a)}return d.call(e,o,s,a)}if(!e.hooks){var u=[],c=[];e.hooks={post:function(e,t){t||(t=e,e="");var r={test:n.checker(e),hook:t};return u.push(r),o(u,r)},pre:function(e,t){t||(t=e,e="");var r={test:n.checker(e),hook:t,safe:!1!==e.safe};return c.push(r),o(c,r)},posthooks:u,prehooks:c},e.on("put",function(e,t){s({type:"put",key:e,value:t})}),e.on("del",function(e,t){s({type:"del",key:e,value:t})}),e.on("batch",function(e){e.forEach(s)});var l=e.put,f=e.del,d=e.batch;e.put=function(e,t,n,r){var i=[{key:e,value:t,type:"put"}];return a(!1,i,n,r)},e.del=function(e,t,n){var r=[{key:e,type:"del"}];return a(!1,r,t,n)},e.batch=function(e,t,n){return a(!0,e,t,n)}}}},{"string-range":39}],39:[function(e,t,n){{var r=n.range=function(e){return null==e?{}:"string"==typeof r?{min:r,max:r+"ÿ"}:e},i=(n.prefix=function(e,t,r){e=n.range(e);var i={};return r=r||"ÿ",e instanceof RegExp||"function"==typeof e?(i.min=t,i.max=t+r,i.inner=function(n){var r=n.substring(t.length);return e.test?e.test(r):e(r)}):"object"==typeof e&&(i.min=t+(e.min||e.start||""),i.max=t+(e.max||e.end||r||"~"),i.reverse=!!e.reverse),i},n.checker=function(e){return e||(e={}),"string"==typeof e?function(t){return 0==t.indexOf(e)}:e instanceof RegExp?function(t){return e.test(t)}:"object"==typeof e?function(t){var n=e.min||e.start,r=e.max||e.end;return t=String(t),(!n||t>=n)&&(!r||r>=t)&&(!e.inner||(e.inner.test?e.inner.test(t):e.inner(t)))}:"function"==typeof e?e:void 0});n.satisfies=function(e,t){return i(t)(e)}}},{}],40:[function(e,t){function n(e){return null!==e&&("object"==typeof e||"function"==typeof e)}t.exports=n},{}],41:[function(e,t){function n(){for(var e={},t=0;t<arguments.length;t++){var n=arguments[t];if(i(n))for(var o=r(n),s=0;s<o.length;s++){var a=o[s];e[a]=n[a]}}return e}var r=e("object-keys"),i=e("./has-keys");t.exports=n},{"./has-keys":40,"object-keys":42}],42:[function(e,t){t.exports=Object.keys||e("./shim")},{"./shim":45}],43:[function(e,t){var n=Object.prototype.hasOwnProperty,r=Object.prototype.toString;t.exports=function(e,t,i){if("[object Function]"!==r.call(t))throw new TypeError("iterator must be a function");var o=e.length;if(o===+o)for(var s=0;o>s;s++)t.call(i,e[s],s,e);else for(var a in e)n.call(e,a)&&t.call(i,e[a],a,e)}},{}],44:[function(e,t){var n=Object.prototype,r=n.hasOwnProperty,i=n.toString,o=function(e){return e!==e},s={"boolean":1,number:1,string:1,undefined:1},a=t.exports={};a.a=a.type=function(e,t){return typeof e===t},a.defined=function(e){return void 0!==e},a.empty=function(e){var t,n=i.call(e);if("[object Array]"===n||"[object Arguments]"===n)return 0===e.length;if("[object Object]"===n){for(t in e)if(r.call(e,t))return!1;return!0}return"[object String]"===n?""===e:!1},a.equal=function(e,t){var n,r=i.call(e);if(r!==i.call(t))return!1;if("[object Object]"===r){for(n in e)if(!a.equal(e[n],t[n]))return!1;return!0}if("[object Array]"===r){if(n=e.length,n!==t.length)return!1;for(;--n;)if(!a.equal(e[n],t[n]))return!1;return!0}return"[object Function]"===r?e.prototype===t.prototype:"[object Date]"===r?e.getTime()===t.getTime():e===t},a.hosted=function(e,t){var n=typeof t[e];return"object"===n?!!t[e]:!s[n]},a.instance=a["instanceof"]=function(e,t){return e instanceof t},a["null"]=function(e){return null===e},a.undefined=function(e){return void 0===e},a.arguments=function(e){var t="[object Arguments]"===i.call(e),n=!a.array(e)&&a.arraylike(e)&&a.object(e)&&a.fn(e.callee);return t||n},a.array=function(e){return"[object Array]"===i.call(e)},a.arguments.empty=function(e){return a.arguments(e)&&0===e.length},a.array.empty=function(e){return a.array(e)&&0===e.length},a.arraylike=function(e){return!!e&&!a.boolean(e)&&r.call(e,"length")&&isFinite(e.length)&&a.number(e.length)&&e.length>=0},a.boolean=function(e){return"[object Boolean]"===i.call(e)},a["false"]=function(e){return a.boolean(e)&&(e===!1||e.valueOf()===!1)},a["true"]=function(e){return a.boolean(e)&&(e===!0||e.valueOf()===!0)},a.date=function(e){return"[object Date]"===i.call(e)},a.element=function(e){return void 0!==e&&"undefined"!=typeof HTMLElement&&e instanceof HTMLElement&&1===e.nodeType},a.error=function(e){return"[object Error]"===i.call(e)},a.fn=a["function"]=function(e){var t="undefined"!=typeof window&&e===window.alert;return t||"[object Function]"===i.call(e)},a.number=function(e){return"[object Number]"===i.call(e)},a.infinite=function(e){return 1/0===e||e===-1/0},a.decimal=function(e){return a.number(e)&&!o(e)&&!a.infinite(e)&&e%1!==0},a.divisibleBy=function(e,t){var n=a.infinite(e),r=a.infinite(t),i=a.number(e)&&!o(e)&&a.number(t)&&!o(t)&&0!==t;return n||r||i&&e%t===0},a.int=function(e){return a.number(e)&&!o(e)&&e%1===0},a.maximum=function(e,t){if(o(e))throw new TypeError("NaN is not a valid value");if(!a.arraylike(t))throw new TypeError("second argument must be array-like");for(var n=t.length;--n>=0;)if(e<t[n])return!1;return!0},a.minimum=function(e,t){if(o(e))throw new TypeError("NaN is not a valid value");if(!a.arraylike(t))throw new TypeError("second argument must be array-like");for(var n=t.length;--n>=0;)if(e>t[n])return!1;return!0},a.nan=function(e){return!a.number(e)||e!==e},a.even=function(e){return a.infinite(e)||a.number(e)&&e===e&&e%2===0},a.odd=function(e){return a.infinite(e)||a.number(e)&&e===e&&e%2!==0},a.ge=function(e,t){if(o(e)||o(t))throw new TypeError("NaN is not a valid value");return!a.infinite(e)&&!a.infinite(t)&&e>=t},a.gt=function(e,t){if(o(e)||o(t))throw new TypeError("NaN is not a valid value");return!a.infinite(e)&&!a.infinite(t)&&e>t},a.le=function(e,t){if(o(e)||o(t))throw new TypeError("NaN is not a valid value");return!a.infinite(e)&&!a.infinite(t)&&t>=e},a.lt=function(e,t){if(o(e)||o(t))throw new TypeError("NaN is not a valid value");return!a.infinite(e)&&!a.infinite(t)&&t>e},a.within=function(e,t,n){if(o(e)||o(t)||o(n))throw new TypeError("NaN is not a valid value");if(!a.number(e)||!a.number(t)||!a.number(n))throw new TypeError("all arguments must be numbers");var r=a.infinite(e)||a.infinite(t)||a.infinite(n);return r||e>=t&&n>=e},a.object=function(e){return e&&"[object Object]"===i.call(e)},a.hash=function(e){return a.object(e)&&e.constructor===Object&&!e.nodeType&&!e.setInterval},a.regexp=function(e){return"[object RegExp]"===i.call(e)},a.string=function(e){return"[object String]"===i.call(e)}},{}],45:[function(e,t){!function(){"use strict";var n,r=Object.prototype.hasOwnProperty,i=e("is"),o=e("foreach"),s=!{toString:null}.propertyIsEnumerable("toString"),a=["toString","toLocaleString","valueOf","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","constructor"];n=function(e){if(!i.object(e)&&!i.array(e))throw new TypeError("Object.keys called on a non-object");var t,n=[];for(t in e)r.call(e,t)&&n.push(t);return s&&o(a,function(t){r.call(e,t)&&n.push(t)}),n},t.exports=n}()},{foreach:43,is:44}],46:[function(e,t){function n(e,t,r){if("string"==typeof r&&(console.error("db.sublevel(name, seperator<string>) is depreciated"),console.error("use db.sublevel(name, {sep: separator})) if you must"),r={sep:r}),!(this instanceof n))return new n(e,t,r);if(!e)throw new Error("must provide db");if(!t)throw new Error("must provide prefix");r=r||{},r.sep=r.sep||"ÿ",this._parent=e,this._options=r,this.options=r,this._prefix=t,this._root=i(this),e.sublevels[t]=this,this.sublevels={},this.methods={};var o=this;this.hooks={pre:function(){return o.pre.apply(o,arguments)},post:function(){return o.post.apply(o,arguments)}}}function r(e,t){["valueEncoding","encoding","keyEncoding","reverse","values","keys","limit","fillCache"].forEach(function(n){t.hasOwnProperty(n)&&(e[n]=t[n])})}function i(e){return e._parent?i(e._parent):e}var o=e("events").EventEmitter,s=e("util").inherits,a=e("string-range"),u=e("level-fix-range"),c=e("xtend"),l=e("./batch");s(n,o);var f=n.prototype;f._key=function(e){var t=this._options.sep;return t+this._prefix+t+e},f._getOptsAndCb=function(e,t){return"function"==typeof e&&(t=e,e={}),{opts:c(e,this._options),cb:t}},f.sublevel=function(e,t){return this.sublevels[e]?this.sublevels[e]:new n(this,e,t||this._options)},f.put=function(e,t,n,r){var i=this._getOptsAndCb(n,r);this._root.put(this.prefix(e),t,i.opts,i.cb)},f.get=function(e,t,n){var r=this._getOptsAndCb(t,n);this._root.get(this.prefix(e),r.opts,r.cb)},f.del=function(e,t,n){var r=this._getOptsAndCb(t,n);this._root.del(this.prefix(e),r.opts,r.cb)},f.batch=function(e,t,n){if(!Array.isArray(e))return new l(this);var r=this,i=this._getOptsAndCb(t,n);e.forEach(function(e){e.key="string"==typeof e.prefix?e.prefix+e.key:(e.prefix||r).prefix(e.key),e.prefix&&(e.prefix=null)}),this._root.batch(e,i.opts,i.cb)},f._getKeyEncoding=function(){return this.options.keyEncoding?this.options.keyEncoding:this._parent&&this._parent._getKeyEncoding?this._parent._getKeyEncoding():void 0},f._getValueEncoding=function(){return this.options.valueEncoding?this.options.valueEncoding:this._parent&&this._parent._getValueEncoding?this._parent._getValueEncoding():void 0},f.prefix=function(e){var t=this._options.sep;return this._parent.prefix()+t+this._prefix+t+(e||"")},f.keyStream=f.createKeyStream=function(e){return e=e||{},e.keys=!0,e.values=!1,this.createReadStream(e)},f.valueStream=f.createValueStream=function(e){return e=e||{},e.keys=!1,e.values=!0,e.keys=!1,this.createReadStream(e)},f.readStream=f.createReadStream=function(e){e=e||{};var t=i(this),n=this.prefix(),o=a.prefix(e,n);r(o,c(e,this._options));var s=t.createReadStream(o);if(o.values===!1){var u=s.read;if(u)s.read=function(e){var t=u.call(this,e);return t&&(t=t.substring(n.length)),t};else{var l=s.emit;s.emit=function(e,t){"data"===e?l.call(this,"data",t.substring(n.length)):l.call(this,e,t)}}return s}if(o.keys===!1)return s;var u=s.read;return u?s.read=function(e){var t=u.call(this,e);return t&&(t.key=t.key.substring(n.length)),t}:s.on("data",function(e){e.key=e.key.substring(n.length)}),s},f.writeStream=f.createWriteStream=function(){var e=i(this),t=this.prefix(),n=e.createWriteStream.apply(e,arguments),r=n.write,o=this._options.encoding,s=this._options.valueEncoding,a=this._options.keyEncoding,u=!o&&!s&&!a;return n.write=u?function(e){return e.key=t+e.key,r.call(n,e)}:function(e){return e.key=t+e.key,o&&"undefined"==typeof e.encoding&&(e.encoding=o),s&&"undefined"==typeof e.valueEncoding&&(e.valueEncoding=s),a&&"undefined"==typeof e.keyEncoding&&(e.keyEncoding=a),r.call(n,e)},n},f.approximateSize=function(){var e=i(db);return e.approximateSize.apply(e,arguments)},f.pre=function(e,t){t||(t=e,e=null),e=a.prefix(e,this.prefix(),this._options.sep);var n=i(this._parent),r=this.prefix();return n.hooks.pre(u(e),function(e,n,i){t({key:e.key.substring(r.length),value:e.value,type:e.type},function(e,t){n(e,e.prefix?t:t||r)},i)})},f.post=function(e,t){t||(t=e,e=null);var n=i(this._parent),r=this.prefix();return e=a.prefix(e,r,this._options.sep),n.hooks.post(u(e),function(e){t({key:e.key.substring(r.length),value:e.value,type:e.type})})};t.exports=n},{"./batch":34,events:18,"level-fix-range":36,"string-range":39,util:32,xtend:41}],47:[function(e,t){function n(e){this._levelup=e,this.batch=e.db.batch(),this.ops=[]}var r=e("./util"),i=e("./errors").WriteError,o=r.getOptions,s=r.dispatchError;n.prototype.put=function(e,t,n){n=o(this._levelup,n);var s=r.encodeKey(e,n),a=r.encodeValue(t,n);try{this.batch.put(s,a)}catch(u){throw new i(u)}return this.ops.push({type:"put",key:s,value:a}),this},n.prototype.del=function(e,t){t=o(this._levelup,t);var n=r.encodeKey(e,t);try{this.batch.del(n)}catch(s){throw new i(s)}return this.ops.push({type:"del",key:n}),this},n.prototype.clear=function(){try{this.batch.clear()}catch(e){throw new i(e)}return this.ops=[],this},n.prototype.write=function(e){var t=this._levelup,n=this.ops;try{this.batch.write(function(r){return r?s(t,new i(r),e):(t.emit("batch",n),void(e&&e()))})}catch(r){throw new i(r)}},t.exports=n},{"./errors":48,"./util":51}],48:[function(e,t){var n=e("errno").create,r=n("LevelUPError"),i=n("NotFoundError",r);i.prototype.notFound=!0,i.prototype.status=404,t.exports={LevelUPError:r,InitializationError:n("InitializationError",r),OpenError:n("OpenError",r),ReadError:n("ReadError",r),WriteError:n("WriteError",r),NotFoundError:i,EncodingError:n("EncodingError",r)}},{errno:59}],49:[function(e,t){(function(n){function r(e,t){return"function"==typeof e?e:t}function i(e,t,r){if(!(this instanceof i))return new i(e,t,r);var o;if(s.call(this),this.setMaxListeners(1/0),"function"==typeof e?(t="object"==typeof t?t:{},t.db=e,e=null):"object"==typeof e&&"function"==typeof e.db&&(t=e,e=null),"function"==typeof t&&(r=t,t={}),(!t||"function"!=typeof t.db)&&"string"!=typeof e){if(o=new v("Must provide a location for the database"),r)return n.nextTick(function(){r(o)});throw o}t=w(this,t),this.options=u(E,t),this._status="new",c(this,"location",e,"e"),this.open(r)}function o(e){return function(t,n){k()[e](t,n||function(){})}}var s=e("events").EventEmitter,a=e("util").inherits,u=e("xtend"),c=e("prr"),l=e("deferred-leveldown"),f=e("./errors").WriteError,d=e("./errors").ReadError,h=e("./errors").NotFoundError,p=e("./errors").OpenError,g=e("./errors").EncodingError,v=e("./errors").InitializationError,b=e("./read-stream"),y=e("./write-stream"),m=e("./util"),_=e("./batch"),w=m.getOptions,E=m.defaultOptions,k=m.getLevelDOWN,S=m.dispatchError;
+a(i,s),i.prototype.open=function(e){var t,r,i=this;return this.isOpen()?(e&&n.nextTick(function(){e(null,i)}),this):this._isOpening()?e&&this.once("open",function(){e(null,i)}):(this.emit("opening"),this._status="opening",this.db=new l(this.location),t=this.options.db||k(),r=t(this.location),void r.open(this.options,function(t){return t?S(i,new p(t),e):(i.db.setDb(r),i.db=r,i._status="open",e&&e(null,i),i.emit("open"),i.emit("ready"),void 0)}))},i.prototype.close=function(e){var t=this;if(this.isOpen())this._status="closing",this.db.close(function(){t._status="closed",t.emit("closed"),e&&e.apply(null,arguments)}),this.emit("closing"),this.db=null;else{if("closed"==this._status&&e)return n.nextTick(e);"closing"==this._status&&e?this.once("closed",e):this._isOpening()&&this.once("open",function(){t.close(e)})}},i.prototype.isOpen=function(){return"open"==this._status},i.prototype._isOpening=function(){return"opening"==this._status},i.prototype.isClosed=function(){return/^clos/.test(this._status)},i.prototype.get=function(e,t,n){var i,o=this;return n=r(t,n),"function"!=typeof n?S(this,new d("get() requires key and callback arguments")):this._isOpening()||this.isOpen()?(t=m.getOptions(this,t),i=m.encodeKey(e,t),t.asBuffer=m.isValueAsBuffer(t),void this.db.get(i,t,function(r,i){if(r)return r=/notfound/i.test(r)?new h("Key not found in database ["+e+"]",r):new d(r),S(o,r,n);if(n){try{i=m.decodeValue(i,t)}catch(s){return n(new g(s))}n(null,i)}})):S(this,new d("Database is not open"),n)},i.prototype.put=function(e,t,n,i){var o,s,a=this;return i=r(n,i),null===e||void 0===e||null===t||void 0===t?S(this,new f("put() requires key and value arguments"),i):this._isOpening()||this.isOpen()?(n=w(this,n),o=m.encodeKey(e,n),s=m.encodeValue(t,n),void this.db.put(o,s,n,function(n){return n?S(a,new f(n),i):(a.emit("put",e,t),void(i&&i()))})):S(this,new f("Database is not open"),i)},i.prototype.del=function(e,t,n){var i,o=this;return n=r(t,n),null===e||void 0===e?S(this,new f("del() requires a key argument"),n):this._isOpening()||this.isOpen()?(t=w(this,t),i=m.encodeKey(e,t),void this.db.del(i,t,function(t){return t?S(o,new f(t),n):(o.emit("del",e),void(n&&n()))})):S(this,new f("Database is not open"),n)},i.prototype.batch=function(e,t,n){var i,o,s,a=this;return arguments.length?(n=r(t,n),Array.isArray(e)?this._isOpening()||this.isOpen()?(t=w(this,t),i=t.keyEncoding,o=t.valueEncoding,s=e.map(function(e){if(void 0===e.type||void 0===e.key)return{};var n,r=e.keyEncoding||i,s=e.valueEncoding||e.encoding||o;return"utf8"!=r&&"binary"!=r||"utf8"!=s&&"binary"!=s?(n={type:e.type,key:m.encodeKey(e.key,t,e)},void 0!==e.value&&(n.value=m.encodeValue(e.value,t,e)),n):e}),void this.db.batch(s,t,function(t){return t?S(a,new f(t),n):(a.emit("batch",e),void(n&&n()))})):S(this,new f("Database is not open"),n):S(this,new f("batch() requires an array argument"),n)):new _(this)},i.prototype.approximateSize=function(e,t,n){var r,i,o=this;return null===e||void 0===e||null===t||void 0===t||"function"!=typeof n?S(this,new d("approximateSize() requires start, end and callback arguments"),n):(r=m.encodeKey(e,this.options),i=m.encodeKey(t,this.options),this._isOpening()||this.isOpen()?void this.db.approximateSize(r,i,function(e,t){return e?S(o,new p(e),n):void(n&&n(null,t))}):S(this,new f("Database is not open"),n))},i.prototype.readStream=i.prototype.createReadStream=function(e){var t=this;return e=u(this.options,e),new b(e,this,function(e){return t.db.iterator(e)})},i.prototype.keyStream=i.prototype.createKeyStream=function(e){return this.createReadStream(u(e,{keys:!0,values:!1}))},i.prototype.valueStream=i.prototype.createValueStream=function(e){return this.createReadStream(u(e,{keys:!1,values:!0}))},i.prototype.writeStream=i.prototype.createWriteStream=function(e){return new y(u(e),this)},i.prototype.toString=function(){return"LevelUP"},t.exports=i,t.exports.copy=m.copy,t.exports.destroy=o("destroy"),t.exports.repair=o("repair")}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"./batch":47,"./errors":48,"./read-stream":50,"./util":51,"./write-stream":52,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"deferred-leveldown":54,events:18,prr:60,util:32,xtend:70}],50:[function(e,t){function n(e,t,i){if(!(this instanceof n))return new n(e,t,i);r.call(this,{objectMode:!0,highWaterMark:e.highWaterMark}),this._db=t,e=this._options=o(u,e),this._keyEncoding=e.keyEncoding||e.encoding,this._valueEncoding=e.valueEncoding||e.encoding,"undefined"!=typeof this._options.start&&(this._options.start=a.encodeKey(this._options.start,this._options)),"undefined"!=typeof this._options.end&&(this._options.end=a.encodeKey(this._options.end,this._options)),"number"!=typeof this._options.limit&&(this._options.limit=-1),this._options.keyAsBuffer=a.isKeyAsBuffer(this._options),this._options.valueAsBuffer=a.isValueAsBuffer(this._options),this._makeData=this._options.keys&&this._options.values?c:this._options.keys?l:this._options.values?f:d;var s=this;this._db.isOpen()?this._iterator=i(this._options):this._db.once("ready",function(){s._destroyed||(s._iterator=i(s._options))})}var r=e("readable-stream").Readable,i=e("util").inherits,o=e("xtend"),s=e("./errors").EncodingError,a=e("./util"),u={keys:!0,values:!0},c=function(e,t){return{key:a.decodeKey(e,this._options),value:a.decodeValue(t,this._options)}},l=function(e){return a.decodeKey(e,this._options)},f=function(e,t){return a.decodeValue(t,this._options)},d=function(){return null};i(n,r),n.prototype._read=function h(){var e=this;return e._db.isOpen()?void(e._destroyed||e._iterator.next(function(t,n,r){if(t||void 0===n&&void 0===r)return t||e._destroyed||e.push(null),e._cleanup(t);try{r=e._makeData(n,r)}catch(i){return e._cleanup(new s(i))}e._destroyed||e.push(r)})):e._db.once("ready",function(){h.call(e)})},n.prototype._cleanup=function(e){if(!this._destroyed){this._destroyed=!0;var t=this;e&&t.emit("error",e),t._iterator?t._iterator.end(function(){t._iterator=null,t.emit("close")}):t.emit("close")}},n.prototype.destroy=function(){this._cleanup()},n.prototype.toString=function(){return"LevelUP.ReadStream"},t.exports=n},{"./errors":48,"./util":51,"readable-stream":69,util:32,xtend:70}],51:[function(e,t){(function(n,r){function i(e,t,n){e.readStream().pipe(t.writeStream()).on("close",n?n:function(){}).on("error",n?n:function(e){throw e})}function o(e,t){var n="string"==typeof t;return!n&&t&&t.encoding&&!t.valueEncoding&&(t.valueEncoding=t.encoding),b(e&&e.options||{},n?E[t]||E[_.valueEncoding]:t)}function s(){if(v)return v;var t,n=e("../package.json").devDependencies.leveldown,r="Could not locate LevelDOWN, try `npm install leveldown`";try{t=e("leveldown/package").version}catch(i){throw new y(r)}if(!e("semver").satisfies(t,n))throw new y("Installed version of LevelDOWN ("+t+") does not match required version ("+n+")");try{return v=e("leveldown")}catch(i){throw new y(r)}}function a(e,t,n){return"function"==typeof n?n(t):e.emit("error",t)}function u(e,t){var n=t&&t.keyEncoding||e.keyEncoding||"utf8";return w[n]||n}function c(e,t){var n=t&&(t.valueEncoding||t.encoding)||e.valueEncoding||e.encoding||"utf8";return w[n]||n}function l(e,t,n){return u(t,n).encode(e)}function f(e,t,n){return c(t,n).encode(e)}function d(e,t){return u(t).decode(e)}function h(e,t){return c(t).decode(e)}function p(e,t){return c(e,t).buffer}function g(e,t){return u(e,t).buffer}var v,b=e("xtend"),y=e("./errors").LevelUPError,m=["hex","utf8","utf-8","ascii","binary","base64","ucs2","ucs-2","utf16le","utf-16le"],_={createIfMissing:!0,errorIfExists:!1,keyEncoding:"utf8",valueEncoding:"utf8",compression:!0},w=function(){function e(e){return void 0===e||null===e||r.isBuffer(e)}var t={};return t.utf8=t["utf-8"]={encode:function(t){return e(t)?t:String(t)},decode:function(e){return e},buffer:!1,type:"utf8"},t.json={encode:JSON.stringify,decode:JSON.parse,buffer:!1,type:"json"},m.forEach(function(i){t[i]||(t[i]={encode:function(t){return e(t)?t:new r(t,i)},decode:function(e){return n.browser?e.toString(i):e},buffer:!0,type:i})}),t}(),E=function(){var e={};return m.forEach(function(t){e[t]={valueEncoding:t}}),e}();t.exports={defaultOptions:_,copy:i,getOptions:o,getLevelDOWN:s,dispatchError:a,encodeKey:l,encodeValue:f,isValueAsBuffer:p,isKeyAsBuffer:g,decodeValue:h,decodeKey:d}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),e("buffer").Buffer)},{"../package.json":71,"./errors":48,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,leveldown:"RQL87X","leveldown/package":17,semver:17,xtend:70}],52:[function(e,t){(function(n,r){function i(e,t){if(!(this instanceof i))return new i(e,t);o.call(this),this._options=a(f,l(t,e)),this._db=t,this._buffer=[],this._status="init",this._end=!1,this.writable=!0,this.readable=!1;var n=this,r=function(){n.writable&&(n._status="ready",n.emit("ready"),n._process())};t.isOpen()?c(r):t.once("ready",r)}var o=e("stream").Stream,s=e("util").inherits,a=e("xtend"),u=e("bl"),c=r.setImmediate||n.nextTick,l=e("./util").getOptions,f={type:"put"};s(i,o),i.prototype.write=function(e){return this.writable?(this._buffer.push(e),"init"!=this._status&&this._processDelayed(),this._options.maxBufferLength&&this._buffer.length>this._options.maxBufferLength?(this._writeBlock=!0,!1):!0):!1},i.prototype.end=function(e){var t=this;e&&this.write(e),c(function(){t._end=!0,t._process()})},i.prototype.destroy=function(){this.writable=!1,this.end()},i.prototype.destroySoon=function(){this.end()},i.prototype.add=function(e){return e.props?(e.props.Directory?e.pipe(this._db.writeStream(this._options)):(e.props.File||e.File||"File"==e.type)&&this._write(e),!0):void 0},i.prototype._processDelayed=function(){var e=this;c(function(){e._process()})},i.prototype._process=function(){var e,t=this,n=function(e){return t.writable?("closed"!=t._status&&(t._status="ready"),e?(t.writable=!1,t.emit("error",e)):void t._process()):void 0};return"ready"!=t._status&&t.writable?void(t._buffer.length&&"closed"!=t._status&&t._processDelayed()):t._buffer.length&&t.writable?(t._status="writing",e=t._buffer,t._buffer=[],t._db.batch(e.map(function(e){return{type:e.type||t._options.type,key:e.key,value:e.value,keyEncoding:e.keyEncoding||t._options.keyEncoding,valueEncoding:e.valueEncoding||e.encoding||t._options.valueEncoding}}),n),void(t._writeBlock&&(t._writeBlock=!1,t.emit("drain")))):void(t._end&&"closed"!=t._status&&(t._status="closed",t.writable=!1,t.emit("close")))},i.prototype._write=function(e){var t=e.path||e.props.path,n=this;t&&e.pipe(u(function(e,r){return e?(n.writable=!1,n.emit("error",e)):(n._options.fstreamRoot&&t.indexOf(n._options.fstreamRoot)>-1&&(t=t.substr(n._options.fstreamRoot.length+1)),void n.write({key:t,value:r.slice(0)}))}))},i.prototype.toString=function(){return"LevelUP.WriteStream"},t.exports=i}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./util":51,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,bl:53,stream:24,util:32,xtend:70}],53:[function(e,t){(function(n){function r(e){if(!(this instanceof r))return new r(e);if(this._bufs=[],this.length=0,"function"==typeof e){this._callback=e;var t=function(e){this._callback&&(this._callback(e),this._callback=null)}.bind(this);this.on("pipe",function(e){e.on("error",t)}),this.on("unpipe",function(e){e.removeListener("error",t)})}else n.isBuffer(e)?this.append(e):Array.isArray(e)&&e.forEach(function(e){n.isBuffer(e)&&this.append(e)}.bind(this));i.call(this)}var i=e("readable-stream").Duplex,o=e("util");o.inherits(r,i),r.prototype._offset=function(e){for(var t,n=0,r=0;r<this._bufs.length;r++){if(t=n+this._bufs[r].length,t>e)return[r,e-n];n=t}},r.prototype.append=function(e){return this._bufs.push(n.isBuffer(e)?e:new n(e)),this.length+=e.length,this},r.prototype._write=function(e,t,n){this.append(e),n&&n()},r.prototype._read=function(e){return this.length?(e=Math.min(e,this.length),this.push(this.slice(0,e)),void this.consume(e)):this.push(null)},r.prototype.end=function(e){i.prototype.end.call(this,e),this._callback&&(this._callback(null,this.slice()),this._callback=null)},r.prototype.get=function(e){return this.slice(e,e+1)[0]},r.prototype.slice=function(e,t){return this.copy(null,0,e,t)},r.prototype.copy=function(e,t,r,i){if(("number"!=typeof r||0>r)&&(r=0),("number"!=typeof i||i>this.length)&&(i=this.length),r>=this.length)return e||new n(0);if(0>=i)return e||new n(0);var o,s,a=!!e,u=this._offset(r),c=i-r,l=c,f=a&&t||0,d=u[1];if(0===r&&i==this.length){if(!a)return n.concat(this._bufs);for(s=0;s<this._bufs.length;s++)this._bufs[s].copy(e,f),f+=this._bufs[s].length;return e}if(l<=this._bufs[u[0]].length-d)return a?this._bufs[u[0]].copy(e,t,d,d+l):this._bufs[u[0]].slice(d,d+l);for(a||(e=new n(c)),s=u[0];s<this._bufs.length;s++){if(o=this._bufs[s].length-d,!(l>o)){this._bufs[s].copy(e,f,d,d+l);break}this._bufs[s].copy(e,f,d),f+=o,l-=o,d&&(d=0)}return e},r.prototype.toString=function(e,t,n){return this.slice(t,n).toString(e)},r.prototype.consume=function(e){for(;this._bufs.length;){if(!(e>this._bufs[0].length)){this._bufs[0]=this._bufs[0].slice(e),this.length-=e;break}e-=this._bufs[0].length,this.length-=this._bufs[0].length,this._bufs.shift()}return this},r.prototype.duplicate=function(){for(var e=0,t=new r;e<this._bufs.length;e++)t.append(this._bufs[e]);return t},r.prototype.destroy=function(){this._bufs.length=0,this.length=0,this.push(null)},function(){var e={readDoubleBE:8,readDoubleLE:8,readFloatBE:4,readFloatLE:4,readInt32BE:4,readInt32LE:4,readUInt32BE:4,readUInt32LE:4,readInt16BE:2,readInt16LE:2,readUInt16BE:2,readUInt16LE:2,readInt8:1,readUInt8:1};for(var t in e)!function(t){r.prototype[t]=function(n){return this.slice(n,n+e[t])[t](0)}}(t)}(),t.exports=r}).call(this,e("buffer").Buffer)},{buffer:20,"readable-stream":69,util:32}],54:[function(e,t){(function(n,r){function i(e){s.call(this,"string"==typeof e?e:""),this._db=void 0,this._operations=[]}var o=e("util"),s=e("abstract-leveldown").AbstractLevelDOWN;o.inherits(i,s),i.prototype.setDb=function(e){this._db=e,this._operations.forEach(function(t){e[t.method].apply(e,t.args)})},i.prototype._open=function(e,t){return n.nextTick(t)},i.prototype._operation=function(e,t){return this._db?this._db[e].apply(this._db,t):void this._operations.push({method:e,args:t})},"put get del batch approximateSize".split(" ").forEach(function(e){i.prototype["_"+e]=function(){this._operation(e,arguments)}}),i.prototype._isBuffer=function(e){return r.isBuffer(e)},i.prototype._iterator=function(){throw new TypeError("not implemented")},t.exports=i}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),e("buffer").Buffer)},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"abstract-leveldown":57,buffer:20,util:32}],55:[function(e,t){(function(e){function n(e){this._db=e,this._operations=[],this._written=!1}n.prototype._checkWritten=function(){if(this._written)throw new Error("write() already called on this batch")},n.prototype.put=function(e,t){this._checkWritten();var n=this._db._checkKeyValue(e,"key",this._db._isBuffer);if(n)throw n;if(n=this._db._checkKeyValue(t,"value",this._db._isBuffer))throw n;return this._db._isBuffer(e)||(e=String(e)),this._db._isBuffer(t)||(t=String(t)),"function"==typeof this._put?this._put(e,t):this._operations.push({type:"put",key:e,value:t}),this},n.prototype.del=function(e){this._checkWritten();var t=this._db._checkKeyValue(e,"key",this._db._isBuffer);if(t)throw t;return this._db._isBuffer(e)||(e=String(e)),"function"==typeof this._del?this._del(e):this._operations.push({type:"del",key:e}),this},n.prototype.clear=function(){return this._checkWritten(),this._operations=[],"function"==typeof this._clear&&this._clear(),this},n.prototype.write=function(t,n){if(this._checkWritten(),"function"==typeof t&&(n=t),"function"!=typeof n)throw new Error("write() requires a callback argument");return"object"!=typeof t&&(t={}),this._written=!0,"function"==typeof this._write?this._write(n):"function"==typeof this._db._batch?this._db._batch(this._operations,t,n):void e.nextTick(n)},t.exports=n}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],56:[function(e,t){(function(e){function n(e){this.db=e,this._ended=!1,this._nexting=!1}n.prototype.next=function(t){var n=this;if("function"!=typeof t)throw new Error("next() requires a callback argument");return n._ended?t(new Error("cannot call next() after end()")):n._nexting?t(new Error("cannot call next() before previous next() has completed")):(n._nexting=!0,"function"==typeof n._next?n._next(function(){n._nexting=!1,t.apply(null,arguments)}):void e.nextTick(function(){n._nexting=!1,t()}))},n.prototype.end=function(t){if("function"!=typeof t)throw new Error("end() requires a callback argument");return this._ended?t(new Error("end() already called on iterator")):(this._ended=!0,"function"==typeof this._end?this._end(t):void e.nextTick(t))},t.exports=n}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],57:[function(e,t){(function(n,r){function i(e){if(!arguments.length||void 0===e)throw new Error("constructor requires at least a location argument");if("string"!=typeof e)throw new Error("constructor requires a location string argument");this.location=e}var o=e("xtend"),s=e("./abstract-iterator"),a=e("./abstract-chained-batch");i.prototype.open=function(e,t){if("function"==typeof e&&(t=e),"function"!=typeof t)throw new Error("open() requires a callback argument");return"object"!=typeof e&&(e={}),"function"==typeof this._open?this._open(e,t):void n.nextTick(t)},i.prototype.close=function(e){if("function"!=typeof e)throw new Error("close() requires a callback argument");return"function"==typeof this._close?this._close(e):void n.nextTick(e)},i.prototype.get=function(e,t,r){var i;if("function"==typeof t&&(r=t),"function"!=typeof r)throw new Error("get() requires a callback argument");return(i=this._checkKeyValue(e,"key",this._isBuffer))?r(i):(this._isBuffer(e)||(e=String(e)),"object"!=typeof t&&(t={}),"function"==typeof this._get?this._get(e,t,r):void n.nextTick(function(){r(new Error("NotFound"))}))},i.prototype.put=function(e,t,r,i){var o;if("function"==typeof r&&(i=r),"function"!=typeof i)throw new Error("put() requires a callback argument");return(o=this._checkKeyValue(e,"key",this._isBuffer))?i(o):(o=this._checkKeyValue(t,"value",this._isBuffer))?i(o):(this._isBuffer(e)||(e=String(e)),this._isBuffer(t)||n.browser||(t=String(t)),"object"!=typeof r&&(r={}),"function"==typeof this._put?this._put(e,t,r,i):void n.nextTick(i))},i.prototype.del=function(e,t,r){var i;if("function"==typeof t&&(r=t),"function"!=typeof r)throw new Error("del() requires a callback argument");return(i=this._checkKeyValue(e,"key",this._isBuffer))?r(i):(this._isBuffer(e)||(e=String(e)),"object"!=typeof t&&(t={}),"function"==typeof this._del?this._del(e,t,r):void n.nextTick(r))},i.prototype.batch=function(e,t,r){if(!arguments.length)return this._chainedBatch();if("function"==typeof t&&(r=t),"function"!=typeof r)throw new Error("batch(array) requires a callback argument");if(!Array.isArray(e))return r(new Error("batch(array) requires an array argument"));"object"!=typeof t&&(t={});for(var i,o,s=0,a=e.length;a>s;s++)if(i=e[s],"object"==typeof i){if(o=this._checkKeyValue(i.type,"type",this._isBuffer))return r(o);if(o=this._checkKeyValue(i.key,"key",this._isBuffer))return r(o);if("put"==i.type&&(o=this._checkKeyValue(i.value,"value",this._isBuffer)))return r(o)}return"function"==typeof this._batch?this._batch(e,t,r):void n.nextTick(r)},i.prototype.approximateSize=function(e,t,r){if(null==e||null==t||"function"==typeof e||"function"==typeof t)throw new Error("approximateSize() requires valid `start`, `end` and `callback` arguments");if("function"!=typeof r)throw new Error("approximateSize() requires a callback argument");return this._isBuffer(e)||(e=String(e)),this._isBuffer(t)||(t=String(t)),"function"==typeof this._approximateSize?this._approximateSize(e,t,r):void n.nextTick(function(){r(null,0)})},i.prototype._setupIteratorOptions=function(e){var t=this;return e=o(e),["start","end","gt","gte","lt","lte"].forEach(function(n){e[n]&&t._isBuffer(e[n])&&0===e[n].length&&delete e[n]}),e.reverse=!!e.reverse,e.reverse&&e.lt&&(e.start=e.lt),e.reverse&&e.lte&&(e.start=e.lte),!e.reverse&&e.gt&&(e.start=e.gt),!e.reverse&&e.gte&&(e.start=e.gte),(e.reverse&&e.lt&&!e.lte||!e.reverse&&e.gt&&!e.gte)&&(e.exclusiveStart=!0),e},i.prototype.iterator=function(e){return"object"!=typeof e&&(e={}),e=this._setupIteratorOptions(e),"function"==typeof this._iterator?this._iterator(e):new s(this)},i.prototype._chainedBatch=function(){return new a(this)},i.prototype._isBuffer=function(e){return r.isBuffer(e)},i.prototype._checkKeyValue=function(e,t){if(null===e||void 0===e)return new Error(t+" cannot be `null` or `undefined`");if(null===e||void 0===e)return new Error(t+" cannot be `null` or `undefined`");if(this._isBuffer(e)){if(0===e.length)return new Error(t+" cannot be an empty Buffer")}else if(""===String(e))return new Error(t+" cannot be an empty String")},t.exports.AbstractLevelDOWN=i,t.exports.AbstractIterator=s,t.exports.AbstractChainedBatch=a}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),e("buffer").Buffer)},{"./abstract-chained-batch":55,"./abstract-iterator":56,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,xtend:70}],58:[function(e,t){function n(e,t,n){o(this,{type:e,name:e,cause:"string"!=typeof t?t:n,message:t&&"string"!=typeof t?t.message:t},"ewr")}function r(e,t){Error.call(this),Error.captureStackTrace&&Error.captureStackTrace(this,arguments.callee),n.call(this,"CustomError",e,t)}function i(e,t,i){var o=function(r,i){n.call(this,t,r,i),"FilesystemError"==t&&(this.code=this.cause.code,this.path=this.cause.path,this.errno=this.cause.errno,this.message=(e.errno[this.cause.errno]?e.errno[this.cause.errno].description:this.cause.message)+(this.cause.path?" ["+this.cause.path+"]":"")),Error.call(this),Error.captureStackTrace&&Error.captureStackTrace(this,arguments.callee)};return o.prototype=i?new i:new r,o}var o=e("prr");r.prototype=new Error,t.exports=function(e){var t=function(t,n){return i(e,t,n)};return{CustomError:r,FilesystemError:t("FilesystemError"),createError:t}}},{prr:60}],59:[function(e,t){var n=t.exports.all=[{errno:-1,code:"UNKNOWN",description:"unknown error"},{errno:0,code:"OK",description:"success"},{errno:1,code:"EOF",description:"end of file"},{errno:2,code:"EADDRINFO",description:"getaddrinfo error"},{errno:3,code:"EACCES",description:"permission denied"},{errno:4,code:"EAGAIN",description:"resource temporarily unavailable"},{errno:5,code:"EADDRINUSE",description:"address already in use"},{errno:6,code:"EADDRNOTAVAIL",description:"address not available"},{errno:7,code:"EAFNOSUPPORT",description:"address family not supported"},{errno:8,code:"EALREADY",description:"connection already in progress"},{errno:9,code:"EBADF",description:"bad file descriptor"},{errno:10,code:"EBUSY",description:"resource busy or locked"},{errno:11,code:"ECONNABORTED",description:"software caused connection abort"},{errno:12,code:"ECONNREFUSED",description:"connection refused"},{errno:13,code:"ECONNRESET",description:"connection reset by peer"},{errno:14,code:"EDESTADDRREQ",description:"destination address required"},{errno:15,code:"EFAULT",description:"bad address in system call argument"},{errno:16,code:"EHOSTUNREACH",description:"host is unreachable"},{errno:17,code:"EINTR",description:"interrupted system call"},{errno:18,code:"EINVAL",description:"invalid argument"},{errno:19,code:"EISCONN",description:"socket is already connected"},{errno:20,code:"EMFILE",description:"too many open files"},{errno:21,code:"EMSGSIZE",description:"message too long"},{errno:22,code:"ENETDOWN",description:"network is down"},{errno:23,code:"ENETUNREACH",description:"network is unreachable"},{errno:24,code:"ENFILE",description:"file table overflow"},{errno:25,code:"ENOBUFS",description:"no buffer space available"},{errno:26,code:"ENOMEM",description:"not enough memory"},{errno:27,code:"ENOTDIR",description:"not a directory"},{errno:28,code:"EISDIR",description:"illegal operation on a directory"},{errno:29,code:"ENONET",description:"machine is not on the network"},{errno:31,code:"ENOTCONN",description:"socket is not connected"},{errno:32,code:"ENOTSOCK",description:"socket operation on non-socket"},{errno:33,code:"ENOTSUP",description:"operation not supported on socket"},{errno:34,code:"ENOENT",description:"no such file or directory"},{errno:35,code:"ENOSYS",description:"function not implemented"},{errno:36,code:"EPIPE",description:"broken pipe"},{errno:37,code:"EPROTO",description:"protocol error"},{errno:38,code:"EPROTONOSUPPORT",description:"protocol not supported"},{errno:39,code:"EPROTOTYPE",description:"protocol wrong type for socket"},{errno:40,code:"ETIMEDOUT",description:"connection timed out"},{errno:41,code:"ECHARSET",description:"invalid Unicode character"},{errno:42,code:"EAIFAMNOSUPPORT",description:"address family for hostname not supported"},{errno:44,code:"EAISERVICE",description:"servname not supported for ai_socktype"},{errno:45,code:"EAISOCKTYPE",description:"ai_socktype not supported"},{errno:46,code:"ESHUTDOWN",description:"cannot send after transport endpoint shutdown"},{errno:47,code:"EEXIST",description:"file already exists"},{errno:48,code:"ESRCH",description:"no such process"},{errno:49,code:"ENAMETOOLONG",description:"name too long"},{errno:50,code:"EPERM",description:"operation not permitted"},{errno:51,code:"ELOOP",description:"too many symbolic links encountered"},{errno:52,code:"EXDEV",description:"cross-device link not permitted"},{errno:53,code:"ENOTEMPTY",description:"directory not empty"},{errno:54,code:"ENOSPC",description:"no space left on device"},{errno:55,code:"EIO",description:"i/o error"},{errno:56,code:"EROFS",description:"read-only file system"},{errno:57,code:"ENODEV",description:"no such device"},{errno:58,code:"ESPIPE",description:"invalid seek"},{errno:59,code:"ECANCELED",description:"operation canceled"}];t.exports.errno={"-1":n[0],0:n[1],1:n[2],2:n[3],3:n[4],4:n[5],5:n[6],6:n[7],7:n[8],8:n[9],9:n[10],10:n[11],11:n[12],12:n[13],13:n[14],14:n[15],15:n[16],16:n[17],17:n[18],18:n[19],19:n[20],20:n[21],21:n[22],22:n[23],23:n[24],24:n[25],25:n[26],26:n[27],27:n[28],28:n[29],29:n[30],31:n[31],32:n[32],33:n[33],34:n[34],35:n[35],36:n[36],37:n[37],38:n[38],39:n[39],40:n[40],41:n[41],42:n[42],44:n[43],45:n[44],46:n[45],47:n[46],48:n[47],49:n[48],50:n[49],51:n[50],52:n[51],53:n[52],54:n[53],55:n[54],56:n[55],57:n[56],58:n[57],59:n[58]},t.exports.code={UNKNOWN:n[0],OK:n[1],EOF:n[2],EADDRINFO:n[3],EACCES:n[4],EAGAIN:n[5],EADDRINUSE:n[6],EADDRNOTAVAIL:n[7],EAFNOSUPPORT:n[8],EALREADY:n[9],EBADF:n[10],EBUSY:n[11],ECONNABORTED:n[12],ECONNREFUSED:n[13],ECONNRESET:n[14],EDESTADDRREQ:n[15],EFAULT:n[16],EHOSTUNREACH:n[17],EINTR:n[18],EINVAL:n[19],EISCONN:n[20],EMFILE:n[21],EMSGSIZE:n[22],ENETDOWN:n[23],ENETUNREACH:n[24],ENFILE:n[25],ENOBUFS:n[26],ENOMEM:n[27],ENOTDIR:n[28],EISDIR:n[29],ENONET:n[30],ENOTCONN:n[31],ENOTSOCK:n[32],ENOTSUP:n[33],ENOENT:n[34],ENOSYS:n[35],EPIPE:n[36],EPROTO:n[37],EPROTONOSUPPORT:n[38],EPROTOTYPE:n[39],ETIMEDOUT:n[40],ECHARSET:n[41],EAIFAMNOSUPPORT:n[42],EAISERVICE:n[43],EAISOCKTYPE:n[44],ESHUTDOWN:n[45],EEXIST:n[46],ESRCH:n[47],ENAMETOOLONG:n[48],EPERM:n[49],ELOOP:n[50],EXDEV:n[51],ENOTEMPTY:n[52],ENOSPC:n[53],EIO:n[54],EROFS:n[55],ENODEV:n[56],ESPIPE:n[57],ECANCELED:n[58]},t.exports.custom=e("./custom")(t.exports),t.exports.create=t.exports.custom.createError},{"./custom":58}],60:[function(e,t){!function(e,n,r){"undefined"!=typeof t&&t.exports?t.exports=r():n[e]=r()}("prr",this,function(){var e="function"==typeof Object.defineProperty?function(e,t,n){return Object.defineProperty(e,t,n),e}:function(e,t,n){return e[t]=n.value,e},t=function(e,t){var n="object"==typeof t,r=!n&&"string"==typeof t,i=function(e){return n?!!t[e]:r?t.indexOf(e[0])>-1:!1};return{enumerable:i("enumerable"),configurable:i("configurable"),writable:i("writable"),value:e}},n=function(n,r,i,o){var s;if(o=t(i,o),"object"==typeof r){for(s in r)Object.hasOwnProperty.call(r,s)&&(o.value=r[s],e(n,s,o));return n}return e(n,r,o)};return n})},{}],61:[function(e,t){(function(n){function r(e){return this instanceof r?(u.call(this,e),c.call(this,e),e&&e.readable===!1&&(this.readable=!1),e&&e.writable===!1&&(this.writable=!1),this.allowHalfOpen=!0,e&&e.allowHalfOpen===!1&&(this.allowHalfOpen=!1),void this.once("end",i)):new r(e)}function i(){this.allowHalfOpen||this._writableState.ended||n.nextTick(this.end.bind(this))}function o(e,t){for(var n=0,r=e.length;r>n;n++)t(e[n],n)}t.exports=r;var s=Object.keys||function(e){var t=[];for(var n in e)t.push(n);return t},a=e("core-util-is");a.inherits=e("inherits");var u=e("./_stream_readable"),c=e("./_stream_writable");a.inherits(r,u),o(s(c.prototype),function(e){r.prototype[e]||(r.prototype[e]=c.prototype[e])})}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"./_stream_readable":63,"./_stream_writable":65,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"core-util-is":66,inherits:33}],62:[function(e,t){function n(e){return this instanceof n?void r.call(this,e):new n(e)}t.exports=n;var r=e("./_stream_transform"),i=e("core-util-is");i.inherits=e("inherits"),i.inherits(n,r),n.prototype._transform=function(e,t,n){n(null,e)}},{"./_stream_transform":64,"core-util-is":66,inherits:33}],63:[function(e,t){(function(n){function r(t){t=t||{};var n=t.highWaterMark;this.highWaterMark=n||0===n?n:16384,this.highWaterMark=~~this.highWaterMark,this.buffer=[],this.length=0,this.pipes=null,this.pipesCount=0,this.flowing=!1,this.ended=!1,this.endEmitted=!1,this.reading=!1,this.calledRead=!1,this.sync=!0,this.needReadable=!1,this.emittedReadable=!1,this.readableListening=!1,this.objectMode=!!t.objectMode,this.defaultEncoding=t.defaultEncoding||"utf8",this.ranOut=!1,this.awaitDrain=0,this.readingMore=!1,this.decoder=null,this.encoding=null,t.encoding&&(L||(L=e("string_decoder/").StringDecoder),this.decoder=new L(t.encoding),this.encoding=t.encoding)}function i(e){return this instanceof i?(this._readableState=new r(e,this),this.readable=!0,void j.call(this)):new i(e)}function o(e,t,n,r,i){var o=c(t,n);if(o)e.emit("error",o);else if(null===n||void 0===n)t.reading=!1,t.ended||l(e,t);else if(t.objectMode||n&&n.length>0)if(t.ended&&!i){var a=new Error("stream.push() after EOF");e.emit("error",a)}else if(t.endEmitted&&i){var a=new Error("stream.unshift() after end event");e.emit("error",a)}else!t.decoder||i||r||(n=t.decoder.write(n)),t.length+=t.objectMode?1:n.length,i?t.buffer.unshift(n):(t.reading=!1,t.buffer.push(n)),t.needReadable&&f(e),h(e,t);
+else i||(t.reading=!1);return s(t)}function s(e){return!e.ended&&(e.needReadable||e.length<e.highWaterMark||0===e.length)}function a(e){if(e>=A)e=A;else{e--;for(var t=1;32>t;t<<=1)e|=e>>t;e++}return e}function u(e,t){return 0===t.length&&t.ended?0:t.objectMode?0===e?0:1:isNaN(e)||null===e?t.flowing&&t.buffer.length?t.buffer[0].length:t.length:0>=e?0:(e>t.highWaterMark&&(t.highWaterMark=a(e)),e>t.length?t.ended?t.length:(t.needReadable=!0,0):e)}function c(e,t){var n=null;return S.isBuffer(t)||"string"==typeof t||null===t||void 0===t||e.objectMode||n||(n=new TypeError("Invalid non-string/buffer chunk")),n}function l(e,t){if(t.decoder&&!t.ended){var n=t.decoder.end();n&&n.length&&(t.buffer.push(n),t.length+=t.objectMode?1:n.length)}t.ended=!0,t.length>0?f(e):_(e)}function f(e){var t=e._readableState;t.needReadable=!1,t.emittedReadable||(t.emittedReadable=!0,t.sync?n.nextTick(function(){d(e)}):d(e))}function d(e){e.emit("readable")}function h(e,t){t.readingMore||(t.readingMore=!0,n.nextTick(function(){p(e,t)}))}function p(e,t){for(var n=t.length;!t.reading&&!t.flowing&&!t.ended&&t.length<t.highWaterMark&&(e.read(0),n!==t.length);)n=t.length;t.readingMore=!1}function g(e){return function(){var t=e._readableState;t.awaitDrain--,0===t.awaitDrain&&v(e)}}function v(e){function t(e){var t=e.write(n);!1===t&&r.awaitDrain++}var n,r=e._readableState;for(r.awaitDrain=0;r.pipesCount&&null!==(n=e.read());)if(1===r.pipesCount?t(r.pipes,0,null):w(r.pipes,t),e.emit("data",n),r.awaitDrain>0)return;return 0===r.pipesCount?(r.flowing=!1,void(x.listenerCount(e,"data")>0&&y(e))):void(r.ranOut=!0)}function b(){this._readableState.ranOut&&(this._readableState.ranOut=!1,v(this))}function y(e,t){var r=e._readableState;if(r.flowing)throw new Error("Cannot switch to old mode now.");var i=t||!1,o=!1;e.readable=!0,e.pipe=j.prototype.pipe,e.on=e.addListener=j.prototype.on,e.on("readable",function(){o=!0;for(var t;!i&&null!==(t=e.read());)e.emit("data",t);null===t&&(o=!1,e._readableState.needReadable=!0)}),e.pause=function(){i=!0,this.emit("pause")},e.resume=function(){i=!1,o?n.nextTick(function(){e.emit("readable")}):this.read(0),this.emit("resume")},e.emit("readable")}function m(e,t){var n,r=t.buffer,i=t.length,o=!!t.decoder,s=!!t.objectMode;if(0===r.length)return null;if(0===i)n=null;else if(s)n=r.shift();else if(!e||e>=i)n=o?r.join(""):S.concat(r,i),r.length=0;else if(e<r[0].length){var a=r[0];n=a.slice(0,e),r[0]=a.slice(e)}else if(e===r[0].length)n=r.shift();else{n=o?"":new S(e);for(var u=0,c=0,l=r.length;l>c&&e>u;c++){var a=r[0],f=Math.min(e-u,a.length);o?n+=a.slice(0,f):a.copy(n,u,0,f),f<a.length?r[0]=a.slice(f):r.shift(),u+=f}}return n}function _(e){var t=e._readableState;if(t.length>0)throw new Error("endReadable called on non-empty stream");!t.endEmitted&&t.calledRead&&(t.ended=!0,n.nextTick(function(){t.endEmitted||0!==t.length||(t.endEmitted=!0,e.readable=!1,e.emit("end"))}))}function w(e,t){for(var n=0,r=e.length;r>n;n++)t(e[n],n)}function E(e,t){for(var n=0,r=e.length;r>n;n++)if(e[n]===t)return n;return-1}t.exports=i;var k=e("isarray"),S=e("buffer").Buffer;i.ReadableState=r;var x=e("events").EventEmitter;x.listenerCount||(x.listenerCount=function(e,t){return e.listeners(t).length});var j=e("stream"),O=e("core-util-is");O.inherits=e("inherits");var L;O.inherits(i,j),i.prototype.push=function(e,t){var n=this._readableState;return"string"!=typeof e||n.objectMode||(t=t||n.defaultEncoding,t!==n.encoding&&(e=new S(e,t),t="")),o(this,n,e,t,!1)},i.prototype.unshift=function(e){var t=this._readableState;return o(this,t,e,"",!0)},i.prototype.setEncoding=function(t){L||(L=e("string_decoder/").StringDecoder),this._readableState.decoder=new L(t),this._readableState.encoding=t};var A=8388608;i.prototype.read=function(e){var t=this._readableState;t.calledRead=!0;var n=e;if(("number"!=typeof e||e>0)&&(t.emittedReadable=!1),0===e&&t.needReadable&&(t.length>=t.highWaterMark||t.ended))return f(this),null;if(e=u(e,t),0===e&&t.ended)return 0===t.length&&_(this),null;var r=t.needReadable;t.length-e<=t.highWaterMark&&(r=!0),(t.ended||t.reading)&&(r=!1),r&&(t.reading=!0,t.sync=!0,0===t.length&&(t.needReadable=!0),this._read(t.highWaterMark),t.sync=!1),r&&!t.reading&&(e=u(n,t));var i;return i=e>0?m(e,t):null,null===i&&(t.needReadable=!0,e=0),t.length-=e,0!==t.length||t.ended||(t.needReadable=!0),t.ended&&!t.endEmitted&&0===t.length&&_(this),i},i.prototype._read=function(){this.emit("error",new Error("not implemented"))},i.prototype.pipe=function(e,t){function r(e){e===l&&o()}function i(){e.end()}function o(){e.removeListener("close",a),e.removeListener("finish",u),e.removeListener("drain",p),e.removeListener("error",s),e.removeListener("unpipe",r),l.removeListener("end",i),l.removeListener("end",o),(!e._writableState||e._writableState.needDrain)&&p()}function s(t){c(),e.removeListener("error",s),0===x.listenerCount(e,"error")&&e.emit("error",t)}function a(){e.removeListener("finish",u),c()}function u(){e.removeListener("close",a),c()}function c(){l.unpipe(e)}var l=this,f=this._readableState;switch(f.pipesCount){case 0:f.pipes=e;break;case 1:f.pipes=[f.pipes,e];break;default:f.pipes.push(e)}f.pipesCount+=1;var d=(!t||t.end!==!1)&&e!==n.stdout&&e!==n.stderr,h=d?i:o;f.endEmitted?n.nextTick(h):l.once("end",h),e.on("unpipe",r);var p=g(l);return e.on("drain",p),e._events&&e._events.error?k(e._events.error)?e._events.error.unshift(s):e._events.error=[s,e._events.error]:e.on("error",s),e.once("close",a),e.once("finish",u),e.emit("pipe",l),f.flowing||(this.on("readable",b),f.flowing=!0,n.nextTick(function(){v(l)})),e},i.prototype.unpipe=function(e){var t=this._readableState;if(0===t.pipesCount)return this;if(1===t.pipesCount)return e&&e!==t.pipes?this:(e||(e=t.pipes),t.pipes=null,t.pipesCount=0,this.removeListener("readable",b),t.flowing=!1,e&&e.emit("unpipe",this),this);if(!e){var n=t.pipes,r=t.pipesCount;t.pipes=null,t.pipesCount=0,this.removeListener("readable",b),t.flowing=!1;for(var i=0;r>i;i++)n[i].emit("unpipe",this);return this}var i=E(t.pipes,e);return-1===i?this:(t.pipes.splice(i,1),t.pipesCount-=1,1===t.pipesCount&&(t.pipes=t.pipes[0]),e.emit("unpipe",this),this)},i.prototype.on=function(e,t){var n=j.prototype.on.call(this,e,t);if("data"!==e||this._readableState.flowing||y(this),"readable"===e&&this.readable){var r=this._readableState;r.readableListening||(r.readableListening=!0,r.emittedReadable=!1,r.needReadable=!0,r.reading?r.length&&f(this,r):this.read(0))}return n},i.prototype.addListener=i.prototype.on,i.prototype.resume=function(){y(this),this.read(0),this.emit("resume")},i.prototype.pause=function(){y(this,!0),this.emit("pause")},i.prototype.wrap=function(e){var t=this._readableState,n=!1,r=this;e.on("end",function(){if(t.decoder&&!t.ended){var e=t.decoder.end();e&&e.length&&r.push(e)}r.push(null)}),e.on("data",function(i){if(t.decoder&&(i=t.decoder.write(i)),i&&(t.objectMode||i.length)){var o=r.push(i);o||(n=!0,e.pause())}});for(var i in e)"function"==typeof e[i]&&"undefined"==typeof this[i]&&(this[i]=function(t){return function(){return e[t].apply(e,arguments)}}(i));var o=["error","close","destroy","pause","resume"];return w(o,function(t){e.on(t,r.emit.bind(r,t))}),r._read=function(){n&&(n=!1,e.resume())},r},i._fromList=m}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,"core-util-is":66,events:18,inherits:33,isarray:67,stream:24,"string_decoder/":68}],64:[function(e,t){function n(e,t){this.afterTransform=function(e,n){return r(t,e,n)},this.needTransform=!1,this.transforming=!1,this.writecb=null,this.writechunk=null}function r(e,t,n){var r=e._transformState;r.transforming=!1;var i=r.writecb;if(!i)return e.emit("error",new Error("no writecb in Transform class"));r.writechunk=null,r.writecb=null,null!==n&&void 0!==n&&e.push(n),i&&i(t);var o=e._readableState;o.reading=!1,(o.needReadable||o.length<o.highWaterMark)&&e._read(o.highWaterMark)}function i(e){if(!(this instanceof i))return new i(e);s.call(this,e);var t=(this._transformState=new n(e,this),this);this._readableState.needReadable=!0,this._readableState.sync=!1,this.once("finish",function(){"function"==typeof this._flush?this._flush(function(e){o(t,e)}):o(t)})}function o(e,t){if(t)return e.emit("error",t);var n=e._writableState,r=(e._readableState,e._transformState);if(n.length)throw new Error("calling transform done when ws.length != 0");if(r.transforming)throw new Error("calling transform done when still transforming");return e.push(null)}t.exports=i;var s=e("./_stream_duplex"),a=e("core-util-is");a.inherits=e("inherits"),a.inherits(i,s),i.prototype.push=function(e,t){return this._transformState.needTransform=!1,s.prototype.push.call(this,e,t)},i.prototype._transform=function(){throw new Error("not implemented")},i.prototype._write=function(e,t,n){var r=this._transformState;if(r.writecb=n,r.writechunk=e,r.writeencoding=t,!r.transforming){var i=this._readableState;(r.needTransform||i.needReadable||i.length<i.highWaterMark)&&this._read(i.highWaterMark)}},i.prototype._read=function(){var e=this._transformState;null!==e.writechunk&&e.writecb&&!e.transforming?(e.transforming=!0,this._transform(e.writechunk,e.writeencoding,e.afterTransform)):e.needTransform=!0}},{"./_stream_duplex":61,"core-util-is":66,inherits:33}],65:[function(e,t){(function(n){function r(e,t,n){this.chunk=e,this.encoding=t,this.callback=n}function i(e,t){e=e||{};var n=e.highWaterMark;this.highWaterMark=n||0===n?n:16384,this.objectMode=!!e.objectMode,this.highWaterMark=~~this.highWaterMark,this.needDrain=!1,this.ending=!1,this.ended=!1,this.finished=!1;var r=e.decodeStrings===!1;this.decodeStrings=!r,this.defaultEncoding=e.defaultEncoding||"utf8",this.length=0,this.writing=!1,this.sync=!0,this.bufferProcessing=!1,this.onwrite=function(e){h(t,e)},this.writecb=null,this.writelen=0,this.buffer=[],this.errorEmitted=!1}function o(t){var n=e("./_stream_duplex");return this instanceof o||this instanceof n?(this._writableState=new i(t,this),this.writable=!0,void E.call(this)):new o(t)}function s(e,t,r){var i=new Error("write after end");e.emit("error",i),n.nextTick(function(){r(i)})}function a(e,t,r,i){var o=!0;if(!_.isBuffer(r)&&"string"!=typeof r&&null!==r&&void 0!==r&&!t.objectMode){var s=new TypeError("Invalid non-string/buffer chunk");e.emit("error",s),n.nextTick(function(){i(s)}),o=!1}return o}function u(e,t,n){return e.objectMode||e.decodeStrings===!1||"string"!=typeof t||(t=new _(t,n)),t}function c(e,t,n,i,o){n=u(t,n,i),_.isBuffer(n)&&(i="buffer");var s=t.objectMode?1:n.length;t.length+=s;var a=t.length<t.highWaterMark;return a||(t.needDrain=!0),t.writing?t.buffer.push(new r(n,i,o)):l(e,t,s,n,i,o),a}function l(e,t,n,r,i,o){t.writelen=n,t.writecb=o,t.writing=!0,t.sync=!0,e._write(r,i,t.onwrite),t.sync=!1}function f(e,t,r,i,o){r?n.nextTick(function(){o(i)}):o(i),e._writableState.errorEmitted=!0,e.emit("error",i)}function d(e){e.writing=!1,e.writecb=null,e.length-=e.writelen,e.writelen=0}function h(e,t){var r=e._writableState,i=r.sync,o=r.writecb;if(d(r),t)f(e,r,i,t,o);else{var s=b(e,r);s||r.bufferProcessing||!r.buffer.length||v(e,r),i?n.nextTick(function(){p(e,r,s,o)}):p(e,r,s,o)}}function p(e,t,n,r){n||g(e,t),r(),n&&y(e,t)}function g(e,t){0===t.length&&t.needDrain&&(t.needDrain=!1,e.emit("drain"))}function v(e,t){t.bufferProcessing=!0;for(var n=0;n<t.buffer.length;n++){var r=t.buffer[n],i=r.chunk,o=r.encoding,s=r.callback,a=t.objectMode?1:i.length;if(l(e,t,a,i,o,s),t.writing){n++;break}}t.bufferProcessing=!1,n<t.buffer.length?t.buffer=t.buffer.slice(n):t.buffer.length=0}function b(e,t){return t.ending&&0===t.length&&!t.finished&&!t.writing}function y(e,t){var n=b(e,t);return n&&(t.finished=!0,e.emit("finish")),n}function m(e,t,r){t.ending=!0,y(e,t),r&&(t.finished?n.nextTick(r):e.once("finish",r)),t.ended=!0}t.exports=o;var _=e("buffer").Buffer;o.WritableState=i;var w=e("core-util-is");w.inherits=e("inherits");var E=e("stream");w.inherits(o,E),o.prototype.pipe=function(){this.emit("error",new Error("Cannot pipe. Not readable."))},o.prototype.write=function(e,t,n){var r=this._writableState,i=!1;return"function"==typeof t&&(n=t,t=null),_.isBuffer(e)?t="buffer":t||(t=r.defaultEncoding),"function"!=typeof n&&(n=function(){}),r.ended?s(this,r,n):a(this,r,e,n)&&(i=c(this,r,e,t,n)),i},o.prototype._write=function(e,t,n){n(new Error("not implemented"))},o.prototype.end=function(e,t,n){var r=this._writableState;"function"==typeof e?(n=e,e=null,t=null):"function"==typeof t&&(n=t,t=null),"undefined"!=typeof e&&null!==e&&this.write(e,t),r.ending||r.finished||m(this,r,n)}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"./_stream_duplex":61,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,"core-util-is":66,inherits:33,stream:24}],66:[function(e,t,n){(function(e){function t(e){return Array.isArray(e)}function r(e){return"boolean"==typeof e}function i(e){return null===e}function o(e){return null==e}function s(e){return"number"==typeof e}function a(e){return"string"==typeof e}function u(e){return"symbol"==typeof e}function c(e){return void 0===e}function l(e){return f(e)&&"[object RegExp]"===b(e)}function f(e){return"object"==typeof e&&null!==e}function d(e){return f(e)&&"[object Date]"===b(e)}function h(e){return f(e)&&("[object Error]"===b(e)||e instanceof Error)}function p(e){return"function"==typeof e}function g(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"==typeof e||"undefined"==typeof e}function v(t){return e.isBuffer(t)}function b(e){return Object.prototype.toString.call(e)}n.isArray=t,n.isBoolean=r,n.isNull=i,n.isNullOrUndefined=o,n.isNumber=s,n.isString=a,n.isSymbol=u,n.isUndefined=c,n.isRegExp=l,n.isObject=f,n.isDate=d,n.isError=h,n.isFunction=p,n.isPrimitive=g,n.isBuffer=v}).call(this,e("buffer").Buffer)},{buffer:20}],67:[function(e,t){t.exports=Array.isArray||function(e){return"[object Array]"==Object.prototype.toString.call(e)}},{}],68:[function(e,t,n){function r(e){if(e&&!u(e))throw new Error("Unknown encoding: "+e)}function i(e){return e.toString(this.encoding)}function o(e){var t=this.charReceived=e.length%2;return this.charLength=t?2:0,t}function s(e){var t=this.charReceived=e.length%3;return this.charLength=t?3:0,t}var a=e("buffer").Buffer,u=a.isEncoding||function(e){switch(e&&e.toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":case"raw":return!0;default:return!1}},c=n.StringDecoder=function(e){switch(this.encoding=(e||"utf8").toLowerCase().replace(/[-_]/,""),r(e),this.encoding){case"utf8":this.surrogateSize=3;break;case"ucs2":case"utf16le":this.surrogateSize=2,this.detectIncompleteChar=o;break;case"base64":this.surrogateSize=3,this.detectIncompleteChar=s;break;default:return void(this.write=i)}this.charBuffer=new a(6),this.charReceived=0,this.charLength=0};c.prototype.write=function(e){for(var t="",n=0;this.charLength;){var r=e.length>=this.charLength-this.charReceived?this.charLength-this.charReceived:e.length;if(e.copy(this.charBuffer,this.charReceived,n,r),this.charReceived+=r-n,n=r,this.charReceived<this.charLength)return"";t=this.charBuffer.slice(0,this.charLength).toString(this.encoding);var i=t.charCodeAt(t.length-1);if(!(i>=55296&&56319>=i)){if(this.charReceived=this.charLength=0,r==e.length)return t;e=e.slice(r,e.length);break}this.charLength+=this.surrogateSize,t=""}var o=this.detectIncompleteChar(e),s=e.length;this.charLength&&(e.copy(this.charBuffer,0,e.length-o,s),this.charReceived=o,s-=o),t+=e.toString(this.encoding,0,s);var s=t.length-1,i=t.charCodeAt(s);if(i>=55296&&56319>=i){var a=this.surrogateSize;return this.charLength+=a,this.charReceived+=a,this.charBuffer.copy(this.charBuffer,a,0,a),this.charBuffer.write(t.charAt(t.length-1),this.encoding),t.substring(0,s)}return t},c.prototype.detectIncompleteChar=function(e){for(var t=e.length>=3?3:e.length;t>0;t--){var n=e[e.length-t];if(1==t&&n>>5==6){this.charLength=2;break}if(2>=t&&n>>4==14){this.charLength=3;break}if(3>=t&&n>>3==30){this.charLength=4;break}}return t},c.prototype.end=function(e){var t="";if(e&&e.length&&(t=this.write(e)),this.charReceived){var n=this.charReceived,r=this.charBuffer,i=this.encoding;t+=r.slice(0,n).toString(i)}return t}},{buffer:20}],69:[function(e,t,n){n=t.exports=e("./lib/_stream_readable.js"),n.Readable=n,n.Writable=e("./lib/_stream_writable.js"),n.Duplex=e("./lib/_stream_duplex.js"),n.Transform=e("./lib/_stream_transform.js"),n.PassThrough=e("./lib/_stream_passthrough.js")},{"./lib/_stream_duplex.js":61,"./lib/_stream_passthrough.js":62,"./lib/_stream_readable.js":63,"./lib/_stream_transform.js":64,"./lib/_stream_writable.js":65}],70:[function(e,t){function n(){for(var e={},t=0;t<arguments.length;t++){var n=arguments[t];for(var r in n)n.hasOwnProperty(r)&&(e[r]=n[r])}return e}t.exports=n},{}],71:[function(e,t){t.exports={name:"levelup",description:"Fast & simple storage - a Node.js-style LevelDB wrapper",version:"0.18.6",contributors:[{name:"Rod Vagg",email:"r@va.gg",url:"https://github.com/rvagg"},{name:"John Chesley",email:"john@chesl.es",url:"https://github.com/chesles/"},{name:"Jake Verbaten",email:"raynos2@gmail.com",url:"https://github.com/raynos"},{name:"Dominic Tarr",email:"dominic.tarr@gmail.com",url:"https://github.com/dominictarr"},{name:"Max Ogden",email:"max@maxogden.com",url:"https://github.com/maxogden"},{name:"Lars-Magnus Skog",email:"lars.magnus.skog@gmail.com",url:"https://github.com/ralphtheninja"},{name:"David Björklund",email:"david.bjorklund@gmail.com",url:"https://github.com/kesla"},{name:"Julian Gruber",email:"julian@juliangruber.com",url:"https://github.com/juliangruber"},{name:"Paolo Fragomeni",email:"paolo@async.ly",url:"https://github.com/hij1nx"},{name:"Anton Whalley",email:"anton.whalley@nearform.com",url:"https://github.com/No9"},{name:"Matteo Collina",email:"matteo.collina@gmail.com",url:"https://github.com/mcollina"},{name:"Pedro Teixeira",email:"pedro.teixeira@gmail.com",url:"https://github.com/pgte"},{name:"James Halliday",email:"mail@substack.net",url:"https://github.com/substack"}],repository:{type:"git",url:"https://github.com/rvagg/node-levelup.git"},homepage:"https://github.com/rvagg/node-levelup",keywords:["leveldb","stream","database","db","store","storage","json"],main:"lib/levelup.js",dependencies:{bl:"~0.8.1","deferred-leveldown":"~0.2.0",errno:"~0.1.1",prr:"~0.0.0","readable-stream":"~1.0.26",semver:"~2.3.1",xtend:"~3.0.0"},devDependencies:{leveldown:"~0.10.0",bustermove:"*",tap:"*",referee:"*",rimraf:"*",async:"*",fstream:"*",tar:"*",mkfiletree:"*",readfiletree:"*","slow-stream":">=0.0.4",delayed:"*",boganipsum:"*",du:"*",memdown:"*","msgpack-js":"*"},browser:{leveldown:!1,"leveldown/package":!1,semver:!1},scripts:{test:"tap test/*-test.js --stderr",functionaltests:"node ./test/functional/fstream-test.js && node ./test/functional/binary-data-test.js && node ./test/functional/compat-test.js",alltests:"npm test && npm run-script functionaltests"},license:"MIT",gitHead:"213e989e2b75273e2b44c23f84f95e35bff7ea11",bugs:{url:"https://github.com/rvagg/node-levelup/issues"},_id:"levelup@0.18.6",_shasum:"e6a01cb089616c8ecc0291c2a9bd3f0c44e3e5eb",_from:"levelup@~0.18.4",_npmVersion:"1.4.14",_npmUser:{name:"rvagg",email:"rod@vagg.org"},maintainers:[{name:"rvagg",email:"rod@vagg.org"}],dist:{shasum:"e6a01cb089616c8ecc0291c2a9bd3f0c44e3e5eb",tarball:"http://127.0.0.1:5080/tarballs/levelup/0.18.6.tgz"},_resolved:"http://127.0.0.1:5080/tarballs/levelup/0.18.6.tgz",readme:"ERROR: No README data found!"}},{}],72:[function(e,t){"use strict";function n(){}t.exports=n},{}],73:[function(e,t){"use strict";var n=e("./promise"),r=e("./reject"),i=e("./resolve"),o=e("./INTERNAL"),s=e("./handlers"),a=r(new TypeError("must be an array"));t.exports=function(e){function t(e,t){function n(e){c[t]=e,++l===r&!u&&(u=!0,s.resolve(d,c))}i(e).then(n,function(e){u||(u=!0,s.reject(d,e))})}if("[object Array]"!==Object.prototype.toString.call(e))return a;var r=e.length,u=!1;if(!r)return i([]);for(var c=new Array(r),l=0,f=-1,d=new n(o);++f<r;)t(e[f],f);return d}},{"./INTERNAL":72,"./handlers":74,"./promise":76,"./reject":78,"./resolve":79}],74:[function(e,t,n){"use strict";function r(e){var t=e&&e.then;return e&&"object"==typeof e&&"function"==typeof t?function(){t.apply(e,arguments)}:void 0}var i=e("./tryCatch"),o=e("./resolveThenable"),s=e("./states");n.resolve=function(e,t){var a=i(r,t);if("error"===a.status)return n.reject(e,a.value);var u=a.value;if(u)o.safely(e,u);else{e.state=s.FULFILLED,e.outcome=t;for(var c=-1,l=e.queue.length;++c<l;)e.queue[c].callFulfilled(t)}return e},n.reject=function(e,t){e.state=s.REJECTED,e.outcome=t;for(var n=-1,r=e.queue.length;++n<r;)e.queue[n].callRejected(t);return e}},{"./resolveThenable":80,"./states":81,"./tryCatch":82}],75:[function(e,t,n){t.exports=n=e("./promise"),n.resolve=e("./resolve"),n.reject=e("./reject"),n.all=e("./all")},{"./all":73,"./promise":76,"./reject":78,"./resolve":79}],76:[function(e,t){"use strict";function n(e){if(!(this instanceof n))return new n(e);if("function"!=typeof e)throw new TypeError("reslover must be a function");this.state=s.PENDING,this.queue=[],this.outcome=void 0,e!==i&&o.safely(this,e)}var r=e("./unwrap"),i=e("./INTERNAL"),o=e("./resolveThenable"),s=e("./states"),a=e("./queueItem");t.exports=n,n.prototype["catch"]=function(e){return this.then(null,e)},n.prototype.then=function(e,t){if("function"!=typeof e&&this.state===s.FULFILLED||"function"!=typeof t&&this.state===s.REJECTED)return this;var o=new n(i);if(this.state!==s.PENDING){var u=this.state===s.FULFILLED?e:t;r(o,u,this.outcome)}else this.queue.push(new a(o,e,t));return o}},{"./INTERNAL":72,"./queueItem":77,"./resolveThenable":80,"./states":81,"./unwrap":83}],77:[function(e,t){"use strict";function n(e,t,n){this.promise=e,"function"==typeof t&&(this.onFulfilled=t,this.callFulfilled=this.otherCallFulfilled),"function"==typeof n&&(this.onRejected=n,this.callRejected=this.otherCallRejected)}var r=e("./handlers"),i=e("./unwrap");t.exports=n,n.prototype.callFulfilled=function(e){r.resolve(this.promise,e)},n.prototype.otherCallFulfilled=function(e){i(this.promise,this.onFulfilled,e)},n.prototype.callRejected=function(e){r.reject(this.promise,e)},n.prototype.otherCallRejected=function(e){i(this.promise,this.onRejected,e)}},{"./handlers":74,"./unwrap":83}],78:[function(e,t){"use strict";function n(e){var t=new r(i);return o.reject(t,e)}var r=e("./promise"),i=e("./INTERNAL"),o=e("./handlers");t.exports=n},{"./INTERNAL":72,"./handlers":74,"./promise":76}],79:[function(e,t){"use strict";function n(e){if(e)return e instanceof r?e:o.resolve(new r(i),e);var t=typeof e;switch(t){case"boolean":return s;case"undefined":return u;case"object":return a;case"number":return c;case"string":return l}}var r=e("./promise"),i=e("./INTERNAL"),o=e("./handlers");t.exports=n;var s=o.resolve(new r(i),!1),a=o.resolve(new r(i),null),u=o.resolve(new r(i),void 0),c=o.resolve(new r(i),0),l=o.resolve(new r(i),"")},{"./INTERNAL":72,"./handlers":74,"./promise":76}],80:[function(e,t,n){"use strict";function r(e,t){function n(t){a||(a=!0,i.reject(e,t))}function r(t){a||(a=!0,i.resolve(e,t))}function s(){t(r,n)}var a=!1,u=o(s);"error"===u.status&&n(u.value)}var i=e("./handlers"),o=e("./tryCatch");n.safely=r},{"./handlers":74,"./tryCatch":82}],81:[function(e,t,n){n.REJECTED=["REJECTED"],n.FULFILLED=["FULFILLED"],n.PENDING=["PENDING"]},{}],82:[function(e,t){"use strict";function n(e,t){var n={};try{n.value=e(t),n.status="success"}catch(r){n.status="error",n.value=r}return n}t.exports=n},{}],83:[function(e,t){"use strict";function n(e,t,n){r(function(){var r;try{r=t(n)}catch(o){return i.reject(e,o)}r===e?i.reject(e,new TypeError("Cannot resolve promise with itself")):i.resolve(e,r)})}var r=e("immediate"),i=e("./handlers");t.exports=n},{"./handlers":74,immediate:84}],84:[function(e,t){"use strict";function n(){i=!0;for(var e,t,n=a.length;n;){for(t=a,a=[],e=-1;++e<n;)t[e]();n=a.length}i=!1}function r(e){1!==a.push(e)||i||o()}for(var i,o,s=[e("./nextTick"),e("./mutation.js"),e("./messageChannel"),e("./stateChange"),e("./timeout")],a=[],u=-1,c=s.length;++u<c;)if(s[u]&&s[u].test&&s[u].test()){o=s[u].install(n);break}t.exports=r},{"./messageChannel":85,"./mutation.js":86,"./nextTick":17,"./stateChange":87,"./timeout":88}],85:[function(e,t,n){(function(e){"use strict";n.test=function(){return e.setImmediate?!1:"undefined"!=typeof e.MessageChannel},n.install=function(t){var n=new e.MessageChannel;return n.port1.onmessage=t,function(){n.port2.postMessage(0)}}}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],86:[function(e,t,n){(function(e){"use strict";var t=e.MutationObserver||e.WebKitMutationObserver;n.test=function(){return t},n.install=function(n){var r=0,i=new t(n),o=e.document.createTextNode("");return i.observe(o,{characterData:!0}),function(){o.data=r=++r%2}}}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],87:[function(e,t,n){(function(e){"use strict";n.test=function(){return"document"in e&&"onreadystatechange"in e.document.createElement("script")},n.install=function(t){return function(){var n=e.document.createElement("script");return n.onreadystatechange=function(){t(),n.onreadystatechange=null,n.parentNode.removeChild(n),n=null},e.document.documentElement.appendChild(n),t}}}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],88:[function(e,t,n){"use strict";n.test=function(){return!0},n.install=function(e){return function(){setTimeout(e,0)}}},{}],RQL87X:[function(e,t){(function(n,r,i){function o(e){return"string"==typeof e?"$"+e:JSON.stringify(e)}function s(e,t){for(var n,r=0,i=e.length;i>r;)n=r+i>>>1,e[n]<t?r=n+1:i=n;return r}function a(e,t){f.call(this,e),this._reverse=t.reverse,this._limit=t.limit,this._count=0,this._end=t.end,this._start=t.start,this._gt=t.gt,this._gte=t.gte,this._lt=t.lt,this._lte=t.lte,this._keys=[];var n;if(this._start){for(n=0;n<this.db._keys.length;n++)if(this.db._keys[n]>=this._start){this._pos=n,this.db._keys[n]!=this._start?this._reverse&&--this._pos:t.exclusiveStart&&(this._pos+=this._reverse?-1:1);break}null!=this._pos||this._reverse||(this._pos=-1)}t.start&&void 0!==this._pos||(this._pos=this._reverse?this.db._keys.length-1:0),this._pos>=0&&(this._keys=this._reverse?this.db._keys.slice(0,this._pos+1):this.db._keys.slice(this._pos),this._pos=this._reverse?this._keys.length-1:0)}function u(e){return this instanceof u?(l.call(this,"string"==typeof e?e:""),this._store={},void(this._keys=[])):new u(e)}var c=e("util"),l=e("abstract-leveldown").AbstractLevelDOWN,f=e("abstract-leveldown").AbstractIterator,d=function(){},h=r.setImmediate||n.nextTick;c.inherits(a,f),a.prototype._next=function(e){var t,n=this,r=n._keys[n._pos];return n._pos>=n._keys.length||n._pos<0?h(e):n._end&&(n._reverse?r<n._end:r>n._end)?h(e):n._limit&&n._limit>0&&n._count++>=n._limit?h(e):this._lt&&r>=this._lt||this._lte&&r>this._lte||this._gt&&r<=this._gt||this._gte&&r<this._gte?h(e):(t=n.db._store[o(r)],n._pos+=n._reverse?-1:1,void h(function(){e(null,r,t)}))},c.inherits(u,l),u.prototype._open=function(e,t){var n=this;h(function(){t(null,n)})},u.prototype._put=function(e,t,n,r){var i=s(this._keys,e);this._keys[i]!=e&&this._keys.splice(i,0,e),e=o(e),this._store[e]=t,h(r)},u.prototype._get=function(e,t,n){var r=this._store[o(e)];return void 0===r?h(function(){n(new Error("NotFound"))}):(t.asBuffer===!1||i.isBuffer(r)||(r=new i(String(r))),void h(function(){n(null,r)}))},u.prototype._del=function(e,t,n){var r=s(this._keys,e);this._keys[r]==e&&this._keys.splice(r,1),delete this._store[o(e)],h(n)},u.prototype._batch=function(e,t,n){var r,o,s,a=0;if(Array.isArray(e))for(;a<e.length;a++)if(e[a]){if(o=i.isBuffer(e[a].key)?e[a].key:String(e[a].key),r=this._checkKeyValue(o,"key"))return h(function(){n(r)});if("del"===e[a].type)this._del(e[a].key,t,d);else if("put"===e[a].type){if(s=i.isBuffer(e[a].value)?e[a].value:String(e[a].value),r=this._checkKeyValue(s,"value"))return h(function(){n(r)});this._put(o,s,t,d)}}h(n)},u.prototype._iterator=function(e){return new a(this,e)},u.prototype._isBuffer=function(e){return i.isBuffer(e)},t.exports=u}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{},e("buffer").Buffer)},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"abstract-leveldown":93,buffer:20,util:32}],leveldown:[function(e,t){t.exports=e("RQL87X")},{}],91:[function(e,t){t.exports=e(55)},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],92:[function(e,t){t.exports=e(56)},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19}],93:[function(e,t){t.exports=e(57)},{"./abstract-chained-batch":91,"./abstract-iterator":92,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,xtend:94}],94:[function(e,t){t.exports=e(70)},{}],95:[function(e,t){"use strict";function n(e){return null===e?String(e):"object"==typeof e||"function"==typeof e?a[f.call(e)]||"object":typeof e}function r(e){return null!==e&&e===e.window}function i(e){if(!e||"object"!==n(e)||e.nodeType||r(e))return!1;try{if(e.constructor&&!d.call(e,"constructor")&&!d.call(e.constructor.prototype,"isPrototypeOf"))return!1}catch(t){return!1}var i;for(i in e);return void 0===i||d.call(e,i)}function o(e){return"function"===n(e)}function s(){var e,t,n,r,a,u,c=arguments[0]||{},l=1,f=arguments.length,d=!1;for("boolean"==typeof c&&(d=c,c=arguments[1]||{},l=2),"object"==typeof c||o(c)||(c={}),f===l&&(c=this,--l);f>l;l++)if(null!=(e=arguments[l]))for(t in e)if(!(t in Object.prototype)){if(n=c[t],r=e[t],c===r)continue;d&&r&&(i(r)||(a=h(r)))?(a?(a=!1,u=n&&h(n)?n:[]):u=n&&i(n)?n:{},c[t]=s(d,u,r)):void 0!==r&&(h(e)&&o(r)||(c[t]=r))}return c}for(var a={},u=["Boolean","Number","String","Function","Array","Date","RegExp","Object","Error"],c=0;c<u.length;c++){var l=u[c];a["[object "+l+"]"]=l.toLowerCase()}var f=a.toString,d=a.hasOwnProperty,h=Array.isArray||function(e){return"array"===n(e)};t.exports=s},{}],96:[function(e,t,n){!function(e){if("object"==typeof n)t.exports=e();else if("function"==typeof define&&define.amd)define(e);else{var r;try{r=window}catch(i){r=self}r.SparkMD5=e()}}(function(){"use strict";var e=function(e,t){return e+t&4294967295},t=function(t,n,r,i,o,s){return n=e(e(n,t),e(i,s)),e(n<<o|n>>>32-o,r)},n=function(e,n,r,i,o,s,a){return t(n&r|~n&i,e,n,o,s,a)},r=function(e,n,r,i,o,s,a){return t(n&i|r&~i,e,n,o,s,a)},i=function(e,n,r,i,o,s,a){return t(n^r^i,e,n,o,s,a)},o=function(e,n,r,i,o,s,a){return t(r^(n|~i),e,n,o,s,a)},s=function(t,s){var a=t[0],u=t[1],c=t[2],l=t[3];a=n(a,u,c,l,s[0],7,-680876936),l=n(l,a,u,c,s[1],12,-389564586),c=n(c,l,a,u,s[2],17,606105819),u=n(u,c,l,a,s[3],22,-1044525330),a=n(a,u,c,l,s[4],7,-176418897),l=n(l,a,u,c,s[5],12,1200080426),c=n(c,l,a,u,s[6],17,-1473231341),u=n(u,c,l,a,s[7],22,-45705983),a=n(a,u,c,l,s[8],7,1770035416),l=n(l,a,u,c,s[9],12,-1958414417),c=n(c,l,a,u,s[10],17,-42063),u=n(u,c,l,a,s[11],22,-1990404162),a=n(a,u,c,l,s[12],7,1804603682),l=n(l,a,u,c,s[13],12,-40341101),c=n(c,l,a,u,s[14],17,-1502002290),u=n(u,c,l,a,s[15],22,1236535329),a=r(a,u,c,l,s[1],5,-165796510),l=r(l,a,u,c,s[6],9,-1069501632),c=r(c,l,a,u,s[11],14,643717713),u=r(u,c,l,a,s[0],20,-373897302),a=r(a,u,c,l,s[5],5,-701558691),l=r(l,a,u,c,s[10],9,38016083),c=r(c,l,a,u,s[15],14,-660478335),u=r(u,c,l,a,s[4],20,-405537848),a=r(a,u,c,l,s[9],5,568446438),l=r(l,a,u,c,s[14],9,-1019803690),c=r(c,l,a,u,s[3],14,-187363961),u=r(u,c,l,a,s[8],20,1163531501),a=r(a,u,c,l,s[13],5,-1444681467),l=r(l,a,u,c,s[2],9,-51403784),c=r(c,l,a,u,s[7],14,1735328473),u=r(u,c,l,a,s[12],20,-1926607734),a=i(a,u,c,l,s[5],4,-378558),l=i(l,a,u,c,s[8],11,-2022574463),c=i(c,l,a,u,s[11],16,1839030562),u=i(u,c,l,a,s[14],23,-35309556),a=i(a,u,c,l,s[1],4,-1530992060),l=i(l,a,u,c,s[4],11,1272893353),c=i(c,l,a,u,s[7],16,-155497632),u=i(u,c,l,a,s[10],23,-1094730640),a=i(a,u,c,l,s[13],4,681279174),l=i(l,a,u,c,s[0],11,-358537222),c=i(c,l,a,u,s[3],16,-722521979),u=i(u,c,l,a,s[6],23,76029189),a=i(a,u,c,l,s[9],4,-640364487),l=i(l,a,u,c,s[12],11,-421815835),c=i(c,l,a,u,s[15],16,530742520),u=i(u,c,l,a,s[2],23,-995338651),a=o(a,u,c,l,s[0],6,-198630844),l=o(l,a,u,c,s[7],10,1126891415),c=o(c,l,a,u,s[14],15,-1416354905),u=o(u,c,l,a,s[5],21,-57434055),a=o(a,u,c,l,s[12],6,1700485571),l=o(l,a,u,c,s[3],10,-1894986606),c=o(c,l,a,u,s[10],15,-1051523),u=o(u,c,l,a,s[1],21,-2054922799),a=o(a,u,c,l,s[8],6,1873313359),l=o(l,a,u,c,s[15],10,-30611744),c=o(c,l,a,u,s[6],15,-1560198380),u=o(u,c,l,a,s[13],21,1309151649),a=o(a,u,c,l,s[4],6,-145523070),l=o(l,a,u,c,s[11],10,-1120210379),c=o(c,l,a,u,s[2],15,718787259),u=o(u,c,l,a,s[9],21,-343485551),t[0]=e(a,t[0]),t[1]=e(u,t[1]),t[2]=e(c,t[2]),t[3]=e(l,t[3])
+},a=function(e){var t,n=[];for(t=0;64>t;t+=4)n[t>>2]=e.charCodeAt(t)+(e.charCodeAt(t+1)<<8)+(e.charCodeAt(t+2)<<16)+(e.charCodeAt(t+3)<<24);return n},u=function(e){var t,n=[];for(t=0;64>t;t+=4)n[t>>2]=e[t]+(e[t+1]<<8)+(e[t+2]<<16)+(e[t+3]<<24);return n},c=function(e){var t,n,r,i,o,u,c=e.length,l=[1732584193,-271733879,-1732584194,271733878];for(t=64;c>=t;t+=64)s(l,a(e.substring(t-64,t)));for(e=e.substring(t-64),n=e.length,r=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],t=0;n>t;t+=1)r[t>>2]|=e.charCodeAt(t)<<(t%4<<3);if(r[t>>2]|=128<<(t%4<<3),t>55)for(s(l,r),t=0;16>t;t+=1)r[t]=0;return i=8*c,i=i.toString(16).match(/(.*?)(.{0,8})$/),o=parseInt(i[2],16),u=parseInt(i[1],16)||0,r[14]=o,r[15]=u,s(l,r),l},l=function(e){var t,n,r,i,o,a,c=e.length,l=[1732584193,-271733879,-1732584194,271733878];for(t=64;c>=t;t+=64)s(l,u(e.subarray(t-64,t)));for(e=c>t-64?e.subarray(t-64):new Uint8Array(0),n=e.length,r=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],t=0;n>t;t+=1)r[t>>2]|=e[t]<<(t%4<<3);if(r[t>>2]|=128<<(t%4<<3),t>55)for(s(l,r),t=0;16>t;t+=1)r[t]=0;return i=8*c,i=i.toString(16).match(/(.*?)(.{0,8})$/),o=parseInt(i[2],16),a=parseInt(i[1],16)||0,r[14]=o,r[15]=a,s(l,r),l},f=["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"],d=function(e){var t,n="";for(t=0;4>t;t+=1)n+=f[e>>8*t+4&15]+f[e>>8*t&15];return n},h=function(e){var t;for(t=0;t<e.length;t+=1)e[t]=d(e[t]);return e.join("")},p=function(e){return h(c(e))},g=function(){this.reset()};return"5d41402abc4b2a76b9719d911017c592"!==p("hello")&&(e=function(e,t){var n=(65535&e)+(65535&t),r=(e>>16)+(t>>16)+(n>>16);return r<<16|65535&n}),g.prototype.append=function(e){return/[\u0080-\uFFFF]/.test(e)&&(e=unescape(encodeURIComponent(e))),this.appendBinary(e),this},g.prototype.appendBinary=function(e){this._buff+=e,this._length+=e.length;var t,n=this._buff.length;for(t=64;n>=t;t+=64)s(this._state,a(this._buff.substring(t-64,t)));return this._buff=this._buff.substr(t-64),this},g.prototype.end=function(e){var t,n,r=this._buff,i=r.length,o=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];for(t=0;i>t;t+=1)o[t>>2]|=r.charCodeAt(t)<<(t%4<<3);return this._finish(o,i),n=e?this._state:h(this._state),this.reset(),n},g.prototype._finish=function(e,t){var n,r,i,o=t;if(e[o>>2]|=128<<(o%4<<3),o>55)for(s(this._state,e),o=0;16>o;o+=1)e[o]=0;n=8*this._length,n=n.toString(16).match(/(.*?)(.{0,8})$/),r=parseInt(n[2],16),i=parseInt(n[1],16)||0,e[14]=r,e[15]=i,s(this._state,e)},g.prototype.reset=function(){return this._buff="",this._length=0,this._state=[1732584193,-271733879,-1732584194,271733878],this},g.prototype.destroy=function(){delete this._state,delete this._buff,delete this._length},g.hash=function(e,t){/[\u0080-\uFFFF]/.test(e)&&(e=unescape(encodeURIComponent(e)));var n=c(e);return t?n:h(n)},g.hashBinary=function(e,t){var n=c(e);return t?n:h(n)},g.ArrayBuffer=function(){this.reset()},g.ArrayBuffer.prototype.append=function(e){var t,n=this._concatArrayBuffer(this._buff,e),r=n.length;for(this._length+=e.byteLength,t=64;r>=t;t+=64)s(this._state,u(n.subarray(t-64,t)));return this._buff=r>t-64?n.subarray(t-64):new Uint8Array(0),this},g.ArrayBuffer.prototype.end=function(e){var t,n,r=this._buff,i=r.length,o=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];for(t=0;i>t;t+=1)o[t>>2]|=r[t]<<(t%4<<3);return this._finish(o,i),n=e?this._state:h(this._state),this.reset(),n},g.ArrayBuffer.prototype._finish=g.prototype._finish,g.ArrayBuffer.prototype.reset=function(){return this._buff=new Uint8Array(0),this._length=0,this._state=[1732584193,-271733879,-1732584194,271733878],this},g.ArrayBuffer.prototype.destroy=g.prototype.destroy,g.ArrayBuffer.prototype._concatArrayBuffer=function(e,t){var n=e.length,r=new Uint8Array(n+t.byteLength);return r.set(e),r.set(new Uint8Array(t),n),r},g.ArrayBuffer.hash=function(e,t){var n=l(new Uint8Array(e));return t?n:h(n)},g})},{}],97:[function(e,t,n){arguments[4][61][0].apply(n,arguments)},{"./_stream_readable":98,"./_stream_writable":100,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,"core-util-is":101,inherits:33}],98:[function(e,t){t.exports=e(63)},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,"core-util-is":101,events:18,inherits:33,isarray:102,stream:24,"string_decoder/":103}],99:[function(e,t,n){arguments[4][64][0].apply(n,arguments)},{"./_stream_duplex":97,"core-util-is":101,inherits:33}],100:[function(e,t,n){arguments[4][65][0].apply(n,arguments)},{"./_stream_duplex":97,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":19,buffer:20,"core-util-is":101,inherits:33,stream:24}],101:[function(e,t){t.exports=e(66)},{buffer:20}],102:[function(e,t){t.exports=e(67)},{}],103:[function(e,t){t.exports=e(68)},{buffer:20}],104:[function(e,t){t.exports=e("./lib/_stream_transform.js")},{"./lib/_stream_transform.js":99}],105:[function(e,t){t.exports=e(40)},{}],106:[function(e,t,n){arguments[4][41][0].apply(n,arguments)},{"./has-keys":105,"object-keys":108}],107:[function(e,t){var n=Object.prototype.hasOwnProperty,r=Object.prototype.toString,i=function(e){var t="function"==typeof e&&!(e instanceof RegExp)||"[object Function]"===r.call(e);return t||"undefined"==typeof window||(t=e===window.setTimeout||e===window.alert||e===window.confirm||e===window.prompt),t};t.exports=function(e,t){if(!i(t))throw new TypeError("iterator must be a function");var r,o,s="string"==typeof e,a=e.length,u=arguments.length>2?arguments[2]:null;if(a===+a)for(r=0;a>r;r++)null===u?t(s?e.charAt(r):e[r],r,e):t.call(u,s?e.charAt(r):e[r],r,e);else for(o in e)n.call(e,o)&&(null===u?t(e[o],o,e):t.call(u,e[o],o,e))}},{}],108:[function(e,t,n){arguments[4][42][0].apply(n,arguments)},{"./shim":110}],109:[function(e,t){var n=Object.prototype.toString;t.exports=function r(e){var t=n.call(e),r="[object Arguments]"===t;return r||(r="[object Array]"!==t&&null!==e&&"object"==typeof e&&"number"==typeof e.length&&e.length>=0&&"[object Function]"===n.call(e.callee)),r}},{}],110:[function(e,t){!function(){"use strict";var n,r=Object.prototype.hasOwnProperty,i=Object.prototype.toString,o=e("./foreach"),s=e("./isArguments"),a=!{toString:null}.propertyIsEnumerable("toString"),u=function(){}.propertyIsEnumerable("prototype"),c=["toString","toLocaleString","valueOf","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","constructor"];n=function(e){var t=null!==e&&"object"==typeof e,n="[object Function]"===i.call(e),l=s(e),f=[];if(!t&&!n&&!l)throw new TypeError("Object.keys called on a non-object");if(l)o(e,function(e){f.push(e)});else{var d,h=u&&n;for(d in e)h&&"prototype"===d||!r.call(e,d)||f.push(d)}if(a){var p=e.constructor,g=p&&p.prototype===e;o(c,function(t){g&&"constructor"===t||!r.call(e,t)||f.push(t)})}return f},t.exports=n}()},{"./foreach":107,"./isArguments":109}],111:[function(e,t){function n(e,t,n){n(null,e)}function r(e){return function(t,r,i){return"function"==typeof t&&(i=r,r=t,t={}),"function"!=typeof r&&(r=n),"function"!=typeof i&&(i=null),e(t,r,i)}}var i=e("readable-stream/transform"),o=e("util").inherits,s=e("xtend");t.exports=r(function(e,t,n){var r=new i(e);return r._transform=t,n&&(r._flush=n),r}),t.exports.ctor=r(function(e,t,n){function r(t){return this instanceof r?(this.options=s(e,t),void i.call(this,this.options)):new r(t)}return o(r,i),r.prototype._transform=t,n&&(r.prototype._flush=n),r}),t.exports.obj=r(function(e,t,n){var r=new i(s({objectMode:!0},e));return r._transform=t,n&&(r._flush=n),r})},{"readable-stream/transform":104,util:32,xtend:106}]},{},[11]);
\ No newline at end of file
diff --git a/dist/pouchdb.min.js b/dist/pouchdb.min.js
new file mode 100644
index 0000000..59e55d8
--- /dev/null
+++ b/dist/pouchdb.min.js
@@ -0,0 +1,10 @@
+// PouchDB 3.0.1
+//
+// (c) 2012-2014 Dale Harvey and the PouchDB team
+// PouchDB may be freely distributed under the Apache license, version 2.0.
+// For all details and documentation:
+// http://pouchdb.com
+!function(e){if("object"==typeof exports)module.exports=e();else if("function"==typeof define&&define.amd)define(e);else{var t;"undefined"!=typeof window?t=window:"undefined"!=typeof global?t=global:"undefined"!=typeof self&&(t=self),t.PouchDB=e()}}(function(){var define,module,exports;return function e(t,n,r){function o(s,a){if(!n[s]){if(!t[s]){var u="function"==typeof require&&require;if(!a&&u)return u(s,!0);if(i)return i(s,!0);throw new Error("Cannot find module '"+s+"'")}var c=n[s]={exports:{}};t[s][0].call(c.exports,function(e){var n=t[s][1][e];return o(n?n:e)},c,c.exports,e,t,n,r)}return n[s].exports}for(var i="function"==typeof require&&require,s=0;s<r.length;s++)o(r[s]);return o}({1:[function(e,t){"use strict";function n(e,t){for(var n=0;n<e.length;n++)if(t(e[n],n)===!0)return e[n];return!1}function r(e){return function(t,n){t||n[0].error?e(t||n[0]):e(null,n[0])}}function o(e){var t={},n=[];return u.traverseRevTree(e,function(e,r,o,i){var s=r+"-"+o;return e&&(t[s]=0),void 0!==i&&n.push({from:i,to:s}),s}),n.reverse(),n.forEach(function(e){t[e.from]=void 0===t[e.from]?1+t[e.to]:Math.min(t[e.from],1+t[e.to])}),t}function i(e,t,n){var r="limit"in t?t.keys.slice(t.skip,t.limit+t.skip):t.skip>0?t.keys.slice(t.skip):t.keys;if(t.descending&&r.reverse(),!r.length)return e._allDocs({limit:0},n);var o={offset:t.skip};return p.all(r.map(function(n){var r=a.extend(!0,{key:n,deleted:"ok"},t);return["limit","skip","keys"].forEach(function(e){delete r[e]}),new p(function(t,i){e._allDocs(r,function(e,r){return e?i(e):(o.total_rows=r.total_rows,void t(r.rows[0]||{key:n,error:"not_found"}))})})})).then(function(e){return o.rows=e,o})}function s(){var e=this;d.call(this),e.autoCompact=function(t){return e.auto_compaction?function(n,r){if(n)t(n);else{var o=r.length,i=function(){o--,o||t(null,r)};r.forEach(function(t){t.ok&&t.id?e.compactDocument(t.id,1,i):i()})}}:t};var t,n=0,r=["change","delete","create","update"];this.on("newListener",function(o){if(~r.indexOf(o)){if(n)return void n++;n++;var i=0;t=this.changes({conflicts:!0,include_docs:!0,continuous:!0,since:"now",onChange:function(t){t.seq<=i||(i=t.seq,e.emit("change",t),t.doc._deleted?e.emit("delete",t):"1"===t.doc._rev.split("-")[0]?e.emit("create",t):e.emit("update",t))}})}}),this.on("removeListener",function(e){~r.indexOf(e)&&(n--,n||t.cancel())})}var a=e("./utils"),u=e("./merge"),c=e("./deps/errors"),d=e("events").EventEmitter,l=e("./deps/upsert"),f=e("./changes"),p=a.Promise;a.inherits(s,d),t.exports=s,s.prototype.post=a.adapterFun("post",function(e,t,n){return"function"==typeof t&&(n=t,t={}),"object"!=typeof e||Array.isArray(e)?n(c.NOT_AN_OBJECT):void this.bulkDocs({docs:[e]},t,this.autoCompact(r(n)))}),s.prototype.put=a.adapterFun("put",a.getArguments(function(e){var t,n,o,i,s=e.shift(),u="_id"in s;if("object"!=typeof s||Array.isArray(s))return(i=e.pop())(c.NOT_AN_OBJECT);for(s=a.clone(s);;)if(t=e.shift(),n=typeof t,"string"!==n||u?"string"!==n||!u||"_rev"in s?"object"===n?o=t:"function"===n&&(i=t):s._rev=t:(s._id=t,u=!0),!e.length)break;o=o||{};var d=a.invalidIdError(s._id);return d?i(d):a.isLocalId(s._id)&&"function"==typeof this._putLocal?s._deleted?this._removeLocal(s,i):this._putLocal(s,i):void this.bulkDocs({docs:[s]},o,this.autoCompact(r(i)))})),s.prototype.putAttachment=a.adapterFun("putAttachment",function(e,t,n,r,o,i){function s(e){return e._attachments=e._attachments||{},e._attachments[t]={content_type:o,data:r},a.put(e)}var a=this;return"function"==typeof o&&(i=o,o=r,r=n,n=null),"undefined"==typeof o&&(o=r,r=n,n=null),a.get(e).then(function(e){if(e._rev!==n)throw c.REV_CONFLICT;return s(e)},function(t){if(t.error===c.MISSING_DOC.error)return s({_id:e});throw t})}),s.prototype.removeAttachment=a.adapterFun("removeAttachment",function(e,t,n,r){var o=this;o.get(e,function(e,i){return e?void r(e):i._rev!==n?void r(c.REV_CONFLICT):i._attachments?(delete i._attachments[t],0===Object.keys(i._attachments).length&&delete i._attachments,void o.put(i,r)):r()})}),s.prototype.remove=a.adapterFun("remove",function(e,t,n,o){var i;"string"==typeof t?(i={_id:e,_rev:t},"function"==typeof n&&(o=n,n={})):(i=e,"function"==typeof t?(o=t,n={}):(o=n,n=t)),n=a.clone(n||{}),n.was_delete=!0;var s={_id:i._id,_rev:i._rev||n.rev};return s._deleted=!0,a.isLocalId(s._id)&&"function"==typeof this._removeLocal?this._removeLocal(i,o):void this.bulkDocs({docs:[s]},n,r(o))}),s.prototype.revsDiff=a.adapterFun("revsDiff",function(e,t,n){function r(e,t){c.has(e)||c.set(e,{missing:[]}),c.get(e).missing.push(t)}function o(t,n){var o=e[t].slice(0);u.traverseRevTree(n,function(e,n,i,s,a){var u=n+"-"+i,c=o.indexOf(u);-1!==c&&(o.splice(c,1),"available"!==a.status&&r(t,u))}),o.forEach(function(e){r(t,e)})}"function"==typeof t&&(n=t,t={}),t=a.clone(t);var i=Object.keys(e);if(!i.length)return n(null,{});var s=0,c=new a.Map;i.map(function(t){this._getRevisionTree(t,function(r,a){if(r&&"not_found"===r.name&&"missing"===r.message)c.set(t,{missing:e[t]});else{if(r)return n(r);o(t,a)}if(++s===i.length){var u={};return c.forEach(function(e,t){u[t]=e}),n(null,u)}})},this)}),s.prototype.compactDocument=function(e,t,n){var r=this;this._getRevisionTree(e,function(i,s){if(i)return n(i);var a=o(s),c=[],d=[];Object.keys(a).forEach(function(e){a[e]>t&&c.push(e)}),u.traverseRevTree(s,function(e,t,n,r,o){var i=t+"-"+n;"available"===o.status&&-1!==c.indexOf(i)&&(o.status="missing",d.push(i))}),r._doCompaction(e,s,d,n)})},s.prototype.compact=a.adapterFun("compact",function(e,t){"function"==typeof e&&(t=e,e={});var n=this;this.changes({complete:function(e,r){if(e)return void t();var o=r.results.length;return o?void r.results.forEach(function(e){n.compactDocument(e.id,0,function(){o--,o||t()})}):void t()}})}),s.prototype.get=a.adapterFun("get",function(e,t,r){function o(){var n=[],o=i.length;return o?void i.forEach(function(i){s.get(e,{rev:i,revs:t.revs,attachments:t.attachments},function(e,t){n.push(e?{missing:i}:{ok:t}),o--,o||r(null,n)})}):r(null,n)}if("function"==typeof t&&(r=t,t={}),"string"!=typeof e)return r(c.INVALID_ID);if(a.isLocalId(e)&&"function"==typeof this._getLocal)return this._getLocal(e,r);var i=[],s=this;if(!t.open_revs)return this._get(e,t,function(e,o){if(t=a.clone(t),e)return r(e);var i=o.doc;if(!i)return r(new Error("no doc!"));var c=o.metadata,d=o.ctx;if(t.conflicts){var l=u.collectConflicts(c);l.length&&(i._conflicts=l)}if(t.revs||t.revs_info){var f=u.rootToLeaf(c.rev_tree),p=n(f,function(e){return-1!==e.ids.map(function(e){return e.id}).indexOf(i._rev.split("-")[1])}),h=p.ids.map(function(e){return e.id}).indexOf(i._rev.split("-")[1])+1,v=p.ids.length-h;if(p.ids.splice(h,v),p.ids.reverse(),t.revs&&(i._revisions={start:p.pos+p.ids.length-1,ids:p.ids.map(function(e){return e.id})}),t.revs_info){var m=p.pos+p.ids.length;i._revs_info=p.ids.map(function(e){return m--,{rev:m+"-"+e.id,status:e.opts.status}})}}if(t.local_seq&&(i._local_seq=o.metadata.seq),t.attachments&&i._attachments){var _=i._attachments,y=Object.keys(_).length;if(0===y)return r(null,i);Object.keys(_).forEach(function(e){this._getAttachment(_[e],{encode:!0,ctx:d},function(t,n){var o=i._attachments[e];o.data=n,delete o.stub,--y||r(null,i)})},s)}else{if(i._attachments)for(var g in i._attachments)i._attachments.hasOwnProperty(g)&&(i._attachments[g].stub=!0);r(null,i)}});if("all"===t.open_revs)this._getRevisionTree(e,function(e,t){e&&(t=[]),i=u.collectLeaves(t).map(function(e){return e.rev}),o()});else{if(!Array.isArray(t.open_revs))return r(c.error(c.UNKNOWN_ERROR,"function_clause"));i=t.open_revs;for(var d=0;d<i.length;d++){var l=i[d];if("string"!=typeof l||!/^\d+-/.test(l))return r(c.error(c.BAD_REQUEST,"Invalid rev format"))}o()}}),s.prototype.getAttachment=a.adapterFun("getAttachment",function(e,t,n,r){var o=this;n instanceof Function&&(r=n,n={}),n=a.clone(n),this._get(e,n,function(e,i){return e?r(e):i.doc._attachments&&i.doc._attachments[t]?(n.ctx=i.ctx,void o._getAttachment(i.doc._attachments[t],n,r)):r(c.MISSING_DOC)})}),s.prototype.allDocs=a.adapterFun("allDocs",function(e,t){if("function"==typeof e&&(t=e,e={}),e=a.clone(e),e.skip="undefined"!=typeof e.skip?e.skip:0,"keys"in e){if(!Array.isArray(e.keys))return t(new TypeError("options.keys must be an array"));var n=["startkey","endkey","key"].filter(function(t){return t in e})[0];if(n)return void t(c.error(c.QUERY_PARSE_ERROR,"Query parameter `"+n+"` is not compatible with multi-get"));if("http"!==this.type())return i(this,e,t)}return this._allDocs(e,t)}),s.prototype.changes=function(e,t){return"function"==typeof e&&(t=e,e={}),new f(this,e,t)},s.prototype.close=a.adapterFun("close",function(e){return this._closed=!0,this._close(e)}),s.prototype.info=a.adapterFun("info",function(e){var t=this;this._info(function(n,r){return n?e(n):(r.db_name=r.db_name||t._db_name,void e(null,r))})}),s.prototype.id=a.adapterFun("id",function(e){return this._id(e)}),s.prototype.type=function(){return"function"==typeof this._type?this._type():this.adapter},s.prototype.bulkDocs=a.adapterFun("bulkDocs",function(e,t,n){if("function"==typeof t&&(n=t,t={}),t=a.clone(t),Array.isArray(e)&&(e={docs:e}),!e||!e.docs||!Array.isArray(e.docs))return n(c.MISSING_BULK_DOCS);for(var r=0;r<e.docs.length;++r)if("object"!=typeof e.docs[r]||Array.isArray(e.docs[r]))return n(c.NOT_AN_OBJECT);return e=a.clone(e),"new_edits"in t||(t.new_edits="new_edits"in e?e.new_edits:!0),this._bulkDocs(e,t,this.autoCompact(n))}),s.prototype.registerDependentDatabase=a.adapterFun("registerDependentDatabase",function(e,t){function n(t){return t.dependentDbs=t.dependentDbs||{},t.dependentDbs[e]?!1:(t.dependentDbs[e]=!0,t)}var r=new this.constructor(e,{adapter:this._adapter});l(this,"_local/_pouch_dependentDbs",n,function(e){return e?t(e):t(null,{db:r})})})},{"./changes":6,"./deps/errors":11,"./deps/upsert":13,"./merge":18,"./utils":23,events:27}],2:[function(e,t){"use strict";function n(e){for(var t=n.options,r=t.parser[t.strictMode?"strict":"loose"].exec(e),o={},i=14;i--;)o[t.key[i]]=r[i]||"";return o[t.q.name]={},o[t.key[12]].replace(t.q.parser,function(e,n,r){n&&(o[t.q.name][n]=r)}),o}function r(e){return/^_(design|local)/.test(e)?e:encodeURIComponent(e)}function o(e,t){if(/http(s?):/.test(e)){var r=n(e);r.remote=!0,(r.user||r.password)&&(r.auth={username:r.user,password:r.password});var o=r.path.replace(/(^\/|\/$)/g,"").split("/");if(r.db=o.pop(),r.path=o.join("/"),t=t||{},t=c.clone(t),r.headers=t.headers||{},t.auth||r.auth){var i=t.auth||r.auth,s=c.btoa(i.username+":"+i.password);r.headers.Authorization="Basic "+s}return t.headers&&(r.headers=t.headers),r}return{host:"",path:"/",db:e,auth:!1}}function i(e,t){return s(e,e.db+"/"+t)}function s(e,t){if(e.remote){var n=e.path?"/":"";return e.protocol+"://"+e.host+":"+e.port+"/"+e.path+n+t}return"/"+t}function a(e,t){function n(e,t){return c.ajax(c.extend({},p,e),t)}var a=this;a.getHost=e.getHost?e.getHost:o;var l=a.getHost(e.name,e),f=i(l,"");a.getUrl=function(){return f};var p=e.ajax||{};e=c.clone(e);var h=function(){n({headers:l.headers,method:"PUT",url:f},function(e){e&&401===e.status?n({headers:l.headers,method:"HEAD",url:f},function(e){e?t(e):t(null,a)}):e&&412!==e.status?t(e):t(null,a)})};e.skipSetup||n({headers:l.headers,method:"GET",url:f},function(e){e?404===e.status?h():t(e):t(null,a)}),a.type=function(){return"http"},a.id=c.adapterFun("id",function(e){n({headers:l.headers,method:"GET",url:s(l,"")},function(t,n){var r=n&&n.uuid?n.uuid+l.db:i(l,"");e(null,r)})}),a.request=c.adapterFun("request",function(e,t){e.headers=l.headers,e.url=i(l,e.url),n(e,t)}),a.compact=c.adapterFun("compact",function(e,t){"function"==typeof e&&(t=e,e={}),e=c.clone(e),n({headers:l.headers,url:i(l,"_compact"),method:"POST"},function(){function n(){a.info(function(r,o){o.compact_running?setTimeout(n,e.interval||200):t()})}"function"==typeof t&&n()})}),a._info=function(e){n({headers:l.headers,method:"GET",url:i(l,"")},function(t,n){t?e(t):(n.host=i(l,""),e(null,n))})},a.get=c.adapterFun("get",function(e,t,o){"function"==typeof t&&(o=t,t={}),t=c.clone(t),void 0===t.auto_encode&&(t.auto_encode=!0);var s=[];t.revs&&s.push("revs=true"),t.revs_info&&s.push("revs_info=true"),t.local_seq&&s.push("local_seq=true"),t.open_revs&&("all"!==t.open_revs&&(t.open_revs=JSON.stringify(t.open_revs)),s.push("open_revs="+t.open_revs)),t.attachments&&s.push("attachments=true"),t.rev&&s.push("rev="+t.rev),t.conflicts&&s.push("conflicts="+t.conflicts),s=s.join("&"),s=""===s?"":"?"+s,t.auto_encode&&(e=r(e));var a={headers:l.headers,method:"GET",url:i(l,e+s)},u=e.split("/");(u.length>1&&"_design"!==u[0]&&"_local"!==u[0]||u.length>2&&"_design"===u[0]&&"_local"!==u[0])&&(a.binary=!0),n(a,function(e,t,n){return e?o(e):void o(null,t,n)})}),a.remove=c.adapterFun("remove",function(e,t,o,s){var a;"string"==typeof t?(a={_id:e,_rev:t},"function"==typeof o&&(s=o,o={})):(a=e,"function"==typeof t?(s=t,o={}):(s=o,o=t));var u=a._rev||o.rev;n({headers:l.headers,method:"DELETE",url:i(l,r(a._id))+"?rev="+u},s)}),a.getAttachment=c.adapterFun("getAttachment",function(e,t,n,o){"function"==typeof n&&(o=n,n={}),n=c.clone(n),void 0===n.auto_encode&&(n.auto_encode=!0),n.auto_encode&&(e=r(e)),n.auto_encode=!1,a.get(e+"/"+t,n,o)}),a.removeAttachment=c.adapterFun("removeAttachment",function(e,t,o,s){n({headers:l.headers,method:"DELETE",url:i(l,r(e)+"/"+t)+"?rev="+o},s)}),a.putAttachment=c.adapterFun("putAttachment",function(e,t,o,s,a,u){"function"==typeof a&&(u=a,a=s,s=o,o=null),"undefined"==typeof a&&(a=s,s=o,o=null);var d=r(e)+"/"+t,f=i(l,d);o&&(f+="?rev="+o);var p={headers:c.clone(l.headers),method:"PUT",url:f,processData:!1,body:s,timeout:6e4};p.headers["Content-Type"]=a,n(p,u)}),a.put=c.adapterFun("put",c.getArguments(function(e){var t,o,s,a,u=e.shift(),f="_id"in u;if("object"!=typeof u||Array.isArray(u))return(a=e.pop())(d.NOT_AN_OBJECT);for(u=c.clone(u);;)if(t=e.shift(),o=typeof t,"string"!==o||f?"string"!==o||!f||"_rev"in u?"object"===o?s=c.clone(t):"function"===o&&(a=t):u._rev=t:(u._id=t,f=!0),!e.length)break;s=s||{};var p=c.invalidIdError(u._id);if(p)return a(p);var h=[];s&&"undefined"!=typeof s.new_edits&&h.push("new_edits="+s.new_edits),h=h.join("&"),""!==h&&(h="?"+h),n({headers:l.headers,method:"PUT",url:i(l,r(u._id))+h,body:u},function(e,t){return e?a(e):(t.ok=!0,void a(null,t))})})),a.post=c.adapterFun("post",function(e,t,n){return"function"==typeof t&&(n=t,t={}),t=c.clone(t),"object"!=typeof e?n(d.NOT_AN_OBJECT):("_id"in e||(e._id=c.uuid()),void a.put(e,t,function(e,t){return e?n(e):(t.ok=!0,void n(null,t))}))}),a._bulkDocs=function(e,t,r){"undefined"!=typeof t.new_edits&&(e.new_edits=t.new_edits),n({headers:l.headers,method:"POST",url:i(l,"_bulk_docs"),body:e},function(e,t){return e?r(e):(t.forEach(function(e){e.ok=!0}),void r(null,t))})},a.allDocs=c.adapterFun("allDocs",function(e,t){"function"==typeof e&&(t=e,e={}),e=c.clone(e);var r,o=[],s="GET";if(e.conflicts&&o.push("conflicts=true"),e.descending&&o.push("descending=true"),e.include_docs&&o.push("include_docs=true"),e.key&&o.push("key="+encodeURIComponent(JSON.stringify(e.key))),e.startkey&&o.push("startkey="+encodeURIComponent(JSON.stringify(e.startkey))),e.endkey&&o.push("endkey="+encodeURIComponent(JSON.stringify(e.endkey))),"undefined"!=typeof e.inclusive_end&&o.push("inclusive_end="+!!e.inclusive_end),"undefined"!=typeof e.limit&&o.push("limit="+e.limit),"undefined"!=typeof e.skip&&o.push("skip="+e.skip),o=o.join("&"),""!==o&&(o="?"+o),"undefined"!=typeof e.keys){var a=2e3,u="keys="+encodeURIComponent(JSON.stringify(e.keys));u.length+o.length+1<=a?o+=(-1!==o.indexOf("?")?"&":"?")+u:(s="POST",r=JSON.stringify({keys:e.keys}))}n({headers:l.headers,method:s,url:i(l,"_all_docs"+o),body:r},t)}),a._changes=function(e){var t="batch_size"in e?e.batch_size:u;e=c.clone(e),e.timeout=e.timeout||3e4;var r={timeout:e.timeout-5e3},o="undefined"!=typeof e.limit?e.limit:!1;0===o&&(o=1);var s;s="returnDocs"in e?e.returnDocs:!0;var a=o;if(e.style&&(r.style=e.style),(e.include_docs||e.filter&&"function"==typeof e.filter)&&(r.include_docs=!0),e.continuous&&(r.feed="longpoll"),e.conflicts&&(r.conflicts=!0),e.descending&&(r.descending=!0),e.filter&&"string"==typeof e.filter&&(r.filter=e.filter,"_view"===e.filter&&e.view&&"string"==typeof e.view&&(r.view=e.view)),e.query_params&&"object"==typeof e.query_params)for(var f in e.query_params)e.query_params.hasOwnProperty(f)&&(r[f]=e.query_params[f]);var p,h,v=function(s,u){if(!e.aborted){r.since=s,e.descending?o&&(r.limit=a):r.limit=!o||a>t?t:a;var c="?"+Object.keys(r).map(function(e){return e+"="+r[e]}).join("&"),d={headers:l.headers,method:"GET",url:i(l,"_changes"+c),timeout:e.timeout};h=s,e.aborted||(p=n(d,u))}},m=10,_=0,y={results:[]},g=function(n,r){if(!e.aborted){var i=0;if(r&&r.results){i=r.results.length,y.last_seq=r.last_seq;var u={};u.query=e.query_params,r.results=r.results.filter(function(t){a--;var n=c.filterChange(e)(t);return n&&(s&&y.results.push(t),c.call(e.onChange,t)),n})}else if(n)return e.aborted=!0,void c.call(e.complete,n);r&&r.last_seq&&(h=r.last_seq);var l=o&&0>=a||r&&t>i||e.descending;if((!e.continuous||o&&0>=a)&&l)c.call(e.complete,null,y);else{n?_+=1:_=0;var f=1<<_,p=m*f,b=e.maximumWait||3e4;if(p>b)return void c.call(e.complete,n||d.UNKNOWN_ERROR);setTimeout(function(){v(h,g)},p)}}};return v(e.since||0,g),{cancel:function(){e.aborted=!0,p&&p.abort()}}},a.revsDiff=c.adapterFun("revsDiff",function(e,t,r){"function"==typeof t&&(r=t,t={}),n({headers:l.headers,method:"POST",url:i(l,"_revs_diff"),body:JSON.stringify(e)},r)}),a._close=function(e){e()},a.destroy=c.adapterFun("destroy",function(e){n({url:i(l,""),method:"DELETE",headers:l.headers},function(t,n){t?(a.emit("error",t),e(t)):(a.emit("destroyed"),e(null,n))})})}var u=25,c=e("../utils"),d=e("../deps/errors");n.options={strictMode:!1,key:["source","protocol","authority","userInfo","user","password","host","port","relative","path","directory","file","query","anchor"],q:{name:"queryKey",parser:/(?:^|&)([^&=]*)=?([^&]*)/g},parser:{strict:/^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/,loose:/^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/}},a.destroy=c.toPromise(function(e,t,n){var r=o(e,t);t=t||{},"function"==typeof t&&(n=t,t={}),t=c.clone(t),t.headers=r.headers,t.method="DELETE",t.url=i(r,"");var s=t.ajax||{};t=c.extend({},t,s),c.ajax(t,n)}),a.valid=function(){return!0},t.exports=a},{"../deps/errors":11,"../utils":23}],3:[function(e,t){(function(n,r){"use strict";function o(e,t,n){try{e.apply(t,n)}catch(r){window.PouchDB&&window.PouchDB.emit("error",r)}}function i(){if(!v.running&&v.queue.length){v.running=!0;var e=v.queue.shift();e.action(function(t,r){o(e.callback,this,[t,r]),v.running=!1,n.nextTick(i)})}}function s(e){return function(t){var n=t.target&&t.target.error&&t.target.error.name||t.target;e(p.error(p.IDB_ERROR,n,t.type))}}function a(){var e="_pouch__checkModernIdb_"+(r.navigator&&r.navigator.appVersion),t=l.hasLocalStorage()&&r.localStorage[e];if(t)return JSON.parse(t);var n="_pouch__checkModernIdb",o=null===r.indexedDB.open(n,1).onupgradeneeded;return r.indexedDB.deleteDatabase&&r.indexedDB.deleteDatabase(n),l.hasLocalStorage()&&(r.localStorage[e]=JSON.stringify(o)),o}function u(e,t){var n=this;v.queue.push({action:function(t){c(n,e,t)},callback:t}),i()}function c(e,t,o){function i(e){e.createObjectStore(y,{keyPath:"id"}).createIndex("seq","seq",{unique:!0}),e.createObjectStore(g,{autoIncrement:!0}).createIndex("_doc_id_rev","_doc_id_rev",{unique:!0}),e.createObjectStore(b,{keyPath:"digest"}),e.createObjectStore(w,{keyPath:"id",autoIncrement:!1}),e.createObjectStore(S)}function a(e,t){var n=e.currentTarget.transaction,r=n.objectStore(y);r.createIndex("deletedOrLocal","deletedOrLocal",{unique:!1}),r.openCursor().onsuccess=function(e){var o=e.target.result;if(o){var i=o.value,s=l.isDeleted(i);i.deletedOrLocal=s?"1":"0",r.put(i),o["continue"]()}else t(n)}}function c(e){e.createObjectStore(E,{keyPath:"_id"}).createIndex("_doc_id_rev","_doc_id_rev",{unique:!0})}function d(e,t){t=t||e.currentTarget.transaction;var n=t.objectStore(E),o=t.objectStore(y),i=t.objectStore(g),s=o.openCursor();s.onsuccess=function(e){var t=e.target.result;if(t){var s=t.value,a=s.id,u=l.isLocalId(a),c=f.winningRev(s);if(u){var d=a+"::"+c,p=a+"::",h=a+"::~",v=i.index("_doc_id_rev"),m=r.IDBKeyRange.bound(p,h,!1,!1),_=v.openCursor(m);_.onsuccess=function(e){if(_=e.target.result){var r=_.value;r._doc_id_rev===d&&n.put(r),i["delete"](_.primaryKey),_["continue"]()}else o["delete"](t.primaryKey),t["continue"]()}}else t["continue"]()}}}function v(e,t,n){var o="startkey"in t?t.startkey:!1,i="endkey"in t?t.endkey:!1,s="key"in t?t.key:!1,a=t.skip||0,u="number"==typeof t.limit?t.limit:-1,c=t.inclusive_end!==!1,d="descending"in t&&t.descending?"prev":null,h=!1;d&&o&&i&&(h=i,i=!1);var v=null;try{o&&i?v=r.IDBKeyRange.bound(o,i,!1,!c):o?v=d?r.IDBKeyRange.upperBound(o):r.IDBKeyRange.lowerBound(o):i?v=d?r.IDBKeyRange.lowerBound(i,!c):r.IDBKeyRange.upperBound(i,!c):s&&(v=r.IDBKeyRange.only(s))}catch(m){return"DataError"===m.name&&0===m.code?n(null,{total_rows:e,offset:t.skip,rows:[]}):n(p.error(p.IDB_ERROR,m.name,m.message))}var _=A.transaction([y,g],"readonly");_.oncomplete=function(){n(null,{total_rows:e,offset:t.skip,rows:E})};var b=_.objectStore(y),w=d?b.openCursor(v,d):b.openCursor(v),E=[];w.onsuccess=function(e){function n(e,n){var o={id:e.id,key:e.id,value:{rev:i}};if(t.include_docs){o.doc=n,o.doc._rev=i,o.doc._doc_id_rev&&delete o.doc._doc_id_rev,t.conflicts&&(o.doc._conflicts=f.collectConflicts(e));for(var s in o.doc._attachments)o.doc._attachments.hasOwnProperty(s)&&(o.doc._attachments[s].stub=!0)}var d=l.isDeleted(e,i);if("ok"===t.deleted)d&&(o.value.deleted=!0,o.doc=null),E.push(o);else if(!d&&a--<=0){if(h){if(c&&o.key<h)return;if(!c&&o.key<=h)return}if(E.push(o),0===--u)return}r["continue"]()}if(e.target.result){var r=e.target.result,o=r.value,i=o.winningRev||f.winningRev(o);if(t.include_docs){var s=_.objectStore(g).index("_doc_id_rev"),d=o.id+"::"+i;s.get(d).onsuccess=function(e){n(r.value,e.target.result)}}else n(o)}}}function m(e){if(-1!==O)return e(null,O);var t,n=A.transaction([y],"readonly"),o=n.objectStore(y).index("deletedOrLocal");o.count(r.IDBKeyRange.only("0")).onsuccess=function(e){t=e.target.result},n.onerror=s(e),n.oncomplete=function(){O=t,e(null,O)}}var _=3,y="document-store",g="by-sequence",b="attach-store",w="meta-store",E="local-store",S="detect-blob-support",k=t.name,q=null,x=null,T=!1,A=null,O=-1;e.type=function(){return"idb"},e._id=l.toPromise(function(e){e(null,x)}),e._bulkDocs=function(t,n,r){function o(e){var t=e.target.result;t.updateSeq=(t.updateSeq||0)+F,C.objectStore(w).put(t)}function i(){++B===D.length&&(C.objectStore(w).get(w).onsuccess=o)}function a(){if(D.length){var t=new l.Map;D.forEach(function(n,r){if(n._id&&l.isLocalId(n._id))return void e[n._deleted?"_removeLocal":"_putLocal"](n,{ctx:C},function(e){N[r]=e?e:{},i()});var o=n.metadata.id;t.has(o)?t.get(o).push([n,r]):t.set(o,[[n,r]])}),t.forEach(function(e,t){function n(){i(),++o<e.length&&r()}function r(){var r=e[o],i=r[0],s=r[1];j.has(t)?_(j.get(t),i,s,n):S(i,s,n)}var o=0;r()})}}function c(e){function t(){++n===D.length&&e()}if(!D.length)return e();var n=0;D.forEach(function(e){if(e._id&&l.isLocalId(e._id))return t();var n=e.metadata.id,r=C.objectStore(y).get(n);r.onsuccess=function(e){var r=e.target.result;r&&j.set(n,r),t()}})}function d(){var e=N.map(function(e){if(e._bulk_seq)delete e._bulk_seq;else if(!Object.keys(e).length)return{ok:!0};if(e.error)return e;var t=e.metadata,n=f.winningRev(t);return{ok:!0,id:t.id,rev:n}});u.Changes.notify(k),O=-1,r(null,e)}function h(e,t){if(e.stub)return t();if("string"==typeof e.data){var n;try{n=atob(e.data)}catch(o){var i=p.error(p.BAD_ARG,"Attachments need to be base64 encoded");return r(i)}if(q){var s=e.content_type;n=l.fixBinary(n),e.data=l.createBlob([n],{type:s})}return void l.MD5(n).then(function(n){e.digest="md5-"+n,t()})}var a=new FileReader;a.onloadend=function(){var n=l.arrayBufferToBinaryString(this.result);q||(e.data=btoa(n)),l.MD5(n).then(function(n){e.digest="md5-"+n,t()})},a.readAsArrayBuffer(e.data)}function v(e){function t(){n++,D.length===n&&e()}if(!D.length)return e();var n=0;D.forEach(function(e){function n(){o++,o===r.length&&t()}var r=e.data&&e.data._attachments?Object.keys(e.data._attachments):[];if(!r.length)return t();var o=0;for(var i in e.data._attachments)e.data._attachments.hasOwnProperty(i)&&h(e.data._attachments[i],n)})}function m(e,t,n,r,o){function i(e){u||(e?(u=e,r(u)):c===d.length&&a())}function s(e){c++,i(e)}function a(){function i(i){var s=e.metadata;s.seq=i.target.result,delete s.rev,s.deletedOrLocal=n?"1":"0",s.winningRev=t;var a=C.objectStore(y).put(s);a.onsuccess=function(){delete s.deletedOrLocal,delete s.winningRev,N[o]=e,j.set(e.metadata.id,e.metadata),l.call(r)}}F++,e.data._doc_id_rev=e.data._id+"::"+e.data._rev;var s=C.objectStore(g),a=s.index("_doc_id_rev"),u=s.put(e.data);u.onsuccess=i,u.onerror=function(t){t.preventDefault(),t.stopPropagation();var n=a.getKey(e.data._doc_id_rev);n.onsuccess=function(t){var n=s.put(e.data,t.target.result);F--,n.onsuccess=i}}}var u=null,c=0;e.data._id=e.metadata.id,e.data._rev=e.metadata.rev,n&&(e.data._deleted=!0);var d=e.data._attachments?Object.keys(e.data._attachments):[];for(var f in e.data._attachments)if(e.data._attachments[f].stub)c++,i();else{var p=e.data._attachments[f].data;delete e.data._attachments[f].data;var h=e.data._attachments[f].digest;T(e,h,p,s)}d.length||a()}function _(e,t,n,r){var o=f.merge(e.rev_tree,t.metadata.rev_tree[0],1e3),i=l.isDeleted(e),s=l.isDeleted(t.metadata),a=i&&s&&L||!i&&L&&"new_leaf"!==o.conflicts;if(a)return N[n]=x(p.REV_CONFLICT,t._bulk_seq),r();t.metadata.rev_tree=o.tree;var u=f.winningRev(t.metadata);s=l.isDeleted(t.metadata,u),m(t,u,s,r,n)}function S(e,t,r){var o=f.winningRev(e.metadata),i=l.isDeleted(e.metadata,o);return"was_delete"in n&&i?(N[t]=p.MISSING_DOC,r()):void m(e,o,i,r,t)}function x(e,t){return e._bulk_seq=t,e}function T(e,t,n,r){var o=C.objectStore(b);o.get(t).onsuccess=function(i){var s=i.target.result&&i.target.result.refs||{},a=[e.metadata.id,e.metadata.rev].join("@"),u={digest:t,body:n,refs:s};u.refs[a]=!0,o.put(u).onsuccess=function(){l.call(r)}}}var L=n.new_edits,I=t.docs,D=I.map(function(e,t){if(e._id&&l.isLocalId(e._id))return e;var n=l.parseDoc(e,L);return n._bulk_seq=t,n}),R=D.filter(function(e){return e.error});if(R.length)return r(R[0]);var C,N=new Array(D.length),j=new l.Map,F=0,B=0;v(function(){var e=[y,g,b,w,E];C=A.transaction(e,"readwrite"),C.onerror=s(r),C.ontimeout=s(r),C.oncomplete=d,c(a)})},e._get=function(e,t,n){function r(){n(s,{doc:o,metadata:i,ctx:a})}var o,i,s,a;t=l.clone(t),a=t.ctx?t.ctx:A.transaction([y,g,b],"readonly"),a.objectStore(y).get(e).onsuccess=function(e){if(i=e.target.result,!i)return s=p.MISSING_DOC,r();if(l.isDeleted(i)&&!t.rev)return s=p.error(p.MISSING_DOC,"deleted"),r();var n=a.objectStore(g),u=t.rev||i.winningRev||f.winningRev(i),c=i.id+"::"+u;n.index("_doc_id_rev").get(c).onsuccess=function(e){return o=e.target.result,o&&o._doc_id_rev&&delete o._doc_id_rev,o?void r():(s=p.MISSING_DOC,r())}}},e._getAttachment=function(e,t,n){var r,o;t=l.clone(t),o=t.ctx?t.ctx:A.transaction([y,g,b],"readonly");var i=e.digest,s=e.content_type;o.objectStore(b).get(i).onsuccess=function(e){var o=e.target.result.body;if(t.encode)if(q){var i=new FileReader;i.onloadend=function(){var e=l.arrayBufferToBinaryString(this.result);r=btoa(e),n(null,r)},i.readAsArrayBuffer(o)}else r=o,n(null,r);else q?r=o:(o=l.fixBinary(atob(o)),r=l.createBlob([o],{type:s})),n(null,r)}},e._allDocs=function(e,t){m(function(n,r){return n?t(n):0===e.limit?t(null,{total_rows:r,offset:e.skip,rows:[]}):void v(r,e,t)})},e._info=function(e){m(function(t,n){if(t)return e(t);if(null===A){var r=new Error("db isn't open");return r.id="idbNull",e(r)}var o=0,i=A.transaction([w],"readonly");i.objectStore(w).get(w).onsuccess=function(e){o=e.target.result&&e.target.result.updateSeq||0},i.oncomplete=function(){e(null,{doc_count:n,update_seq:o})}})},e._changes=function(t){function n(){h=A.transaction([y,g],"readonly"),h.oncomplete=i;var e;e=a?h.objectStore(g).openCursor(r.IDBKeyRange.lowerBound(t.since,!0),a):h.objectStore(g).openCursor(r.IDBKeyRange.lowerBound(t.since,!0)),e.onsuccess=o,e.onerror=onerror}function o(e){var n=e.target.result;if(n){var r=n.value;if(t.doc_ids&&-1===t.doc_ids.indexOf(r._id))return n["continue"]();var o=h.objectStore(y);o.get(r._id).onsuccess=function(e){var o=e.target.result;c<o.seq&&(c=o.seq);var i=o.winningRev||f.winningRev(o);if(r._rev!==i)return n["continue"]();delete r._doc_id_rev;var s=t.processChange(r,o,t);s.seq=n.key,_(s)&&(m++,p&&v.push(s),t.onChange(s)),m!==d&&n["continue"]()}}}function i(){t.continuous||t.complete(null,{results:v,last_seq:c})}if(t=l.clone(t),t.continuous){var s=k+":"+l.uuid();return u.Changes.addListener(k,s,e,t),u.Changes.notify(k),{cancel:function(){u.Changes.removeListener(k,s)}}}var a=t.descending?"prev":null,c=0;t.since=t.since&&!a?t.since:0;var d="limit"in t?t.limit:-1;0===d&&(d=1);var p;p="returnDocs"in t?t.returnDocs:!0;var h,v=[],m=0,_=l.filterChange(t);n()},e._close=function(e){return null===A?e(p.NOT_OPEN):(A.close(),delete h[k],A=null,void e())},e._getRevisionTree=function(e,t){var n=A.transaction([y],"readonly"),r=n.objectStore(y).get(e);r.onsuccess=function(e){var n=e.target.result;n?t(null,n.rev_tree):t(p.MISSING_DOC)}},e._doCompaction=function(e,t,n,r){var o=A.transaction([y,g],"readwrite"),i=o.objectStore(y);i.get(e).onsuccess=function(r){var i=r.target.result;i.rev_tree=t;var s=n.length;n.forEach(function(t){var n=o.objectStore(g).index("_doc_id_rev"),r=e+"::"+t;n.getKey(r).onsuccess=function(e){var t=e.target.result;t&&(o.objectStore(g)["delete"](t),s--,s||o.objectStore(y).put(i))}})},o.oncomplete=function(){l.call(r)}},e._getLocal=function(e,t){var n=A.transaction([E],"readonly"),r=n.objectStore(E).get(e);r.onerror=s(t),r.onsuccess=function(e){var n=e.target.result;n?(delete n._doc_id_rev,t(null,n)):t(p.MISSING_DOC)}},e._putLocal=function(e,t,n){"function"==typeof t&&(n=t,t={});var r=e._rev,o=e._id;e._rev=r?"0-"+(parseInt(r.split("-")[1],10)+1):"0-0",e._doc_id_rev=o+"::"+e._rev;var i,a=t.ctx;a||(a=A.transaction([E],"readwrite"),a.onerror=s(n),a.oncomplete=function(){i&&n(null,i)});var u,c=a.objectStore(E);if(r){var d=c.index("_doc_id_rev"),l=o+"::"+r;u=d.get(l),u.onsuccess=function(r){if(r.target.result){var o=c.put(e);o.onsuccess=function(){i={ok:!0,id:e._id,rev:e._rev},t.ctx&&n(null,i)}}else n(p.REV_CONFLICT)}}else u=c.get(o),u.onsuccess=function(r){if(r.target.result)n(p.REV_CONFLICT);else{var o=c.put(e);o.onsuccess=function(){i={ok:!0,id:e._id,rev:e._rev},t.ctx&&n(null,i)}}}},e._removeLocal=function(e,t){var n,r=A.transaction([E],"readwrite");r.oncomplete=function(){n&&t(null,n)};var o=e._id+"::"+e._rev,i=r.objectStore(E),a=i.index("_doc_id_rev"),u=a.get(o);u.onerror=s(t),u.onsuccess=function(e){var r=e.target.result;if(r){var s=a.getKey(o);s.onsuccess=function(e){var t=e.target.result;i["delete"](t),n={ok:!0,id:r._id,rev:"0-0"}}}else t(p.MISSING_DOC)}};var L=h[k];if(L)return A=L.idb,q=L.blobSupport,x=L.instanceId,T=L.idStored,void n.nextTick(function(){o(null,e)});var I=r.indexedDB.open(k,_);"openReqList"in u||(u.openReqList={}),u.openReqList[k]=I,I.onupgradeneeded=function(e){var t=e.target.result;e.oldVersion<1&&i(t),e.oldVersion<3&&(c(t),e.oldVersion<2?a(e,function(t){d(e,t)}):d(e))},I.onsuccess=function(t){A=t.target.result,A.onversionchange=function(){A.close(),delete h[k]},A.onabort=function(){A.close(),delete h[k]};var n=A.transaction([w,S],"readwrite"),r=n.objectStore(w).get(w);r.onsuccess=function(t){var r=function(){null!==q&&T&&(h[k]={idb:A,blobSupport:q,instanceId:x,idStored:T,loaded:!0},o(null,e))},i=t.target.result||{id:w};k+"_id"in i?(x=i[k+"_id"],T=!0,r()):(x=l.uuid(),i[k+"_id"]=x,n.objectStore(w).put(i).onsuccess=function(){T=!0,r()
+});try{n.objectStore(S).put(l.createBlob(),"key"),q=!0}catch(s){q=!1}finally{r()}}},I.onerror=s(o)}function d(e,t,n){"openReqList"in u||(u.openReqList={}),u.Changes.removeAllListeners(e),u.openReqList[e]&&u.openReqList[e].result&&u.openReqList[e].result.close();var o=r.indexedDB.deleteDatabase(e);o.onsuccess=function(){u.openReqList[e]&&(u.openReqList[e]=null),l.hasLocalStorage()&&e in r.localStorage&&delete r.localStorage[e],delete h[e],n(null,{ok:!0})},o.onerror=s(n)}var l=e("../utils"),f=e("../merge"),p=e("../deps/errors"),h={},v={running:!1,queue:[]};u.valid=function(){return r.indexedDB&&a()},u.destroy=l.toPromise(function(e,t,n){v.queue.push({action:function(n){d(e,t,n)},callback:n}),i()}),u.Changes=new l.Changes,t.exports=u}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"../deps/errors":11,"../merge":18,"../utils":23,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":28}],4:[function(e,t){t.exports=["idb","websql"]},{}],5:[function(e,t){(function(n){"use strict";function r(e){return"'"+e+"'"}function o(e,t,n,r,o){return"SELECT "+e+" FROM "+("string"==typeof t?t:t.join(" JOIN "))+(n?" ON "+n:"")+(r?" WHERE "+("string"==typeof r?r:r.join(" AND ")):"")+(o?" ORDER BY "+o:"")}function i(e){return function(t){var n=t&&t.constructor.toString().match(/function ([^\(]+)/),r=n&&n[1]||t.type,o=t.target||t.message;e(h.error(h.WSQ_ERROR,o,r))}}function s(e){return decodeURIComponent(window.escape(e))}function a(e,t){for(var n="",r="UTF-8"===t?2:4,o=0,i=e.length;i>o;o+=r){var a=e.substring(o,o+r);4===r&&(a=a.substring(2,4)+a.substring(0,2)),n+=String.fromCharCode(parseInt(a,16))}return n="UTF-8"===t?s(n):n}function u(e){return delete e._id,delete e._rev,JSON.stringify(e)}function c(e,t,n){return e=JSON.parse(e),e._id=t,e._rev=n,e}function d(e){if("size"in e)return 1e6*e.size;var t=/Android/.test(window.navigator.userAgent);return t?5e6:1}function l(e,t){function r(){f.hasLocalStorage()&&(n.localStorage["_pouch__websqldb_"+B]=!0),t(null,j)}function s(e,t){e.executeSql(x),e.executeSql("ALTER TABLE "+b+" ADD COLUMN deleted TINYINT(1) DEFAULT 0",[],function(){e.executeSql(k),e.executeSql("ALTER TABLE "+g+" ADD COLUMN local TINYINT(1) DEFAULT 0",[],function(){e.executeSql("CREATE INDEX IF NOT EXISTS 'doc-store-local-idx' ON "+g+" (local, id)");var n="SELECT "+g+".winningseq AS seq, "+g+".json AS metadata FROM "+b+" JOIN "+g+" ON "+b+".seq = "+g+".winningseq";e.executeSql(n,[],function(e,n){for(var r=[],o=[],i=0;i<n.rows.length;i++){var s=n.rows.item(i),a=s.seq,u=JSON.parse(s.metadata);f.isDeleted(u)&&r.push(a),f.isLocalId(u.id)&&o.push(u.id)}e.executeSql("UPDATE "+g+"SET local = 1 WHERE id IN ("+o.map(function(){return"?"}).join(",")+")",o,function(){e.executeSql("UPDATE "+b+" SET deleted = 1 WHERE seq IN ("+r.map(function(){return"?"}).join(",")+")",r,t)})})})})}function v(e,t){var n="CREATE TABLE IF NOT EXISTS "+E+" (id UNIQUE, rev, json)";e.executeSql(n,[],function(){var n="SELECT "+g+".id AS id, "+b+".json AS data FROM "+b+" JOIN "+g+" ON "+b+".seq = "+g+".winningseq WHERE local = 1";e.executeSql(n,[],function(e,n){function r(){if(!o.length)return t();var n=o.shift(),i=JSON.parse(n.data)._rev;e.executeSql("INSERT INTO "+E+" (id, rev, json) VALUES (?,?,?)",[n.id,i,n.data],function(e){e.executeSql("DELETE FROM "+g+" WHERE id=?",[n.id],function(e){e.executeSql("DELETE FROM "+b+" WHERE seq=?",[n.seq],function(){r()})})})}for(var o=[],i=0;i<n.rows.length;i++)o.push(n.rows.item(i));r()})})}function O(e,t){function n(n,r){function o(){if(!n.length)return t();var i=n.shift(),s=a(i.hex,r),u=s.lastIndexOf("::"),c=s.substring(0,u),d=s.substring(u+2),l="UPDATE "+b+" SET doc_id=?, rev=? WHERE doc_id_rev=?";e.executeSql(l,[c,d,s],function(){o()})}o()}var r="ALTER TABLE "+b+" ADD COLUMN doc_id";e.executeSql(r,[],function(e){var t="ALTER TABLE "+b+" ADD COLUMN rev";e.executeSql(t,[],function(e){e.executeSql(q,[],function(e){var t="SELECT hex(doc_id_rev) as hex FROM "+b;e.executeSql(t,[],function(e,t){for(var r=[],o=0;o<t.rows.length;o++)r.push(t.rows.item(o));e.executeSql("SELECT dbid, hex(dbid) AS hexId FROM "+S,[],function(e,t){var o=t.rows.item(0).dbid,i=t.rows.item(0).hexId,s=i.length===2*o.length?"UTF-8":"UTF-16";n(r,s)})})})})})}function L(e){for(;U.length>0;){var t=U.pop();t(null,F)}I(e)}function I(e){e.executeSql("SELECT dbid, hex(dbid) AS hexId FROM "+S,[],function(e,t){var n=t.rows.item(0).dbid,r=t.rows.item(0).hexId;N=r.length===2*n.length?"UTF-8":"UTF-16"})}function D(e,t){if(0===t){var n="CREATE TABLE IF NOT EXISTS "+S+" (update_seq INTEGER, dbid, db_version INTEGER)",r="CREATE TABLE IF NOT EXISTS "+w+" (digest, json, body BLOB)",o="CREATE TABLE IF NOT EXISTS "+g+" (id unique, json, winningseq)",i="CREATE TABLE IF NOT EXISTS "+b+" (seq INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, json, deleted TINYINT(1), doc_id, rev)",a="CREATE TABLE IF NOT EXISTS "+E+" (id UNIQUE, rev, json)";e.executeSql(r),e.executeSql(a),e.executeSql(o,[],function(){e.executeSql(x),e.executeSql(i,[],function(){e.executeSql(k),e.executeSql(q),e.executeSql(n,[],function(){var t="INSERT INTO "+S+" (update_seq, db_version, dbid) VALUES (?, ?, ?)";F=f.uuid();var n=[0,y,F];e.executeSql(t,n,function(e){L(e)})})})})}else{var u=function(){var n=y>t;n&&e.executeSql("UPDATE "+S+" SET db_version = "+y);var r="SELECT dbid FROM "+S;e.executeSql(r,[],function(e,t){F=t.rows.item(0).dbid,L(e)})};switch(t){case 1:s(e,function(){v(e,function(){O(e,u)})});break;case 2:v(e,function(){O(e,u)});break;case 3:O(e,u);break;default:u()}}}function R(){J.transaction(function(e){e.executeSql("SELECT sql FROM sqlite_master WHERE tbl_name = "+S,[],function(e,t){t.rows.length?/db_version/.test(t.rows.item(0).sql)?e.executeSql("SELECT db_version FROM "+S,[],function(e,t){var n=t.rows.item(0).db_version;D(e,n)}):e.executeSql("ALTER TABLE "+S+" ADD COLUMN db_version INTEGER",[],function(){D(e,1)}):D(e,0)})},i(t),r)}function C(e,t){if(-1!==P)return t(P);var n=o("COUNT("+g+".id) AS 'num'",[g,b],T,b+".deleted=0");e.executeSql(n,[],function(e,n){P=n.rows.item(0).num,t(P)})}var N,j=this,F=null,B=e.name,M=d(e),U=[],P=-1,J=m(B,_,B,M);return J?("function"!=typeof J.readTransaction&&(J.readTransaction=J.transaction),f.isCordova()&&"undefined"!=typeof n?n.addEventListener(B+"_pouch",function G(){n.removeEventListener(B+"_pouch",G,!1),R()},!1):R(),j.type=function(){return"websql"},j._id=f.toPromise(function(e){e(null,F)}),j._info=function(e){J.readTransaction(function(t){C(t,function(n){var r="SELECT update_seq FROM "+S;t.executeSql(r,[],function(t,r){var o=r.rows.item(0).update_seq;e(null,{doc_count:n,update_seq:o})})})},i(e))},j._bulkDocs=function(e,t,n){function r(){var e=L.map(function(e){if(e._bulk_seq)delete e._bulk_seq;else if(!Object.keys(e).length)return{ok:!0};if(e.error)return e;var t=e.metadata,n=p.winningRev(t);return{ok:!0,id:t.id,rev:n}});l.Changes.notify(B);var t="SELECT update_seq FROM "+S;O.executeSql(t,[],function(t,r){var o=r.rows.item(0).update_seq+I,i="UPDATE "+S+" SET update_seq=?";t.executeSql(i,[o],function(){n(null,e)})})}function s(e,t){if(e.stub)return t();if("string"==typeof e.data){try{e.data=atob(e.data)}catch(r){var o=h.error(h.BAD_ARG,"Attachments need to be base64 encoded");return n(o)}var i=f.fixBinary(e.data);e.data=f.createBlob([i],{type:e.content_type})}var s=new FileReader;s.onloadend=function(){var n=f.arrayBufferToBinaryString(this.result);e.data=n,f.MD5(n).then(function(n){e.digest="md5-"+n,t()})},s.readAsArrayBuffer(e.data)}function a(e){function t(){n++,T.length===n&&e()}if(!T.length)return e();var n=0;T.forEach(function(e){function n(){o++,o===r.length&&t()}var r=e.data&&e.data._attachments?Object.keys(e.data._attachments):[],o=0;if(!r.length)return t();for(var i in e.data._attachments)e.data._attachments.hasOwnProperty(i)&&s(e.data._attachments[i],n)})}function c(e,t,n,r,i,s){function a(){I++;var t=e.data,r=n?1:0,i=t._id,s=t._rev,a=u(t),c="INSERT INTO "+b+" (doc_id, rev, json, deleted) VALUES (?, ?, ?, ?);",d=[i,s,a,r];O.executeSql(c,d,function(e,t){l(e,t.insertId)},function(){var e=o("seq",b,null,"doc_id=? AND rev=?");return O.executeSql(e,[i,s],function(e,t){var n=t.rows.item(0).seq,o="UPDATE "+b+" SET json=?, deleted=? WHERE doc_id=? AND rev=?;",u=[a,r,i,s];e.executeSql(o,u,function(e){I--,l(e,n)})}),!1})}function c(e){f||(e?(f=e,r(f)):p===h.length&&a())}function d(e){p++,c(e)}function l(n,o){e.metadata.seq=o,delete e.metadata.rev;var a=i?"UPDATE "+g+" SET json=?, winningseq=(SELECT seq FROM "+b+" WHERE doc_id="+g+".id AND rev=?) WHERE id=?":"INSERT INTO "+g+" (id, winningseq, json) VALUES (?, ?, ?);",u=JSON.stringify(e.metadata),c=e.metadata.id,d=i?[u,t,c]:[c,o,u];n.executeSql(a,d,function(){L[s]=e,D.set(c,e.metadata),r()})}var f=null,p=0;e.data._id=e.metadata.id,e.data._rev=e.metadata.rev,n&&(e.data._deleted=!0);var h=e.data._attachments?Object.keys(e.data._attachments):[];for(var v in e.data._attachments)if(e.data._attachments[v].stub)p++,c();else{var m=e.data._attachments[v].data;delete e.data._attachments[v].data;var _=e.data._attachments[v].digest;k(e,_,m,d)}h.length||a()}function d(e,t,n,r){var o=p.merge(e.rev_tree,t.metadata.rev_tree[0],1e3),i=f.isDeleted(t.metadata),s=f.isDeleted(e),a=s&&i&&q||!s&&q&&"new_leaf"!==o.conflicts;if(a)return L[n]=E(h.REV_CONFLICT,t._bulk_seq),r();t.metadata.rev_tree=o.tree;var u=p.winningRev(t.metadata);i=f.isDeleted(t.metadata,u),c(t,u,i,r,!0,n)}function v(e,n,r){var o=p.winningRev(e.metadata),i=f.isDeleted(e.metadata,o);return"was_delete"in t&&i?(L[n]=h.MISSING_DOC,r()):void c(e,o,i,r,!1,n)}function m(){++R===T.length&&r()}function _(){if(!T.length)return r();var e=new f.Map;T.forEach(function(t,n){if(t._id&&f.isLocalId(t._id))return void j[t._deleted?"_removeLocal":"_putLocal"](t,{ctx:O},function(e){L[n]=e?e:{},m()});var r=t.metadata.id;e.has(r)?e.get(r).push([t,n]):e.set(r,[[t,n]])}),e.forEach(function(e,t){function n(){m(),++o<e.length&&r()}function r(){var r=e[o],i=r[0],s=r[1];D.has(t)?d(D.get(t),i,s,n):v(i,s,n)}var o=0;r()})}function y(e){function t(){++n===T.length&&e()}if(!T.length)return e();var n=0;T.forEach(function(e){if(e._id&&f.isLocalId(e._id))return t();var n=e.metadata.id;O.executeSql("SELECT json FROM "+g+" WHERE id = ?",[n],function(e,r){if(r.rows.length){var o=JSON.parse(r.rows.item(0).json);D.set(n,o)}t()})})}function E(e,t){return e._bulk_seq=t,e}function k(e,t,n,r){var o=[e.metadata.id,e.metadata.rev].join("@"),i={digest:t},s="SELECT digest, json FROM "+w+" WHERE digest=?";O.executeSql(s,[t],function(e,a){a.rows.length?(i.refs=JSON.parse(a.rows.item(0).json).refs,s="UPDATE "+w+" SET json=?, body=? WHERE digest=?",e.executeSql(s,[JSON.stringify(i),n,t],function(){r()})):(i.refs={},i.refs[o]=!0,s="INSERT INTO "+w+"(digest, json, body) VALUES (?, ?, ?)",e.executeSql(s,[t,JSON.stringify(i),n],function(){r()}))})}var q=t.new_edits,x=e.docs,T=x.map(function(e,t){if(e._id&&f.isLocalId(e._id))return e;var n=f.parseDoc(e,q);return n._bulk_seq=t,n}),A=T.filter(function(e){return e.error});if(A.length)return n(A[0]);var O,L=new Array(T.length),I=0,D=new f.Map,R=0;a(function(){J.transaction(function(e){O=e,y(_)},i(n),function(){P=-1})})},j._get=function(e,t,n){function r(){n(a,{doc:i,metadata:s,ctx:l})}t=f.clone(t);var i,s,a;if(!t.ctx)return void J.readTransaction(function(r){t.ctx=r,j._get(e,t,n)});var u,d,l=t.ctx;t.rev?(u=o(A,[g,b],g+".id="+b+".doc_id",[b+".doc_id=?",b+".rev=?"]),d=[e,t.rev]):(u=o(A,[g,b],T,g+".id=?"),d=[e]),l.executeSql(u,d,function(e,n){if(!n.rows.length)return a=h.MISSING_DOC,r();var o=n.rows.item(0);return s=JSON.parse(o.metadata),o.deleted&&!t.rev?(a=h.error(h.MISSING_DOC,"deleted"),r()):(i=c(o.data,s.id,o.rev),void r())})},j._allDocs=function(e,t){var n,r=[],s="startkey"in e?e.startkey:!1,a="endkey"in e?e.endkey:!1,u="key"in e?e.key:!1,d="descending"in e?e.descending:!1,l="limit"in e?e.limit:-1,f="skip"in e?e.skip:0,h=e.inclusive_end!==!1,v=[],m=[];if(u!==!1)m.push(g+".id = ?"),v.push(u);else if(s!==!1||a!==!1){if(s!==!1&&(m.push(g+".id "+(d?"<=":">=")+" ?"),v.push(s)),a!==!1){var _=d?">":"<";h&&(_+="="),m.push(g+".id "+_+" ?"),v.push(a)}u!==!1&&(m.push(g+".id = ?"),v.push(u))}"ok"!==e.deleted&&m.push(b+".deleted = 0"),J.readTransaction(function(t){C(t,function(i){if(n=i,0!==l){var s=o(A,[g,b],T,m,g+".id "+(d?"DESC":"ASC"));s+=" LIMIT "+l+" OFFSET "+f,t.executeSql(s,v,function(t,n){for(var o=0,i=n.rows.length;i>o;o++){var s=n.rows.item(o),a=JSON.parse(s.metadata),u=c(s.data,a.id,s.rev),d=u._rev,l={id:a.id,key:a.id,value:{rev:d}};if(e.include_docs){l.doc=u,l.doc._rev=d,e.conflicts&&(l.doc._conflicts=p.collectConflicts(a));for(var f in l.doc._attachments)l.doc._attachments.hasOwnProperty(f)&&(l.doc._attachments[f].stub=!0)}if(s.deleted){if("ok"!==e.deleted)continue;l.value.deleted=!0,l.doc=null}r.push(l)}})}})},i(t),function(){t(null,{total_rows:n,offset:e.skip,rows:r})})},j._changes=function(e){function t(){var t=[g+".winningseq > "+e.since],n=[];e.doc_ids&&(t.push(g+".id IN ("+e.doc_ids.map(function(){return"?"}).join(",")+")"),n=e.doc_ids);var d=o(A,[g,b],T,t,g+".winningseq "+(r?"DESC":"ASC")),l=f.filterChange(e);e.view||e.filter||(d+=" LIMIT "+i),J.readTransaction(function(t){t.executeSql(d,n,function(t,n){for(var r=0,o=0,d=n.rows.length;d>o;o++){var f=n.rows.item(o),p=JSON.parse(f.metadata);r<f.seq&&(r=f.seq);var h=c(f.data,p.id,f.rev),v=e.processChange(h,p,e);if(v.seq=f.seq,l(v)&&(u++,s&&a.push(v),e.onChange(v)),u===i)break}e.continuous||e.complete(null,{results:a,last_seq:r})})})}if(e=f.clone(e),e.continuous){var n=B+":"+f.uuid();return l.Changes.addListener(B,n,j,e),l.Changes.notify(B),{cancel:function(){l.Changes.removeListener(B,n)}}}var r=e.descending;e.since=e.since&&!r?e.since:0;var i="limit"in e?e.limit:-1;0===i&&(i=1);var s;s="returnDocs"in e?e.returnDocs:!0;var a=[],u=0;t()},j._close=function(e){e()},j._getAttachment=function(e,t,n){var r,o=t.ctx,i=e.digest,s=e.content_type,u="SELECT hex(body) as body FROM "+w+" WHERE digest=?";o.executeSql(u,[i],function(e,o){var i=a(o.rows.item(0).body,N);t.encode?r=btoa(i):(i=f.fixBinary(i),r=f.createBlob([i],{type:s})),n(null,r)})},j._getRevisionTree=function(e,t){J.readTransaction(function(n){var r="SELECT json AS metadata FROM "+g+" WHERE id = ?";n.executeSql(r,[e],function(e,n){if(n.rows.length){var r=JSON.parse(n.rows.item(0).metadata);t(null,r.rev_tree)}else t(h.MISSING_DOC)})})},j._doCompaction=function(e,t,n,r){return n.length?void J.transaction(function(o){var i="SELECT json AS metadata FROM "+g+" WHERE id = ?";o.executeSql(i,[e],function(o,i){if(!i.rows.length)return f.call(r);var s=JSON.parse(i.rows.item(0).metadata);s.rev_tree=t;var a=0;n.forEach(function(t){var i="DELETE FROM "+b+" WHERE doc_id=? AND rev=?";o.executeSql(i,[e,t],function(t){if(++a===n.length){var o="UPDATE "+g+" SET json = ? WHERE id = ?";t.executeSql(o,[JSON.stringify(s),e],function(){r()})}})})})}):r()},j._getLocal=function(e,t){J.readTransaction(function(n){var r="SELECT json, rev FROM "+E+" WHERE id=?";n.executeSql(r,[e],function(n,r){if(r.rows.length){var o=r.rows.item(0),i=c(o.json,e,o.rev);t(null,i)}else t(h.MISSING_DOC)})})},j._putLocal=function(e,t,n){function r(e){var r,i;s?(r="UPDATE "+E+" SET rev=?, json=? WHERE id=? AND rev=?",i=[o,d,a,s]):(r="INSERT INTO "+E+" (id, rev, json) VALUES (?,?,?)",i=[a,o,d]),e.executeSql(r,i,function(e,r){r.rowsAffected?(c={ok:!0,id:a,rev:o},t.ctx&&n(null,c)):n(h.REV_CONFLICT)},function(){return n(h.REV_CONFLICT),!1})}"function"==typeof t&&(n=t,t={});var o,s=e._rev,a=e._id;o=e._rev=s?"0-"+(parseInt(s.split("-")[1],10)+1):"0-0";var c,d=u(e);t.ctx?r(t.ctx):J.transaction(function(e){r(e)},i(n),function(){c&&n(null,c)})},void(j._removeLocal=function(e,t){var n;J.transaction(function(r){var o="DELETE FROM "+E+" WHERE id=? AND rev=?",i=[e._id,e._rev];r.executeSql(o,i,function(r,o){return o.rowsAffected?void(n={ok:!0,id:e._id,rev:"0-0"}):t(h.REV_CONFLICT)})},i(t),function(){t(null,n)})})):t(h.UNKNOWN_ERROR)}var f=e("../utils"),p=e("../merge"),h=e("../deps/errors"),v={},m=f.getArguments(function(e){if("undefined"!=typeof n){if(n.navigator&&n.navigator.sqlitePlugin&&n.navigator.sqlitePlugin.openDatabase)return navigator.sqlitePlugin.openDatabase.apply(navigator.sqlitePlugin,e);if(n.sqlitePlugin&&n.sqlitePlugin.openDatabase)return n.sqlitePlugin.openDatabase.apply(n.sqlitePlugin,e);var t=v[e[0]];return t||(t=v[e[0]]=n.openDatabase.apply(n,e)),t}}),_=1,y=4,g=r("document-store"),b=r("by-sequence"),w=r("attach-store"),E=r("local-store"),S=r("metadata-store"),k="CREATE INDEX IF NOT EXISTS 'by-seq-deleted-idx' ON "+b+" (seq, deleted)",q="CREATE UNIQUE INDEX IF NOT EXISTS 'by-seq-doc-id-rev' ON "+b+" (doc_id, rev)",x="CREATE INDEX IF NOT EXISTS 'doc-winningseq-idx' ON "+g+" (winningseq)",T=b+".seq = "+g+".winningseq",A=b+".seq AS seq, "+b+".deleted AS deleted, "+b+".json AS data, "+b+".rev AS rev, "+g+".json AS metadata";l.valid=function(){if("undefined"!=typeof n){if(n.navigator&&n.navigator.sqlitePlugin&&n.navigator.sqlitePlugin.openDatabase)return!0;if(n.sqlitePlugin&&n.sqlitePlugin.openDatabase)return!0;if(n.openDatabase)return!0}return!1},l.destroy=f.toPromise(function(e,t,r){l.Changes.removeAllListeners(e);var o=d(t),s=m(e,_,e,o);s.transaction(function(e){var t=[g,b,w,S,E];t.forEach(function(t){e.executeSql("DROP TABLE IF EXISTS "+t,[])})},i(r),function(){f.hasLocalStorage()&&(delete n.localStorage["_pouch__websqldb_"+e],delete n.localStorage[e]),r(null,{ok:!0})})}),l.Changes=new f.Changes,t.exports=l}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"../deps/errors":11,"../merge":18,"../utils":23}],6:[function(e,t){"use strict";function n(e,t,n){function r(){i.cancel()}a.call(this);var i=this;this.db=e,t=t?o.clone(t):{};var s=n||t.complete||function(){},u=t.complete=o.once(function(t,n){t?i.emit("error",t):i.emit("complete",n),i.removeAllListeners(),e.removeListener("destroyed",r)});s&&(i.on("complete",function(e){s(null,e)}),i.on("error",function(e){s(e)}));var c=t.onChange;c&&i.on("change",c),e.once("destroyed",r),t.onChange=function(e){t.isCancelled||(i.emit("change",e),i.startSeq&&i.startSeq<=e.seq&&(i.emit("uptodate"),i.startSeq=!1),e.deleted?i.emit("delete",e):1===e.changes.length&&"1-"===e.changes[0].rev.slice(0,2)?i.emit("create",e):i.emit("update",e))};var d=new o.Promise(function(e,n){t.complete=function(t,r){t?n(t):e(r)}});i.once("cancel",function(){c&&i.removeListener("change",c),t.complete(null,{status:"cancelled"})}),this.then=d.then.bind(d),this["catch"]=d["catch"].bind(d),this.then(function(e){u(null,e)},u),e.taskqueue.isReady?i.doChanges(t):e.taskqueue.addTask(function(){i.isCancelled?i.emit("cancel"):i.doChanges(t)})}function r(e,t,n){var r=[{rev:e._rev}];"all_docs"===n.style&&(r=i.collectLeaves(t.rev_tree).map(function(e){return{rev:e.rev}}));var s={id:t.id,changes:r,doc:e};return o.isDeleted(t,e._rev)&&(s.deleted=!0),n.conflicts&&(s.doc._conflicts=i.collectConflicts(t),s.doc._conflicts.length||delete s.doc._conflicts),s}var o=e("./utils"),i=e("./merge"),s=e("./deps/errors"),a=e("events").EventEmitter,u=e("./evalFilter"),c=e("./evalView");t.exports=n,o.inherits(n,a),n.prototype.cancel=function(){this.isCancelled=!0,this.db.taskqueue.isReady&&this.emit("cancel")},n.prototype.doChanges=function(e){var t=this,n=e.complete;if(e=o.clone(e),"live"in e&&!("continuous"in e)&&(e.continuous=e.live),e.processChange=r,"latest"===e.since&&(e.since="now"),e.since||(e.since=0),"now"===e.since)return void this.db.info().then(function(r){return t.isCancelled?void n(null,{status:"cancelled"}):(e.since=r.update_seq-1,void t.doChanges(e))},n);if(e.continuous&&"now"!==e.since&&this.db.info().then(function(e){t.startSeq=e.update_seq-1},function(e){if("idbNull"!==e.id)throw e}),"http"!==this.db.type()&&e.filter&&"string"==typeof e.filter)return this.filterChanges(e);"descending"in e||(e.descending=!1),e.limit=0===e.limit?1:e.limit,e.complete=n;var i=this.db._changes(e);if(i&&"function"==typeof i.cancel){var s=t.cancel;t.cancel=o.getArguments(function(e){i.cancel(),s.apply(this,e)})}},n.prototype.filterChanges=function(e){var t=this,n=e.complete;if("_view"===e.filter){if(!e.view||"string"!=typeof e.view){var r=new Error("`view` filter parameter is not provided.");return r.status=s.BAD_REQUEST.status,r.name=s.BAD_REQUEST.name,r.error=!0,void n(r)}var o=e.view.split("/");this.db.get("_design/"+o[0],function(r,i){if(t.isCancelled)return void n(null,{status:"cancelled"});if(r)return void n(r);if(i&&i.views&&i.views[o[1]]){var a=c(i.views[o[1]].map);return e.filter=a,void t.doChanges(e)}var u=i.views?"missing json key: "+o[1]:"missing json key: views";r||(r=new Error(u),r.status=s.MISSING_DOC.status,r.name=s.MISSING_DOC.name,r.error=!0),n(r)})}else{var i=e.filter.split("/");this.db.get("_design/"+i[0],function(r,o){if(t.isCancelled)return void n(null,{status:"cancelled"});if(r)return void n(r);if(o&&o.filters&&o.filters[i[1]]){var a=u(o.filters[i[1]]);return e.filter=a,void t.doChanges(e)}var c=o&&o.filters?"missing json key: "+i[1]:"missing json key: filters";return r||(r=new Error(c),r.status=s.MISSING_DOC.status,r.name=s.MISSING_DOC.name,r.error=!0),void n(r)})}}},{"./deps/errors":11,"./evalFilter":15,"./evalView":16,"./merge":18,"./utils":23,events:27}],7:[function(e,t){(function(n){"use strict";function r(e){e&&n.debug&&console.error(e)}function o(e,t,n){if(!(this instanceof o))return new o(e,t,n);var c=this;("function"==typeof t||"undefined"==typeof t)&&(n=t,t={}),e&&"object"==typeof e&&(t=e,e=void 0),"undefined"==typeof n&&(n=r),t=t||{};var d=n;c.auto_compaction=t.auto_compaction,c.prefix=o.prefix,i.call(c),c.taskqueue=new a;var l=new u(function(r,i){n=function(e,t){return e?i(e):(delete t.then,void r(t))},t=s.clone(t);var a,u,d=t.name||e;return function(){try{if("string"!=typeof d)throw u=new Error("Missing/invalid DB name"),u.code=400,u;if(a=o.parseAdapter(d,t),t.originalName=d,t.name=a.name,t.prefix&&"http"!==a.adapter&&"https"!==a.adapter&&(t.name=t.prefix+t.name),t.adapter=t.adapter||a.adapter,c._adapter=t.adapter,c._db_name=d,!o.adapters[t.adapter])throw u=new Error("Adapter is missing"),u.code=404,u;if(!o.adapters[t.adapter].valid())throw u=new Error("Invalid Adapter"),u.code=404,u}catch(e){c.taskqueue.fail(e),c.changes=s.toPromise(function(t){t.complete&&t.complete(e)})}}(),u?i(u):(c.adapter=t.adapter,c.replicate={},c.replicate.from=function(e,t,n){return c.constructor.replicate(e,c,t,n)},c.replicate.to=function(e,t,n){return c.constructor.replicate(c,e,t,n)},c.sync=function(e,t,n){return c.constructor.sync(c,e,t,n)},c.replicate.sync=c.sync,c.destroy=s.adapterFun("destroy",function(e){var t=this;t.info(function(n,r){return n?e(n):void t.constructor.destroy(r.db_name,e)})}),o.adapters[t.adapter].call(c,t,function(e){function r(e){"destroyed"===e&&(c.emit("destroyed"),o.removeListener(d,r))}return e?void(n&&(c.taskqueue.fail(e),n(e))):(o.on(d,r),c.emit("created",c),o.emit("created",t.originalName),c.taskqueue.ready(c),void n(null,c))}),t.skipSetup&&c.taskqueue.ready(c),void(s.isCordova()&&cordova.fireWindowEvent(t.name+"_pouch",{})))});l.then(function(e){d(null,e)},d),c.then=l.then.bind(l),c["catch"]=l["catch"].bind(l)}var i=e("./adapter"),s=e("./utils"),a=e("./taskqueue"),u=s.Promise;s.inherits(o,i),t.exports=o}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./adapter":1,"./taskqueue":22,"./utils":23}],8:[function(e,t){"use strict";function n(e,t){function n(t,n,r){if(e.binary||e.json||!e.processData||"string"==typeof t){if(!e.binary&&e.json&&"string"==typeof t)try{t=JSON.parse(t)}catch(o){return r(o)}}else t=JSON.stringify(t);Array.isArray(t)&&(t=t.map(function(e){var t;return e.ok?e:e.error&&"conflict"===e.error?(t=i.REV_CONFLICT,t.id=e.id,t):e.error&&"forbidden"===e.error?(t=i.FORBIDDEN,t.id=e.id,t.reason=e.reason,t):e.missing?(t=i.MISSING_DOC,t.missing=e.missing,t):e})),r(null,t,n)}function a(e,t){var n,r,o,s;try{n=JSON.parse(e.responseText);for(s in i)if(i.hasOwnProperty(s)&&i[s].name===n.error){o=i[s];break}o||(o=i.UNKNOWN_ERROR,e.status&&(o.status=e.status),e.statusText&&(e.name=e.statusText)),r=i.error(o,n.reason)}catch(a){for(var s in i)if(i.hasOwnProperty(s)&&i[s].status===e.status){o=i[s];break}o||(o=i.UNKNOWN_ERROR,e.status&&(o.status=e.status),e.statusText&&(e.name=e.statusText)),r=i.error(o)}e.withCredentials&&0===e.status&&(r.status=405,r.statusText="Method Not Allowed"),t(r)}var u=!1,c=s.getArguments(function(e){u||(t.apply(this,e),u=!0)});"function"==typeof e&&(c=e,e={}),e=s.clone(e);var d={method:"GET",headers:{},json:!0,processData:!0,timeout:1e4,cache:!1};if(e=s.extend(!0,d,e),"GET"===e.method&&!e.cache){var l=-1!==e.url.indexOf("?");e.url+=(l?"&":"?")+"_nonce="+s.uuid(16)}var f,p;p=e.xhr?new e.xhr:new XMLHttpRequest,p.open(e.method,e.url),p.withCredentials=!0,e.json&&(e.headers.Accept="application/json",e.headers["Content-Type"]=e.headers["Content-Type"]||"application/json",e.body&&e.processData&&"string"!=typeof e.body&&(e.body=JSON.stringify(e.body))),e.binary&&(p.responseType="arraybuffer");var h=function(e,t,n){var r="";if(n){var o=new Date;o.setTime(o.getTime()+24*n*60*60*1e3),r="; expires="+o.toGMTString()}document.cookie=e+"="+t+r+"; path=/"};for(var v in e.headers)if("Cookie"===v){var m=e.headers[v].split("=");h(m[0],m[1],10)}else p.setRequestHeader(v,e.headers[v]);"body"in e||(e.body=null);var _=function(){u||(p.abort(),a(p,c))};if(p.onreadystatechange=function(){if(4===p.readyState&&!u)if(clearTimeout(f),p.status>=200&&p.status<300){var t;t=e.binary?o([p.response||""],{type:p.getResponseHeader("Content-Type")}):p.responseText,n(t,p,c)}else a(p,c)},e.timeout>0&&(f=setTimeout(_,e.timeout),p.onprogress=function(){clearTimeout(f),f=setTimeout(_,e.timeout)},"undefined"==typeof r&&(r=-1!==Object.keys(p).indexOf("upload")),r&&(p.upload.onprogress=p.onprogress)),e.body&&e.body instanceof Blob){var y=new FileReader;y.onloadend=function(){for(var e="",t=new Uint8Array(this.result),n=t.byteLength,r=0;n>r;r++)e+=String.fromCharCode(t[r]);e=s.fixBinary(e),p.send(e)},y.readAsArrayBuffer(e.body)}else p.send(e.body);return{abort:_}}var r,o=e("./blob.js"),i=e("./errors"),s=e("../utils");t.exports=n},{"../utils":23,"./blob.js":9,"./errors":11}],9:[function(e,t){(function(e){"use strict";function n(t,n){t=t||[],n=n||{};try{return new Blob(t,n)}catch(r){if("TypeError"!==r.name)throw r;for(var o=e.BlobBuilder||e.MSBlobBuilder||e.MozBlobBuilder||e.WebKitBlobBuilder,i=new o,s=0;s<t.length;s+=1)i.append(t[s]);return i.getBlob(n.type)}}t.exports=n}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],10:[function(e,t,n){"use strict";function r(){this.store={}}function o(){this.store=new r}n.Map=r,n.Set=o,r.prototype.mangle=function(e){if("string"!=typeof e)throw new TypeError("key must be a string but Got "+e);return"$"+e},r.prototype.unmangle=function(e){return e.substring(1)},r.prototype.get=function(e){var t=this.mangle(e);return t in this.store?this.store[t]:void 0},r.prototype.set=function(e,t){var n=this.mangle(e);return this.store[n]=t,!0},r.prototype.has=function(e){var t=this.mangle(e);return t in this.store},r.prototype["delete"]=function(e){var t=this.mangle(e);return t in this.store?(delete this.store[t],!0):!1},r.prototype.forEach=function(e){var t=this,n=Object.keys(t.store);n.forEach(function(n){var r=t.store[n];n=t.unmangle(n),e(r,n)})},o.prototype.add=function(e){return this.store.set(e,!0)},o.prototype.has=function(e){return this.store.has(e)},o.prototype["delete"]=function(e){return this.store["delete"](e)}},{}],11:[function(e,t,n){"use strict";function r(e){this.status=e.status,this.name=e.error,this.message=e.reason,this.error=!0}r.prototype__proto__=Error.prototype,r.prototype.toString=function(){return JSON.stringify({status:this.status,name:this.name,message:this.message})},n.UNAUTHORIZED=new r({status:401,error:"unauthorized",reason:"Name or password is incorrect."}),n.MISSING_BULK_DOCS=new r({status:400,error:"bad_request",reason:"Missing JSON list of 'docs'"}),n.MISSING_DOC=new r({status:404,error:"not_found",reason:"missing"}),n.REV_CONFLICT=new r({status:409,error:"conflict",reason:"Document update conflict"}),n.INVALID_ID=new r({status:400,error:"invalid_id",reason:"_id field must contain a string"}),n.MISSING_ID=new r({status:412,error:"missing_id",reason:"_id is required for puts"}),n.RESERVED_ID=new r({status:400,error:"bad_request",reason:"Only reserved document ids may start with underscore."}),n.NOT_OPEN=new r({status:412,error:"precondition_failed",reason:"Database not open"}),n.UNKNOWN_ERROR=new r({status:500,error:"unknown_error",reason:"Database encountered an unknown error"}),n.BAD_ARG=new r({status:500,error:"badarg",reason:"Some query argument is invalid"}),n.INVALID_REQUEST=new r({status:400,error:"invalid_request",reason:"Request was invalid"}),n.QUERY_PARSE_ERROR=new r({status:400,error:"query_parse_error",reason:"Some query parameter is invalid"}),n.DOC_VALIDATION=new r({status:500,error:"doc_validation",reason:"Bad special document member"}),n.BAD_REQUEST=new r({status:400,error:"bad_request",reason:"Something wrong with the request"}),n.NOT_AN_OBJECT=new r({status:400,error:"bad_request",reason:"Document must be a JSON object"}),n.DB_MISSING=new r({status:404,error:"not_found",reason:"Database not found"}),n.IDB_ERROR=new r({status:500,error:"indexed_db_went_bad",reason:"unknown"}),n.WSQ_ERROR=new r({status:500,error:"web_sql_went_bad",reason:"unknown"}),n.LDB_ERROR=new r({status:500,error:"levelDB_went_went_bad",reason:"unknown"}),n.FORBIDDEN=new r({status:403,error:"forbidden",reason:"Forbidden by design doc validate_doc_update function"}),n.error=function(e,t,n){function r(){this.message=t,n&&(this.name=n)}return r.prototype=e,new r(t)}},{}],12:[function(e,t){(function(n,r){"use strict";function o(e,t,n){if("function"==typeof e.slice)return e.slice(t,n);t=Math.floor(t||0),n=Math.floor(n||0);var r=e.byteLength;if(t=0>t?Math.max(t+r,0):Math.min(r,t),n=0>n?Math.max(n+r,0):Math.min(r,n),0>=n-t)return new ArrayBuffer(0);var o=new ArrayBuffer(n-t),i=new Uint8Array(o),s=new Uint8Array(e,t,n-t);return i.set(s),o}var i=e("crypto"),s=e("spark-md5"),a=r.setImmediate||r.setTimeout;t.exports=function(e,t){function r(){var n=d*u,i=n+u;n+u>=e.size&&(i=e.size),d++,c>d?(l.append(o(e,n,i)),a(r)):(l.append(o(e,n,i)),t(null,l.end()),l.destroy())}if(!n.browser)return void t(null,i.createHash("md5").update(e).digest("hex"));var u=Math.min(524288,e.length),c=Math.ceil(e.length/u),d=0,l=new s;r()}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":28,crypto:26,"spark-md5":56}],13:[function(e,t){"use strict";function n(e,t,n){return new o(function(o,i){return t&&"object"==typeof t&&(t=t._id),"string"!=typeof t?i(new Error("doc id is required")):void e.get(t,function(s,a){if(s)return"not_found"!==s.name?i(s):o(r(e,n({_id:t}),n));var u=n(a);return u?void o(r(e,u,n)):o(a)})})}function r(e,t,r){return e.put(t)["catch"](function(o){if("conflict"!==o.name)throw o;return n(e,t,r)})}var o=e("../utils").Promise;t.exports=function(e,t,r,o){return"function"!=typeof o?n(e,t,r):void n(e,t,r).then(function(e){o(null,e)},o)}},{"../utils":23}],14:[function(e,t){"use strict";function n(e){return 0|Math.random()*e}function r(e,t){t=t||o.length;var r="",i=-1;if(e){for(;++i<e;)r+=o[n(t)];return r}for(;++i<36;)switch(i){case 8:case 13:case 18:case 23:r+="-";break;case 19:r+=o[3&n(16)|8];break;default:r+=o[n(16)]}return r}var o="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".split("");t.exports=r},{}],15:[function(_dereq_,module,exports){"use strict";function evalFilter(input){return eval(["(function () { return ",input," })()"].join(""))}module.exports=evalFilter
+},{}],16:[function(_dereq_,module,exports){"use strict";function evalView(input){return eval(["(function () {"," return function (doc) {"," var emitted = false;"," var emit = function (a, b) {"," emitted = true;"," };"," var view = "+input+";"," view(doc);"," if (emitted) {"," return true;"," }"," }","})()"].join("\n"))}module.exports=evalView},{}],17:[function(e,t){(function(n){"use strict";var r=e("./setup");t.exports=r,r.ajax=e("./deps/ajax"),r.extend=e("pouchdb-extend"),r.utils=e("./utils"),r.Errors=e("./deps/errors"),r.replicate=e("./replicate").replicate,r.sync=e("./sync"),r.version=e("./version");var o=e("./adapters/http");if(r.adapter("http",o),r.adapter("https",o),r.adapter("idb",e("./adapters/idb")),r.adapter("websql",e("./adapters/websql")),r.plugin(e("pouchdb-mapreduce")),!n.browser){var i=e("./adapters/leveldb");r.adapter("ldb",i),r.adapter("leveldb",i)}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"./adapters/http":2,"./adapters/idb":3,"./adapters/leveldb":26,"./adapters/websql":5,"./deps/ajax":8,"./deps/errors":11,"./replicate":19,"./setup":20,"./sync":21,"./utils":23,"./version":24,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":28,"pouchdb-extend":47,"pouchdb-mapreduce":50}],18:[function(e,t){"use strict";function n(e){for(var t,n=e.shift(),r=[n.id,n.opts,[]],o=r;e.length;)n=e.shift(),t=[n.id,n.opts,[]],o[2].push(t),o=t;return r}function r(e,t){for(var n=[{tree1:e,tree2:t}],r=!1;n.length>0;){var o=n.pop(),i=o.tree1,s=o.tree2;(i[1].status||s[1].status)&&(i[1].status="available"===i[1].status||"available"===s[1].status?"available":"missing");for(var a=0;a<s[2].length;a++)if(i[2][0]){for(var u=!1,c=0;c<i[2].length;c++)i[2][c][0]===s[2][a][0]&&(n.push({tree1:i[2][c],tree2:s[2][a]}),u=!0);u||(r="new_branch",i[2].push(s[2][a]),i[2].sort())}else r="new_leaf",i[2][0]=s[2][a]}return{conflicts:r,tree:e}}function o(e,t,n){var o,i=[],s=!1,a=!1;return e.length?(e.forEach(function(e){if(e.pos===t.pos&&e.ids[0]===t.ids[0])o=r(e.ids,t.ids),i.push({pos:e.pos,ids:o.tree}),s=s||o.conflicts,a=!0;else if(n!==!0){var u=e.pos<t.pos?e:t,c=e.pos<t.pos?t:e,d=c.pos-u.pos,l=[],f=[];for(f.push({ids:u.ids,diff:d,parent:null,parentIdx:null});f.length>0;){var p=f.pop();0!==p.diff?p.ids&&p.ids[2].forEach(function(e,t){f.push({ids:e,diff:p.diff-1,parent:p.ids,parentIdx:t})}):p.ids[0]===c.ids[0]&&l.push(p)}var h=l[0];h?(o=r(h.ids,c.ids),h.parent[2][h.parentIdx]=o.tree,i.push({pos:u.pos,ids:u.ids}),s=s||o.conflicts,a=!0):i.push(e)}else i.push(e)}),a||i.push(t),i.sort(function(e,t){return e.pos-t.pos}),{tree:i,conflicts:s||"internal_node"}):{tree:[t],conflicts:"new_leaf"}}function i(e,t){var r=a.rootToLeaf(e).map(function(e){var r=e.ids.slice(-t);return{pos:e.pos+(e.ids.length-r.length),ids:n(r)}});return r.reduce(function(e,t){return o(e,t,!0).tree},[r.shift()])}var s=e("pouchdb-extend"),a={};a.merge=function(e,t,n){e=s(!0,[],e),t=s(!0,{},t);var r=o(e,t);return{tree:i(r.tree,n),conflicts:r.conflicts}},a.winningRev=function(e){var t=[];return a.traverseRevTree(e.rev_tree,function(e,n,r,o,i){e&&t.push({pos:n,id:r,deleted:!!i.deleted})}),t.sort(function(e,t){return e.deleted!==t.deleted?e.deleted>t.deleted?1:-1:e.pos!==t.pos?t.pos-e.pos:e.id<t.id?1:-1}),t[0].pos+"-"+t[0].id},a.traverseRevTree=function(e,t){for(var n,r=e.slice();n=r.pop();)for(var o=n.pos,i=n.ids,s=i[2],a=t(0===s.length,o,i[0],n.ctx,i[1]),u=0,c=s.length;c>u;u++)r.push({pos:o+1,ids:s[u],ctx:a})},a.collectLeaves=function(e){var t=[];return a.traverseRevTree(e,function(e,n,r,o,i){e&&t.unshift({rev:n+"-"+r,pos:n,opts:i})}),t.sort(function(e,t){return t.pos-e.pos}),t.map(function(e){delete e.pos}),t},a.collectConflicts=function(e){var t=a.winningRev(e),n=a.collectLeaves(e.rev_tree),r=[];return n.forEach(function(e){e.rev===t||e.opts.deleted||r.push(e.rev)}),r},a.rootToLeaf=function(e){var t=[];return a.traverseRevTree(e,function(e,n,r,o,i){if(o=o?o.slice(0):[],o.push({id:r,opts:i}),e){var s=n+1-o.length;t.unshift({pos:s,ids:o})}return o}),t},t.exports=a},{"pouchdb-extend":47}],19:[function(e,t,n){"use strict";function r(){f.call(this),this.cancelled=!1;var e=this,t=new d.Promise(function(t,n){e.once("complete",t),e.once("error",n)});e.then=function(e,n){return t.then(e,n)},e["catch"]=function(e){return t["catch"](e)},e["catch"](function(){})}function o(e,t,n){var r=n.filter?n.filter.toString():"";return e.id().then(function(e){return t.id().then(function(t){var o=e+t+r+JSON.stringify(n.query_params)+n.doc_ids;return d.MD5(o).then(function(e){return"_local/"+e})})})}function i(e,t,n){return e.get(t)["catch"](function(e){if(404===e.status)return{_id:t};throw e}).then(function(t){return t.last_seq=n,e.put(t)})}function s(e,t,n){this.src=e,this.target=t,this.id=n}function a(e,t,n,r,o){function i(){if(0!==E.docs.length){var e=E.docs;return n.bulkDocs({docs:e},{new_edits:!1}).then(function(e){if(o.cancelled)throw m(),new Error("cancelled");var t=[];if(e.forEach(function(e){e.ok||(j.doc_write_failures++,t.push(new Error(e.reason||e.message||"Unknown reason")))}),t.length>0){var n=new Error("bulkDocs error");throw n.other_errors=t,v("target.bulkDocs failed to write docs",n),new Error("bulkWrite partial failure")}},function(t){throw j.doc_write_failures+=e.length,t})}}function a(){var e=Object.keys(E.diffs);if(!e.length)return d.Promise.resolve();var t=new d.Map;return E.changes.forEach(function(e){t.set(e.id,e.doc)}),d.Promise.all(e.map(function(e){return u(e,t.get(e))})).then(function(e){e.forEach(function(e){e.forEach(c)})})}function u(e,n){if(n._deleted)return[{ok:n}];var r=E.diffs,o=r[e].missing,i=n._attachments,s=o.length>1||o[0]!==n._rev;return i||s?t.get(e,{revs:!0,open_revs:"all",attachments:!0}).then(function(e){var t={};return o.forEach(function(e){t[e]=!0}),e.filter(function(e){var n=e.ok?e.ok._rev:e.missing;return t[n]})}):[{ok:n}]}function c(e){var t=E.diffs;return o.cancelled?m():void(e.ok&&(j.docs_read++,E.pendingRevs++,E.docs.push(e.ok),delete t[e.ok._id]))}function l(){return q=!0,N.writeCheckpoint(E.seq).then(function(){if(q=!1,o.cancelled)throw m(),new Error("cancelled");j.last_seq=A=E.seq,j.docs_written+=E.docs.length,o.emit("change",d.clone(j)),E=void 0,b()})["catch"](function(e){throw q=!1,v("writeCheckpoint completed with error",e),e})}function f(){var e={};return E.changes.forEach(function(t){e[t.id]=t.changes.map(function(e){return e.rev})}),n.revsDiff(e).then(function(e){if(o.cancelled)throw m(),new Error("cancelled");E.diffs=e,E.pendingRevs=0})}function p(){if(!o.cancelled&&!E){if(0===S.length)return void h(!0);E=S.shift(),f().then(a).then(i).then(l).then(p)["catch"](function(e){v("batch processing terminated with error",e)})}}function h(e){return 0===k.changes.length?void(0!==S.length||E||((O&&F.live||x)&&o.emit("uptodate",d.clone(j)),x&&m())):void((e||x||k.changes.length>=L)&&(S.push(k),k={seq:0,changes:[],docs:[]},p()))}function v(e,t){T||(j.ok=!1,j.status="aborted",j.errors.push(t),S=[],k={seq:0,changes:[],docs:[]},m())}function m(){if(!(T||o.cancelled&&(j.status="cancelled",q))){if(j.status=j.status||"complete",j.end_time=new Date,j.last_seq=A,T=o.cancelled=!0,j.errors.length>0){var e=j.errors.pop();j.errors.length>0&&(e.other_errors=j.errors),e.result=j,o.emit("error",e)}else o.emit("complete",j);o.removeAllListeners()}}function _(e){return o.cancelled?m():(R++,0!==k.changes.length||0!==S.length||E||o.emit("outofdate",d.clone(j)),k.seq=e.seq,k.changes.push(e),void h(0===S.length))}function y(e){return D=!1,o.cancelled?m():(R>0?(F.since=e.last_seq,b()):O?(F.live=!0,b()):x=!0,void h(!0))}function g(e){return D=!1,o.cancelled?m():void v("changes rejected",e)}function b(){!D&&!x&&S.length<I&&(D=!0,R=0,t.changes(F).on("change",_).then(y)["catch"](g))}function w(){N.getCheckpoint().then(function(e){A=e,F={since:A,limit:L,batch_size:L,style:"all_docs",doc_ids:C,returnDocs:!1,include_docs:!0},r.filter&&(F.filter=r.filter),r.query_params&&(F.query_params=r.query_params),b()})["catch"](function(e){v("getCheckpoint rejected with ",e)})}var E,S=[],k={seq:0,changes:[],docs:[]},q=!1,x=!1,T=!1,A=0,O=r.continuous||r.live||!1,L=r.batch_size||100,I=r.batches_limit||10,D=!1,R=0,C=r.doc_ids,N=new s(t,n,e),j={ok:!0,start_time:new Date,docs_read:0,docs_written:0,doc_write_failures:0,errors:[]},F={};o.ready(t,n),o.once("cancel",m),"function"==typeof r.onChange&&o.on("change",r.onChange),"function"==typeof r.complete&&(o.once("error",r.complete),o.once("complete",function(e){r.complete(null,e)})),"undefined"==typeof r.since?w():(q=!0,N.writeCheckpoint(r.since).then(function(){return q=!1,o.cancelled?void m():(A=r.since,void w())})["catch"](function(e){throw q=!1,v("writeCheckpoint completed with error",e),e}))}function u(e,t){return"string"==typeof e?new t(e):e.then?e:d.Promise.resolve(e)}function c(e,t,n,i){"function"==typeof n&&(i=n,n={}),"undefined"==typeof n&&(n={}),n.complete||(n.complete=i||function(){}),n=d.clone(n),n.continuous=n.continuous||n.live;var s=new r(n),c=n.pouchConstructor||l;return u(e,c).then(function(e){return u(t,c).then(function(t){return o(e,t,n).then(function(r){a(r,e,t,n,s)})})})["catch"](function(e){s.emit("error",e),n.complete(e)}),s}var d=e("./utils"),l=e("./index"),f=e("events").EventEmitter;d.inherits(r,f),r.prototype.cancel=function(){this.cancelled=!0,this.emit("cancel")},r.prototype.ready=function(e,t){function n(){o.cancel()}function r(){e.removeListener("destroyed",n),t.removeListener("destroyed",n)}var o=this;e.once("destroyed",n),t.once("destroyed",n),this.then(r,r)},s.prototype.writeCheckpoint=function(e){var t=this;return this.updateTarget(e).then(function(){return t.updateSource(e)})},s.prototype.updateTarget=function(e){return i(this.target,this.id,e)},s.prototype.updateSource=function(e){var t=this;return this.readOnlySource?d.Promise.resolve(!0):i(this.src,this.id,e)["catch"](function(e){var n="number"==typeof e.status&&4===Math.floor(e.status/100);if(n)return t.readOnlySource=!0,!0;throw e})},s.prototype.getCheckpoint=function(){var e=this;return e.target.get(e.id).then(function(t){return e.src.get(e.id).then(function(e){return t.last_seq===e.last_seq?e.last_seq:0},function(n){if(404===n.status&&t.last_seq)return e.src.put({_id:e.id,last_seq:0}).then(function(){return 0},function(n){return 401===n.status?(e.readOnlySource=!0,t.last_seq):0});throw n})})["catch"](function(e){if(404!==e.status)throw e;return 0})},n.replicate=c},{"./index":17,"./utils":23,events:27}],20:[function(e,t){(function(n){"use strict";var r=e("./constructor"),o=e("./utils"),i=o.Promise,s=e("events").EventEmitter;r.adapters={},r.preferredAdapters=e("./adapters/preferredAdapters.js"),r.prefix="_pouch_";var a=new s,u=["on","addListener","emit","listeners","once","removeAllListeners","removeListener","setMaxListeners"];u.forEach(function(e){r[e]=a[e].bind(a)}),r.setMaxListeners(0),r.parseAdapter=function(e,t){var i,s,a=e.match(/([a-z\-]*):\/\/(.*)/);if(a){if(e=/http(s?)/.test(a[1])?a[1]+"://"+a[2]:a[2],i=a[1],!r.adapters[i].valid())throw"Invalid adapter";return{name:e,adapter:a[1]}}var u="idb"in r.adapters&&"websql"in r.adapters&&o.hasLocalStorage()&&n.localStorage["_pouch__websqldb_"+r.prefix+e];if("undefined"!=typeof t&&t.db)s="leveldb";else for(var c=0;c<r.preferredAdapters.length;++c)if(s=r.preferredAdapters[c],s in r.adapters){if(u&&"idb"===s)continue;break}if(i=r.adapters[s],s&&i){var d="use_prefix"in i?i.use_prefix:!0;return{name:d?r.prefix+e:e,adapter:s}}throw"No valid adapter found"},r.destroy=o.toPromise(function(e,t,n){function s(){c.destroy(f,t,function(t,o){t?n(t):(r.emit("destroyed",e),r.emit(e,"destroyed"),n(null,o||{ok:!0}))})}("function"==typeof t||"undefined"==typeof t)&&(n=t,t={}),e&&"object"==typeof e&&(t=e,e=void 0);var a=r.parseAdapter(t.name||e,t),u=a.name,c=r.adapters[a.adapter],d="use_prefix"in c?c.use_prefix:!0,l=d?u.replace(new RegExp("^"+r.prefix),""):u,f=("http"===a.adapter||"https"===a.adapter?"":t.prefix||"")+u,p=o.extend(!0,{},t,{adapter:a.adapter});new r(l,p,function(e,u){return e?n(e):void u.get("_local/_pouch_dependentDbs",function(e,u){if(e)return"not_found"!==e.name?n(e):s();var c=u.dependentDbs,l=Object.keys(c).map(function(e){var n=d?e.replace(new RegExp("^"+r.prefix),""):e,i=o.extend(!0,t,{adapter:a.adapter});return r.destroy(n,i)});i.all(l).then(s,function(e){n(e)})})})}),r.allDbs=o.toPromise(function(e){var t=new Error("allDbs method removed");t.stats="400",e(t)}),r.adapter=function(e,t){t.valid()&&(r.adapters[e]=t)},r.plugin=function(e){Object.keys(e).forEach(function(t){r.prototype[t]=e[t]})},r.defaults=function(e){function t(t,n,i){("function"==typeof n||"undefined"==typeof n)&&(i=n,n={}),t&&"object"==typeof t&&(n=t,t=void 0),n=o.extend(!0,{},e,n),r.call(this,t,n,i)}return o.inherits(t,r),t.destroy=o.toPromise(function(t,n,i){return("function"==typeof n||"undefined"==typeof n)&&(i=n,n={}),t&&"object"==typeof t&&(n=t,t=void 0),n=o.extend(!0,{},e,n),r.destroy(t,n,i)}),u.forEach(function(e){t[e]=a[e].bind(a)}),t.setMaxListeners(0),t.preferredAdapters=r.preferredAdapters.slice(),Object.keys(r).forEach(function(e){e in t||(t[e]=r[e])}),t.replicate=function(e,n,i,s){return"function"==typeof i&&(s=i,i={}),"undefined"==typeof i&&(i={}),i=o.clone(i),i.pouchConstructor=t,r.replicate(e,n,i,s)},t},t.exports=r}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./adapters/preferredAdapters.js":4,"./constructor":7,"./utils":23,events:27}],21:[function(e,t){"use strict";function n(e,t,i,s){function a(e){h||(h=!0,l.emit("cancel",e))}function u(e){l.emit("change",{direction:"pull",change:e})}function c(e){l.emit("change",{direction:"push",change:e})}function d(e){return function(t,n){var r="change"===t&&(n===u||n===c),o="cancel"===t&&n===a,i=t in v&&n===v[t];(r||o||i)&&(t in m||(m[t]={}),m[t][e]=!0,2===Object.keys(m[t]).length&&l.removeAllListeners(t))}}if(!(this instanceof n))return new n(e,t,i,s);var l=this;"function"==typeof i&&(s=i,i={}),"undefined"==typeof i&&(i={}),this.canceled=!1,i=r.clone(i);var f,p;"onChange"in i&&(f=i.onChange,delete i.onChange),"function"!=typeof s||i.complete?"complete"in i&&(p=i.complete,delete i.complete):p=s,this.push=o(e,t,i),this.pull=o(t,e,i);var h=!1,v={},m={};this.on("newListener",function(e){"change"===e?(l.pull.on("change",u),l.push.on("change",c)):"cancel"===e?(l.pull.on("cancel",a),l.push.on("cancel",a)):"error"===e||"removeListener"===e||"complete"===e||e in v||(v[e]=function(t){l.emit(e,t)},l.pull.on(e,v[e]),l.push.on(e,v[e]))}),this.on("removeListener",function(e){"change"===e?(l.pull.removeListener("change",u),l.push.removeListener("change",c)):"cancel"===e?(l.pull.removeListener("cancel",a),l.push.removeListener("cancel",a)):e in v&&"function"==typeof v[e]&&(l.pull.removeListener(e,v[e]),l.push.removeListener(e,v[e]),delete v[e])}),this.pull.on("removeListener",d("pull")),this.push.on("removeListener",d("push"));var _=r.Promise.all([this.push,this.pull]).then(function(e){var t={push:e[0],pull:e[1]};return l.emit("complete",t),p&&p(null,t),l.removeAllListeners(),t},function(e){throw l.cancel(),l.emit("error",e),p&&p(e),l.removeAllListeners(),e});this.then=function(e,t){return _.then(e,t)},this["catch"]=function(e){return _["catch"](e)}}var r=e("./utils"),o=e("./replicate").replicate,i=e("events").EventEmitter;t.exports=n,r.inherits(n,i),n.prototype.cancel=function(){this.canceled||(this.canceled=!0,this.push.cancel(),this.pull.cancel())}},{"./replicate":19,"./utils":23,events:27}],22:[function(e,t){"use strict";function n(){this.isReady=!1,this.failed=!1,this.queue=[]}t.exports=n,n.prototype.execute=function(){var e,t;if(this.failed)for(;e=this.queue.shift();)"function"!=typeof e?(t=e.parameters[e.parameters.length-1],"function"==typeof t?t(this.failed):"changes"===e.name&&"function"==typeof t.complete&&t.complete(this.failed)):e(this.failed);else if(this.isReady)for(;e=this.queue.shift();)"function"==typeof e?e():e.task=this.db[e.name].apply(this.db,e.parameters)},n.prototype.fail=function(e){this.failed=e,this.execute()},n.prototype.ready=function(e){return this.failed?!1:0===arguments.length?this.isReady:(this.isReady=e?!0:!1,this.db=e,void this.execute())},n.prototype.addTask=function(e,t){if("function"!=typeof e){var n={name:e,parameters:t};return this.queue.push(n),this.failed&&this.execute(),n}this.queue.push(e),this.failed&&this.execute()}},{}],23:[function(e,t,n){(function(t,r){function o(e){var t={};return e.forEach(function(e){t[e]=!0}),t}function i(){return"undefined"!=typeof chrome&&"undefined"!=typeof chrome.storage&&"undefined"!=typeof chrome.storage.local}function s(){if(!(this instanceof s))return new s;var e=this;d.call(this),this.isChrome=i(),this.listeners={},this.hasLocal=!1,this.isChrome||(this.hasLocal=n.hasLocalStorage()),this.isChrome?chrome.storage.onChanged.addListener(function(t){null!=t.db_name&&e.emit(t.dbName.newValue)}):this.hasLocal&&(r.addEventListener?r.addEventListener("storage",function(t){e.emit(t.key)}):r.attachEvent("storage",function(t){e.emit(t.key)}))}var a=e("./merge");n.extend=e("pouchdb-extend"),n.ajax=e("./deps/ajax"),n.createBlob=e("./deps/blob"),n.uuid=e("./deps/uuid"),n.getArguments=e("argsarray");var u=e("./deps/buffer"),c=e("./deps/errors"),d=e("events").EventEmitter,l=e("./deps/collections");n.Map=l.Map,n.Set=l.Set,n.Promise="function"==typeof r.Promise?r.Promise:e("bluebird");var f=n.Promise,p=o(["_id","_rev","_attachments","_deleted","_revisions","_revs_info","_conflicts","_deleted_conflicts","_local_seq","_rev_tree","_replication_id","_replication_state","_replication_state_time","_replication_state_reason","_replication_stats"]);n.clone=function(e){return n.extend(!0,{},e)},n.inherits=e("inherits"),n.invalidIdError=function(e){var t;if(e?"string"!=typeof e?(t=new TypeError(c.INVALID_ID.message),t.status=400):/^_/.test(e)&&!/^_(design|local)/.test(e)&&(t=new TypeError(c.RESERVED_ID.message),t.status=400):(t=new TypeError(c.MISSING_ID.message),t.status=412),t)throw t},n.call=n.getArguments(function(e){if(e.length){var t=e.shift();"function"==typeof t&&t.apply(this,e)}}),n.isLocalId=function(e){return/^_local/.test(e)},n.isDeleted=function(e,t){t||(t=a.winningRev(e));var n=t.indexOf("-");-1!==n&&(t=t.substring(n+1));var r=!1;return a.traverseRevTree(e.rev_tree,function(e,n,o,i,s){o===t&&(r=!!s.deleted)}),r},n.filterChange=function(e){return function(t){var n={},r=e.filter&&"function"==typeof e.filter;if(n.query=e.query_params,e.filter&&r&&!e.filter.call(this,t.doc,n))return!1;if(e.doc_ids&&-1===e.doc_ids.indexOf(t.id))return!1;if(e.include_docs)for(var o in t.doc._attachments)t.doc._attachments.hasOwnProperty(o)&&(t.doc._attachments[o].stub=!0);else delete t.doc;return!0}},n.parseDoc=function(e,t){var r,o,i,s,a={status:"available"};if(e._deleted&&(a.deleted=!0),t)if(e._id||(e._id=n.uuid()),o=n.uuid(32,16).toLowerCase(),e._rev){if(i=/^(\d+)-(.+)$/.exec(e._rev),!i){var u=new TypeError("invalid value for property '_rev'");u.status=400}e._rev_tree=[{pos:parseInt(i[1],10),ids:[i[2],{status:"missing"},[[o,a,[]]]]}],r=parseInt(i[1],10)+1}else e._rev_tree=[{pos:1,ids:[o,a,[]]}],r=1;else if(e._revisions&&(e._rev_tree=[{pos:e._revisions.start-e._revisions.ids.length+1,ids:e._revisions.ids.reduce(function(e,t){return null===e?[t,a,[]]:[t,{status:"missing"},[e]]},null)}],r=e._revisions.start,o=e._revisions.ids[0]),!e._rev_tree){if(i=/^(\d+)-(.+)$/.exec(e._rev),!i)throw s=new TypeError(c.BAD_ARG.message),s.status=c.BAD_ARG.status,s;r=parseInt(i[1],10),o=i[2],e._rev_tree=[{pos:parseInt(i[1],10),ids:[i[2],a,[]]}]}n.invalidIdError(e._id),e._id=decodeURIComponent(e._id),e._rev=[r,o].join("-");var d={metadata:{},data:{}};for(var l in e)if(e.hasOwnProperty(l)){var f="_"===l[0];if(f&&!p[l])throw s=new Error(c.DOC_VALIDATION.message+": "+l),s.status=c.DOC_VALIDATION.status,s;f&&"_attachments"!==l?d.metadata[l.slice(1)]=e[l]:d.data[l]=e[l]}return d},n.isCordova=function(){return"undefined"!=typeof cordova||"undefined"!=typeof PhoneGap||"undefined"!=typeof phonegap},n.hasLocalStorage=function(){if(i())return!1;try{return r.localStorage}catch(e){return!1}},n.Changes=s,n.inherits(s,d),s.prototype.addListener=function(e,t,r,o){function i(){r.changes({include_docs:o.include_docs,conflicts:o.conflicts,continuous:!1,descending:!1,filter:o.filter,view:o.view,since:o.since,query_params:o.query_params,onChange:function(e){e.seq>o.since&&!o.cancelled&&(o.since=e.seq,n.call(o.onChange,e))}})}this.listeners[t]||(this.listeners[t]=i,this.on(e,i))},s.prototype.removeListener=function(e,t){t in this.listeners&&d.prototype.removeListener.call(this,e,this.listeners[t])},s.prototype.notifyLocalWindows=function(e){this.isChrome?chrome.storage.local.set({dbName:e}):this.hasLocal&&(localStorage[e]="a"===localStorage[e]?"b":"a")},s.prototype.notify=function(e){this.emit(e),this.notifyLocalWindows(e)},n.atob=t.browser&&"atob"in r?function(e){return atob(e)}:function(e){var t=new u(e,"base64");if(t.toString("base64")!==e)throw"Cannot base64 encode full string";return t.toString("binary")},n.btoa=t.browser&&"btoa"in r?function(e){return btoa(e)}:function(e){return new u(e,"binary").toString("base64")},n.fixBinary=function(e){if(!t.browser)return e;for(var n=e.length,r=new ArrayBuffer(n),o=new Uint8Array(r),i=0;n>i;i++)o[i]=e.charCodeAt(i);return r},n.once=function(e){var t=!1;return n.getArguments(function(n){if(t)throw"function"==typeof console.trace&&console.trace(),new Error("once called more than once");t=!0,e.apply(this,n)})},n.toPromise=function(e){return n.getArguments(function(r){var o,i=this,s="function"==typeof r[r.length-1]?r.pop():!1;s&&(o=function(e,n){t.nextTick(function(){s(e,n)})});var a=new f(function(t,o){var s;try{var a=n.once(function(e,n){e?o(e):t(n)});r.push(a),s=e.apply(i,r),s&&"function"==typeof s.then&&t(s)}catch(u){o(u)}});return o&&a.then(function(e){o(null,e)},o),a.cancel=function(){return this},a})},n.adapterFun=function(e,t){return n.toPromise(n.getArguments(function(r){if(this._closed)return f.reject(new Error("database is closed"));var o=this;return this.taskqueue.isReady?t.apply(this,r):new n.Promise(function(t,n){o.taskqueue.addTask(function(i){i?n(i):t(o[e].apply(o,r))})})}))},n.arrayBufferToBinaryString=function(e){for(var t="",n=new Uint8Array(e),r=n.byteLength,o=0;r>o;o++)t+=String.fromCharCode(n[o]);return t},n.cancellableFun=function(e,t,r){r=r?n.clone(!0,{},r):{};var o=new d,i=r.complete||function(){},s=r.complete=n.once(function(e,t){e?i(e):(o.emit("end",t),i(null,t)),o.removeAllListeners()}),a=r.onChange||function(){},u=0;t.on("destroyed",function(){o.removeAllListeners()}),r.onChange=function(e){a(e),e.seq<=u||(u=e.seq,o.emit("change",e),e.deleted?o.emit("delete",e):1===e.changes.length&&"1-"===e.changes[0].rev.slice(0,1)?o.emit("create",e):o.emit("update",e))};var c=new f(function(e,t){r.complete=function(n,r){n?t(n):e(r)}});return c.then(function(e){s(null,e)},s),c.cancel=function(){c.isCancelled=!0,t.taskqueue.isReady&&r.complete(null,{status:"cancelled"})},t.taskqueue.isReady?e(t,r,c):t.taskqueue.addTask(function(){c.isCancelled?r.complete(null,{status:"cancelled"}):e(t,r,c)}),c.on=o.on.bind(o),c.once=o.once.bind(o),c.addListener=o.addListener.bind(o),c.removeListener=o.removeListener.bind(o),c.removeAllListeners=o.removeAllListeners.bind(o),c.setMaxListeners=o.setMaxListeners.bind(o),c.listeners=o.listeners.bind(o),c.emit=o.emit.bind(o),c},n.MD5=n.toPromise(e("./deps/md5"))}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./deps/ajax":8,"./deps/blob":9,"./deps/buffer":26,"./deps/collections":10,"./deps/errors":11,"./deps/md5":12,"./deps/uuid":14,"./merge":18,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":28,argsarray:25,bluebird:33,events:27,inherits:29,"pouchdb-extend":47}],24:[function(e,t){t.exports="3.0.1"},{}],25:[function(e,t){"use strict";function n(e){return function(){var t=arguments.length;if(t){for(var n=[],r=-1;++r<t;)n[r]=arguments[r];return e.call(this,n)}return e.call(this,[])}}t.exports=n},{}],26:[function(){},{}],27:[function(e,t){function n(){this._events=this._events||{},this._maxListeners=this._maxListeners||void 0}function r(e){return"function"==typeof e}function o(e){return"number"==typeof e}function i(e){return"object"==typeof e&&null!==e}function s(e){return void 0===e}t.exports=n,n.EventEmitter=n,n.prototype._events=void 0,n.prototype._maxListeners=void 0,n.defaultMaxListeners=10,n.prototype.setMaxListeners=function(e){if(!o(e)||0>e||isNaN(e))throw TypeError("n must be a positive number");return this._maxListeners=e,this},n.prototype.emit=function(e){var t,n,o,a,u,c;if(this._events||(this._events={}),"error"===e&&(!this._events.error||i(this._events.error)&&!this._events.error.length))throw t=arguments[1],t instanceof Error?t:TypeError('Uncaught, unspecified "error" event.');if(n=this._events[e],s(n))return!1;if(r(n))switch(arguments.length){case 1:n.call(this);break;case 2:n.call(this,arguments[1]);break;case 3:n.call(this,arguments[1],arguments[2]);break;default:for(o=arguments.length,a=new Array(o-1),u=1;o>u;u++)a[u-1]=arguments[u];n.apply(this,a)}else if(i(n)){for(o=arguments.length,a=new Array(o-1),u=1;o>u;u++)a[u-1]=arguments[u];for(c=n.slice(),o=c.length,u=0;o>u;u++)c[u].apply(this,a)}return!0},n.prototype.addListener=function(e,t){var o;if(!r(t))throw TypeError("listener must be a function");if(this._events||(this._events={}),this._events.newListener&&this.emit("newListener",e,r(t.listener)?t.listener:t),this._events[e]?i(this._events[e])?this._events[e].push(t):this._events[e]=[this._events[e],t]:this._events[e]=t,i(this._events[e])&&!this._events[e].warned){var o;o=s(this._maxListeners)?n.defaultMaxListeners:this._maxListeners,o&&o>0&&this._events[e].length>o&&(this._events[e].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[e].length),"function"==typeof console.trace&&console.trace())}return this},n.prototype.on=n.prototype.addListener,n.prototype.once=function(e,t){function n(){this.removeListener(e,n),o||(o=!0,t.apply(this,arguments))}if(!r(t))throw TypeError("listener must be a function");var o=!1;return n.listener=t,this.on(e,n),this},n.prototype.removeListener=function(e,t){var n,o,s,a;if(!r(t))throw TypeError("listener must be a function");if(!this._events||!this._events[e])return this;if(n=this._events[e],s=n.length,o=-1,n===t||r(n.listener)&&n.listener===t)delete this._events[e],this._events.removeListener&&this.emit("removeListener",e,t);else if(i(n)){for(a=s;a-->0;)if(n[a]===t||n[a].listener&&n[a].listener===t){o=a;break}if(0>o)return this;1===n.length?(n.length=0,delete this._events[e]):n.splice(o,1),this._events.removeListener&&this.emit("removeListener",e,t)}return this},n.prototype.removeAllListeners=function(e){var t,n;if(!this._events)return this;if(!this._events.removeListener)return 0===arguments.length?this._events={}:this._events[e]&&delete this._events[e],this;if(0===arguments.length){for(t in this._events)"removeListener"!==t&&this.removeAllListeners(t);return this.removeAllListeners("removeListener"),this._events={},this}if(n=this._events[e],r(n))this.removeListener(e,n);else for(;n.length;)this.removeListener(e,n[n.length-1]);return delete this._events[e],this},n.prototype.listeners=function(e){var t;return t=this._events&&this._events[e]?r(this._events[e])?[this._events[e]]:this._events[e].slice():[]},n.listenerCount=function(e,t){var n;return n=e._events&&e._events[t]?r(e._events[t])?1:e._events[t].length:0}},{}],28:[function(e,t){var n=t.exports={};n.nextTick=function(){var e="undefined"!=typeof window&&window.setImmediate,t="undefined"!=typeof window&&window.postMessage&&window.addEventListener;if(e)return function(e){return window.setImmediate(e)};if(t){var n=[];return window.addEventListener("message",function(e){var t=e.source;if((t===window||null===t)&&"process-tick"===e.data&&(e.stopPropagation(),n.length>0)){var r=n.shift();r()}},!0),function(e){n.push(e),window.postMessage("process-tick","*")}}return function(e){setTimeout(e,0)}}(),n.title="browser",n.browser=!0,n.env={},n.argv=[],n.binding=function(){throw new Error("process.binding is not supported")},n.cwd=function(){return"/"},n.chdir=function(){throw new Error("process.chdir is not supported")}},{}],29:[function(e,t){t.exports="function"==typeof Object.create?function(e,t){e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}})}:function(e,t){e.super_=t;var n=function(){};n.prototype=t.prototype,e.prototype=new n,e.prototype.constructor=e}},{}],30:[function(e,t){"use strict";function n(){}t.exports=n},{}],31:[function(e,t){"use strict";var n=e("./promise"),r=e("./reject"),o=e("./resolve"),i=e("./INTERNAL"),s=e("./handlers"),a=r(new TypeError("must be an array"));t.exports=function(e){function t(e,t){function n(e){c[t]=e,++d===r&!u&&(u=!0,s.resolve(f,c))}o(e).then(n,function(e){u||(u=!0,s.reject(f,e))})}if("[object Array]"!==Object.prototype.toString.call(e))return a;var r=e.length,u=!1;if(!r)return o([]);for(var c=new Array(r),d=0,l=-1,f=new n(i);++l<r;)t(e[l],l);return f}},{"./INTERNAL":30,"./handlers":32,"./promise":34,"./reject":36,"./resolve":37}],32:[function(e,t,n){"use strict";function r(e){var t=e&&e.then;return e&&"object"==typeof e&&"function"==typeof t?function(){t.apply(e,arguments)}:void 0}var o=e("./tryCatch"),i=e("./resolveThenable"),s=e("./states");n.resolve=function(e,t){var a=o(r,t);if("error"===a.status)return n.reject(e,a.value);var u=a.value;if(u)i.safely(e,u);else{e.state=s.FULFILLED,e.outcome=t;for(var c=-1,d=e.queue.length;++c<d;)e.queue[c].callFulfilled(t)}return e},n.reject=function(e,t){e.state=s.REJECTED,e.outcome=t;for(var n=-1,r=e.queue.length;++n<r;)e.queue[n].callRejected(t);return e}},{"./resolveThenable":38,"./states":39,"./tryCatch":40}],33:[function(e,t,n){t.exports=n=e("./promise"),n.resolve=e("./resolve"),n.reject=e("./reject"),n.all=e("./all")},{"./all":31,"./promise":34,"./reject":36,"./resolve":37}],34:[function(e,t){"use strict";function n(e){if(!(this instanceof n))return new n(e);if("function"!=typeof e)throw new TypeError("reslover must be a function");this.state=s.PENDING,this.queue=[],this.outcome=void 0,e!==o&&i.safely(this,e)}var r=e("./unwrap"),o=e("./INTERNAL"),i=e("./resolveThenable"),s=e("./states"),a=e("./queueItem");t.exports=n,n.prototype["catch"]=function(e){return this.then(null,e)},n.prototype.then=function(e,t){if("function"!=typeof e&&this.state===s.FULFILLED||"function"!=typeof t&&this.state===s.REJECTED)return this;var i=new n(o);if(this.state!==s.PENDING){var u=this.state===s.FULFILLED?e:t;r(i,u,this.outcome)}else this.queue.push(new a(i,e,t));return i}},{"./INTERNAL":30,"./queueItem":35,"./resolveThenable":38,"./states":39,"./unwrap":41}],35:[function(e,t){"use strict";function n(e,t,n){this.promise=e,"function"==typeof t&&(this.onFulfilled=t,this.callFulfilled=this.otherCallFulfilled),"function"==typeof n&&(this.onRejected=n,this.callRejected=this.otherCallRejected)}var r=e("./handlers"),o=e("./unwrap");t.exports=n,n.prototype.callFulfilled=function(e){r.resolve(this.promise,e)},n.prototype.otherCallFulfilled=function(e){o(this.promise,this.onFulfilled,e)},n.prototype.callRejected=function(e){r.reject(this.promise,e)},n.prototype.otherCallRejected=function(e){o(this.promise,this.onRejected,e)}},{"./handlers":32,"./unwrap":41}],36:[function(e,t){"use strict";function n(e){var t=new r(o);return i.reject(t,e)}var r=e("./promise"),o=e("./INTERNAL"),i=e("./handlers");t.exports=n},{"./INTERNAL":30,"./handlers":32,"./promise":34}],37:[function(e,t){"use strict";function n(e){if(e)return e instanceof r?e:i.resolve(new r(o),e);var t=typeof e;switch(t){case"boolean":return s;case"undefined":return u;
+case"object":return a;case"number":return c;case"string":return d}}var r=e("./promise"),o=e("./INTERNAL"),i=e("./handlers");t.exports=n;var s=i.resolve(new r(o),!1),a=i.resolve(new r(o),null),u=i.resolve(new r(o),void 0),c=i.resolve(new r(o),0),d=i.resolve(new r(o),"")},{"./INTERNAL":30,"./handlers":32,"./promise":34}],38:[function(e,t,n){"use strict";function r(e,t){function n(t){a||(a=!0,o.reject(e,t))}function r(t){a||(a=!0,o.resolve(e,t))}function s(){t(r,n)}var a=!1,u=i(s);"error"===u.status&&n(u.value)}var o=e("./handlers"),i=e("./tryCatch");n.safely=r},{"./handlers":32,"./tryCatch":40}],39:[function(e,t,n){n.REJECTED=["REJECTED"],n.FULFILLED=["FULFILLED"],n.PENDING=["PENDING"]},{}],40:[function(e,t){"use strict";function n(e,t){var n={};try{n.value=e(t),n.status="success"}catch(r){n.status="error",n.value=r}return n}t.exports=n},{}],41:[function(e,t){"use strict";function n(e,t,n){r(function(){var r;try{r=t(n)}catch(i){return o.reject(e,i)}r===e?o.reject(e,new TypeError("Cannot resolve promise with itself")):o.resolve(e,r)})}var r=e("immediate"),o=e("./handlers");t.exports=n},{"./handlers":32,immediate:42}],42:[function(e,t){"use strict";function n(){o=!0;for(var e,t,n=a.length;n;){for(t=a,a=[],e=-1;++e<n;)t[e]();n=a.length}o=!1}function r(e){1!==a.push(e)||o||i()}for(var o,i,s=[e("./nextTick"),e("./mutation.js"),e("./messageChannel"),e("./stateChange"),e("./timeout")],a=[],u=-1,c=s.length;++u<c;)if(s[u]&&s[u].test&&s[u].test()){i=s[u].install(n);break}t.exports=r},{"./messageChannel":43,"./mutation.js":44,"./nextTick":26,"./stateChange":45,"./timeout":46}],43:[function(e,t,n){(function(e){"use strict";n.test=function(){return e.setImmediate?!1:"undefined"!=typeof e.MessageChannel},n.install=function(t){var n=new e.MessageChannel;return n.port1.onmessage=t,function(){n.port2.postMessage(0)}}}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],44:[function(e,t,n){(function(e){"use strict";var t=e.MutationObserver||e.WebKitMutationObserver;n.test=function(){return t},n.install=function(n){var r=0,o=new t(n),i=e.document.createTextNode("");return o.observe(i,{characterData:!0}),function(){i.data=r=++r%2}}}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],45:[function(e,t,n){(function(e){"use strict";n.test=function(){return"document"in e&&"onreadystatechange"in e.document.createElement("script")},n.install=function(t){return function(){var n=e.document.createElement("script");return n.onreadystatechange=function(){t(),n.onreadystatechange=null,n.parentNode.removeChild(n),n=null},e.document.documentElement.appendChild(n),t}}}).call(this,"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],46:[function(e,t,n){"use strict";n.test=function(){return!0},n.install=function(e){return function(){setTimeout(e,0)}}},{}],47:[function(e,t){"use strict";function n(e){return null===e?String(e):"object"==typeof e||"function"==typeof e?a[l.call(e)]||"object":typeof e}function r(e){return null!==e&&e===e.window}function o(e){if(!e||"object"!==n(e)||e.nodeType||r(e))return!1;try{if(e.constructor&&!f.call(e,"constructor")&&!f.call(e.constructor.prototype,"isPrototypeOf"))return!1}catch(t){return!1}var o;for(o in e);return void 0===o||f.call(e,o)}function i(e){return"function"===n(e)}function s(){var e,t,n,r,a,u,c=arguments[0]||{},d=1,l=arguments.length,f=!1;for("boolean"==typeof c&&(f=c,c=arguments[1]||{},d=2),"object"==typeof c||i(c)||(c={}),l===d&&(c=this,--d);l>d;d++)if(null!=(e=arguments[d]))for(t in e)if(!(t in Object.prototype)){if(n=c[t],r=e[t],c===r)continue;f&&r&&(o(r)||(a=p(r)))?(a?(a=!1,u=n&&p(n)?n:[]):u=n&&o(n)?n:{},c[t]=s(f,u,r)):void 0!==r&&(p(e)&&i(r)||(c[t]=r))}return c}for(var a={},u=["Boolean","Number","String","Function","Array","Date","RegExp","Object","Error"],c=0;c<u.length;c++){var d=u[c];a["[object "+d+"]"]=d.toLowerCase()}var l=a.toString,f=a.hasOwnProperty,p=Array.isArray||function(e){return"array"===n(e)};t.exports=s},{}],48:[function(e,t){"use strict";var n=e("./upsert"),r=e("./utils"),o=r.Promise;t.exports=function(e){var t=e.db,i=e.viewName,s=e.map,a=e.reduce,u=e.temporary,c=s.toString()+(a&&a.toString())+"undefined";if(!u&&t._cachedViews){var d=t._cachedViews[c];if(d)return o.resolve(d)}return t.info().then(function(e){function o(e){e.views=e.views||{};var t=i;-1===t.indexOf("/")&&(t=i+"/"+i);var n=e.views[t]=e.views[t]||{};if(!n[d])return n[d]=!0,e}var d=e.db_name+"-mrview-"+(u?"temp":r.MD5(c));return n(t,"_local/mrviews",o).then(function(){return t.registerDependentDatabase(d).then(function(e){var n=e.db;n.auto_compaction=!0;var r={name:d,db:n,sourceDB:t,adapter:t.adapter,mapFun:s,reduceFun:a};return r.db.get("_local/lastSeq")["catch"](function(e){if("not_found"!==e.name)throw e}).then(function(e){return r.seq=e?e.seq:0,u||(t._cachedViews=t._cachedViews||{},t._cachedViews[c]=r,r.db.on("destroyed",function(){delete t._cachedViews[c]})),r})})})})}},{"./upsert":54,"./utils":55}],49:[function(_dereq_,module,exports){"use strict";module.exports=function(func,emit,sum,log,isArray,toJSON){return eval("'use strict'; ("+func.replace(/;\s*$/,"")+");")}},{}],50:[function(e,t,n){(function(t){"use strict";function r(e){return-1===e.indexOf("/")?[e,e]:e.split("/")}function o(e,t,n){try{return{output:t.apply(null,n)}}catch(r){return e.emit("error",r),{error:r}}}function i(e,t){var n=S(e.key,t.key);return 0!==n?n:S(e.value,t.value)}function s(e,t,n){return n=n||0,"number"==typeof t?e.slice(n,t+n):n>0?e.slice(n):e}function a(e){var t=new Error("builtin "+e+" function requires map values to be numbers or number arrays");return t.name="invalid_value",t.status=500,t}function u(e){for(var t=0,n=0,r=e.length;r>n;n++){var o=e[n];if("number"!=typeof o){if(!Array.isArray(o))throw a("_sum");t="number"==typeof t?[t]:t;for(var i=0,s=o.length;s>i;i++){var u=o[i];if("number"!=typeof u)throw a("_sum");"undefined"==typeof t[i]?t.push(u):t[i]+=u}}else"number"==typeof t?t+=o:t[0]+=o}return t}function c(e,t,n,r){var o=t[e];"undefined"!=typeof o&&(r&&(o=encodeURIComponent(JSON.stringify(o))),n.push(e+"="+o))}function d(e,t){var n=e.descending?"endkey":"startkey",r=e.descending?"startkey":"endkey";if("undefined"!=typeof e[n]&&"undefined"!=typeof e[r]&&S(e[n],e[r])>0)throw new y("No rows can match your key range, reverse your start_key and end_key or set {descending : true}");if(t.reduce&&e.reduce!==!1){if(e.include_docs)throw new y("{include_docs:true} is invalid for reduce");if(e.keys&&e.keys.length>1&&!e.group&&!e.group_level)throw new y("Multi-key fetches for reduce views must use {group: true}")}if(e.group_level){if("number"!=typeof e.group_level)throw new y('Invalid value for integer: "'+e.group_level+'"');if(e.group_level<0)throw new y('Invalid value for positive integer: "'+e.group_level+'"')}}function l(e,t,n){var o,i=[],s="GET";if(c("reduce",n,i),c("include_docs",n,i),c("limit",n,i),c("descending",n,i),c("group",n,i),c("group_level",n,i),c("skip",n,i),c("stale",n,i),c("startkey",n,i,!0),c("endkey",n,i,!0),c("inclusive_end",n,i),c("key",n,i,!0),i=i.join("&"),i=""===i?"":"?"+i,"undefined"!=typeof n.keys){var a=2e3,u="keys="+encodeURIComponent(JSON.stringify(n.keys));u.length+i.length+1<=a?i+=("?"===i[0]?"&":"?")+u:(s="POST","string"==typeof t?o=JSON.stringify({keys:n.keys}):t.keys=n.keys)}if("string"==typeof t){var d=r(t);return e.request({method:s,url:"_design/"+d[0]+"/_view/"+d[1]+i,body:o})}return o=o||{},Object.keys(t).forEach(function(e){o[e]=Array.isArray(t[e])?t[e]:t[e].toString()}),e.request({method:"POST",url:"_temp_view"+i,body:o})}function f(e){return function(t){if("not_found"===t.name)return e;throw t}}function p(e,t,n){var r="_local/doc_"+e;return t.db.get(r)["catch"](f({_id:r,keys:[]})).then(function(r){return O.resolve().then(function(){return r.keys.length?t.db.allDocs({keys:r.keys,include_docs:!0}):{rows:[]}}).then(function(t){var o=t.rows.map(function(e){return e.doc}).filter(function(e){return e}),i=n[e],s={};o.forEach(function(e){s[e._id]=!0,e._deleted=!i[e._id],e._deleted||(e.value=i[e._id])});var a=Object.keys(i);return a.forEach(function(e){s[e]||o.push({_id:e,value:i[e]})}),r.keys=A.uniq(a.concat(r.keys)),o.splice(0,0,r),o})})}function h(e,t,n){var r="_local/lastSeq";return e.db.get(r)["catch"](f({_id:r,seq:0})).then(function(r){var o=Object.keys(t);return O.all(o.map(function(n){return p(n,e,t)})).then(function(t){var o=[];return t.forEach(function(e){o=o.concat(e)}),r.seq=n,o.push(r),e.db.bulkDocs({docs:o})})})}function v(e,t,n){0===n.group_level&&delete n.group_level;var r,i=n.group||n.group_level;r=R[e.reduceFun]?R[e.reduceFun]:T(e.reduceFun.toString(),null,u,b,Array.isArray,JSON.parse);var a=[],c=n.group_level;t.forEach(function(e){var t=a[a.length-1],n=i?e.key:null;return i&&Array.isArray(n)&&"number"==typeof c&&(n=n.length>c?n.slice(0,c):n),t&&0===S(t.key[0][0],n)?(t.key.push([n,e.id]),void t.value.push(e.value)):void a.push({key:[[n,e.id]],value:[e.value]})});for(var d=0,l=a.length;l>d;d++){var f=a[d],p=o(e.sourceDB,r,[f.key,f.value,!1]);f.value=p.error?null:p.output,f.key=f.key[0][0]}return{rows:s(a,n.limit,n.skip)}}function m(e){return e.request({method:"POST",url:"_view_cleanup"})}function _(e,n,o){if("http"===e.type())return l(e,n,o);if("string"!=typeof n){d(o,n);var i={db:e,viewName:"temp_view/temp_view",map:n.map,reduce:n.reduce,temporary:!0};return I.add(function(){return x(i).then(function(e){function t(){return e.db.destroy()}return A.fin(C(e).then(function(){return N(e,o)}),t)})}),I.finish()}var s=n,a=r(s),u=a[0],c=a[1];return e.get("_design/"+u).then(function(n){var r=n.views&&n.views[c];if(!r||"string"!=typeof r.map)throw new g("ddoc "+u+" has no view named "+c);d(o,r);var i={db:e,viewName:s,map:r.map,reduce:r.reduce};return x(i).then(function(e){return"ok"===o.stale||"update_after"===o.stale?("update_after"===o.stale&&t.nextTick(function(){C(e)}),N(e,o)):C(e).then(function(){return N(e,o)})})})}function y(e){this.status=400,this.name="query_parse_error",this.message=e,this.error=!0;try{Error.captureStackTrace(this,y)}catch(t){}}function g(e){this.status=404,this.name="not_found",this.message=e,this.error=!0;try{Error.captureStackTrace(this,g)}catch(t){}}var b,w=e("pouchdb-collate"),E=e("./taskqueue"),S=w.collate,k=w.toIndexableString,q=w.normalizeKey,x=e("./create-view"),T=e("./evalfunc");b="undefined"!=typeof console&&"function"==typeof console.log?Function.prototype.bind.call(console.log,console):function(){};var A=e("./utils"),O=A.Promise,L=new E,I=new E,D=50,R={_sum:function(e,t){return u(t)},_count:function(e,t){return t.length},_stats:function(e,t){function n(e){for(var t=0,n=0,r=e.length;r>n;n++){var o=e[n];t+=o*o}return t}return{sum:u(t),min:Math.min.apply(null,t),max:Math.max.apply(null,t),count:t.length,sumsqr:n(t)}}},C=A.sequentialize(L,function(e){function t(e,t){r.push({id:s._id,key:q(e),value:q(t)})}function n(t,n){return function(){return h(e,t,n)}}var r,s,a;if("function"==typeof e.mapFun&&2===e.mapFun.length){var c=e.mapFun;a=function(e){return c(e,t)}}else a=T(e.mapFun.toString(),t,u,b,Array.isArray,JSON.parse);var d=e.seq||0,l=new E;return new O(function(t,u){function c(){l.finish().then(function(){e.seq=d,t()})}function f(){function t(e){u(e)}e.sourceDB.changes({conflicts:!0,include_docs:!0,since:d,limit:D}).on("complete",function(t){var u=t.results;if(!u.length)return c();for(var p={},h=0,v=u.length;v>h;h++){var m=u[h];if("_"!==m.doc._id[0]){r=[],s=m.doc,s._deleted||o(e.sourceDB,a,[s]),r.sort(i);for(var _={},y=0,g=r.length;g>y;y++){var b=r[y],w=k([b.key,b.id,y]);_[w]=b}p[m.doc._id]=_}d=m.seq}return l.add(n(p,d)),u.length<D?c():f()}).on("error",t)}f()})}),N=A.sequentialize(L,function(e,t){function n(t){return t.include_docs=!0,e.db.allDocs(t).then(function(e){return o=e.total_rows,e.rows.map(function(e){return e.doc.value})})}function r(n){var r;if(r=i?v(e,n,t):{total_rows:o,offset:s,rows:n},t.include_docs){var a=n.map(function(t){var n=t.value,r=n&&"object"==typeof n&&n._id||t.id;return e.sourceDB.get(r).then(function(e){t.doc=e},function(){})});return O.all(a).then(function(){return r})}return r}var o,i=e.reduceFun&&t.reduce!==!1,s=t.skip||0;"undefined"==typeof t.keys||t.keys.length||(t.limit=0,delete t.keys);var a=function(e){return e.reduce(function(e,t){return e.concat(t)})};if("undefined"!=typeof t.keys){var u=t.keys,c=u.map(function(e){var t={startkey:k([e]),endkey:k([e,{}])};return n(t)});return O.all(c).then(a).then(r)}var d={descending:t.descending};if("undefined"!=typeof t.startkey&&(d.startkey=k(t.descending?[t.startkey,{}]:[t.startkey])),"undefined"!=typeof t.endkey){var l=t.inclusive_end!==!1;t.descending&&(l=!l),d.endkey=k(l?[t.endkey,{}]:[t.endkey])}if("undefined"!=typeof t.key){var f=k([t.key]),p=k([t.key,{}]);d.descending?(d.endkey=f,d.startkey=p):(d.startkey=f,d.endkey=p)}return i||("number"==typeof t.limit&&(d.limit=t.limit),d.skip=s),n(d).then(r)}),j=A.sequentialize(L,function(e){return e.get("_local/mrviews").then(function(t){var n={};Object.keys(t.views).forEach(function(e){var t=r(e),o="_design/"+t[0],i=t[1];n[o]=n[o]||{},n[o][i]=!0});var o={keys:Object.keys(n),include_docs:!0};return e.allDocs(o).then(function(r){var o={};r.rows.forEach(function(e){var r=e.key.substring(8);Object.keys(n[e.key]).forEach(function(n){var i=r+"/"+n;t.views[i]||(i=n);var s=Object.keys(t.views[i]),a=e.doc&&e.doc.views&&e.doc.views[n];s.forEach(function(e){o[e]=o[e]||a})})});var i=Object.keys(o).filter(function(e){return!o[e]}),s=i.map(function(t){return e.constructor.destroy(t,{adapter:e.adapter})});return O.all(s).then(function(){return{ok:!0}})})},f({ok:!0}))});n.viewCleanup=A.callbackify(function(){var e=this;return"http"===e.type()?m(e):j(e)}),n.query=function(e,t,n){"function"==typeof t&&(n=t,t={}),t=A.extend(!0,{},t),"function"==typeof e&&(e={map:e});var r=this,o=O.resolve().then(function(){return _(r,e,t)});return A.promisedCallback(o,n),o},A.inherits(y,Error),A.inherits(g,Error)}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"))},{"./create-view":48,"./evalfunc":49,"./taskqueue":53,"./utils":55,"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":28,"pouchdb-collate":51}],51:[function(e,t,n){"use strict";function r(e){if(null!==e)switch(typeof e){case"boolean":return e?1:0;case"number":return u(e);case"string":return e.replace(/\u0002/g,"").replace(/\u0001/g,"").replace(/\u0000/g,"");case"object":var t=Array.isArray(e),r=t?e:Object.keys(e),o=-1,i=r.length,s="";if(t)for(;++o<i;)s+=n.toIndexableString(r[o]);else for(;++o<i;){var a=r[o];s+=n.toIndexableString(a)+n.toIndexableString(e[a])}return s}return""}function o(e,t){for(var r=Math.min(e.length,t.length),o=0;r>o;o++){var i=n.collate(e[o],t[o]);if(0!==i)return i}return e.length===t.length?0:e.length>t.length?1:-1}function i(e,t){return e===t?0:e>t?1:-1}function s(e,t){for(var r=Object.keys(e),o=Object.keys(t),i=Math.min(r.length,o.length),s=0;i>s;s++){var a=n.collate(r[s],o[s]);if(0!==a)return a;if(a=n.collate(e[r[s]],t[o[s]]),0!==a)return a}return r.length===o.length?0:r.length>o.length?1:-1}function a(e){var t=["boolean","number","string","object"],n=t.indexOf(typeof e);return~n?null===e?1:Array.isArray(e)?5:3>n?n+2:n+3:Array.isArray(e)?5:void 0}function u(e){if(0===e)return"1";var t=e.toExponential().split(/e\+?/),n=parseInt(t[1],10),r=0>e,o=r?"0":"2",i=(r?-n:n)-c,s=f.padLeft(i.toString(),"0",d);o+=l+s;var a=Math.abs(parseFloat(t[0]));r&&(a=10-a);var u=a.toFixed(20);return u=u.replace(/\.?0+$/,""),o+=l+u}var c=-324,d=3,l="",f=e("./utils");n.collate=function(e,t){if(e===t)return 0;e=n.normalizeKey(e),t=n.normalizeKey(t);var r=a(e),u=a(t);if(r-u!==0)return r-u;if(null===e)return 0;switch(typeof e){case"number":return e-t;case"boolean":return e===t?0:t>e?-1:1;case"string":return i(e,t)}return Array.isArray(e)?o(e,t):s(e,t)},n.normalizeKey=function(e){switch(typeof e){case"undefined":return null;case"number":return 1/0===e||e===-1/0||isNaN(e)?null:e;case"object":var t=e;if(Array.isArray(e)){var r=e.length;e=new Array(r);for(var o=0;r>o;o++)e[o]=n.normalizeKey(t[o])}else{if(e instanceof Date)return e.toJSON();if(null!==e){e={};for(var i in t)if(t.hasOwnProperty(i)){var s=t[i];"undefined"!=typeof s&&(e[i]=n.normalizeKey(s))}}}}return e},n.toIndexableString=function(e){var t="\x00";return e=n.normalizeKey(e),a(e)+l+r(e)+t}},{"./utils":52}],52:[function(e,t,n){"use strict";function r(e,t,n){for(var r="",o=n-e.length;r.length<o;)r+=t;return r}n.padLeft=function(e,t,n){var o=r(e,t,n);return o+e},n.padRight=function(e,t,n){var o=r(e,t,n);return e+o},n.stringLexCompare=function(e,t){var n,r=e.length,o=t.length;for(n=0;r>n;n++){if(n===o)return 1;var i=e.charAt(n),s=t.charAt(n);if(i!==s)return s>i?-1:1}return o>r?-1:0},n.intToDecimalForm=function(e){var t=0>e,n="";do{var r=t?-Math.ceil(e%10):Math.floor(e%10);n=r+n,e=t?Math.ceil(e/10):Math.floor(e/10)}while(e);return t&&"0"!==n&&(n="-"+n),n}},{}],53:[function(e,t){"use strict";function n(){this.promise=new r(function(e){e()})}var r=e("./utils").Promise;n.prototype.add=function(e){return this.promise=this.promise["catch"](function(){}).then(function(){return e()}),this.promise},n.prototype.finish=function(){return this.promise},t.exports=n},{"./utils":55}],54:[function(e,t){"use strict";function n(e,t,n){return new o(function(o,i){return t&&"object"==typeof t&&(t=t._id),"string"!=typeof t?i(new Error("doc id is required")):void e.get(t,function(s,a){if(s)return"not_found"!==s.name?i(s):o(r(e,n({_id:t}),n));var u=n(a);return u?void o(r(e,u,n)):o(a)})})}function r(e,t,r){return e.put(t)["catch"](function(o){if("conflict"!==o.name)throw o;return n(e,t,r)})}var o=e("./utils").Promise;t.exports=n},{"./utils":55}],55:[function(e,t,n){(function(t,r){"use strict";n.Promise="function"==typeof r.Promise?r.Promise:e("lie"),n.uniq=function(e){var t={};return e.forEach(function(e){t[e]=!0}),Object.keys(t)},n.inherits=e("inherits"),n.extend=e("pouchdb-extend");var o=e("argsarray");n.promisedCallback=function(e,n){return n&&e.then(function(e){t.nextTick(function(){n(null,e)})},function(e){t.nextTick(function(){n(e)})}),e},n.callbackify=function(e){return o(function(t){var r=t.pop(),o=e.apply(this,t);return"function"==typeof r&&n.promisedCallback(o,r),o})},n.fin=function(e,t){return e.then(function(e){var n=t();return"function"==typeof n.then?n.then(function(){return e}):e},function(e){var n=t();if("function"==typeof n.then)return n.then(function(){throw e});throw e})},n.sequentialize=function(e,t){return function(){var n=arguments,r=this;return e.add(function(){return t.apply(r,n)})}};var i=e("crypto"),s=e("spark-md5");n.MD5=function(e){return t.browser?s.hash(e):i.createHash("md5").update(e).digest("hex")}}).call(this,e("/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js"),"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"/Users/nolan/workspace/pouchdb/node_modules/browserify/node_modules/insert-module-globals/node_modules/process/browser.js":28,argsarray:25,crypto:26,inherits:29,lie:33,"pouchdb-extend":47,"spark-md5":56}],56:[function(e,t,n){!function(e){if("object"==typeof n)t.exports=e();else if("function"==typeof define&&define.amd)define(e);else{var r;try{r=window}catch(o){r=self}r.SparkMD5=e()}}(function(){"use strict";var e=function(e,t){return e+t&4294967295},t=function(t,n,r,o,i,s){return n=e(e(n,t),e(o,s)),e(n<<i|n>>>32-i,r)},n=function(e,n,r,o,i,s,a){return t(n&r|~n&o,e,n,i,s,a)},r=function(e,n,r,o,i,s,a){return t(n&o|r&~o,e,n,i,s,a)},o=function(e,n,r,o,i,s,a){return t(n^r^o,e,n,i,s,a)},i=function(e,n,r,o,i,s,a){return t(r^(n|~o),e,n,i,s,a)},s=function(t,s){var a=t[0],u=t[1],c=t[2],d=t[3];a=n(a,u,c,d,s[0],7,-680876936),d=n(d,a,u,c,s[1],12,-389564586),c=n(c,d,a,u,s[2],17,606105819),u=n(u,c,d,a,s[3],22,-1044525330),a=n(a,u,c,d,s[4],7,-176418897),d=n(d,a,u,c,s[5],12,1200080426),c=n(c,d,a,u,s[6],17,-1473231341),u=n(u,c,d,a,s[7],22,-45705983),a=n(a,u,c,d,s[8],7,1770035416),d=n(d,a,u,c,s[9],12,-1958414417),c=n(c,d,a,u,s[10],17,-42063),u=n(u,c,d,a,s[11],22,-1990404162),a=n(a,u,c,d,s[12],7,1804603682),d=n(d,a,u,c,s[13],12,-40341101),c=n(c,d,a,u,s[14],17,-1502002290),u=n(u,c,d,a,s[15],22,1236535329),a=r(a,u,c,d,s[1],5,-165796510),d=r(d,a,u,c,s[6],9,-1069501632),c=r(c,d,a,u,s[11],14,643717713),u=r(u,c,d,a,s[0],20,-373897302),a=r(a,u,c,d,s[5],5,-701558691),d=r(d,a,u,c,s[10],9,38016083),c=r(c,d,a,u,s[15],14,-660478335),u=r(u,c,d,a,s[4],20,-405537848),a=r(a,u,c,d,s[9],5,568446438),d=r(d,a,u,c,s[14],9,-1019803690),c=r(c,d,a,u,s[3],14,-187363961),u=r(u,c,d,a,s[8],20,1163531501),a=r(a,u,c,d,s[13],5,-1444681467),d=r(d,a,u,c,s[2],9,-51403784),c=r(c,d,a,u,s[7],14,1735328473),u=r(u,c,d,a,s[12],20,-1926607734),a=o(a,u,c,d,s[5],4,-378558),d=o(d,a,u,c,s[8],11,-2022574463),c=o(c,d,a,u,s[11],16,1839030562),u=o(u,c,d,a,s[14],23,-35309556),a=o(a,u,c,d,s[1],4,-1530992060),d=o(d,a,u,c,s[4],11,1272893353),c=o(c,d,a,u,s[7],16,-155497632),u=o(u,c,d,a,s[10],23,-1094730640),a=o(a,u,c,d,s[13],4,681279174),d=o(d,a,u,c,s[0],11,-358537222),c=o(c,d,a,u,s[3],16,-722521979),u=o(u,c,d,a,s[6],23,76029189),a=o(a,u,c,d,s[9],4,-640364487),d=o(d,a,u,c,s[12],11,-421815835),c=o(c,d,a,u,s[15],16,530742520),u=o(u,c,d,a,s[2],23,-995338651),a=i(a,u,c,d,s[0],6,-198630844),d=i(d,a,u,c,s[7],10,1126891415),c=i(c,d,a,u,s[14],15,-1416354905),u=i(u,c,d,a,s[5],21,-57434055),a=i(a,u,c,d,s[12],6,1700485571),d=i(d,a,u,c,s[3],10,-1894986606),c=i(c,d,a,u,s[10],15,-1051523),u=i(u,c,d,a,s[1],21,-2054922799),a=i(a,u,c,d,s[8],6,1873313359),d=i(d,a,u,c,s[15],10,-30611744),c=i(c,d,a,u,s[6],15,-1560198380),u=i(u,c,d,a,s[13],21,1309151649),a=i(a,u,c,d,s[4],6,-145523070),d=i(d,a,u,c,s[11],10,-1120210379),c=i(c,d,a,u,s[2],15,718787259),u=i(u,c,d,a,s[9],21,-343485551),t[0]=e(a,t[0]),t[1]=e(u,t[1]),t[2]=e(c,t[2]),t[3]=e(d,t[3])},a=function(e){var t,n=[];for(t=0;64>t;t+=4)n[t>>2]=e.charCodeAt(t)+(e.charCodeAt(t+1)<<8)+(e.charCodeAt(t+2)<<16)+(e.charCodeAt(t+3)<<24);return n},u=function(e){var t,n=[];for(t=0;64>t;t+=4)n[t>>2]=e[t]+(e[t+1]<<8)+(e[t+2]<<16)+(e[t+3]<<24);return n},c=function(e){var t,n,r,o,i,u,c=e.length,d=[1732584193,-271733879,-1732584194,271733878];for(t=64;c>=t;t+=64)s(d,a(e.substring(t-64,t)));for(e=e.substring(t-64),n=e.length,r=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],t=0;n>t;t+=1)r[t>>2]|=e.charCodeAt(t)<<(t%4<<3);if(r[t>>2]|=128<<(t%4<<3),t>55)for(s(d,r),t=0;16>t;t+=1)r[t]=0;return o=8*c,o=o.toString(16).match(/(.*?)(.{0,8})$/),i=parseInt(o[2],16),u=parseInt(o[1],16)||0,r[14]=i,r[15]=u,s(d,r),d},d=function(e){var t,n,r,o,i,a,c=e.length,d=[1732584193,-271733879,-1732584194,271733878];for(t=64;c>=t;t+=64)s(d,u(e.subarray(t-64,t)));for(e=c>t-64?e.subarray(t-64):new Uint8Array(0),n=e.length,r=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],t=0;n>t;t+=1)r[t>>2]|=e[t]<<(t%4<<3);if(r[t>>2]|=128<<(t%4<<3),t>55)for(s(d,r),t=0;16>t;t+=1)r[t]=0;return o=8*c,o=o.toString(16).match(/(.*?)(.{0,8})$/),i=parseInt(o[2],16),a=parseInt(o[1],16)||0,r[14]=i,r[15]=a,s(d,r),d},l=["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"],f=function(e){var t,n="";for(t=0;4>t;t+=1)n+=l[e>>8*t+4&15]+l[e>>8*t&15];return n},p=function(e){var t;for(t=0;t<e.length;t+=1)e[t]=f(e[t]);return e.join("")},h=function(e){return p(c(e))},v=function(){this.reset()};return"5d41402abc4b2a76b9719d911017c592"!==h("hello")&&(e=function(e,t){var n=(65535&e)+(65535&t),r=(e>>16)+(t>>16)+(n>>16);return r<<16|65535&n}),v.prototype.append=function(e){return/[\u0080-\uFFFF]/.test(e)&&(e=unescape(encodeURIComponent(e))),this.appendBinary(e),this},v.prototype.appendBinary=function(e){this._buff+=e,this._length+=e.length;var t,n=this._buff.length;for(t=64;n>=t;t+=64)s(this._state,a(this._buff.substring(t-64,t)));return this._buff=this._buff.substr(t-64),this},v.prototype.end=function(e){var t,n,r=this._buff,o=r.length,i=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];for(t=0;o>t;t+=1)i[t>>2]|=r.charCodeAt(t)<<(t%4<<3);return this._finish(i,o),n=e?this._state:p(this._state),this.reset(),n},v.prototype._finish=function(e,t){var n,r,o,i=t;if(e[i>>2]|=128<<(i%4<<3),i>55)for(s(this._state,e),i=0;16>i;i+=1)e[i]=0;n=8*this._length,n=n.toString(16).match(/(.*?)(.{0,8})$/),r=parseInt(n[2],16),o=parseInt(n[1],16)||0,e[14]=r,e[15]=o,s(this._state,e)},v.prototype.reset=function(){return this._buff="",this._length=0,this._state=[1732584193,-271733879,-1732584194,271733878],this},v.prototype.destroy=function(){delete this._state,delete this._buff,delete this._length},v.hash=function(e,t){/[\u0080-\uFFFF]/.test(e)&&(e=unescape(encodeURIComponent(e)));var n=c(e);return t?n:p(n)},v.hashBinary=function(e,t){var n=c(e);return t?n:p(n)},v.ArrayBuffer=function(){this.reset()},v.ArrayBuffer.prototype.append=function(e){var t,n=this._concatArrayBuffer(this._buff,e),r=n.length;for(this._length+=e.byteLength,t=64;r>=t;t+=64)s(this._state,u(n.subarray(t-64,t)));return this._buff=r>t-64?n.subarray(t-64):new Uint8Array(0),this},v.ArrayBuffer.prototype.end=function(e){var t,n,r=this._buff,o=r.length,i=[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];for(t=0;o>t;t+=1)i[t>>2]|=r[t]<<(t%4<<3);return this._finish(i,o),n=e?this._state:p(this._state),this.reset(),n},v.ArrayBuffer.prototype._finish=v.prototype._finish,v.ArrayBuffer.prototype.reset=function(){return this._buff=new Uint8Array(0),this._length=0,this._state=[1732584193,-271733879,-1732584194,271733878],this},v.ArrayBuffer.prototype.destroy=v.prototype.destroy,v.ArrayBuffer.prototype._concatArrayBuffer=function(e,t){var n=e.length,r=new Uint8Array(n+t.byteLength);return r.set(e),r.set(new Uint8Array(t),n),r},v.ArrayBuffer.hash=function(e,t){var n=d(new Uint8Array(e));return t?n:p(n)},v})},{}]},{},[17])(17)});
\ No newline at end of file
diff --git a/lib/version-browser.js b/lib/version-browser.js
index b7cb5a0..1ef294f 100644
--- a/lib/version-browser.js
+++ b/lib/version-browser.js
@@ -1 +1 @@
-module.exports = "3.0.1-prerelease";
+module.exports = "3.0.1";
diff --git a/package.json b/package.json
index 8aef003..ca77aae 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
{
"name": "pouchdb",
- "version": "3.0.1-prerelease",
+ "version": "3.0.1",
"description": "PouchDB is a pocket-sized database.",
"main": "./lib/index.js",
"homepage": "http://pouchdb.com/",
