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})({"minimongo":[function(require,module,exports){

module.exports=require('1+WUYb');

},{}],"1+WUYb":[function(require,module,exports){

exports.MemoryDb = require('./lib/MemoryDb');

exports.LocalStorageDb = require('./lib/LocalStorageDb');

exports.IndexedDb = require('./lib/IndexedDb');

exports.WebSQLDb = require('./lib/WebSQLDb');

exports.RemoteDb = require('./lib/RemoteDb');

exports.HybridDb = require('./lib/HybridDb');

exports.utils = require('./lib/utils');

},{"./lib/HybridDb":6,"./lib/IndexedDb":7,"./lib/LocalStorageDb":8,"./lib/MemoryDb":9,"./lib/RemoteDb":10,"./lib/WebSQLDb":11,"./lib/utils":14}],"dsrzUy":[function(require,module,exports){

module.exports = window.$;

},{}],"jquery":[function(require,module,exports){

module.exports=require('dsrzUy');

},{}],5:[function(require,module,exports){

var _ = require('lodash');

EJSON = {}; // Global!

var customTypes = {};

// Add a custom type, using a method of your choice to get to and

// from a basic JSON-able representation. The factory argument

// is a function of JSON-able --> your object

// The type you add must have:

// - A clone() method, so that Meteor can deep-copy it when necessary.

// - A equals() method, so that Meteor can compare it

// - A toJSONValue() method, so that Meteor can serialize it

// - a typeName() method, to show how to look it up in our type table.

// It is okay if these methods are monkey-patched on.

EJSON.addType = function (name, factory) {

if (_.has(customTypes, name))

throw new Error("Type " + name + " already present");

customTypes[name] = factory;

};

var builtinConverters = [

{ // Date

matchJSONValue: function (obj) {

return _.has(obj, '$date') && _.size(obj) === 1;

},

matchObject: function (obj) {

return obj instanceof Date;

},

toJSONValue: function (obj) {

return {$date: obj.getTime()};

},

fromJSONValue: function (obj) {

return new Date(obj.$date);

}

},

{ // Binary

matchJSONValue: function (obj) {

return _.has(obj, '$binary') && _.size(obj) === 1;

},

matchObject: function (obj) {

return typeof Uint8Array !== 'undefined' && obj instanceof Uint8Array

|| (obj && _.has(obj, '$Uint8ArrayPolyfill'));

},

toJSONValue: function (obj) {

return {$binary: EJSON._base64Encode(obj)};

},

fromJSONValue: function (obj) {

return EJSON._base64Decode(obj.$binary);

}

},

{ // Escaping one level

matchJSONValue: function (obj) {

return _.has(obj, '$escape') && _.size(obj) === 1;

},

matchObject: function (obj) {

if (_.isEmpty(obj) || _.size(obj) > 2) {

return false;

}

return _.any(builtinConverters, function (converter) {

return converter.matchJSONValue(obj);

});

},

toJSONValue: function (obj) {

var newObj = {};

_.each(obj, function (value, key) {

newObj[key] = EJSON.toJSONValue(value);

});

return {$escape: newObj};

},

fromJSONValue: function (obj) {

var newObj = {};

_.each(obj.$escape, function (value, key) {

newObj[key] = EJSON.fromJSONValue(value);

});

return newObj;

}

},

{ // Custom

matchJSONValue: function (obj) {

return _.has(obj, '$type') && _.has(obj, '$value') && _.size(obj) === 2;

},

matchObject: function (obj) {

return EJSON._isCustomType(obj);

},

toJSONValue: function (obj) {

return {$type: obj.typeName(), $value: obj.toJSONValue()};

},

fromJSONValue: function (obj) {

var typeName = obj.$type;

var converter = customTypes[typeName];

return converter(obj.$value);

}

}

];

EJSON._isCustomType = function (obj) {

return obj &&

typeof obj.toJSONValue === 'function' &&

typeof obj.typeName === 'function' &&

_.has(customTypes, obj.typeName());

};

//for both arrays and objects, in-place modification.

var adjustTypesToJSONValue =

EJSON._adjustTypesToJSONValue = function (obj) {

if (obj === null)

return null;

var maybeChanged = toJSONValueHelper(obj);

if (maybeChanged !== undefined)

return maybeChanged;

_.each(obj, function (value, key) {

if (typeof value !== 'object' && value !== undefined)

return; // continue

var changed = toJSONValueHelper(value);

if (changed) {

obj[key] = changed;

return; // on to the next key

}

// if we get here, value is an object but not adjustable

// at this level. recurse.

adjustTypesToJSONValue(value);

});

return obj;

};

// Either return the JSON-compatible version of the argument, or undefined (if

// the item isn't itself replaceable, but maybe some fields in it are)

var toJSONValueHelper = function (item) {

for (var i = 0; i < builtinConverters.length; i++) {

var converter = builtinConverters[i];

if (converter.matchObject(item)) {

return converter.toJSONValue(item);

}

}

return undefined;

};

EJSON.toJSONValue = function (item) {

var changed = toJSONValueHelper(item);

if (changed !== undefined)

return changed;

if (typeof item === 'object') {

item = EJSON.clone(item);

adjustTypesToJSONValue(item);

}

return item;

};

//for both arrays and objects. Tries its best to just

// use the object you hand it, but may return something

// different if the object you hand it itself needs changing.

var adjustTypesFromJSONValue =

EJSON._adjustTypesFromJSONValue = function (obj) {

if (obj === null)

return null;

var maybeChanged = fromJSONValueHelper(obj);

if (maybeChanged !== obj)

return maybeChanged;

_.each(obj, function (value, key) {

if (typeof value === 'object') {

var changed = fromJSONValueHelper(value);

if (value !== changed) {

obj[key] = changed;

return;

}

// if we get here, value is an object but not adjustable

// at this level. recurse.

adjustTypesFromJSONValue(value);

}

});

return obj;

};

// Either return the argument changed to have the non-json

// rep of itself (the Object version) or the argument itself.

// DOES NOT RECURSE. For actually getting the fully-changed value, use

// EJSON.fromJSONValue

var fromJSONValueHelper = function (value) {

if (typeof value === 'object' && value !== null) {

if (_.size(value) <= 2

&& _.all(value, function (v, k) {

return typeof k === 'string' && k.substr(0, 1) === '$';

})) {

for (var i = 0; i < builtinConverters.length; i++) {

var converter = builtinConverters[i];

if (converter.matchJSONValue(value)) {

return converter.fromJSONValue(value);

}

}

}

}

return value;

};

EJSON.fromJSONValue = function (item) {

var changed = fromJSONValueHelper(item);

if (changed === item && typeof item === 'object') {

item = EJSON.clone(item);

adjustTypesFromJSONValue(item);

return item;

} else {

return changed;

}

};

EJSON.stringify = function (item) {

return JSON.stringify(EJSON.toJSONValue(item));

};

EJSON.parse = function (item) {

return EJSON.fromJSONValue(JSON.parse(item));

};

EJSON.isBinary = function (obj) {

return (typeof Uint8Array !== 'undefined' && obj instanceof Uint8Array) ||

(obj && obj.$Uint8ArrayPolyfill);

};

EJSON.equals = function (a, b, options) {

var i;

var keyOrderSensitive = !!(options && options.keyOrderSensitive);

if (a === b)

return true;

if (!a || !b) // if either one is falsy, they'd have to be === to be equal

return false;

if (!(typeof a === 'object' && typeof b === 'object'))

return false;

if (a instanceof Date && b instanceof Date)

return a.valueOf() === b.valueOf();

if (EJSON.isBinary(a) && EJSON.isBinary(b)) {

if (a.length !== b.length)

return false;

for (i = 0; i < a.length; i++) {

if (a[i] !== b[i])

return false;

}

return true;

}

if (typeof (a.equals) === 'function')

return a.equals(b, options);

if (a instanceof Array) {

if (!(b instanceof Array))

return false;

if (a.length !== b.length)

return false;

for (i = 0; i < a.length; i++) {

if (!EJSON.equals(a[i], b[i], options))

return false;

}

return true;

}

// fall back to structural equality of objects

var ret;

if (keyOrderSensitive) {

var bKeys = [];

_.each(b, function (val, x) {

bKeys.push(x);

});

i = 0;

ret = _.all(a, function (val, x) {

if (i >= bKeys.length) {

return false;

}

if (x !== bKeys[i]) {

return false;

}

if (!EJSON.equals(val, b[bKeys[i]], options)) {

return false;

}

i++;

return true;

});

return ret && i === bKeys.length;

} else {

i = 0;

ret = _.all(a, function (val, key) {

if (!_.has(b, key)) {

return false;

}

if (!EJSON.equals(val, b[key], options)) {

return false;

}

i++;

return true;

});

return ret && _.size(b) === i;

}

};

EJSON.clone = function (v) {

var ret;

if (typeof v !== "object")

return v;

if (v === null)

return null; // null has typeof "object"

if (v instanceof Date)

return new Date(v.getTime());

if (EJSON.isBinary(v)) {

ret = EJSON.newBinary(v.length);

for (var i = 0; i < v.length; i++) {

ret[i] = v[i];

}

return ret;

}

if (_.isArray(v) || _.isArguments(v)) {

// For some reason, _.map doesn't work in this context on Opera (weird test

// failures).

ret = [];

for (i = 0; i < v.length; i++)

ret[i] = EJSON.clone(v[i]);

return ret;

}

// handle general user-defined typed Objects if they have a clone method

if (typeof v.clone === 'function') {

return v.clone();

}

// handle other objects

ret = {};

_.each(v, function (value, key) {

ret[key] = EJSON.clone(value);

});

return ret;

};

module.exports = EJSON;

},{"lodash":"z2coUu"}],6:[function(require,module,exports){

/*

Database which caches locally in a localDb but pulls results

ultimately from a RemoteDb

*/

var HybridCollection, HybridDb, processFind, utils, _;

_ = require('lodash');

processFind = require('./utils').processFind;

utils = require('./utils');

module.exports = HybridDb = (function() {

function HybridDb(localDb, remoteDb) {

this.localDb = localDb;

this.remoteDb = remoteDb;

this.collections = {};

}

HybridDb.prototype.addCollection = function(name, options, success, error) {

var collection, _ref;

if (_.isFunction(options)) {

_ref = [{}, options, success], options = _ref[0], success = _ref[1], error = _ref[2];

}

collection = new HybridCollection(name, this.localDb[name], this.remoteDb[name], options);

this[name] = collection;

this.collections[name] = collection;

if (success != null) {

return success();

}

};

HybridDb.prototype.removeCollection = function(name, success, error) {

delete this[name];

delete this.collections[name];

if (success != null) {

return success();

}

};

HybridDb.prototype.upload = function(success, error) {

var cols, uploadCols;

cols = _.values(this.collections);

uploadCols = function(cols, success, error) {

var col;

col = _.first(cols);

if (col) {

return col.upload(function() {

return uploadCols(_.rest(cols), success, error);

}, function(err) {

return error(err);

});

} else {

return success();

}

};

return uploadCols(cols, success, error);

};

return HybridDb;

})();

HybridCollection = (function() {

function HybridCollection(name, localCol, remoteCol, options) {

this.name = name;

this.localCol = localCol;

this.remoteCol = remoteCol;

this.options = options || {};

_.defaults(this.options, {

cacheFind: true,

cacheFindOne: true,

interim: true,

useLocalOnRemoteError: true,

shortcut: false,

timeout: 0

});

}

HybridCollection.prototype.find = function(selector, options) {

if (options == null) {

options = {};

}

return {

fetch: (function(_this) {

return function(success, error) {

return _this._findFetch(selector, options, success, error);

};

})(this)

};

};

HybridCollection.prototype.findOne = function(selector, options, success, error) {

var step2, _ref;

if (options == null) {

options = {};

}

if (_.isFunction(options)) {

_ref = [{}, options, success], options = _ref[0], success = _ref[1], error = _ref[2];

}

_.defaults(options, this.options);

step2 = (function(_this) {

return function(localDoc) {

var findOptions;

findOptions = _.cloneDeep(options);

findOptions.interim = false;

findOptions.cacheFind = options.cacheFindOne;

findOptions.useLocalOnRemoteError = true;

if (selector._id) {

findOptions.limit = 1;

} else {

delete findOptions.limit;

}

return _this.find(selector, findOptions).fetch(function(data) {

if (data.length > 0) {

if (!_.isEqual(localDoc, data[0])) {

return success(data[0]);

}

} else {

return success(null);

}

}, error);

};

})(this);

if (options.interim || options.shortcut) {

return this.localCol.findOne(selector, options, function(localDoc) {

if (localDoc) {

success(_.cloneDeep(localDoc));

if (options.shortcut) {

return;

}

}

return step2(localDoc);

}, error);

} else {

return step2();

}

};

HybridCollection.prototype._findFetch = function(selector, options, success, error) {

var localSuccess, step2;

_.defaults(options, this.options);

step2 = (function(_this) {

return function(localData) {

var remoteError, remoteOptions, remoteSuccess, timedOut, timer;

remoteOptions = _.cloneDeep(options);

if (options.cacheFind) {

delete remoteOptions.fields;

}

timer = null;

timedOut = false;

remoteSuccess = function(remoteData) {

var cacheSuccess, data;

if (timer) {

clearTimeout(timer);

}

if (timedOut) {

return;

}

if (options.cacheFind) {

cacheSuccess = function() {

var localSuccess2;

localSuccess2 = function(localData2) {

if (!_.isEqual(localData, localData2)) {

return success(localData2);

}

};

return _this.localCol.find(selector, options).fetch(localSuccess2, error);

};

return _this.localCol.cache(remoteData, selector, options, cacheSuccess, error);

} else {

data = remoteData;

return _this.localCol.pendingRemoves(function(removes) {

var removesMap;

if (removes.length > 0) {

removesMap = _.object(_.map(removes, function(id) {

return [id, id];

}));

data = _.filter(remoteData, function(doc) {

return !_.has(removesMap, doc._id);

});

}

return _this.localCol.pendingUpserts(function(upserts) {

var upsertsMap;

if (upserts.length > 0) {

upsertsMap = _.object(_.map(upserts, function(u) {

return u.doc._id;

}), _.map(upserts, function(u) {

return u.doc._id;

}));

data = _.filter(data, function(doc) {

return !_.has(upsertsMap, doc._id);

});

data = data.concat(_.pluck(upserts, "doc"));

data = processFind(data, selector, options);

}

if (!_.isEqual(localData, data)) {

return success(data);

}

}, error);

}, error);

}

};

remoteError = function(err) {

if (timer) {

clearTimeout(timer);

}

if (timedOut) {

return;

}

if (!options.interim) {

if (options.useLocalOnRemoteError) {

return _this.localCol.find(selector, options).fetch(success, error);

} else {

if (error) {

return error(err);

}

}

} else {

}

};

if (options.timeout) {

timer = setTimeout(function() {

timer = null;

timedOut = true;

if (!options.interim) {

if (options.useLocalOnRemoteError) {

return _this.localCol.find(selector, options).fetch(success, error);

} else {

if (error) {

return error(new Error("Remote timed out"));

}

}

} else {

}

}, options.timeout);

}

return _this.remoteCol.find(selector, remoteOptions).fetch(remoteSuccess, remoteError);

};

})(this);

if (options.interim) {

localSuccess = function(localData) {

success(localData);

return step2(localData);

};

return this.localCol.find(selector, options).fetch(localSuccess, error);

} else {

return step2();

}

};

HybridCollection.prototype.upsert = function(docs, bases, success, error) {

return this.localCol.upsert(docs, bases, function(result) {

if (success != null) {

return success(docs);

}

}, error);

};

HybridCollection.prototype.remove = function(id, success, error) {

return this.localCol.remove(id, function() {

if (success != null) {

return success();

}

}, error);

};

HybridCollection.prototype.upload = function(success, error) {

var uploadRemoves, uploadUpserts;

uploadUpserts = (function(_this) {

return function(upserts, success, error) {

var upsert;

upsert = _.first(upserts);

if (upsert) {

return _this.remoteCol.upsert(upsert.doc, upsert.base, function(remoteDoc) {

return _this.localCol.resolveUpserts([upsert], function() {

return _this.localCol.cacheOne(remoteDoc, function() {

return uploadUpserts(_.rest(upserts), success, error);

}, error);

}, error);

}, function(err) {

if (err.status === 410 || err.status === 403) {

return _this.localCol.remove(upsert.doc._id, function() {

return _this.localCol.resolveRemove(upsert.doc._id, function() {

if (err.status === 410) {

return uploadUpserts(_.rest(upserts), success, error);

} else {

return error(err);

}

}, error);

}, error);

} else {

return error(err);

}

});

} else {

return success();

}

};

})(this);

uploadRemoves = (function(_this) {

return function(removes, success, error) {

var remove;

remove = _.first(removes);

if (remove) {

return _this.remoteCol.remove(remove, function() {

return _this.localCol.resolveRemove(remove, function() {

return uploadRemoves(_.rest(removes), success, error);

}, error);

}, function(err) {

if (err.status === 410 || err.status === 403) {

return _this.localCol.resolveRemove(remove, function() {

if (err.status === 410) {

return uploadRemoves(_.rest(removes), success, error);

} else {

return error(err);

}

}, error);

} else {

return error(err);

}

}, error);

} else {

return success();

}

};

})(this);

return this.localCol.pendingUpserts((function(_this) {

return function(upserts) {

return uploadUpserts(upserts, function() {

return _this.localCol.pendingRemoves(function(removes) {

return uploadRemoves(removes, success, error);

}, error);

}, error);

};

})(this), error);

};

return HybridCollection;

})();

},{"./utils":14,"lodash":"z2coUu"}],7:[function(require,module,exports){

var Collection, IDBStore, IndexedDb, async, compileSort, processFind, utils, _;

_ = require('lodash');

async = require('async');

IDBStore = require('idb-wrapper');

utils = require('./utils');

processFind = require('./utils').processFind;

compileSort = require('./selector').compileSort;

module.exports = IndexedDb = (function() {

function IndexedDb(options, success, error) {

var ex;

this.collections = {};

try {

this.store = new IDBStore({

dbVersion: 1,

storeName: 'minimongo_' + options.namespace,

keyPath: ['col', 'doc._id'],

autoIncrement: false,

onStoreReady: (function(_this) {

return function() {

if (success) {

return success(_this);

}

};

})(this),

onError: error,

indexes: [

{

name: 'col',

keyPath: 'col',

unique: false,

multiEntry: false

}, {

name: 'col-state',

keyPath: ['col', 'state'],

unique: false,

multiEntry: false

}

]

});

} catch (_error) {

ex = _error;

if (error) {

error(ex);

}

return;

}

}

IndexedDb.prototype.addCollection = function(name, success, error) {

var collection;

collection = new Collection(name, this.store);

this[name] = collection;

this.collections[name] = collection;

if (success) {

return success();

}

};

IndexedDb.prototype.removeCollection = function(name, success, error) {

delete this[name];

delete this.collections[name];

return this.store.query((function(_this) {

return function(matches) {

var keys;

keys = _.map(matches, function(m) {

return [m.col, m.doc._id];

});

if (keys.length > 0) {

return _this.store.removeBatch(keys, function() {

if (success != null) {

return success();

}

}, error);

} else {

if (success != null) {

return success();

}

}

};

})(this), {

index: "col",

keyRange: this.store.makeKeyRange({

only: name

}),

onError: error

});

};

return IndexedDb;

})();

Collection = (function() {

function Collection(name, store) {

this.name = name;

this.store = store;

}

Collection.prototype.find = function(selector, options) {

return {

fetch: (function(_this) {

return function(success, error) {

return _this._findFetch(selector, options, success, error);

};

})(this)

};

};

Collection.prototype.findOne = function(selector, options, success, error) {

var _ref;

if (_.isFunction(options)) {

_ref = [{}, options, success], options = _ref[0], success = _ref[1], error = _ref[2];

}

return this.find(selector, options).fetch(function(results) {

if (success != null) {

return success(results.length > 0 ? results[0] : null);

}

}, error);

};

Collection.prototype._findFetch = function(selector, options, success, error) {

return this.store.query(function(matches) {

matches = _.filter(matches, function(m) {

return m.state !== "removed";

});

if (success != null) {

return success(processFind(_.pluck(matches, "doc"), selector, options));

}

}, {

index: "col",

keyRange: this.store.makeKeyRange({

only: this.name

}),

onError: error

});

};

Collection.prototype.upsert = function(docs, bases, success, error) {

var items, keys, _ref;

_ref = utils.regularizeUpsert(docs, bases, success, error), items = _ref[0], success = _ref[1], error = _ref[2];

keys = _.map(items, (function(_this) {

return function(item) {

return [_this.name, item.doc._id];

};

})(this));

return this.store.getBatch(keys, (function(_this) {

return function(records) {

var puts;

puts = _.map(items, function(item, i) {

var base;

if (item.base !== void 0) {

base = item.base;

} else if (records[i] && records[i].doc && records[i].state === "cached") {

base = records[i].doc;

} else if (records[i] && records[i].doc && records[i].state === "upserted") {

base = records[i].base;

} else {

base = null;

}

return {

col: _this.name,

state: "upserted",

doc: item.doc,

base: base

};

});

return _this.store.putBatch(puts, function() {

if (success) {

return success(docs);

}

}, error);

};

})(this), error);

};

Collection.prototype.remove = function(id, success, error) {

return this.store.get([this.name, id], (function(_this) {

return function(record) {

if (record == null) {

record = {

col: _this.name,

doc: {

_id: id

}

};

}

record.state = "removed";

return _this.store.put(record, function() {

if (success) {

return success(id);

}

}, error);

};

})(this));

};

Collection.prototype.cache = function(docs, selector, options, success, error) {

var keys, puts, step2;

step2 = (function(_this) {

return function() {

var docsMap, sort;

docsMap = _.object(_.pluck(docs, "_id"), docs);

if (options.sort) {

sort = compileSort(options.sort);

}

return _this.find(selector, options).fetch(function(results) {

var keys, removes;

removes = [];

keys = _.map(results, function(result) {

return [_this.name, result._id];

});

if (keys.length === 0) {

if (success != null) {

success();

}

return;

}

return _this.store.getBatch(keys, function(records) {

var i, record, result, _i, _ref;

for (i = _i = 0, _ref = records.length; 0 <= _ref ? _i < _ref : _i > _ref; i = 0 <= _ref ? ++_i : --_i) {

record = records[i];

result = results[i];

if (!docsMap[result._id] && record && record.state === "cached") {

if (options.sort && options.limit && docs.length === options.limit) {

if (sort(result, _.last(docs)) >= 0) {

continue;

}

}

removes.push([_this.name, result._id]);

}

}

if (removes.length > 0) {

return _this.store.removeBatch(removes, function() {

if (success != null) {

return success();

}

}, error);

} else {

if (success != null) {

return success();

}

}

}, error);

}, error);

};

})(this);

if (docs.length === 0) {

return step2();

}

keys = _.map(docs, (function(_this) {

return function(doc) {

return [_this.name, doc._id];

};

})(this));

puts = [];

return this.store.getBatch(keys, (function(_this) {

return function(records) {

var doc, i, record, _i, _ref;

for (i = _i = 0, _ref = records.length; 0 <= _ref ? _i < _ref : _i > _ref; i = 0 <= _ref ? ++_i : --_i) {

record = records[i];

doc = docs[i];

if ((record == null) || record.state === "cached") {

if (!record || !doc._rev || !record.doc._rev || doc._rev >= record.doc._rev) {

puts.push({

col: _this.name,

state: "cached",

doc: doc

});

}

}

}

if (puts.length > 0) {

return _this.store.putBatch(puts, step2, error);

} else {

return step2();

}

};

})(this), error);

};

Collection.prototype.pendingUpserts = function(success, error) {

return this.store.query(function(matches) {

var upserts;

upserts = _.map(matches, function(m) {

return {

doc: m.doc,

base: m.base || null

};

});

if (success != null) {

return success(upserts);

}

}, {

index: "col-state",

keyRange: this.store.makeKeyRange({

only: [this.name, "upserted"]

}),

onError: error

});

};