true If public access is allowed
+ */
+
+
+ Acl.prototype.isPublicReadAllowed = function isPublicReadAllowed() {
+ return this.read.isPublicAllowed();
+ };
+
+ /**
+ * Sets whenever all users and roles should have the permission to read the object.
+ * Note: All other allow read rules will be removed.
+ */
+
+
+ Acl.prototype.setPublicReadAllowed = function setPublicReadAllowed() {
+ return this.read.setPublicAllowed();
+ };
+
+ /**
+ * Checks whenever the user or role is explicit allowed to read the object.
+ *
+ * @param {model.User|model.Role|string} userOrRole The user or role to check for
+ * @return {boolean} true if read access is explicitly allowed for the given user or role
+ */
+
+
+ Acl.prototype.isReadAllowed = function isReadAllowed(userOrRole) {
+ return this.read.isAllowed(userOrRole);
+ };
+
+ /**
+ * Checks whenever the user or role is explicit denied to read the object
+ *
+ * @param {model.User|model.Role|string} userOrRole The user or role to check for
+ * @return {boolean} true if read access is explicitly denied for the given user or role
+ */
+
+
+ Acl.prototype.isReadDenied = function isReadDenied(userOrRole) {
+ return this.read.isDenied(userOrRole);
+ };
+
+ /**
+ * Allows the given user or rule to read the object
+ * @param {...(model.User|model.Role|string)} userOrRole The user or role to allow
+ * @return {Acl} this acl object
+ */
+
+
+ Acl.prototype.allowReadAccess = function allowReadAccess(userOrRole) {
+ Permission.prototype.allowAccess.apply(this.read, arguments);
+ return this;
+ };
+
+ /**
+ * Denies the given user or rule to read the object
+ * @param {...(model.User|model.Role|string)} userOrRole The user or role to deny
+ * @return {Acl} this acl object
+ */
+
+
+ Acl.prototype.denyReadAccess = function denyReadAccess(userOrRole) {
+ Permission.prototype.denyAccess.apply(this.read, arguments);
+ return this;
+ };
+
+ /**
+ * Deletes any read allow/deny rule for the given user or role
+ * @param {...(model.User|model.Role|string)} userOrRole The user or role
+ * @return {Acl} this acl object
+ */
+
+
+ Acl.prototype.deleteReadAccess = function deleteReadAccess(userOrRole) {
+ Permission.prototype.deleteAccess.apply(this.read, arguments);
+ return this;
+ };
+
+ /**
+ * Gets whenever all users and roles have the permission to write the object
+ * @return {boolean} true If public access is allowed
+ */
+
+
+ Acl.prototype.isPublicWriteAllowed = function isPublicWriteAllowed() {
+ return this.write.isPublicAllowed();
+ };
+
+ /**
+ * Sets whenever all users and roles should have the permission to write the object.
+ * Note: All other allow write rules will be removed.
+ */
+
+
+ Acl.prototype.setPublicWriteAllowed = function setPublicWriteAllowed() {
+ return this.write.setPublicAllowed();
+ };
+
+ /**
+ * Checks whenever the user or role is explicit allowed to write the object.
+ *
+ * @param {model.User|model.Role|string} userOrRole The user or role to check for
+ * @return {boolean} true if write access is explicitly allowed for the given user or role
+ */
+
+
+ Acl.prototype.isWriteAllowed = function isWriteAllowed(userOrRole) {
+ return this.write.isAllowed(userOrRole);
+ };
+
+ /**
+ * Checks whenever the user or role is explicit denied to write the object
+ *
+ * @param {model.User|model.Role|string} userOrRole The user or role to check for
+ * @return {boolean} true if write access is explicitly denied for the given user or role
+ */
+
+
+ Acl.prototype.isWriteDenied = function isWriteDenied(userOrRole) {
+ return this.write.isDenied(userOrRole);
+ };
+
+ /**
+ * Allows the given user or rule to write the object
+ * @param {...(model.User|model.Role|string)} userOrRole The user or role to allow
+ * @return {Acl} this acl object
+ */
+
+
+ Acl.prototype.allowWriteAccess = function allowWriteAccess(userOrRole) {
+ Permission.prototype.allowAccess.apply(this.write, arguments);
+ return this;
+ };
+
+ /**
+ * Denies the given user or rule to write the object
+ * @param {...(model.User|model.Role|string)} userOrRole The user or role to deny
+ * @return {Acl} this acl object
+ */
+
+
+ Acl.prototype.denyWriteAccess = function denyWriteAccess(userOrRole) {
+ Permission.prototype.denyAccess.apply(this.write, arguments);
+ return this;
+ };
+
+ /**
+ * Deletes any write allow/deny rule for the given user or role
+ * @param {...(model.User|model.Role|string)} userOrRole The user or role
+ * @return {Acl} this acl object
+ */
+
+
+ Acl.prototype.deleteWriteAccess = function deleteWriteAccess(userOrRole) {
+ Permission.prototype.deleteAccess.apply(this.write, arguments);
+ return this;
+ };
+
+ /**
+ * A Json representation of the set of rules
+ * @return {json}
+ */
+
+
+ Acl.prototype.toJSON = function toJSON() {
+ return {
+ read: this.read,
+ write: this.write
+ };
+ };
+
+ /**
+ * Sets the acl rules form json
+ * @param {json} json The json encoded acls
+ */
+
+
+ Acl.prototype.fromJSON = function fromJSON(json) {
+ this.read.fromJSON(json.read || {});
+ this.write.fromJSON(json.write || {});
+ };
+
+ return Acl;
+}();
+
+module.exports = Acl;
+
+},{"65":65}],2:[function(_dereq_,module,exports){
+"use strict";
+
+var message = _dereq_(36);
+var error = _dereq_(34);
+var binding = _dereq_(20);
+var util = _dereq_(70);
+var query = _dereq_(59);
+
+var UserFactory = _dereq_(19);
+var EntityTransaction = _dereq_(4);
+var Metadata = _dereq_(63);
+var Message = _dereq_(25);
+var BloomFilter = _dereq_(21);
+var StatusCode = Message.StatusCode;
+
+/**
+ * @alias EntityManager
+ * @extends util.Lockable
+ */
+
+var EntityManager = function (_util$Lockable) {
+ babelHelpers.inherits(EntityManager, _util$Lockable);
+ babelHelpers.createClass(EntityManager, [{
+ key: 'isOpen',
+
+
+ /**
+ * Determine whether the entity manager is open.
+ * true until the entity manager has been closed
+ * @type boolean
+ */
+ get: function get() {
+ return !!this._connector;
+ }
+
+ /**
+ * The authentication token if the user is logged in currently
+ * @type String
+ */
+
+ }, {
+ key: 'token',
+ get: function get() {
+ return this.tokenStorage.token;
+ },
+
+
+ /**
+ * The authentication token if the user is logged in currently
+ * @param {String} value
+ */
+ set: function set(value) {
+ this.tokenStorage.update(value);
+ }
+
+ /**
+ * @param {EntityManagerFactory} entityManagerFactory The factory which of this entityManager instance
+ */
+
+ }, {
+ key: 'isCachingDisabled',
+ get: function get() {
+ return !this.bloomFilter;
+ }
+ }]);
+
+ function EntityManager(entityManagerFactory) {
+ babelHelpers.classCallCheck(this, EntityManager);
+
+ /**
+ * Log messages can created by calling log directly as function, with a specific log level or with the helper
+ * methods, which a members of the log method.
+ *
+ * Logs will be filtered by the client logger and the before they persisted. The default log level is
+ * 'info' therefore all log messages below the given message aren't persisted.
+ *
+ * Examples:
+ *
+ // default log level ist info
+ db.log('test message %s', 'my string');
+ // info: test message my string
+ // pass a explicit log level as the first argument, one of ('trace', 'debug', 'info', 'warn', 'error')
+ db.log('warn', 'test message %d', 123);
+ // warn: test message 123
+ // debug log level will not be persisted by default, since the default logging level is info
+ db.log('debug', 'test message %j', {number: 123}, {});
+ // debug: test message {"number":123}
+ // data = {}
+ // One additional json object can be provided, which will be persisted together with the log entry
+ db.log('info', 'test message %s, %s', 'first', 'second', {number: 123});
+ // info: test message first, second
+ // data = {number: 123}
+ //use the log level helper
+ db.log.info('test message', 'first', 'second', {number: 123});
+ // info: test message first second
+ // data = {number: 123}
+ //change the default log level to trace, i.e. all log levels will be persisted, note that the log level can be
+ //additionally configured in the baqend
+ db.log.level = 'trace';
+ //trace will be persisted now
+ db.log.trace('test message', 'first', 'second', {number: 123});
+ // info: test message first second
+ // data = {number: 123}
+ *
+ *
+ * @type util.Logger
+ */
+ var _this = babelHelpers.possibleConstructorReturn(this, _util$Lockable.call(this));
+
+ _this.log = util.Logger.create(_this);
+
+ /**
+ * The connector used for requests
+ * @type connector.Connector
+ * @private
+ */
+ _this._connector = null;
+
+ /**
+ * All managed and cached entity instances
+ * @type Map
+ */
+ _this._entities = null;
+
+ /** @type EntityManagerFactory */
+ _this.entityManagerFactory = entityManagerFactory;
+
+ /** @type metamodel.Metamodel */
+ _this.metamodel = entityManagerFactory.metamodel;
+
+ /** @type util.Code */
+ _this.code = entityManagerFactory.code;
+
+ /** @type util.Modules */
+ _this.modules = null;
+
+ /**
+ * The current logged in user object
+ * @type model.User
+ */
+ _this.me = null;
+
+ /**
+ * Returns true if the device token is already registered, otherwise false.
+ * @type boolean
+ */
+ _this.isDeviceRegistered = false;
+
+ /**
+ * Returns the tokenStorage which will be used to authorize all requests.
+ * @type {util.TokenStorage}
+ */
+ _this.tokenStorage = null;
+
+ /**
+ * @type {caching.BloomFilter}
+ */
+ _this.bloomFilter = null;
+
+ /**
+ * Set of object ids that were revalidated after the Bloom filter was loaded.
+ */
+ _this.cacheWhiteList = null;
+
+ /**
+ * Set of object ids that were updated but are not yet included in the bloom filter.
+ * This set essentially implements revalidation by side effect which does not work in Chrome.
+ */
+ _this.cacheBlackList = null;
+
+ /**
+ * Bloom filter refresh interval in seconds.
+ *
+ * @type {number}
+ */
+ _this.bloomFilterRefresh = 60;
+
+ /**
+ * Bloom filter refresh Promise
+ *
+ */
+ _this._bloomFilterLock = new util.Lockable();
+ return _this;
+ }
+
+ /**
+ * Connects this entityManager, used for synchronous and asynchronous initialization
+ * @param {connector.Connector} connector
+ * @param {Object} connectData
+ * @param {util.TokenStorage} tokenStorage The used tokenStorage for token persistence
+ */
+
+
+ EntityManager.prototype.connected = function connected(connector, connectData, tokenStorage) {
+ this._connector = connector;
+ this.tokenStorage = tokenStorage;
+ this.bloomFilterRefresh = this.entityManagerFactory.staleness;
+ this._entities = {};
+
+ this.File = binding.FileFactory.create(this);
+ this._createObjectFactory(this.metamodel.embeddables);
+ this._createObjectFactory(this.metamodel.entities);
+
+ this.transaction = new EntityTransaction(this);
+ this.modules = new util.Modules(this, connector);
+
+ if (connectData) {
+ this.isDeviceRegistered = !!connectData.device;
+ if (connectData.user && connectData.token == tokenStorage.token) this._updateUser(connectData.user, true);
+
+ if (this.bloomFilterRefresh > 0 && connectData.bloomFilter && util.atob && !util.isNode) {
+ this.updateBloomFilter(connectData.bloomFilter);
+ }
+ }
+ };
+
+ /**
+ * @param {metamodel.ManagedType[]} types
+ * @return {binding.ManagedFactory}
+ * @private
+ */
+
+
+ EntityManager.prototype._createObjectFactory = function _createObjectFactory(types) {
+ Object.keys(types).forEach(function (ref) {
+ var type = this.metamodel.managedType(ref);
+ var name = type.name;
+
+ if (this[name]) {
+ type.typeConstructor = this[name];
+ Object.defineProperty(this, name, {
+ value: type.createObjectFactory(this)
+ });
+ } else {
+ Object.defineProperty(this, name, {
+ get: function get() {
+ Object.defineProperty(this, name, {
+ value: type.createObjectFactory(this)
+ });
+
+ return this[name];
+ },
+ set: function set(typeConstructor) {
+ type.typeConstructor = typeConstructor;
+ },
+
+ configurable: true
+ });
+ }
+ }, this);
+ };
+
+ EntityManager.prototype.send = function send(message) {
+ var _this2 = this;
+
+ message.tokenStorage = this.tokenStorage;
+ return this._connector.send(message).catch(function (e) {
+ if (e.status == StatusCode.BAD_CREDENTIALS) {
+ _this2._logout();
+ }
+ throw e;
+ });
+ };
+
+ /**
+ * Get an instance, whose state may be lazily fetched. If the requested instance does not exist
+ * in the database, the EntityNotFoundError is thrown when the instance state is first accessed.
+ * The application should not expect that the instance state will be available upon detachment,
+ * unless it was accessed by the application while the entity manager was open.
+ *
+ * @param {(Class|string)} entityClass
+ * @param {string=} key
+ */
+
+
+ EntityManager.prototype.getReference = function getReference(entityClass, key) {
+ var id, type;
+ if (key) {
+ type = this.metamodel.entity(entityClass);
+ if (key.indexOf('/db/') == 0) {
+ id = key;
+ } else {
+ id = type.ref + '/' + encodeURIComponent(key);
+ }
+ } else {
+ id = entityClass;
+ type = this.metamodel.entity(id.substring(0, id.indexOf('/', 4))); //skip /db/
+ }
+
+ var entity = this._entities[id];
+ if (!entity) {
+ entity = type.create();
+ var metadata = Metadata.get(entity);
+ metadata.id = id;
+ metadata.setUnavailable();
+
+ this._attach(entity);
+ }
+
+ return entity;
+ };
+
+ /**
+ * Creates an instance of Query.Builder for query creation and execution. The Query results are instances of the
+ * resultClass argument.
+ * @param {Class<*>=} resultClass - the type of the query result
+ * @return {query.Builder<*>} A query builder to create one ore more queries for the specified class
+ */
+
+
+ EntityManager.prototype.createQueryBuilder = function createQueryBuilder(resultClass) {
+ return new query.Builder(this, resultClass);
+ };
+
+ /**
+ * Clear the persistence context, causing all managed entities to become detached.
+ * Changes made to entities that have not been flushed to the database will not be persisted.
+ */
+
+
+ EntityManager.prototype.clear = function clear() {
+ this._entities = {};
+ };
+
+ /**
+ * Close an application-managed entity manager. After the close method has been invoked,
+ * all methods on the EntityManager instance and any Query and TypedQuery objects obtained from it
+ * will throw the IllegalStateError except for transaction, and isOpen (which will return false).
+ * If this method is called when the entity manager is associated with an active transaction,
+ * the persistence context remains managed until the transaction completes.
+ */
+
+
+ EntityManager.prototype.close = function close() {
+ this._connector = null;
+
+ return this.clear();
+ };
+
+ /**
+ * Check if the instance is a managed entity instance belonging to the current persistence context.
+ * @param {binding.Entity} entity - entity instance
+ * @returns {boolean} boolean indicating if entity is in persistence context
+ */
+
+
+ EntityManager.prototype.contains = function contains(entity) {
+ return !!entity && this._entities[entity.id] === entity;
+ };
+
+ /**
+ * Check if an object with the id from the given entity is already attached.
+ * @param {binding.Entity} entity - entity instance
+ * @returns {boolean} boolean indicating if entity with same id is attached
+ */
+
+
+ EntityManager.prototype.containsById = function containsById(entity) {
+ return !!(entity && this._entities[entity.id]);
+ };
+
+ /**
+ * Remove the given entity from the persistence context, causing a managed entity to become detached.
+ * Unflushed changes made to the entity if any (including removal of the entity),
+ * will not be synchronized to the database. Entities which previously referenced the detached entity will continue to reference it.
+ * @param {binding.Entity} entity - entity instance
+ */
+
+
+ EntityManager.prototype.detach = function detach(entity) {
+ var _this3 = this;
+
+ var state = Metadata.get(entity);
+ return state.withLock(function () {
+ _this3.removeReference(entity);
+ return Promise.resolve(entity);
+ });
+ };
+
+ /**
+ * Resolve the depth by loading the referenced objects of the given entity.
+ *
+ * @param {binding.Entity} entity - entity instance
+ * @param {Object} [options] The load options
+ * @return {Promise}
+ */
+
+
+ EntityManager.prototype.resolveDepth = function resolveDepth(entity, options) {
+ var _this4 = this;
+
+ if (!options || !options.depth) return Promise.resolve(entity);
+
+ options.resolved = options.resolved || [];
+ var promises = [];
+ var subOptions = Object.assign({}, options, {
+ depth: options.depth === true ? true : options.depth - 1
+ });
+ this.getSubEntities(entity, 1).forEach(function (subEntity) {
+ if (subEntity != null && !~options.resolved.indexOf(subEntity)) {
+ options.resolved.push(subEntity);
+ promises.push(_this4.load(subEntity.id, null, subOptions));
+ }
+ });
+
+ return Promise.all(promises).then(function () {
+ return entity;
+ });
+ };
+
+ /**
+ * Search for an entity of the specified oid.
+ * If the entity instance is contained in the persistence context, it is returned from there.
+ * @param {(Class|string)} entityClass - entity class
+ * @param {String} oid - Object ID
+ * @param {Object} [options] The load options.
+ * @return {Promise} the loaded entity or null
+ */
+
+
+ EntityManager.prototype.load = function load(entityClass, oid, options) {
+ var _this5 = this;
+
+ options = options || {};
+ var entity = this.getReference(entityClass, oid);
+ var state = Metadata.get(entity);
+
+ if (!options.refresh && options.local && state.isAvailable) {
+ return this.resolveDepth(entity, options);
+ }
+
+ var msg = new message.GetObject(state.bucket, state.key);
+
+ this.ensureCacheHeader(entity.id, msg, options.refresh);
+
+ return this.send(msg).then(function (response) {
+ // refresh object if loaded older version from cache
+ // chrome doesn't using cache when ifNoneMatch is set
+ if (entity.version > response.entity.version) {
+ options.refresh = true;
+ return _this5.load(entityClass, oid, options);
+ }
+
+ _this5.addToWhiteList(response.entity.id);
+
+ if (response.status != StatusCode.NOT_MODIFIED) {
+ state.setJson(response.entity);
+ }
+
+ state.setPersistent();
+
+ return _this5.resolveDepth(entity, options);
+ }, function (e) {
+ if (e.status == StatusCode.OBJECT_NOT_FOUND) {
+ _this5.removeReference(entity);
+ state.setRemoved();
+ return null;
+ } else {
+ throw e;
+ }
+ });
+ };
+
+ /**
+ * @param {binding.Entity} entity
+ * @param {Object} options
+ * @return {Promise}
+ */
+
+
+ EntityManager.prototype.insert = function insert(entity, options) {
+ var _this6 = this;
+
+ options = options || {};
+ var isNew;
+
+ return this._save(entity, options, function (state, json) {
+ if (state.version) throw new error.PersistentError('Existing objects can\'t be inserted.');
+
+ isNew = !state.id;
+
+ return new message.CreateObject(state.bucket, json);
+ }).then(function (val) {
+ if (isNew) _this6._attach(entity);
+
+ return val;
+ });
+ };
+
+ /**
+ * @param {binding.Entity} entity
+ * @param {Object} options
+ * @return {Promise}
+ */
+
+
+ EntityManager.prototype.update = function update(entity, options) {
+ options = options || {};
+
+ return this._save(entity, options, function (state, json) {
+ if (!state.version) throw new error.PersistentError("New objects can't be inserted.");
+
+ if (options.force) {
+ delete json.version;
+ return new message.ReplaceObject(state.bucket, state.key, json).ifMatch('*');
+ } else {
+ return new message.ReplaceObject(state.bucket, state.key, json).ifMatch(state.version);
+ }
+ });
+ };
+
+ /**
+ * @param {binding.Entity} entity
+ * @param {Object} options The save options
+ * @param {boolean=} withoutLock Set true to save the entity without locking
+ * @return {Promise}
+ */
+
+
+ EntityManager.prototype.save = function save(entity, options, withoutLock) {
+ options = options || {};
+
+ var msgFactory = function msgFactory(state, json) {
+ if (options.force) {
+ if (!state.id) throw new error.PersistentError("New special objects can't be forcedly saved.");
+
+ delete json.version;
+ return new message.ReplaceObject(state.bucket, state.key, json);
+ } else if (state.version) {
+ return new message.ReplaceObject(state.bucket, state.key, json).ifMatch(state.version);
+ } else {
+ return new message.CreateObject(state.bucket, json);
+ }
+ };
+
+ return withoutLock ? this._locklessSave(entity, options, msgFactory) : this._save(entity, options, msgFactory);
+ };
+
+ /**
+ * @param {binding.Entity} entity
+ * @param {Function} cb pre-safe callback
+ * @return {Promise}
+ */
+
+
+ EntityManager.prototype.optimisticSave = function optimisticSave(entity, cb) {
+ var _this7 = this;
+
+ return Metadata.get(entity).withLock(function () {
+ return _this7._optimisticSave(entity, cb);
+ });
+ };
+
+ /**
+ * @param {binding.Entity} entity
+ * @param {Function} cb pre-safe callback
+ * @return {Promise}
+ * @private
+ */
+
+
+ EntityManager.prototype._optimisticSave = function _optimisticSave(entity, cb) {
+ var _this8 = this;
+
+ var abort = false;
+ var abortFn = function abortFn() {
+ abort = true;
+ };
+ var promise = Promise.resolve(cb(entity, abortFn));
+
+ if (abort) return Promise.resolve(entity);
+
+ return promise.then(function () {
+ return _this8.save(entity, {}, true).catch(function (e) {
+ if (e.status == 412) {
+ return _this8.refresh(entity, {}).then(function () {
+ return _this8._optimisticSave(entity, cb);
+ });
+ } else {
+ throw e;
+ }
+ });
+ });
+ };
+
+ /**
+ * Save the object state without locking
+ * @param {binding.Entity} entity
+ * @param {Object} options
+ * @param {Function} msgFactory
+ * @return {Promise.}
+ * @private
+ */
+
+
+ EntityManager.prototype._locklessSave = function _locklessSave(entity, options, msgFactory) {
+ var _this9 = this;
+
+ this.attach(entity);
+ var state = Metadata.get(entity);
+ var refPromises;
+
+ var json;
+ if (state.isAvailable) {
+ //getting json will check all collections changes, therefore we must do it before proofing the dirty state
+ json = state.getJson();
+ }
+
+ if (state.isDirty) {
+ if (!options.refresh) {
+ state.setPersistent();
+ }
+
+ var sendPromise = this.send(msgFactory(state, json)).then(function (response) {
+ if (options.refresh) {
+ state.setJson(response.entity);
+ state.setPersistent();
+ } else {
+ state.setJsonMetadata(response.entity);
+ }
+ return entity;
+ }, function (e) {
+ if (e.status == StatusCode.OBJECT_NOT_FOUND) {
+ _this9.removeReference(entity);
+ state.setRemoved();
+ return null;
+ } else {
+ state.setDirty();
+ throw e;
+ }
+ });
+
+ refPromises = [sendPromise];
+ } else {
+ refPromises = [Promise.resolve(entity)];
+ }
+
+ var subOptions = Object.assign({}, options);
+ subOptions.depth = 0;
+ this.getSubEntities(entity, options.depth).forEach(function (sub) {
+ refPromises.push(_this9._save(sub, subOptions, msgFactory));
+ });
+
+ return Promise.all(refPromises).then(function () {
+ return entity;
+ });
+ };
+
+ /**
+ * Save and lock the object state
+ * @param {binding.Entity} entity
+ * @param {Object} options
+ * @param {Function} msgFactory
+ * @return {Promise.}
+ * @private
+ */
+
+
+ EntityManager.prototype._save = function _save(entity, options, msgFactory) {
+ var _this10 = this;
+
+ this.ensureBloomFilterFreshness();
+
+ var state = Metadata.get(entity);
+ if (state.version) {
+ this.addToBlackList(entity.id);
+ }
+
+ return state.withLock(function () {
+ return _this10._locklessSave(entity, options, msgFactory);
+ });
+ };
+
+ /**
+ * Returns all referenced sub entities for the given depth and root entity
+ * @param {binding.Entity} entity
+ * @param {boolean|number} depth
+ * @param {binding.Entity[]} [resolved]
+ * @param {binding.Entity=} initialEntity
+ * @returns {binding.Entity[]}
+ */
+
+
+ EntityManager.prototype.getSubEntities = function getSubEntities(entity, depth, resolved, initialEntity) {
+ var _this11 = this;
+
+ resolved = resolved || [];
+ if (!depth) {
+ return resolved;
+ }
+ initialEntity = initialEntity || entity;
+
+ var state = Metadata.get(entity);
+ for (var _iterator = state.type.references(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var value = _ref;
+
+ this.getSubEntitiesByPath(entity, value.path).forEach(function (subEntity) {
+ if (!~resolved.indexOf(subEntity) && subEntity != initialEntity) {
+ resolved.push(subEntity);
+ resolved = _this11.getSubEntities(subEntity, depth === true ? depth : depth - 1, resolved, initialEntity);
+ }
+ });
+ }
+
+ return resolved;
+ };
+
+ /**
+ * Returns all referenced one level sub entities for the given path
+ * @param {binding.Entity} entity
+ * @param {Array} path
+ * @returns {binding.Entity[]}
+ */
+
+
+ EntityManager.prototype.getSubEntitiesByPath = function getSubEntitiesByPath(entity, path) {
+ var _this12 = this;
+
+ var subEntities = [entity];
+
+ path.forEach(function (attributeName) {
+
+ var tmpSubEntities = [];
+ subEntities.forEach(function (subEntity) {
+ var curEntity = subEntity[attributeName];
+ if (!curEntity) return;
+
+ var attribute = _this12.metamodel.managedType(subEntity.constructor).getAttribute(attributeName);
+ if (attribute.isCollection) {
+ for (var _iterator2 = curEntity.entries(), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+ var _ref2;
+
+ if (_isArray2) {
+ if (_i2 >= _iterator2.length) break;
+ _ref2 = _iterator2[_i2++];
+ } else {
+ _i2 = _iterator2.next();
+ if (_i2.done) break;
+ _ref2 = _i2.value;
+ }
+
+ var entry = _ref2;
+
+ tmpSubEntities.push(entry[1]);
+ attribute.keyType && attribute.keyType.isEntity && tmpSubEntities.push(entry[0]);
+ }
+ } else {
+ tmpSubEntities.push(curEntity);
+ }
+ });
+ subEntities = tmpSubEntities;
+ });
+
+ return subEntities;
+ };
+
+ /**
+ * Delete the entity instance.
+ * @param {binding.Entity} entity
+ * @param {Object} options The delete options
+ * @return {Promise}
+ */
+
+
+ EntityManager.prototype['delete'] = function _delete(entity, options) {
+ var _this13 = this;
+
+ options = options || {};
+
+ this.attach(entity);
+ var state = Metadata.get(entity);
+
+ return state.withLock(function () {
+ if (!state.version && !options.force) throw new error.IllegalEntityError(entity);
+
+ var msg = new message.DeleteObject(state.bucket, state.key);
+
+ _this13.addToBlackList(entity.id);
+
+ if (!options.force) msg.ifMatch(state.version);
+
+ var refPromises = [_this13.send(msg).then(function () {
+ _this13.removeReference(entity);
+ state.setRemoved();
+ return entity;
+ })];
+
+ var subOptions = Object.assign({}, options);
+ subOptions.depth = 0;
+ _this13.getSubEntities(entity, options.depth).forEach(function (sub) {
+ refPromises.push(_this13.delete(sub, subOptions));
+ });
+
+ return Promise.all(refPromises).then(function () {
+ return entity;
+ });
+ });
+ };
+
+ /**
+ * Synchronize the persistence context to the underlying database.
+ *
+ * @returns {Promise<*>}
+ */
+
+
+ EntityManager.prototype.flush = function flush(doneCallback, failCallback) {}
+ // TODO: implement this
+
+
+ /**
+ * Make an instance managed and persistent.
+ * @param {binding.Entity} entity - entity instance
+ */
+ ;
+
+ EntityManager.prototype.persist = function persist(entity) {
+ this.attach(entity);
+ };
+
+ /**
+ * Refresh the state of the instance from the database, overwriting changes made to the entity, if any.
+ * @param {binding.Entity} entity - entity instance
+ * @param {Object} options The refresh options
+ * @return {Promise}
+ */
+
+
+ EntityManager.prototype.refresh = function refresh(entity, options) {
+ options = options || {};
+ options.refresh = true;
+
+ return this.load(entity.id, null, options);
+ };
+
+ /**
+ * Attach the instance to this database context, if it is not already attached
+ * @param {binding.Entity} entity The entity to attach
+ */
+
+
+ EntityManager.prototype.attach = function attach(entity) {
+ if (!this.contains(entity)) {
+ var type = this.metamodel.entity(entity.constructor);
+ if (!type) throw new error.IllegalEntityError(entity);
+
+ if (this.containsById(entity)) throw new error.EntityExistsError(entity);
+
+ this._attach(entity);
+ }
+ };
+
+ EntityManager.prototype._attach = function _attach(entity) {
+ var metadata = Metadata.get(entity);
+ if (metadata.isAttached) {
+ if (metadata.db != this) {
+ throw new error.EntityExistsError(entity);
+ }
+ } else {
+ metadata.db = this;
+ }
+
+ if (!metadata.id) {
+ if (metadata.type.name != 'User' && metadata.type.name != 'Role' && metadata.type.name != 'logs.AppLog') {
+ metadata.id = '/db/' + metadata.type.name + '/' + util.uuid();
+ }
+ }
+
+ if (metadata.id) {
+ this._entities[metadata.id] = entity;
+ }
+ };
+
+ EntityManager.prototype.removeReference = function removeReference(entity) {
+ var state = Metadata.get(entity);
+ if (!state) throw new error.IllegalEntityError(entity);
+
+ delete this._entities[state.id];
+ };
+
+ EntityManager.prototype.register = function register(user, password, loginOption) {
+ var _this14 = this;
+
+ var login = loginOption > UserFactory.LoginOption.NO_LOGIN;
+ if (this.me && login) {
+ throw new error.PersistentError('User is already logged in.');
+ }
+
+ return this.withLock(function () {
+ var msg = new message.Register({
+ user: user,
+ password: password,
+ login: login
+ });
+ return _this14._userRequest(msg, loginOption);
+ });
+ };
+
+ EntityManager.prototype.login = function login(username, password, loginOption) {
+ var _this15 = this;
+
+ if (this.me) throw new error.PersistentError('User is already logged in.');
+
+ return this.withLock(function () {
+ var msg = new message.Login({
+ username: username,
+ password: password
+ });
+
+ return _this15._userRequest(msg, loginOption);
+ });
+ };
+
+ EntityManager.prototype.logout = function logout() {
+ var _this16 = this;
+
+ return this.withLock(function () {
+ return _this16.send(new message.Logout()).then(_this16._logout.bind(_this16));
+ });
+ };
+
+ EntityManager.prototype.loginWithOAuth = function loginWithOAuth(provider, clientID, options) {
+ if (this.me) throw new error.PersistentError('User is already logged in.');
+
+ options = Object.assign({
+ title: "Login with " + provider,
+ timeout: 5 * 60 * 1000,
+ state: {},
+ loginOption: true
+ }, options);
+
+ var msg;
+ if (Message[provider + 'OAuth']) {
+ msg = new Message[provider + 'OAuth'](clientID, options.scope, JSON.stringify(options.state));
+ } else {
+ throw new Error('OAuth provider ' + provider + ' not supported.');
+ }
+
+ var req = this._userRequest(msg, options.loginOption);
+ var w = open(msg.request.path, options.title, 'width=' + options.width + ',height=' + options.height);
+
+ return new Promise(function (resolve, reject) {
+ var timeout = setTimeout(function () {
+ reject(new error.PersistentError('OAuth login timeout.'));
+ }, options.timeout);
+
+ req.then(resolve, reject).then(function () {
+ clearTimeout(timeout);
+ });
+ });
+ };
+
+ EntityManager.prototype.renew = function renew() {
+ var _this17 = this;
+
+ return this.withLock(function () {
+ var msg = new message.Me();
+ return _this17._userRequest(msg, true);
+ });
+ };
+
+ EntityManager.prototype.newPassword = function newPassword(username, password, _newPassword) {
+ var _this18 = this;
+
+ return this.withLock(function () {
+ var msg = new message.NewPassword({
+ username: username,
+ password: password,
+ newPassword: _newPassword
+ });
+
+ return _this18.send(msg).then(function (response) {
+ return _this18._updateUser(response.entity);
+ });
+ });
+ };
+
+ EntityManager.prototype._updateUser = function _updateUser(obj, updateMe) {
+ var user = this.getReference(obj.id);
+ var metadata = Metadata.get(user);
+ metadata.setJson(obj);
+ metadata.setPersistent();
+
+ if (updateMe) this.me = user;
+
+ return user;
+ };
+
+ EntityManager.prototype._logout = function _logout() {
+ this.me = null;
+ this.token = null;
+ };
+
+ EntityManager.prototype._userRequest = function _userRequest(msg, loginOption) {
+ var _this19 = this;
+
+ var login = loginOption > UserFactory.LoginOption.NO_LOGIN;
+ if (login) {
+ this.tokenStorage.temporary = loginOption < UserFactory.LoginOption.PERSIST_LOGIN;
+ }
+
+ return this.send(msg).then(function (response) {
+ if (response.entity) {
+ return _this19._updateUser(response.entity, login);
+ }
+ }, function (e) {
+ if (e.status == StatusCode.OBJECT_NOT_FOUND) {
+ if (login) _this19._logout();
+ return null;
+ } else {
+ throw e;
+ }
+ });
+ };
+
+ EntityManager.prototype.registerDevice = function registerDevice(os, token, device) {
+ var msg = new message.DeviceRegister({
+ token: token,
+ devicetype: os,
+ device: device
+ });
+
+ msg.withCredentials = true;
+ return this.send(msg);
+ };
+
+ EntityManager.prototype.checkDeviceRegistration = function checkDeviceRegistration() {
+ var _this20 = this;
+
+ return this.send(new message.DeviceRegistered()).then(function () {
+ return _this20.isDeviceRegistered = true;
+ }, function (e) {
+ if (e.status == StatusCode.OBJECT_NOT_FOUND) {
+ return _this20.isDeviceRegistered = false;
+ } else {
+ throw e;
+ }
+ });
+ };
+
+ EntityManager.prototype.pushDevice = function pushDevice(pushMessage) {
+ return this.send(new message.DevicePush(pushMessage));
+ };
+
+ /**
+ * The given entity will be checked by the validation code of the entity type.
+ *
+ * @param {binding.Entity} entity
+ * @returns {util.ValidationResult} result
+ */
+
+
+ EntityManager.prototype.validate = function validate(entity) {
+ var type = Metadata.get(entity).type;
+
+ var result = new util.ValidationResult();
+ for (var iter = type.attributes(), item; !(item = iter.next()).done;) {
+ var validate = new util.Validator(item.value.name, entity);
+ result.fields[validate.key] = validate;
+ }
+
+ var validationCode = type.validationCode;
+ if (validationCode) {
+ validationCode(result.fields);
+ }
+
+ return result;
+ };
+
+ /**
+ * Adds the given object id to the cacheWhiteList if needed.
+ * @param {string} objectId The id to add.
+ */
+
+
+ EntityManager.prototype.addToWhiteList = function addToWhiteList(objectId) {
+ if (!this.isCachingDisabled) {
+ if (this.bloomFilter.contains(objectId)) {
+ this.cacheWhiteList.add(objectId);
+ }
+ this.cacheBlackList.delete(objectId);
+ }
+ };
+
+ /**
+ * Adds the given object id to the cacheBlackList if needed.
+ * @param {string} objectId The id to add.
+ */
+
+
+ EntityManager.prototype.addToBlackList = function addToBlackList(objectId) {
+ if (!this.isCachingDisabled) {
+ if (!this.bloomFilter.contains(objectId)) {
+ this.cacheBlackList.add(objectId);
+ }
+ this.cacheWhiteList.delete(objectId);
+ }
+ };
+
+ EntityManager.prototype.refreshBloomFilter = function refreshBloomFilter() {
+ var _this21 = this;
+
+ if (this.isCachingDisabled) return Promise.resolve();
+
+ var msg = new message.GetBloomFilter();
+ return this.send(msg).then(function (response) {
+ _this21.updateBloomFilter(response.entity);
+ return _this21.bloomFilter;
+ });
+ };
+
+ EntityManager.prototype.updateBloomFilter = function updateBloomFilter(bloomFilter) {
+ this.bloomFilter = new BloomFilter(bloomFilter);
+ this.cacheWhiteList = new Set();
+ this.cacheBlackList = new Set();
+ };
+
+ /**
+ * Checks the freshness of the bloom filter and does a reload if necessary
+ */
+
+
+ EntityManager.prototype.ensureBloomFilterFreshness = function ensureBloomFilterFreshness() {
+ var _this22 = this;
+
+ if (this.isCachingDisabled) return;
+
+ var now = new Date().getTime();
+ var refreshRate = this.bloomFilterRefresh * 1000;
+
+ if (this._bloomFilterLock.isReady && now - this.bloomFilter.creation > refreshRate) {
+ this._bloomFilterLock.withLock(function () {
+ return _this22.refreshBloomFilter();
+ });
+ }
+ };
+
+ /**
+ * Checks for a given id, if revalidation is required, the resource is stale or caching was disabled
+ * @param {string} id The object id to check
+ * @returns {boolean} Indicates if the resource must be revalidated
+ */
+
+
+ EntityManager.prototype.mustRevalidate = function mustRevalidate(id) {
+ if (util.isNode) return false;
+
+ this.ensureBloomFilterFreshness();
+
+ var refresh = this.isCachingDisabled || !this._bloomFilterLock.isReady;
+ refresh = refresh || !this.cacheWhiteList.has(id) && (this.cacheBlackList.has(id) || this.bloomFilter.contains(id));
+ return refresh;
+ };
+
+ /**
+ *
+ * @param {string} id To check the bloom filter
+ * @param {connector.Message} message To attach the headers
+ * @param {boolean} refresh To force the reload headers
+ */
+
+
+ EntityManager.prototype.ensureCacheHeader = function ensureCacheHeader(id, message, refresh) {
+ refresh = refresh || this.mustRevalidate(id);
+
+ if (refresh) {
+ message.noCache();
+ }
+ };
+
+ /**
+ * Creates a absolute url for the given relative one
+ * @param {string} relativePath the relative url
+ * @param {boolean=} authorize indicates if authorization credentials should be generated and be attached to the url
+ * @return {string} a absolute url wich is optionaly signed with a resource token which authenticates the currently
+ * logged in user
+ */
+
+
+ EntityManager.prototype.createURL = function createURL(relativePath, authorize) {
+ var path = this._connector.basePath + relativePath;
+
+ var append = false;
+ if (authorize && this.me) {
+ path = this.tokenStorage.signPath(path);
+ append = true;
+ } else {
+ path = path.split('/').map(encodeURIComponent).join('/');
+ }
+
+ if (this.mustRevalidate(relativePath)) {
+ path = path + (append ? '&' : '?') + 'BCB';
+ }
+
+ return this._connector.origin + path;
+ };
+
+ return EntityManager;
+}(util.Lockable);
+
+/**
+ * Constructor for a new List collection
+ * @function
+ * @param {...*} args Same arguments can be passed as the Array constructor takes
+ * @return {void} The new created List
+ */
+
+
+EntityManager.prototype.List = Array;
+
+/**
+ * Constructor for a new Set collection
+ * @function
+ * @param {Iterable<*>=} collection The initial array or collection to initialize the new Set
+ * @return {void} The new created Set
+ */
+EntityManager.prototype.Set = Set;
+
+/**
+ * Constructor for a new Map collection
+ * @function
+ * @param {Iterable<*>=} collection The initial array or collection to initialize the new Map
+ * @return {void} The new created Map
+ */
+EntityManager.prototype.Map = Map;
+
+/**
+ * Constructor for a new GeoPoint
+ * @function
+ * @param {string|number|Object|Array} [latitude] A coordinate pair (latitude first), a GeoPoint like object or the GeoPoint's latitude
+ * @param {number=} longitude The GeoPoint's longitude
+ * @return {void} The new created GeoPoint
+ */
+EntityManager.prototype.GeoPoint = _dereq_(5);
+
+/**
+ * An User factory for user objects.
+ * The User factory can be called to create new instances of users or can be used to register/login/logout users.
+ * The created instances implements the {@link model.User} interface
+ * @name User
+ * @type binding.UserFactory
+ * @memberOf EntityManager.prototype
+ */
+
+/**
+ * An Role factory for role objects.
+ * The Role factory can be called to create new instances of roles, later on users can be attached to roles to manage the
+ * access permissions through this role
+ * The created instances implements the {@link model.Role} interface
+ * @name Role
+ * @memberOf EntityManager.prototype
+ * @type binding.EntityFactory
+ */
+
+/**
+ * An Device factory for user objects.
+ * The Device factory can be called to create new instances of devices or can be used to register, push to and
+ * check registration status of devices.
+ * @name Device
+ * @memberOf EntityManager.prototype
+ * @type binding.DeviceFactory
+ */
+
+/**
+ * An Object factory for entity or embedded objects,
+ * that can be accessed by the type name of the entity type.
+ * An object factory can be called to create new instances of the type.
+ * The created instances implements the {@link binding.Entity} or the {@link binding.Managed} interface
+ * whenever the class is an entity or embedded object
+ * @name [YourEntityClass: string]
+ * @memberOf EntityManager.prototype
+ * @type {*}
+ */
+
+/**
+ * A File factory for file objects.
+ * The file factory can be called to create new instances for files.
+ * The created instances implements the {@link binding.File} interface
+ * @name File
+ * @memberOf EntityManager.prototype
+ * @type binding.FileFactory
+ */
+
+module.exports = EntityManager;
+
+},{"19":19,"20":20,"21":21,"25":25,"34":34,"36":36,"4":4,"5":5,"59":59,"63":63,"70":70}],3:[function(_dereq_,module,exports){
+"use strict";
+
+var message = _dereq_(36);
+var metamodel = _dereq_(52);
+
+var util = _dereq_(70);
+var caching = _dereq_(22);
+var Connector = _dereq_(23);
+var EntityManager = _dereq_(2);
+
+/**
+ * @alias EntityManagerFactory
+ * @extends util.Lockable
+ */
+
+var EntityManagerFactory = function (_util$Lockable) {
+ babelHelpers.inherits(EntityManagerFactory, _util$Lockable);
+
+ EntityManagerFactory.prototype._connected = function _connected() {};
+
+ /**
+ * Creates a new EntityManagerFactory connected to the given destination
+ * @param {string|Object} [options] The destination to connect with, or an options object
+ * @param {string} [options.host] The destination to connect with
+ * @param {number} [options.port=80|443] The optional destination port to connect with
+ * @param {boolean} [options.secure=false] true To use a secure ssl encrypted connection
+ * @param {string} [options.basePath="/v1"] The base path of the api
+ * @param {Object} [options.schema=null] The serialized schema as json used to initialize the metamodel
+ * @param {util.TokenStorage} [options.tokenStorage] The tokenStorage which should be used by this emf
+ * @param {util.TokenStorageFactory} [options.tokenStorageFactory] The tokenStorage factory implementation which should
+ * be used for token storage
+ * @param {number} [options.staleness=60] The maximum staleness of objects that are acceptable while reading cached data
+ */
+
+
+ function EntityManagerFactory(options) {
+ babelHelpers.classCallCheck(this, EntityManagerFactory);
+
+ var _this = babelHelpers.possibleConstructorReturn(this, _util$Lockable.call(this));
+
+ options = Object(options) instanceof String ? { host: options } : options || {};
+
+ /** @type connector.Connector */
+ _this._connector = null;
+ /** @type metamodel.Metamodel */
+ _this.metamodel = _this.createMetamodel();
+ /** @type util.Code */
+ _this.code = new util.Code(_this.metamodel, _this);
+ /** @type util.TokenStorageFactory */
+ _this.tokenStorageFactory = util.TokenStorage.WEB_STORAGE || util.TokenStorage.GLOBAL;
+
+ _this.configure(options);
+
+ var isReady = true;
+ var ready = new Promise(function (success) {
+ _this._connected = success;
+ });
+
+ if (options.host) {
+ _this.connect(options.host, options.port, options.secure, options.basePath);
+ } else {
+ isReady = false;
+ }
+
+ if (!_this.tokenStorage) {
+ isReady = false;
+ ready = ready.then(function () {
+ return _this.tokenStorageFactory.create(_this._connector.origin);
+ }).then(function (tokenStorage) {
+ _this.tokenStorage = tokenStorage;
+ });
+ }
+
+ if (options.schema) {
+ _this._connectData = options;
+ _this.metamodel.init(options.schema);
+ } else {
+ isReady = false;
+ ready = ready.then(function () {
+ var msg = new message.Connect();
+ msg.withCredentials = true; //used for registered devices
+
+ if (_this.staleness === 0) msg.noCache();
+
+ return _this.send(msg);
+ }).then(function (response) {
+ _this._connectData = response.entity;
+
+ if (_this.staleness === undefined) {
+ _this.staleness = _this._connectData.bloomFilterRefresh || 60;
+ }
+
+ if (!_this.metamodel.isInitialized) _this.metamodel.init(_this._connectData.schema);
+
+ _this.tokenStorage.update(_this._connectData.token);
+ });
+ }
+
+ if (!isReady) {
+ _this.withLock(function () {
+ return ready;
+ }, true);
+ }
+ return _this;
+ }
+
+ /**
+ * Apply additional configurations to this EntityManagerFactory
+ * @param {Object} options The additional configuration options
+ * @param {util.TokenStorage} [options.tokenStorage] The tokenStorage which should be used by this emf
+ * @param {util.TokenStorageFactory} [options.tokenStorageFactory] The tokenStorage factory implementation which should
+ * be used for token storage
+ * @param {number} [options.staleness=60] The maximum staleness of objects that are acceptable while reading cached data,
+ * 0 to always bypass the browser cache
+ */
+
+
+ EntityManagerFactory.prototype.configure = function configure(options) {
+ if (this._connector) throw new Error('The EntityManagerFactory can only be configured before is is connected.');
+
+ if (options.tokenStorage) {
+ /** @type util.TokenStorage */
+ this.tokenStorage = options.tokenStorage;
+ }
+
+ if (options.tokenStorageFactory) {
+ this.tokenStorageFactory = options.tokenStorageFactory;
+ }
+
+ if (options.staleness !== undefined) {
+ /** @type number */
+ this.staleness = options.staleness;
+ }
+ };
+
+ /**
+ * Connects this EntityManager to the given destination
+ * @param {string} hostOrApp The host or the app name to connect with
+ * @param {number} [port=80|443] The port to connect to
+ * @param {boolean} [secure=false] true To use a secure connection
+ * @param {string} [basePath="/v1"] The base path of the api
+ */
+
+
+ EntityManagerFactory.prototype.connect = function connect(hostOrApp, port, secure, basePath) {
+ if (this._connector) throw new Error('The EntityManagerFactory is already connected.');
+
+ if (Object(port) instanceof Boolean) {
+ secure = port;
+ port = 0;
+ }
+
+ this._connector = Connector.create(hostOrApp, port, secure, basePath);
+
+ this._connected();
+ return this.ready();
+ };
+
+ /**
+ * Connects this EntityManager to the given destination
+ * @param {string} hostOrApp The host or the app name to connect with
+ * @param {boolean} [secure=false] true To use a secure connection
+ * @name connect
+ * @memberOf EntityManagerFactory.prototype
+ * @method
+ */
+
+ /**
+ * Creates a new Metamodel instance, which is not connected
+ * @return {metamodel.Metamodel} A new Metamodel instance
+ */
+
+
+ EntityManagerFactory.prototype.createMetamodel = function createMetamodel() {
+ return new metamodel.Metamodel(this);
+ };
+
+ /**
+ * Create a new application-managed EntityManager.
+ *
+ * @param {boolean=} useSharedTokenStorage The token storage to persist the authorization token, or
+ * true To use the shared token storage of the emf.
+ * false To use a instance based storage.
+ *
+ * @returns {EntityManager} a new entityManager
+ */
+
+
+ EntityManagerFactory.prototype.createEntityManager = function createEntityManager(useSharedTokenStorage) {
+ var _this2 = this;
+
+ var em = new EntityManager(this);
+
+ if (this.isReady) {
+ em.connected(this._connector, this._connectData, useSharedTokenStorage ? this.tokenStorage : new util.TokenStorage(this._connector.origin));
+ } else {
+ em.withLock(function () {
+ return _this2.ready().then(function () {
+ em.connected(_this2._connector, _this2._connectData, useSharedTokenStorage ? _this2.tokenStorage : new util.TokenStorage(_this2._connector.origin));
+ });
+ }, true);
+ }
+
+ return em;
+ };
+
+ EntityManagerFactory.prototype.send = function send(message) {
+ if (!message.tokenStorage) message.tokenStorage = this.tokenStorage;
+ return this._connector.send(message);
+ };
+
+ return EntityManagerFactory;
+}(util.Lockable);
+
+module.exports = EntityManagerFactory;
+
+},{"2":2,"22":22,"23":23,"36":36,"52":52,"70":70}],4:[function(_dereq_,module,exports){
+"use strict";
+
+var message = _dereq_(36);
+var error = _dereq_(34);
+
+/**
+ * @alias EntityTransaction
+ */
+
+var EntityTransaction = function () {
+ babelHelpers.createClass(EntityTransaction, [{
+ key: 'isActive',
+
+
+ /**
+ * Indicate whether a resource transaction is in progress.
+ * @returns {boolean} indicating whether transaction is in progress
+ */
+ get: function get() {
+ return Boolean(this.tid);
+ }
+
+ /**
+ * @param {EntityManager} entityManager
+ */
+
+ }]);
+
+ function EntityTransaction(entityManager) {
+ babelHelpers.classCallCheck(this, EntityTransaction);
+
+ this._connector = entityManager.connector;
+ this.entityManager = entityManager;
+
+ this.tid = null;
+ this.rollbackOnly = false;
+
+ this.readSet = null;
+ this.changeSet = null;
+ }
+
+ /**
+ * Start a resource transaction.
+ */
+
+
+ EntityTransaction.prototype.begin = function begin(doneCallback, failCallback) {
+ return this.yield().then(function () {
+ var result = this.send(new message.PostTransaction()).done(function (msg) {
+ this.tid = msg.tid;
+
+ this.rollbackOnly = false;
+ this.readSet = {};
+ this.changeSet = {};
+ });
+
+ return this.wait(result);
+ }).then(doneCallback, failCallback);
+ };
+
+ /**
+ * Commit the current resource transaction, writing any unflushed changes to the database.
+ */
+
+
+ EntityTransaction.prototype.commit = function commit(doneCallback, failCallback) {
+ return this.yield().then(function () {
+ if (this.getRollbackOnly()) {
+ return this.rollback().then(function () {
+ throw new error.RollbackError();
+ });
+ } else {
+ return this.wait(this.entityManager.flush()).then(function () {
+ var readSet = [];
+ for (var ref in this.readSet) {
+ readSet.push({
+ "oid": ref,
+ "version": this.readSet[ref]
+ });
+ }
+
+ var result = this.send(new message.PutTransactionCommitted(this.tid, readSet));
+
+ return this.wait(result).then(function (msg) {
+ this.tid = null;
+ this.readSet = null;
+ this.changeSet = null;
+
+ var oids = msg.oids;
+ for (var oid in oids) {
+ var version = oids[oid];
+ var entity = this.entityManager.entities[oid];
+
+ if (entity) {
+ var state = util.Metadata.get(entity);
+ if (version == 'DELETED' || state.isDeleted) {
+ this.entityManager.removeReference(entity);
+ } else {
+ state.setJsonValue(state.type.version, version);
+ }
+ }
+ }
+ });
+ });
+ }
+ }).then(doneCallback, failCallback);
+ };
+
+ /**
+ * Determine whether the current resource transaction has been marked for rollback.
+ * @returns {boolean} indicating whether the transaction has been marked for rollback
+ */
+
+
+ EntityTransaction.prototype.getRollbackOnly = function getRollbackOnly() {
+ return this.rollbackOnly;
+ };
+
+ /**
+ * Roll back the current resource transaction.
+ */
+
+
+ EntityTransaction.prototype.rollback = function rollback(doneCallback, failCallback) {
+ return this.yield().then(function () {
+ var result = this.send(new message.PutTransactionAborted(this.tid));
+
+ this.wait(result).then(function () {
+ this.tid = null;
+ this.readSet = null;
+ this.changeSet = null;
+ return this.entityManager.clear();
+ }, function () {
+ return this.entityManager.clear();
+ });
+ }).then(doneCallback, failCallback);
+ };
+
+ /**
+ * Mark the current resource transaction so that the only possible outcome of the transaction is for the transaction to be rolled back.
+ */
+
+
+ EntityTransaction.prototype.setRollbackOnly = function setRollbackOnly(context, onSuccess) {
+ return this.yield().done(function () {
+ this.rollbackOnly = true;
+ });
+ };
+
+ EntityTransaction.prototype.isRead = function isRead(identifier) {
+ return this.isActive && identifier in this.readSet;
+ };
+
+ EntityTransaction.prototype.setRead = function setRead(identifier, version) {
+ if (this.isActive && !this.isChanged(identifier)) {
+ this.readSet[identifier] = version;
+ }
+ };
+
+ EntityTransaction.prototype.isChanged = function isChanged(identifier) {
+ return this.isActive && identifier in this.changeSet;
+ };
+
+ EntityTransaction.prototype.setChanged = function setChanged(identifier) {
+ if (this.isActive) {
+ delete this.readSet[identifier];
+ this.changeSet[identifier] = true;
+ }
+ };
+
+ return EntityTransaction;
+}();
+
+module.exports = EntityTransaction;
+
+},{"34":34,"36":36}],5:[function(_dereq_,module,exports){
+"use strict";
+
+/**
+ * Creates a new GeoPoint instance
+ * From latitude and longitude
+ * From a json object
+ * Or an tuple of latitude and longitude
+ *
+ * @alias GeoPoint
+ */
+
+var GeoPoint = function () {
+
+ /**
+ * Creates a GeoPoint with the user's current location, if available.
+ * @return {Promise} A promise that will be resolved with a GeoPoint
+ */
+ GeoPoint.current = function current() {
+ return new Promise(function (resolve, reject) {
+ navigator.geolocation.getCurrentPosition(function (location) {
+ resolve(new GeoPoint(location.coords.latitude, location.coords.longitude));
+ }, function (error) {
+ reject(error);
+ });
+ });
+ };
+
+ /**
+ * @param {string|number|Object|Array} [latitude] A coordinate pair (latitude first), a GeoPoint like object or the GeoPoint's latitude
+ * @param {number=} longitude The GeoPoint's longitude
+ */
+
+
+ function GeoPoint(latitude, longitude) {
+ babelHelpers.classCallCheck(this, GeoPoint);
+
+ var lat = void 0,
+ lng = void 0;
+ if (Object(latitude) instanceof String) {
+ var index = latitude.indexOf(';');
+ lat = latitude.substring(0, index);
+ lng = latitude.substring(index + 1);
+ } else if (Object(latitude) instanceof Number) {
+ lat = latitude;
+ lng = longitude;
+ } else if (Object(latitude) instanceof Array) {
+ lat = latitude[0];
+ lng = latitude[1];
+ } else if (latitude instanceof Object) {
+ lat = latitude.latitude;
+ lng = latitude.longitude;
+ } else {
+ lat = 0;
+ lng = 0;
+ }
+
+ /**
+ * Longitude of the given point
+ * @type {number}
+ */
+ this.longitude = lng;
+
+ /**
+ * Latitude of the given point
+ * @type {number}
+ */
+ this.latitude = lat;
+
+ if (this.latitude < -90 || this.latitude > 90) {
+ throw new Error("Latitude " + this.latitude + " is not in bound of -90 <= latitude <= 90");
+ }
+
+ if (this.longitude < -180 || this.longitude > 180) {
+ throw new Error("Longitude " + this.longitude + " is not in bound of -180 <= longitude <= 180");
+ }
+ }
+
+ /**
+ * Returns the distance from this GeoPoint to another in kilometers.
+ * @param {GeoPoint} point another GeoPoint
+ * @return {number} The distance in kilometers
+ *
+ * @see GeoPoint#radiansTo
+ */
+
+
+ GeoPoint.prototype.kilometersTo = function kilometersTo(point) {
+ return Number((GeoPoint.EARTH_RADIUS_IN_KILOMETERS * this.radiansTo(point)).toFixed(3));
+ };
+
+ /**
+ * Returns the distance from this GeoPoint to another in miles.
+ * @param {GeoPoint} point another GeoPoint
+ * @return {number} The distance in miles
+ *
+ * @see GeoPoint#radiansTo
+ */
+
+
+ GeoPoint.prototype.milesTo = function milesTo(point) {
+ return Number((GeoPoint.EARTH_RADIUS_IN_MILES * this.radiansTo(point)).toFixed(3));
+ };
+
+ /**
+ * Computes the arc, in radian, between two WGS-84 positions.
+ *
+ * The haversine formula implementation is taken from:
+ * {@link http://www.movable-type.co.uk/scripts/latlong.html}
+ *
+ * Returns the distance from this GeoPoint to another in radians.
+ * @param {GeoPoint} point another GeoPoint
+ * @return {number} the arc, in radian, between two WGS-84 positions
+ *
+ * @see http://en.wikipedia.org/wiki/Haversine_formula
+ */
+
+
+ GeoPoint.prototype.radiansTo = function radiansTo(point) {
+ var from = this,
+ to = point;
+ var rad1 = from.latitude * GeoPoint.DEG_TO_RAD,
+ rad2 = to.latitude * GeoPoint.DEG_TO_RAD,
+ dLng = (to.longitude - from.longitude) * GeoPoint.DEG_TO_RAD;
+
+ return Math.acos(Math.sin(rad1) * Math.sin(rad2) + Math.cos(rad1) * Math.cos(rad2) * Math.cos(dLng));
+ };
+
+ /**
+ * A String representation in latitude, longitude format
+ * @return {string} The string representation of this class
+ */
+
+
+ GeoPoint.prototype.toString = function toString() {
+ return this.latitude + ';' + this.longitude;
+ };
+
+ /**
+ * Returns a JSON representation of the GeoPoint
+ * @return {json} A GeoJson object of this GeoPoint
+ */
+
+
+ GeoPoint.prototype.toJSON = function toJSON() {
+ return { latitude: this.latitude, longitude: this.longitude };
+ };
+
+ return GeoPoint;
+}();
+
+GeoPoint.DEG_TO_RAD = Math.PI / 180;
+
+/**
+ * The Earth radius in kilometers used by {@link GeoPoint#kilometersTo}
+ * @type {number}
+ */
+GeoPoint.EARTH_RADIUS_IN_KILOMETERS = 6371;
+
+/**
+ * The Earth radius in miles used by {@link GeoPoint#milesTo}
+ * @type {number}
+ */
+GeoPoint.EARTH_RADIUS_IN_MILES = 3956;
+
+module.exports = GeoPoint;
+
+},{}],6:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * @interface baqend
+ * @extends EntityManager
+ */
+var EntityManagerFactory = _dereq_(3);
+var EntityManager = _dereq_(2);
+
+EntityManager.prototype.binding = _dereq_(20);
+EntityManager.prototype.connector = _dereq_(28);
+EntityManager.prototype.error = _dereq_(34);
+EntityManager.prototype.message = _dereq_(36);
+EntityManager.prototype.metamodel = _dereq_(52);
+EntityManager.prototype.util = _dereq_(70);
+EntityManager.prototype.caching = _dereq_(22);
+EntityManager.prototype.query = _dereq_(59);
+
+EntityManager.prototype.EntityManager = _dereq_(2);
+EntityManager.prototype.EntityManagerFactory = _dereq_(3);
+EntityManager.prototype.EntityTransaction = _dereq_(4);
+EntityManager.prototype.Acl = _dereq_(1);
+
+var emf = new EntityManagerFactory();
+var db = emf.createEntityManager(true);
+
+/**
+ * Configures the DB with additional config options
+ * @param {Object} options The additional configuration options
+ * @param {util.TokenStorage} [options.tokenStorage] The tokenStorage which should be used by this emf
+ * @param {util.TokenStorageFactory} [options.tokenStorageFactory] The tokenStorage factory implementation which should
+ * be used for token storage
+ * @param {number} [options.staleness=60] The maximum staleness of objects that are acceptable while reading cached data,
+ * 0 to always bypass the browser cache
+ * @function
+ * @return {baqend}
+ * @alias baqend#configure
+ */
+db.configure = function (options) {
+ emf.configure(options);
+ return this;
+};
+
+/**
+ * Connects the DB with the server and calls the callback on success
+ * @param {string} hostOrApp The host or the app name to connect with
+ * @param {boolean} [secure=false] true To use a secure connection
+ * @param {util.Lockable~callback=} doneCallback The callback, called when a connection is established and the
+ * SDK is ready to use
+ * @param {util.Lockable~callback=} failCallback When an error occurred while initializing the SDK
+ * @function
+ * @return {Promise}
+ * @alias baqend#connect
+ */
+db.connect = function (hostOrApp, secure, doneCallback, failCallback) {
+ if (secure instanceof Function) {
+ failCallback = doneCallback;
+ doneCallback = secure;
+ secure = undefined;
+ }
+
+ emf.connect(hostOrApp, secure);
+ return this.ready(doneCallback, failCallback);
+};
+
+exports = module.exports = db;
+//import {db} from 'baqend';
+exports.db = db;
+//import db from 'baqend';
+exports.default = db;
+
+},{"1":1,"2":2,"20":20,"22":22,"28":28,"3":3,"34":34,"36":36,"4":4,"52":52,"59":59,"70":70}],7:[function(_dereq_,module,exports){
+"use strict";
+
+/**
+ * @alias binding.Accessor
+ */
+
+var Accessor = function () {
+ function Accessor() {
+ babelHelpers.classCallCheck(this, Accessor);
+ }
+
+ /**
+ * @param {Object} object
+ * @param {metamodel.Attribute} attribute
+ * @returns {*}
+ */
+ Accessor.prototype.getValue = function getValue(object, attribute) {
+ return object[attribute.name];
+ };
+
+ /**
+ * @param {Object} object
+ * @param {metamodel.Attribute} attribute
+ * @param {*} value
+ */
+
+
+ Accessor.prototype.setValue = function setValue(object, attribute, value) {
+ object[attribute.name] = value;
+ };
+
+ return Accessor;
+}();
+
+module.exports = Accessor;
+
+},{}],8:[function(_dereq_,module,exports){
+"use strict";
+
+var EntityFactory = _dereq_(11);
+
+/**
+ * @class binding.DeviceFactory
+ * @extends binding.EntityFactory
+ *
+ * @param {Object=} properties initial properties to set on the instance
+ * @param {...*} arguments Additional constructor params passed through the type constructor
+ * @return {model.Device} The new managed instance
+ */
+var DeviceFactory = EntityFactory.extend( /** @lends binding.DeviceFactory.prototype */{
+
+ /**
+ * Returns true if the devices is already registered, otherwise false.
+ * @returns {boolean} Status of the device registration
+ */
+ get isRegistered() {
+ return this._db.isDeviceRegistered;
+ },
+
+ /**
+ * Register a new device with the given device token and OS.
+ * @param {string} os The OS of the device (IOS/Android)
+ * @param {string} token The GCM or APNS device token
+ * @param {model.Device=} device A optional device entity to set custom field values
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise}
+ */
+ register: function register(os, token, device, doneCallback, failCallback) {
+ if (device instanceof Function) {
+ failCallback = doneCallback;
+ doneCallback = device;
+ device = null;
+ }
+
+ return this._db.registerDevice(os, token, device).then(doneCallback, failCallback);
+ },
+
+
+ /**
+ * Uses the info from the given {util.PushMessage} message to send an push notification.
+ * @param {util.PushMessage} pushMessage to send an push notification.
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise}
+ */
+ push: function push(pushMessage, doneCallback, failCallback) {
+ return this._db.pushDevice(pushMessage).then(doneCallback, failCallback);
+ }
+});
+
+DeviceFactory.PushMessage = _dereq_(66);
+
+module.exports = DeviceFactory;
+
+},{"11":11,"66":66}],9:[function(_dereq_,module,exports){
+"use strict";
+
+var Metadata = _dereq_(63);
+var Lockable = _dereq_(61);
+
+/**
+ * @alias binding.Enhancer
+ */
+
+var Enhancer = function () {
+ function Enhancer() {
+ babelHelpers.classCallCheck(this, Enhancer);
+ }
+
+ /**
+ * @param {Class<*>} superClass
+ * @returns {Class<*>} typeConstructor
+ */
+ Enhancer.prototype.createProxy = function createProxy(superClass) {
+ return function (_superClass) {
+ babelHelpers.inherits(Proxy, _superClass);
+
+ function Proxy() {
+ babelHelpers.classCallCheck(this, Proxy);
+ return babelHelpers.possibleConstructorReturn(this, _superClass.apply(this, arguments));
+ }
+
+ return Proxy;
+ }(superClass);
+ };
+
+ /**
+ * @param {Class<*>} typeConstructor
+ * @returns {string}
+ */
+
+
+ Enhancer.prototype.getIdentifier = function getIdentifier(typeConstructor) {
+ return typeConstructor.__d__;
+ };
+
+ /**
+ * @param {Class<*>} typeConstructor
+ * @param {string} identifier
+ */
+
+
+ Enhancer.prototype.setIdentifier = function setIdentifier(typeConstructor, identifier) {
+ Object.defineProperty(typeConstructor, '__d__', {
+ value: identifier
+ });
+ };
+
+ /**
+ * @param {metamodel.ManagedType} type
+ * @param {Class<*>} typeConstructor
+ */
+
+
+ Enhancer.prototype.enhance = function enhance(type, typeConstructor) {
+ if (typeConstructor.__ype__ == type) return;
+
+ if (typeConstructor.hasOwnProperty('__ype__')) throw new Error('Type is already used by a different manager');
+
+ Object.defineProperty(typeConstructor, '__ype__', {
+ value: type
+ });
+
+ this.setIdentifier(typeConstructor, type.ref);
+ this.enhancePrototype(typeConstructor.prototype, type);
+ };
+
+ /**
+ * Enhance the prototype of the type
+ * @param {Object} proto
+ * @param {metamodel.ManagedType} type
+ */
+
+
+ Enhancer.prototype.enhancePrototype = function enhancePrototype(proto, type) {
+ if (proto.toString === Object.prototype.toString) {
+ // implements a better convenience toString method
+ Object.defineProperty(proto, 'toString', {
+ value: function toString() {
+ return this._metadata.id || this._metadata.bucket;
+ },
+ enumerable: false
+ });
+ }
+
+ // enhance all persistent object properties
+ if (type.superType && type.superType.name == 'Object') {
+ for (var _iterator = type.superType.declaredAttributes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var attr = _ref;
+
+ if (!attr.isMetadata) this.enhanceProperty(proto, attr);
+ }
+ }
+
+ // enhance all persistent properties
+ for (var _iterator2 = type.declaredAttributes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+ var _ref2;
+
+ if (_isArray2) {
+ if (_i2 >= _iterator2.length) break;
+ _ref2 = _iterator2[_i2++];
+ } else {
+ _i2 = _iterator2.next();
+ if (_i2.done) break;
+ _ref2 = _i2.value;
+ }
+
+ var _attr = _ref2;
+
+ this.enhanceProperty(proto, _attr);
+ }
+ };
+
+ /**
+ * @param {Object} proto
+ * @param {metamodel.Attribute} attribute
+ */
+
+
+ Enhancer.prototype.enhanceProperty = function enhanceProperty(proto, attribute) {
+ var name = '$' + attribute.name;
+ Object.defineProperty(proto, attribute.name, {
+ get: function get() {
+ var metadata = this._metadata;
+ metadata.readAccess();
+ return metadata[name];
+ },
+ set: function set(value) {
+ var metadata = this._metadata;
+ metadata.writeAccess();
+ metadata[name] = value;
+ },
+
+ configurable: true,
+ enumerable: true
+ });
+ };
+
+ return Enhancer;
+}();
+
+module.exports = Enhancer;
+
+},{"61":61,"63":63}],10:[function(_dereq_,module,exports){
+"use strict";
+
+var Managed = _dereq_(15);
+
+/**
+ * @alias binding.Entity
+ * @extends binding.Managed
+ */
+
+var Entity = function (_Managed) {
+ babelHelpers.inherits(Entity, _Managed);
+
+ /**
+ * The default constructor, copy all given properties to this object
+ * @param {Object=} properties - The optional properties to copy
+ */
+ function Entity(properties) {
+ babelHelpers.classCallCheck(this, Entity);
+ return babelHelpers.possibleConstructorReturn(this, _Managed.call(this, properties));
+ }
+
+ return Entity;
+}(Managed);
+
+Object.defineProperties(Entity.prototype, /** @lends binding.Entity.prototype */{
+ /**
+ * The unique id of this object
+ *
+ * Sets the unique id of this object, if the id is not formatted as an valid id,
+ * it will be used as the key component of the id has the same affect as setting the key
+ *
+ * @type string
+ */
+ id: {
+ get: function get() {
+ return this._metadata.id;
+ },
+ set: function set(value) {
+ if (this._metadata.id) throw new Error('The id can\'t be set twice: ' + value);
+
+ value += '';
+ if (value.indexOf('/db/' + this._metadata.bucket + '/') == 0) {
+ this._metadata.id = value;
+ } else {
+ this.key = value;
+ }
+ },
+
+ enumerable: true
+ },
+
+ /**
+ * The unique key part of the id
+ * When the key of the unique id is set an error will be thrown if an id is already set.
+ * @type string
+ */
+ key: {
+ get: function get() {
+ return this._metadata.key;
+ },
+ set: function set(value) {
+ this._metadata.key = value;
+ }
+ },
+
+ /**
+ * The version of this object
+ * @type number
+ */
+ version: {
+ get: function get() {
+ return this._metadata.version;
+ },
+
+ enumerable: true
+ },
+
+ /**
+ * The object read/write permissions
+ * @type Acl
+ */
+ acl: {
+ get: function get() {
+ return this._metadata.acl;
+ },
+
+ enumerable: true
+ },
+
+ /**
+ * Waits on the previously requested operation and calls the doneCallback if the operation is fulfilled
+ * @param {util.Lockable~callback=} doneCallback The callback which will be invoked when the previously
+ * operations on this object is completed.
+ * @return {Promise} A promise which completes successfully, when the previously requested
+ * operation completes
+ * @method
+ */
+ ready: {
+ value: function ready(doneCallback) {
+ return this._metadata.ready(doneCallback);
+ }
+ },
+
+ /**
+ * Attach this object to the given db
+ * @param {EntityManager} db The db which will be used for future crud operations
+ * @method
+ */
+ attach: {
+ value: function attach(db) {
+ db.attach(this);
+ }
+ },
+
+ /**
+ * Saves the object. Inserts the object if it doesn't exists and updates the object if the object exist.
+ * @param {Object} [options] The save options
+ * @param {boolean} [options.force=false] Force the save operation, the version will not be validated.
+ * @param {number|boolean} [options.depth=0] The object depth which will be saved. Depth 0 save this object only,
+ * true saves the objects by reachability.
+ * @param {boolean} [options.refresh=false] Refresh the local object state from remote.
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise} A Promise that will be fulfilled when the asynchronous operation completes.
+ * @method
+ */
+ save: {
+ value: function save(options, doneCallback, failCallback) {
+ if (options instanceof Function) {
+ failCallback = doneCallback;
+ doneCallback = options;
+ options = {};
+ }
+
+ return this._metadata.db.save(this, options).then(doneCallback, failCallback);
+ }
+ },
+
+ /**
+ * Inserts a new object. Inserts the object if it doesn't exists and raise an error if the object already exist.
+ * @param {Object} [options] The insertion options
+ * @param {number|boolean} [options.depth=0] The object depth which will be inserted. Depth 0 insert this object only,
+ * true inserts objects by reachability.
+ * @param {boolean} [options.refresh=false] Refresh the local object state from remote.
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise} A Promise that will be fulfilled when the asynchronous operation completes.
+ * @method
+ */
+ insert: {
+ value: function insert(options, doneCallback, failCallback) {
+ if (options instanceof Function) {
+ failCallback = doneCallback;
+ doneCallback = options;
+ options = {};
+ }
+
+ return this._metadata.db.insert(this, options).then(doneCallback, failCallback);
+ }
+ },
+
+ /**
+ * Updates an existing object.
+ * Updates the object if it exists and raise an error if the object doesn't exist.
+ * @param {Object} [options] The update options
+ * @param {boolean} [options.force=false] Force the update operation, the version will not be validated, only existence will be checked.
+ * @param {number|boolean} [options.depth=0] The object depth which will be updated. Depth 0 updates this object only,
+ * true updates objects by reachability.
+ * @param {boolean} [options.refresh=false] Refresh the local object state from remote.
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise} A Promise that will be fulfilled when the asynchronous operation completes.
+ * @method
+ */
+ update: {
+ value: function update(options, doneCallback, failCallback) {
+ if (options instanceof Function) {
+ failCallback = doneCallback;
+ doneCallback = options;
+ options = {};
+ }
+
+ return this._metadata.db.update(this, options).then(doneCallback, failCallback);
+ }
+ },
+
+ /**
+ * Resolves the referenced object in the specified depth. Only unresolved objects will be loaded unless the refresh option is specified.
+ * Removed objects will be marked as removed.
+ * @param {Object} [options] The load options
+ * @param {number|boolean} [options.depth=0] The object depth which will be loaded. Depth set to true
+ * loads objects by reachability.
+ * @param {boolean} [options.refresh=false] Refresh the local object state from remote.
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise} A Promise that will be fulfilled when the asynchronous operation completes.
+ * @method
+ */
+ load: {
+ value: function load(options, doneCallback, failCallback) {
+ if (options instanceof Function) {
+ failCallback = doneCallback;
+ doneCallback = options;
+ options = {};
+ }
+ options = options || {};
+ options.local = true;
+
+ return this._metadata.db.load(this.id, null, options).then(doneCallback, failCallback);
+ }
+ },
+
+ /**
+ * Delete an existing object.
+ * @param {Object} [options] The remove options
+ * @param {boolean} [options.force=false] Force the remove operation, the version will not be validated.
+ * @param {number|boolean} [options.depth=0] The object depth which will be removed. Depth 0 removes this object only,
+ * true removes objects by reachability.
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise} A Promise that will be fulfilled when the asynchronous operation completes.
+ * @method
+ */
+ 'delete': {
+ value: function value(options, doneCallback, failCallback) {
+ if (options instanceof Function) {
+ failCallback = doneCallback;
+ doneCallback = options;
+ options = {};
+ }
+
+ return this._metadata.db.delete(this, options).then(doneCallback, failCallback);
+ }
+ },
+
+ /**
+ * Saves the object and repeats the operation if the object is out of date.
+ * In each pass the callback will be called. Ths first parameter of the callback is the entity and the second one
+ * is a function to abort the process.
+ *
+ * @param {Function} cb Will be called in each pass
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise} A Promise that will be fulfilled when the asynchronous operation completes.
+ * @method
+ */
+ optimisticSave: {
+ value: function optimisticSave(cb, doneCallback, failCallback) {
+ return this._metadata.db.optimisticSave(this, cb).then(doneCallback, failCallback);
+ }
+ },
+
+ attr: {
+ value: function attr() {
+ throw new Error("Attr is not yet implemented.");
+ }
+ },
+
+ /**
+ * Validates the entity by using the validation code of the entity type
+ *
+ * @returns {util.ValidationResult} Contains the result of the Validation
+ * @method
+ */
+ validate: {
+ value: function validate() {
+ return this._metadata.db.validate(this);
+ }
+ },
+
+ /**
+ * Converts the entity to an JSON-Object.
+ * @param {boolean=} excludeMetadata Indicates if the metadata i.e. id, version and acls should not be included into the json
+ * @return {json} JSON-Object
+ * @method
+ */
+ toJSON: {
+ value: function toJSON(excludeMetadata) {
+ return this._metadata.getJson(excludeMetadata);
+ }
+ }
+});
+
+module.exports = Entity;
+
+/**
+ * The done callback is called, when the asynchronous operation completes successfully
+ * @callback binding.Entity~doneCallback
+ * @param {binding.Entity} entity This entity
+ * @return {Promise<*>|*} A Promise, result or undefined
+ */
+
+/**
+ * The fail callback is called, when the asynchronous operation is rejected by an error
+ * @callback binding.Entity~failCallback
+ * @param {error.PersistentError} error The error which reject the operation
+ * @return {Promise<*>|*} A Promise, result or undefined
+ */
+
+},{"15":15}],11:[function(_dereq_,module,exports){
+"use strict";
+
+var ManagedFactory = _dereq_(16);
+
+/**
+ * @class binding.EntityFactory
+ * @extends binding.ManagedFactory
+ *
+ * @param {Object=} properties initial properties to set on the instance
+ * @param {...*} arguments Additional constructor params passed through the type constructor
+ * @return {T} The new managed instance
+ */
+var EntityFactory = ManagedFactory.extend( /** @lends binding.EntityFactory.prototype */{
+ /**
+ * Loads the instance for the given id, or null if the id does not exists.
+ * @param {string} id The id to query
+ * @param {Object} [options] The load options
+ * @param {number|boolean} [options.depth=0] The object depth which will be saved. Depth 0 saves only this object,
+ * true saves the objects by reachability.
+ * @param {boolean} [options.refresh=false] Indicates whether the object should be revalidated (cache bypass).
+ * @param {boolean} [options.local=false] Indicates whether the local copy (from the entity manager)
+ * of an object should be returned if it exists. This value might be stale.
+ * @param {binding.EntityFactory~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.EntityFactory~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise} A Promise that will be fulfilled when the asynchronous operation completes.
+ */
+ load: function load(id, options, doneCallback, failCallback) {
+ if (options instanceof Function) {
+ failCallback = doneCallback;
+ doneCallback = options;
+ options = {};
+ }
+
+ return this._db.load(this._managedType.typeConstructor, id, options).then(doneCallback, failCallback);
+ },
+
+
+ /**
+ * Creates a new instance and sets the DatabaseObject to the given json
+ * @param {json} json
+ * @returns {T} instance
+ */
+ fromJSON: function fromJSON(json) {
+ var instance = json.id ? this._db.getReference(this._managedType.typeConstructor, json.id) : this.newInstance();
+ var metadata = instance._metadata;
+ metadata.setJson(json);
+ metadata.setDirty();
+ return instance;
+ },
+
+
+ /**
+ * Creates a new query for this class
+ * @return {query.Builder} The query builder
+ */
+ find: function find() {
+ return this._db.createQueryBuilder(this._managedType.typeConstructor);
+ },
+ partialUpdate: function partialUpdate() {
+ throw new Error("partialUpdate is not yet implemented.");
+ }
+
+ /**
+ * Creates a new instance of the of this type
+ * @function
+ * @name new
+ * @param {Object} properties Additional properties which will be applied to the created instance
+ * @return {binding.Entity} A new created instance of this class
+ * @memberOf binding.EntityFactory.prototype
+ */
+
+});
+
+module.exports = EntityFactory;
+
+/**
+ * The entity callback is called, when the asynchronous operation completes successfully
+ * @callback binding.EntityFactory~doneCallback
+ * @param {T} entity The entity
+ * @return {Promise<*>|*} A Promise or result
+ */
+
+/**
+ * The fail callback is called, when the asynchronous operation is rejected by an error
+ * @callback binding.EntityFactory~failCallback
+ * @param {error.PersistentError} error The error which reject the operation
+ * @return {Promise<*>|*} A Promise or result
+ */
+
+},{"16":16}],12:[function(_dereq_,module,exports){
+"use strict";
+
+/**
+ * This factory creates instances of type T, by invoking the {@link #new()} method or by instanciating this factory directly
+ * @class binding.Factory
+ *
+ * @param {...any} args constructor params passed to the type constructor
+ * @return {T} The new instance
+ */
+
+var Factory = _extend( /** @lends binding.Factory.prototype */{
+
+ /**
+ * Creates a child factory of this factory
+ * @param {Object} factoryMembers additional members applied to the child factory
+ * @returns {Object} The new created child Factory
+ * @static
+ * @ignore
+ */
+ extend: function extend(factoryMembers) {
+ //copy all factory members to the child factory
+ return _extend({}, this, factoryMembers);
+ },
+
+
+ /**
+ * Creates a new Factory for the given type
+ * @param {Class<*>} type the type constructor of T
+ * @return {binding.Factory} A new object factory to created instances of T
+ * @static
+ * @ignore
+ */
+ create: function create(type) {
+ var factory = function Factory(properties) {
+ return factory.newInstance(arguments);
+ };
+
+ _extend(factory, this);
+
+ //lets instanceof work properly
+ factory.prototype = type.prototype;
+ factory._type = type;
+
+ return factory;
+ },
+
+
+ /**
+ * Creates a new instance of the factory type
+ * @param {...any} args Constructor arguments used for instantiation
+ * @return {*} A new created instance of *
+ * @instance
+ */
+ new: function _new() {
+ return this.newInstance(arguments);
+ },
+
+
+ /**
+ * Creates a new instance of the factory type
+ * @param {Array<*>=} a Constructor arguments used for instantiation
+ * @return {*} A new created instance of *
+ * @instance
+ */
+ newInstance: function newInstance(a) {
+ var instance;
+ if (!a || a.length == 0) {
+ instance = new this._type();
+ } else {
+ //es6 constructors can't be called, therfore we must provide all arguments separately
+ //TODO: uggly! replace this with the spread operator if node support it
+ instance = new this._type(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9]);
+ }
+
+ return instance;
+ }
+});
+
+function _extend(target) {
+ for (var i = 1, source; source = arguments[i]; ++i) {
+ for (var _iterator = Object.getOwnPropertyNames(source), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var prop = _ref;
+
+ Object.defineProperty(target, prop, Object.getOwnPropertyDescriptor(source, prop));
+ }
+ }return target;
+}
+
+module.exports = Factory;
+
+},{}],13:[function(_dereq_,module,exports){
+"use strict";
+
+var error = _dereq_(34);
+var Acl = _dereq_(1);
+var util = _dereq_(71);
+var message = _dereq_(36);
+var StatusCode = _dereq_(25).StatusCode;
+
+var PREFIX = '/file';
+var LEN = PREFIX.length;
+
+/**
+ * Creates a file object, which represents one specific file reference.
+ * This File object can afterwards be used to up- and download the file contents or to retrieves and change the files
+ * metadata.
+ *
+ * The file data can be uploaded and downloaded as:
+ *
+ *
+ *
+ * type
+ * JavaScript type
+ * Description
+ *
+ *
+ * 'arraybuffer'
+ * ArrayBuffer
+ * The content is represented as a fixed-length raw binary data buffer
+ *
+ *
+ * 'blob'
+ * Blob
+ * The content is represented as a simple blob
+ *
+ *
+ * 'json'
+ * object|array|string
+ * The file content is represented as json
+ *
+ *
+ * 'text'
+ * string
+ * The file content is represented through the string
+ *
+ *
+ * 'base64'
+ * string
+ * The file content as base64 encoded string
+ *
+ *
+ * 'data-url'
+ * string
+ * A data url which represents the file content
+ *
+ *
+ *
+ *
+ * @alias binding.File
+ */
+
+var File = function () {
+ babelHelpers.createClass(File, [{
+ key: 'id',
+
+
+ /**
+ * The complete id of the file, including folder and name
+ * @type string
+ */
+ get: function get() {
+ return this._id;
+ }
+
+ /**
+ * The fully url to the file, can be directly used to link the file, i.e. in link tags ot image sources
+ * @type string
+ */
+
+ }, {
+ key: 'url',
+ get: function get() {
+ if (this.isFolder) {
+ throw new Error("Url can not be created for folders.");
+ }
+ if (!this._url) {
+ this._url = this._db.createURL(this.id, this.bucket != 'www');
+ }
+ return this._url;
+ }
+
+ /**
+ * The name of the file
+ * @type string
+ */
+
+ }, {
+ key: 'name',
+ get: function get() {
+ if (!this._name) this._name = this._id.substring(this._id.lastIndexOf('/', this._id.length - 2) + 1);
+ return this._name;
+ }
+
+ /**
+ * The mimeType of the file, only accessible after fetching the metadata or downloading/uploading/providing the file
+ * @type string
+ */
+
+ }, {
+ key: 'mimeType',
+ get: function get() {
+ if (this.isFolder) {
+ throw new Error("A folder has no mimeType");
+ }
+ this._checkAvailable();
+ return this._mimeType;
+ }
+
+ /**
+ * The current file acl, only accessible after fetching the metadata or downloading/uploading/providing the file
+ * @type string
+ */
+
+ }, {
+ key: 'acl',
+ get: function get() {
+ this._checkAvailable();
+ return this._acl;
+ }
+
+ /**
+ * The last modified date of the file, only accessible after fetching the metadata or downloading/uploading/providing the eTag
+ * @type string
+ */
+
+ }, {
+ key: 'lastModified',
+ get: function get() {
+ if (this.isFolder) {
+ throw new Error("A folder has no lastModified");
+ }
+ this._checkAvailable();
+ return this._lastModified;
+ }
+
+ /**
+ * The eTag of the file, only accessible after fetching the metadata or downloading/uploading/providing the file
+ * @type string
+ */
+
+ }, {
+ key: 'eTag',
+ get: function get() {
+ if (this.isFolder) {
+ throw new Error("A folder has no eTag");
+ }
+ this._checkAvailable();
+ return this._eTag;
+ }
+
+ /**
+ * The size of the file, only accessible after fetching the metadata or downloading/uploading/providing the file
+ * @type string
+ */
+
+ }, {
+ key: 'size',
+ get: function get() {
+ if (this.isFolder) {
+ throw new Error("A folder has no size");
+ }
+ this._checkAvailable();
+ return this._size;
+ }
+ }, {
+ key: 'bucket',
+ get: function get() {
+ return this.id.substring(LEN + 1, this.id.indexOf('/', LEN + 1));
+ }
+ }, {
+ key: 'key',
+ get: function get() {
+ return this.id.substring(this.id.indexOf('/', LEN + 1) + 1);
+ }
+
+ /**
+ * The full path of the file.
+ * @type string
+ */
+
+ }, {
+ key: 'path',
+ get: function get() {
+ return this.id.substring(LEN);
+ }
+
+ /**
+ * The parent folder of the file.
+ * @type string
+ */
+
+ }, {
+ key: 'parent',
+ get: function get() {
+ return this.id.substring(LEN, this.id.lastIndexOf('/', this.id.length - 2));
+ }
+
+ /**
+ * Indicates if the metadata are loaded.
+ * @type boolean
+ */
+
+ }, {
+ key: 'isMetadataLoaded',
+ get: function get() {
+ return this._available;
+ }
+
+ /**
+ * Creates a new file object which represents the a file at the given id. Data are provided to the constructor will
+ * be uploaded by invoking {@link upload()}
+ * @param {object|string} fileOptions The fileOptions used to create a new file object, or just the id of the
+ * file object
+ * @param {string=} fileOptions.id The id of the file.
+ * @param {string=} fileOptions.name The filename without the id. If omitted and data is provided as a file object, the
+ * {@link File#name} will be used otherwise a uuid will be generated.
+ * @param {string} [fileOptions.parent="/www"] The parent folder which contains the file
+ * @param {string} [fileOptions.path="/www"] The full path of the file. You might either specifiy the path of the file or a combination of parent and file name.
+ * @param {string|Blob|File|ArrayBuffer|json=} fileOptions.data The initial file content, which will be uploaded by
+ * invoking {@link #upload} later on.
+ * @param {string=} fileOptions.type A optional type hint used to correctly interpret the provided data
+ * @param {string=} fileOptions.mimeType The mimType of the file. Defaults to the mimeType of the provided data if
+ * it is a file object, blob or data-url
+ * @param {string=} fileOptions.eTag The optional current ETag of the file
+ * @param {string=} fileOptions.lastModified The optional last modified date
+ * @param {Acl=} fileOptions.acl The file acl which will be set, if the file is uploaded afterwards
+ */
+
+ }]);
+
+ function File(fileOptions) {
+ babelHelpers.classCallCheck(this, File);
+
+ fileOptions = fileOptions || {};
+
+ this._available = false;
+
+ if (Object(fileOptions) instanceof String) {
+ var id = fileOptions;
+ var nameSeparator = id.indexOf('/', '/file/'.length);
+ if (nameSeparator == -1 || id.indexOf('/file/') != 0) {
+ throw new Error('Invalid file reference ' + id);
+ }
+
+ this._id = id;
+ } else if (fileOptions.id) {
+ this._id = fileOptions.id;
+ this._setMetadata(fileOptions);
+ } else {
+ var path = void 0;
+ if (fileOptions.path) {
+ path = fileOptions.path;
+ } else {
+ var parent = fileOptions.parent || '/www';
+ if (parent.charAt(parent.length - 1) != '/') parent = parent + '/';
+
+ if (parent.length < 3) {
+ throw new Error('Invalid parent name: ' + parent);
+ }
+
+ var name = fileOptions.name || fileOptions.data && fileOptions.data.name || util.uuid();
+ path = parent + name;
+ }
+
+ if (path.charAt(0) != '/') path = '/' + path;
+
+ if (path.indexOf('//') != -1 || path.length < 3) throw new Error('Invalid path: ' + path);
+
+ this._id = PREFIX + path;
+ this._setMetadata(fileOptions);
+ }
+
+ /**
+ * Specifies whether this file is a folder.
+ * @type {boolean}
+ */
+ this.isFolder = this._id.charAt(this._id.length - 1) == '/';
+ }
+
+ /**
+ * Uploads the file content which was provided in the constructor or by uploadOptions.data
+ * @param {object=} uploadOptions The upload options
+ * @param {string|Blob|File|ArrayBuffer|json=} uploadOptions.data The initial file content, which will be uploaded by
+ * invoking {@link #upload} later on.
+ * @param {string=} uploadOptions.type A optional type hint used to correctly interpret the provided data
+ * @param {string=} uploadOptions.mimeType The mimType of the file. Defaults to the mimeType of the provided data if
+ * it is a file object, blob or data-url
+ * @param {string=} uploadOptions.eTag The optional current ETag of the file
+ * @param {string=} uploadOptions.lastModified The optional last modified date
+ * @param {Acl=} uploadOptions.acl The file acl which will be set, if the file is uploaded afterwards
+ * @param {boolean} [uploadOptions.force=false] force the upload and overwrite any existing files without validating it
+ * @param {connector.Message~progressCallback} [uploadOptions.progress] listen to progress changes during upload
+ * @param {binding.File~fileCallback=} doneCallback The callback is invoked after the upload succeed successfully
+ * @param {binding.File~failCallback=} failCallback The callback is invoked if any error is occurred
+ * @return {Promise} A promise which will be fulfilled with this file object where the metadata is updated
+ */
+
+
+ File.prototype.upload = function upload(uploadOptions, doneCallback, failCallback) {
+ var _this = this;
+
+ uploadOptions = uploadOptions || {};
+
+ if (this.isFolder) {
+ throw new Error("A folder cannot be uploaded");
+ }
+
+ this._setMetadata(uploadOptions);
+
+ var uploadMessage = new message.UploadFile(this.bucket, this.key).entity(this._data, this._type).acl(this._acl);
+
+ uploadMessage.progress(uploadOptions.progress);
+
+ if (this._size) {
+ uploadMessage.contentLength(this._size);
+ }
+
+ if (this._mimeType) {
+ uploadMessage.mimeType(this._mimeType);
+ }
+
+ this._conditional(uploadMessage, uploadOptions);
+
+ this._db.addToBlackList(this.id);
+ return this._db.send(uploadMessage).then(function (response) {
+ _this._data = null;
+ _this._type = null;
+
+ _this.fromJSON(response.entity);
+ return _this;
+ }).then(doneCallback, failCallback);
+ };
+
+ /**
+ * Download a file and providing it in the requested type
+ * @param {object=} downloadOptions The download options
+ * @param {string} [downloadOptions.type="blob"] The type used to provide the file
+ * @param {string} [downloadOptions.refresh=false] Indicates to make a revalidation request and not use the cache
+ * @param {binding.File~downloadCallback=} doneCallback The callback is invoked after the download succeed successfully
+ * @param {binding.File~failCallback=} failCallback The callback is invoked if any error is occurred
+ * @return {Promise} A promise which will be fulfilled with the downloaded file content
+ */
+
+
+ File.prototype.download = function download(downloadOptions, doneCallback, failCallback) {
+ var _this2 = this;
+
+ downloadOptions = downloadOptions || {};
+
+ if (this.isFolder) {
+ throw new Error("A folder cannot be downloaded");
+ }
+
+ var type = downloadOptions.type || 'blob';
+
+ var downloadMessage = new message.DownloadFile(this.bucket, this.key).responseType(type);
+
+ this._db.ensureCacheHeader(this.id, downloadMessage, downloadOptions.refresh);
+
+ return this._db.send(downloadMessage).then(function (response) {
+ _this2._db.addToWhiteList(_this2.id);
+ _this2._fromHeaders(response.headers);
+ return response.entity;
+ }, function (e) {
+ if (e.status == StatusCode.OBJECT_NOT_FOUND) {
+ return null;
+ } else {
+ throw e;
+ }
+ }).then(doneCallback, failCallback);
+ };
+
+ /**
+ * Deletes a file
+ * @param {object=} deleteOptions The delete options
+ * @param {boolean} [deleteOptions.force=false] force the deletion without verifying any version
+ * @param {binding.File~deleteCallback=} doneCallback The callback is invoked after the deletion succeed successfully
+ * @param {binding.File~failCallback=} failCallback The callback is invoked if any error is occurred
+ * @return {Promise} A promise which will be fulfilled with this file object
+ */
+
+
+ File.prototype.delete = function _delete(deleteOptions, doneCallback, failCallback) {
+ deleteOptions = deleteOptions || {};
+
+ if (this.isFolder) {
+ throw new Error("A folder cannot be deleted");
+ }
+
+ var deleteMessage = new message.DeleteFile(this.bucket, this.key);
+ this._conditional(deleteMessage, deleteOptions);
+
+ this._db.addToBlackList(this.id);
+ return this._db.send(deleteMessage).then(function () {
+ return this;
+ }).then(doneCallback, failCallback);
+ };
+
+ File.prototype._conditional = function _conditional(message, options) {
+ if (!options.force) {
+ if (this._lastModified) message.ifUnmodifiedSince(this._lastModified);
+ if (this._eTag) message.ifMatch(this._eTag);
+ if (!this._lastModified && !this._eTag) message.ifNoneMatch('*');
+ }
+ };
+
+ /**
+ * Gets the file metadata of a file
+ * @param {Object} options The load metadata options
+ * @param {Object} [options.refresh=false] Force a revalidation while fetching the metadata
+ * @param {binding.File~fileCallback=} doneCallback The callback is invoked after the metadata is fetched
+ * @param {binding.File~failCallback=} failCallback The callback is invoked if any error has occurred
+ * @return {Promise} A promise which will be fulfilled with this file
+ */
+
+
+ File.prototype.loadMetadata = function loadMetadata(options, doneCallback, failCallback) {
+ var _this3 = this;
+
+ options = options || {};
+
+ if (this.isFolder) {
+ throw new Error("A folder has no matadata");
+ }
+
+ var msg = new message.GetFileMetadata(this.bucket, this.key);
+ this._db.ensureCacheHeader(this.id, msg, options.refresh);
+ return this._db.send(msg).then(function (response) {
+ // do not white list the file, because head-request does not revalidate the cache.
+ _this3._fromHeaders(response.headers);
+ return _this3;
+ }, function (e) {
+ if (e.status == StatusCode.OBJECT_NOT_FOUND) {
+ return null;
+ } else {
+ throw e;
+ }
+ }).then(doneCallback, failCallback);
+ };
+
+ /**
+ * Updates the matadata of this file.
+ * @param {boolean} [options.force=false] force the update and overwrite the existing metadata without validating it
+ * @return {Promise} A promise which will be fulfilled with this file
+ */
+
+
+ File.prototype.saveMetadata = function saveMetadata(options, doneCallback, failCallback) {
+ var _this4 = this;
+
+ options = options || {};
+
+ var metadata = this.toJSON();
+ metadata.id = this._id;
+
+ var msg = new message.UpdateFileMetadata(this.bucket, this.key).entity(metadata);
+
+ this._conditional(msg, options);
+
+ return this._db.send(msg).then(function (response) {
+ _this4.fromJSON(response);
+ return _this4;
+ });
+ };
+
+ /**
+ * Validates and sets the file metadata based on the given options
+ * @param {Object} options
+ * @private
+ */
+
+
+ File.prototype._setMetadata = function _setMetadata(options) {
+ var data = options.data;
+ var type = options.type;
+ var eTag = options.eTag;
+ var acl = options.acl;
+ var size = options.size;
+ var mimeType = options.mimeType;
+ var lastModified = options.lastModified;
+
+ if (!data) {
+ this._available = false;
+ } else {
+ if (typeof Blob !== "undefined" && data instanceof Blob) {
+ mimeType = mimeType || data.type;
+ } else if (type == 'data-url') {
+ var match = data.match(/^data:(.+?)(;base64)?,.*$/);
+ mimeType = mimeType || match[1];
+ }
+
+ this._data = data;
+ this._type = type;
+ this._size = size;
+
+ this._mimeType = mimeType;
+ this._acl = acl || this._acl || new Acl();
+ this._available = true;
+ }
+
+ this._eTag = eTag || this._eTag;
+
+ if (lastModified) {
+ this._lastModified = new Date(lastModified);
+ }
+ };
+
+ File.prototype._fromHeaders = function _fromHeaders(headers) {
+ this.fromJSON({
+ eTag: headers.etag ? headers.etag.substring(1, headers.etag.length - 1) : null,
+ lastModified: headers['last-modified'],
+ mimeType: headers['content-type'],
+ acl: headers['baqend-acl'] && JSON.parse(headers['baqend-acl']),
+ contentLength: +headers['baqend-size']
+ });
+ };
+
+ File.prototype.fromJSON = function fromJSON(metadata) {
+ if (metadata.mimeType) this._mimeType = metadata.mimeType;
+
+ if (metadata.lastModified) this._lastModified = new Date(metadata.lastModified);
+
+ if (metadata.eTag) this._eTag = metadata.eTag;
+
+ this._acl = this._acl || new Acl();
+ if (metadata.acl) this._acl.fromJSON(metadata.acl);
+
+ if (metadata.contentLength) this._size = metadata.contentLength;
+
+ this._available = true;
+ };
+
+ File.prototype.toJSON = function toJSON() {
+ var result = {
+ mimeType: this._mimeType,
+ eTag: this._eTag,
+ acl: this._acl,
+ contentLength: this._size
+ };
+
+ if (this._lastModified) {
+ result.lastModified = this._lastModified.toISOString();
+ }
+ return result;
+ };
+
+ File.prototype._checkAvailable = function _checkAvailable() {
+ if (!this._available) {
+ throw new error.PersistentError('The file metadata of ' + this.id + ' is not available.');
+ }
+ };
+
+ /**
+ * The database connection to use
+ * @member {EntityManager} _db
+ * @private
+ */
+
+
+ return File;
+}();
+
+/**
+ * The file callback is called, when the asynchronous operation completes successfully
+ * @callback binding.File~fileCallback
+ * @param {binding.File} file The updated file metadata
+ * @return {any} A Promise, result or undefined
+ */
+
+/**
+ * The download callback is called, when the asynchronous download completes successfully
+ * @callback binding.File~downloadCallback
+ * @param {string|Blob|File|ArrayBuffer|json} data The download file content in the requested format
+ * @return {any} A Promise, result or undefined
+ */
+
+/**
+ * The delete callback is called, when the asynchronous deletion completes successfully
+ * @callback binding.File~deleteCallback
+ * @param {binding.File} data The file metadata
+ * @return {any} A Promise, result or undefined
+ */
+
+/**
+ * The fail callback is called, when the asynchronous operation is rejected by an error
+ * @callback binding.File~failCallback
+ * @param {error.PersistentError} error The error which reject the operation
+ * @return {any} A Promise, result or undefined
+ */
+
+module.exports = File;
+
+},{"1":1,"25":25,"34":34,"36":36,"71":71}],14:[function(_dereq_,module,exports){
+"use strict";
+
+var Factory = _dereq_(12);
+var File = _dereq_(13);
+var message = _dereq_(36);
+var Permission = _dereq_(65);
+
+/**
+ * @class binding.FileFactory
+ * @extends binding.Factory
+ *
+ * @param {Object=} properties initial properties to set on the file
+ * @param {...*} arguments Additional constructor params passed through the type constructor
+ * @return {binding.File} The new managed instance
+ */
+var FileFactory = Factory.extend( /** @lends binding.FileFactory.prototype */{
+
+ /**
+ * Creates a new FileFactory for the given type
+ * @param {EntityManager} db
+ * @return {binding.FileFactory} A new file factory
+ * @static
+ */
+ create: function create(db) {
+ //invoke super method
+ var factory = Factory.create.call(this, File);
+ factory._db = db;
+ return factory;
+ },
+
+
+ /**
+ * Creates a new file
+ * @param {Array<*>=} args Constructor arguments used for instantiation, the constructor will not be called
+ * when no arguments are passed
+ * @return {binding.File} A new created file
+ */
+ newInstance: function newInstance(args) {
+ var instance = Factory.newInstance.call(this, args);
+ instance._db = this._db;
+ return instance;
+ },
+
+
+ /**
+ * Updates the metadata of the root file directory formally the file "bucket"
+ * @param {string} bucket The name of the root file directory
+ * @param {Object} metadata The new metadata for the bucket
+ * @param {util.Permission} metadata.loadPermission The load permission which grants read access to all stored
+ * files under the specified bucket
+ * @param {util.Permission} metadata.insertPermission The insert permission which is required to insert new
+ * files into the bucket
+ * @param {util.Permission} metadata.updatePermission The update permission which is required to update existing
+ * files within the bucket
+ * @param {util.Permission} metadata.deletePermission The delete permission which is required to delete existing
+ * files within the bucket
+ * @param {util.Permission} metadata.queryPermission The query permission which is required to list all files
+ * within a bucket
+ * @param {binding.FileFactory~bucketMetadataCallback=} doneCallback Invoked if the operation succeeds
+ * @param {binding.File~failCallback=} failCallback The callback is invoked if any error has occurred
+ * @return {Promise} A promise which will fulfilled with the updated metadata
+ */
+ saveMetadata: function saveMetadata(bucket, metadata, doneCallback, failCallback) {
+ var msg = new message.SetFileBucketMetadata(bucket, metadata);
+ return this._db.send(msg).then(doneCallback, failCallback);
+ },
+
+
+ /**
+ * Gets the metadata of the root folder (formally the file "bucket")
+ * @param {string} bucket The name of the root file directory
+ * @param {Object} options The load metadata options
+ * @param {Object} [options.refresh=false] Force a revalidation while fetching the metadata
+ * @param {binding.FileFactory~bucketMetadataCallback=} doneCallback The callback is invoked after the metadata is fetched
+ * @param {binding.File~failCallback=} failCallback The callback is invoked if any error has occurred
+ * @return {Promise} A promise which will be fulfilled with the bucket acls
+ */
+ loadMetadata: function loadMetadata(bucket, options, doneCallback, failCallback) {
+ options = options || {};
+
+ var msg = new message.GetFileBucketMetadata(bucket);
+ // this._db.ensureCacheHeader(this.id, msg, options.refresh);
+ // do not white list the file, because head-request does not revalidate the cache.
+ return this._db.send(msg).then(function (response) {
+ var result = {};
+ Permission.BASE_PERMISSIONS.forEach(function (key) {
+ result[key] = Permission.fromJSON(response.entity[key] || {});
+ });
+ return result;
+ }, function (e) {
+ if (e.status == StatusCode.OBJECT_NOT_FOUND) {
+ return null;
+ } else {
+ throw e;
+ }
+ }).then(doneCallback, failCallback);
+ },
+
+
+ /**
+ * Lists all the buckets.
+ * @param {binding.FileFactory~fileListCallback=} doneCallback The callback is invoked with the listed buckets
+ * @param {binding.File~failCallback=} failCallback The callback is invoked if any error has occurred
+ * @return {Promise>} The listed buckets.
+ */
+ listBuckets: function listBuckets(doneCallback, failCallback) {
+ var _this = this;
+
+ return this._db.send(new message.ListBuckets()).then(function (response) {
+ return response.entity.map(function (bucket) {
+ return _this.new(bucket + '/');
+ });
+ }).then(doneCallback, failCallback);
+ },
+
+
+ /**
+ * Lists the files (and folders) in the given folder.
+ *
+ * @param {binding.File|string} folder The folder/path to list.
+ * @param {binding.File} start The file/folder from where to start listing (not included)
+ * @param {number} count The maximum number of files to return.
+ * @param {binding.FileFactory~fileListCallback=} doneCallback The callback is invoked with the listed files
+ * @param {binding.File~failCallback=} failCallback The callback is invoked if any error has occurred
+ * @return {Promise>} The listed files/folders.
+ */
+ listFiles: function listFiles(folder, start, count, doneCallback, failCallback) {
+ var _this2 = this;
+
+ if (Object(folder) instanceof String) {
+ if (folder.charAt(folder.length - 1) != '/') {
+ folder += '/';
+ }
+ folder = this.new({ path: folder });
+ }
+
+ var path = folder.key;
+ var bucket = folder.bucket;
+ start = start ? start.key : null;
+ return this._db.send(new message.ListFiles(bucket, path, start, count)).then(function (response) {
+ return response.entity.map(function (file) {
+ return _this2.new(file);
+ });
+ }).then(doneCallback, failCallback);
+ }
+
+ /**
+ * Creates a new file object which represents the a file at the given id. Data are provided to the constructor will
+ * be uploaded by invoking {@link upload()}
+ * @param {object|string} fileOptions The fileOptions used to create a new file object, or just the id of the
+ * file object
+ * @param {string=} fileOptions.name The filename without the id. If omitted and data is provided as a file object, the
+ * {@link File#name} will be used otherwise a uuid will be generated.
+ * @param {string} [fileOptions.parent="/www"] The parent folder which contains the file
+ * @param {string|Blob|File|ArrayBuffer|json=} fileOptions.data The initial file content, which will be uploaded by
+ * invoking {@link #upload} later on.
+ * @param {string=} fileOptions.type A optional type hint used to correctly interpret the provided data
+ * @param {string=} fileOptions.mimeType The mimType of the file. Defaults to the mimeType of the provided data if
+ * it is a file object, blob or data-url
+ * @param {string=} fileOptions.eTag The optional current ETag of the file
+ * @param {string=} fileOptions.lastModified The optional last modified date
+ * @param {Acl=} fileOptions.acl The file acl which will be set, if the file is uploaded afterwards
+ * @return {binding.File} A new file instance
+ *
+ * @function
+ * @name new
+ * @memberOf binding.FileFactory.prototype
+ */
+
+});
+
+/**
+ * The list files callback is called, with the bucket metadata
+ * @callback binding.FileFactory~bucketMetadataCallback
+ * @param {Array} bucketMetadata the bucket metadata
+ * @return {any} A Promise, result or undefined
+ */
+
+/**
+ * The list files callback is called, with the loaded files
+ * @callback binding.FileFactory~fileListCallback
+ * @param {Array} files The listed files
+ * @return {any} A Promise, result or undefined
+ */
+
+module.exports = FileFactory;
+
+},{"12":12,"13":13,"36":36,"65":65}],15:[function(_dereq_,module,exports){
+"use strict";
+
+var Metadata = _dereq_(63);
+
+/**
+ * @alias binding.Managed
+ */
+
+var Managed = function () {
+
+ /**
+ * Initialize the given instance
+ * @param {binding.Managed} instance The managed instance to initialize
+ * @param {Object=} properties The optional properties to set on the instance
+ */
+ Managed.init = function init(instance, properties) {
+ var type = instance.constructor.__ype__;
+ if (type) {
+ Object.defineProperty(instance, '_metadata', {
+ value: Metadata.create(type, instance),
+ configurable: true
+ });
+ }
+
+ if (properties) Object.assign(instance, properties);
+ };
+
+ /**
+ * Creates a subclass of this class
+ * @param {Class<*>} childClass
+ * @return {Class<*>} The extended child class
+ */
+
+
+ Managed.extend = function extend(childClass) {
+ childClass.prototype = Object.create(this.prototype, {
+ constructor: {
+ value: childClass,
+ configurable: true,
+ writable: true
+ }
+ });
+ childClass.extend = Managed.extend;
+ return childClass;
+ };
+
+ /**
+ * The default constructor, copy all given properties to this object
+ * @param {Object=} properties - The optional properties to copy
+ */
+
+
+ function Managed(properties) {
+ babelHelpers.classCallCheck(this, Managed);
+
+ Managed.init(this, properties);
+ }
+
+ return Managed;
+}();
+
+Object.defineProperties(Managed.prototype, /** @lends binding.Managed.prototype */{
+ /**
+ * Converts the managed object to an JSON-Object.
+ * @return {json} JSON-Object
+ * @method
+ */
+ toJSON: {
+ value: function toJSON() {
+ return this._metadata.type.toJsonValue(this._metadata, this);
+ }
+ }
+});
+
+/**
+ * Contains the metadata of this managed object
+ * @type util.Metadata
+ * @name _metadata
+ * @memberOf binding.Managed
+ * @private
+ */
+
+module.exports = Managed;
+
+},{"63":63}],16:[function(_dereq_,module,exports){
+"use strict";
+
+var Factory = _dereq_(12);
+var Managed = _dereq_(15);
+
+/**
+ * @class binding.ManagedFactory
+ * @extends binding.Factory
+ *
+ * @param {Object=} properties initial properties to set on the instance
+ * @param {...*} args Additional constructor params passed through the type constructor
+ * @return {T} The new managed instance
+ */
+var ManagedFactory = Factory.extend( /** @lends binding.ManagedFactory.prototype */{
+
+ /**
+ * Creates a new ManagedFactory for the given type
+ * @param {metamodel.ManagedType} managedType The metadata of type T
+ * @param {EntityManager} db
+ * @return {binding.ManagedFactory<*>} A new object factory to created instances of T
+ * @static
+ * @ignore
+ */
+ create: function create(managedType, db) {
+ //invoke super method
+ var factory = Factory.create.call(this, managedType.typeConstructor);
+ factory.methods = factory.prototype;
+
+ factory._managedType = managedType;
+ factory._db = db;
+
+ return factory;
+ },
+
+
+ /**
+ * Creates a new instance of the factory type
+ * @param {Array<*>=} args Constructor arguments used for instantiation, the constructor will not be called
+ * when no arguments are passed
+ * @return {T} A new created instance of T
+ */
+ newInstance: function newInstance(args) {
+ var instance = args ? Factory.newInstance.call(this, args) : this._managedType.create(args);
+ instance._metadata.db = this._db;
+ return instance;
+ },
+
+
+ /**
+ * Creates a new instance and sets the Managed Object to the given json
+ * @param {json} json
+ * @returns {T} instance
+ */
+ fromJSON: function fromJSON(json) {
+ var instance = this.newInstance();
+ var metadata = instance._metadata;
+ this._managedType.fromJsonValue(metadata, json, instance);
+ return instance;
+ },
+
+
+ /**
+ * Adds methods to instances of this factories type
+ * @param {Object} methods The methods to add
+ */
+ addMethods: function addMethods(methods) {
+ Object.assign(this.methods, methods);
+ },
+
+
+ /**
+ * Add a method to instances of this factories type
+ * @param {string} name The method name to add
+ * @param {Function} fn The Method to add
+ */
+ addMethod: function addMethod(name, fn) {
+ this.methods[name] = fn;
+ }
+
+ /**
+ * Methods that are added to object instances
+ * This property is an alias for this factory type prototype
+ * @name methods
+ * @type {Object}
+ * @memberOf binding.ManagedFactory.prototype
+ */
+
+ /**
+ * The managed type of this factory
+ * @name _managedType
+ * @type metamodel.ManagedType
+ * @protected
+ * @memberOf binding.ManagedFactory.prototype
+ */
+
+ /**
+ * The owning EntityManager where this factory belongs to
+ * @name _db
+ * @type EntityManager
+ * @protected
+ * @memberOf binding.ManagedFactory.prototype
+ */
+
+ /**
+ * Creates a new instance of the of this type
+ * @function
+ * @name new
+ * @param {Object} properties Additional properties which will be applied to the created instance
+ * @return {T} A new created instance of this class
+ * @memberOf binding.ManagedFactory.prototype
+ */
+
+});
+
+module.exports = ManagedFactory;
+
+},{"12":12,"15":15}],17:[function(_dereq_,module,exports){
+"use strict";
+
+var Entity = _dereq_(10);
+var User = _dereq_(18);
+
+/**
+ * @alias binding.Role
+ * @extends binding.Entity
+ */
+
+var Role = function (_Entity) {
+ babelHelpers.inherits(Role, _Entity);
+
+ /**
+ * The default constructor, copy all given properties to this object
+ * @param {Object=} properties - The optional properties to copy
+ */
+ function Role(properties) {
+ babelHelpers.classCallCheck(this, Role);
+ return babelHelpers.possibleConstructorReturn(this, _Entity.call(this, properties));
+ }
+
+ return Role;
+}(Entity);
+
+Object.defineProperties(Role.prototype, /** @lends binding.Role.prototype */{
+ /**
+ * Test if the given user has this role
+ * @return {boolean} true if the given user has this role,
+ * otherwise false
+ * @method
+ */
+ hasUser: {
+ value: function hasUser(user) {
+ return this.users && this.users.has(user);
+ }
+ },
+
+ /**
+ * Add the given user to this role
+ * @param {model.User} user The user to add
+ * @method
+ */
+ addUser: {
+ value: function addUser(user) {
+ if (user instanceof User) {
+ if (!this.users) this.users = new Set();
+
+ this.users.add(user);
+ } else {
+ throw new Error('Only user instances can be added to a role.');
+ }
+ }
+ },
+
+ /**
+ * Remove the given user from this role
+ * @param {model.User} user The user to remove
+ * @method
+ */
+ removeUser: {
+ value: function removeUser(user) {
+ if (user instanceof User) {
+ if (this.users) this.users.delete(user);
+ } else {
+ throw new Error('Only user instances can be removed from a role.');
+ }
+ }
+ }
+
+ /**
+ * A set of users which have this role
+ * @type Set
+ * @name users
+ * @memberOf binding.Role.prototype
+ */
+
+ /**
+ * The name of the role
+ * @type string
+ * @name name
+ * @memberOf binding.Role.prototype
+ */
+});
+
+module.exports = Role;
+
+},{"10":10,"18":18}],18:[function(_dereq_,module,exports){
+"use strict";
+
+var Entity = _dereq_(10);
+
+/**
+ * @alias binding.User
+ * @extends binding.Entity
+ */
+
+var User = function (_Entity) {
+ babelHelpers.inherits(User, _Entity);
+
+ /**
+ * The default constructor, copy all given properties to this object
+ * @param {Object=} properties - The optional properties to copy
+ */
+ function User(properties) {
+ babelHelpers.classCallCheck(this, User);
+ return babelHelpers.possibleConstructorReturn(this, _Entity.call(this, properties));
+ }
+
+ return User;
+}(Entity);
+
+Object.defineProperties(User.prototype, /** @lends binding.User.prototype */{
+
+ /**
+ * Change the password of the given user
+ *
+ * @param {string} currentPassword Current password of the user
+ * @param {string} password New password of the user
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise}
+ * @method
+ */
+ newPassword: {
+ value: function newPassword(currentPassword, password, doneCallback, failCallback) {
+ return this._metadata.db.newPassword(this.username, currentPassword, password).then(doneCallback, failCallback);
+ }
+ }
+
+ /**
+ * The users username or email address
+ * @type string
+ * @name username
+ * @memberOf binding.User.prototype
+ */
+
+ /**
+ * Indicates if the user is currently inactive, which disallow user login
+ * @type boolean
+ * @name inactive
+ * @memberOf binding.User.prototype
+ */
+});
+
+module.exports = User;
+
+},{"10":10}],19:[function(_dereq_,module,exports){
+"use strict";
+
+var EntityFactory = _dereq_(11);
+
+/**
+ * @class binding.UserFactory
+ * @extends binding.EntityFactory
+ *
+ * Creates a new instance of the managed type of this factory
+ * @param {Object=} properties initial properties to set on the instance
+ * @param {...*} arguments Additional constructor params passed through the type constructor
+ * @return {model.User} The new managed instance
+ */
+var UserFactory = EntityFactory.extend( /** @lends binding.UserFactory.prototype */{
+ /**
+ * The current logged in user, or null if the user is not logged in
+ * @type model.User
+ */
+ get me() {
+ return this._db.me;
+ },
+
+ /**
+ * Register a new user with the given username and password, if the username is not used by an another user.
+ * @param {string|model.User} user The username as a string or a Object, which must contain the username.
+ * @param {string} password The password for the given user
+ * @param {boolean|binding.UserFactory.LoginOption} [loginOption=true] The default logs the user in after a successful registration and keeps the user logged in over multiple sessions
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise} The created user object, for the new registered user.
+ */
+ register: function register(user, password, loginOption, doneCallback, failCallback) {
+ if (loginOption instanceof Function) {
+ failCallback = doneCallback;
+ doneCallback = loginOption;
+ loginOption = true;
+ }
+
+ user = Object(user) instanceof String ? this.fromJSON({ username: user }) : user;
+ return this._db.register(user, password, loginOption === undefined ? true : loginOption).then(doneCallback, failCallback);
+ },
+
+
+ /**
+ * Log in the user with the given username and password and starts a user session
+ * @param {string} username The username of the user
+ * @param {string} password The password of the user
+ * @param {boolean|binding.UserFactory.LoginOption} [loginOption=true] The default keeps the user logged in over multiple sessions
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise}
+ */
+ login: function login(username, password, loginOption, doneCallback, failCallback) {
+ if (loginOption instanceof Function) {
+ failCallback = doneCallback;
+ doneCallback = loginOption;
+ loginOption = true;
+ }
+
+ return this._db.login(username, password, loginOption === undefined ? true : loginOption).then(doneCallback, failCallback);
+ },
+
+
+ /**
+ * Log out the current logged in user and ends the active user session
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise<*>}
+ */
+ logout: function logout(doneCallback, failCallback) {
+ return this._db.logout().then(doneCallback, failCallback);
+ },
+
+
+ /**
+ * Change the password of the given user
+ *
+ * @param {string} username Username to identify the user
+ * @param {string} password Current password of the user
+ * @param {string} newPassword New password of the user
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise}
+ */
+ newPassword: function newPassword(username, password, _newPassword, doneCallback, failCallback) {
+ return this._db.newPassword(username, password, _newPassword).then(doneCallback, failCallback);
+ }
+
+ /**
+ * Prompts the user for the Google login in a new window. Before using OAuth you need to setup your application
+ * on the provider website, add the redirect uri: https://example.net/db/User/OAuth/google and copy the client id
+ * and the client secret to your Baqend dashboard settings. When the returned promise succeeds the user is logged in.
+ *
+ * @param {string} clientID
+ * @param {Object=} options
+ * @param {boolean|binding.UserFactory.LoginOption} [loginOption=true] The default keeps the user logged in over multiple sessions
+ * @param {string} [options.title="Login"] sets the title of the popup window
+ * @param {number} [options.width=585] defines the width of the popup window
+ * @param {number} [options.height=545] defines the height of the popup window
+ * @param {string} [options.scope="email"] the range of rights requested from the user
+ * @param {Object} [options.state={}]
+ * @param {number} [options.timeout=5 * 60 * 1000]
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise}
+ *
+ * @function
+ * @name loginWithGoogle
+ * @memberOf binding.UserFactory.prototype
+ */
+
+ /**
+ * Prompts the user for the Facebook login in a new window. Before using OAuth you need to setup your application
+ * on the provider website, add the redirect uri: https://example.net/db/User/OAuth/facebook and copy the client id
+ * and the client secret to your Baqend dashboard settings. When the returned promise succeeds the user is logged in.
+ *
+ * @param {string} clientID
+ * @param {Object=} options
+ * @param {boolean|binding.UserFactory.LoginOption} [loginOption=true] The default keeps the user logged in over multiple sessions
+ * @param {string} [options.title="Login"] sets the title of the popup window
+ * @param {number} [options.width=1140] defines the width of the popup window
+ * @param {number} [options.height=640] defines the height of the popup window
+ * @param {string} [options.scope="email"] the range of rights requested from the user
+ * @param {Object} [options.state={}]
+ * @param {number} [options.timeout=5 * 60 * 1000]
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise}
+ *
+ * @function
+ * @name loginWithFacebook
+ * @memberOf binding.UserFactory.prototype
+ */
+
+ /**
+ * Prompts the user for the GitHub login in a new window. Before using OAuth you need to setup your application
+ * on the provider website, add the redirect uri: https://example.net/db/User/OAuth/github and copy the client id
+ * and the client secret to your Baqend dashboard settings. When the returned promise succeeds the user is logged in.
+ *
+ * @param {string} clientID
+ * @param {Object=} options
+ * @param {boolean|binding.UserFactory.LoginOption} [loginOption=true] The default keeps the user logged in over multiple sessions
+ * @param {string} [options.title="Login"] sets the title of the popup window
+ * @param {number} [options.width=1040] defines the width of the popup window
+ * @param {number} [options.height=580] defines the height of the popup window
+ * @param {string} [options.scope="user:email"] the range of rights requested from the user
+ * @param {Object} [options.state={}]
+ * @param {number} [options.timeout=5 * 60 * 1000]
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise}
+ *
+ * @function
+ * @name loginWithGitHub
+ * @memberOf binding.UserFactory.prototype
+ */
+
+ /**
+ * Prompts the user for the Twitter login in a new window. Before using OAuth you need to setup your application
+ * on the provider website, add the redirect uri: https://example.net/db/User/OAuth/twitter and copy the client id
+ * and the client secret to your Baqend dashboard settings. When the returned promise succeeds the user is logged in.
+ *
+ * @param {string} clientID
+ * @param {Object=} options
+ * @param {boolean|binding.UserFactory.LoginOption} [loginOption=true] The default keeps the user logged in over multiple sessions
+ * @param {string} [options.title="Login"] sets the title of the popup window
+ * @param {number} [options.width=740] defines the width of the popup window
+ * @param {number} [options.height=730] defines the height of the popup window
+ * @param {number} [options.timeout=5 * 60 * 1000]
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise}
+ *
+ * @function
+ * @name loginWithTwitter
+ * @memberOf binding.UserFactory.prototype
+ */
+
+ /**
+ * Prompts the user for the LinkedIn login in a new window. Before using OAuth you need to setup your application
+ * on the provider website, add the redirect uri: https://example.net/db/User/OAuth/linkedin and copy the client id
+ * and the client secret to your Baqend dashboard settings. When the returned promise succeeds the user is logged in.
+ *
+ * @param {string} clientID
+ * @param {Object=} options
+ * @param {boolean|binding.UserFactory.LoginOption} [loginOption=true] The default keeps the user logged in over multiple sessions
+ * @param {string} [options.title="Login"] sets the title of the popup window
+ * @param {number} [options.width=630] defines the width of the popup window
+ * @param {number} [options.height=530] defines the height of the popup window
+ * @param {string} [options.scope=""] the range of rights requested from the user
+ * @param {Object} [options.state={}]
+ * @param {number} [options.timeout=5 * 60 * 1000]
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise}
+ *
+ * @function
+ * @name loginWithLinkedIn
+ * @memberOf binding.UserFactory.prototype
+ */
+
+ /**
+ * Creates a new user object
+ * @function
+ * @name new
+ * @param {Object} properties Additional properties which will be applied to the created instance
+ * @return {model.User} A new created user
+ * @memberOf binding.UserFactory.prototype
+ */
+
+});
+
+/**
+ * @alias binding.UserFactory.LoginOption
+ * @enum {number}
+ */
+UserFactory.LoginOption = {
+ /**
+ * Do not login the user after a successful registration
+ */
+ NO_LOGIN: -1,
+ /**
+ * Login in after a successful registration and keep the token in a nonpermanent storage, i.e SessionStorage
+ */
+ SESSION_LOGIN: 0,
+ /**
+ * Login in after a successful registration and keep the token in a persistent storage, i.e LocalStorage
+ */
+ PERSIST_LOGIN: 1
+};
+
+/**
+ * @alias binding.UserFactory.DefaultOptions
+ * @property {Object} oauth default properties
+ * @property {Object} oauth.google default oauth properties for Google
+ * @property {Object} oauth.facebook default oauth properties for Facebook
+ * @property {Object} oauth.github default oauth properties for GitHub
+ * @property {Object} oauth.twitter default oauth properties for Twitter
+ * @property {Object} oauth.linkedin default oauth properties for LinkedIn
+ */
+UserFactory.DefaultOptions = {
+ google: {
+ width: 585,
+ height: 545,
+ scope: 'email'
+ },
+ facebook: {
+ width: 1140,
+ height: 640,
+ scope: 'email'
+ },
+ github: {
+ width: 1040,
+ height: 580,
+ scope: 'user:email'
+ },
+ twitter: {
+ width: 740,
+ height: 730
+ },
+ linkedin: {
+ width: 630,
+ height: 530,
+ scope: ''
+ }
+};
+
+["Google", "Facebook", "GitHub", "Twitter", "LinkedIn"].forEach(function (name) {
+ UserFactory["loginWith" + name] = function (clientID, options, doneCallback, failCallback) {
+ //noinspection JSPotentiallyInvalidUsageOfThis
+ if (options instanceof Function) {
+ failCallback = doneCallback;
+ doneCallback = options;
+ options = {};
+ }
+
+ options = Object.assign({}, UserFactory.DefaultOptions[name.toLowerCase()], options || {});
+
+ return this._db.loginWithOAuth(name, clientID, options).then(doneCallback, failCallback);
+ };
+});
+
+module.exports = UserFactory;
+
+},{"11":11}],20:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * @namespace binding
+ */
+
+exports.Accessor = _dereq_(7);
+exports.Enhancer = _dereq_(9);
+exports.Factory = _dereq_(12);
+exports.ManagedFactory = _dereq_(16);
+exports.EntityFactory = _dereq_(11);
+exports.UserFactory = _dereq_(19);
+exports.DeviceFactory = _dereq_(8);
+exports.FileFactory = _dereq_(14);
+exports.Managed = _dereq_(15);
+exports.Entity = _dereq_(10);
+exports.Role = _dereq_(17);
+exports.User = _dereq_(18);
+exports.File = _dereq_(13);
+
+},{"10":10,"11":11,"12":12,"13":13,"14":14,"15":15,"16":16,"17":17,"18":18,"19":19,"7":7,"8":8,"9":9}],21:[function(_dereq_,module,exports){
+"use strict";
+
+var atob = _dereq_(70).atob;
+
+/**
+ * @alias caching.BloomFilter
+ */
+
+var BloomFilter = function () {
+ function BloomFilter(rawBF) {
+ babelHelpers.classCallCheck(this, BloomFilter);
+
+ this.bytes = atob(rawBF.b);
+ this.bits = rawBF.m;
+ this.hashes = rawBF.h;
+ this.creation = new Date().getTime();
+ }
+
+ BloomFilter.prototype.contains = function contains(element) {
+ for (var _iterator = BloomFilter._getHashes(element, this.bits, this.hashes), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var hash = _ref;
+
+ if (!this._isSet(hash)) {
+ return false;
+ }
+ }
+ return true;
+ };
+
+ BloomFilter.prototype._isSet = function _isSet(index) {
+ var pos = Math.floor(index / 8);
+ var bit = 1 << index % 8;
+ //Extract byte as int or NaN if out of range
+ var byte = this.bytes.charCodeAt(pos);
+ //Bit-wise AND should be non-zero (NaN always yields false)
+ return (byte & bit) != 0;
+ };
+
+ BloomFilter._getHashes = function _getHashes(element, bits, hashes) {
+ var hashValues = new Array(this.hashes);
+ var hash1 = BloomFilter._murmur3(0, element);
+ var hash2 = BloomFilter._murmur3(hash1, element);
+ for (var i = 0; i < hashes; i++) {
+ hashValues[i] = (hash1 + i * hash2) % bits;
+ }
+ return hashValues;
+ };
+
+ BloomFilter._murmur3 = function _murmur3(seed, key) {
+ var remainder, bytes, h1, h1b, c1, c2, k1, i;
+ remainder = key.length & 3;
+ bytes = key.length - remainder;
+ h1 = seed;
+ c1 = 0xcc9e2d51;
+ c2 = 0x1b873593;
+ i = 0;
+
+ while (i < bytes) {
+ k1 = key.charCodeAt(i) & 0xff | (key.charCodeAt(++i) & 0xff) << 8 | (key.charCodeAt(++i) & 0xff) << 16 | (key.charCodeAt(++i) & 0xff) << 24;
+ ++i;
+
+ k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
+ k1 = k1 << 15 | k1 >>> 17;
+ k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
+
+ h1 ^= k1;
+ h1 = h1 << 13 | h1 >>> 19;
+ h1b = (h1 & 0xffff) * 5 + (((h1 >>> 16) * 5 & 0xffff) << 16) & 0xffffffff;
+ h1 = (h1b & 0xffff) + 0x6b64 + (((h1b >>> 16) + 0xe654 & 0xffff) << 16);
+ }
+
+ k1 = 0;
+
+ switch (remainder) {
+ case 3:
+ k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+ case 2:
+ k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+ case 1:
+ k1 ^= key.charCodeAt(i) & 0xff;
+
+ k1 = (k1 & 0xffff) * c1 + (((k1 >>> 16) * c1 & 0xffff) << 16) & 0xffffffff;
+ k1 = k1 << 15 | k1 >>> 17;
+ k1 = (k1 & 0xffff) * c2 + (((k1 >>> 16) * c2 & 0xffff) << 16) & 0xffffffff;
+ h1 ^= k1;
+ }
+
+ h1 ^= key.length;
+
+ h1 ^= h1 >>> 16;
+ h1 = (h1 & 0xffff) * 0x85ebca6b + (((h1 >>> 16) * 0x85ebca6b & 0xffff) << 16) & 0xffffffff;
+ h1 ^= h1 >>> 13;
+ h1 = (h1 & 0xffff) * 0xc2b2ae35 + (((h1 >>> 16) * 0xc2b2ae35 & 0xffff) << 16) & 0xffffffff;
+ h1 ^= h1 >>> 16;
+
+ return h1 >>> 0;
+ };
+
+ return BloomFilter;
+}();
+
+module.exports = BloomFilter;
+
+},{"70":70}],22:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * @namespace caching
+ */
+exports.BloomFilter = _dereq_(21);
+
+},{"21":21}],23:[function(_dereq_,module,exports){
+"use strict";
+
+var PersistentError = _dereq_(32);
+var message = _dereq_(36);
+
+/**
+ * @alias connector.Connector
+ */
+
+var Connector = function () {
+
+ /**
+ * @param {string} host or location
+ * @param {number=} port
+ * @param {boolean=} secure true for an secure connection
+ * @param {string=} basePath The basepath of the api
+ * @return {connector.Connector}
+ */
+ Connector.create = function create(host, port, secure, basePath) {
+ if (typeof window !== 'undefined') {
+ if (!host) {
+ host = window.location.hostname;
+ port = Number(window.location.port);
+ }
+
+ if (secure === undefined) {
+ secure = window.location.protocol == 'https:';
+ }
+ }
+
+ //ensure right type
+ secure = !!secure;
+ if (basePath === undefined) basePath = Connector.DEFAULT_BASE_PATH;
+
+ if (host.indexOf('/') != -1) {
+ var matches = /^(https?):\/\/([^\/:]+|\[[^\]]+])(:(\d*))?(\/\w+)?\/?$/.exec(host);
+ if (matches) {
+ secure = matches[1] == 'https';
+ host = matches[2].replace(/(\[|])/g, '');
+ port = matches[4];
+ basePath = matches[5] || '';
+ } else {
+ throw new Error('The connection uri host ' + host + ' seems not to be valid');
+ }
+ } else if (host != 'localhost' && /^[a-z0-9-]*$/.test(host)) {
+ //handle app names as hostname
+ host += secure ? Connector.SSL_DOMAIN : Connector.HTTP_DOMAIN;
+ }
+
+ if (!port) port = secure ? 443 : 80;
+
+ var url = Connector.toUri(host, port, secure, basePath);
+ var connection = this.connections[url];
+
+ if (!connection) {
+ for (var name in this.connectors) {
+ var connector = this.connectors[name];
+ if (connector.isUsable && connector.isUsable(host, port, secure, basePath)) {
+ connection = new connector(host, port, secure, basePath);
+ break;
+ }
+ }
+
+ if (!connection) throw new Error('No connector is usable for the requested connection.');
+
+ this.connections[url] = connection;
+ }
+
+ return connection;
+ };
+
+ Connector.toUri = function toUri(host, port, secure, basePath) {
+ var uri = (secure ? 'https://' : 'http://') + (host.indexOf(':') != -1 ? '[' + host + ']' : host);
+ uri += secure && port != 443 || !secure && port != 80 ? ':' + port : '';
+ uri += basePath;
+ return uri;
+ };
+
+ /**
+ * @param {string} host
+ * @param {number} port
+ * @param {boolean} secure
+ * @param {string} basePath
+ */
+
+
+ function Connector(host, port, secure, basePath) {
+ babelHelpers.classCallCheck(this, Connector);
+
+ this.host = host;
+ this.port = port;
+ this.secure = secure;
+ this.basePath = basePath;
+
+ //the origin do not contains the basepath
+ this.origin = Connector.toUri(host, port, secure, "");
+ }
+
+ /**
+ * @param {connector.Message} message
+ * @returns {Promise}
+ */
+
+
+ Connector.prototype.send = function send(message) {
+ var _this = this;
+
+ if (message.request.method == 'OAUTH') {
+ message.addRedirectOrigin(this.origin + this.basePath);
+ }
+
+ var response = { status: 0 };
+ return new Promise(function (resolve) {
+ _this.prepareRequest(message);
+ _this.doSend(message, message.request, resolve);
+ }).then(function (res) {
+ return response = res;
+ }).then(function () {
+ return _this.prepareResponse(message, response);
+ }).then(function () {
+ message.doReceive(response);
+ return response;
+ }).catch(function (e) {
+ response.entity = null;
+ throw PersistentError.of(e);
+ });
+ };
+
+ /**
+ * Handle the actual message send
+ * @param {connector.Message} message
+ * @param {Object} request
+ * @param {Function} receive
+ * @abstract
+ */
+
+
+ Connector.prototype.doSend = function doSend(message, request, receive) {};
+
+ /**
+ * @param {connector.Message} message
+ */
+
+
+ Connector.prototype.prepareRequest = function prepareRequest(message) {
+ var mimeType = message.mimeType();
+ if (!mimeType) {
+ var type = message.request.type;
+ if (type == 'json') {
+ message.mimeType('application/json;charset=utf-8');
+ } else if (type == 'text') {
+ message.mimeType('text/plain;charset=utf-8');
+ }
+ }
+
+ this.toFormat(message);
+
+ var accept = void 0;
+ switch (message.responseType()) {
+ case 'json':
+ accept = 'application/json';
+ break;
+ case 'text':
+ accept = 'text/*';
+ break;
+ default:
+ accept = 'application/json,text/*;q=0.5,*/*;q=0.1';
+ }
+
+ if (!message.accept()) {
+ message.accept(accept);
+ }
+
+ if (this.gzip) {
+ var ifNoneMatch = message.ifNoneMatch();
+ if (ifNoneMatch && ifNoneMatch !== '""' && ifNoneMatch != '*') {
+ message.ifNoneMatch(ifNoneMatch.slice(0, -1) + '--gzip"');
+ }
+ }
+
+ if (message.request.path == '/connect') {
+ message.request.path = message.tokenStorage.signPath(this.basePath + message.request.path).substring(this.basePath.length);
+ if (message.cacheControl()) {
+ message.request.path += (message.tokenStorage.token ? '&' : '?') + 'BCB';
+ }
+ } else if (message.tokenStorage) {
+ var token = message.tokenStorage.token;
+ if (token) {
+ message.header('authorization', 'BAT ' + token);
+ }
+ }
+ };
+
+ /**
+ * Convert the message entity to the sendable representation
+ * @param {connector.Message} message The message to send
+ * @protected
+ * @abstract
+ */
+
+
+ Connector.prototype.toFormat = function toFormat(message) {};
+
+ /**
+ * @param {connector.Message} message
+ * @param {Object} response The received response headers and data
+ */
+
+
+ Connector.prototype.prepareResponse = function prepareResponse(message, response) {
+ var _this2 = this;
+
+ // IE9 returns status code 1223 instead of 204
+ response.status = response.status == 1223 ? 204 : response.status;
+
+ var type = void 0;
+ var headers = response.headers || {};
+ var entity = response.entity;
+
+ if (entity) {
+ type = message.responseType();
+ if (!type || response.status >= 400) {
+ var contentType = headers['content-type'] || headers['Content-Type'];
+ if (contentType && contentType.indexOf("application/json") > -1) {
+ type = 'json';
+ }
+ }
+ }
+
+ if (headers.etag) {
+ headers.etag = headers.etag.replace('--gzip', '');
+ }
+
+ if (message.tokenStorage) {
+ var token = headers['baqend-authorization-token'] || headers['Baqend-Authorization-Token'];
+ if (token) {
+ message.tokenStorage.update(token);
+ }
+ }
+
+ return new Promise(function (resolve) {
+ resolve(entity && _this2.fromFormat(response, entity, type));
+ }).then(function (entity) {
+ response.entity = entity;
+
+ if (message.request.path.indexOf('/connect') != -1 && entity) {
+ _this2.gzip = !!entity.gzip;
+ }
+ }, function (e) {
+ throw new Error('Response was not valid ' + type + ': ' + e.message);
+ });
+ };
+
+ /**
+ * Convert received data to the requested response entity type
+ * @param {Object} response The response object
+ * @param {*} entity The received data
+ * @param {string} type The requested response format
+ * @protected
+ * @abstract
+ */
+
+
+ Connector.prototype.fromFormat = function fromFormat(response, entity, type) {};
+
+ return Connector;
+}();
+
+Object.assign(Connector, /** @lends connector.Connector */{
+ DEFAULT_BASE_PATH: '/v1',
+ HTTP_DOMAIN: '.app.baqend.com',
+ SSL_DOMAIN: '-bq.global.ssl.fastly.net',
+
+ /**
+ * An array of all exposed response headers
+ * @type string[]
+ */
+ RESPONSE_HEADERS: ['baqend-authorization-token', 'content-type', 'baqend-size', 'baqend-acl', 'etag', 'last-modified'],
+
+ /**
+ * Array of all available connector implementations
+ * @type connector.Connector[]
+ */
+ connectors: [],
+
+ /**
+ * Array of all created connections
+ * @type Object
+ */
+ connections: {},
+
+ /**
+ * The connector will detect if gzip is supports.
+ * Returns true if supported otherwise false.
+ * @returns {boolean} gzip
+ */
+ gzip: false
+});
+
+module.exports = Connector;
+
+},{"32":32,"36":36}],24:[function(_dereq_,module,exports){
+"use strict";
+
+var Connector = _dereq_(23);
+var XMLHttpConnector = _dereq_(27);
+
+/**
+ * @alias connector.IFrameConnector
+ * @extends connector.XMLHttpConnector
+ */
+
+var IFrameConnector = function (_XMLHttpConnector) {
+ babelHelpers.inherits(IFrameConnector, _XMLHttpConnector);
+
+ /**
+ * Indicates if this connector implementation is usable for the given host and port
+ * @param {string} host
+ * @param {number} port
+ * @param {boolean} secure
+ * @returns {boolean}
+ */
+ IFrameConnector.isUsable = function isUsable(host, port, secure) {
+ return typeof window != 'undefined';
+ };
+
+ function IFrameConnector(host, port, secure, basePath) {
+ babelHelpers.classCallCheck(this, IFrameConnector);
+
+ var _this = babelHelpers.possibleConstructorReturn(this, _XMLHttpConnector.call(this, host, port, secure, basePath));
+
+ _this.mid = 0;
+ _this.messages = {};
+ _this.doReceive = _this.doReceive.bind(_this);
+
+ addEventListener('message', _this.doReceive, false);
+ return _this;
+ }
+
+ IFrameConnector.prototype.load = function load(path) {
+ this.iframe = document.createElement('iframe');
+ this.iframe.src = this.origin + this.basePath + path;
+ this.iframe.setAttribute("style", IFrameConnector.style);
+ document.body.appendChild(this.iframe);
+
+ this.queue = [];
+ this.iframe.addEventListener('load', this.onLoad.bind(this), false);
+ };
+
+ IFrameConnector.prototype.onLoad = function onLoad() {
+ var queue = this.queue;
+
+ for (var i = 0; i < queue.length; ++i) {
+ this.postMessage(queue[i]);
+ }
+
+ this.queue = null;
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ IFrameConnector.prototype.doSend = function doSend(message, request, receive) {
+ var _this2 = this;
+
+ //binary data will be send and received directly
+ if (message.isBinary) {
+ return _XMLHttpConnector.prototype.doSend.call(this, message, request, receive);
+ }
+
+ if (!this.iframe) {
+ this.load(message.request.path);
+ }
+
+ var msg = {
+ mid: ++this.mid,
+ method: request.method,
+ path: request.path,
+ headers: request.headers,
+ entity: request.entity,
+ responseHeaders: Connector.RESPONSE_HEADERS
+ };
+
+ this.messages[msg.mid] = receive;
+
+ var strMsg = JSON.stringify(msg);
+ if (this.queue) {
+ this.queue.push(strMsg);
+ } else {
+ this.postMessage(strMsg);
+ }
+
+ if (!this.connected) {
+ setTimeout(function () {
+ if (_this2.messages[msg.mid]) {
+ delete _this2.messages[msg.mid];
+ receive({
+ status: 0,
+ error: new Error('Connection refused.')
+ });
+ }
+ }, 10000);
+ }
+ };
+
+ IFrameConnector.prototype.postMessage = function postMessage(msg) {
+ this.iframe.contentWindow.postMessage(msg, this.origin);
+ };
+
+ IFrameConnector.prototype.doReceive = function doReceive(event) {
+ if (event.origin !== this.origin || event.data[0] != '{') {
+ return;
+ }
+
+ var msg = JSON.parse(event.data);
+
+ var receive = this.messages[msg.mid];
+ if (receive) {
+ delete this.messages[msg.mid];
+ this.connected = true;
+
+ receive({
+ status: msg.status,
+ headers: msg.headers,
+ entity: msg.entity
+ });
+ }
+ };
+
+ return IFrameConnector;
+}(XMLHttpConnector);
+
+IFrameConnector.style = 'width:1px;height:1px;position:absolute;top:-10px;left:-10px;';
+
+Connector.connectors.push(IFrameConnector);
+
+module.exports = IFrameConnector;
+
+},{"23":23,"27":27}],25:[function(_dereq_,module,exports){
+"use strict";
+
+var CommunicationError = _dereq_(29);
+
+/**
+ * Checks whether the user uses google chrome.
+ */
+var isChrome = typeof window != 'undefined' && (!!window.chrome && /google/i.test(navigator.vendor) || /cros i686/i.test(window.navigator.platform));
+
+/**
+ * @alias connector.Message
+ */
+
+var Message = function () {
+ /**
+ * Creates a new message class with the given message specification
+ * @param {Object} specification
+ * @return {Class}
+ */
+ Message.create = function create(specification) {
+ var parts = specification.path.split('?');
+ var path = parts[0].split(/[:\*]\w*/);
+
+ var query = [];
+ if (parts[1]) {
+ parts[1].split('&').forEach(function (arg) {
+ var part = arg.split('=');
+ query.push(part[0]);
+ });
+ }
+
+ specification.dynamic = specification.path.indexOf('*') != -1;
+ specification.path = path;
+ specification.query = query;
+
+ return function (_Message) {
+ babelHelpers.inherits(_class, _Message);
+
+ function _class() {
+ babelHelpers.classCallCheck(this, _class);
+ return babelHelpers.possibleConstructorReturn(this, _Message.apply(this, arguments));
+ }
+
+ babelHelpers.createClass(_class, [{
+ key: 'spec',
+ get: function get() {
+ return specification;
+ }
+ }]);
+ return _class;
+ }(Message);
+ };
+
+ /**
+ * Creates a new message class with the given message specification and a full path
+ * @param {Object} specification
+ * @param {Object} members additional members applied to the created message
+ * @return {Class}
+ */
+
+
+ Message.createExternal = function createExternal(specification, members) {
+ specification.path = [specification.path];
+
+ /**
+ * @ignore
+ */
+ var cls = function (_Message2) {
+ babelHelpers.inherits(cls, _Message2);
+
+ function cls() {
+ babelHelpers.classCallCheck(this, cls);
+ return babelHelpers.possibleConstructorReturn(this, _Message2.apply(this, arguments));
+ }
+
+ babelHelpers.createClass(cls, [{
+ key: 'spec',
+ get: function get() {
+ return specification;
+ }
+ }]);
+ return cls;
+ }(Message);
+
+ Object.assign(cls.prototype, members);
+
+ return cls;
+ };
+
+ babelHelpers.createClass(Message, [{
+ key: 'isBinary',
+ get: function get() {
+ return this.request.type in Message.BINARY || this._responseType in Message.BINARY;
+ }
+
+ /**
+ * @param {string} arguments... The path arguments
+ */
+
+ }]);
+
+ function Message() {
+ babelHelpers.classCallCheck(this, Message);
+
+ /** @type boolean */
+ this.withCredentials = false;
+
+ /** @type util.TokenStorage */
+ this.tokenStorage = null;
+
+ /** @type connector.Message~progressCallback */
+ this._progress = null;
+
+ var args = arguments;
+ var index = 0;
+ var path = this.spec.path;
+ if (Object(path) instanceof Array) {
+ path = this.spec.path[0];
+ var len = this.spec.path.length;
+ for (var i = 1; i < len; ++i) {
+ if (this.spec.dynamic && len - 1 == i) {
+ path += args[index].split('/').map(encodeURIComponent).join('/');
+ index += 1;
+ } else {
+ path += encodeURIComponent(args[index++]) + this.spec.path[i];
+ }
+ }
+ }
+
+ var query = "";
+ for (var _i = 0; _i < this.spec.query.length; ++_i) {
+ var arg = args[index++];
+ if (arg !== undefined && arg !== null) {
+ query += query || ~path.indexOf("?") ? "&" : "?";
+ query += this.spec.query[_i] + '=' + encodeURIComponent(arg);
+ }
+ }
+
+ this.request = {
+ method: this.spec.method,
+ path: path + query,
+ entity: null,
+ headers: {}
+ };
+
+ if (args[index]) {
+ this.entity(args[index], 'json');
+ }
+
+ this.responseType('json');
+ }
+
+ /**
+ * Get/Sets the value of a the specified request header
+ * @param {string} name The header name
+ * @param {string=} value The header value if omitted the value will be returned
+ * @return {connector.Message|string} This message object
+ */
+
+
+ Message.prototype.header = function header(name, value) {
+ if (value !== undefined) {
+ this.request.headers[name] = value;
+ return this;
+ } else {
+ return this.request.headers[name];
+ }
+ };
+
+ /**
+ * sets the entity type
+ * @param {any} data The data to send
+ * @param {string} [type="json"] the type of the data one of 'json'|'text'|'blob'|'arraybuffer' defaults to 'json'
+ * @return {connector.Message} This message object
+ */
+
+
+ Message.prototype.entity = function entity(data, type) {
+ if (!type) {
+ if (typeof data === 'string') {
+ if (/^data:(.+?)(;base64)?,.*$/.test(data)) {
+ type = 'data-url';
+ } else {
+ type = 'text';
+ }
+ } else if (typeof Blob != 'undefined' && data instanceof Blob) {
+ type = 'blob';
+ } else if (typeof Buffer != 'undefined' && data instanceof Buffer) {
+ type = 'buffer';
+ } else if (typeof ArrayBuffer != 'undefined' && data instanceof ArrayBuffer) {
+ type = 'arraybuffer';
+ } else if (typeof FormData != 'undefined' && data instanceof FormData) {
+ type = 'form';
+ } else {
+ type = 'json';
+ }
+ }
+
+ this.request.type = type;
+ this.request.entity = data;
+ return this;
+ };
+
+ /**
+ * Get/Sets the mimeType
+ * @param {string=} mimeType the mimeType of the data
+ * @return {connector.Message} This message object
+ */
+
+
+ Message.prototype.mimeType = function mimeType(_mimeType) {
+ return this.header('content-type', _mimeType);
+ };
+
+ /**
+ * Get/Sets the contentLength
+ * @param {number=} contentLength the content length of the data
+ * @return {connector.Message} This message object
+ */
+
+
+ Message.prototype.contentLength = function contentLength(_contentLength) {
+ return this.header('content-length', _contentLength);
+ };
+
+ /**
+ * Get/Sets the request conditional If-Match header
+ * @param {string=} eTag the If-Match ETag value
+ * @return {connector.Message} This message object
+ */
+
+
+ Message.prototype.ifMatch = function ifMatch(eTag) {
+ return this.header('If-Match', this._formatETag(eTag));
+ };
+
+ /**
+ * Get/Sets the request a ETag based conditional header
+ * @param {string=} eTag The ETag value
+ * @return {connector.Message} This message object
+ */
+
+
+ Message.prototype.ifNoneMatch = function ifNoneMatch(eTag) {
+ return this.header('If-None-Match', this._formatETag(eTag));
+ };
+
+ /**
+ * Get/Sets the request date based conditional header
+ * @param {Date=} date The date value
+ * @return {connector.Message} This message object
+ */
+
+
+ Message.prototype.ifUnmodifiedSince = function ifUnmodifiedSince(date) {
+ //IE 10 returns UTC strings and not an RFC-1123 GMT date string
+ return this.header('if-unmodified-since', date && date.toUTCString().replace('UTC', 'GMT'));
+ };
+
+ /**
+ * Indicates that the request should not be served by a local cache
+ */
+
+
+ Message.prototype.noCache = function noCache() {
+ if (!isChrome) {
+ this.ifMatch('') // is needed for firefox or safari (but forbidden for chrome)
+ .ifNoneMatch('-'); // is needed for edge and ie (but forbidden for chrome)
+ }
+
+ return this.cacheControl('max-age=0, no-cache');
+ };
+
+ /**
+ * Get/Sets the cache control header
+ * @param {string=} value The cache control flags
+ * @return {connector.Message} This message object
+ */
+
+
+ Message.prototype.cacheControl = function cacheControl(value) {
+ return this.header('cache-control', value);
+ };
+
+ /**
+ * Get/Sets and encodes the acl of a file into the Baqend-Acl header
+ * @param {Acl=} acl the file acls
+ * @return {connector.Message} This message object
+ */
+
+
+ Message.prototype.acl = function acl(_acl) {
+ return this.header('baqend-acl', _acl && JSON.stringify(_acl));
+ };
+
+ /**
+ * Get/Sets the request accept header
+ * @param {string=} accept the accept header value
+ * @return {connector.Message} This message object
+ */
+
+
+ Message.prototype.accept = function accept(_accept) {
+ return this.header('accept', _accept);
+ };
+
+ /**
+ * Get/Sets the response type which should be returned
+ * @param {string=} type The response type one of 'json'|'text'|'blob'|'arraybuffer' defaults to 'json'
+ * @return {connector.Message} This message object
+ */
+
+
+ Message.prototype.responseType = function responseType(type) {
+ if (type !== undefined) {
+ this._responseType = type;
+ return this;
+ }
+
+ return this._responseType;
+ };
+
+ /**
+ * Get/Sets the progress callback
+ * @param {connector.Message~progressCallback} callback
+ * @return {connector.Message} This message object
+ */
+
+
+ Message.prototype.progress = function progress(callback) {
+ if (callback !== undefined) {
+ this._progress = callback;
+ return this;
+ }
+
+ return this._progress;
+ };
+
+ /**
+ * Adds the given String to the request path.
+ * If the parameter is an object the query string will be created.
+ *
+ * @param {string|Object} query which will added to the request path
+ */
+
+
+ Message.prototype.addQueryString = function addQueryString(query) {
+ var _this3 = this;
+
+ if (Object(query) instanceof String) {
+ this.request.path += query;
+ } else if (query) {
+ var sep = ~this.request.path.indexOf("?") ? "&" : "?";
+ Object.keys(query).forEach(function (key, i) {
+ _this3.request.path += sep + key + "=" + encodeURIComponent(query[key]);
+ if (i == 0) {
+ sep = "&";
+ }
+ });
+ }
+ return this;
+ };
+
+ Message.prototype._formatETag = function _formatETag(eTag) {
+ if (eTag && eTag != '*') {
+ eTag = '' + eTag;
+ if (eTag.indexOf('"') == -1) eTag = '"' + eTag + '"';
+ }
+
+ return eTag;
+ };
+
+ /**
+ * Handle the receive
+ * @param {Object} response The received response headers and data
+ */
+
+
+ Message.prototype.doReceive = function doReceive(response) {
+ if (this.spec.status.indexOf(response.status) == -1) {
+ throw new CommunicationError(this, response);
+ }
+ };
+
+ return Message;
+}();
+
+/**
+ * The message specification
+ * @name spec
+ * @memberOf connector.Message.prototype
+ * @type {Object}
+ */
+
+Object.assign(Message, {
+ /**
+ * @alias connector.Message.StatusCode
+ * @enum {number}
+ */
+ StatusCode: {
+ NOT_MODIFIED: 304,
+ BAD_CREDENTIALS: 460,
+ BUCKET_NOT_FOUND: 461,
+ INVALID_PERMISSION_MODIFICATION: 462,
+ INVALID_TYPE_VALUE: 463,
+ OBJECT_NOT_FOUND: 404,
+ OBJECT_OUT_OF_DATE: 412,
+ PERMISSION_DENIED: 466,
+ QUERY_DISPOSED: 467,
+ QUERY_NOT_SUPPORTED: 468,
+ SCHEMA_NOT_COMPATIBLE: 469,
+ SCHEMA_STILL_EXISTS: 470,
+ SYNTAX_ERROR: 471,
+ TRANSACTION_INACTIVE: 472,
+ TYPE_ALREADY_EXISTS: 473,
+ TYPE_STILL_REFERENCED: 474,
+ SCRIPT_ABORTION: 475
+ },
+
+ BINARY: {
+ blob: true,
+ buffer: true,
+ stream: true,
+ arraybuffer: true,
+ 'data-url': true,
+ 'base64': true
+ },
+
+ GoogleOAuth: Message.createExternal({
+ method: 'OAUTH',
+ path: 'https://accounts.google.com/o/oauth2/auth?response_type=code&access_type=online',
+ query: ["client_id", "scope", "state"],
+ status: [200]
+ }, {
+ addRedirectOrigin: function addRedirectOrigin(baseUri) {
+ this.addQueryString({
+ redirect_uri: baseUri + '/db/User/OAuth/google'
+ });
+ }
+ }),
+
+ FacebookOAuth: Message.createExternal({
+ method: 'OAUTH',
+ path: 'https://www.facebook.com/dialog/oauth?response_type=code',
+ query: ["client_id", "scope", "state"],
+ status: [200]
+ }, {
+ addRedirectOrigin: function addRedirectOrigin(baseUri) {
+ this.addQueryString({
+ redirect_uri: baseUri + '/db/User/OAuth/facebook'
+ });
+ }
+ }),
+
+ GitHubOAuth: Message.createExternal({
+ method: 'OAUTH',
+ path: 'https://github.com/login/oauth/authorize?response_type=code&access_type=online',
+ query: ["client_id", "scope", "state"],
+ status: [200]
+ }, {
+ addRedirectOrigin: function addRedirectOrigin(baseUri) {
+ this.addQueryString({
+ redirect_uri: baseUri + '/db/User/OAuth/github'
+ });
+ }
+ }),
+
+ LinkedInOAuth: Message.createExternal({
+ method: 'OAUTH',
+ path: 'https://www.linkedin.com/uas/oauth2/authorization?response_type=code&access_type=online',
+ query: ["client_id", "scope", "state"],
+ status: [200]
+ }, {
+ addRedirectOrigin: function addRedirectOrigin(baseUri) {
+ this.addQueryString({
+ redirect_uri: baseUri + '/db/User/OAuth/linkedin'
+ });
+ }
+ }),
+
+ TwitterOAuth: Message.createExternal({
+ method: 'OAUTH',
+ path: '',
+ query: [],
+ status: [200]
+ }, {
+ addRedirectOrigin: function addRedirectOrigin(baseUri) {
+ this.request.path = baseUri + '/db/User/OAuth1/twitter';
+ }
+ })
+});
+
+module.exports = Message;
+
+/**
+ * The progress callback is called, when you send a message to the server and a progress is noticed
+ * @callback connector.Message~progressCallback
+ * @param {ProgressEvent} event The Progress Event
+ * @return {*} unused
+ */
+
+},{"29":29}],26:[function(_dereq_,module,exports){
+"use strict";
+
+var Connector = _dereq_(23);
+var PersistentError = _dereq_(32);
+var http;
+var https;
+var stream;
+
+/**
+ * @alias connector.NodeConnector
+ * @extends connector.Connector
+ */
+
+var NodeConnector = function (_Connector) {
+ babelHelpers.inherits(NodeConnector, _Connector);
+
+ NodeConnector.isUsable = function isUsable(host, port, secure) {
+ if (!http) {
+ try {
+ http = _dereq_('http');
+ https = _dereq_('https');
+ stream = _dereq_('stream');
+ } catch (e) {}
+ }
+ //prevent using when it is shimmed
+ return http && http.Server;
+ };
+
+ function NodeConnector(host, port, secure, basePath) {
+ babelHelpers.classCallCheck(this, NodeConnector);
+
+ var _this = babelHelpers.possibleConstructorReturn(this, _Connector.call(this, host, port, secure, basePath));
+
+ _this.cookie = null;
+ _this.http = secure ? https : http;
+ return _this;
+ }
+
+ /**
+ * @inheritDoc
+ */
+
+
+ NodeConnector.prototype.doSend = function doSend(message, request, receive) {
+ var _this2 = this;
+
+ request.host = this.host;
+ request.port = this.port;
+ request.path = this.basePath + request.path;
+
+ var entity = request.entity;
+ var type = request.type;
+ var responseType = message.responseType();
+
+ if (this.cookie && message.withCredentials) request.headers['cookie'] = this.cookie;
+
+ var req = this.http.request(request, function (res) {
+ var cookie = res.headers['set-cookie'];
+ if (cookie) {
+ // cookie may be an array, convert it to a string
+ _this2.cookie = _this2.parseCookie(cookie + '');
+ }
+
+ var status = res.statusCode;
+ if (status >= 400) {
+ responseType = 'json';
+ }
+
+ if (responseType == 'stream') {
+ receive({
+ status: status,
+ headers: res.headers,
+ entity: res
+ });
+ return;
+ }
+
+ var binary = responseType && responseType != 'text' && responseType != 'json';
+ var chunks = [];
+ if (!binary) {
+ res.setEncoding('utf-8');
+ }
+
+ res.on('data', function (chunk) {
+ chunks.push(chunk);
+ });
+
+ res.on('end', function () {
+ receive({
+ status: status,
+ headers: res.headers,
+ entity: binary ? Buffer.concat(chunks) : chunks.join('')
+ });
+ });
+ });
+
+ req.on('error', function (e) {
+ receive({
+ status: 0,
+ error: e
+ });
+ });
+
+ if (type == 'stream') {
+ entity.pipe(req);
+ } else if (type == 'buffer') {
+ req.end(entity);
+ } else if (type) {
+ req.end(entity, 'utf8');
+ } else {
+ req.end();
+ }
+ };
+
+ /**
+ * Parse the cookie header
+ * @param {string} header
+ */
+
+
+ NodeConnector.prototype.parseCookie = function parseCookie(header) {
+ var parts = header.split(';');
+
+ for (var i = 0, part; part = parts[i]; ++i) {
+ if (part.indexOf('Expires=') == 0) {
+ var date = Date.parse(part.substring(8));
+ if (date < Date.now()) {
+ return null;
+ }
+ }
+ }
+
+ return parts[0];
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ NodeConnector.prototype.toFormat = function toFormat(message) {
+ var type = message.request.type;
+
+ if (type) {
+ var entity = message.request.entity;
+ var mimeType = message.mimeType();
+
+ switch (type) {
+ case 'stream':
+ if (!message.contentLength()) {
+ throw new PersistentError('You must specify a content length while making a stream based upload.');
+ }
+ break;
+ case 'buffer':
+ break;
+ case 'arraybuffer':
+ type = 'buffer';
+ entity = new Buffer(entity);
+ break;
+ case 'data-url':
+ var match = entity.match(/^data:(.+?)(;base64)?,(.*)$/);
+ var isBase64 = match[2];
+ entity = match[3];
+
+ type = 'buffer';
+ mimeType = mimeType || match[1];
+ if (isBase64) {
+ entity = new Buffer(entity, 'base64');
+ } else {
+ entity = new Buffer(decodeURIComponent(entity), 'utf8');
+ }
+
+ break;
+ case 'base64':
+ type = 'buffer';
+ entity = new Buffer(entity, 'base64');
+ break;
+ case 'json':
+ if (typeof entity != 'string') {
+ entity = JSON.stringify(entity);
+ }
+ break;
+ case 'text':
+ break;
+ default:
+ throw new Error('The request type ' + type + ' is not supported');
+ }
+
+ message.entity(entity, type).mimeType(mimeType);
+ }
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ NodeConnector.prototype.fromFormat = function fromFormat(response, entity, type) {
+ if (type == 'json') {
+ entity = JSON.parse(entity);
+ } else if (type == 'data-url' || type == 'base64') {
+ entity = entity.toString('base64');
+
+ if (type == 'data-url') {
+ entity = 'data:' + response.headers['content-type'] + ';base64,' + entity;
+ }
+ } else if (type == 'arraybuffer') {
+ entity = entity.buffer.slice(entity.byteOffset, entity.byteOffset + entity.byteLength);
+ }
+
+ return entity;
+ };
+
+ return NodeConnector;
+}(Connector);
+
+Connector.connectors.push(NodeConnector);
+
+module.exports = NodeConnector;
+
+},{"23":23,"32":32,"undefined":undefined}],27:[function(_dereq_,module,exports){
+"use strict";
+
+var Connector = _dereq_(23);
+
+/**
+ * @alias connector.XMLHttpConnector
+ * @extends connector.Connector
+ */
+
+var XMLHttpConnector = function (_Connector) {
+ babelHelpers.inherits(XMLHttpConnector, _Connector);
+
+ function XMLHttpConnector() {
+ babelHelpers.classCallCheck(this, XMLHttpConnector);
+ return babelHelpers.possibleConstructorReturn(this, _Connector.apply(this, arguments));
+ }
+
+ /**
+ * Indicates if this connector implementation is usable for the given host and port
+ * @param {string} host
+ * @param {number} port
+ * @param {boolean} secure
+ * @returns {boolean}
+ */
+ XMLHttpConnector.isUsable = function isUsable(host, port, secure) {
+ if (typeof window == 'undefined') return false;
+
+ var locationSecure = location.protocol == 'https:';
+ var locationPort = location.port || (locationSecure ? 443 : 80);
+
+ return location.hostname == host && locationPort == port && locationSecure == secure;
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ XMLHttpConnector.prototype.doSend = function doSend(message, request, receive) {
+ if (request.method == 'OAUTH') {
+ addEventListener("storage", function handle(event) {
+ if (event.key == 'oauth-response') {
+ receive(JSON.parse(event.newValue));
+ localStorage.removeItem('oauth-response');
+ removeEventListener("storage", handle, false);
+ }
+ }, false);
+ return;
+ }
+
+ var xhr = new XMLHttpRequest();
+
+ var url = this.origin + this.basePath + request.path;
+
+ xhr.onreadystatechange = function () {
+ //if we receive an error switch the response type to json
+ if (xhr.readyState == 2 && xhr.status >= 400) xhr.responseType = 'text';
+
+ if (xhr.readyState == 4) {
+ var response = {
+ headers: {},
+ status: xhr.status,
+ entity: xhr.response || xhr.responseText
+ };
+
+ Connector.RESPONSE_HEADERS.forEach(function (name) {
+ response.headers[name] = xhr.getResponseHeader(name);
+ });
+
+ receive(response);
+ }
+ };
+
+ // Set the message progress callback
+ xhr.upload.onprogress = message.progress();
+
+ xhr.open(request.method, url, true);
+
+ var entity = request.entity;
+ var headers = request.headers;
+ for (var name in headers) {
+ xhr.setRequestHeader(name, headers[name]);
+ }xhr.withCredentials = message.withCredentials;
+
+ switch (message.responseType()) {
+ case 'arraybuffer':
+ xhr.responseType = 'arraybuffer';
+ break;
+ case 'blob':
+ case 'data-url':
+ case 'base64':
+ xhr.responseType = 'blob';
+ break;
+ }
+
+ xhr.send(entity);
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ XMLHttpConnector.prototype.fromFormat = function fromFormat(response, entity, type) {
+ if (type == 'json') {
+ entity = JSON.parse(entity);
+ } else if (type == 'data-url' || type == 'base64') {
+ var _ret = function () {
+ var reader = new FileReader();
+ reader.readAsDataURL(entity);
+
+ return {
+ v: new Promise(function (resolve, reject) {
+ reader.onload = resolve;
+ reader.onerror = reject;
+ }).then(function () {
+ var result = reader.result;
+
+ if (type == 'base64') result = result.substring(result.indexOf(',') + 1);
+
+ return result;
+ })
+ };
+ }();
+
+ if ((typeof _ret === 'undefined' ? 'undefined' : babelHelpers.typeof(_ret)) === "object") return _ret.v;
+ }
+
+ return entity;
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ XMLHttpConnector.prototype.toFormat = function toFormat(message) {
+ var type = message.request.type;
+
+ if (type) {
+ var entity = message.request.entity;
+ var mimeType = message.mimeType();
+ switch (type) {
+ case 'blob':
+ mimeType = mimeType || entity.type;
+ break;
+ case 'arraybuffer':
+ case 'form':
+ break;
+ case 'data-url':
+ var match = entity.match(/^data:(.+?)(;base64)?,(.*)$/);
+ var isBase64 = match[2];
+ entity = match[3];
+
+ type = 'blob';
+ mimeType = mimeType || match[1];
+ if (!isBase64) {
+ entity = decodeURIComponent(entity);
+ break;
+ }
+
+ //fallthrough
+ case 'base64':
+ var binaryStr = atob(entity),
+ len = binaryStr.length;
+ var array = new Uint8Array(len);
+ for (var i = 0; i < len; ++i) {
+ array[i] = binaryStr.charCodeAt(i);
+ }
+ type = 'blob';
+ entity = new Blob([array], { type: mimeType });
+ break;
+ case 'json':
+ if (typeof entity != 'string') {
+ entity = JSON.stringify(entity);
+ }
+ break;
+ case 'text':
+ break;
+ }
+
+ message.entity(entity, type).mimeType(mimeType);
+ }
+ };
+
+ return XMLHttpConnector;
+}(Connector);
+
+Connector.connectors.push(XMLHttpConnector);
+
+module.exports = XMLHttpConnector;
+
+},{"23":23}],28:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * @namespace connector
+ */
+
+exports.Message = _dereq_(25);
+exports.Connector = _dereq_(23);
+exports.NodeConnector = _dereq_(26);
+exports.XMLHttpConnector = _dereq_(27);
+exports.IFrameConnector = _dereq_(24);
+
+},{"23":23,"24":24,"25":25,"26":26,"27":27}],29:[function(_dereq_,module,exports){
+"use strict";
+
+var PersistentError = _dereq_(32);
+
+/**
+ * @alias error.CommunicationError
+ * @extends error.PersistentError
+ */
+
+var CommunicationError = function (_PersistentError) {
+ babelHelpers.inherits(CommunicationError, _PersistentError);
+
+ /**
+ * @param {connector.Message} httpMessage The http message which was send
+ * @param {Object} response The received entity headers and content
+ */
+ function CommunicationError(httpMessage, response) {
+ babelHelpers.classCallCheck(this, CommunicationError);
+
+ var entity = response.entity || response.error || {};
+ var state = response.status == 0 ? 'Request' : 'Response';
+ var message = entity.message || 'Handling the ' + state + ' for ' + httpMessage.request.method + ' ' + httpMessage.request.path;
+
+ var _this = babelHelpers.possibleConstructorReturn(this, _PersistentError.call(this, message, entity));
+
+ _this.name = entity.className || 'CommunicationError';
+ _this.reason = entity.reason || 'Communication failed';
+ _this.status = response.status;
+
+ if (entity.data) _this.data = entity.data;
+
+ var cause = entity;
+ while (cause && cause.stackTrace) {
+ _this.stack += '\nServerside Caused by: ' + cause.className + ' ' + cause.message;
+
+ var stackTrace = cause.stackTrace;
+ for (var i = 0; i < stackTrace.length; ++i) {
+ var el = stackTrace[i];
+
+ _this.stack += '\n at ' + el.className + '.' + el.methodName;
+ _this.stack += ' (' + el.fileName + ':' + el.lineNumber + ')';
+ }
+
+ cause = cause.cause;
+ }
+ return _this;
+ }
+
+ return CommunicationError;
+}(PersistentError);
+
+module.exports = CommunicationError;
+
+},{"32":32}],30:[function(_dereq_,module,exports){
+"use strict";
+
+var PersistentError = _dereq_(32);
+
+/**
+ * @alias error.EntityExistsError
+ * @extends error.PersistentError
+ */
+
+var EntityExistsError = function (_PersistentError) {
+ babelHelpers.inherits(EntityExistsError, _PersistentError);
+
+ /**
+ * @param {string} entity
+ */
+ function EntityExistsError(entity) {
+ babelHelpers.classCallCheck(this, EntityExistsError);
+
+ var _this = babelHelpers.possibleConstructorReturn(this, _PersistentError.call(this, 'The entity ' + entity + ' is managed by a different db.'));
+
+ _this.entity = entity;
+ return _this;
+ }
+
+ return EntityExistsError;
+}(PersistentError);
+
+module.exports = EntityExistsError;
+
+},{"32":32}],31:[function(_dereq_,module,exports){
+"use strict";
+
+var PersistentError = _dereq_(32);
+
+/**
+ * @alias error.IllegalEntityError
+ * @extends error.PersistentError
+ */
+
+var IllegalEntityError = function (_PersistentError) {
+ babelHelpers.inherits(IllegalEntityError, _PersistentError);
+
+ /**
+ * @param {binding.Entity} entity
+ */
+ function IllegalEntityError(entity) {
+ babelHelpers.classCallCheck(this, IllegalEntityError);
+
+ var _this = babelHelpers.possibleConstructorReturn(this, _PersistentError.call(this, 'Entity ' + entity + ' is not a valid entity'));
+
+ _this.entity = entity;
+ return _this;
+ }
+
+ return IllegalEntityError;
+}(PersistentError);
+
+module.exports = IllegalEntityError;
+
+},{"32":32}],32:[function(_dereq_,module,exports){
+"use strict";
+/**
+ * @class error.PersistentError
+ * @extends Error
+ *
+ * @param {string} message
+ * @param {Error=} cause
+ */
+
+//do not use class here, since we can't change the class prototype
+
+function PersistentError(message, cause) {
+ message = message ? message : 'An unexpected persistent error occured.';
+
+ if (Error.hasOwnProperty('captureStackTrace')) {
+ Error.captureStackTrace(this, this.constructor);
+ } else {
+ this.stack = new Error().stack;
+ }
+
+ this.message = message;
+ this.name = this.constructor.name;
+
+ if (cause) {
+ this.cause = cause;
+ if (cause.stack) {
+ this.stack += '\nCaused By: ' + cause.stack;
+ }
+ }
+}
+
+PersistentError.of = function of(error) {
+ if (error instanceof PersistentError) {
+ return error;
+ } else {
+ return new PersistentError(null, error);
+ }
+};
+
+//custom errors must be manually extended for babel, otherwise the super call destroys the origin 'this' reference
+PersistentError.prototype = Object.create(Error.prototype, {
+ constructor: {
+ value: PersistentError,
+ enumerable: false,
+ configurable: true
+ }
+});
+
+module.exports = PersistentError;
+
+},{}],33:[function(_dereq_,module,exports){
+"use strict";
+
+var PersistentError = _dereq_(32);
+
+/**
+ * @alias error.RollbackError
+ * @extends error.PersistentError
+ */
+
+var RollbackError = function (_PersistentError) {
+ babelHelpers.inherits(RollbackError, _PersistentError);
+
+ /**
+ * @param {Error} cause
+ */
+ function RollbackError(cause) {
+ babelHelpers.classCallCheck(this, RollbackError);
+ return babelHelpers.possibleConstructorReturn(this, _PersistentError.call(this, 'The transaction has been rollbacked', cause));
+ }
+
+ return RollbackError;
+}(PersistentError);
+
+module.exports = RollbackError;
+
+},{"32":32}],34:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * @namespace error
+ */
+
+exports.CommunicationError = _dereq_(29);
+exports.IllegalEntityError = _dereq_(31);
+exports.EntityExistsError = _dereq_(30);
+exports.PersistentError = _dereq_(32);
+exports.RollbackError = _dereq_(33);
+
+},{"29":29,"30":30,"31":31,"32":32,"33":33}],35:[function(_dereq_,module,exports){
+'use strict';
+
+_dereq_(163);
+
+module.exports = _dereq_(6);
+
+},{"163":163,"6":6}],36:[function(_dereq_,module,exports){
+'use strict';
+
+var Message = _dereq_(25);
+
+/**
+ * Get the list of all available subresources
+ *
+ * @class message.ListAllResources
+ * @extends connector.Message
+ *
+ */
+exports.ListAllResources = Message.create({
+ method: 'GET',
+ path: '/',
+ status: [200]
+});
+
+/**
+ * Get the API version of the Orestes-Server
+ *
+ * @class message.ApiVersion
+ * @extends connector.Message
+ *
+ */
+exports.ApiVersion = Message.create({
+ method: 'GET',
+ path: '/version',
+ status: [200]
+});
+
+/**
+ * Gets the event Endpoint
+ *
+ * @class message.Events
+ * @extends connector.Message
+ *
+ */
+exports.EventsUrl = Message.create({
+ method: 'GET',
+ path: '/events-url',
+ status: [200]
+});
+
+/**
+ * The Swagger specification of the Orestes-Server
+ *
+ * @class message.Specification
+ * @extends connector.Message
+ *
+ */
+exports.Specification = Message.create({
+ method: 'GET',
+ path: '/spec',
+ status: [200]
+});
+
+/**
+ * Returns all changed objects
+ *
+ * @class message.GetBloomFilter
+ * @extends connector.Message
+ *
+ */
+exports.GetBloomFilter = Message.create({
+ method: 'GET',
+ path: '/bloomfilter',
+ status: [200]
+});
+
+/**
+ * Get the current Orestes config
+ *
+ * @class message.GetOrestesConfig
+ * @extends connector.Message
+ *
+ */
+exports.GetOrestesConfig = Message.create({
+ method: 'GET',
+ path: '/config',
+ status: [200]
+});
+
+/**
+ * Updates the current Orestes config
+ *
+ * @class message.UpdateOrestesConfig
+ * @extends connector.Message
+ *
+ * @param body {Object} The massage Content
+ */
+exports.UpdateOrestesConfig = Message.create({
+ method: 'PUT',
+ path: '/config',
+ status: [200, 202]
+});
+
+/**
+ * Connects a browser to this server
+ *
+ * @class message.Connect
+ * @extends connector.Message
+ *
+ */
+exports.Connect = Message.create({
+ method: 'GET',
+ path: '/connect',
+ status: [200]
+});
+
+/**
+ * Gets the status of the server health
+ *
+ * @class message.Status
+ * @extends connector.Message
+ *
+ */
+exports.Status = Message.create({
+ method: 'GET',
+ path: '/status',
+ status: [200]
+});
+
+/**
+ * Determines whether the IP has exceeded its rate limit
+ *
+ * @class message.BannedIp
+ * @extends connector.Message
+ *
+ * @param ip {Object} The ip to test
+ */
+exports.BannedIp = Message.create({
+ method: 'GET',
+ path: '/banned/:ip',
+ status: [204]
+});
+
+/**
+ * Always returns banned status for proper CDN handling
+ *
+ * @class message.Banned
+ * @extends connector.Message
+ *
+ */
+exports.Banned = Message.create({
+ method: 'GET',
+ path: '/banned',
+ status: []
+});
+
+/**
+ * Clears all rate-limiting information for all IPs
+ *
+ * @class message.Unban
+ * @extends connector.Message
+ *
+ */
+exports.Unban = Message.create({
+ method: 'DELETE',
+ path: '/banned',
+ status: [204]
+});
+
+/**
+ * Clears rate-limiting information for given IPs
+ *
+ * @class message.UnbanIp
+ * @extends connector.Message
+ *
+ * @param ip {Object} The ip to reset
+ */
+exports.UnbanIp = Message.create({
+ method: 'DELETE',
+ path: '/banned/:ip',
+ status: [204]
+});
+
+/**
+ * List all available bucket names
+ * List all bucket
+ *
+ * @class message.GetBucketNames
+ * @extends connector.Message
+ *
+ */
+exports.GetBucketNames = Message.create({
+ method: 'GET',
+ path: '/db',
+ status: [200]
+});
+
+/**
+ * List all bucket objects
+ * List all object ids of the bucket
+ *
+ * @class message.GetBucketIds
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param start {Object} The offset to skip
+ * @param count {Object} The upper limit to return
+ */
+exports.GetBucketIds = Message.create({
+ method: 'GET',
+ path: '/db/:bucket/ids?start=0&count=-1',
+ status: [200]
+});
+
+/**
+ * Dumps all objects of the bucket
+ * Exports the complete Bucket content
+ *
+ * @class message.ExportBucket
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ */
+exports.ExportBucket = Message.create({
+ method: 'GET',
+ path: '/db/:bucket',
+ status: [200]
+});
+
+/**
+ * Upload all objects to the bucket
+ * Imports the complete Bucket content
+ *
+ * @class message.ImportBucket
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param body {Object} The massage Content
+ */
+exports.ImportBucket = Message.create({
+ method: 'PUT',
+ path: '/db/:bucket',
+ status: [200]
+});
+
+/**
+ * Deletes all objects of the bucket
+ * Deletes all objects of the bucket
+ *
+ * @class message.TruncateBucket
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ */
+exports.TruncateBucket = Message.create({
+ method: 'DELETE',
+ path: '/db/:bucket',
+ status: [200]
+});
+
+/**
+ * Create object
+ * Create the given Object.
+ * The object will be created and gets a unique oid.
+ *
+ * @class message.CreateObject
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param body {Object} The massage Content
+ */
+exports.CreateObject = Message.create({
+ method: 'POST',
+ path: '/db/:bucket',
+ status: [201, 202]
+});
+
+/**
+ * Get object
+ * Returns the specified object. Each object has one unique identifier and therefore only one location.
+ *
+ * @class message.GetObject
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param oid {Object} The unique object identifier
+ */
+exports.GetObject = Message.create({
+ method: 'GET',
+ path: '/db/:bucket/:oid',
+ status: [200, 304]
+});
+
+/**
+ * Replace object
+ * Replace the current object with the updated one.
+ * To update a specific version of the object a version Number can be provided in the If-Match header.
+ * The update will only be accepted, if the current version matchesToBeForwarded the provided one, otherwise the update
+ * will be rejected.
+ * You can use the * wildcard to match any existing object, but prevents a insertion if the object doesn't exists.
+ *
+ * @class message.ReplaceObject
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param oid {Object} The unique object identifier
+ * @param body {Object} The massage Content
+ */
+exports.ReplaceObject = Message.create({
+ method: 'PUT',
+ path: '/db/:bucket/:oid',
+ status: [200, 202]
+});
+
+/**
+ * Deletes the object
+ * Deletes the object. The If-Match Header can be used to specify an expected version. The object will
+ * only be deleted if the version matchesToBeForwarded the provided one. The * wildcard can be used to match any existing
+ * version but results in an error if the object doesn't exists.
+ *
+ * @class message.DeleteObject
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param oid {Object} The unique object identifier
+ */
+exports.DeleteObject = Message.create({
+ method: 'DELETE',
+ path: '/db/:bucket/:oid',
+ status: [202, 204]
+});
+
+/**
+ * Get all available class schemas
+ * Gets the complete schema
+ *
+ * @class message.GetAllSchemas
+ * @extends connector.Message
+ *
+ */
+exports.GetAllSchemas = Message.create({
+ method: 'GET',
+ path: '/schema',
+ status: [200]
+});
+
+/**
+ * Create new class schemas and update existing class schemas
+ * Updates the complete schema, merge all changes, reject the schema update if the schema changes aren't compatible
+ *
+ * @class message.UpdateAllSchemas
+ * @extends connector.Message
+ *
+ * @param body {Object} The massage Content
+ */
+exports.UpdateAllSchemas = Message.create({
+ method: 'POST',
+ path: '/schema',
+ status: [200]
+});
+
+/**
+ * Replace all currently created schemas with the new ones
+ * Replace the complete schema, with the new one.
+ *
+ * @class message.ReplaceAllSchemas
+ * @extends connector.Message
+ *
+ * @param body {Object} The massage Content
+ */
+exports.ReplaceAllSchemas = Message.create({
+ method: 'PUT',
+ path: '/schema',
+ status: [200]
+});
+
+/**
+ * Get the class schema
+ * Returns the schema definition of the class
+ * The class definition contains a link to its parent class and all persistable fields with there types of the class
+ *
+ * @class message.GetSchema
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ */
+exports.GetSchema = Message.create({
+ method: 'GET',
+ path: '/schema/:bucket',
+ status: [200]
+});
+
+/**
+ * Update the class schema
+ * Modify the schema definition of the class by adding all missing fields
+ *
+ * @class message.UpdateSchema
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param body {Object} The massage Content
+ */
+exports.UpdateSchema = Message.create({
+ method: 'POST',
+ path: '/schema/:bucket',
+ status: [200]
+});
+
+/**
+ * Replace the class schema
+ * Replace the schema definition of the class
+ *
+ * @class message.ReplaceSchema
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param body {Object} The massage Content
+ */
+exports.ReplaceSchema = Message.create({
+ method: 'PUT',
+ path: '/schema/:bucket',
+ status: [200]
+});
+
+/**
+ * Delete the class schema
+ * Delete the schema definition of the class
+ *
+ * @class message.DeleteSchema
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ */
+exports.DeleteSchema = Message.create({
+ method: 'DELETE',
+ path: '/schema/:bucket',
+ status: [204]
+});
+
+/**
+ * Executes a basic ad-hoc query
+ * Executes the given query and returns a list of matching objects.
+ *
+ * @class message.AdhocQuery
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param q {Object} The query
+ * @param eager {Object} indicates if the query result should be send back as ids or as objects
+ * @param start {Object} The offset to start from
+ * @param count {Object} The number of objects to list
+ * @param sort {Object} The sort object
+ */
+exports.AdhocQuery = Message.create({
+ method: 'GET',
+ path: '/db/:bucket/query?q&start=0&count=-1&sort=&eager=',
+ status: [200]
+});
+
+/**
+ * Executes a basic ad-hoc query
+ * Executes the given query and returns a list of matching objects.
+ *
+ * @class message.AdhocQueryPOST
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param start {Object} The offset to start from
+ * @param count {Object} The number of objects to list
+ * @param sort {Object} The sort object
+ * @param body {Object} The massage Content
+ */
+exports.AdhocQueryPOST = Message.create({
+ method: 'POST',
+ path: '/db/:bucket/query?start=0&count=-1&sort=',
+ status: [200]
+});
+
+/**
+ * Executes a count query
+ * Executes the given query and returns the number of objects that match the query
+ *
+ * @class message.AdhocCountQuery
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param q {Object} The query
+ */
+exports.AdhocCountQuery = Message.create({
+ method: 'GET',
+ path: '/db/:bucket/count?q',
+ status: [200]
+});
+
+/**
+ * Executes a count query
+ * Executes the given query and returns the number of objects that match the query
+ *
+ * @class message.AdhocCountQueryPOST
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param body {Object} The massage Content
+ */
+exports.AdhocCountQueryPOST = Message.create({
+ method: 'POST',
+ path: '/db/:bucket/count',
+ status: [200]
+});
+
+/**
+ * List all Query subresources
+ *
+ * @class message.ListQueryResources
+ * @extends connector.Message
+ *
+ */
+exports.ListQueryResources = Message.create({
+ method: 'GET',
+ path: '/query',
+ status: [200]
+});
+
+/**
+ * Creates a prepared query
+ *
+ * @class message.CreateQuery
+ * @extends connector.Message
+ *
+ * @param body {Object} The massage Content
+ */
+exports.CreateQuery = Message.create({
+ method: 'POST',
+ path: '/query',
+ status: [201]
+});
+
+/**
+ * List all subresources of a query
+ *
+ * @class message.ListThisQueryResources
+ * @extends connector.Message
+ *
+ * @param qid {Object} The query id
+ */
+exports.ListThisQueryResources = Message.create({
+ method: 'GET',
+ path: '/query/:qid',
+ status: [200]
+});
+
+/**
+ * Get the query string
+ *
+ * @class message.GetQueryCode
+ * @extends connector.Message
+ *
+ * @param qid {Object} The query id
+ */
+exports.GetQueryCode = Message.create({
+ method: 'GET',
+ path: '/query/:qid/source',
+ status: [200]
+});
+
+/**
+ * Executes a prepared query
+ *
+ * @class message.RunQuery
+ * @extends connector.Message
+ *
+ * @param start {Object} The offset from where to start from
+ * @param count {Object} The number of objects to enlist
+ * @param qid {Object} The query id
+ */
+exports.RunQuery = Message.create({
+ method: 'GET',
+ path: '/query/:qid/result?start=0&count=-1',
+ status: [200]
+});
+
+/**
+ * Get the declared query parameters
+ *
+ * @class message.GetQueryParameters
+ * @extends connector.Message
+ *
+ * @param qid {Object} The query id
+ */
+exports.GetQueryParameters = Message.create({
+ method: 'GET',
+ path: '/query/:qid/parameters',
+ status: [200]
+});
+
+/**
+ * Starts a new Transaction
+ *
+ * @class message.NewTransaction
+ * @extends connector.Message
+ *
+ */
+exports.NewTransaction = Message.create({
+ method: 'POST',
+ path: '/transaction',
+ status: [201]
+});
+
+/**
+ * Commits the transaction
+ * If the transaction can be completed a list of all changed objects with their updated versions are returned.
+ *
+ * @class message.CommitTransaction
+ * @extends connector.Message
+ *
+ * @param tid {Object} The transaction id
+ * @param body {Object} The massage Content
+ */
+exports.CommitTransaction = Message.create({
+ method: 'PUT',
+ path: '/transaction/:tid/committed',
+ status: [200]
+});
+
+/**
+ * Returns the object in the given version or the newest version if the given does not exist.
+ *
+ * @class message.GetObjectInExplicitVersion
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param oid {Object} The unique object identifier
+ * @param version {Object} The version to load
+ */
+exports.GetObjectInExplicitVersion = Message.create({
+ method: 'GET',
+ path: '/db/:bucket/:oid/:version',
+ status: [200]
+});
+
+/**
+ * Update the object
+ * Executes the partial updates on the object.
+ * To update an object an explicit version must be provided in the If-Match header.
+ * If the version is not equal to the current object version the update will be aborted.
+ * The version identifier Any (*) can be used to skip the version validation and therefore
+ * the update will always be applied.
+ *
+ * @class message.UpdatePartially
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param oid {Object} The unique object identifier
+ * @param body {Object} The massage Content
+ */
+exports.UpdatePartially = Message.create({
+ method: 'POST',
+ path: '/db/:bucket/:oid',
+ status: [204]
+});
+
+/**
+ * Update the object field
+ * Executes the partial update on a object field.
+ * To update an object an explicit version must be provided in the If-Match header.
+ * If the version is not equal to the current object version the update will be aborted.
+ * The version identifier Any (*) can be used to skip the version validation and therefore
+ * the update will always be applied.
+ *
+ * @class message.UpdateField
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param field {Object} The field name
+ * @param oid {Object} The unique object identifier
+ * @param body {Object} The massage Content
+ */
+exports.UpdateField = Message.create({
+ method: 'POST',
+ path: '/db/:bucket/:oid/:field',
+ status: [204]
+});
+
+/**
+ * Method to login a user
+ * Log in a user by it's credentials
+ *
+ * @class message.Login
+ * @extends connector.Message
+ *
+ * @param body {Object} The massage Content
+ */
+exports.Login = Message.create({
+ method: 'POST',
+ path: '/db/User/login',
+ status: [200]
+});
+
+/**
+ * Method to register a user
+ * Register and creates a new user
+ *
+ * @class message.Register
+ * @extends connector.Message
+ *
+ * @param body {Object} The massage Content
+ */
+exports.Register = Message.create({
+ method: 'POST',
+ path: '/db/User/register',
+ status: [200, 204]
+});
+
+/**
+ * Method to load the current user object
+ * Gets the user object of the currently logged in user
+ *
+ * @class message.Me
+ * @extends connector.Message
+ *
+ */
+exports.Me = Message.create({
+ method: 'GET',
+ path: '/db/User/me',
+ status: [200]
+});
+
+/**
+ * Method to validate a user token
+ * Validates if a given token is still valid
+ *
+ * @class message.ValidateUser
+ * @extends connector.Message
+ *
+ */
+exports.ValidateUser = Message.create({
+ method: 'GET',
+ path: '/db/User/validate',
+ status: [200]
+});
+
+/**
+ * Method to remove token cookie
+ * Log out a user by removing the cookie token
+ *
+ * @class message.Logout
+ * @extends connector.Message
+ *
+ */
+exports.Logout = Message.create({
+ method: 'GET',
+ path: '/db/User/logout',
+ status: [204]
+});
+
+/**
+ * Method to change the password
+ *
+ * @class message.NewPassword
+ * @extends connector.Message
+ *
+ * @param body {Object} The massage Content
+ */
+exports.NewPassword = Message.create({
+ method: 'POST',
+ path: '/db/User/password',
+ status: [200]
+});
+
+/**
+ * Method to verify user by a given token
+ *
+ * @class message.Verify
+ * @extends connector.Message
+ *
+ * @param token {Object} Token to verify the user
+ */
+exports.Verify = Message.create({
+ method: 'GET',
+ path: '/db/User/verify?token=',
+ status: [204]
+});
+
+/**
+ * Method to register or login using an OAuth provider.
+ * This resource is invoked by the provider with a redirect after the user granted permission.
+ *
+ * @class message.OAuth2
+ * @extends connector.Message
+ *
+ * @param oauth_verifier {Object} OAuth 1.0 code
+ * @param code {Object} The code written by the provider
+ * @param provider {Object} The OAuth provider
+ * @param oauth_token {Object} OAuth 1.0 identifier
+ * @param error_description {Object} The error description of the oauth provider
+ * @param state {Object} On true a token will be returned
+ */
+exports.OAuth2 = Message.create({
+ method: 'GET',
+ path: '/db/User/OAuth/:provider?state=&code=&oauth_verifier=&oauth_token=&error_description=',
+ status: [200]
+});
+
+/**
+ * Method to invoke a OAuth-1.0 login/register
+ * The resource requests a request-token and redirects the user to the provider page to log-in and grant permission for
+ * your application.
+ *
+ * @class message.OAuth1
+ * @extends connector.Message
+ *
+ * @param provider {Object} The OAuth provider
+ */
+exports.OAuth1 = Message.create({
+ method: 'GET',
+ path: '/db/User/OAuth1/:provider',
+ status: [200]
+});
+
+/**
+ * Gets the code of the the given bucket and type
+ *
+ * @class message.GetBaqendCode
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param type {Object} The type of the script
+ */
+exports.GetBaqendCode = Message.create({
+ method: 'GET',
+ path: '/code/:bucket/:type',
+ status: [200]
+});
+
+/**
+ * Sets the code of the bucket and type
+ *
+ * @class message.SetBaqendCode
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param type {Object} The type of the script
+ * @param body {Object} The massage Content
+ */
+exports.SetBaqendCode = Message.create({
+ method: 'PUT',
+ path: '/code/:bucket/:type',
+ status: [200, 202]
+});
+
+/**
+ * Delete the code of the given bucket and type
+ *
+ * @class message.DeleteBaqendCode
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param type {Object} The type of the script
+ */
+exports.DeleteBaqendCode = Message.create({
+ method: 'DELETE',
+ path: '/code/:bucket/:type',
+ status: [202, 204]
+});
+
+/**
+ * Calls the module of the specific bucket
+ *
+ * @class message.PostBaqendModule
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The method name
+ */
+exports.PostBaqendModule = Message.create({
+ method: 'POST',
+ path: '/code/:bucket',
+ status: [200, 204]
+});
+
+/**
+ * Calls the module of the specific bucket
+ *
+ * @class message.GetBaqendModule
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The module name
+ */
+exports.GetBaqendModule = Message.create({
+ method: 'GET',
+ path: '/code/:bucket',
+ status: [200, 204]
+});
+
+/**
+ * List all available modules
+ *
+ * @class message.GetAllModules
+ * @extends connector.Message
+ *
+ */
+exports.GetAllModules = Message.create({
+ method: 'GET',
+ path: '/code',
+ status: [200]
+});
+
+/**
+ * Get all file ID's in the given folder
+ * Retrieve meta-information about all accessible Files and folders in a specified folder.
+ *
+ * @class message.ListFiles
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param path {Object} The folder to list
+ * @param start {Object} The file/folder name from where to start listing
+ * @param count {Object} The upper limit to return.
+ */
+exports.ListFiles = Message.create({
+ method: 'GET',
+ path: '/file/:bucket/ids?path=/&start=&count=-1',
+ status: [200]
+});
+
+/**
+ * Get all buckets
+ * Get all buckets.
+ *
+ * @class message.ListBuckets
+ * @extends connector.Message
+ *
+ */
+exports.ListBuckets = Message.create({
+ method: 'GET',
+ path: '/file/buckets',
+ status: [200]
+});
+
+/**
+ * Retrieves the bucket Metadata
+ * The bucket metadata object contains the bucketAcl
+ *
+ * @class message.GetFileBucketMetadata
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ */
+exports.GetFileBucketMetadata = Message.create({
+ method: 'GET',
+ path: '/file/:bucket',
+ status: [200]
+});
+
+/**
+ * Sets the Bucket Metadata
+ * Creates or replaces the bucket Metadata to control permission access to all included Files.
+ *
+ * @class message.SetFileBucketMetadata
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param body {Object} The massage Content
+ */
+exports.SetFileBucketMetadata = Message.create({
+ method: 'PUT',
+ path: '/file/:bucket',
+ status: [204]
+});
+
+/**
+ * deletes all files of a file Bucket
+ * Deletes the bucket and all its content
+ *
+ * @class message.DeleteFileBucket
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ */
+exports.DeleteFileBucket = Message.create({
+ method: 'DELETE',
+ path: '/file/:bucket',
+ status: [204]
+});
+
+/**
+ * Creates a new file with a random UUID
+ * Creates a File with a random ID, only Insert permissions are required
+ *
+ * @class message.CreateFile
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ */
+exports.CreateFile = Message.create({
+ method: 'POST',
+ path: '/file/:bucket',
+ status: [200]
+});
+
+/**
+ * Download a file
+ * Download a file.
+ *
+ * @class message.DownloadFile
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param oid {String} The unique object identifier
+ */
+exports.DownloadFile = Message.create({
+ method: 'GET',
+ path: '/file/:bucket/*oid',
+ status: [200, 304]
+});
+
+/**
+ * Upload a new file
+ * Upload and replace any existing File with the new one.
+ * The If-Match or If-Unmodified-Since header can be used to make a conditional update
+ *
+ * @class message.UploadFile
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param oid {String} The unique file identifier
+ */
+exports.UploadFile = Message.create({
+ method: 'PUT',
+ path: '/file/:bucket/*oid',
+ status: [200]
+});
+
+/**
+ * Gets the file metadata
+ * Gets the file Acl and metadata.
+ *
+ * @class message.GetFileMetadata
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param oid {String} The unique object identifier
+ */
+exports.GetFileMetadata = Message.create({
+ method: 'HEAD',
+ path: '/file/:bucket/*oid',
+ status: [200]
+});
+
+/**
+ * update File Metadata
+ * Updates the file Metadata.
+ *
+ * @class message.UpdateFileMetadata
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param oid {String} The unique object identifier
+ * @param body {Object} The massage Content
+ */
+exports.UpdateFileMetadata = Message.create({
+ method: 'POST',
+ path: '/file/:bucket/*oid',
+ status: [200]
+});
+
+/**
+ * Delete a file
+ * Deletes a file.
+ * The If-Match or If-Unmodified-Since header can be used to make a conditional deletion
+ *
+ * @class message.DeleteFile
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param oid {String} The unique file identifier
+ */
+exports.DeleteFile = Message.create({
+ method: 'DELETE',
+ path: '/file/:bucket/*oid',
+ status: [204]
+});
+
+/**
+ * List bucket indexes
+ * List all indexes of the given bucket
+ *
+ * @class message.ListIndexes
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ */
+exports.ListIndexes = Message.create({
+ method: 'GET',
+ path: '/index/:bucket',
+ status: [200]
+});
+
+/**
+ * Create or drop bucket index
+ * Create or drop a index for the given bucket
+ *
+ * @class message.CreateDropIndex
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ * @param body {Object} The massage Content
+ */
+exports.CreateDropIndex = Message.create({
+ method: 'POST',
+ path: '/index/:bucket',
+ status: [202]
+});
+
+/**
+ * Drop all indexes
+ * Drop all indexes on the given bucket
+ *
+ * @class message.DropAllIndexes
+ * @extends connector.Message
+ *
+ * @param bucket {Object} The bucket name
+ */
+exports.DropAllIndexes = Message.create({
+ method: 'DELETE',
+ path: '/index/:bucket',
+ status: [202]
+});
+
+/**
+ * Method to register a new device
+ * Registers a new devices
+ *
+ * @class message.DeviceRegister
+ * @extends connector.Message
+ *
+ * @param body {Object} The massage Content
+ */
+exports.DeviceRegister = Message.create({
+ method: 'POST',
+ path: '/db/Device/register',
+ status: [204]
+});
+
+/**
+ * Method to push a message to devices
+ * Pushes a message to devices
+ *
+ * @class message.DevicePush
+ * @extends connector.Message
+ *
+ * @param body {Object} The massage Content
+ */
+exports.DevicePush = Message.create({
+ method: 'POST',
+ path: '/db/Device/push',
+ status: [204]
+});
+
+/**
+ * Check if device is registered
+ * Checks if the device is already registered
+ *
+ * @class message.DeviceRegistered
+ * @extends connector.Message
+ *
+ */
+exports.DeviceRegistered = Message.create({
+ method: 'GET',
+ path: '/db/Device/registered',
+ status: [200]
+});
+
+/**
+ * Upload APNS certificate
+ * Upload APNS certificate
+ *
+ * @class message.UploadAPNSCertificate
+ * @extends connector.Message
+ *
+ */
+exports.UploadAPNSCertificate = Message.create({
+ method: 'POST',
+ path: '/config/APNSCert',
+ status: [204]
+});
+
+/**
+ * Set GCM-API-Key
+ * Sets the GCM-API-Key
+ *
+ * @class message.GCMAKey
+ * @extends connector.Message
+ *
+ * @param body {Object} The massage Content
+ */
+exports.GCMAKey = Message.create({
+ method: 'POST',
+ path: '/config/GCMKey',
+ status: [204]
+});
+
+},{"25":25}],37:[function(_dereq_,module,exports){
+"use strict";
+
+var Accessor = _dereq_(7);
+
+/**
+ * @alias metamodel.Attribute
+ */
+
+var Attribute = function () {
+ babelHelpers.createClass(Attribute, [{
+ key: 'persistentAttributeType',
+
+ /**
+ * @type number
+ */
+ get: function get() {
+ return -1;
+ }
+
+ /**
+ * @type boolean
+ */
+
+ }, {
+ key: 'isAssociation',
+ get: function get() {
+ return this.persistentAttributeType > Attribute.PersistentAttributeType.EMBEDDED;
+ }
+
+ /**
+ * @type boolean
+ */
+
+ }, {
+ key: 'isCollection',
+ get: function get() {
+ return this.persistentAttributeType == Attribute.PersistentAttributeType.ELEMENT_COLLECTION;
+ }
+
+ /**
+ * @param {string} name The attribute name
+ * @param {boolean=} isMetadata true if the attribute is an metadata attribute
+ */
+
+ }]);
+
+ function Attribute(name, isMetadata) {
+ babelHelpers.classCallCheck(this, Attribute);
+
+ /** @type boolean */
+ this.isMetadata = !!isMetadata;
+ /** @type boolean */
+ this.isId = false;
+ /** @type boolean */
+ this.isVersion = false;
+ /** @type boolean */
+ this.isAcl = false;
+
+ /** @type string */
+ this.name = name;
+ /** @type number */
+ this.order = null;
+ /** @type binding.Accessor */
+ this.accessor = null;
+ /** @type metamodel.ManagedType */
+ this.declaringType = null;
+ }
+
+ /**
+ * @param {metamodel.ManagedType} declaringType The type that owns this attribute
+ * @param {number} order Position of the attribute
+ */
+
+
+ Attribute.prototype.init = function init(declaringType, order) {
+ if (this.declaringType) throw new Error('The attribute is already initialized.');
+
+ this.order = order;
+ this.accessor = new Accessor();
+ this.declaringType = declaringType;
+ };
+
+ /**
+ * @param {Object} entity
+ * @returns {*}
+ */
+
+
+ Attribute.prototype.getValue = function getValue(entity) {
+ return this.accessor.getValue(entity, this);
+ };
+
+ /**
+ * @param {Object} entity
+ * @param {*} value
+ */
+
+
+ Attribute.prototype.setValue = function setValue(entity, value) {
+ this.accessor.setValue(entity, this, value);
+ };
+
+ /**
+ * Gets this attribute value form the object as json
+ * @param {util.Metadata} state The root object state
+ * @param {*} object The object which contains the value of this attribute
+ * @return {*} The converted json value
+ * @abstract
+ */
+
+
+ Attribute.prototype.getJsonValue = function getJsonValue(state, object) {};
+
+ /**
+ * Sets this attribute value from json to the object
+ * @param {util.Metadata} state The root state
+ * @param {*} object The object which contains the attribute
+ * @param {*} jsonValue The json value to convert an set
+ * @abstract
+ */
+
+
+ Attribute.prototype.setJsonValue = function setJsonValue(state, object, jsonValue) {};
+
+ /**
+ * Converts this attribute field to json
+ * @abstract
+ * @returns {json} The attribute description as json
+ */
+
+
+ Attribute.prototype.toJSON = function toJSON() {};
+
+ return Attribute;
+}();
+
+/**
+ * @enum {number}
+ */
+
+
+Attribute.PersistentAttributeType = {
+ BASIC: 0,
+ ELEMENT_COLLECTION: 1,
+ EMBEDDED: 2,
+ MANY_TO_MANY: 3,
+ MANY_TO_ONE: 4,
+ ONE_TO_MANY: 5,
+ ONE_TO_ONE: 6
+};
+
+module.exports = Attribute;
+
+},{"7":7}],38:[function(_dereq_,module,exports){
+"use strict";
+
+var Type = _dereq_(51);
+var GeoPoint = _dereq_(5);
+
+/**
+ * @alias metamodel.BasicType
+ * @extends metamodel.Type
+ */
+
+var BasicType = function (_Type) {
+ babelHelpers.inherits(BasicType, _Type);
+ babelHelpers.createClass(BasicType, [{
+ key: 'persistenceType',
+
+
+ /**
+ * The persistent type of this type
+ * @type number
+ */
+ get: function get() {
+ return Type.PersistenceType.BASIC;
+ }
+
+ /**
+ * Creates a new instance of a native db type
+ * @param {string} ref The db ref of this type
+ * @param {Class<*>} typeConstructor The javascript class of this type
+ * @param {boolean=} noResolving Indicates if this type is not the main type of the constructor
+ */
+
+ }]);
+
+ function BasicType(ref, typeConstructor, noResolving) {
+ babelHelpers.classCallCheck(this, BasicType);
+
+ if (ref.indexOf('/db/') != 0) ref = '/db/' + ref;
+
+ /**
+ * Indicates if this type is not the main type of the constructor
+ * @type {boolean}
+ */
+ var _this = babelHelpers.possibleConstructorReturn(this, _Type.call(this, ref, typeConstructor));
+
+ _this.noResolving = noResolving;
+ return _this;
+ }
+
+ /**
+ * @inheritDoc
+ */
+
+
+ BasicType.prototype.toJsonValue = function toJsonValue(state, currentValue) {
+ return currentValue === null || currentValue === undefined ? null : this.typeConstructor(currentValue);
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ BasicType.prototype.fromJsonValue = function fromJsonValue(state, jsonValue, currentValue) {
+ return jsonValue === null || jsonValue === undefined ? null : jsonValue;
+ };
+
+ BasicType.prototype.toString = function toString() {
+ return "BasicType(" + this.ref + ")";
+ };
+
+ return BasicType;
+}(Type);
+
+function dateToJson(value) {
+ //remove trailing zeros
+ return value instanceof Date ? value.toISOString().replace(/\.?0*Z/, 'Z') : null;
+}
+
+function jsonToDate(json, currentValue) {
+ var date = typeof json === 'string' ? new Date(json) : null;
+ if (currentValue && date) {
+ //compare normalized date strings instead of plain strings
+ return currentValue.toISOString() == date.toISOString() ? currentValue : date;
+ } else {
+ return date;
+ }
+}
+
+Object.assign(BasicType, /** @lends metamodel.BasicType */{
+ Boolean: new (function (_BasicType) {
+ babelHelpers.inherits(BooleanType, _BasicType);
+
+ function BooleanType() {
+ babelHelpers.classCallCheck(this, BooleanType);
+ return babelHelpers.possibleConstructorReturn(this, _BasicType.apply(this, arguments));
+ }
+
+ BooleanType.prototype.fromJsonValue = function fromJsonValue(state, json, currentValue) {
+ return typeof json === 'string' ? json !== "false" : _BasicType.prototype.fromJsonValue.call(this, state, json, currentValue);
+ };
+
+ return BooleanType;
+ }(BasicType))('Boolean', Boolean),
+
+ Double: new (function (_BasicType2) {
+ babelHelpers.inherits(DoubleType, _BasicType2);
+
+ function DoubleType() {
+ babelHelpers.classCallCheck(this, DoubleType);
+ return babelHelpers.possibleConstructorReturn(this, _BasicType2.apply(this, arguments));
+ }
+
+ DoubleType.prototype.fromJsonValue = function fromJsonValue(state, json, currentValue) {
+ return typeof json === 'string' ? parseFloat(json) : _BasicType2.prototype.fromJsonValue.call(this, state, json, currentValue);
+ };
+
+ return DoubleType;
+ }(BasicType))('Double', Number),
+
+ Integer: new (function (_BasicType3) {
+ babelHelpers.inherits(IntegerType, _BasicType3);
+
+ function IntegerType() {
+ babelHelpers.classCallCheck(this, IntegerType);
+ return babelHelpers.possibleConstructorReturn(this, _BasicType3.apply(this, arguments));
+ }
+
+ IntegerType.prototype.fromJsonValue = function fromJsonValue(state, json, currentValue) {
+ return typeof json === 'string' ? parseInt(json) : _BasicType3.prototype.fromJsonValue.call(this, state, json, currentValue);
+ };
+
+ return IntegerType;
+ }(BasicType))('Integer', Number),
+
+ String: new (function (_BasicType4) {
+ babelHelpers.inherits(StringType, _BasicType4);
+
+ function StringType() {
+ babelHelpers.classCallCheck(this, StringType);
+ return babelHelpers.possibleConstructorReturn(this, _BasicType4.apply(this, arguments));
+ }
+
+ return StringType;
+ }(BasicType))('String', String),
+
+ DateTime: new (function (_BasicType5) {
+ babelHelpers.inherits(DateTimeType, _BasicType5);
+
+ function DateTimeType() {
+ babelHelpers.classCallCheck(this, DateTimeType);
+ return babelHelpers.possibleConstructorReturn(this, _BasicType5.apply(this, arguments));
+ }
+
+ DateTimeType.prototype.toJsonValue = function toJsonValue(state, value) {
+ return dateToJson(value);
+ };
+
+ DateTimeType.prototype.fromJsonValue = function fromJsonValue(state, json, currentValue) {
+ return jsonToDate(json, currentValue);
+ };
+
+ return DateTimeType;
+ }(BasicType))('DateTime', Date),
+
+ Date: new (function (_BasicType6) {
+ babelHelpers.inherits(DateType, _BasicType6);
+
+ function DateType() {
+ babelHelpers.classCallCheck(this, DateType);
+ return babelHelpers.possibleConstructorReturn(this, _BasicType6.apply(this, arguments));
+ }
+
+ DateType.prototype.toJsonValue = function toJsonValue(state, value) {
+ var json = dateToJson(value);
+ return json ? json.substring(0, json.indexOf('T')) : null;
+ };
+
+ DateType.prototype.fromJsonValue = function fromJsonValue(state, json, currentValue) {
+ return jsonToDate(json, currentValue);
+ };
+
+ return DateType;
+ }(BasicType))('Date', Date),
+
+ Time: new (function (_BasicType7) {
+ babelHelpers.inherits(TimeType, _BasicType7);
+
+ function TimeType() {
+ babelHelpers.classCallCheck(this, TimeType);
+ return babelHelpers.possibleConstructorReturn(this, _BasicType7.apply(this, arguments));
+ }
+
+ TimeType.prototype.toJsonValue = function toJsonValue(state, value) {
+ var json = dateToJson(value);
+ return json ? json.substring(json.indexOf('T') + 1) : null;
+ };
+
+ TimeType.prototype.fromJsonValue = function fromJsonValue(state, json, currentValue) {
+ return typeof json === 'string' ? jsonToDate('1970-01-01T' + json, currentValue) : json;
+ };
+
+ return TimeType;
+ }(BasicType))('Time', Date),
+
+ GeoPoint: new (function (_BasicType8) {
+ babelHelpers.inherits(GeoPointType, _BasicType8);
+
+ function GeoPointType() {
+ babelHelpers.classCallCheck(this, GeoPointType);
+ return babelHelpers.possibleConstructorReturn(this, _BasicType8.apply(this, arguments));
+ }
+
+ GeoPointType.prototype.toJsonValue = function toJsonValue(state, value) {
+ return value instanceof GeoPoint ? value : null;
+ };
+
+ GeoPointType.prototype.fromJsonValue = function fromJsonValue(state, json) {
+ return json ? new GeoPoint(json) : null;
+ };
+
+ return GeoPointType;
+ }(BasicType))('GeoPoint', GeoPoint),
+
+ JsonArray: new (function (_BasicType9) {
+ babelHelpers.inherits(JsonArrayType, _BasicType9);
+
+ function JsonArrayType() {
+ babelHelpers.classCallCheck(this, JsonArrayType);
+ return babelHelpers.possibleConstructorReturn(this, _BasicType9.apply(this, arguments));
+ }
+
+ JsonArrayType.prototype.init = function init(classFactory) {
+ //do not manipulate array properties
+ this._enhancer = classFactory;
+ };
+
+ JsonArrayType.prototype.toJsonValue = function toJsonValue(state, value) {
+ return Array.isArray(value) ? value : null;
+ };
+
+ JsonArrayType.prototype.fromJsonValue = function fromJsonValue(state, json) {
+ return Array.isArray(json) ? json : null;
+ };
+
+ return JsonArrayType;
+ }(BasicType))('JsonArray', Array),
+
+ JsonObject: new (function (_BasicType10) {
+ babelHelpers.inherits(JsonObjectType, _BasicType10);
+
+ function JsonObjectType() {
+ babelHelpers.classCallCheck(this, JsonObjectType);
+ return babelHelpers.possibleConstructorReturn(this, _BasicType10.apply(this, arguments));
+ }
+
+ JsonObjectType.prototype.init = function init(classFactory) {
+ //do not manipulate object properties
+ this._enhancer = classFactory;
+ };
+
+ JsonObjectType.prototype.toJsonValue = function toJsonValue(state, value) {
+ if (value && value.constructor == Object) {
+ return value;
+ }
+
+ return null;
+ };
+
+ return JsonObjectType;
+ }(BasicType))('JsonObject', Object)
+});
+
+module.exports = BasicType;
+
+},{"5":5,"51":51}],39:[function(_dereq_,module,exports){
+"use strict";
+
+var PluralAttribute = _dereq_(48);
+
+/**
+ * @alias metamodel.CollectionAttribute
+ * @extends metamodel.PluralAttribute
+ */
+
+var CollectionAttribute = function (_PluralAttribute) {
+ babelHelpers.inherits(CollectionAttribute, _PluralAttribute);
+ babelHelpers.createClass(CollectionAttribute, [{
+ key: "collectionType",
+
+
+ /**
+ * @inheritDoc
+ */
+ get: function get() {
+ return PluralAttribute.CollectionType.COLLECTION;
+ }
+
+ /**
+ * @param {string} name
+ * @param {metamodel.Type} elementType
+ */
+
+ }]);
+
+ function CollectionAttribute(name, elementType) {
+ babelHelpers.classCallCheck(this, CollectionAttribute);
+
+ var _this = babelHelpers.possibleConstructorReturn(this, _PluralAttribute.call(this, name, elementType));
+
+ _this.typeConstructor = null;
+ return _this;
+ }
+
+ return CollectionAttribute;
+}(PluralAttribute);
+
+module.exports = CollectionAttribute;
+
+},{"48":48}],40:[function(_dereq_,module,exports){
+"use strict";
+/**
+ * Creates a new index instance which is needed to create an
+ * database index.
+ *
+ * @alias metamodel.DbIndex
+ */
+
+var DbIndex = function () {
+
+ /**
+ * @param {string|Object|Array} keys The name of the field which will be used for the index,
+ * an object of an field and index type combination or
+ * an array of objects to create an compound index
+ * @param {boolean=} unique Indicates if the index will be unique
+ */
+ function DbIndex(keys, unique) {
+ babelHelpers.classCallCheck(this, DbIndex);
+
+ if (Object(keys) instanceof String) {
+ var key = {};
+ key[keys] = DbIndex.ASC;
+ this.keys = [key];
+ } else if (Object(keys) instanceof Array) {
+ this.keys = keys;
+ } else if (keys) {
+ this.keys = [keys];
+ } else {
+ throw new Error("The keys parameter must be an String, Object or Array.");
+ }
+
+ /** @type boolean */
+ this.drop = false;
+ this.unique = unique === true;
+ }
+
+ DbIndex.prototype.hasKey = function hasKey(name) {
+ for (var i = 0; i < this.keys.length; i++) {
+ if (this.keys[i][name]) {
+ return true;
+ }
+ }
+ return false;
+ };
+
+ /**
+ * Returns a JSON representation of the Index object
+ *
+ * @return {json} A Json of this Index object
+ */
+ DbIndex.prototype.toJSON = function toJSON() {
+ return {
+ unique: this.unique,
+ keys: this.keys,
+ drop: this.drop
+ };
+ };
+
+ babelHelpers.createClass(DbIndex, [{
+ key: "isCompound",
+ get: function get() {
+ return this.keys.length > 1;
+ }
+ }, {
+ key: "isUnique",
+ get: function get() {
+ return this.unique;
+ }
+ }]);
+ return DbIndex;
+}();
+
+Object.assign(DbIndex, /** @lends metamodel.DbIndex */{
+ /**
+ * @type string
+ */
+ ASC: 'asc',
+
+ /**
+ * @type string
+ */
+ DESC: 'desc',
+
+ /**
+ * @type string
+ */
+ GEO: 'geo',
+
+ /**
+ * Returns DbIndex Object created from the given JSON
+ * @param {json} json
+ */
+ fromJSON: function fromJSON(json) {
+ return new DbIndex(json.keys, json.unique);
+ }
+});
+
+module.exports = DbIndex;
+
+},{}],41:[function(_dereq_,module,exports){
+"use strict";
+
+var ManagedType = _dereq_(44);
+var Type = _dereq_(51);
+var binding = _dereq_(20);
+
+/**
+ * @alias metamodel.EmbeddableType
+ * @extends metamodel.ManagedType
+ */
+
+var EmbeddableType = function (_ManagedType) {
+ babelHelpers.inherits(EmbeddableType, _ManagedType);
+ babelHelpers.createClass(EmbeddableType, [{
+ key: 'persistenceType',
+ get: function get() {
+ return Type.PersistenceType.EMBEDDABLE;
+ }
+ }]);
+
+ function EmbeddableType(name, typeConstructor) {
+ babelHelpers.classCallCheck(this, EmbeddableType);
+ return babelHelpers.possibleConstructorReturn(this, _ManagedType.call(this, name, typeConstructor));
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+
+
+ EmbeddableType.prototype.createProxyClass = function createProxyClass() {
+ return this._enhancer.createProxy(binding.Managed);
+ };
+
+ /**
+ * {@inheritDoc}
+ * @param {EntityManager} db {@inheritDoc}
+ * @return {binding.ManagedFactory<*>} A factory which creates embeddable objects
+ */
+
+
+ EmbeddableType.prototype.createObjectFactory = function createObjectFactory(db) {
+ return binding.ManagedFactory.create(this, db);
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ EmbeddableType.prototype.toJsonValue = function toJsonValue(state, object) {
+ if (state._root && object instanceof this.typeConstructor && !object._metadata._root) {
+ object._metadata._root = state._root;
+ }
+
+ return _ManagedType.prototype.toJsonValue.call(this, state, object);
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ EmbeddableType.prototype.fromJsonValue = function fromJsonValue(state, jsonObject, currentObject) {
+ if (jsonObject) {
+ if (!(currentObject instanceof this.typeConstructor)) currentObject = this.create();
+
+ if (state._root && !currentObject._metadata._root) currentObject._metadata._root = state._root;
+ }
+
+ return _ManagedType.prototype.fromJsonValue.call(this, state, jsonObject, currentObject);
+ };
+
+ EmbeddableType.prototype.toString = function toString() {
+ return "EmbeddableType(" + this.ref + ")";
+ };
+
+ return EmbeddableType;
+}(ManagedType);
+
+module.exports = EmbeddableType;
+
+},{"20":20,"44":44,"51":51}],42:[function(_dereq_,module,exports){
+"use strict";
+
+var binding = _dereq_(20);
+
+var SingularAttribute = _dereq_(50);
+var BasicType = _dereq_(38);
+var Type = _dereq_(51);
+var ManagedType = _dereq_(44);
+var util = _dereq_(70);
+
+/**
+ * @alias metamodel.EntityType
+ * @extends metamodel.ManagedType
+ */
+
+var EntityType = function (_ManagedType) {
+ babelHelpers.inherits(EntityType, _ManagedType);
+ babelHelpers.createClass(EntityType, [{
+ key: 'persistenceType',
+ get: function get() {
+ return Type.PersistenceType.ENTITY;
+ }
+
+ /**
+ * @type metamodel.SingularAttribute
+ */
+
+ }, {
+ key: 'id',
+ get: function get() {
+ return this.declaredId || this.superType.id;
+ }
+
+ /**
+ * @type metamodel.SingularAttribute
+ */
+
+ }, {
+ key: 'version',
+ get: function get() {
+ return this.declaredVersion || this.superType.version;
+ }
+
+ /**
+ * @type metamodel.SingularAttribute
+ */
+
+ }, {
+ key: 'acl',
+ get: function get() {
+ return this.declaredAcl || this.superType.acl;
+ }
+
+ /**
+ * @param {string} ref
+ * @param {metamodel.EntityType} superType
+ * @param {Class} typeConstructor
+ */
+
+ }]);
+
+ function EntityType(ref, superType, typeConstructor) {
+ babelHelpers.classCallCheck(this, EntityType);
+
+ /** @type metamodel.SingularAttribute */
+ var _this = babelHelpers.possibleConstructorReturn(this, _ManagedType.call(this, ref, typeConstructor));
+
+ _this.declaredId = null;
+ /** @type metamodel.SingularAttribute */
+ _this.declaredVersion = null;
+ /** @type metamodel.SingularAttribute */
+ _this.declaredAcl = null;
+ /** @type metamodel.EntityType */
+ _this.superType = superType;
+
+ /** @type util.Permission */
+ _this.loadPermission = new util.Permission();
+ /** @type util.Permission */
+ _this.updatePermission = new util.Permission();
+ /** @type util.Permission */
+ _this.deletePermission = new util.Permission();
+ /** @type util.Permission */
+ _this.queryPermission = new util.Permission();
+ /** @type util.Permission */
+ _this.schemaSubclassPermission = new util.Permission();
+ /** @type util.Permission */
+ _this.insertPermission = new util.Permission();
+ return _this;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+
+
+ EntityType.prototype.createProxyClass = function createProxyClass() {
+ var Class = this.superType.typeConstructor;
+ if (Class === Object) {
+ switch (this.name) {
+ case 'User':
+ Class = binding.User;
+ break;
+ case 'Role':
+ Class = binding.Role;
+ break;
+ default:
+ Class = binding.Entity;
+ break;
+ }
+ }
+
+ return this._enhancer.createProxy(Class);
+ };
+
+ /**
+ * {@inheritDoc}
+ * Creates an ObjectFactory for this type and the given EntityManager
+ * @return {binding.EntityFactory} A factory which creates entity objects
+ */
+
+
+ EntityType.prototype.createObjectFactory = function createObjectFactory(db) {
+ switch (this.name) {
+ case 'User':
+ return binding.UserFactory.create(this, db);
+ case 'Device':
+ return binding.DeviceFactory.create(this, db);
+ case 'Object':
+ return undefined;
+ }
+
+ return binding.EntityFactory.create(this, db);
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ EntityType.prototype.fromJsonValue = function fromJsonValue(state, jsonObject, currentObject, isRoot) {
+ if (isRoot) {
+ return _ManagedType.prototype.fromJsonValue.call(this, state, jsonObject, currentObject);
+ } else if (jsonObject) {
+ return state.db.getReference(jsonObject);
+ } else {
+ return null;
+ }
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ EntityType.prototype.toJsonValue = function toJsonValue(state, object, isRoot) {
+ if (isRoot) {
+ return _ManagedType.prototype.toJsonValue.call(this, state, object);
+ } else if (object instanceof this.typeConstructor) {
+ object.attach(state.db);
+ return object.id;
+ } else {
+ return null;
+ }
+ };
+
+ EntityType.prototype.toString = function toString() {
+ return "EntityType(" + this.ref + ")";
+ };
+
+ EntityType.prototype.toJSON = function toJSON() {
+ var json = _ManagedType.prototype.toJSON.call(this);
+
+ json.acl.schemaSubclass = this.schemaSubclassPermission;
+ json.acl.insert = this.insertPermission;
+ json.acl.update = this.updatePermission;
+ json.acl.delete = this.deletePermission;
+ json.acl.query = this.queryPermission;
+
+ return json;
+ };
+
+ return EntityType;
+}(ManagedType);
+
+/**
+ * @alias metamodel.EntityType.Object
+ * @extends metamodel.EntityType
+ */
+
+
+var ObjectType = function (_EntityType) {
+ babelHelpers.inherits(ObjectType, _EntityType);
+ babelHelpers.createClass(ObjectType, null, [{
+ key: 'ref',
+ get: function get() {
+ return '/db/Object';
+ }
+ }]);
+
+ function ObjectType() {
+ babelHelpers.classCallCheck(this, ObjectType);
+
+ var _this2 = babelHelpers.possibleConstructorReturn(this, _EntityType.call(this, EntityType.Object.ref, null, Object));
+
+ _this2.declaredId = new SingularAttribute('id', BasicType.String, true);
+ _this2.declaredId.init(_this2, 0);
+ _this2.declaredId.isId = true;
+ _this2.declaredVersion = new SingularAttribute('version', BasicType.Double, true);
+ _this2.declaredVersion.init(_this2, 1);
+ _this2.declaredVersion.isVersion = true;
+ _this2.declaredAcl = new SingularAttribute('acl', BasicType.JsonObject, true);
+ _this2.declaredAcl.init(_this2, 2);
+ _this2.declaredAcl.isAcl = true;
+
+ _this2.declaredAttributes = [_this2.declaredId, _this2.declaredVersion, _this2.declaredAcl];
+ return _this2;
+ }
+
+ return ObjectType;
+}(EntityType);
+
+EntityType.Object = ObjectType;
+
+module.exports = EntityType;
+
+},{"20":20,"38":38,"44":44,"50":50,"51":51,"70":70}],43:[function(_dereq_,module,exports){
+"use strict";
+
+var PluralAttribute = _dereq_(48);
+
+/**
+ * @alias metamodel.ListAttribute
+ * @extends metamodel.PluralAttribute
+ */
+
+var ListAttribute = function (_PluralAttribute) {
+ babelHelpers.inherits(ListAttribute, _PluralAttribute);
+ babelHelpers.createClass(ListAttribute, [{
+ key: 'collectionType',
+ get: function get() {
+ return PluralAttribute.CollectionType.LIST;
+ }
+
+ /**
+ * @param {string} name
+ * @param {metamodel.Type} elementType
+ */
+
+ }], [{
+ key: 'ref',
+ get: function get() {
+ return '/db/collection.List';
+ }
+ }]);
+
+ function ListAttribute(name, elementType) {
+ babelHelpers.classCallCheck(this, ListAttribute);
+
+ var _this = babelHelpers.possibleConstructorReturn(this, _PluralAttribute.call(this, name, elementType));
+
+ _this.typeConstructor = Array;
+ return _this;
+ }
+
+ /**
+ * @inheritDoc
+ */
+
+
+ ListAttribute.prototype.getJsonValue = function getJsonValue(state, object) {
+ var value = this.getValue(object);
+
+ if (value instanceof this.typeConstructor) {
+ var len = value.length;
+ var persisting = new Array(len),
+ persistedState = value.__persistedState__ || [];
+ var changed = persistedState.length != len;
+
+ var json = new Array(len);
+ for (var i = 0; i < len; ++i) {
+ var el = value[i];
+ json[i] = this.elementType.toJsonValue(state, el);
+ persisting[i] = el;
+
+ changed |= persistedState[i] !== el;
+ }
+
+ if (!state.isReady) {
+ Object.defineProperty(value, '__persistedState__', { value: persisting, configurable: true });
+
+ if (state.isPersistent && changed) state.setDirty();
+ }
+
+ return json;
+ } else {
+ return null;
+ }
+ };
+
+ /**
+ * {@inheritDoc}
+ */
+
+
+ ListAttribute.prototype.setJsonValue = function setJsonValue(state, obj, json) {
+ var value = null;
+
+ if (json) {
+ value = this.getValue(obj);
+
+ var len = json.length;
+ if (!(value instanceof this.typeConstructor)) {
+ value = new this.typeConstructor(len);
+ }
+
+ var persisting = new Array(len),
+ persistedState = value.__persistedState__ || [];
+
+ //clear additional items
+ if (len < value.length) value.splice(len, value.length - len);
+
+ for (var i = 0; i < len; ++i) {
+ var el = this.elementType.fromJsonValue(state, json[i], persistedState[i]);
+ persisting[i] = value[i] = el;
+ }
+
+ if (!state.isReady) {
+ Object.defineProperty(value, '__persistedState__', { value: persisting, configurable: true });
+ }
+ }
+
+ this.setValue(obj, value);
+ };
+
+ /**
+ * {@inheritDoc}
+ * @returns {json} {@inheritDoc}
+ */
+
+
+ ListAttribute.prototype.toJSON = function toJSON() {
+ return {
+ name: this.name,
+ type: ListAttribute.ref + '[' + this.elementType.ref + ']',
+ order: this.order
+ };
+ };
+
+ return ListAttribute;
+}(PluralAttribute);
+
+module.exports = ListAttribute;
+
+},{"48":48}],44:[function(_dereq_,module,exports){
+"use strict";
+
+var Type = _dereq_(51);
+var Permission = _dereq_(65);
+var Validator = _dereq_(69);
+var binding = _dereq_(20);
+
+/**
+ * @alias metamodel.ManagedType
+ * @extends metamodel.Type
+ */
+
+var ManagedType = function (_Type) {
+ babelHelpers.inherits(ManagedType, _Type);
+ babelHelpers.createClass(ManagedType, [{
+ key: 'validationCode',
+
+
+ /**
+ * @type Function
+ */
+ get: function get() {
+ return this._validationCode;
+ },
+ set: function set(code) {
+ if (!code) {
+ this._validationCode = null;
+ } else {
+ this._validationCode = Validator.compile(this, code);
+ }
+ }
+
+ /**
+ * The Managed class
+ * @type Class
+ */
+
+ }, {
+ key: 'typeConstructor',
+ get: function get() {
+ if (!this._typeConstructor) {
+ this.typeConstructor = this.createProxyClass();
+ }
+ return this._typeConstructor;
+ }
+
+ /**
+ * The Managed class constructor
+ * @param {Class} typeConstructor The managed class constructor
+ */
+ ,
+ set: function set(typeConstructor) {
+ if (this._typeConstructor) {
+ throw new Error("Type constructor has already been set.");
+ }
+
+ var isEntity = typeConstructor.prototype instanceof binding.Entity;
+ if (this.isEntity) {
+ if (!isEntity) throw new TypeError("Entity classes must extends the Entity class.");
+ } else {
+ if (!(typeConstructor.prototype instanceof binding.Managed) || isEntity) throw new TypeError("Embeddable classes must extends the Managed class.");
+ }
+
+ this._enhancer.enhance(this, typeConstructor);
+ this._typeConstructor = typeConstructor;
+ }
+
+ /**
+ * @param {string} ref or full class name
+ * @param {Class} typeConstructor
+ */
+
+ }]);
+
+ function ManagedType(ref, typeConstructor) {
+ babelHelpers.classCallCheck(this, ManagedType);
+
+ /** @type binding.Enhancer */
+ var _this = babelHelpers.possibleConstructorReturn(this, _Type.call(this, ref.indexOf('/db/') != 0 ? '/db/' + ref : ref, typeConstructor));
+
+ _this._enhancer = null;
+ /** @type {metamodel.Attribute[]} */
+ _this.declaredAttributes = [];
+
+ /** @type util.Permission */
+ _this.schemaAddPermission = new Permission();
+ /** @type util.Permission */
+ _this.schemaReplacePermission = new Permission();
+ return _this;
+ }
+
+ /**
+ * Initialize this type
+ * @param {binding.Enhancer} enhancer The class enhancer
+ * used to enhance and instantiate instance of this managed class
+ */
+
+
+ ManagedType.prototype.init = function init(enhancer) {
+ this._enhancer = enhancer;
+
+ if (this._typeConstructor && !this._enhancer.getIdentifier(this._typeConstructor)) this._enhancer.setIdentifier(this._typeConstructor, this.ref);
+ };
+
+ /**
+ * Creates an ProxyClass for this type
+ * @return {Class<*>} the crated proxy class for this type
+ * @abstract
+ */
+
+
+ ManagedType.prototype.createProxyClass = function createProxyClass() {};
+
+ /**
+ * Creates an ObjectFactory for this type and the given EntityManager
+ * @param {EntityManager} db The created instances will be attached to this EntityManager
+ * @return {binding.ManagedFactory<*>} the crated object factory for the given EntityManager
+ * @abstract
+ */
+
+
+ ManagedType.prototype.createObjectFactory = function createObjectFactory(db) {};
+
+ /**
+ * Creates a new instance of the managed type, without invoking any constructors
+ * This method is used to create object instances which are loaded form the backend
+ * @returns {Object} The created instance
+ */
+
+
+ ManagedType.prototype.create = function create() {
+ var instance;
+ instance = Object.create(this.typeConstructor.prototype);
+ binding.Managed.init(instance);
+
+ return instance;
+ };
+
+ /**
+ * An iterator which returns all attributes declared by this type and inherited form all super types
+ * @return {Iterator}
+ */
+
+
+ ManagedType.prototype.attributes = function attributes() {
+ var _ref;
+
+ var iter = void 0,
+ index = 0,
+ type = this;
+ if (this.superType) {
+ iter = this.superType.attributes();
+ }
+
+ return _ref = {}, _ref[Symbol.iterator] = function () {
+ return this;
+ }, _ref.next = function next() {
+ if (iter) {
+ var item = iter.next();
+ if (item.done) {
+ iter = null;
+ } else {
+ return item;
+ }
+ }
+
+ if (index < type.declaredAttributes.length) {
+ return {
+ value: type.declaredAttributes[index++],
+ done: false
+ };
+ } else {
+ return { done: true };
+ }
+ }, _ref;
+ };
+
+ /**
+ * Adds an attribute to this type
+ * @param {metamodel.Attribute} attr The attribute to add
+ * @param {number=} order Position of the attribute
+ */
+
+
+ ManagedType.prototype.addAttribute = function addAttribute(attr, order) {
+ if (this.getAttribute(attr.name)) throw new Error("An attribute with the name " + attr.name + " is already declared.");
+
+ if (attr.order == null) {
+ order = typeof order == 'undefined' ? this.declaredAttributes.length : order;
+ } else {
+ order = attr.order;
+ }
+ attr.init(this, order);
+
+ this.declaredAttributes.push(attr);
+ if (this._typeConstructor && this.name != 'Object') this._enhancer.enhanceProperty(this._typeConstructor, attr);
+ };
+
+ /**
+ * Removes an attribute from this type
+ * @param {string} name The Name of the attribute which will be removed
+ */
+
+
+ ManagedType.prototype.removeAttribute = function removeAttribute(name) {
+ var length = this.declaredAttributes.length;
+ this.declaredAttributes = this.declaredAttributes.filter(function (val) {
+ return val.name != name;
+ });
+
+ if (length == this.declaredAttributes.length) throw new Error("An Attribute with the name " + name + " is not declared.");
+ };
+
+ /**
+ * @param {!string} name
+ * @returns {metamodel.Attribute}
+ */
+
+
+ ManagedType.prototype.getAttribute = function getAttribute(name) {
+ var attr = this.getDeclaredAttribute(name);
+
+ if (!attr && this.superType) {
+ attr = this.superType.getAttribute(name);
+ }
+
+ return attr;
+ };
+
+ /**
+ * @param {string|number} val Name or order of the attribute
+ * @returns {metamodel.Attribute}
+ */
+
+
+ ManagedType.prototype.getDeclaredAttribute = function getDeclaredAttribute(val) {
+ for (var _iterator = this.declaredAttributes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+ var _ref2;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref2 = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref2 = _i.value;
+ }
+
+ var attr = _ref2;
+
+ if (attr.name === val || attr.order === val) {
+ return attr;
+ }
+ }
+
+ return null;
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ ManagedType.prototype.fromJsonValue = function fromJsonValue(state, jsonObject, currentObject) {
+ if (jsonObject) {
+ for (var _iterator2 = this.attributes(), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+ var _ref3;
+
+ if (_isArray2) {
+ if (_i2 >= _iterator2.length) break;
+ _ref3 = _iterator2[_i2++];
+ } else {
+ _i2 = _iterator2.next();
+ if (_i2.done) break;
+ _ref3 = _i2.value;
+ }
+
+ var attribute = _ref3;
+
+ if (!attribute.isMetadata) attribute.setJsonValue(state, currentObject, jsonObject[attribute.name]);
+ }
+ } else {
+ currentObject = null;
+ }
+
+ return currentObject;
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ ManagedType.prototype.toJsonValue = function toJsonValue(state, object) {
+ var value = null;
+
+ if (object instanceof this.typeConstructor) {
+ value = {};
+ for (var _iterator3 = this.attributes(), _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
+ var _ref4;
+
+ if (_isArray3) {
+ if (_i3 >= _iterator3.length) break;
+ _ref4 = _iterator3[_i3++];
+ } else {
+ _i3 = _iterator3.next();
+ if (_i3.done) break;
+ _ref4 = _i3.value;
+ }
+
+ var attribute = _ref4;
+
+ if (!attribute.isMetadata) value[attribute.name] = attribute.getJsonValue(state, object);
+ }
+ }
+
+ return value;
+ };
+
+ /**
+ * Converts ths type schema to json
+ * @returns {json}
+ */
+
+
+ ManagedType.prototype.toJSON = function toJSON() {
+ var json = {};
+ json['class'] = this.ref;
+
+ if (this.superType) json['superClass'] = this.superType.ref;
+
+ if (this.isEmbeddable) json['embedded'] = true;
+
+ json['acl'] = {
+ load: this.loadPermission,
+ schemaAdd: this.schemaAddPermission,
+ schemaReplace: this.schemaReplacePermission
+ };
+
+ var fields = json['fields'] = {};
+ for (var _iterator4 = this.declaredAttributes, _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[Symbol.iterator]();;) {
+ var _ref5;
+
+ if (_isArray4) {
+ if (_i4 >= _iterator4.length) break;
+ _ref5 = _iterator4[_i4++];
+ } else {
+ _i4 = _iterator4.next();
+ if (_i4.done) break;
+ _ref5 = _i4.value;
+ }
+
+ var attribute = _ref5;
+
+ if (!attribute.isMetadata) fields[attribute.name] = attribute;
+ }
+
+ return json;
+ };
+
+ /**
+ * Returns iterator to get all referenced entities
+ * @return {Iterator}
+ */
+
+
+ ManagedType.prototype.references = function references() {
+ var _ref8;
+
+ var attributes = this.attributes();
+ var embedded = [];
+
+ return _ref8 = {}, _ref8[Symbol.iterator] = function () {
+ return this;
+ }, _ref8.next = function next() {
+ for (var _iterator5 = attributes, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[Symbol.iterator]();;) {
+ var _ref6;
+
+ if (_isArray5) {
+ if (_i5 >= _iterator5.length) break;
+ _ref6 = _iterator5[_i5++];
+ } else {
+ _i5 = _iterator5.next();
+ if (_i5.done) break;
+ _ref6 = _i5.value;
+ }
+
+ var attribute = _ref6;
+
+ var type = attribute.isCollection ? attribute.elementType : attribute.type;
+ if (type.isEntity) {
+ return { done: false, value: { path: [attribute.name] } };
+ } else if (type.isEmbeddable) {
+ for (var _iterator6 = type.references(), _isArray6 = Array.isArray(_iterator6), _i6 = 0, _iterator6 = _isArray6 ? _iterator6 : _iterator6[Symbol.iterator]();;) {
+ var _ref7;
+
+ if (_isArray6) {
+ if (_i6 >= _iterator6.length) break;
+ _ref7 = _iterator6[_i6++];
+ } else {
+ _i6 = _iterator6.next();
+ if (_i6.done) break;
+ _ref7 = _i6.value;
+ }
+
+ var emItem = _ref7;
+
+ embedded.push({ done: false, value: { path: [attribute.name].concat(emItem.path) } });
+ }
+ }
+ }
+
+ return embedded.length ? embedded.pop() : { done: true };
+ }, _ref8;
+ };
+
+ return ManagedType;
+}(Type);
+
+module.exports = ManagedType;
+
+},{"20":20,"51":51,"65":65,"69":69}],45:[function(_dereq_,module,exports){
+"use strict";
+
+var PluralAttribute = _dereq_(48);
+var PersistentError = _dereq_(32);
+
+/**
+ * @alias metamodel.MapAttribute
+ * @extends metamodel.PluralAttribute
+ */
+
+var MapAttribute = function (_PluralAttribute) {
+ babelHelpers.inherits(MapAttribute, _PluralAttribute);
+ babelHelpers.createClass(MapAttribute, [{
+ key: 'collectionType',
+ get: function get() {
+ return PluralAttribute.CollectionType.MAP;
+ }
+
+ /**
+ * @param {string} name
+ * @param {metamodel.Type} keyType
+ * @param {metamodel.Type} elementType
+ */
+
+ }], [{
+ key: 'ref',
+ get: function get() {
+ return '/db/collection.Map';
+ }
+ }]);
+
+ function MapAttribute(name, keyType, elementType) {
+ babelHelpers.classCallCheck(this, MapAttribute);
+
+ /** @type metamodel.Type */
+ var _this = babelHelpers.possibleConstructorReturn(this, _PluralAttribute.call(this, name, elementType));
+
+ _this.keyType = keyType;
+ _this.typeConstructor = Map;
+ return _this;
+ }
+
+ /**
+ * @inheritDoc
+ */
+
+
+ MapAttribute.prototype.getJsonValue = function getJsonValue(state, object) {
+ var value = this.getValue(object);
+
+ if (value instanceof this.typeConstructor) {
+ var persisting = {},
+ persistedState = value.__persistedState__ || {};
+ var changed = value.__persistedSize__ !== value.size;
+
+ var json = {};
+ for (var _iterator = value.entries(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var entry = _ref;
+
+ if (entry[0] === null || entry[0] === undefined) throw new PersistentError('Map keys can\'t be null nor undefined.');
+
+ var jsonKey = this.keyType.toJsonValue(state, entry[0]);
+ json[jsonKey] = this.elementType.toJsonValue(state, entry[1]);
+
+ persisting[jsonKey] = [entry[0], entry[1]];
+ changed |= (persistedState[jsonKey] || [])[1] !== entry[1];
+ }
+
+ if (!state.isReady) {
+ Object.defineProperties(value, {
+ '__persistedState__': { value: persisting, configurable: true },
+ '__persistedSize__': { value: value.size, configurable: true }
+ });
+
+ if (state.isPersistent && changed) state.setDirty();
+ }
+
+ return json;
+ } else {
+ return null;
+ }
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ MapAttribute.prototype.setJsonValue = function setJsonValue(state, obj, json) {
+ var value = null;
+ if (json) {
+ value = this.getValue(obj);
+
+ if (!(value instanceof this.typeConstructor)) {
+ value = new this.typeConstructor();
+ }
+
+ var persisting = {},
+ persistedState = value.__persistedState__ || {};
+
+ value.clear();
+ for (var jsonKey in json) {
+ var persistedEntry = persistedState[jsonKey] || [];
+ // ensure that "false" keys will be converted to false
+ var key = this.keyType.fromJsonValue(state, jsonKey, persistedEntry[0]);
+ var val = this.elementType.fromJsonValue(state, json[jsonKey], persistedEntry[1]);
+
+ persisting[jsonKey] = [key, value];
+ value.set(key, val);
+ }
+
+ if (!state.isReady) {
+ Object.defineProperties(value, {
+ '__persistedState__': { value: persisting, configurable: true },
+ '__persistedSize__': { value: value.size, configurable: true }
+ });
+ }
+ }
+
+ this.setValue(obj, value);
+ };
+
+ /**
+ * {@inheritDoc}
+ * @returns {json} {@inheritDoc}
+ */
+
+
+ MapAttribute.prototype.toJSON = function toJSON() {
+ return {
+ name: this.name,
+ type: MapAttribute.ref + '[' + this.keyType.ref + ',' + this.elementType.ref + ']',
+ order: this.order
+ };
+ };
+
+ return MapAttribute;
+}(PluralAttribute);
+
+module.exports = MapAttribute;
+
+},{"32":32,"48":48}],46:[function(_dereq_,module,exports){
+"use strict";
+
+var BasicType = _dereq_(38);
+var ManagedType = _dereq_(44);
+var EntityType = _dereq_(42);
+var Enhancer = _dereq_(9);
+var ModelBuilder = _dereq_(47);
+var DbIndex = _dereq_(40);
+var Lockable = _dereq_(61);
+var StatusCode = _dereq_(25).StatusCode;
+
+var message = _dereq_(36);
+
+/**
+ * @alias metamodel.Metamodel
+ * @extends util.Lockable
+ */
+
+var Metamodel = function (_Lockable) {
+ babelHelpers.inherits(Metamodel, _Lockable);
+
+ function Metamodel(entityManagerFactory) {
+ babelHelpers.classCallCheck(this, Metamodel);
+
+ /**
+ * Defines if the Metamodel has been finalized
+ * @type boolean
+ */
+ var _this = babelHelpers.possibleConstructorReturn(this, _Lockable.call(this));
+
+ _this.isInitialized = false;
+
+ /**
+ * @type EntityManagerFactory
+ */
+ _this.entityManagerFactory = entityManagerFactory;
+
+ /**
+ * @type Array.
+ */
+ _this.entities = null;
+
+ /**
+ * @type Array.
+ */
+ _this.embeddables = null;
+
+ /**
+ * @type Array.
+ */
+ _this.baseTypes = null;
+
+ _this._enhancer = new Enhancer();
+ return _this;
+ }
+
+ /**
+ * Prepare the Metamodel for custom schema creation
+ * @param {Object=} jsonMetamodel initialize the metamodel with the serialized json schema
+ */
+
+
+ Metamodel.prototype.init = function init(jsonMetamodel) {
+ if (this.isInitialized) {
+ throw new Error('Metamodel is already initialized.');
+ }
+
+ this.fromJSON(jsonMetamodel || []);
+ this.isInitialized = true;
+ };
+
+ /**
+ * @param {(Class|string)} arg
+ * @return {string}
+ */
+
+
+ Metamodel.prototype._getRef = function _getRef(arg) {
+ var ref;
+ if (Object(arg) instanceof String) {
+ ref = arg;
+
+ if (ref.indexOf('/db/') != 0) {
+ ref = '/db/' + arg;
+ }
+ } else {
+ ref = this._enhancer.getIdentifier(arg);
+ }
+
+ return ref;
+ };
+
+ /**
+ * Return the metamodel entity type representing the entity.
+ *
+ * @param {(Class|string)} typeConstructor - the type of the represented entity
+ * @returns {metamodel.EntityType} the metamodel entity type
+ */
+
+
+ Metamodel.prototype.entity = function entity(typeConstructor) {
+ var ref = this._getRef(typeConstructor);
+ return ref ? this.entities[ref] : null;
+ };
+
+ /**
+ * Return the metamodel basic type representing the native class.
+ * @param {(Class<*>|string)} typeConstructor - the type of the represented native class
+ * @returns {metamodel.BasicType} the metamodel basic type
+ */
+
+
+ Metamodel.prototype.baseType = function baseType(typeConstructor) {
+ var ref = null;
+ if (Object(typeConstructor) instanceof String) {
+ ref = this._getRef(typeConstructor);
+ } else {
+ for (var name in this.baseTypes) {
+ var type = this.baseTypes[name];
+ if (!type.noResolving && type.typeConstructor == typeConstructor) {
+ ref = name;
+ break;
+ }
+ }
+ }
+
+ return ref ? this.baseTypes[ref] : null;
+ };
+
+ /**
+ * Return the metamodel embeddable type representing the embeddable class.
+ * @param {Class|string} typeConstructor - the type of the represented embeddable class
+ * @returns {metamodel.EmbeddableType} the metamodel embeddable type
+ */
+
+
+ Metamodel.prototype.embeddable = function embeddable(typeConstructor) {
+ var ref = this._getRef(typeConstructor);
+ return ref ? this.embeddables[ref] : null;
+ };
+
+ /**
+ * Return the metamodel managed type representing the entity, mapped superclass, or embeddable class.
+ *
+ * @param {(Class|string)} typeConstructor - the type of the represented managed class
+ * @returns {metamodel.Type} the metamodel managed type
+ */
+
+
+ Metamodel.prototype.managedType = function managedType(typeConstructor) {
+ return this.baseType(typeConstructor) || this.entity(typeConstructor) || this.embeddable(typeConstructor);
+ };
+
+ /**
+ * @param {metamodel.Type} type
+ * @return {metamodel.Type} the added type
+ */
+
+
+ Metamodel.prototype.addType = function addType(type) {
+ var types;
+
+ if (type.isBasic) {
+ types = this.baseTypes;
+ } else if (type.isEmbeddable) {
+ type.init(this._enhancer);
+ types = this.embeddables;
+ } else if (type.isEntity) {
+ type.init(this._enhancer);
+ types = this.entities;
+
+ if (type.superType == null && type.ref != EntityType.Object.ref) {
+ type.superType = this.entity(EntityType.Object.ref);
+ }
+ }
+
+ if (types[type.ref]) {
+ throw new Error("The type " + type.ref + " is already declared.");
+ }
+
+ return types[type.ref] = type;
+ };
+
+ /**
+ * Load all schema data from the server
+ * @returns {Promise}
+ */
+
+
+ Metamodel.prototype.load = function load() {
+ var _this2 = this;
+
+ if (!this.isInitialized) {
+ return this.withLock(function () {
+ var msg = new message.GetAllSchemas();
+
+ return _this2.entityManagerFactory.send(msg).then(function (response) {
+ _this2.init(response.entity);
+ return _this2;
+ });
+ });
+ } else {
+ throw new Error("Metamodel is already initialized.");
+ }
+ };
+
+ /**
+ * Store all local schema data on the server, or the provided one
+ *
+ * Note: The schema must be initialized, by init or load
+ *
+ * @param {metamodel.ManagedType=} managedType The specific type to persist, if omitted the complete schema will be updated
+ * @returns {Promise}
+ */
+
+
+ Metamodel.prototype.save = function save(managedType) {
+ var _this3 = this;
+
+ return this._send(managedType || this.toJSON()).then(function () {
+ return _this3;
+ });
+ };
+
+ /**
+ * The provided options object will be forwarded to the UpdateAllSchemas resource.
+ * The underlying schema of this Metamodel object will be replaced by the result.
+ *
+ * @param {json} data The JSON which will be send to the UpdateAllSchemas resource.
+ * @returns {Promise}
+ */
+
+
+ Metamodel.prototype.update = function update(data) {
+ var _this4 = this;
+
+ return this._send(data).then(function (response) {
+ _this4.fromJSON(response.entity);
+ return _this4;
+ });
+ };
+
+ Metamodel.prototype._send = function _send(data) {
+ var _this5 = this;
+
+ if (!this.isInitialized) throw new Error("Metamodel is not initialized.");
+
+ return this.withLock(function () {
+ var msg;
+ if (data instanceof ManagedType) {
+ msg = new message.UpdateSchema(data.name, data.toJSON());
+ } else {
+ msg = new message.UpdateAllSchemas(data);
+ }
+
+ return _this5.entityManagerFactory.send(msg);
+ });
+ };
+
+ /**
+ * Get the current schema types as json
+ * @returns {json} the json data
+ */
+
+
+ Metamodel.prototype.toJSON = function toJSON() {
+ var json = [];
+
+ for (var ref in this.entities) {
+ json.push(this.entities[ref]);
+ }
+
+ for (ref in this.embeddables) {
+ json.push(this.embeddables[ref]);
+ }
+
+ return json;
+ };
+
+ /**
+ * Replace the current schema by the provided one in json
+ * @param {json} json The json schema data
+ */
+
+
+ Metamodel.prototype.fromJSON = function fromJSON(json) {
+ var builder = new ModelBuilder();
+ var models = builder.buildModels(json);
+
+ this.baseTypes = {};
+ this.embeddables = {};
+ this.entities = {};
+
+ for (var ref in models) {
+ var type = models[ref];
+ this.addType(type);
+ }
+ };
+
+ /**
+ * Creates an index
+ *
+ * @param {string} bucket Name of the Bucket
+ * @param {metamodel.DbIndex} index Will be applied for the given bucket
+ * @return {Promise<*>}
+ */
+
+
+ Metamodel.prototype.createIndex = function createIndex(bucket, index) {
+ index.drop = false;
+ var msg = new message.CreateDropIndex(bucket, index.toJSON());
+ return this.entityManagerFactory.send(msg);
+ };
+
+ /**
+ * Drops an index
+ *
+ * @param {string} bucket Name of the Bucket
+ * @param {metamodel.DbIndex} index Will be dropped for the given bucket
+ * @return {Promise<*>}
+ */
+
+
+ Metamodel.prototype.dropIndex = function dropIndex(bucket, index) {
+ index.drop = true;
+ var msg = new message.CreateDropIndex(bucket, index.toJSON());
+ return this.entityManagerFactory.send(msg);
+ };
+
+ /**
+ * Drops all indexes
+ *
+ * @param {string} bucket Indexes will be dropped for the given bucket
+ * @returns {Promise<*>}
+ */
+
+
+ Metamodel.prototype.dropAllIndexes = function dropAllIndexes(bucket) {
+ var msg = new message.DropAllIndexes(bucket);
+ return this.entityManagerFactory.send(msg);
+ };
+
+ /**
+ * Loads all indexes for the given bucket
+ *
+ * @param {string} bucket Current indexes will be loaded for the given bucket
+ * @returns {Promise>}
+ */
+
+
+ Metamodel.prototype.getIndexes = function getIndexes(bucket) {
+ var msg = new message.ListIndexes(bucket);
+ return this.entityManagerFactory.send(msg).then(function (response) {
+ return response.entity.map(function (el) {
+ return new DbIndex(el.keys, el.unique);
+ });
+ }, function (e) {
+ if (e.status == StatusCode.BUCKET_NOT_FOUND || e.status == StatusCode.OBJECT_NOT_FOUND) {
+ return null;
+ } else {
+ throw e;
+ }
+ });
+ };
+
+ return Metamodel;
+}(Lockable);
+
+module.exports = Metamodel;
+
+},{"25":25,"36":36,"38":38,"40":40,"42":42,"44":44,"47":47,"61":61,"9":9}],47:[function(_dereq_,module,exports){
+"use strict";
+
+var BasicType = _dereq_(38);
+var EntityType = _dereq_(42);
+var EmbeddableType = _dereq_(41);
+
+var ListAttribute = _dereq_(43);
+var MapAttribute = _dereq_(45);
+var SetAttribute = _dereq_(49);
+var SingularAttribute = _dereq_(50);
+
+var PersistentError = _dereq_(32);
+
+/**
+ * @alias metamodel.ModelBuilder
+ */
+
+var ModelBuilder = function () {
+ /**
+ * @param {metamodel.Metamodel} metamodel
+ */
+ function ModelBuilder() {
+ babelHelpers.classCallCheck(this, ModelBuilder);
+
+ /** @type Object */
+ this.models = {};
+
+ /** @type Object */
+ this.modelDescriptors = null;
+
+ for (var _iterator = Object.keys(BasicType), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var typeName = _ref;
+
+ var basicType = BasicType[typeName];
+ if (basicType instanceof BasicType) {
+ this.models[basicType.ref] = basicType;
+ }
+ }
+ }
+
+ /**
+ * @param {string} ref
+ * @returns {metamodel.ManagedType}
+ */
+
+
+ ModelBuilder.prototype.getModel = function getModel(ref) {
+ if (ref in this.models) {
+ return this.models[ref];
+ } else {
+ return this.models[ref] = this.buildModel(ref);
+ }
+ };
+
+ /**
+ * @param {Object[]} modelDescriptors
+ * @returns {Object}
+ */
+
+
+ ModelBuilder.prototype.buildModels = function buildModels(modelDescriptors) {
+ this.modelDescriptors = {};
+ for (var i = 0, modelDescriptor; modelDescriptor = modelDescriptors[i]; ++i) {
+ this.modelDescriptors[modelDescriptor['class']] = modelDescriptor;
+ }
+
+ for (var ref in this.modelDescriptors) {
+ try {
+ var model = this.getModel(ref);
+ this.buildAttributes(model);
+ } catch (e) {
+ throw new PersistentError('Can\'t create model for entity class ' + ref, e);
+ }
+ }
+
+ //ensure at least an object entity
+ this.getModel(EntityType.Object.ref);
+
+ return this.models;
+ };
+
+ /**
+ * @param {string} ref
+ * @returns {metamodel.ManagedType}
+ */
+
+
+ ModelBuilder.prototype.buildModel = function buildModel(ref) {
+ var modelDescriptor = this.modelDescriptors[ref];
+ var type;
+ if (ref == EntityType.Object.ref) {
+ type = new EntityType.Object();
+ } else if (modelDescriptor) {
+ if (modelDescriptor.embedded) {
+ type = new EmbeddableType(ref);
+ } else {
+ var superTypeIdentifier = modelDescriptor['superClass'] || EntityType.Object.ref;
+ type = new EntityType(ref, this.getModel(superTypeIdentifier));
+ }
+ } else {
+ throw new TypeError('No model available for ' + ref);
+ }
+
+ if (modelDescriptor) {
+ var permissions = modelDescriptor['acl'];
+ for (var permission in permissions) {
+ type[permission + 'Permission'].fromJSON(permissions[permission]);
+ }
+ }
+
+ return type;
+ };
+
+ /**
+ * @param {metamodel.EntityType} model
+ */
+
+
+ ModelBuilder.prototype.buildAttributes = function buildAttributes(model) {
+ var modelDescriptor = this.modelDescriptors[model.ref];
+ var fields = modelDescriptor['fields'];
+
+ for (var name in fields) {
+ var field = fields[name];
+ if (!model.getAttribute(name)) //skip predefined attributes
+ model.addAttribute(this.buildAttribute(field.name, field.type), field.order);
+ }
+
+ if (modelDescriptor.validationCode) {
+ model.validationCode = modelDescriptor.validationCode;
+ }
+ };
+
+ /**
+ * @param {metamodel.EntityType} model
+ * @param {string} name
+ * @param {string} ref
+ * @returns {metamodel.Attribute}
+ */
+
+
+ ModelBuilder.prototype.buildAttribute = function buildAttribute(name, ref) {
+ if (ref.indexOf('/db/collection.') == 0) {
+ var collectionType = ref.substring(0, ref.indexOf('['));
+
+ var elementType = ref.substring(ref.indexOf('[') + 1, ref.indexOf(']')).trim();
+ switch (collectionType) {
+ case ListAttribute.ref:
+ return new ListAttribute(name, this.getModel(elementType));
+ case SetAttribute.ref:
+ return new SetAttribute(name, this.getModel(elementType));
+ case MapAttribute.ref:
+ var keyType = elementType.substring(0, elementType.indexOf(',')).trim();
+ elementType = elementType.substring(elementType.indexOf(',') + 1).trim();
+
+ return new MapAttribute(name, this.getModel(keyType), this.getModel(elementType));
+ default:
+ throw new TypeError('No collection available for ' + ref);
+ }
+ } else {
+ return new SingularAttribute(name, this.getModel(ref));
+ }
+ };
+
+ return ModelBuilder;
+}();
+
+module.exports = ModelBuilder;
+
+},{"32":32,"38":38,"41":41,"42":42,"43":43,"45":45,"49":49,"50":50}],48:[function(_dereq_,module,exports){
+"use strict";
+
+var Attribute = _dereq_(37);
+
+/**
+ * @alias metamodel.PluralAttribute
+ * @extends metamodel.Attribute
+ */
+
+var PluralAttribute = function (_Attribute) {
+ babelHelpers.inherits(PluralAttribute, _Attribute);
+ babelHelpers.createClass(PluralAttribute, [{
+ key: "persistentAttributeType",
+ get: function get() {
+ return Attribute.PersistentAttributeType.ELEMENT_COLLECTION;
+ }
+
+ /**
+ * @param {string} name
+ * @param {metamodel.Type} elementType
+ */
+
+ }]);
+
+ function PluralAttribute(name, elementType) {
+ babelHelpers.classCallCheck(this, PluralAttribute);
+
+ /** @type metamodel.Type */
+ var _this = babelHelpers.possibleConstructorReturn(this, _Attribute.call(this, name));
+
+ _this.elementType = elementType;
+ /** @type Class<*> */
+ _this.typeConstructor = null;
+ return _this;
+ }
+
+ return PluralAttribute;
+}(Attribute);
+
+/**
+ * @enum {number}
+ */
+
+
+PluralAttribute.CollectionType = {
+ COLLECTION: 0,
+ LIST: 1,
+ MAP: 2,
+ SET: 3
+};
+
+module.exports = PluralAttribute;
+
+},{"37":37}],49:[function(_dereq_,module,exports){
+"use strict";
+
+var PluralAttribute = _dereq_(48);
+
+/**
+ * @alias metamodel.SetAttribute
+ * @extends metamodel.PluralAttribute
+ */
+
+var SetAttribute = function (_PluralAttribute) {
+ babelHelpers.inherits(SetAttribute, _PluralAttribute);
+ babelHelpers.createClass(SetAttribute, [{
+ key: 'collectionType',
+ get: function get() {
+ return PluralAttribute.CollectionType.SET;
+ }
+
+ /**
+ * @param {string} name
+ * @param {metamodel.Type} elementType
+ */
+
+ }], [{
+ key: 'ref',
+ get: function get() {
+ return '/db/collection.Set';
+ }
+ }]);
+
+ function SetAttribute(name, elementType) {
+ babelHelpers.classCallCheck(this, SetAttribute);
+
+ var _this = babelHelpers.possibleConstructorReturn(this, _PluralAttribute.call(this, name, elementType));
+
+ _this.typeConstructor = Set;
+ return _this;
+ }
+
+ /**
+ * @inheritDoc
+ */
+
+
+ SetAttribute.prototype.getJsonValue = function getJsonValue(state, object) {
+ var value = this.getValue(object);
+
+ if (value instanceof this.typeConstructor) {
+ var persisting = {},
+ persistedState = value.__persistedState__ || {};
+ var changed = value.__persistedSize__ !== value.size;
+
+ var json = [];
+ for (var _iterator = value, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var el = _ref;
+
+ var jsonValue = this.elementType.toJsonValue(state, el);
+ json.push(jsonValue);
+
+ persisting[jsonValue] = el;
+ changed |= persistedState[jsonValue] !== el;
+ }
+
+ if (!state.isReady) {
+ Object.defineProperties(value, {
+ '__persistedState__': { value: persisting, configurable: true },
+ '__persistedSize__': { value: value.size, configurable: true }
+ });
+
+ if (state.isPersistent && changed) state.setDirty();
+ }
+
+ return json;
+ } else {
+ return null;
+ }
+ };
+
+ /**
+ * {@inheritDoc}
+ */
+
+
+ SetAttribute.prototype.setJsonValue = function setJsonValue(state, obj, json) {
+ var value = null;
+
+ if (json) {
+ value = this.getValue(obj);
+
+ if (!(value instanceof this.typeConstructor)) {
+ value = new this.typeConstructor();
+ }
+
+ var persisting = {},
+ persistedState = value.__persistedState__ || {};
+
+ value.clear();
+ for (var i = 0, len = json.length; i < len; ++i) {
+ var jsonValue = json[i];
+ var el = this.elementType.fromJsonValue(state, jsonValue, persistedState[jsonValue]);
+ value.add(el);
+
+ persisting[jsonValue] = el;
+ }
+
+ if (!state.isReady) {
+ Object.defineProperties(value, {
+ '__persistedState__': { value: persisting, configurable: true },
+ '__persistedSize__': { value: value.size, configurable: true }
+ });
+ }
+ }
+
+ this.setValue(obj, value);
+ };
+
+ /**
+ * {@inheritDoc}
+ * @returns {json} {@inheritDoc}
+ */
+
+
+ SetAttribute.prototype.toJSON = function toJSON() {
+ return {
+ name: this.name,
+ type: SetAttribute.ref + '[' + this.elementType.ref + ']',
+ order: this.order
+ };
+ };
+
+ return SetAttribute;
+}(PluralAttribute);
+
+module.exports = SetAttribute;
+
+},{"48":48}],50:[function(_dereq_,module,exports){
+"use strict";
+
+var Attribute = _dereq_(37);
+var Type = _dereq_(51);
+
+/**
+ * @alias metamodel.SingularAttribute
+ * @extends metamodel.Attribute
+ */
+
+var SingularAttribute = function (_Attribute) {
+ babelHelpers.inherits(SingularAttribute, _Attribute);
+ babelHelpers.createClass(SingularAttribute, [{
+ key: 'typeConstructor',
+ get: function get() {
+ return this.type.typeConstructor;
+ }
+ }, {
+ key: 'persistentAttributeType',
+ get: function get() {
+ switch (this.type.persistenceType) {
+ case Type.PersistenceType.BASIC:
+ return Attribute.PersistentAttributeType.BASIC;
+ case Type.PersistenceType.EMBEDDABLE:
+ return Attribute.PersistentAttributeType.EMBEDDED;
+ case Type.PersistenceType.ENTITY:
+ return Attribute.PersistentAttributeType.ONE_TO_MANY;
+ }
+ }
+
+ /**
+ * @param {string} name
+ * @param {metamodel.Type} type
+ * @param {boolean=} isMetadata
+ */
+
+ }]);
+
+ function SingularAttribute(name, type, isMetadata) {
+ babelHelpers.classCallCheck(this, SingularAttribute);
+
+ /** @type metamodel.Type */
+ var _this = babelHelpers.possibleConstructorReturn(this, _Attribute.call(this, name, isMetadata));
+
+ _this.type = type;
+ return _this;
+ }
+
+ /**
+ * @inheritDoc
+ */
+
+
+ SingularAttribute.prototype.getJsonValue = function getJsonValue(state, object) {
+ return this.type.toJsonValue(state, this.getValue(object));
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ SingularAttribute.prototype.setJsonValue = function setJsonValue(state, object, jsonValue) {
+ this.setValue(object, this.type.fromJsonValue(state, jsonValue, this.getValue(object)));
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ SingularAttribute.prototype.toJSON = function toJSON() {
+ return {
+ name: this.name,
+ type: this.type.ref,
+ order: this.order
+ };
+ };
+
+ return SingularAttribute;
+}(Attribute);
+
+module.exports = SingularAttribute;
+
+},{"37":37,"51":51}],51:[function(_dereq_,module,exports){
+"use strict";
+
+/**
+ * @alias metamodel.Type
+ */
+
+var Type = function () {
+ babelHelpers.createClass(Type, [{
+ key: "persistenceType",
+
+ /**
+ * The persistent type of this type
+ * @type number
+ * @abstract
+ */
+ get: function get() {
+ return -1;
+ }
+
+ /**
+ * @type boolean
+ */
+
+ }, {
+ key: "isBasic",
+ get: function get() {
+ return this.persistenceType == Type.PersistenceType.BASIC;
+ }
+
+ /**
+ * @type boolean
+ */
+
+ }, {
+ key: "isEmbeddable",
+ get: function get() {
+ return this.persistenceType == Type.PersistenceType.EMBEDDABLE;
+ }
+
+ /**
+ * @type boolean
+ */
+
+ }, {
+ key: "isEntity",
+ get: function get() {
+ return this.persistenceType == Type.PersistenceType.ENTITY;
+ }
+
+ /**
+ * @type boolean
+ */
+
+ }, {
+ key: "isMappedSuperclass",
+ get: function get() {
+ return this.persistenceType == Type.PersistenceType.MAPPED_SUPERCLASS;
+ }
+
+ /**
+ * @return {Class<*>}
+ */
+
+ }, {
+ key: "typeConstructor",
+ get: function get() {
+ return this._typeConstructor;
+ }
+
+ /**
+ * @param {Class<*>} typeConstructor
+ */
+ ,
+ set: function set(typeConstructor) {
+ if (this._typeConstructor) {
+ throw new Error("typeConstructor has already been set.");
+ }
+ this._typeConstructor = typeConstructor;
+ }
+
+ /**
+ * @param {string} ref
+ * @param {Class<*>} typeConstructor
+ */
+
+ }]);
+
+ function Type(ref, typeConstructor) {
+ babelHelpers.classCallCheck(this, Type);
+
+ if (ref.indexOf("/db/") != 0) {
+ throw new SyntaxError("Type ref " + ref + " is invalid.");
+ }
+
+ /** @type string */
+ this.ref = ref;
+ /** @type string */
+ this.name = ref.substring(4);
+ this._typeConstructor = typeConstructor;
+ }
+
+ /**
+ * Merge the json data into the current object instance and returns the merged object
+ * @param {util.Metadata} state The root object state
+ * @param {json} jsonValue The json data to merge
+ * @param {*=} currentValue The object where the jsonObject will be merged into, if the current object is null,
+ * a new instance will be created
+ * @return {*} The merged object instance
+ * @abstract
+ */
+
+
+ Type.prototype.fromJsonValue = function fromJsonValue(state, jsonValue, currentValue) {};
+
+ /**
+ * Converts the given object to json
+ * @param {util.Metadata} state The root object state
+ * @param {*} object The object to convert
+ * @return {json} The converted object as json
+ * @abstract
+ */
+
+
+ Type.prototype.toJsonValue = function toJsonValue(state, object) {};
+
+ return Type;
+}();
+
+/**
+ * @enum {number}
+ */
+
+
+Type.PersistenceType = {
+ BASIC: 0,
+ EMBEDDABLE: 1,
+ ENTITY: 2,
+ MAPPED_SUPERCLASS: 3
+};
+
+module.exports = Type;
+
+},{}],52:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * @namespace metamodel
+ */
+
+var Metamodel = _dereq_(46);
+
+Metamodel.prototype.Attribute = _dereq_(37);
+Metamodel.prototype.BasicType = _dereq_(38);
+Metamodel.prototype.CollectionAttribute = _dereq_(39);
+Metamodel.prototype.EmbeddableType = _dereq_(41);
+Metamodel.prototype.EntityType = _dereq_(42);
+Metamodel.prototype.ListAttribute = _dereq_(43);
+Metamodel.prototype.ManagedType = _dereq_(44);
+Metamodel.prototype.MapAttribute = _dereq_(45);
+Metamodel.prototype.Metamodel = _dereq_(46);
+Metamodel.prototype.ModelBuilder = _dereq_(47);
+Metamodel.prototype.PluralAttribute = _dereq_(48);
+Metamodel.prototype.SetAttribute = _dereq_(49);
+Metamodel.prototype.SingularAttribute = _dereq_(50);
+Metamodel.prototype.Type = _dereq_(51);
+Metamodel.prototype.DbIndex = _dereq_(40);
+
+exports = module.exports = new Metamodel();
+
+},{"37":37,"38":38,"39":39,"40":40,"41":41,"42":42,"43":43,"44":44,"45":45,"46":46,"47":47,"48":48,"49":49,"50":50,"51":51}],53:[function(_dereq_,module,exports){
+"use strict";
+
+var Filter = _dereq_(55);
+var Condition = _dereq_(54);
+var Operator = _dereq_(57);
+var Query = _dereq_(58);
+var varargs = Query.varargs;
+
+/**
+ * @alias query.Builder
+ * @extends query.Query
+ * @extends query.Condition
+ */
+
+var Builder = function (_Query) {
+ babelHelpers.inherits(Builder, _Query);
+
+ /**
+ * @param {EntityManager} entityManager The owning entity manager of this query
+ * @param {Class} resultClass The query result class
+ */
+ function Builder(entityManager, resultClass) {
+ babelHelpers.classCallCheck(this, Builder);
+ return babelHelpers.possibleConstructorReturn(this, _Query.call(this, entityManager, resultClass));
+ }
+
+ /**
+ * Joins the conditions by an logical AND
+ * @param {...(query.Query|Array>)} args The query nodes to join
+ * @return {query.Query} Returns a new query which joins the given queries by a logical AND
+ */
+
+
+ Builder.prototype.and = function and(args) {
+ return this._addOperator('$and', varargs(0, arguments));
+ };
+
+ /**
+ * Joins the conditions by an logical OR
+ * @param {...(query.Query|Array>)} args The query nodes to join
+ * @return {query.Query} Returns a new query which joins the given queries by a logical OR
+ */
+
+
+ Builder.prototype.or = function or(args) {
+ return this._addOperator('$or', varargs(0, arguments));
+ };
+
+ /**
+ * Joins the conditions by an logical NOR
+ * @param {...(query.Query|Array>)} args The query nodes to join
+ * @return {query.Query} Returns a new query which joins the given queries by a logical NOR
+ */
+
+
+ Builder.prototype.nor = function nor(args) {
+ return this._addOperator('$nor', varargs(0, arguments));
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ Builder.prototype.stream = function stream(options) {
+ return this.where({})._stream(options, this);
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ Builder.prototype.resultList = function resultList(options, doneCallback, failCallback) {
+ return this.where({}).resultList(options, doneCallback, failCallback);
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ Builder.prototype.singleResult = function singleResult(options, doneCallback, failCallback) {
+ return this.where({}).singleResult(options, doneCallback, failCallback);
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ Builder.prototype.count = function count(doneCallback, failCallback) {
+ return this.where({}).count(doneCallback, failCallback);
+ };
+
+ Builder.prototype._addOperator = function _addOperator(operator, args) {
+ if (args.length < 2) {
+ throw new Error('Only two or more queries can be joined with an ' + operator + ' operator.');
+ }
+
+ args.forEach(function (arg, index) {
+ if (!(arg instanceof Query)) {
+ throw new Error('Argument at index ' + index + ' is not a query.');
+ }
+ });
+
+ return new Operator(this.entityManager, this.resultClass, operator, args);
+ };
+
+ Builder.prototype._addOrder = function _addOrder(fieldOrSort, order) {
+ return new Filter(this.entityManager, this.resultClass)._addOrder(fieldOrSort, order);
+ };
+
+ Builder.prototype._addFilter = function _addFilter(field, filter, value) {
+ return new Filter(this.entityManager, this.resultClass)._addFilter(field, filter, value);
+ };
+
+ Builder.prototype._addOffset = function _addOffset(offset) {
+ return new Filter(this.entityManager, this.resultClass)._addOffset(offset);
+ };
+
+ Builder.prototype._addLimit = function _addLimit(limit) {
+ return new Filter(this.entityManager, this.resultClass)._addLimit(limit);
+ };
+
+ return Builder;
+}(Query);
+
+Object.assign(Builder.prototype, Condition);
+
+module.exports = Builder;
+
+},{"54":54,"55":55,"57":57,"58":58}],54:[function(_dereq_,module,exports){
+"use strict";
+
+var varargs = _dereq_(58).varargs;
+
+/**
+ * @class query.Condition
+ */
+var Condition = {};
+
+Object.assign(Condition, /** @lends query.Condition.prototype */{
+
+ /**
+ * An object, that contains filter rules which will be merged with the current filters of this query.
+ * @param {json} conditions - Additional filters for this query
+ * @return {query.Filter} The resulting Query
+ * @instance
+ */
+ where: function where(conditions) {
+ return this._addFilter(null, null, conditions);
+ },
+
+
+ /**
+ * Adds a equal filter to the field. All other other filters on the field will be discarded
+ * @param {string} field The field to filter
+ * @param {*} value The value used to filter
+ * @return {query.Filter} The resulting Query
+ * @instance
+ */
+ equal: function equal(field, value) {
+ return this._addFilter(field, null, value);
+ },
+
+
+ /**
+ * Adds a not equal filter to the field.
+ * @param {string} field The field to filter
+ * @param {*} value The value used to filter
+ * @return {query.Filter} The resulting Query
+ * @instance
+ *
+ * @see http://docs.mongodb.org/manual/reference/operator/query/nin/
+ */
+ notEqual: function notEqual(field, value) {
+ return this._addFilter(field, "$ne", value);
+ },
+
+
+ /**
+ * Adds a greater than filter to the field.
+ * @param {string} field The field to filter
+ * @param {number|string|Date} value The value used to filter
+ * @return {query.Filter} The resulting Query
+ * @instance
+ *
+ * @see http://docs.mongodb.org/manual/reference/operator/query/gt/
+ */
+ greaterThan: function greaterThan(field, value) {
+ return this._addFilter(field, "$gt", value);
+ },
+
+
+ /**
+ * Adds a greater than or equal to filter to the field.
+ * @param {string} field The field to filter
+ * @param {number|string|Date} value The value used to filter
+ * @return {query.Filter} The resulting Query
+ * @instance
+ *
+ * @see http://docs.mongodb.org/manual/reference/operator/query/gte/
+ */
+ greaterThanOrEqualTo: function greaterThanOrEqualTo(field, value) {
+ return this._addFilter(field, "$gte", value);
+ },
+
+
+ /**
+ * Adds a less than filter to the field.
+ * @param {string} field The field to filter
+ * @param {number|string|Date} value The value used to filter
+ * @return {query.Filter} The resulting Query
+ * @instance
+ *
+ * @see http://docs.mongodb.org/manual/reference/operator/query/lt/
+ */
+ lessThan: function lessThan(field, value) {
+ return this._addFilter(field, "$lt", value);
+ },
+
+
+ /**
+ * Adds a less than or equal to filter to the field.
+ * @param {string} field The field to filter
+ * @param {number|string|Date} value The value used to filter
+ * @return {query.Filter} The resulting Query
+ * @instance
+ *
+ * @see http://docs.mongodb.org/manual/reference/operator/query/lte/
+ */
+ lessThanOrEqualTo: function lessThanOrEqualTo(field, value) {
+ return this._addFilter(field, "$lte", value);
+ },
+
+
+ /**
+ * Adds a between filter to the field. This is a shorthand for an less than and greater than filter.
+ * @param {string} field The field to filter
+ * @param {number|string|Date} lessValue The field value must be greater than this value
+ * @param {number|string|Date} greaterValue The field value must be less than this value
+ * @return {query.Filter} The resulting Query
+ * @instance
+ */
+ between: function between(field, lessValue, greaterValue) {
+ return this._addFilter(field, "$gt", lessValue)._addFilter(field, "$lt", greaterValue);
+ },
+
+
+ /**
+ * Adds a in filter to the field. The field value must be equal to one of the given values
+ * @param {string} field The field to filter
+ * @param {...(*|Array<*>)} args The field value or values to filter
+ * @return {query.Filter} The resulting Query
+ * @instance
+ *
+ * @see http://docs.mongodb.org/manual/reference/operator/query/in/
+ */
+ 'in': function _in(field, args) {
+ return this._addFilter(field, "$in", varargs(1, arguments));
+ },
+
+
+ /**
+ * Adds a in filter to the field. The field value must be equal to one of the given values
+ * @param {string} field The field to filter
+ * @param {...(*|Array<*>)} args The field value or values to filter
+ * @return {query.Filter} The resulting Query
+ * @instance
+ * @memberOf query.Condition.prototype
+ * @name in
+ *
+ * @see http://docs.mongodb.org/manual/reference/operator/query/in/
+ */
+
+ /**
+ * Adds a not in filter to the field. The field value must not be equal to any of the given values
+ * @param {string} field The field to filter
+ * @param {...(*|Array<*>)} args The field value or values to filter
+ * @return {query.Filter} The resulting Query
+ * @instance
+ *
+ * @see http://docs.mongodb.org/manual/reference/operator/query/nin/
+ */
+ notIn: function notIn(field, args) {
+ return this._addFilter(field, "$nin", varargs(1, arguments));
+ },
+
+
+ /**
+ * Adds a null filter to the field. The field value must be null
+ * @param {string} field The field to filter
+ * @return {query.Filter} The resulting Query
+ * @instance
+ */
+ isNull: function isNull(field) {
+ return this.equal(field, null);
+ },
+
+
+ /**
+ * Adds a not null filter to the field. The field value must not be null
+ * @param {string} field The field to filter
+ * @return {query.Filter} The resulting Query
+ * @instance
+ */
+ isNotNull: function isNotNull(field) {
+ return this._addFilter(field, "$exists", true)._addFilter(field, "$ne", null);
+ },
+
+
+ /**
+ * Adds a contains all filter to the collection field. The collection must contain all the given values.
+ * @param {string} field The field to filter
+ * @param {...(*|Array<*>)} args The field value or values to filter
+ * @return {query.Filter} The resulting Query
+ * @instance
+ *
+ * @see http://docs.mongodb.org/manual/reference/operator/query/all/
+ */
+ containsAll: function containsAll(field, args) {
+ return this._addFilter(field, "$all", varargs(1, arguments));
+ },
+
+
+ /**
+ * Adds a modulo filter to the field. The field value divided by divisor must be equal to the remainder.
+ * @param {string} field The field to filter
+ * @param {number} divisor The divisor of the modulo filter
+ * @param {number} remainder The remainder of the modulo filter
+ * @return {query.Filter} The resulting Query
+ * @instance
+ *
+ * @see http://docs.mongodb.org/manual/reference/operator/query/mod/
+ */
+ mod: function mod(field, divisor, remainder) {
+ return this._addFilter(field, "$mod", [divisor, remainder]);
+ },
+
+
+ /**
+ * Adds a regular expression filter to the field. The field value must matches the regular expression.
+ * Note: Only anchored expressions (Expressions that starts with an ^) and the multiline flag are supported.
+ * @param {string} field The field to filter
+ * @param {string|RegExp} regExp The regular expression of the filter
+ * @return {query.Filter} The resulting Query
+ * @instance
+ *
+ * @see http://docs.mongodb.org/manual/reference/operator/query/regex/
+ */
+ matches: function matches(field, regExp) {
+ if (!(Object(regExp) instanceof RegExp)) {
+ regExp = new RegExp(regExp);
+ }
+
+ if (regExp.ignoreCase) {
+ throw new Error('RegExp.ignoreCase flag is not supported.');
+ }
+
+ if (regExp.global) {
+ throw new Error('RegExp.global flag is not supported.');
+ }
+
+ if (regExp.source.indexOf('^') != 0) {
+ throw new Error('regExp must be an anchored expression, i.e. it must be started with a ^.');
+ }
+
+ var result = this._addFilter(field, '$regex', regExp.source);
+ if (regExp.multiline) {
+ result._addFilter(field, '$options', 'm');
+ }
+
+ return result;
+ },
+
+
+ /**
+ * Adds a size filter to the collection field. The collection must have exactly size members.
+ * @param {string} field The field to filter
+ * @param {number} size The collections size to filter
+ * @return {query.Filter} The resulting Query
+ * @instance
+ *
+ * @see http://docs.mongodb.org/manual/reference/operator/query/size/
+ */
+ size: function size(field, _size) {
+ return this._addFilter(field, "$size", _size);
+ },
+
+
+ /**
+ * Adds a geopoint based near filter to the GeoPoint field. The GeoPoint must be within the maximum distance
+ * to the given GeoPoint. Returns from nearest to farthest.
+ * @param {string} field The field to filter
+ * @param {GeoPoint} geoPoint The GeoPoint to filter
+ * @param {number} maxDistance Tha maximum distance to filter in meters
+ * @return {query.Filter} The resulting Query
+ * @instance
+ *
+ * @see http://docs.mongodb.org/manual/reference/operator/query/nearSphere/
+ */
+ near: function near(field, geoPoint, maxDistance) {
+ return this._addFilter(field, "$nearSphere", {
+ $geometry: {
+ type: "Point",
+ coordinates: [geoPoint.longitude, geoPoint.latitude]
+ },
+ $maxDistance: maxDistance
+ });
+ },
+
+
+ /**
+ * Adds a GeoPoint based polygon filter to the GeoPoint field. The GeoPoint must be contained within the polygon.
+ * @param {string} field The field to filter
+ * @param {...(GeoPoint|Array)} geoPoints The geoPoints that describes the polygon of the filter
+ * @return {query.Filter} The resulting Query
+ * @instance
+ *
+ * @see http://docs.mongodb.org/manual/reference/operator/query/geoWithin/
+ */
+ withinPolygon: function withinPolygon(field, geoPoints) {
+ geoPoints = varargs(1, arguments);
+ return this._addFilter(field, "$geoWithin", {
+ $geometry: {
+ type: "Polygon",
+ coordinates: [geoPoints.map(function (geoPoint) {
+ return [geoPoint.longitude, geoPoint.latitude];
+ })]
+ }
+ });
+ }
+});
+
+// aliases
+Object.assign(Condition, /** @lends query.Condition.prototype */{
+ /**
+ * Adds a less than filter to the field. Shorthand for {@link query.Condition#lessThan}.
+ * @method
+ * @param {string} field The field to filter
+ * @param {number|string|Date} value The value used to filter
+ * @return {query.Filter} The resulting Query
+ *
+ * @see http://docs.mongodb.org/manual/reference/operator/query/lt/
+ */
+ lt: Condition.lessThan,
+
+ /**
+ * Adds a less than or equal to filter to the field. Shorthand for {@link query.Condition#lessThanOrEqualTo}.
+ * @method
+ * @param {string} field The field to filter
+ * @param {number|string|Date} value The value used to filter
+ * @return {query.Filter} The resulting Query
+ *
+ * @see http://docs.mongodb.org/manual/reference/operator/query/lte/
+ */
+ le: Condition.lessThanOrEqualTo,
+
+ /**
+ * Adds a greater than filter to the field. Shorthand for {@link query.Condition#greaterThan}.
+ * @method
+ * @param {string} field The field to filter
+ * @param {number|string|Date} value The value used to filter
+ * @return {query.Filter} The resulting Query
+ *
+ * @see http://docs.mongodb.org/manual/reference/operator/query/gt/
+ */
+ gt: Condition.greaterThan,
+
+ /**
+ * Adds a greater than or equal to filter to the field. Shorthand for {@link query.Condition#greaterThanOrEqualTo}.
+ * @method
+ * @param {string} field The field to filter
+ * @param {number|string|Date} value The value used to filter
+ * @return {query.Filter} The resulting Query
+ *
+ * @see http://docs.mongodb.org/manual/reference/operator/query/gte/
+ */
+ ge: Condition.greaterThanOrEqualTo,
+
+ /**
+ * Adds a contains any filter to the collection field. The collection must contains one the given values.
+ * Alias for {@link query.Condition#in}
+ * @method
+ * @param {string} field The field to filter
+ * @param {...(*|Array<*>)} args The field value or values to filter
+ * @return {query.Filter} The resulting Query
+ *
+ * @see http://docs.mongodb.org/manual/reference/operator/query/in/
+ */
+ containsAny: Condition.in
+});
+
+module.exports = Condition;
+
+},{"58":58}],55:[function(_dereq_,module,exports){
+"use strict";
+
+var Node = _dereq_(56);
+var Condition = _dereq_(54);
+
+/**
+ * @alias query.Filter
+ * @extends query.Node
+ * @extends query.Condition
+ */
+
+var Filter = function (_Node) {
+ babelHelpers.inherits(Filter, _Node);
+
+ /**
+ * @param {EntityManager} entityManager The owning entity manager of this query
+ * @param {Class} resultClass The query result class
+ */
+ function Filter(entityManager, resultClass) {
+ babelHelpers.classCallCheck(this, Filter);
+
+ /**
+ * The actual filters of this node
+ * @type Object
+ */
+ var _this = babelHelpers.possibleConstructorReturn(this, _Node.call(this, entityManager, resultClass));
+
+ _this._filter = {};
+ return _this;
+ }
+
+ Filter.prototype._addFilter = function _addFilter(field, filter, value) {
+ if (field !== null) {
+ if (!(Object(field) instanceof String)) throw new Error('Field must be a string.');
+
+ if (filter) {
+ var fieldFilter = this._filter[field];
+ if (!(fieldFilter instanceof Object) || Object.getPrototypeOf(fieldFilter) != Object.prototype) {
+ this._filter[field] = fieldFilter = {};
+ }
+
+ fieldFilter[filter] = value;
+ } else {
+ this._filter[field] = value;
+ }
+ } else {
+ Object.assign(this._filter, value);
+ }
+
+ return this;
+ };
+
+ Filter.prototype.toJSON = function toJSON() {
+ return this._filter;
+ };
+
+ return Filter;
+}(Node);
+
+Object.assign(Filter.prototype, Condition);
+module.exports = Filter;
+
+},{"54":54,"56":56}],56:[function(_dereq_,module,exports){
+"use strict";
+
+var Query = _dereq_(58);
+var message = _dereq_(36);
+var Metadata = _dereq_(63);
+var Entity = _dereq_(10);
+
+/**
+ * @alias query.Node
+ * @extends query.Query
+ */
+
+var Node = function (_Query) {
+ babelHelpers.inherits(Node, _Query);
+
+ /**
+ * @param {EntityManager} entityManager The owning entity manager of this query
+ * @param {Class} resultClass The query result class
+ */
+ function Node(entityManager, resultClass) {
+ babelHelpers.classCallCheck(this, Node);
+
+ /**
+ * The offset how many results should be skipped
+ * @type number
+ */
+ var _this = babelHelpers.possibleConstructorReturn(this, _Query.call(this, entityManager, resultClass));
+
+ _this.firstResult = 0;
+
+ /**
+ * The limit how many objects should be returned
+ * @type number
+ */
+ _this.maxResults = -1;
+
+ _this._sort = {};
+ return _this;
+ }
+
+ /**
+ * @inheritDoc
+ */
+
+
+ Node.prototype.stream = function stream(options) {
+ return this._stream(options, this);
+ };
+
+ /**
+ * Only available in streaming SDK!
+ * @ignore
+ */
+
+
+ Node.prototype._stream = function _stream(options, target) {
+ throw new Error('Streaming features not available! Please use Streaming SDK!');
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ Node.prototype.resultList = function resultList(options, doneCallback, failCallback) {
+ var _this2 = this;
+
+ if (options instanceof Function) {
+ failCallback = doneCallback;
+ doneCallback = options;
+ options = {};
+ }
+
+ var type = this.resultClass ? this.entityManager.metamodel.entity(this.resultClass) : null;
+
+ if (!type) {
+ throw new Error('Only typed queries can be executed.');
+ }
+
+ var query = this._serializeQuery();
+ var sort = this._serializeSort();
+
+ var uriSize = this.entityManager._connector.host.length + query.length;
+ var msg;
+ if (uriSize > Query.MAX_URI_SIZE) {
+ msg = new message.AdhocQueryPOST(type.name, this.firstResult, this.maxResults, sort).entity(query, 'text');
+ } else {
+ msg = new message.AdhocQuery(type.name, query, this.firstResult, this.maxResults, sort);
+ }
+
+ return this.entityManager.send(msg).then(function (response) {
+ return _this2._createResultList(response.entity, options);
+ }).then(doneCallback, failCallback);
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ Node.prototype.singleResult = function singleResult(options, doneCallback, failCallback) {
+ var _this3 = this;
+
+ if (options instanceof Function) {
+ failCallback = doneCallback;
+ doneCallback = options;
+ options = {};
+ }
+
+ var type = this.resultClass ? this.entityManager.metamodel.entity(this.resultClass) : null;
+
+ if (!type) {
+ throw new Error('Only typed queries can be executed.');
+ }
+
+ var query = this._serializeQuery();
+ var sort = this._serializeSort();
+
+ var uriSize = this.entityManager._connector.host.length + query.length;
+ var msg;
+ if (uriSize > Query.MAX_URI_SIZE) {
+ msg = new message.AdhocQueryPOST(type.name, query, this.firstResult, 1, sort).entity(query, 'text');
+ } else {
+ msg = new message.AdhocQuery(type.name, query, this.firstResult, 1, sort);
+ }
+
+ return this.entityManager.send(msg).then(function (response) {
+ return _this3._createResultList(response.entity, options);
+ }).then(function (list) {
+ return list.length ? list[0] : null;
+ }).then(doneCallback, failCallback);
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ Node.prototype.count = function count(doneCallback, failCallback) {
+ var type = this.resultClass ? this.entityManager.metamodel.entity(this.resultClass) : null;
+
+ if (!type) {
+ throw new Error('Only typed queries can be executed.');
+ }
+
+ var query = this._serializeQuery();
+
+ var uriSize = this.entityManager._connector.host.length + query.length;
+ var msg;
+ if (uriSize > Query.MAX_URI_SIZE) {
+ msg = new message.AdhocCountQueryPOST(type.name).entity(query, 'text');
+ } else {
+ msg = new message.AdhocCountQuery(type.name, query);
+ }
+
+ return this.entityManager.send(msg).then(function (response) {
+ return response.entity.count;
+ }).then(doneCallback, failCallback);
+ };
+
+ Node.prototype._serializeQuery = function _serializeQuery() {
+ return JSON.stringify(this, function (k, v) {
+ var typedValue = this[k];
+ if (Object(typedValue) instanceof Date) {
+ return { $date: v };
+ } else if (typedValue instanceof Entity) {
+ return typedValue.id;
+ } else {
+ return v;
+ }
+ });
+ };
+
+ Node.prototype._serializeSort = function _serializeSort() {
+ return JSON.stringify(this._sort);
+ };
+
+ Node.prototype._createResultList = function _createResultList(result, options) {
+ if (result.length) {
+ return Promise.all(result.map(function (el) {
+ if (el.id) {
+ var entity = this.entityManager.getReference(this.resultClass, el.id);
+ var metadata = Metadata.get(entity);
+ metadata.setJson(el);
+ metadata.setPersistent();
+ return this.entityManager.resolveDepth(entity, options);
+ } else {
+ return this.entityManager.load(Object.keys(el)[0]);
+ }
+ }, this)).then(function (result) {
+ return result.filter(function (val) {
+ return !!val;
+ });
+ });
+ } else {
+ return Promise.resolve([]);
+ }
+ };
+
+ Node.prototype._addOrder = function _addOrder(fieldOrSort, order) {
+ if (order) {
+ this._sort[fieldOrSort] = order;
+ } else {
+ this._sort = fieldOrSort;
+ }
+ return this;
+ };
+
+ Node.prototype._addOffset = function _addOffset(offset) {
+ this.firstResult = offset;
+ return this;
+ };
+
+ Node.prototype._addLimit = function _addLimit(limit) {
+ this.maxResults = limit;
+ return this;
+ };
+
+ return Node;
+}(Query);
+
+module.exports = Node;
+
+},{"10":10,"36":36,"58":58,"63":63}],57:[function(_dereq_,module,exports){
+"use strict";
+
+var Node = _dereq_(56);
+
+/**
+ * @alias query.Operator
+ * @extends query.Node
+ */
+
+var Operator = function (_Node) {
+ babelHelpers.inherits(Operator, _Node);
+
+ /**
+ * @param {EntityManager} entityManager The owning entity manager of this query
+ * @param {Class} resultClass The query result class
+ * @param {string} operator The operator used to join the childs
+ * @param {Array>} childs The childs to join
+ */
+ function Operator(entityManager, resultClass, operator, childs) {
+ babelHelpers.classCallCheck(this, Operator);
+
+ /**
+ * The operator used to join the child queries
+ * @type string
+ */
+ var _this = babelHelpers.possibleConstructorReturn(this, _Node.call(this, entityManager, resultClass));
+
+ _this._operator = operator;
+ /**
+ * The child Node of this query, it is always one
+ * @type Array
+ */
+ _this._childs = childs;
+ return _this;
+ }
+
+ Operator.prototype.toJSON = function toJSON() {
+ var json = {};
+ json[this._operator] = this._childs;
+ return json;
+ };
+
+ return Operator;
+}(Node);
+
+module.exports = Operator;
+
+},{"56":56}],58:[function(_dereq_,module,exports){
+"use strict";
+
+/**
+ * @alias query.Query
+ */
+
+var Query = function () {
+ function Query(entityManager, resultClass) {
+ babelHelpers.classCallCheck(this, Query);
+
+ /**
+ * The owning EntityManager of this query
+ * @type EntityManager
+ */
+ this.entityManager = entityManager;
+
+ /**
+ * The result class of this query
+ * @type Class
+ */
+ this.resultClass = resultClass;
+ }
+
+ /**
+ * Add an ascending sort for the specified field to this query
+ * @param {string} field The field to sort
+ * @return {query.Query} The resulting Query
+ */
+
+
+ Query.prototype.ascending = function ascending(field) {
+ return this._addOrder(field, 1);
+ };
+
+ /**
+ * Add an decending sort for the specified field to this query
+ * @param {string} field The field to sort
+ * @return {query.Query} The resulting Query
+ */
+
+
+ Query.prototype.descending = function descending(field) {
+ return this._addOrder(field, -1);
+ };
+
+ /**
+ * Sets the sort of the query and discard all existing paramaters
+ * @param {Object} sort The new sort of the query
+ * @return {query.Query} The resulting Query
+ *
+ * @see http://docs.mongodb.org/manual/reference/method/cursor.sort/
+ */
+
+
+ Query.prototype.sort = function sort(_sort) {
+ if (!(_sort instanceof Object) || Object.getPrototypeOf(_sort) != Object.prototype) throw new Error('sort must be an object.');
+
+ return this._addOrder(_sort);
+ };
+
+ /**
+ * Sets the offset of the query, i.e. how many elements should be skipped
+ * @param {number} offset The offset of this query
+ * @return {query.Query} The resulting Query
+ *
+ * @see http://docs.mongodb.org/manual/reference/method/cursor.skip/
+ */
+
+
+ Query.prototype.offset = function offset(_offset) {
+ if (_offset < 0) throw new Error("The offset can't be nagative.");
+
+ return this._addOffset(_offset);
+ };
+
+ /**
+ * Sets the limit of this query, i.e hox many objects should be returnd
+ * @param {number} limit The limit of this query
+ * @return {query.Query} The resulting Query
+ *
+ * @see http://docs.mongodb.org/manual/reference/method/cursor.limit/
+ */
+
+
+ Query.prototype.limit = function limit(_limit) {
+ if (_limit < 0) throw new Error("The limit can't be nagative.");
+
+ return this._addLimit(_limit);
+ };
+
+ /**
+ * Execute the query and return the query results as a List.
+ * Note: All local unsaved changes on matching objects, will be discarded.
+ * @param {Object} [options] The query options
+ * @param {number|boolean} [options.depth=0] The object depth which will be loaded. Depth 0 load only the found
+ * objects, true loads the objects by reachability.
+ * @param {query.Query~resultListCallback=} doneCallback Called when the operation succeed.
+ * @param {query.Query~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise>} A promise that will be resolved with the query result as a list
+ */
+
+
+ Query.prototype.resultList = function resultList(options, doneCallback, failCallback) {};
+
+ /**
+ * Execute the query and return the query results as a List.
+ * Note: All local unsaved changes on matching objects, will be discarded.
+ * @param {query.Query~resultListCallback=} doneCallback Called when the operation succeed.
+ * @param {query.Query~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise>} A promise that will be resolved with the query result as a list
+ * @name resultList
+ * @memberOf query.Query.prototype
+ * @method
+ */
+
+ /**
+ * Execute the query that returns a single result.
+ * Note: All local unsaved changes on the matched object, will be discarded.
+ * @param {Object} [options] The query options
+ * @param {number|boolean} [options.depth=0] The object depth which will be loaded. Depth 0 load only the found
+ * object, true loads the objects by reachability.
+ * @param {query.Query~singleResultCallback=} doneCallback Called when the operation succeed.
+ * @param {query.Query~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise} A promise that will be resolved with the query result as a single result
+ */
+
+
+ Query.prototype.singleResult = function singleResult(options, doneCallback, failCallback) {};
+
+ /**
+ * Execute the query that returns a single result.
+ * Note: All local unsaved changes on the matched object, will be discarded.
+ * @param {query.Query~singleResultCallback=} doneCallback Called when the operation succeed.
+ * @param {query.Query~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise} A promise that will be resolved with the query result as a single result
+ * @name singleResult
+ * @memberOf query.Query.prototype
+ * @method
+ */
+
+ /**
+ * Returns an RxJS observable that receives events for streaming query.
+ * @param {Object} [options] options on whether an initial result and what kind of events (w.r.t. match types and operations) are requested
+ * @param {boolean} [options.initial=true] whether or not you want to receive the initial result set (i.e. the entities matching the query at subscription time)
+ * @param {(string|Array)} [options.matchTypes=['all']] the match types you are interested in; accepts the default ('all'/['all']) or any combination of 'match', 'add', 'change', 'changeIndex' and 'remove'
+ * @param {(string|Array)} [options.operations=['any']] the operations you are interested in; accepts the default ('any'/['any']) or any combination of 'insert', 'update', 'delete' and 'none'
+ * @return {Observable>} an RxJS observable
+ */
+
+
+ Query.prototype.stream = function stream(options) {};
+
+ /**
+ * Execute the query that returns the matching objects count.
+ * @param {query.Query~countCallback=} doneCallback Called when the operation succeed.
+ * @param {query.Query~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise} The total number of matched objects
+ */
+
+
+ Query.prototype.count = function count(doneCallback, failCallback) {};
+
+ return Query;
+}();
+
+Query.MAX_URI_SIZE = 2000;
+
+Query.varargs = function varargs(offset, args) {
+ return Array.prototype.concat.apply([], Array.prototype.slice.call(args, offset));
+};
+
+module.exports = Query;
+
+/**
+ * The resultList callback is called, when the asynchronous query operation completes successfully
+ * @callback query.Query~resultListCallback
+ * @param {Array} result The query result list, an empty list if no match was found
+ * @return {Promise<*>|*} A Promise, result or undefined
+ */
+
+/**
+ * The singleResult callback is called, when the asynchronous query operation completes successfully
+ * @callback query.Query~singleResultCallback
+ * @param {T} entity The matching object or null id no matching object was found
+ * @return {Promise<*>|*} A Promise, result or undefined
+ */
+
+/**
+ * The count callback is called, when the asynchronous query operation completes successfully
+ * @callback query.Query~countCallback
+ * @param {number} count the matching object count
+ * @return {Promise<*>|*} A Promise, result or undefined
+ */
+
+/**
+ * The fail callback is called, when the asynchronous query operation is rejected by an error
+ * @callback query.Query~failCallback
+ * @param {error.PersistentError} error The error which reject the operation
+ * @return {Promise<*>|*} A Promise, result or undefined
+ */
+
+},{}],59:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * @namespace query
+ */
+
+exports.Builder = _dereq_(53);
+exports.Condition = _dereq_(54);
+exports.Filter = _dereq_(55);
+exports.Node = _dereq_(56);
+exports.Operator = _dereq_(57);
+exports.Query = _dereq_(58);
+
+},{"53":53,"54":54,"55":55,"56":56,"57":57,"58":58}],60:[function(_dereq_,module,exports){
+"use strict";
+
+var message = _dereq_(36);
+var StatusCode = _dereq_(25).StatusCode;
+
+/**
+ * @alias util.Code
+ * @param {metamodel.Metamodel} metamodel
+ */
+
+var Code = function () {
+ function Code(metamodel, entityManagerFactory) {
+ babelHelpers.classCallCheck(this, Code);
+
+ /**
+ * @private
+ * @type metamodel.Metamodel
+ */
+ this._metamodel = metamodel;
+ /** @type EntityManagerFactory */
+ this.entityManagerFactory = entityManagerFactory;
+ }
+
+ /**
+ * Converts the given function to a string
+ * @param {Function} fn The JavaScript function to serialize
+ * @return {string} The serialized function
+ */
+
+
+ Code.prototype.functionToString = function functionToString(fn) {
+ if (!fn) return "";
+
+ var str = fn.toString();
+ str = str.substring(str.indexOf("{") + 1, str.lastIndexOf("}"));
+ if (str.charAt(0) == '\n') str = str.substring(1);
+
+ if (str.charAt(str.length - 1) == '\n') str = str.substring(0, str.length - 1);
+
+ return str;
+ };
+
+ /**
+ * Converts the given string to a module wrapper function
+ * @param {Array} signature The expected parameters of the function
+ * @param {string} code The JavaScript function to deserialize
+ * @return {Function} The deserialized function
+ */
+
+
+ Code.prototype.stringToFunction = function stringToFunction(signature, code) {
+ return new Function(signature, code);
+ };
+
+ /**
+ * Loads a list of all available modules
+ * Does not include handlers
+ *
+ * @returns {Promise>}
+ */
+
+
+ Code.prototype.loadModules = function loadModules() {
+ var msg = new message.GetAllModules();
+ return this.entityManagerFactory.send(msg).then(function (response) {
+ return response.entity;
+ });
+ };
+
+ /**
+ * Loads Baqend code which will be identified by the given bucket and code codeType
+ *
+ * @param {metamodel.ManagedType|string} type The entity type for the handler or the Name of the
+ * Baqend code
+ * @param {string} codeType The type of the code
+ * @param {boolean} [asFunction=false] set it to true, to parse the code as a function and return it
+ * instead of a string
+ * @returns {Promise} The code as string or as a parsed function
+ */
+
+
+ Code.prototype.loadCode = function loadCode(type, codeType, asFunction) {
+ var _this = this;
+
+ var bucket = Object(type) instanceof String ? type : type.name;
+ var msg = new message.GetBaqendCode(bucket, codeType).responseType('text');
+
+ return this.entityManagerFactory.send(msg).then(function (response) {
+ return _this._parseCode(bucket, codeType, asFunction, response.entity);
+ }, function (e) {
+ if (e.status == StatusCode.OBJECT_NOT_FOUND) return null;
+
+ throw e;
+ });
+ };
+
+ /**
+ * Saves Baqend code which will be identified by the given bucket and code type
+ *
+ * @param {metamodel.ManagedType|string} type The entity type for the handler or the Name of the
+ * Baqend code
+ * @param {string} codeType The type of the code
+ * @param {string|Function} fn Baqend code as a string or function
+ * @return {Promise} The stored code as a string or as a parsed function
+ */
+
+
+ Code.prototype.saveCode = function saveCode(type, codeType, fn) {
+ var _this2 = this;
+
+ var bucket = Object(type) instanceof String ? type : type.name;
+ var asFunction = fn instanceof Function;
+
+ var msg = new message.SetBaqendCode(bucket, codeType).entity(asFunction ? this.functionToString(fn) : fn, 'text').responseType('text');
+
+ return this.entityManagerFactory.send(msg).then(function (response) {
+ return _this2._parseCode(bucket, codeType, asFunction, response.entity);
+ });
+ };
+
+ /**
+ * Deletes Baqend code identified by the given bucket and code type
+ *
+ * @param {metamodel.ManagedType|string} type The entity type for the handler or the Name of the
+ * Baqend code
+ * @param {string} codeType The type of the code
+ * @returns {Promise<*>} succeed if the code was deleted
+ */
+
+
+ Code.prototype.deleteCode = function deleteCode(type, codeType) {
+ var _this3 = this;
+
+ var bucket = Object(type) instanceof String ? type : type.name;
+ var msg = new message.DeleteBaqendCode(bucket, codeType);
+ return this.entityManagerFactory.send(msg).then(function () {
+ return _this3._parseCode(bucket, codeType, false, null);
+ });
+ };
+
+ Code.prototype._parseCode = function _parseCode(bucket, codeType, asFunction, code) {
+ if (codeType == 'validate') {
+ var type = this._metamodel.entity(bucket);
+ type.validationCode = code;
+ return asFunction ? type.validationCode : code;
+ } else {
+ return asFunction ? this.stringToFunction(['module', 'exports'], code) : code;
+ }
+ };
+
+ return Code;
+}();
+
+module.exports = Code;
+
+},{"25":25,"36":36}],61:[function(_dereq_,module,exports){
+"use strict";
+
+/**
+ * This base class provides an lock interface to execute exclusive operations
+ * @alias util.Lockable
+ */
+
+var Lockable = function () {
+ function Lockable() {
+ babelHelpers.classCallCheck(this, Lockable);
+
+ /**
+ * Indicates if there is currently an onging exclusive operation
+ * @type boolean
+ * @private
+ */
+ this._isLocked = false;
+
+ /**
+ * A promise which represents the state of the least exclusive operation
+ * @type Promise
+ * @private
+ */
+ this._readyPromise = Promise.resolve(this);
+
+ /**
+ * A deferred used to explicit lock and unlock this instance
+ * @private
+ */
+ this._deferred = null;
+ }
+
+ /**
+ * Indicates if there is currently no exclusive operation executed
+ * true If no exclusive lock is hold
+ * @type {boolean}
+ */
+
+
+ /**
+ * Waits on the previously requested operation and calls the doneCallback if the operation is fulfilled
+ * @param {util.Lockable~callback=} doneCallback The callback which will be invoked when the previously
+ * operations on this object is completed.
+ * @param {util.Lockable~callback=} failCallback When the lock can't be released caused by a none
+ * recoverable error
+ * @return {Promise} A promise which completes successfully, when the previously requested
+ * operation completes
+ */
+ Lockable.prototype.ready = function ready(doneCallback, failCallback) {
+ return this._readyPromise.then(doneCallback, failCallback);
+ };
+
+ /**
+ * Try to aquire an exclusive lock and executes the given callback.
+ * @param {util.Lockable~callback} callback The exclusive operation to execute
+ * @param {boolean} [critical=false] Indicates if the operation is critical. If the operation is critical and the
+ * operation fails, then the lock will not be released
+ * @return {Promise} A promise
+ * @throws {Error} If the lock can't be aquired
+ * @protected
+ */
+
+
+ Lockable.prototype.withLock = function withLock(callback, critical) {
+ if (this._isLocked) throw new Error('Current operation has not been finished.');
+
+ var self = this;
+ try {
+ this._isLocked = true;
+ var result = callback().then(function (result) {
+ self._isLocked = false;
+ return result;
+ }, function (e) {
+ if (!critical) self._isLocked = false;
+ throw e;
+ });
+
+ this._readyPromise = result.then(function () {
+ return self;
+ }, function (e) {
+ if (!critical) return self;
+ throw e;
+ });
+
+ return result;
+ } catch (e) {
+ if (critical) {
+ this._readyPromise = Promise.reject(e);
+ } else {
+ this._isLocked = false;
+ }
+ throw e;
+ }
+ };
+
+ babelHelpers.createClass(Lockable, [{
+ key: "isReady",
+ get: function get() {
+ return !this._isLocked;
+ }
+ }]);
+ return Lockable;
+}();
+
+module.exports = Lockable;
+
+/**
+ * The operation callback is used by the {@link util.Lockable#withLock} method,
+ * to perform an exclusive operation on the
+ * @callback util.Lockable~callback
+ * @return {Promise<*>} A Promise, which reflects the result of the operation
+ */
+
+},{}],62:[function(_dereq_,module,exports){
+"use strict";
+
+var message = _dereq_(36);
+var StatusCode = _dereq_(25).StatusCode;
+
+/**
+ * @alias util.Logger
+ */
+
+var Logger = function () {
+ function Logger() {
+ babelHelpers.classCallCheck(this, Logger);
+ }
+
+ Logger.create = function create(entityManager) {
+ var proto = this.prototype;
+
+ function Logger() {
+ proto.log.apply(Logger, arguments);
+ }
+
+ for (var _iterator = Object.getOwnPropertyNames(proto), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var key = _ref;
+
+ Object.defineProperty(Logger, key, Object.getOwnPropertyDescriptor(proto, key));
+ }Logger._init(entityManager);
+
+ return Logger;
+ };
+
+ /**
+ * The log level which will be logged
+ *
+ * The log level can be one of 'trace', 'debug', 'info', 'warn', 'error'
+ * @type string
+ */
+
+
+ /**
+ * Logs a message in the default level 'info'
+ * @param {string} message The message to log, the message string can be interpolated like the node util.format method
+ * @param {...*} args The arguments used to interpolated the message string. The last param can be object which will
+ * be included in the log entry
+ *
+ * @name log
+ * @memberOf util.Logger.prototype
+ * @function
+ * @see https://nodejs.org/api/util.html#util_util_format_format
+ */
+
+ /**
+ * Logs a message in the default level 'info'
+ * @param {string} message The message to log, the message string can be interpolated like the node util.format method
+ * @param {Object} [data=null] An optional object which will be included in the log entry
+ *
+ * @name log
+ * @memberOf util.Logger.prototype
+ * @function
+ * @see https://nodejs.org/api/util.html#util_util_format_format
+ */
+
+ /**
+ * Logs a message with the given log level
+ * @param {string} level The level used to log the message
+ * @param {string} message The message to log, the message string can be interpolated like the node util.format method
+ * @param {...*} args The arguments used to interpolated the message string. The last param can be object which will
+ * be included in the log entry
+ * @name log
+ * @memberOf util.Logger.prototype
+ * @function
+ *
+ * @see https://nodejs.org/api/util.html#util_util_format_format
+ */
+
+ /**
+ * Logs a message with the given log level
+ * @param {string} level The level used to log the message
+ * @param {string} message The message to log, the message string can be interpolated like the node util.format method
+ * @param {Object} [data=null] An optional object which will be included in the log entry
+ *
+ * @see https://nodejs.org/api/util.html#util_util_format_format
+ */
+ Logger.prototype.log = function log(level, message, data) {
+ var args = Array.prototype.slice.call(arguments);
+
+ if (Logger.LEVELS.indexOf(args[0]) == -1) {
+ level = 'info';
+ } else {
+ level = args.shift();
+ }
+
+ if (this.levelIndex > Logger.LEVELS.indexOf(level)) return;
+
+ message = typeof args[0] === 'string' ? this._format(args.shift(), args) : '[no message]';
+ data = null;
+ if (args.length && babelHelpers.typeof(args[args.length - 1]) === 'object') {
+ data = args.pop();
+ if (Array.isArray(data)) data = { data: data };
+ }
+
+ if (args.length) {
+ message += ", " + args.join(", ");
+ }
+
+ return this._log({
+ date: new Date(),
+ message: message,
+ level: level,
+ user: this.entityManager.me && this.entityManager.me.id,
+ data: data
+ });
+ };
+
+ Logger.prototype._format = function _format(f, args) {
+ if (args.length == 0) return f;
+
+ var str = String(f).replace(Logger.FORMAT_REGEXP, function (x) {
+ if (x === '%%') return '%';
+ if (!args.length) return x;
+ switch (x) {
+ case '%s':
+ return String(args.shift());
+ case '%d':
+ return Number(args.shift());
+ case '%j':
+ try {
+ return JSON.stringify(args.shift());
+ } catch (_) {
+ return '[Circular]';
+ }
+ default:
+ return x;
+ }
+ });
+
+ return str;
+ };
+
+ Logger.prototype._init = function _init(entityManager) {
+ var _this = this;
+
+ /** @type EntityManager */
+ this.entityManager = entityManager;
+ this.levelIndex = 2;
+
+ Logger.LEVELS.forEach(function (level) {
+ _this[level] = _this.log.bind(_this, level);
+ });
+ };
+
+ Logger.prototype._log = function _log(json) {
+ if (!this.entityManager.isReady) {
+ return this.entityManager.ready(this._log.bind(this, json));
+ } else {
+ return this.entityManager.send(new message.CreateObject('logs.AppLog', json));
+ }
+ };
+
+ /**
+ * Log message at trace level
+ * @param {string} message The message to log, the message string can be interpolated like the node util.format method
+ * @param {...*} args The arguments used to interpolated the message string. The last param can be object which will
+ * be included in the log entry
+ * @function trace
+ * @memberOf util.Logger.prototype
+ *
+ * @see https://nodejs.org/api/util.html#util_util_format_format
+ */
+
+ /**
+ * Log message at trace level
+ * @param {string} message The message to log, the message string can be interpolated like the node util.format method
+ * @param {Object} [data=null] An optional object which will be included in the log entry
+ * @function trace
+ * @memberOf util.Logger.prototype
+ *
+ * @see https://nodejs.org/api/util.html#util_util_format_format
+ */
+
+ /**
+ * Log message at debug level
+ * @param {string} message The message to log, the message string can be interpolated like the node util.format method
+ * @param {...*} args The arguments used to interpolated the message string. The last param can be object which will
+ * be included in the log entry
+ * @function debug
+ * @memberOf util.Logger.prototype
+ *
+ * @see https://nodejs.org/api/util.html#util_util_format_format
+ */
+
+ /**
+ * Log message at debug level
+ * @param {string} message The message to log, the message string can be interpolated like the node util.format method
+ * @param {Object} [data=null] An optional object which will be included in the log entry
+ * @function debug
+ * @memberOf util.Logger.prototype
+ *
+ * @see https://nodejs.org/api/util.html#util_util_format_format
+ */
+
+ /**
+ * Log message at info level
+ * @param {string} message The message to log, the message string can be interpolated like the node util.format method
+ * @param {...*} args The arguments used to interpolated the message string. The last param can be object which will
+ * be included in the log entry
+ * @function info
+ * @memberOf util.Logger.prototype
+ *
+ * @see https://nodejs.org/api/util.html#util_util_format_format
+ */
+
+ /**
+ * Log message at info level
+ * @param {string} message The message to log, the message string can be interpolated like the node util.format method
+ * @param {Object} [data=null] An optional object which will be included in the log entry
+ * @function info
+ * @memberOf util.Logger.prototype
+ *
+ * @see https://nodejs.org/api/util.html#util_util_format_format
+ */
+
+ /**
+ * Log message at warn level
+ * @param {string} message The message to log, the message string can be interpolated like the node util.format method
+ * @param {...*} args The arguments used to interpolated the message string. The last param can be object which will
+ * be included in the log entry
+ * @function warn
+ * @memberOf util.Logger.prototype
+ *
+ * @see https://nodejs.org/api/util.html#util_util_format_format
+ */
+
+ /**
+ * Log message at warn level
+ * @param {string} message The message to log, the message string can be interpolated like the node util.format method
+ * @param {Object} [data=null] An optional object which will be included in the log entry
+ * @function warn
+ * @memberOf util.Logger.prototype
+ *
+ * @see https://nodejs.org/api/util.html#util_util_format_format
+ */
+
+ /**
+ * Log message at error level
+ * @param {string} message The message to log, the message string can be interpolated like the node util.format method
+ * @param {...*} args The arguments used to interpolated the message string. The last param can be object which will
+ * be included in the log entry
+ * @function error
+ * @memberOf util.Logger.prototype
+ *
+ * @see https://nodejs.org/api/util.html#util_util_format_format
+ */
+
+ /**
+ * Log message at error level
+ * @param {string} message The message to log, the message string can be interpolated like the node util.format method
+ * @param {Object} [data=null] An optional object which will be included in the log entry
+ * @function error
+ * @memberOf util.Logger.prototype
+ *
+ * @see https://nodejs.org/api/util.html#util_util_format_format
+ */
+
+
+ babelHelpers.createClass(Logger, [{
+ key: 'level',
+ get: function get() {
+ return Logger.LEVELS[this.levelIndex];
+ }
+
+ /**
+ * Sets the log level which will be logged
+ * @param {string} value
+ */
+ ,
+ set: function set(value) {
+ var index = Logger.LEVELS.indexOf(value);
+ if (index == -1) throw new Error("Unknown logging level " + value);
+
+ this.levelIndex = index;
+ }
+ }]);
+ return Logger;
+}();
+
+Object.assign(Logger, {
+ LEVELS: ['trace', 'debug', 'info', 'warn', 'error'],
+ FORMAT_REGEXP: /%[sdj%]/g
+});
+
+module.exports = Logger;
+
+},{"25":25,"36":36}],63:[function(_dereq_,module,exports){
+"use strict";
+
+var error = _dereq_(34);
+var Acl = _dereq_(1);
+var Lockable = _dereq_(61);
+var binding = _dereq_(20);
+
+/**
+ * @alias util.Metadata
+ * @extends util.Lockable
+ */
+
+var Metadata = function (_Lockable) {
+ babelHelpers.inherits(Metadata, _Lockable);
+
+ Metadata.create = function create(type, object) {
+ var metadata;
+ if (type.isEntity) {
+ metadata = new Metadata(object, type);
+ } else if (type.isEmbeddable) {
+ metadata = {
+ type: type,
+ readAccess: function readAccess() {
+ var metadata = this._root && this._root._metadata;
+ if (metadata) metadata.readAccess();
+ },
+ writeAccess: function writeAccess() {
+ var metadata = this._root && this._root._metadata;
+ if (metadata) metadata.writeAccess();
+ }
+ };
+ } else {
+ throw new Error('Illegal type ' + type);
+ }
+
+ return metadata;
+ };
+
+ /**
+ * Returns the metadata of the managed object
+ * @param {binding.Managed} managed
+ * @return {util.Metadata}
+ */
+
+
+ Metadata.get = function get(managed) {
+ return managed._metadata;
+ };
+
+ /**
+ * @type EntityManager
+ */
+
+
+ babelHelpers.createClass(Metadata, [{
+ key: 'db',
+ get: function get() {
+ if (this._db) return this._db;
+
+ return this._db = _dereq_(6);
+ }
+
+ /**
+ * @param db {EntityManager}
+ */
+ ,
+ set: function set(db) {
+ if (!this._db) {
+ this._db = db;
+ } else {
+ throw new Error("DB has already been set.");
+ }
+ }
+
+ /**
+ * @type string
+ */
+
+ }, {
+ key: 'bucket',
+ get: function get() {
+ return this.type.name;
+ }
+
+ /**
+ * @type string
+ */
+
+ }, {
+ key: 'key',
+ get: function get() {
+ if (!this._key && this.id) {
+ var index = this.id.lastIndexOf('/');
+ this._key = decodeURIComponent(this.id.substring(index + 1));
+ }
+ return this._key;
+ }
+
+ /**
+ * @param {string} value
+ */
+ ,
+ set: function set(value) {
+ value += '';
+
+ if (this.id) throw new Error('The id can\'t be set twice.');
+
+ this.id = '/db/' + this.bucket + '/' + encodeURIComponent(value);
+ this._key = value;
+ }
+
+ /**
+ * Indicates if this object already belongs to an db
+ * true if this object belongs already to an db otherwise false
+ * @type boolean
+ */
+
+ }, {
+ key: 'isAttached',
+ get: function get() {
+ return !!this._db;
+ }
+
+ /**
+ * Indicates if this object is represents a db object, but was not loaded up to now
+ * @type boolean
+ */
+
+ }, {
+ key: 'isAvailable',
+ get: function get() {
+ return this._state > Metadata.Type.UNAVAILABLE;
+ }
+
+ /**
+ * Indicates if this object represents the state of the db and was not modified in any manner
+ * @type boolean
+ */
+
+ }, {
+ key: 'isPersistent',
+ get: function get() {
+ return this._state == Metadata.Type.PERSISTENT;
+ }
+
+ /**
+ * Indicates that this object was modified and the object was not written back to the db
+ * @type boolean
+ */
+
+ }, {
+ key: 'isDirty',
+ get: function get() {
+ return this._state == Metadata.Type.DIRTY;
+ }
+
+ /**
+ * @param {binding.Entity} entity
+ * @param {metamodel.ManagedType} type
+ */
+
+ }]);
+
+ function Metadata(entity, type) {
+ babelHelpers.classCallCheck(this, Metadata);
+
+ /**
+ * @type binding.Entity
+ * @private
+ */
+ var _this = babelHelpers.possibleConstructorReturn(this, _Lockable.call(this));
+
+ _this._root = entity;
+ _this._state = Metadata.Type.DIRTY;
+ _this._enabled = true;
+ /** @type string */
+ _this.id = null;
+ /** @type number */
+ _this.version = null;
+ /** @type metamodel.ManagedType */
+ _this.type = type;
+ /** @type Acl */
+ _this.acl = new Acl(_this);
+ return _this;
+ }
+
+ /**
+ * Signals that the object will be access by a read access
+ * Ensures that the object was loaded already
+ */
+
+
+ Metadata.prototype.readAccess = function readAccess() {
+ if (this._enabled) {
+ if (!this.isAvailable) {
+ throw new error.PersistentError('This object ' + this.id + ' is not available.');
+ }
+ }
+ };
+
+ /**
+ * Signals that the object will be access by a write access
+ * Ensures that the object was loaded already and marks the object as dirty
+ */
+
+
+ Metadata.prototype.writeAccess = function writeAccess() {
+ if (this._enabled) {
+ if (!this.isAvailable) {
+ throw new error.PersistentError('This object ' + this.id + ' is not available.');
+ }
+
+ this.setDirty();
+ }
+ };
+
+ /**
+ * Indicates that the associated object isn't available
+ */
+
+
+ Metadata.prototype.setUnavailable = function setUnavailable() {
+ this._state = Metadata.Type.UNAVAILABLE;
+ };
+
+ /**
+ * Indicates that the associated object isn't stale, i.e.
+ * the object correlate the database state and is not modified by the user
+ */
+
+
+ Metadata.prototype.setPersistent = function setPersistent() {
+ this._state = Metadata.Type.PERSISTENT;
+ };
+
+ /**
+ * Indicates the the object is modified by the user
+ */
+
+
+ Metadata.prototype.setDirty = function setDirty() {
+ this._state = Metadata.Type.DIRTY;
+ };
+
+ /**
+ * Indicates the the object is removed
+ */
+
+
+ Metadata.prototype.setRemoved = function setRemoved() {
+ //mark the object only as dirty if it was already available
+ if (this.isAvailable) {
+ this.setDirty();
+ this.version = null;
+ }
+ };
+
+ Metadata.prototype.getJsonMetadata = function getJsonMetadata() {
+ var info = {};
+
+ if (this.id) {
+ info.id = this.id;
+ }
+
+ if (this.version) {
+ info.version = this.version;
+ }
+
+ info.acl = this.acl;
+
+ return info;
+ };
+
+ /**
+ * Sets the object metadata from the object
+ * @param {Object} json
+ */
+
+
+ Metadata.prototype.setJsonMetadata = function setJsonMetadata(json) {
+ if (!this.id) {
+ this.id = json.id;
+ }
+
+ if (json.version) this.version = json.version;
+
+ this.acl.fromJSON(json.acl || {});
+ };
+
+ /**
+ * Converts the object to an JSON-Object
+ * @param {boolean} [excludeMetadata=false]
+ * @returns {json} JSON-Object
+ */
+
+
+ Metadata.prototype.getJson = function getJson(excludeMetadata) {
+ this._enabled = false;
+ var json = this.type.toJsonValue(this, this._root, true);
+ this._enabled = true;
+
+ if (this.isAttached && !excludeMetadata) {
+ Object.assign(json, this.getJsonMetadata());
+ }
+
+ return json;
+ };
+
+ Metadata.prototype.setJson = function setJson(json) {
+ if (json.id || json.version || json.acl) {
+ this.setJsonMetadata(json);
+ }
+
+ this._enabled = false;
+ this.type.fromJsonValue(this, json, this._root, true);
+ this._enabled = true;
+ };
+
+ return Metadata;
+}(Lockable);
+
+/**
+ * @enum {number}
+ */
+
+
+Metadata.Type = {
+ UNAVAILABLE: -1,
+ PERSISTENT: 0,
+ DIRTY: 1
+};
+
+module.exports = Metadata;
+
+},{"1":1,"20":20,"34":34,"6":6,"61":61}],64:[function(_dereq_,module,exports){
+"use strict";
+
+var message = _dereq_(36);
+
+/**
+ * @alias util.Modules
+ */
+
+var Modules = function () {
+
+ /**
+ * @param {EntityManager} entityManager
+ * @param {connector.Connector} connector
+ */
+ function Modules(entityManager, connector) {
+ babelHelpers.classCallCheck(this, Modules);
+
+ /**
+ * @type EntityManager
+ */
+ this._entityManager = entityManager;
+ /**
+ * The connector used for requests
+ * @type connector.Connector
+ */
+ this._connector = connector;
+ }
+
+ /**
+ * Calls the module, which is identified by the given bucket.
+ * The optional query parameter will be attached as GET-parameters.
+ *
+ * @param {string} bucket Name of the module
+ * @param {Object|string=} query GET-Parameter as key-value-pairs or query string
+ * @param {Object=} options Additional request options
+ * @param {string=} options.responseType The type used to provide the response data, defaults to text oder json depends
+ * on the received data, can be one of arraybuffer, blob, json, text, base64, data-url
+ * @param {Function=} doneCallback
+ * @param {Function=} failCallback
+ * @returns {Promise}
+ */
+
+
+ Modules.prototype.get = function get(bucket, query, options, doneCallback, failCallback) {
+ if (query instanceof Function) {
+ failCallback = options;
+ doneCallback = query;
+ options = {};
+ query = null;
+ }
+
+ if (options instanceof Function) {
+ failCallback = doneCallback;
+ doneCallback = options;
+ options = {};
+ }
+
+ options = options || {};
+
+ var msg = new message.GetBaqendModule(bucket).addQueryString(query).responseType(options.responseType || null);
+
+ return this._send(msg, doneCallback, failCallback);
+ };
+
+ /**
+ * Calls the module, which is identified by the given bucket.
+ *
+ * @param {string} bucket Name of the module
+ * @param body {string|Blob|File|ArrayBuffer|FormData|json=} The POST-body data to send
+ * @param {Object=} options Additional request options
+ * @param {string=} options.requestType A optional type hint used to correctly interpret the provided data, can be one of
+ * arraybuffer, blob, json, text, base64, data-url, form
+ * @param {string=} options.mimeType The mimType of the body. Defaults to the mimeType of the provided data if
+ * it is a file object, blob or data-url
+ * @param {string=} options.responseType The type used to provide the response data, defaults to text oder json depends
+ * on the received data, can be one of arraybuffer, blob, json, text, base64, data-url
+ * @param {Function=} doneCallback
+ * @param {Function=} failCallback
+ * @returns {Promise}
+ */
+
+
+ Modules.prototype.post = function post(bucket, body, options, doneCallback, failCallback) {
+ if (options instanceof Function) {
+ failCallback = doneCallback;
+ doneCallback = options;
+ options = {};
+ }
+
+ options = options || {};
+
+ var msg = new message.PostBaqendModule(bucket).entity(body, options.requestType).mimeType(options.mimeType || null).responseType(options.responseType || null);
+
+ return this._send(msg, doneCallback, failCallback);
+ };
+
+ Modules.prototype._send = function _send(msg, doneCallback, failCallback) {
+ return this._entityManager.send(msg).then(function (response) {
+ return response.entity;
+ }).then(doneCallback, failCallback);
+ };
+
+ return Modules;
+}();
+
+module.exports = Modules;
+
+},{"36":36}],65:[function(_dereq_,module,exports){
+"use strict";
+
+/**
+ * @alias util.Permission
+ */
+
+var Permission = function () {
+
+ /**
+ * Creates a new Permission object, with an empty rule set
+ * @param {util.Metadata} metadata The metadata of the object
+ */
+ function Permission(metadata) {
+ babelHelpers.classCallCheck(this, Permission);
+
+ /** @type {Object.} */
+ this._rules = {};
+ /** @type util.Metadata */
+ this._metadata = metadata;
+ }
+
+ /**
+ * Returns a list of user and role references of all rules
+ * @return {Array} a list of references
+ */
+
+
+ Permission.prototype.allRules = function allRules() {
+ return Object.keys(this._rules);
+ };
+
+ /**
+ * Removes all rules from this permission object
+ */
+
+
+ Permission.prototype.clear = function clear() {
+ this._metadata && this._metadata.writeAccess();
+ this._rules = {};
+ };
+
+ /**
+ * Copies permissions from another permission object
+ * @param {util.Permission} permission The permission to copy from
+ * @return {util.Permission}
+ */
+
+
+ Permission.prototype.copy = function copy(permission) {
+ this._metadata && this._metadata.writeAccess();
+ this._rules = Object.assign({}, permission._rules);
+ return this;
+ };
+
+ /**
+ * Gets whenever all users and roles have the permission to perform the operation
+ * @return {boolean} true If public access is allowed
+ */
+
+
+ Permission.prototype.isPublicAllowed = function isPublicAllowed() {
+ if ('*' in this._rules) return false;
+
+ for (var ref in this._rules) {
+ if (this._rules[ref] == 'allow') {
+ return false;
+ }
+ }
+
+ return true;
+ };
+
+ /**
+ * Sets whenever all users and roles should have the permission to perform the operation.
+ * Note: All other allow rules will be removed.
+ */
+
+
+ Permission.prototype.setPublicAllowed = function setPublicAllowed() {
+ this._metadata && this._metadata.writeAccess();
+ for (var ref in this._rules) {
+ if (this._rules[ref] == 'allow') {
+ delete this._rules[ref];
+ }
+ }
+ };
+
+ /**
+ * Returns the actual rule of the given user or role.
+ * @param {model.User|model.Role|string} userOrRole The user or role to check for
+ * @return {string} The actual access rule or undefined if no rule was found
+ */
+
+
+ Permission.prototype.getRule = function getRule(userOrRole) {
+ return this._rules[this._getRef(userOrRole)];
+ };
+
+ /**
+ * Checks whenever the user or role is explicit allowed to perform the operation.
+ *
+ * @param {model.User|model.Role|string} userOrRole The user or role to check for
+ */
+
+
+ Permission.prototype.isAllowed = function isAllowed(userOrRole) {
+ return this._rules[this._getRef(userOrRole)] == 'allow';
+ };
+
+ /**
+ * Checks whenever the user or role is explicit denied to perform the operation.
+ *
+ * @param {model.User|model.Role|string} userOrRole The user or role to check for
+ */
+
+
+ Permission.prototype.isDenied = function isDenied(userOrRole) {
+ return this._rules[this._getRef(userOrRole)] == 'deny';
+ };
+
+ /**
+ * Allows the given users or rules to perform the operation
+ * @param {...(model.User|model.Role|string)} userOrRole The users or roles to allow
+ * @return {util.Permission} this permission object
+ */
+
+
+ Permission.prototype.allowAccess = function allowAccess(userOrRole) {
+ var rules = arguments;
+ this._metadata && this._metadata.writeAccess();
+ for (var i = 0; i < rules.length; i++) {
+ this._rules[this._getRef(rules[i])] = 'allow';
+ }
+ return this;
+ };
+
+ /**
+ * Denies the given users or rules to perform the operation
+ * @param {...(model.User|model.Role|string)} userOrRole The users or roles to deny
+ * @return {util.Permission} this permission object
+ */
+
+
+ Permission.prototype.denyAccess = function denyAccess(userOrRole) {
+ var rules = arguments;
+ this._metadata && this._metadata.writeAccess();
+ for (var i = 0; i < rules.length; i++) {
+ this._rules[this._getRef(rules[i])] = 'deny';
+ }
+ return this;
+ };
+
+ /**
+ * Deletes any allow/deny rules for the given users or roles
+ * @param {...(model.User|model.Role|string)} userOrRole The users or roles to delete rules for
+ * @return {util.Permission} this permission object
+ */
+
+
+ Permission.prototype.deleteAccess = function deleteAccess(userOrRole) {
+ var rules = arguments;
+ this._metadata && this._metadata.writeAccess();
+ for (var i = 0; i < rules.length; i++) {
+ delete this._rules[this._getRef(rules[i])];
+ }
+ return this;
+ };
+
+ /**
+ * A Json representation of the set of rules
+ * @return {json}
+ */
+
+
+ Permission.prototype.toJSON = function toJSON() {
+ return this._rules;
+ };
+
+ /**
+ * Sets the permission rules from json
+ * @param {json} json The permission json representation
+ */
+
+
+ Permission.prototype.fromJSON = function fromJSON(json) {
+ this._rules = json;
+ };
+
+ /**
+ * Creates a permission from the given rules.
+ * @param {json} json The rules.
+ * @return {util.Permission} The permission.
+ */
+
+
+ Permission.fromJSON = function fromJSON(json) {
+ var permission = new this();
+ permission.fromJSON(json);
+ return permission;
+ };
+
+ /**
+ * Resolves user and role references and validate given references
+ * @param {model.User|model.Role|string} userOrRole The user, role or reference
+ * @return {string} The resolved and validated reference
+ * @private
+ */
+
+
+ Permission.prototype._getRef = function _getRef(userOrRole) {
+ if (typeof userOrRole !== 'string') {
+ userOrRole = userOrRole._metadata.id;
+ }
+
+ if (userOrRole.indexOf('/db/User/') == 0 || userOrRole.indexOf('/db/Role/') == 0) {
+ return userOrRole;
+ }
+
+ throw new TypeError('The given object isn\'t a user, role or a valid reference.');
+ };
+
+ return Permission;
+}();
+
+Permission.BASE_PERMISSIONS = ['load', 'update', 'delete', 'query', 'insert'];
+module.exports = Permission;
+
+},{}],66:[function(_dereq_,module,exports){
+"use strict";
+
+var Entity = _dereq_(10);
+
+/**
+ * @alias util.PushMessage
+ */
+
+var PushMessage = function () {
+
+ /**
+ * Push message will be used to send a push notification to a set of devices
+ *
+ * @param {Set|Array} [devices] The Set of device references which
+ * will receive this push notification.
+ * @param {string=} message The message of the push notification.
+ * @param {string=} subject The subject of the push notification.
+ * @param {string=} sound The file reference of the sound file as a string. The device uses this file as the
+ * notification sound.
+ * @param {number=} badge The badge count.
+ * @param {Object=} data The data object which can contain additional information.
+ */
+ function PushMessage(devices, message, subject, sound, badge, data) {
+ babelHelpers.classCallCheck(this, PushMessage);
+
+ /**
+ * Set of devices
+ * @type Set
+ */
+ this.devices = null;
+
+ if (devices instanceof Set) {
+ this.devices = devices;
+ } else if (!devices || devices[Symbol.iterator]) {
+ this.devices = new Set(devices);
+ } else if (devices instanceof Entity) {
+ this.devices = new Set();
+ this.devices.add(devices);
+ } else {
+ throw new Error("Only Sets, Lists and Arrays can be used as devices.");
+ }
+
+ /**
+ * push notification message
+ * @type string
+ */
+ this.message = message;
+
+ /**
+ * push notification subject
+ * @type string
+ */
+ this.subject = subject;
+
+ /**
+ * push notification sound
+ * @type string
+ */
+ this.sound = sound;
+
+ /**
+ * badge count
+ * @type number
+ */
+ this.badge = badge;
+
+ /**
+ * data object
+ * @type json
+ */
+ this.data = data;
+ }
+
+ /**
+ * Adds a new object to the set of devices
+ *
+ * @param {binding.Entity} device will be added to the device set to receive the push notification
+ */
+
+
+ PushMessage.prototype.addDevice = function addDevice(device) {
+ if (!this.devices) {
+ this.devices = new Set();
+ }
+
+ this.devices.add(device);
+ };
+
+ PushMessage.prototype.toJSON = function toJSON() {
+ if (!this.devices || !this.devices.size) throw new Error("Set of devices is empty.");
+
+ return Object.assign({}, this, {
+ devices: Array.from(this.devices, function (device) {
+ return device.id;
+ })
+ });
+ };
+
+ return PushMessage;
+}();
+
+module.exports = PushMessage;
+
+},{"10":10}],67:[function(_dereq_,module,exports){
+"use strict";
+
+var hmac = _dereq_(71).hmac;
+
+/**
+ * @interface util.TokenStorageFactory
+ */
+
+/**
+ * Creates a new tokenStorage which persist tokens for the given origin
+ * @param {string} origin The origin where the token contains to
+ * @return {Promise} The initialized token storage
+ * @name create
+ * @memberOf util.TokenStorageFactory.prototype
+ * @method
+ */
+
+/**
+ * @alias util.TokenStorage
+ */
+
+var TokenStorage = function () {
+ TokenStorage.create = function create(origin) {
+ return Promise.resolve(new TokenStorage(origin));
+ };
+
+ /**
+ * @param {string} origin The origin where the token belongs to
+ * @param {string} token The initial token
+ * @param {boolean=} temporary If the token should be saved temporary or permanently
+ */
+
+
+ babelHelpers.createClass(TokenStorage, [{
+ key: 'token',
+
+ /**
+ * Get the stored token
+ * @returns {string} The token or undefined, if no token is available
+ */
+ get: function get() {
+ return this._token;
+ }
+ }]);
+
+ function TokenStorage(origin, token, temporary) {
+ babelHelpers.classCallCheck(this, TokenStorage);
+
+ /**
+ * The actual stored token
+ */
+ this._token = token || null;
+ this._origin = origin;
+ /**
+ * Indicates if the token should keep temporary only or should be persisted for later sessions
+ * @type boolean
+ */
+ this.temporary = temporary;
+ }
+
+ /**
+ * Use the underlying storage implementation to save the token
+ * @param {string} origin The origin where the token belongs to
+ * @param {string} token The initial token
+ * @param {boolean} temporary If the token should be saved temporary or permanently
+ * @protected
+ * @abstract
+ */
+
+
+ TokenStorage.prototype._saveToken = function _saveToken(origin, token, temporary) {};
+
+ /**
+ * Update the token for the givin origin, the operation may be asynchronous
+ * @param {String} token The token to store or null to remove the token
+ */
+
+
+ TokenStorage.prototype.update = function update(token) {
+ this._token = token;
+ this._saveToken(this._origin, this._token, this.temporary);
+ };
+
+ /**
+ * Derived a resource token from the the stored origin token for the resource and signs the resource with the
+ * generated resource token
+ * @param {string} resource The resource which will be accessible with the returned token
+ * @returns {string} A resource token which can only be used to access the specified resource
+ */
+
+
+ TokenStorage.prototype.signPath = function signPath(resource) {
+ var token = this.token;
+ if (token) {
+ var data = token.substring(0, token.length - 40);
+ var sig = token.substring(data.length);
+
+ var path = resource.split('/').map(encodeURIComponent).join('/');
+ return path + '?BAT=' + (data + hmac(resource + data, sig));
+ }
+ return resource;
+ };
+
+ return TokenStorage;
+}();
+
+var tokens = {};
+/**
+ * @ignore
+ */
+
+var GlobalStorage = function (_TokenStorage) {
+ babelHelpers.inherits(GlobalStorage, _TokenStorage);
+
+ function GlobalStorage() {
+ babelHelpers.classCallCheck(this, GlobalStorage);
+ return babelHelpers.possibleConstructorReturn(this, _TokenStorage.apply(this, arguments));
+ }
+
+ GlobalStorage.create = function create(origin) {
+ return Promise.resolve(new GlobalStorage(origin, tokens[origin]));
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ GlobalStorage.prototype._saveToken = function _saveToken(origin, token, temporary) {
+ if (!temporary) {
+ if (token) {
+ tokens[origin] = token;
+ } else {
+ delete tokens[origin];
+ }
+ }
+ };
+
+ return GlobalStorage;
+}(TokenStorage);
+
+/**
+ * @alias util.TokenStorage.GLOBAL
+ * @type {util.TokenStorageFactory}
+ */
+
+
+TokenStorage.GLOBAL = GlobalStorage;
+
+/**
+ * @ignore
+ */
+
+var WebStorage = function (_TokenStorage2) {
+ babelHelpers.inherits(WebStorage, _TokenStorage2);
+
+ function WebStorage() {
+ babelHelpers.classCallCheck(this, WebStorage);
+ return babelHelpers.possibleConstructorReturn(this, _TokenStorage2.apply(this, arguments));
+ }
+
+ WebStorage.isAvailable = function isAvailable() {
+ try {
+ //firefox throws an exception if cookies are disabled
+ if (typeof localStorage === 'undefined') {
+ return false;
+ }
+
+ localStorage.setItem('bq_webstorage_test', 'bq');
+ localStorage.removeItem('bq_webstorage_test');
+ return true;
+ } catch (e) {}
+ return false;
+ };
+
+ WebStorage.create = function create(origin) {
+ var temporary = false;
+ var token = localStorage.getItem('BAT:' + origin);
+ if (!token) {
+ token = sessionStorage.getItem('BAT:' + origin);
+ temporary = !!token;
+ }
+
+ return Promise.resolve(new WebStorage(origin, token, temporary));
+ };
+
+ /**
+ * @inheritDoc
+ */
+
+
+ WebStorage.prototype._saveToken = function _saveToken(origin, token, temporary) {
+ var webStorage = temporary ? sessionStorage : localStorage;
+ if (token) {
+ webStorage.setItem('BAT:' + origin, token);
+ } else {
+ webStorage.removeItem('BAT:' + origin);
+ }
+ };
+
+ return WebStorage;
+}(TokenStorage);
+
+if (WebStorage.isAvailable()) {
+ /**
+ * @alias util.TokenStorage.WEB_STORAGE
+ * @type {util.TokenStorageFactory}
+ */
+ TokenStorage.WEB_STORAGE = WebStorage;
+}
+
+module.exports = TokenStorage;
+
+},{"71":71}],68:[function(_dereq_,module,exports){
+"use strict";
+
+/**
+ * @alias util.ValidationResult
+ */
+
+var ValidationResult = function () {
+ babelHelpers.createClass(ValidationResult, [{
+ key: "isValid",
+ get: function get() {
+ for (var key in this.fields) {
+ if (!this.fields[key].isValid) {
+ return false;
+ }
+ }
+ return true;
+ }
+ }]);
+
+ function ValidationResult() {
+ babelHelpers.classCallCheck(this, ValidationResult);
+
+ this.fields = {};
+ }
+
+ ValidationResult.prototype.toJSON = function toJSON() {
+ var json = {};
+ for (var key in this.fields) {
+ json[key] = this.fields[key].toJSON();
+ }
+ return json;
+ };
+
+ return ValidationResult;
+}();
+
+module.exports = ValidationResult;
+
+},{}],69:[function(_dereq_,module,exports){
+"use strict";
+
+var valLib = _dereq_(162);
+var ValidationResult = _dereq_(68);
+
+/**
+ * @alias util.Validator
+ */
+
+var Validator = function () {
+
+ /**
+ * Compiles the given validation code for the managedType
+ * @param {metamodel.ManagedType} managedType The managedType of the code
+ * @param {string} validationCode The validation code
+ */
+ Validator.compile = function compile(managedType, validationCode) {
+ var keys = [];
+ for (var _iterator = managedType.attributes(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var attr = _ref;
+
+ keys.push(attr.name);
+ }
+
+ var fn = new Function(keys, validationCode);
+ return function onValidate(argObj) {
+ var args = keys.map(function (name) {
+ return argObj[name];
+ });
+
+ return fn.apply({}, args);
+ };
+ };
+
+ /**
+ * Gets the value of the attribute
+ * @return {*} Value
+ */
+
+
+ /**
+ * Executes the given validation function to validate the value.
+ *
+ * The value will be passed as the first parameter to the validation function and
+ * the library {@link https://github.com/chriso/validator.js} as the second one.
+ * If the function returns true the value is valid, otherwise it's invalid.
+ *
+ * @name is
+ * @memberOf util.Validator.prototype
+ * @function
+ * @param {Function} fn will be used to validate the value
+ * @returns {util.Validator}
+ */
+
+ /**
+ * Executes the given validation function to validate the value.
+ *
+ * The value will be passed as the first parameter to the validation function and
+ * the library {@link https://github.com/chriso/validator.js} as the second one.
+ * If the function returns true the value is valid, otherwise it's invalid.
+ *
+ * @param {string} error The error message which will be used if the value is invalid
+ * @param {Function} fn will be used to validate the value
+ * @returns {util.Validator}
+ */
+ Validator.prototype.is = function is(error, fn) {
+ if (error instanceof Function) {
+ fn = error;
+ error = 'is';
+ }
+ if (fn(this.value, valLib) === false) {
+ this.errors.push(error);
+ }
+ return this;
+ };
+
+ babelHelpers.createClass(Validator, [{
+ key: 'value',
+ get: function get() {
+ return this._entity[this.key];
+ }
+
+ /**
+ * Checks if the attribute is valid
+ * @return {boolean}
+ */
+
+ }, {
+ key: 'isValid',
+ get: function get() {
+ return this.errors.length == 0;
+ }
+ }]);
+
+ function Validator(key, entity) {
+ babelHelpers.classCallCheck(this, Validator);
+
+ /**
+ * Name of the attribute
+ * @type string
+ */
+ this.key = key;
+
+ /**
+ * Entity to get the value of the attribute
+ * @type {binding.Entity}
+ * @private
+ */
+ this._entity = entity;
+
+ /**
+ * Entity to get the value of the attribute
+ * @type {binding.Entity}
+ * @private
+ */
+ this.errors = [];
+ }
+
+ Validator.prototype._callMethod = function _callMethod(method, error, args) {
+ args = args || [];
+ args.unshift(this.value);
+ if (valLib[method].apply(this, args) === false) {
+ this.errors.push(error);
+ }
+ return this;
+ };
+
+ Validator.prototype.toString = function toString() {
+ return this.value;
+ };
+
+ Validator.prototype.toJSON = function toJSON() {
+ return {
+ isValid: this.isValid,
+ errors: this.errors
+ };
+ };
+
+ return Validator;
+}();
+
+Object.keys(valLib).forEach(function (name) {
+ if (typeof valLib[name] == 'function' && name !== 'toString' && name !== 'toDate' && name !== 'extend' && name !== 'init') {
+
+ /**
+ * @ignore
+ */
+ Validator.prototype[name] = function (error) {
+ //noinspection JSPotentiallyInvalidUsageOfThis
+ return this._callMethod(name, error || name, Array.prototype.slice.call(arguments, error ? 1 : 0));
+ };
+ }
+});
+
+module.exports = Validator;
+
+},{"162":162,"68":68}],70:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * @namespace util
+ */
+module.exports = exports = _dereq_(71);
+exports.Metadata = _dereq_(63);
+exports.Permission = _dereq_(65);
+exports.Validator = _dereq_(69);
+exports.ValidationResult = _dereq_(68);
+exports.Code = _dereq_(60);
+exports.Modules = _dereq_(64);
+exports.Lockable = _dereq_(61);
+exports.Logger = _dereq_(62);
+exports.PushMessage = _dereq_(66);
+exports.TokenStorage = _dereq_(67);
+
+/**
+ * @function
+ * @name uuid
+ * @memberOf util.prototype
+ * @return {string} A generated version 4 UUID.
+ */
+exports.uuid = _dereq_(160).v4;
+
+},{"160":160,"60":60,"61":61,"62":62,"63":63,"64":64,"65":65,"66":66,"67":67,"68":68,"69":69,"71":71}],71:[function(_dereq_,module,exports){
+'use strict';
+
+exports.hmac = _dereq_(157);
+exports.atob = window.atob;
+exports.isNode = false;
+
+},{"157":157}],72:[function(_dereq_,module,exports){
+module.exports = function(it){
+ if(typeof it != 'function')throw TypeError(it + ' is not a function!');
+ return it;
+};
+},{}],73:[function(_dereq_,module,exports){
+// 22.1.3.31 Array.prototype[@@unscopables]
+var UNSCOPABLES = _dereq_(144)('unscopables')
+ , ArrayProto = Array.prototype;
+if(ArrayProto[UNSCOPABLES] == undefined)_dereq_(94)(ArrayProto, UNSCOPABLES, {});
+module.exports = function(key){
+ ArrayProto[UNSCOPABLES][key] = true;
+};
+},{"144":144,"94":94}],74:[function(_dereq_,module,exports){
+module.exports = function(it, Constructor, name, forbiddenField){
+ if(!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)){
+ throw TypeError(name + ': incorrect invocation!');
+ } return it;
+};
+},{}],75:[function(_dereq_,module,exports){
+var isObject = _dereq_(102);
+module.exports = function(it){
+ if(!isObject(it))throw TypeError(it + ' is not an object!');
+ return it;
+};
+},{"102":102}],76:[function(_dereq_,module,exports){
+// false -> Array#indexOf
+// true -> Array#includes
+var toIObject = _dereq_(137)
+ , toLength = _dereq_(138)
+ , toIndex = _dereq_(135);
+module.exports = function(IS_INCLUDES){
+ return function($this, el, fromIndex){
+ var O = toIObject($this)
+ , length = toLength(O.length)
+ , index = toIndex(fromIndex, length)
+ , value;
+ // Array#includes uses SameValueZero equality algorithm
+ if(IS_INCLUDES && el != el)while(length > index){
+ value = O[index++];
+ if(value != value)return true;
+ // Array#toIndex ignores holes, Array#includes - not
+ } else for(;length > index; index++)if(IS_INCLUDES || index in O){
+ if(O[index] === el)return IS_INCLUDES || index || 0;
+ } return !IS_INCLUDES && -1;
+ };
+};
+},{"135":135,"137":137,"138":138}],77:[function(_dereq_,module,exports){
+// getting tag from 19.1.3.6 Object.prototype.toString()
+var cof = _dereq_(78)
+ , TAG = _dereq_(144)('toStringTag')
+ // ES3 wrong here
+ , ARG = cof(function(){ return arguments; }()) == 'Arguments';
+
+// fallback for IE11 Script Access Denied error
+var tryGet = function(it, key){
+ try {
+ return it[key];
+ } catch(e){ /* empty */ }
+};
+
+module.exports = function(it){
+ var O, T, B;
+ return it === undefined ? 'Undefined' : it === null ? 'Null'
+ // @@toStringTag case
+ : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T
+ // builtinTag case
+ : ARG ? cof(O)
+ // ES3 arguments fallback
+ : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
+};
+},{"144":144,"78":78}],78:[function(_dereq_,module,exports){
+var toString = {}.toString;
+
+module.exports = function(it){
+ return toString.call(it).slice(8, -1);
+};
+},{}],79:[function(_dereq_,module,exports){
+'use strict';
+var dP = _dereq_(115).f
+ , create = _dereq_(114)
+ , redefineAll = _dereq_(126)
+ , ctx = _dereq_(83)
+ , anInstance = _dereq_(74)
+ , defined = _dereq_(84)
+ , forOf = _dereq_(91)
+ , $iterDefine = _dereq_(105)
+ , step = _dereq_(107)
+ , setSpecies = _dereq_(129)
+ , DESCRIPTORS = _dereq_(85)
+ , fastKey = _dereq_(111).fastKey
+ , SIZE = DESCRIPTORS ? '_s' : 'size';
+
+var getEntry = function(that, key){
+ // fast case
+ var index = fastKey(key), entry;
+ if(index !== 'F')return that._i[index];
+ // frozen object case
+ for(entry = that._f; entry; entry = entry.n){
+ if(entry.k == key)return entry;
+ }
+};
+
+module.exports = {
+ getConstructor: function(wrapper, NAME, IS_MAP, ADDER){
+ var C = wrapper(function(that, iterable){
+ anInstance(that, C, NAME, '_i');
+ that._i = create(null); // index
+ that._f = undefined; // first entry
+ that._l = undefined; // last entry
+ that[SIZE] = 0; // size
+ if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that);
+ });
+ redefineAll(C.prototype, {
+ // 23.1.3.1 Map.prototype.clear()
+ // 23.2.3.2 Set.prototype.clear()
+ clear: function clear(){
+ for(var that = this, data = that._i, entry = that._f; entry; entry = entry.n){
+ entry.r = true;
+ if(entry.p)entry.p = entry.p.n = undefined;
+ delete data[entry.i];
+ }
+ that._f = that._l = undefined;
+ that[SIZE] = 0;
+ },
+ // 23.1.3.3 Map.prototype.delete(key)
+ // 23.2.3.4 Set.prototype.delete(value)
+ 'delete': function(key){
+ var that = this
+ , entry = getEntry(that, key);
+ if(entry){
+ var next = entry.n
+ , prev = entry.p;
+ delete that._i[entry.i];
+ entry.r = true;
+ if(prev)prev.n = next;
+ if(next)next.p = prev;
+ if(that._f == entry)that._f = next;
+ if(that._l == entry)that._l = prev;
+ that[SIZE]--;
+ } return !!entry;
+ },
+ // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)
+ // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)
+ forEach: function forEach(callbackfn /*, that = undefined */){
+ anInstance(this, C, 'forEach');
+ var f = ctx(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3)
+ , entry;
+ while(entry = entry ? entry.n : this._f){
+ f(entry.v, entry.k, this);
+ // revert to the last existing entry
+ while(entry && entry.r)entry = entry.p;
+ }
+ },
+ // 23.1.3.7 Map.prototype.has(key)
+ // 23.2.3.7 Set.prototype.has(value)
+ has: function has(key){
+ return !!getEntry(this, key);
+ }
+ });
+ if(DESCRIPTORS)dP(C.prototype, 'size', {
+ get: function(){
+ return defined(this[SIZE]);
+ }
+ });
+ return C;
+ },
+ def: function(that, key, value){
+ var entry = getEntry(that, key)
+ , prev, index;
+ // change existing entry
+ if(entry){
+ entry.v = value;
+ // create new entry
+ } else {
+ that._l = entry = {
+ i: index = fastKey(key, true), // <- index
+ k: key, // <- key
+ v: value, // <- value
+ p: prev = that._l, // <- previous entry
+ n: undefined, // <- next entry
+ r: false // <- removed
+ };
+ if(!that._f)that._f = entry;
+ if(prev)prev.n = entry;
+ that[SIZE]++;
+ // add to index
+ if(index !== 'F')that._i[index] = entry;
+ } return that;
+ },
+ getEntry: getEntry,
+ setStrong: function(C, NAME, IS_MAP){
+ // add .keys, .values, .entries, [@@iterator]
+ // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11
+ $iterDefine(C, NAME, function(iterated, kind){
+ this._t = iterated; // target
+ this._k = kind; // kind
+ this._l = undefined; // previous
+ }, function(){
+ var that = this
+ , kind = that._k
+ , entry = that._l;
+ // revert to the last existing entry
+ while(entry && entry.r)entry = entry.p;
+ // get next entry
+ if(!that._t || !(that._l = entry = entry ? entry.n : that._t._f)){
+ // or finish the iteration
+ that._t = undefined;
+ return step(1);
+ }
+ // return step by kind
+ if(kind == 'keys' )return step(0, entry.k);
+ if(kind == 'values')return step(0, entry.v);
+ return step(0, [entry.k, entry.v]);
+ }, IS_MAP ? 'entries' : 'values' , !IS_MAP, true);
+
+ // add [@@species], 23.1.2.2, 23.2.2.2
+ setSpecies(NAME);
+ }
+};
+},{"105":105,"107":107,"111":111,"114":114,"115":115,"126":126,"129":129,"74":74,"83":83,"84":84,"85":85,"91":91}],80:[function(_dereq_,module,exports){
+'use strict';
+var global = _dereq_(92)
+ , $export = _dereq_(89)
+ , redefine = _dereq_(127)
+ , redefineAll = _dereq_(126)
+ , meta = _dereq_(111)
+ , forOf = _dereq_(91)
+ , anInstance = _dereq_(74)
+ , isObject = _dereq_(102)
+ , fails = _dereq_(90)
+ , $iterDetect = _dereq_(106)
+ , setToStringTag = _dereq_(130)
+ , inheritIfRequired = _dereq_(97);
+
+module.exports = function(NAME, wrapper, methods, common, IS_MAP, IS_WEAK){
+ var Base = global[NAME]
+ , C = Base
+ , ADDER = IS_MAP ? 'set' : 'add'
+ , proto = C && C.prototype
+ , O = {};
+ var fixMethod = function(KEY){
+ var fn = proto[KEY];
+ redefine(proto, KEY,
+ KEY == 'delete' ? function(a){
+ return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
+ } : KEY == 'has' ? function has(a){
+ return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
+ } : KEY == 'get' ? function get(a){
+ return IS_WEAK && !isObject(a) ? undefined : fn.call(this, a === 0 ? 0 : a);
+ } : KEY == 'add' ? function add(a){ fn.call(this, a === 0 ? 0 : a); return this; }
+ : function set(a, b){ fn.call(this, a === 0 ? 0 : a, b); return this; }
+ );
+ };
+ if(typeof C != 'function' || !(IS_WEAK || proto.forEach && !fails(function(){
+ new C().entries().next();
+ }))){
+ // create collection constructor
+ C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
+ redefineAll(C.prototype, methods);
+ meta.NEED = true;
+ } else {
+ var instance = new C
+ // early implementations not supports chaining
+ , HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance
+ // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false
+ , THROWS_ON_PRIMITIVES = fails(function(){ instance.has(1); })
+ // most early implementations doesn't supports iterables, most modern - not close it correctly
+ , ACCEPT_ITERABLES = $iterDetect(function(iter){ new C(iter); }) // eslint-disable-line no-new
+ // for early implementations -0 and +0 not the same
+ , BUGGY_ZERO = !IS_WEAK && fails(function(){
+ // V8 ~ Chromium 42- fails only with 5+ elements
+ var $instance = new C()
+ , index = 5;
+ while(index--)$instance[ADDER](index, index);
+ return !$instance.has(-0);
+ });
+ if(!ACCEPT_ITERABLES){
+ C = wrapper(function(target, iterable){
+ anInstance(target, C, NAME);
+ var that = inheritIfRequired(new Base, target, C);
+ if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that);
+ return that;
+ });
+ C.prototype = proto;
+ proto.constructor = C;
+ }
+ if(THROWS_ON_PRIMITIVES || BUGGY_ZERO){
+ fixMethod('delete');
+ fixMethod('has');
+ IS_MAP && fixMethod('get');
+ }
+ if(BUGGY_ZERO || HASNT_CHAINING)fixMethod(ADDER);
+ // weak collections should not contains .clear method
+ if(IS_WEAK && proto.clear)delete proto.clear;
+ }
+
+ setToStringTag(C, NAME);
+
+ O[NAME] = C;
+ $export($export.G + $export.W + $export.F * (C != Base), O);
+
+ if(!IS_WEAK)common.setStrong(C, NAME, IS_MAP);
+
+ return C;
+};
+},{"102":102,"106":106,"111":111,"126":126,"127":127,"130":130,"74":74,"89":89,"90":90,"91":91,"92":92,"97":97}],81:[function(_dereq_,module,exports){
+var core = module.exports = {version: '2.4.0'};
+if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef
+},{}],82:[function(_dereq_,module,exports){
+'use strict';
+var $defineProperty = _dereq_(115)
+ , createDesc = _dereq_(125);
+
+module.exports = function(object, index, value){
+ if(index in object)$defineProperty.f(object, index, createDesc(0, value));
+ else object[index] = value;
+};
+},{"115":115,"125":125}],83:[function(_dereq_,module,exports){
+// optional / simple context binding
+var aFunction = _dereq_(72);
+module.exports = function(fn, that, length){
+ aFunction(fn);
+ if(that === undefined)return fn;
+ switch(length){
+ case 1: return function(a){
+ return fn.call(that, a);
+ };
+ case 2: return function(a, b){
+ return fn.call(that, a, b);
+ };
+ case 3: return function(a, b, c){
+ return fn.call(that, a, b, c);
+ };
+ }
+ return function(/* ...args */){
+ return fn.apply(that, arguments);
+ };
+};
+},{"72":72}],84:[function(_dereq_,module,exports){
+// 7.2.1 RequireObjectCoercible(argument)
+module.exports = function(it){
+ if(it == undefined)throw TypeError("Can't call method on " + it);
+ return it;
+};
+},{}],85:[function(_dereq_,module,exports){
+// Thank's IE8 for his funny defineProperty
+module.exports = !_dereq_(90)(function(){
+ return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
+});
+},{"90":90}],86:[function(_dereq_,module,exports){
+var isObject = _dereq_(102)
+ , document = _dereq_(92).document
+ // in old IE typeof document.createElement is 'object'
+ , is = isObject(document) && isObject(document.createElement);
+module.exports = function(it){
+ return is ? document.createElement(it) : {};
+};
+},{"102":102,"92":92}],87:[function(_dereq_,module,exports){
+// IE 8- don't enum bug keys
+module.exports = (
+ 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
+).split(',');
+},{}],88:[function(_dereq_,module,exports){
+// all enumerable object keys, includes symbols
+var getKeys = _dereq_(123)
+ , gOPS = _dereq_(120)
+ , pIE = _dereq_(124);
+module.exports = function(it){
+ var result = getKeys(it)
+ , getSymbols = gOPS.f;
+ if(getSymbols){
+ var symbols = getSymbols(it)
+ , isEnum = pIE.f
+ , i = 0
+ , key;
+ while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))result.push(key);
+ } return result;
+};
+},{"120":120,"123":123,"124":124}],89:[function(_dereq_,module,exports){
+var global = _dereq_(92)
+ , core = _dereq_(81)
+ , hide = _dereq_(94)
+ , redefine = _dereq_(127)
+ , ctx = _dereq_(83)
+ , PROTOTYPE = 'prototype';
+
+var $export = function(type, name, source){
+ var IS_FORCED = type & $export.F
+ , IS_GLOBAL = type & $export.G
+ , IS_STATIC = type & $export.S
+ , IS_PROTO = type & $export.P
+ , IS_BIND = type & $export.B
+ , target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE]
+ , exports = IS_GLOBAL ? core : core[name] || (core[name] = {})
+ , expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {})
+ , key, own, out, exp;
+ if(IS_GLOBAL)source = name;
+ for(key in source){
+ // contains in native
+ own = !IS_FORCED && target && target[key] !== undefined;
+ // export native or passed
+ out = (own ? target : source)[key];
+ // bind timers to global for call from export context
+ exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
+ // extend global
+ if(target)redefine(target, key, out, type & $export.U);
+ // export
+ if(exports[key] != out)hide(exports, key, exp);
+ if(IS_PROTO && expProto[key] != out)expProto[key] = out;
+ }
+};
+global.core = core;
+// type bitmap
+$export.F = 1; // forced
+$export.G = 2; // global
+$export.S = 4; // static
+$export.P = 8; // proto
+$export.B = 16; // bind
+$export.W = 32; // wrap
+$export.U = 64; // safe
+$export.R = 128; // real proto method for `library`
+module.exports = $export;
+},{"127":127,"81":81,"83":83,"92":92,"94":94}],90:[function(_dereq_,module,exports){
+module.exports = function(exec){
+ try {
+ return !!exec();
+ } catch(e){
+ return true;
+ }
+};
+},{}],91:[function(_dereq_,module,exports){
+var ctx = _dereq_(83)
+ , call = _dereq_(103)
+ , isArrayIter = _dereq_(100)
+ , anObject = _dereq_(75)
+ , toLength = _dereq_(138)
+ , getIterFn = _dereq_(145)
+ , BREAK = {}
+ , RETURN = {};
+var exports = module.exports = function(iterable, entries, fn, that, ITERATOR){
+ var iterFn = ITERATOR ? function(){ return iterable; } : getIterFn(iterable)
+ , f = ctx(fn, that, entries ? 2 : 1)
+ , index = 0
+ , length, step, iterator, result;
+ if(typeof iterFn != 'function')throw TypeError(iterable + ' is not iterable!');
+ // fast case for arrays with default iterator
+ if(isArrayIter(iterFn))for(length = toLength(iterable.length); length > index; index++){
+ result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
+ if(result === BREAK || result === RETURN)return result;
+ } else for(iterator = iterFn.call(iterable); !(step = iterator.next()).done; ){
+ result = call(iterator, f, step.value, entries);
+ if(result === BREAK || result === RETURN)return result;
+ }
+};
+exports.BREAK = BREAK;
+exports.RETURN = RETURN;
+},{"100":100,"103":103,"138":138,"145":145,"75":75,"83":83}],92:[function(_dereq_,module,exports){
+// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+var global = module.exports = typeof window != 'undefined' && window.Math == Math
+ ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
+if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef
+},{}],93:[function(_dereq_,module,exports){
+var hasOwnProperty = {}.hasOwnProperty;
+module.exports = function(it, key){
+ return hasOwnProperty.call(it, key);
+};
+},{}],94:[function(_dereq_,module,exports){
+var dP = _dereq_(115)
+ , createDesc = _dereq_(125);
+module.exports = _dereq_(85) ? function(object, key, value){
+ return dP.f(object, key, createDesc(1, value));
+} : function(object, key, value){
+ object[key] = value;
+ return object;
+};
+},{"115":115,"125":125,"85":85}],95:[function(_dereq_,module,exports){
+module.exports = _dereq_(92).document && document.documentElement;
+},{"92":92}],96:[function(_dereq_,module,exports){
+module.exports = !_dereq_(85) && !_dereq_(90)(function(){
+ return Object.defineProperty(_dereq_(86)('div'), 'a', {get: function(){ return 7; }}).a != 7;
+});
+},{"85":85,"86":86,"90":90}],97:[function(_dereq_,module,exports){
+var isObject = _dereq_(102)
+ , setPrototypeOf = _dereq_(128).set;
+module.exports = function(that, target, C){
+ var P, S = target.constructor;
+ if(S !== C && typeof S == 'function' && (P = S.prototype) !== C.prototype && isObject(P) && setPrototypeOf){
+ setPrototypeOf(that, P);
+ } return that;
+};
+},{"102":102,"128":128}],98:[function(_dereq_,module,exports){
+// fast apply, http://jsperf.lnkit.com/fast-apply/5
+module.exports = function(fn, args, that){
+ var un = that === undefined;
+ switch(args.length){
+ case 0: return un ? fn()
+ : fn.call(that);
+ case 1: return un ? fn(args[0])
+ : fn.call(that, args[0]);
+ case 2: return un ? fn(args[0], args[1])
+ : fn.call(that, args[0], args[1]);
+ case 3: return un ? fn(args[0], args[1], args[2])
+ : fn.call(that, args[0], args[1], args[2]);
+ case 4: return un ? fn(args[0], args[1], args[2], args[3])
+ : fn.call(that, args[0], args[1], args[2], args[3]);
+ } return fn.apply(that, args);
+};
+},{}],99:[function(_dereq_,module,exports){
+// fallback for non-array-like ES3 and non-enumerable old V8 strings
+var cof = _dereq_(78);
+module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){
+ return cof(it) == 'String' ? it.split('') : Object(it);
+};
+},{"78":78}],100:[function(_dereq_,module,exports){
+// check on default Array iterator
+var Iterators = _dereq_(108)
+ , ITERATOR = _dereq_(144)('iterator')
+ , ArrayProto = Array.prototype;
+
+module.exports = function(it){
+ return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
+};
+},{"108":108,"144":144}],101:[function(_dereq_,module,exports){
+// 7.2.2 IsArray(argument)
+var cof = _dereq_(78);
+module.exports = Array.isArray || function isArray(arg){
+ return cof(arg) == 'Array';
+};
+},{"78":78}],102:[function(_dereq_,module,exports){
+module.exports = function(it){
+ return typeof it === 'object' ? it !== null : typeof it === 'function';
+};
+},{}],103:[function(_dereq_,module,exports){
+// call something on iterator step with safe closing on error
+var anObject = _dereq_(75);
+module.exports = function(iterator, fn, value, entries){
+ try {
+ return entries ? fn(anObject(value)[0], value[1]) : fn(value);
+ // 7.4.6 IteratorClose(iterator, completion)
+ } catch(e){
+ var ret = iterator['return'];
+ if(ret !== undefined)anObject(ret.call(iterator));
+ throw e;
+ }
+};
+},{"75":75}],104:[function(_dereq_,module,exports){
+'use strict';
+var create = _dereq_(114)
+ , descriptor = _dereq_(125)
+ , setToStringTag = _dereq_(130)
+ , IteratorPrototype = {};
+
+// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
+_dereq_(94)(IteratorPrototype, _dereq_(144)('iterator'), function(){ return this; });
+
+module.exports = function(Constructor, NAME, next){
+ Constructor.prototype = create(IteratorPrototype, {next: descriptor(1, next)});
+ setToStringTag(Constructor, NAME + ' Iterator');
+};
+},{"114":114,"125":125,"130":130,"144":144,"94":94}],105:[function(_dereq_,module,exports){
+'use strict';
+var LIBRARY = _dereq_(110)
+ , $export = _dereq_(89)
+ , redefine = _dereq_(127)
+ , hide = _dereq_(94)
+ , has = _dereq_(93)
+ , Iterators = _dereq_(108)
+ , $iterCreate = _dereq_(104)
+ , setToStringTag = _dereq_(130)
+ , getPrototypeOf = _dereq_(121)
+ , ITERATOR = _dereq_(144)('iterator')
+ , BUGGY = !([].keys && 'next' in [].keys()) // Safari has buggy iterators w/o `next`
+ , FF_ITERATOR = '@@iterator'
+ , KEYS = 'keys'
+ , VALUES = 'values';
+
+var returnThis = function(){ return this; };
+
+module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED){
+ $iterCreate(Constructor, NAME, next);
+ var getMethod = function(kind){
+ if(!BUGGY && kind in proto)return proto[kind];
+ switch(kind){
+ case KEYS: return function keys(){ return new Constructor(this, kind); };
+ case VALUES: return function values(){ return new Constructor(this, kind); };
+ } return function entries(){ return new Constructor(this, kind); };
+ };
+ var TAG = NAME + ' Iterator'
+ , DEF_VALUES = DEFAULT == VALUES
+ , VALUES_BUG = false
+ , proto = Base.prototype
+ , $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]
+ , $default = $native || getMethod(DEFAULT)
+ , $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined
+ , $anyNative = NAME == 'Array' ? proto.entries || $native : $native
+ , methods, key, IteratorPrototype;
+ // Fix native
+ if($anyNative){
+ IteratorPrototype = getPrototypeOf($anyNative.call(new Base));
+ if(IteratorPrototype !== Object.prototype){
+ // Set @@toStringTag to native iterators
+ setToStringTag(IteratorPrototype, TAG, true);
+ // fix for some old engines
+ if(!LIBRARY && !has(IteratorPrototype, ITERATOR))hide(IteratorPrototype, ITERATOR, returnThis);
+ }
+ }
+ // fix Array#{values, @@iterator}.name in V8 / FF
+ if(DEF_VALUES && $native && $native.name !== VALUES){
+ VALUES_BUG = true;
+ $default = function values(){ return $native.call(this); };
+ }
+ // Define iterator
+ if((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])){
+ hide(proto, ITERATOR, $default);
+ }
+ // Plug for library
+ Iterators[NAME] = $default;
+ Iterators[TAG] = returnThis;
+ if(DEFAULT){
+ methods = {
+ values: DEF_VALUES ? $default : getMethod(VALUES),
+ keys: IS_SET ? $default : getMethod(KEYS),
+ entries: $entries
+ };
+ if(FORCED)for(key in methods){
+ if(!(key in proto))redefine(proto, key, methods[key]);
+ } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
+ }
+ return methods;
+};
+},{"104":104,"108":108,"110":110,"121":121,"127":127,"130":130,"144":144,"89":89,"93":93,"94":94}],106:[function(_dereq_,module,exports){
+var ITERATOR = _dereq_(144)('iterator')
+ , SAFE_CLOSING = false;
+
+try {
+ var riter = [7][ITERATOR]();
+ riter['return'] = function(){ SAFE_CLOSING = true; };
+ Array.from(riter, function(){ throw 2; });
+} catch(e){ /* empty */ }
+
+module.exports = function(exec, skipClosing){
+ if(!skipClosing && !SAFE_CLOSING)return false;
+ var safe = false;
+ try {
+ var arr = [7]
+ , iter = arr[ITERATOR]();
+ iter.next = function(){ return {done: safe = true}; };
+ arr[ITERATOR] = function(){ return iter; };
+ exec(arr);
+ } catch(e){ /* empty */ }
+ return safe;
+};
+},{"144":144}],107:[function(_dereq_,module,exports){
+module.exports = function(done, value){
+ return {value: value, done: !!done};
+};
+},{}],108:[function(_dereq_,module,exports){
+module.exports = {};
+},{}],109:[function(_dereq_,module,exports){
+var getKeys = _dereq_(123)
+ , toIObject = _dereq_(137);
+module.exports = function(object, el){
+ var O = toIObject(object)
+ , keys = getKeys(O)
+ , length = keys.length
+ , index = 0
+ , key;
+ while(length > index)if(O[key = keys[index++]] === el)return key;
+};
+},{"123":123,"137":137}],110:[function(_dereq_,module,exports){
+module.exports = false;
+},{}],111:[function(_dereq_,module,exports){
+var META = _dereq_(141)('meta')
+ , isObject = _dereq_(102)
+ , has = _dereq_(93)
+ , setDesc = _dereq_(115).f
+ , id = 0;
+var isExtensible = Object.isExtensible || function(){
+ return true;
+};
+var FREEZE = !_dereq_(90)(function(){
+ return isExtensible(Object.preventExtensions({}));
+});
+var setMeta = function(it){
+ setDesc(it, META, {value: {
+ i: 'O' + ++id, // object ID
+ w: {} // weak collections IDs
+ }});
+};
+var fastKey = function(it, create){
+ // return primitive with prefix
+ if(!isObject(it))return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
+ if(!has(it, META)){
+ // can't set metadata to uncaught frozen object
+ if(!isExtensible(it))return 'F';
+ // not necessary to add metadata
+ if(!create)return 'E';
+ // add missing metadata
+ setMeta(it);
+ // return object ID
+ } return it[META].i;
+};
+var getWeak = function(it, create){
+ if(!has(it, META)){
+ // can't set metadata to uncaught frozen object
+ if(!isExtensible(it))return true;
+ // not necessary to add metadata
+ if(!create)return false;
+ // add missing metadata
+ setMeta(it);
+ // return hash weak collections IDs
+ } return it[META].w;
+};
+// add metadata on freeze-family methods calling
+var onFreeze = function(it){
+ if(FREEZE && meta.NEED && isExtensible(it) && !has(it, META))setMeta(it);
+ return it;
+};
+var meta = module.exports = {
+ KEY: META,
+ NEED: false,
+ fastKey: fastKey,
+ getWeak: getWeak,
+ onFreeze: onFreeze
+};
+},{"102":102,"115":115,"141":141,"90":90,"93":93}],112:[function(_dereq_,module,exports){
+var global = _dereq_(92)
+ , macrotask = _dereq_(134).set
+ , Observer = global.MutationObserver || global.WebKitMutationObserver
+ , process = global.process
+ , Promise = global.Promise
+ , isNode = _dereq_(78)(process) == 'process';
+
+module.exports = function(){
+ var head, last, notify;
+
+ var flush = function(){
+ var parent, fn;
+ if(isNode && (parent = process.domain))parent.exit();
+ while(head){
+ fn = head.fn;
+ head = head.next;
+ try {
+ fn();
+ } catch(e){
+ if(head)notify();
+ else last = undefined;
+ throw e;
+ }
+ } last = undefined;
+ if(parent)parent.enter();
+ };
+
+ // Node.js
+ if(isNode){
+ notify = function(){
+ process.nextTick(flush);
+ };
+ // browsers with MutationObserver
+ } else if(Observer){
+ var toggle = true
+ , node = document.createTextNode('');
+ new Observer(flush).observe(node, {characterData: true}); // eslint-disable-line no-new
+ notify = function(){
+ node.data = toggle = !toggle;
+ };
+ // environments with maybe non-completely correct, but existent Promise
+ } else if(Promise && Promise.resolve){
+ var promise = Promise.resolve();
+ notify = function(){
+ promise.then(flush);
+ };
+ // for other environments - macrotask based on:
+ // - setImmediate
+ // - MessageChannel
+ // - window.postMessag
+ // - onreadystatechange
+ // - setTimeout
+ } else {
+ notify = function(){
+ // strange IE + webpack dev server bug - use .call(global)
+ macrotask.call(global, flush);
+ };
+ }
+
+ return function(fn){
+ var task = {fn: fn, next: undefined};
+ if(last)last.next = task;
+ if(!head){
+ head = task;
+ notify();
+ } last = task;
+ };
+};
+},{"134":134,"78":78,"92":92}],113:[function(_dereq_,module,exports){
+'use strict';
+// 19.1.2.1 Object.assign(target, source, ...)
+var getKeys = _dereq_(123)
+ , gOPS = _dereq_(120)
+ , pIE = _dereq_(124)
+ , toObject = _dereq_(139)
+ , IObject = _dereq_(99)
+ , $assign = Object.assign;
+
+// should work with symbols and should have deterministic property order (V8 bug)
+module.exports = !$assign || _dereq_(90)(function(){
+ var A = {}
+ , B = {}
+ , S = Symbol()
+ , K = 'abcdefghijklmnopqrst';
+ A[S] = 7;
+ K.split('').forEach(function(k){ B[k] = k; });
+ return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;
+}) ? function assign(target, source){ // eslint-disable-line no-unused-vars
+ var T = toObject(target)
+ , aLen = arguments.length
+ , index = 1
+ , getSymbols = gOPS.f
+ , isEnum = pIE.f;
+ while(aLen > index){
+ var S = IObject(arguments[index++])
+ , keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S)
+ , length = keys.length
+ , j = 0
+ , key;
+ while(length > j)if(isEnum.call(S, key = keys[j++]))T[key] = S[key];
+ } return T;
+} : $assign;
+},{"120":120,"123":123,"124":124,"139":139,"90":90,"99":99}],114:[function(_dereq_,module,exports){
+// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
+var anObject = _dereq_(75)
+ , dPs = _dereq_(116)
+ , enumBugKeys = _dereq_(87)
+ , IE_PROTO = _dereq_(131)('IE_PROTO')
+ , Empty = function(){ /* empty */ }
+ , PROTOTYPE = 'prototype';
+
+// Create object with fake `null` prototype: use iframe Object with cleared prototype
+var createDict = function(){
+ // Thrash, waste and sodomy: IE GC bug
+ var iframe = _dereq_(86)('iframe')
+ , i = enumBugKeys.length
+ , lt = '<'
+ , gt = '>'
+ , iframeDocument;
+ iframe.style.display = 'none';
+ _dereq_(95).appendChild(iframe);
+ iframe.src = 'javascript:'; // eslint-disable-line no-script-url
+ // createDict = iframe.contentWindow.Object;
+ // html.removeChild(iframe);
+ iframeDocument = iframe.contentWindow.document;
+ iframeDocument.open();
+ iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
+ iframeDocument.close();
+ createDict = iframeDocument.F;
+ while(i--)delete createDict[PROTOTYPE][enumBugKeys[i]];
+ return createDict();
+};
+
+module.exports = Object.create || function create(O, Properties){
+ var result;
+ if(O !== null){
+ Empty[PROTOTYPE] = anObject(O);
+ result = new Empty;
+ Empty[PROTOTYPE] = null;
+ // add "__proto__" for Object.getPrototypeOf polyfill
+ result[IE_PROTO] = O;
+ } else result = createDict();
+ return Properties === undefined ? result : dPs(result, Properties);
+};
+
+},{"116":116,"131":131,"75":75,"86":86,"87":87,"95":95}],115:[function(_dereq_,module,exports){
+var anObject = _dereq_(75)
+ , IE8_DOM_DEFINE = _dereq_(96)
+ , toPrimitive = _dereq_(140)
+ , dP = Object.defineProperty;
+
+exports.f = _dereq_(85) ? Object.defineProperty : function defineProperty(O, P, Attributes){
+ anObject(O);
+ P = toPrimitive(P, true);
+ anObject(Attributes);
+ if(IE8_DOM_DEFINE)try {
+ return dP(O, P, Attributes);
+ } catch(e){ /* empty */ }
+ if('get' in Attributes || 'set' in Attributes)throw TypeError('Accessors not supported!');
+ if('value' in Attributes)O[P] = Attributes.value;
+ return O;
+};
+},{"140":140,"75":75,"85":85,"96":96}],116:[function(_dereq_,module,exports){
+var dP = _dereq_(115)
+ , anObject = _dereq_(75)
+ , getKeys = _dereq_(123);
+
+module.exports = _dereq_(85) ? Object.defineProperties : function defineProperties(O, Properties){
+ anObject(O);
+ var keys = getKeys(Properties)
+ , length = keys.length
+ , i = 0
+ , P;
+ while(length > i)dP.f(O, P = keys[i++], Properties[P]);
+ return O;
+};
+},{"115":115,"123":123,"75":75,"85":85}],117:[function(_dereq_,module,exports){
+var pIE = _dereq_(124)
+ , createDesc = _dereq_(125)
+ , toIObject = _dereq_(137)
+ , toPrimitive = _dereq_(140)
+ , has = _dereq_(93)
+ , IE8_DOM_DEFINE = _dereq_(96)
+ , gOPD = Object.getOwnPropertyDescriptor;
+
+exports.f = _dereq_(85) ? gOPD : function getOwnPropertyDescriptor(O, P){
+ O = toIObject(O);
+ P = toPrimitive(P, true);
+ if(IE8_DOM_DEFINE)try {
+ return gOPD(O, P);
+ } catch(e){ /* empty */ }
+ if(has(O, P))return createDesc(!pIE.f.call(O, P), O[P]);
+};
+},{"124":124,"125":125,"137":137,"140":140,"85":85,"93":93,"96":96}],118:[function(_dereq_,module,exports){
+// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
+var toIObject = _dereq_(137)
+ , gOPN = _dereq_(119).f
+ , toString = {}.toString;
+
+var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames
+ ? Object.getOwnPropertyNames(window) : [];
+
+var getWindowNames = function(it){
+ try {
+ return gOPN(it);
+ } catch(e){
+ return windowNames.slice();
+ }
+};
+
+module.exports.f = function getOwnPropertyNames(it){
+ return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it));
+};
+
+},{"119":119,"137":137}],119:[function(_dereq_,module,exports){
+// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
+var $keys = _dereq_(122)
+ , hiddenKeys = _dereq_(87).concat('length', 'prototype');
+
+exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O){
+ return $keys(O, hiddenKeys);
+};
+},{"122":122,"87":87}],120:[function(_dereq_,module,exports){
+exports.f = Object.getOwnPropertySymbols;
+},{}],121:[function(_dereq_,module,exports){
+// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
+var has = _dereq_(93)
+ , toObject = _dereq_(139)
+ , IE_PROTO = _dereq_(131)('IE_PROTO')
+ , ObjectProto = Object.prototype;
+
+module.exports = Object.getPrototypeOf || function(O){
+ O = toObject(O);
+ if(has(O, IE_PROTO))return O[IE_PROTO];
+ if(typeof O.constructor == 'function' && O instanceof O.constructor){
+ return O.constructor.prototype;
+ } return O instanceof Object ? ObjectProto : null;
+};
+},{"131":131,"139":139,"93":93}],122:[function(_dereq_,module,exports){
+var has = _dereq_(93)
+ , toIObject = _dereq_(137)
+ , arrayIndexOf = _dereq_(76)(false)
+ , IE_PROTO = _dereq_(131)('IE_PROTO');
+
+module.exports = function(object, names){
+ var O = toIObject(object)
+ , i = 0
+ , result = []
+ , key;
+ for(key in O)if(key != IE_PROTO)has(O, key) && result.push(key);
+ // Don't enum bug & hidden keys
+ while(names.length > i)if(has(O, key = names[i++])){
+ ~arrayIndexOf(result, key) || result.push(key);
+ }
+ return result;
+};
+},{"131":131,"137":137,"76":76,"93":93}],123:[function(_dereq_,module,exports){
+// 19.1.2.14 / 15.2.3.14 Object.keys(O)
+var $keys = _dereq_(122)
+ , enumBugKeys = _dereq_(87);
+
+module.exports = Object.keys || function keys(O){
+ return $keys(O, enumBugKeys);
+};
+},{"122":122,"87":87}],124:[function(_dereq_,module,exports){
+exports.f = {}.propertyIsEnumerable;
+},{}],125:[function(_dereq_,module,exports){
+module.exports = function(bitmap, value){
+ return {
+ enumerable : !(bitmap & 1),
+ configurable: !(bitmap & 2),
+ writable : !(bitmap & 4),
+ value : value
+ };
+};
+},{}],126:[function(_dereq_,module,exports){
+var redefine = _dereq_(127);
+module.exports = function(target, src, safe){
+ for(var key in src)redefine(target, key, src[key], safe);
+ return target;
+};
+},{"127":127}],127:[function(_dereq_,module,exports){
+var global = _dereq_(92)
+ , hide = _dereq_(94)
+ , has = _dereq_(93)
+ , SRC = _dereq_(141)('src')
+ , TO_STRING = 'toString'
+ , $toString = Function[TO_STRING]
+ , TPL = ('' + $toString).split(TO_STRING);
+
+_dereq_(81).inspectSource = function(it){
+ return $toString.call(it);
+};
+
+(module.exports = function(O, key, val, safe){
+ var isFunction = typeof val == 'function';
+ if(isFunction)has(val, 'name') || hide(val, 'name', key);
+ if(O[key] === val)return;
+ if(isFunction)has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));
+ if(O === global){
+ O[key] = val;
+ } else {
+ if(!safe){
+ delete O[key];
+ hide(O, key, val);
+ } else {
+ if(O[key])O[key] = val;
+ else hide(O, key, val);
+ }
+ }
+// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
+})(Function.prototype, TO_STRING, function toString(){
+ return typeof this == 'function' && this[SRC] || $toString.call(this);
+});
+},{"141":141,"81":81,"92":92,"93":93,"94":94}],128:[function(_dereq_,module,exports){
+// Works with __proto__ only. Old v8 can't work with null proto objects.
+/* eslint-disable no-proto */
+var isObject = _dereq_(102)
+ , anObject = _dereq_(75);
+var check = function(O, proto){
+ anObject(O);
+ if(!isObject(proto) && proto !== null)throw TypeError(proto + ": can't set as prototype!");
+};
+module.exports = {
+ set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line
+ function(test, buggy, set){
+ try {
+ set = _dereq_(83)(Function.call, _dereq_(117).f(Object.prototype, '__proto__').set, 2);
+ set(test, []);
+ buggy = !(test instanceof Array);
+ } catch(e){ buggy = true; }
+ return function setPrototypeOf(O, proto){
+ check(O, proto);
+ if(buggy)O.__proto__ = proto;
+ else set(O, proto);
+ return O;
+ };
+ }({}, false) : undefined),
+ check: check
+};
+},{"102":102,"117":117,"75":75,"83":83}],129:[function(_dereq_,module,exports){
+'use strict';
+var global = _dereq_(92)
+ , dP = _dereq_(115)
+ , DESCRIPTORS = _dereq_(85)
+ , SPECIES = _dereq_(144)('species');
+
+module.exports = function(KEY){
+ var C = global[KEY];
+ if(DESCRIPTORS && C && !C[SPECIES])dP.f(C, SPECIES, {
+ configurable: true,
+ get: function(){ return this; }
+ });
+};
+},{"115":115,"144":144,"85":85,"92":92}],130:[function(_dereq_,module,exports){
+var def = _dereq_(115).f
+ , has = _dereq_(93)
+ , TAG = _dereq_(144)('toStringTag');
+
+module.exports = function(it, tag, stat){
+ if(it && !has(it = stat ? it : it.prototype, TAG))def(it, TAG, {configurable: true, value: tag});
+};
+},{"115":115,"144":144,"93":93}],131:[function(_dereq_,module,exports){
+var shared = _dereq_(132)('keys')
+ , uid = _dereq_(141);
+module.exports = function(key){
+ return shared[key] || (shared[key] = uid(key));
+};
+},{"132":132,"141":141}],132:[function(_dereq_,module,exports){
+var global = _dereq_(92)
+ , SHARED = '__core-js_shared__'
+ , store = global[SHARED] || (global[SHARED] = {});
+module.exports = function(key){
+ return store[key] || (store[key] = {});
+};
+},{"92":92}],133:[function(_dereq_,module,exports){
+// 7.3.20 SpeciesConstructor(O, defaultConstructor)
+var anObject = _dereq_(75)
+ , aFunction = _dereq_(72)
+ , SPECIES = _dereq_(144)('species');
+module.exports = function(O, D){
+ var C = anObject(O).constructor, S;
+ return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);
+};
+},{"144":144,"72":72,"75":75}],134:[function(_dereq_,module,exports){
+var ctx = _dereq_(83)
+ , invoke = _dereq_(98)
+ , html = _dereq_(95)
+ , cel = _dereq_(86)
+ , global = _dereq_(92)
+ , process = global.process
+ , setTask = global.setImmediate
+ , clearTask = global.clearImmediate
+ , MessageChannel = global.MessageChannel
+ , counter = 0
+ , queue = {}
+ , ONREADYSTATECHANGE = 'onreadystatechange'
+ , defer, channel, port;
+var run = function(){
+ var id = +this;
+ if(queue.hasOwnProperty(id)){
+ var fn = queue[id];
+ delete queue[id];
+ fn();
+ }
+};
+var listener = function(event){
+ run.call(event.data);
+};
+// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
+if(!setTask || !clearTask){
+ setTask = function setImmediate(fn){
+ var args = [], i = 1;
+ while(arguments.length > i)args.push(arguments[i++]);
+ queue[++counter] = function(){
+ invoke(typeof fn == 'function' ? fn : Function(fn), args);
+ };
+ defer(counter);
+ return counter;
+ };
+ clearTask = function clearImmediate(id){
+ delete queue[id];
+ };
+ // Node.js 0.8-
+ if(_dereq_(78)(process) == 'process'){
+ defer = function(id){
+ process.nextTick(ctx(run, id, 1));
+ };
+ // Browsers with MessageChannel, includes WebWorkers
+ } else if(MessageChannel){
+ channel = new MessageChannel;
+ port = channel.port2;
+ channel.port1.onmessage = listener;
+ defer = ctx(port.postMessage, port, 1);
+ // Browsers with postMessage, skip WebWorkers
+ // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
+ } else if(global.addEventListener && typeof postMessage == 'function' && !global.importScripts){
+ defer = function(id){
+ global.postMessage(id + '', '*');
+ };
+ global.addEventListener('message', listener, false);
+ // IE8-
+ } else if(ONREADYSTATECHANGE in cel('script')){
+ defer = function(id){
+ html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function(){
+ html.removeChild(this);
+ run.call(id);
+ };
+ };
+ // Rest old browsers
+ } else {
+ defer = function(id){
+ setTimeout(ctx(run, id, 1), 0);
+ };
+ }
+}
+module.exports = {
+ set: setTask,
+ clear: clearTask
+};
+},{"78":78,"83":83,"86":86,"92":92,"95":95,"98":98}],135:[function(_dereq_,module,exports){
+var toInteger = _dereq_(136)
+ , max = Math.max
+ , min = Math.min;
+module.exports = function(index, length){
+ index = toInteger(index);
+ return index < 0 ? max(index + length, 0) : min(index, length);
+};
+},{"136":136}],136:[function(_dereq_,module,exports){
+// 7.1.4 ToInteger
+var ceil = Math.ceil
+ , floor = Math.floor;
+module.exports = function(it){
+ return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
+};
+},{}],137:[function(_dereq_,module,exports){
+// to indexed object, toObject with fallback for non-array-like ES3 strings
+var IObject = _dereq_(99)
+ , defined = _dereq_(84);
+module.exports = function(it){
+ return IObject(defined(it));
+};
+},{"84":84,"99":99}],138:[function(_dereq_,module,exports){
+// 7.1.15 ToLength
+var toInteger = _dereq_(136)
+ , min = Math.min;
+module.exports = function(it){
+ return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
+};
+},{"136":136}],139:[function(_dereq_,module,exports){
+// 7.1.13 ToObject(argument)
+var defined = _dereq_(84);
+module.exports = function(it){
+ return Object(defined(it));
+};
+},{"84":84}],140:[function(_dereq_,module,exports){
+// 7.1.1 ToPrimitive(input [, PreferredType])
+var isObject = _dereq_(102);
+// instead of the ES6 spec version, we didn't implement @@toPrimitive case
+// and the second argument - flag - preferred type is a string
+module.exports = function(it, S){
+ if(!isObject(it))return it;
+ var fn, val;
+ if(S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
+ if(typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it)))return val;
+ if(!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it)))return val;
+ throw TypeError("Can't convert object to primitive value");
+};
+},{"102":102}],141:[function(_dereq_,module,exports){
+var id = 0
+ , px = Math.random();
+module.exports = function(key){
+ return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
+};
+},{}],142:[function(_dereq_,module,exports){
+var global = _dereq_(92)
+ , core = _dereq_(81)
+ , LIBRARY = _dereq_(110)
+ , wksExt = _dereq_(143)
+ , defineProperty = _dereq_(115).f;
+module.exports = function(name){
+ var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});
+ if(name.charAt(0) != '_' && !(name in $Symbol))defineProperty($Symbol, name, {value: wksExt.f(name)});
+};
+},{"110":110,"115":115,"143":143,"81":81,"92":92}],143:[function(_dereq_,module,exports){
+exports.f = _dereq_(144);
+},{"144":144}],144:[function(_dereq_,module,exports){
+var store = _dereq_(132)('wks')
+ , uid = _dereq_(141)
+ , Symbol = _dereq_(92).Symbol
+ , USE_SYMBOL = typeof Symbol == 'function';
+
+var $exports = module.exports = function(name){
+ return store[name] || (store[name] =
+ USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
+};
+
+$exports.store = store;
+},{"132":132,"141":141,"92":92}],145:[function(_dereq_,module,exports){
+var classof = _dereq_(77)
+ , ITERATOR = _dereq_(144)('iterator')
+ , Iterators = _dereq_(108);
+module.exports = _dereq_(81).getIteratorMethod = function(it){
+ if(it != undefined)return it[ITERATOR]
+ || it['@@iterator']
+ || Iterators[classof(it)];
+};
+},{"108":108,"144":144,"77":77,"81":81}],146:[function(_dereq_,module,exports){
+'use strict';
+var ctx = _dereq_(83)
+ , $export = _dereq_(89)
+ , toObject = _dereq_(139)
+ , call = _dereq_(103)
+ , isArrayIter = _dereq_(100)
+ , toLength = _dereq_(138)
+ , createProperty = _dereq_(82)
+ , getIterFn = _dereq_(145);
+
+$export($export.S + $export.F * !_dereq_(106)(function(iter){ Array.from(iter); }), 'Array', {
+ // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)
+ from: function from(arrayLike/*, mapfn = undefined, thisArg = undefined*/){
+ var O = toObject(arrayLike)
+ , C = typeof this == 'function' ? this : Array
+ , aLen = arguments.length
+ , mapfn = aLen > 1 ? arguments[1] : undefined
+ , mapping = mapfn !== undefined
+ , index = 0
+ , iterFn = getIterFn(O)
+ , length, result, step, iterator;
+ if(mapping)mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);
+ // if object isn't iterable or it's array with default iterator - use simple case
+ if(iterFn != undefined && !(C == Array && isArrayIter(iterFn))){
+ for(iterator = iterFn.call(O), result = new C; !(step = iterator.next()).done; index++){
+ createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);
+ }
+ } else {
+ length = toLength(O.length);
+ for(result = new C(length); length > index; index++){
+ createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);
+ }
+ }
+ result.length = index;
+ return result;
+ }
+});
+
+},{"100":100,"103":103,"106":106,"138":138,"139":139,"145":145,"82":82,"83":83,"89":89}],147:[function(_dereq_,module,exports){
+'use strict';
+var addToUnscopables = _dereq_(73)
+ , step = _dereq_(107)
+ , Iterators = _dereq_(108)
+ , toIObject = _dereq_(137);
+
+// 22.1.3.4 Array.prototype.entries()
+// 22.1.3.13 Array.prototype.keys()
+// 22.1.3.29 Array.prototype.values()
+// 22.1.3.30 Array.prototype[@@iterator]()
+module.exports = _dereq_(105)(Array, 'Array', function(iterated, kind){
+ this._t = toIObject(iterated); // target
+ this._i = 0; // next index
+ this._k = kind; // kind
+// 22.1.5.2.1 %ArrayIteratorPrototype%.next()
+}, function(){
+ var O = this._t
+ , kind = this._k
+ , index = this._i++;
+ if(!O || index >= O.length){
+ this._t = undefined;
+ return step(1);
+ }
+ if(kind == 'keys' )return step(0, index);
+ if(kind == 'values')return step(0, O[index]);
+ return step(0, [index, O[index]]);
+}, 'values');
+
+// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
+Iterators.Arguments = Iterators.Array;
+
+addToUnscopables('keys');
+addToUnscopables('values');
+addToUnscopables('entries');
+},{"105":105,"107":107,"108":108,"137":137,"73":73}],148:[function(_dereq_,module,exports){
+'use strict';
+var strong = _dereq_(79);
+
+// 23.1 Map Objects
+module.exports = _dereq_(80)('Map', function(get){
+ return function Map(){ return get(this, arguments.length > 0 ? arguments[0] : undefined); };
+}, {
+ // 23.1.3.6 Map.prototype.get(key)
+ get: function get(key){
+ var entry = strong.getEntry(this, key);
+ return entry && entry.v;
+ },
+ // 23.1.3.9 Map.prototype.set(key, value)
+ set: function set(key, value){
+ return strong.def(this, key === 0 ? 0 : key, value);
+ }
+}, strong, true);
+},{"79":79,"80":80}],149:[function(_dereq_,module,exports){
+// 19.1.3.1 Object.assign(target, source)
+var $export = _dereq_(89);
+
+$export($export.S + $export.F, 'Object', {assign: _dereq_(113)});
+},{"113":113,"89":89}],150:[function(_dereq_,module,exports){
+// 19.1.3.19 Object.setPrototypeOf(O, proto)
+var $export = _dereq_(89);
+$export($export.S, 'Object', {setPrototypeOf: _dereq_(128).set});
+},{"128":128,"89":89}],151:[function(_dereq_,module,exports){
+'use strict';
+var LIBRARY = _dereq_(110)
+ , global = _dereq_(92)
+ , ctx = _dereq_(83)
+ , classof = _dereq_(77)
+ , $export = _dereq_(89)
+ , isObject = _dereq_(102)
+ , aFunction = _dereq_(72)
+ , anInstance = _dereq_(74)
+ , forOf = _dereq_(91)
+ , speciesConstructor = _dereq_(133)
+ , task = _dereq_(134).set
+ , microtask = _dereq_(112)()
+ , PROMISE = 'Promise'
+ , TypeError = global.TypeError
+ , process = global.process
+ , $Promise = global[PROMISE]
+ , process = global.process
+ , isNode = classof(process) == 'process'
+ , empty = function(){ /* empty */ }
+ , Internal, GenericPromiseCapability, Wrapper;
+
+var USE_NATIVE = !!function(){
+ try {
+ // correct subclassing with @@species support
+ var promise = $Promise.resolve(1)
+ , FakePromise = (promise.constructor = {})[_dereq_(144)('species')] = function(exec){ exec(empty, empty); };
+ // unhandled rejections tracking support, NodeJS Promise without it fails @@species test
+ return (isNode || typeof PromiseRejectionEvent == 'function') && promise.then(empty) instanceof FakePromise;
+ } catch(e){ /* empty */ }
+}();
+
+// helpers
+var sameConstructor = function(a, b){
+ // with library wrapper special case
+ return a === b || a === $Promise && b === Wrapper;
+};
+var isThenable = function(it){
+ var then;
+ return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
+};
+var newPromiseCapability = function(C){
+ return sameConstructor($Promise, C)
+ ? new PromiseCapability(C)
+ : new GenericPromiseCapability(C);
+};
+var PromiseCapability = GenericPromiseCapability = function(C){
+ var resolve, reject;
+ this.promise = new C(function($$resolve, $$reject){
+ if(resolve !== undefined || reject !== undefined)throw TypeError('Bad Promise constructor');
+ resolve = $$resolve;
+ reject = $$reject;
+ });
+ this.resolve = aFunction(resolve);
+ this.reject = aFunction(reject);
+};
+var perform = function(exec){
+ try {
+ exec();
+ } catch(e){
+ return {error: e};
+ }
+};
+var notify = function(promise, isReject){
+ if(promise._n)return;
+ promise._n = true;
+ var chain = promise._c;
+ microtask(function(){
+ var value = promise._v
+ , ok = promise._s == 1
+ , i = 0;
+ var run = function(reaction){
+ var handler = ok ? reaction.ok : reaction.fail
+ , resolve = reaction.resolve
+ , reject = reaction.reject
+ , domain = reaction.domain
+ , result, then;
+ try {
+ if(handler){
+ if(!ok){
+ if(promise._h == 2)onHandleUnhandled(promise);
+ promise._h = 1;
+ }
+ if(handler === true)result = value;
+ else {
+ if(domain)domain.enter();
+ result = handler(value);
+ if(domain)domain.exit();
+ }
+ if(result === reaction.promise){
+ reject(TypeError('Promise-chain cycle'));
+ } else if(then = isThenable(result)){
+ then.call(result, resolve, reject);
+ } else resolve(result);
+ } else reject(value);
+ } catch(e){
+ reject(e);
+ }
+ };
+ while(chain.length > i)run(chain[i++]); // variable length - can't use forEach
+ promise._c = [];
+ promise._n = false;
+ if(isReject && !promise._h)onUnhandled(promise);
+ });
+};
+var onUnhandled = function(promise){
+ task.call(global, function(){
+ var value = promise._v
+ , abrupt, handler, console;
+ if(isUnhandled(promise)){
+ abrupt = perform(function(){
+ if(isNode){
+ process.emit('unhandledRejection', value, promise);
+ } else if(handler = global.onunhandledrejection){
+ handler({promise: promise, reason: value});
+ } else if((console = global.console) && console.error){
+ console.error('Unhandled promise rejection', value);
+ }
+ });
+ // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
+ promise._h = isNode || isUnhandled(promise) ? 2 : 1;
+ } promise._a = undefined;
+ if(abrupt)throw abrupt.error;
+ });
+};
+var isUnhandled = function(promise){
+ if(promise._h == 1)return false;
+ var chain = promise._a || promise._c
+ , i = 0
+ , reaction;
+ while(chain.length > i){
+ reaction = chain[i++];
+ if(reaction.fail || !isUnhandled(reaction.promise))return false;
+ } return true;
+};
+var onHandleUnhandled = function(promise){
+ task.call(global, function(){
+ var handler;
+ if(isNode){
+ process.emit('rejectionHandled', promise);
+ } else if(handler = global.onrejectionhandled){
+ handler({promise: promise, reason: promise._v});
+ }
+ });
+};
+var $reject = function(value){
+ var promise = this;
+ if(promise._d)return;
+ promise._d = true;
+ promise = promise._w || promise; // unwrap
+ promise._v = value;
+ promise._s = 2;
+ if(!promise._a)promise._a = promise._c.slice();
+ notify(promise, true);
+};
+var $resolve = function(value){
+ var promise = this
+ , then;
+ if(promise._d)return;
+ promise._d = true;
+ promise = promise._w || promise; // unwrap
+ try {
+ if(promise === value)throw TypeError("Promise can't be resolved itself");
+ if(then = isThenable(value)){
+ microtask(function(){
+ var wrapper = {_w: promise, _d: false}; // wrap
+ try {
+ then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));
+ } catch(e){
+ $reject.call(wrapper, e);
+ }
+ });
+ } else {
+ promise._v = value;
+ promise._s = 1;
+ notify(promise, false);
+ }
+ } catch(e){
+ $reject.call({_w: promise, _d: false}, e); // wrap
+ }
+};
+
+// constructor polyfill
+if(!USE_NATIVE){
+ // 25.4.3.1 Promise(executor)
+ $Promise = function Promise(executor){
+ anInstance(this, $Promise, PROMISE, '_h');
+ aFunction(executor);
+ Internal.call(this);
+ try {
+ executor(ctx($resolve, this, 1), ctx($reject, this, 1));
+ } catch(err){
+ $reject.call(this, err);
+ }
+ };
+ Internal = function Promise(executor){
+ this._c = []; // <- awaiting reactions
+ this._a = undefined; // <- checked in isUnhandled reactions
+ this._s = 0; // <- state
+ this._d = false; // <- done
+ this._v = undefined; // <- value
+ this._h = 0; // <- rejection state, 0 - default, 1 - handled, 2 - unhandled
+ this._n = false; // <- notify
+ };
+ Internal.prototype = _dereq_(126)($Promise.prototype, {
+ // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)
+ then: function then(onFulfilled, onRejected){
+ var reaction = newPromiseCapability(speciesConstructor(this, $Promise));
+ reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;
+ reaction.fail = typeof onRejected == 'function' && onRejected;
+ reaction.domain = isNode ? process.domain : undefined;
+ this._c.push(reaction);
+ if(this._a)this._a.push(reaction);
+ if(this._s)notify(this, false);
+ return reaction.promise;
+ },
+ // 25.4.5.1 Promise.prototype.catch(onRejected)
+ 'catch': function(onRejected){
+ return this.then(undefined, onRejected);
+ }
+ });
+ PromiseCapability = function(){
+ var promise = new Internal;
+ this.promise = promise;
+ this.resolve = ctx($resolve, promise, 1);
+ this.reject = ctx($reject, promise, 1);
+ };
+}
+
+$export($export.G + $export.W + $export.F * !USE_NATIVE, {Promise: $Promise});
+_dereq_(130)($Promise, PROMISE);
+_dereq_(129)(PROMISE);
+Wrapper = _dereq_(81)[PROMISE];
+
+// statics
+$export($export.S + $export.F * !USE_NATIVE, PROMISE, {
+ // 25.4.4.5 Promise.reject(r)
+ reject: function reject(r){
+ var capability = newPromiseCapability(this)
+ , $$reject = capability.reject;
+ $$reject(r);
+ return capability.promise;
+ }
+});
+$export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {
+ // 25.4.4.6 Promise.resolve(x)
+ resolve: function resolve(x){
+ // instanceof instead of internal slot check because we should fix it without replacement native Promise core
+ if(x instanceof $Promise && sameConstructor(x.constructor, this))return x;
+ var capability = newPromiseCapability(this)
+ , $$resolve = capability.resolve;
+ $$resolve(x);
+ return capability.promise;
+ }
+});
+$export($export.S + $export.F * !(USE_NATIVE && _dereq_(106)(function(iter){
+ $Promise.all(iter)['catch'](empty);
+})), PROMISE, {
+ // 25.4.4.1 Promise.all(iterable)
+ all: function all(iterable){
+ var C = this
+ , capability = newPromiseCapability(C)
+ , resolve = capability.resolve
+ , reject = capability.reject;
+ var abrupt = perform(function(){
+ var values = []
+ , index = 0
+ , remaining = 1;
+ forOf(iterable, false, function(promise){
+ var $index = index++
+ , alreadyCalled = false;
+ values.push(undefined);
+ remaining++;
+ C.resolve(promise).then(function(value){
+ if(alreadyCalled)return;
+ alreadyCalled = true;
+ values[$index] = value;
+ --remaining || resolve(values);
+ }, reject);
+ });
+ --remaining || resolve(values);
+ });
+ if(abrupt)reject(abrupt.error);
+ return capability.promise;
+ },
+ // 25.4.4.4 Promise.race(iterable)
+ race: function race(iterable){
+ var C = this
+ , capability = newPromiseCapability(C)
+ , reject = capability.reject;
+ var abrupt = perform(function(){
+ forOf(iterable, false, function(promise){
+ C.resolve(promise).then(capability.resolve, reject);
+ });
+ });
+ if(abrupt)reject(abrupt.error);
+ return capability.promise;
+ }
+});
+},{"102":102,"106":106,"110":110,"112":112,"126":126,"129":129,"130":130,"133":133,"134":134,"144":144,"72":72,"74":74,"77":77,"81":81,"83":83,"89":89,"91":91,"92":92}],152:[function(_dereq_,module,exports){
+'use strict';
+var strong = _dereq_(79);
+
+// 23.2 Set Objects
+module.exports = _dereq_(80)('Set', function(get){
+ return function Set(){ return get(this, arguments.length > 0 ? arguments[0] : undefined); };
+}, {
+ // 23.2.3.1 Set.prototype.add(value)
+ add: function add(value){
+ return strong.def(this, value = value === 0 ? 0 : value, value);
+ }
+}, strong);
+},{"79":79,"80":80}],153:[function(_dereq_,module,exports){
+'use strict';
+// ECMAScript 6 symbols shim
+var global = _dereq_(92)
+ , has = _dereq_(93)
+ , DESCRIPTORS = _dereq_(85)
+ , $export = _dereq_(89)
+ , redefine = _dereq_(127)
+ , META = _dereq_(111).KEY
+ , $fails = _dereq_(90)
+ , shared = _dereq_(132)
+ , setToStringTag = _dereq_(130)
+ , uid = _dereq_(141)
+ , wks = _dereq_(144)
+ , wksExt = _dereq_(143)
+ , wksDefine = _dereq_(142)
+ , keyOf = _dereq_(109)
+ , enumKeys = _dereq_(88)
+ , isArray = _dereq_(101)
+ , anObject = _dereq_(75)
+ , toIObject = _dereq_(137)
+ , toPrimitive = _dereq_(140)
+ , createDesc = _dereq_(125)
+ , _create = _dereq_(114)
+ , gOPNExt = _dereq_(118)
+ , $GOPD = _dereq_(117)
+ , $DP = _dereq_(115)
+ , $keys = _dereq_(123)
+ , gOPD = $GOPD.f
+ , dP = $DP.f
+ , gOPN = gOPNExt.f
+ , $Symbol = global.Symbol
+ , $JSON = global.JSON
+ , _stringify = $JSON && $JSON.stringify
+ , PROTOTYPE = 'prototype'
+ , HIDDEN = wks('_hidden')
+ , TO_PRIMITIVE = wks('toPrimitive')
+ , isEnum = {}.propertyIsEnumerable
+ , SymbolRegistry = shared('symbol-registry')
+ , AllSymbols = shared('symbols')
+ , OPSymbols = shared('op-symbols')
+ , ObjectProto = Object[PROTOTYPE]
+ , USE_NATIVE = typeof $Symbol == 'function'
+ , QObject = global.QObject;
+// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173
+var setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;
+
+// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
+var setSymbolDesc = DESCRIPTORS && $fails(function(){
+ return _create(dP({}, 'a', {
+ get: function(){ return dP(this, 'a', {value: 7}).a; }
+ })).a != 7;
+}) ? function(it, key, D){
+ var protoDesc = gOPD(ObjectProto, key);
+ if(protoDesc)delete ObjectProto[key];
+ dP(it, key, D);
+ if(protoDesc && it !== ObjectProto)dP(ObjectProto, key, protoDesc);
+} : dP;
+
+var wrap = function(tag){
+ var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]);
+ sym._k = tag;
+ return sym;
+};
+
+var isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function(it){
+ return typeof it == 'symbol';
+} : function(it){
+ return it instanceof $Symbol;
+};
+
+var $defineProperty = function defineProperty(it, key, D){
+ if(it === ObjectProto)$defineProperty(OPSymbols, key, D);
+ anObject(it);
+ key = toPrimitive(key, true);
+ anObject(D);
+ if(has(AllSymbols, key)){
+ if(!D.enumerable){
+ if(!has(it, HIDDEN))dP(it, HIDDEN, createDesc(1, {}));
+ it[HIDDEN][key] = true;
+ } else {
+ if(has(it, HIDDEN) && it[HIDDEN][key])it[HIDDEN][key] = false;
+ D = _create(D, {enumerable: createDesc(0, false)});
+ } return setSymbolDesc(it, key, D);
+ } return dP(it, key, D);
+};
+var $defineProperties = function defineProperties(it, P){
+ anObject(it);
+ var keys = enumKeys(P = toIObject(P))
+ , i = 0
+ , l = keys.length
+ , key;
+ while(l > i)$defineProperty(it, key = keys[i++], P[key]);
+ return it;
+};
+var $create = function create(it, P){
+ return P === undefined ? _create(it) : $defineProperties(_create(it), P);
+};
+var $propertyIsEnumerable = function propertyIsEnumerable(key){
+ var E = isEnum.call(this, key = toPrimitive(key, true));
+ if(this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key))return false;
+ return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true;
+};
+var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key){
+ it = toIObject(it);
+ key = toPrimitive(key, true);
+ if(it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key))return;
+ var D = gOPD(it, key);
+ if(D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key]))D.enumerable = true;
+ return D;
+};
+var $getOwnPropertyNames = function getOwnPropertyNames(it){
+ var names = gOPN(toIObject(it))
+ , result = []
+ , i = 0
+ , key;
+ while(names.length > i){
+ if(!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META)result.push(key);
+ } return result;
+};
+var $getOwnPropertySymbols = function getOwnPropertySymbols(it){
+ var IS_OP = it === ObjectProto
+ , names = gOPN(IS_OP ? OPSymbols : toIObject(it))
+ , result = []
+ , i = 0
+ , key;
+ while(names.length > i){
+ if(has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true))result.push(AllSymbols[key]);
+ } return result;
+};
+
+// 19.4.1.1 Symbol([description])
+if(!USE_NATIVE){
+ $Symbol = function Symbol(){
+ if(this instanceof $Symbol)throw TypeError('Symbol is not a constructor!');
+ var tag = uid(arguments.length > 0 ? arguments[0] : undefined);
+ var $set = function(value){
+ if(this === ObjectProto)$set.call(OPSymbols, value);
+ if(has(this, HIDDEN) && has(this[HIDDEN], tag))this[HIDDEN][tag] = false;
+ setSymbolDesc(this, tag, createDesc(1, value));
+ };
+ if(DESCRIPTORS && setter)setSymbolDesc(ObjectProto, tag, {configurable: true, set: $set});
+ return wrap(tag);
+ };
+ redefine($Symbol[PROTOTYPE], 'toString', function toString(){
+ return this._k;
+ });
+
+ $GOPD.f = $getOwnPropertyDescriptor;
+ $DP.f = $defineProperty;
+ _dereq_(119).f = gOPNExt.f = $getOwnPropertyNames;
+ _dereq_(124).f = $propertyIsEnumerable;
+ _dereq_(120).f = $getOwnPropertySymbols;
+
+ if(DESCRIPTORS && !_dereq_(110)){
+ redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);
+ }
+
+ wksExt.f = function(name){
+ return wrap(wks(name));
+ }
+}
+
+$export($export.G + $export.W + $export.F * !USE_NATIVE, {Symbol: $Symbol});
+
+for(var symbols = (
+ // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14
+ 'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'
+).split(','), i = 0; symbols.length > i; )wks(symbols[i++]);
+
+for(var symbols = $keys(wks.store), i = 0; symbols.length > i; )wksDefine(symbols[i++]);
+
+$export($export.S + $export.F * !USE_NATIVE, 'Symbol', {
+ // 19.4.2.1 Symbol.for(key)
+ 'for': function(key){
+ return has(SymbolRegistry, key += '')
+ ? SymbolRegistry[key]
+ : SymbolRegistry[key] = $Symbol(key);
+ },
+ // 19.4.2.5 Symbol.keyFor(sym)
+ keyFor: function keyFor(key){
+ if(isSymbol(key))return keyOf(SymbolRegistry, key);
+ throw TypeError(key + ' is not a symbol!');
+ },
+ useSetter: function(){ setter = true; },
+ useSimple: function(){ setter = false; }
+});
+
+$export($export.S + $export.F * !USE_NATIVE, 'Object', {
+ // 19.1.2.2 Object.create(O [, Properties])
+ create: $create,
+ // 19.1.2.4 Object.defineProperty(O, P, Attributes)
+ defineProperty: $defineProperty,
+ // 19.1.2.3 Object.defineProperties(O, Properties)
+ defineProperties: $defineProperties,
+ // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
+ getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
+ // 19.1.2.7 Object.getOwnPropertyNames(O)
+ getOwnPropertyNames: $getOwnPropertyNames,
+ // 19.1.2.8 Object.getOwnPropertySymbols(O)
+ getOwnPropertySymbols: $getOwnPropertySymbols
+});
+
+// 24.3.2 JSON.stringify(value [, replacer [, space]])
+$JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function(){
+ var S = $Symbol();
+ // MS Edge converts symbol values to JSON as {}
+ // WebKit converts symbol values to JSON as null
+ // V8 throws on boxed symbols
+ return _stringify([S]) != '[null]' || _stringify({a: S}) != '{}' || _stringify(Object(S)) != '{}';
+})), 'JSON', {
+ stringify: function stringify(it){
+ if(it === undefined || isSymbol(it))return; // IE8 returns string on undefined
+ var args = [it]
+ , i = 1
+ , replacer, $replacer;
+ while(arguments.length > i)args.push(arguments[i++]);
+ replacer = args[1];
+ if(typeof replacer == 'function')$replacer = replacer;
+ if($replacer || !isArray(replacer))replacer = function(key, value){
+ if($replacer)value = $replacer.call(this, key, value);
+ if(!isSymbol(value))return value;
+ };
+ args[1] = replacer;
+ return _stringify.apply($JSON, args);
+ }
+});
+
+// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)
+$Symbol[PROTOTYPE][TO_PRIMITIVE] || _dereq_(94)($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);
+// 19.4.3.5 Symbol.prototype[@@toStringTag]
+setToStringTag($Symbol, 'Symbol');
+// 20.2.1.9 Math[@@toStringTag]
+setToStringTag(Math, 'Math', true);
+// 24.3.3 JSON[@@toStringTag]
+setToStringTag(global.JSON, 'JSON', true);
+},{"101":101,"109":109,"110":110,"111":111,"114":114,"115":115,"117":117,"118":118,"119":119,"120":120,"123":123,"124":124,"125":125,"127":127,"130":130,"132":132,"137":137,"140":140,"141":141,"142":142,"143":143,"144":144,"75":75,"85":85,"88":88,"89":89,"90":90,"92":92,"93":93,"94":94}],154:[function(_dereq_,module,exports){
+'use strict';
+// https://github.com/zenparsing/es-observable
+var $export = _dereq_(89)
+ , global = _dereq_(92)
+ , core = _dereq_(81)
+ , microtask = _dereq_(112)()
+ , OBSERVABLE = _dereq_(144)('observable')
+ , aFunction = _dereq_(72)
+ , anObject = _dereq_(75)
+ , anInstance = _dereq_(74)
+ , redefineAll = _dereq_(126)
+ , hide = _dereq_(94)
+ , forOf = _dereq_(91)
+ , RETURN = forOf.RETURN;
+
+var getMethod = function(fn){
+ return fn == null ? undefined : aFunction(fn);
+};
+
+var cleanupSubscription = function(subscription){
+ var cleanup = subscription._c;
+ if(cleanup){
+ subscription._c = undefined;
+ cleanup();
+ }
+};
+
+var subscriptionClosed = function(subscription){
+ return subscription._o === undefined;
+};
+
+var closeSubscription = function(subscription){
+ if(!subscriptionClosed(subscription)){
+ subscription._o = undefined;
+ cleanupSubscription(subscription);
+ }
+};
+
+var Subscription = function(observer, subscriber){
+ anObject(observer);
+ this._c = undefined;
+ this._o = observer;
+ observer = new SubscriptionObserver(this);
+ try {
+ var cleanup = subscriber(observer)
+ , subscription = cleanup;
+ if(cleanup != null){
+ if(typeof cleanup.unsubscribe === 'function')cleanup = function(){ subscription.unsubscribe(); };
+ else aFunction(cleanup);
+ this._c = cleanup;
+ }
+ } catch(e){
+ observer.error(e);
+ return;
+ } if(subscriptionClosed(this))cleanupSubscription(this);
+};
+
+Subscription.prototype = redefineAll({}, {
+ unsubscribe: function unsubscribe(){ closeSubscription(this); }
+});
+
+var SubscriptionObserver = function(subscription){
+ this._s = subscription;
+};
+
+SubscriptionObserver.prototype = redefineAll({}, {
+ next: function next(value){
+ var subscription = this._s;
+ if(!subscriptionClosed(subscription)){
+ var observer = subscription._o;
+ try {
+ var m = getMethod(observer.next);
+ if(m)return m.call(observer, value);
+ } catch(e){
+ try {
+ closeSubscription(subscription);
+ } finally {
+ throw e;
+ }
+ }
+ }
+ },
+ error: function error(value){
+ var subscription = this._s;
+ if(subscriptionClosed(subscription))throw value;
+ var observer = subscription._o;
+ subscription._o = undefined;
+ try {
+ var m = getMethod(observer.error);
+ if(!m)throw value;
+ value = m.call(observer, value);
+ } catch(e){
+ try {
+ cleanupSubscription(subscription);
+ } finally {
+ throw e;
+ }
+ } cleanupSubscription(subscription);
+ return value;
+ },
+ complete: function complete(value){
+ var subscription = this._s;
+ if(!subscriptionClosed(subscription)){
+ var observer = subscription._o;
+ subscription._o = undefined;
+ try {
+ var m = getMethod(observer.complete);
+ value = m ? m.call(observer, value) : undefined;
+ } catch(e){
+ try {
+ cleanupSubscription(subscription);
+ } finally {
+ throw e;
+ }
+ } cleanupSubscription(subscription);
+ return value;
+ }
+ }
+});
+
+var $Observable = function Observable(subscriber){
+ anInstance(this, $Observable, 'Observable', '_f')._f = aFunction(subscriber);
+};
+
+redefineAll($Observable.prototype, {
+ subscribe: function subscribe(observer){
+ return new Subscription(observer, this._f);
+ },
+ forEach: function forEach(fn){
+ var that = this;
+ return new (core.Promise || global.Promise)(function(resolve, reject){
+ aFunction(fn);
+ var subscription = that.subscribe({
+ next : function(value){
+ try {
+ return fn(value);
+ } catch(e){
+ reject(e);
+ subscription.unsubscribe();
+ }
+ },
+ error: reject,
+ complete: resolve
+ });
+ });
+ }
+});
+
+redefineAll($Observable, {
+ from: function from(x){
+ var C = typeof this === 'function' ? this : $Observable;
+ var method = getMethod(anObject(x)[OBSERVABLE]);
+ if(method){
+ var observable = anObject(method.call(x));
+ return observable.constructor === C ? observable : new C(function(observer){
+ return observable.subscribe(observer);
+ });
+ }
+ return new C(function(observer){
+ var done = false;
+ microtask(function(){
+ if(!done){
+ try {
+ if(forOf(x, false, function(it){
+ observer.next(it);
+ if(done)return RETURN;
+ }) === RETURN)return;
+ } catch(e){
+ if(done)throw e;
+ observer.error(e);
+ return;
+ } observer.complete();
+ }
+ });
+ return function(){ done = true; };
+ });
+ },
+ of: function of(){
+ for(var i = 0, l = arguments.length, items = Array(l); i < l;)items[i] = arguments[i++];
+ return new (typeof this === 'function' ? this : $Observable)(function(observer){
+ var done = false;
+ microtask(function(){
+ if(!done){
+ for(var i = 0; i < items.length; ++i){
+ observer.next(items[i]);
+ if(done)return;
+ } observer.complete();
+ }
+ });
+ return function(){ done = true; };
+ });
+ }
+});
+
+hide($Observable.prototype, OBSERVABLE, function(){ return this; });
+
+$export($export.G, {Observable: $Observable});
+
+_dereq_(129)('Observable');
+},{"112":112,"126":126,"129":129,"144":144,"72":72,"74":74,"75":75,"81":81,"89":89,"91":91,"92":92,"94":94}],155:[function(_dereq_,module,exports){
+_dereq_(142)('observable');
+},{"142":142}],156:[function(_dereq_,module,exports){
+;(function (root, factory) {
+ if (typeof exports === "object") {
+ // CommonJS
+ module.exports = exports = factory();
+ }
+ else if (typeof define === "function" && define.amd) {
+ // AMD
+ define([], factory);
+ }
+ else {
+ // Global (browser)
+ root.CryptoJS = factory();
+ }
+}(this, function () {
+
+ /**
+ * CryptoJS core components.
+ */
+ var CryptoJS = CryptoJS || (function (Math, undefined) {
+ /*
+ * Local polyfil of Object.create
+ */
+ var create = Object.create || (function () {
+ function F() {};
+
+ return function (obj) {
+ var subtype;
+
+ F.prototype = obj;
+
+ subtype = new F();
+
+ F.prototype = null;
+
+ return subtype;
+ };
+ }())
+
+ /**
+ * CryptoJS namespace.
+ */
+ var C = {};
+
+ /**
+ * Library namespace.
+ */
+ var C_lib = C.lib = {};
+
+ /**
+ * Base object for prototypal inheritance.
+ */
+ var Base = C_lib.Base = (function () {
+
+
+ return {
+ /**
+ * Creates a new object that inherits from this object.
+ *
+ * @param {Object} overrides Properties to copy into the new object.
+ *
+ * @return {Object} The new object.
+ *
+ * @static
+ *
+ * @example
+ *
+ * var MyType = CryptoJS.lib.Base.extend({
+ * field: 'value',
+ *
+ * method: function () {
+ * }
+ * });
+ */
+ extend: function (overrides) {
+ // Spawn
+ var subtype = create(this);
+
+ // Augment
+ if (overrides) {
+ subtype.mixIn(overrides);
+ }
+
+ // Create default initializer
+ if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {
+ subtype.init = function () {
+ subtype.$super.init.apply(this, arguments);
+ };
+ }
+
+ // Initializer's prototype is the subtype object
+ subtype.init.prototype = subtype;
+
+ // Reference supertype
+ subtype.$super = this;
+
+ return subtype;
+ },
+
+ /**
+ * Extends this object and runs the init method.
+ * Arguments to create() will be passed to init().
+ *
+ * @return {Object} The new object.
+ *
+ * @static
+ *
+ * @example
+ *
+ * var instance = MyType.create();
+ */
+ create: function () {
+ var instance = this.extend();
+ instance.init.apply(instance, arguments);
+
+ return instance;
+ },
+
+ /**
+ * Initializes a newly created object.
+ * Override this method to add some logic when your objects are created.
+ *
+ * @example
+ *
+ * var MyType = CryptoJS.lib.Base.extend({
+ * init: function () {
+ * // ...
+ * }
+ * });
+ */
+ init: function () {
+ },
+
+ /**
+ * Copies properties into this object.
+ *
+ * @param {Object} properties The properties to mix in.
+ *
+ * @example
+ *
+ * MyType.mixIn({
+ * field: 'value'
+ * });
+ */
+ mixIn: function (properties) {
+ for (var propertyName in properties) {
+ if (properties.hasOwnProperty(propertyName)) {
+ this[propertyName] = properties[propertyName];
+ }
+ }
+
+ // IE won't copy toString using the loop above
+ if (properties.hasOwnProperty('toString')) {
+ this.toString = properties.toString;
+ }
+ },
+
+ /**
+ * Creates a copy of this object.
+ *
+ * @return {Object} The clone.
+ *
+ * @example
+ *
+ * var clone = instance.clone();
+ */
+ clone: function () {
+ return this.init.prototype.extend(this);
+ }
+ };
+ }());
+
+ /**
+ * An array of 32-bit words.
+ *
+ * @property {Array} words The array of 32-bit words.
+ * @property {number} sigBytes The number of significant bytes in this word array.
+ */
+ var WordArray = C_lib.WordArray = Base.extend({
+ /**
+ * Initializes a newly created word array.
+ *
+ * @param {Array} words (Optional) An array of 32-bit words.
+ * @param {number} sigBytes (Optional) The number of significant bytes in the words.
+ *
+ * @example
+ *
+ * var wordArray = CryptoJS.lib.WordArray.create();
+ * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
+ * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
+ */
+ init: function (words, sigBytes) {
+ words = this.words = words || [];
+
+ if (sigBytes != undefined) {
+ this.sigBytes = sigBytes;
+ } else {
+ this.sigBytes = words.length * 4;
+ }
+ },
+
+ /**
+ * Converts this word array to a string.
+ *
+ * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
+ *
+ * @return {string} The stringified word array.
+ *
+ * @example
+ *
+ * var string = wordArray + '';
+ * var string = wordArray.toString();
+ * var string = wordArray.toString(CryptoJS.enc.Utf8);
+ */
+ toString: function (encoder) {
+ return (encoder || Hex).stringify(this);
+ },
+
+ /**
+ * Concatenates a word array to this word array.
+ *
+ * @param {WordArray} wordArray The word array to append.
+ *
+ * @return {WordArray} This word array.
+ *
+ * @example
+ *
+ * wordArray1.concat(wordArray2);
+ */
+ concat: function (wordArray) {
+ // Shortcuts
+ var thisWords = this.words;
+ var thatWords = wordArray.words;
+ var thisSigBytes = this.sigBytes;
+ var thatSigBytes = wordArray.sigBytes;
+
+ // Clamp excess bits
+ this.clamp();
+
+ // Concat
+ if (thisSigBytes % 4) {
+ // Copy one byte at a time
+ for (var i = 0; i < thatSigBytes; i++) {
+ var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+ thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
+ }
+ } else {
+ // Copy one word at a time
+ for (var i = 0; i < thatSigBytes; i += 4) {
+ thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];
+ }
+ }
+ this.sigBytes += thatSigBytes;
+
+ // Chainable
+ return this;
+ },
+
+ /**
+ * Removes insignificant bits.
+ *
+ * @example
+ *
+ * wordArray.clamp();
+ */
+ clamp: function () {
+ // Shortcuts
+ var words = this.words;
+ var sigBytes = this.sigBytes;
+
+ // Clamp
+ words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
+ words.length = Math.ceil(sigBytes / 4);
+ },
+
+ /**
+ * Creates a copy of this word array.
+ *
+ * @return {WordArray} The clone.
+ *
+ * @example
+ *
+ * var clone = wordArray.clone();
+ */
+ clone: function () {
+ var clone = Base.clone.call(this);
+ clone.words = this.words.slice(0);
+
+ return clone;
+ },
+
+ /**
+ * Creates a word array filled with random bytes.
+ *
+ * @param {number} nBytes The number of random bytes to generate.
+ *
+ * @return {WordArray} The random word array.
+ *
+ * @static
+ *
+ * @example
+ *
+ * var wordArray = CryptoJS.lib.WordArray.random(16);
+ */
+ random: function (nBytes) {
+ var words = [];
+
+ var r = (function (m_w) {
+ var m_w = m_w;
+ var m_z = 0x3ade68b1;
+ var mask = 0xffffffff;
+
+ return function () {
+ m_z = (0x9069 * (m_z & 0xFFFF) + (m_z >> 0x10)) & mask;
+ m_w = (0x4650 * (m_w & 0xFFFF) + (m_w >> 0x10)) & mask;
+ var result = ((m_z << 0x10) + m_w) & mask;
+ result /= 0x100000000;
+ result += 0.5;
+ return result * (Math.random() > .5 ? 1 : -1);
+ }
+ });
+
+ for (var i = 0, rcache; i < nBytes; i += 4) {
+ var _r = r((rcache || Math.random()) * 0x100000000);
+
+ rcache = _r() * 0x3ade67b7;
+ words.push((_r() * 0x100000000) | 0);
+ }
+
+ return new WordArray.init(words, nBytes);
+ }
+ });
+
+ /**
+ * Encoder namespace.
+ */
+ var C_enc = C.enc = {};
+
+ /**
+ * Hex encoding strategy.
+ */
+ var Hex = C_enc.Hex = {
+ /**
+ * Converts a word array to a hex string.
+ *
+ * @param {WordArray} wordArray The word array.
+ *
+ * @return {string} The hex string.
+ *
+ * @static
+ *
+ * @example
+ *
+ * var hexString = CryptoJS.enc.Hex.stringify(wordArray);
+ */
+ stringify: function (wordArray) {
+ // Shortcuts
+ var words = wordArray.words;
+ var sigBytes = wordArray.sigBytes;
+
+ // Convert
+ var hexChars = [];
+ for (var i = 0; i < sigBytes; i++) {
+ var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+ hexChars.push((bite >>> 4).toString(16));
+ hexChars.push((bite & 0x0f).toString(16));
+ }
+
+ return hexChars.join('');
+ },
+
+ /**
+ * Converts a hex string to a word array.
+ *
+ * @param {string} hexStr The hex string.
+ *
+ * @return {WordArray} The word array.
+ *
+ * @static
+ *
+ * @example
+ *
+ * var wordArray = CryptoJS.enc.Hex.parse(hexString);
+ */
+ parse: function (hexStr) {
+ // Shortcut
+ var hexStrLength = hexStr.length;
+
+ // Convert
+ var words = [];
+ for (var i = 0; i < hexStrLength; i += 2) {
+ words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
+ }
+
+ return new WordArray.init(words, hexStrLength / 2);
+ }
+ };
+
+ /**
+ * Latin1 encoding strategy.
+ */
+ var Latin1 = C_enc.Latin1 = {
+ /**
+ * Converts a word array to a Latin1 string.
+ *
+ * @param {WordArray} wordArray The word array.
+ *
+ * @return {string} The Latin1 string.
+ *
+ * @static
+ *
+ * @example
+ *
+ * var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
+ */
+ stringify: function (wordArray) {
+ // Shortcuts
+ var words = wordArray.words;
+ var sigBytes = wordArray.sigBytes;
+
+ // Convert
+ var latin1Chars = [];
+ for (var i = 0; i < sigBytes; i++) {
+ var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+ latin1Chars.push(String.fromCharCode(bite));
+ }
+
+ return latin1Chars.join('');
+ },
+
+ /**
+ * Converts a Latin1 string to a word array.
+ *
+ * @param {string} latin1Str The Latin1 string.
+ *
+ * @return {WordArray} The word array.
+ *
+ * @static
+ *
+ * @example
+ *
+ * var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
+ */
+ parse: function (latin1Str) {
+ // Shortcut
+ var latin1StrLength = latin1Str.length;
+
+ // Convert
+ var words = [];
+ for (var i = 0; i < latin1StrLength; i++) {
+ words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
+ }
+
+ return new WordArray.init(words, latin1StrLength);
+ }
+ };
+
+ /**
+ * UTF-8 encoding strategy.
+ */
+ var Utf8 = C_enc.Utf8 = {
+ /**
+ * Converts a word array to a UTF-8 string.
+ *
+ * @param {WordArray} wordArray The word array.
+ *
+ * @return {string} The UTF-8 string.
+ *
+ * @static
+ *
+ * @example
+ *
+ * var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
+ */
+ stringify: function (wordArray) {
+ try {
+ return decodeURIComponent(escape(Latin1.stringify(wordArray)));
+ } catch (e) {
+ throw new Error('Malformed UTF-8 data');
+ }
+ },
+
+ /**
+ * Converts a UTF-8 string to a word array.
+ *
+ * @param {string} utf8Str The UTF-8 string.
+ *
+ * @return {WordArray} The word array.
+ *
+ * @static
+ *
+ * @example
+ *
+ * var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
+ */
+ parse: function (utf8Str) {
+ return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
+ }
+ };
+
+ /**
+ * Abstract buffered block algorithm template.
+ *
+ * The property blockSize must be implemented in a concrete subtype.
+ *
+ * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
+ */
+ var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
+ /**
+ * Resets this block algorithm's data buffer to its initial state.
+ *
+ * @example
+ *
+ * bufferedBlockAlgorithm.reset();
+ */
+ reset: function () {
+ // Initial values
+ this._data = new WordArray.init();
+ this._nDataBytes = 0;
+ },
+
+ /**
+ * Adds new data to this block algorithm's buffer.
+ *
+ * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
+ *
+ * @example
+ *
+ * bufferedBlockAlgorithm._append('data');
+ * bufferedBlockAlgorithm._append(wordArray);
+ */
+ _append: function (data) {
+ // Convert string to WordArray, else assume WordArray already
+ if (typeof data == 'string') {
+ data = Utf8.parse(data);
+ }
+
+ // Append
+ this._data.concat(data);
+ this._nDataBytes += data.sigBytes;
+ },
+
+ /**
+ * Processes available data blocks.
+ *
+ * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
+ *
+ * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
+ *
+ * @return {WordArray} The processed data.
+ *
+ * @example
+ *
+ * var processedData = bufferedBlockAlgorithm._process();
+ * var processedData = bufferedBlockAlgorithm._process(!!'flush');
+ */
+ _process: function (doFlush) {
+ // Shortcuts
+ var data = this._data;
+ var dataWords = data.words;
+ var dataSigBytes = data.sigBytes;
+ var blockSize = this.blockSize;
+ var blockSizeBytes = blockSize * 4;
+
+ // Count blocks ready
+ var nBlocksReady = dataSigBytes / blockSizeBytes;
+ if (doFlush) {
+ // Round up to include partial blocks
+ nBlocksReady = Math.ceil(nBlocksReady);
+ } else {
+ // Round down to include only full blocks,
+ // less the number of blocks that must remain in the buffer
+ nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
+ }
+
+ // Count words ready
+ var nWordsReady = nBlocksReady * blockSize;
+
+ // Count bytes ready
+ var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
+
+ // Process blocks
+ if (nWordsReady) {
+ for (var offset = 0; offset < nWordsReady; offset += blockSize) {
+ // Perform concrete-algorithm logic
+ this._doProcessBlock(dataWords, offset);
+ }
+
+ // Remove processed words
+ var processedWords = dataWords.splice(0, nWordsReady);
+ data.sigBytes -= nBytesReady;
+ }
+
+ // Return processed words
+ return new WordArray.init(processedWords, nBytesReady);
+ },
+
+ /**
+ * Creates a copy of this object.
+ *
+ * @return {Object} The clone.
+ *
+ * @example
+ *
+ * var clone = bufferedBlockAlgorithm.clone();
+ */
+ clone: function () {
+ var clone = Base.clone.call(this);
+ clone._data = this._data.clone();
+
+ return clone;
+ },
+
+ _minBufferSize: 0
+ });
+
+ /**
+ * Abstract hasher template.
+ *
+ * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)
+ */
+ var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
+ /**
+ * Configuration options.
+ */
+ cfg: Base.extend(),
+
+ /**
+ * Initializes a newly created hasher.
+ *
+ * @param {Object} cfg (Optional) The configuration options to use for this hash computation.
+ *
+ * @example
+ *
+ * var hasher = CryptoJS.algo.SHA256.create();
+ */
+ init: function (cfg) {
+ // Apply config defaults
+ this.cfg = this.cfg.extend(cfg);
+
+ // Set initial values
+ this.reset();
+ },
+
+ /**
+ * Resets this hasher to its initial state.
+ *
+ * @example
+ *
+ * hasher.reset();
+ */
+ reset: function () {
+ // Reset data buffer
+ BufferedBlockAlgorithm.reset.call(this);
+
+ // Perform concrete-hasher logic
+ this._doReset();
+ },
+
+ /**
+ * Updates this hasher with a message.
+ *
+ * @param {WordArray|string} messageUpdate The message to append.
+ *
+ * @return {Hasher} This hasher.
+ *
+ * @example
+ *
+ * hasher.update('message');
+ * hasher.update(wordArray);
+ */
+ update: function (messageUpdate) {
+ // Append
+ this._append(messageUpdate);
+
+ // Update the hash
+ this._process();
+
+ // Chainable
+ return this;
+ },
+
+ /**
+ * Finalizes the hash computation.
+ * Note that the finalize operation is effectively a destructive, read-once operation.
+ *
+ * @param {WordArray|string} messageUpdate (Optional) A final message update.
+ *
+ * @return {WordArray} The hash.
+ *
+ * @example
+ *
+ * var hash = hasher.finalize();
+ * var hash = hasher.finalize('message');
+ * var hash = hasher.finalize(wordArray);
+ */
+ finalize: function (messageUpdate) {
+ // Final message update
+ if (messageUpdate) {
+ this._append(messageUpdate);
+ }
+
+ // Perform concrete-hasher logic
+ var hash = this._doFinalize();
+
+ return hash;
+ },
+
+ blockSize: 512/32,
+
+ /**
+ * Creates a shortcut function to a hasher's object interface.
+ *
+ * @param {Hasher} hasher The hasher to create a helper for.
+ *
+ * @return {Function} The shortcut function.
+ *
+ * @static
+ *
+ * @example
+ *
+ * var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
+ */
+ _createHelper: function (hasher) {
+ return function (message, cfg) {
+ return new hasher.init(cfg).finalize(message);
+ };
+ },
+
+ /**
+ * Creates a shortcut function to the HMAC's object interface.
+ *
+ * @param {Hasher} hasher The hasher to use in this HMAC helper.
+ *
+ * @return {Function} The shortcut function.
+ *
+ * @static
+ *
+ * @example
+ *
+ * var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
+ */
+ _createHmacHelper: function (hasher) {
+ return function (message, key) {
+ return new C_algo.HMAC.init(hasher, key).finalize(message);
+ };
+ }
+ });
+
+ /**
+ * Algorithm namespace.
+ */
+ var C_algo = C.algo = {};
+
+ return C;
+ }(Math));
+
+
+ return CryptoJS;
+
+}));
+},{}],157:[function(_dereq_,module,exports){
+;(function (root, factory, undef) {
+ if (typeof exports === "object") {
+ // CommonJS
+ module.exports = exports = factory(_dereq_(156), _dereq_(159), _dereq_(158));
+ }
+ else if (typeof define === "function" && define.amd) {
+ // AMD
+ define(["./core", "./sha1", "./hmac"], factory);
+ }
+ else {
+ // Global (browser)
+ factory(root.CryptoJS);
+ }
+}(this, function (CryptoJS) {
+
+ return CryptoJS.HmacSHA1;
+
+}));
+},{"156":156,"158":158,"159":159}],158:[function(_dereq_,module,exports){
+;(function (root, factory) {
+ if (typeof exports === "object") {
+ // CommonJS
+ module.exports = exports = factory(_dereq_(156));
+ }
+ else if (typeof define === "function" && define.amd) {
+ // AMD
+ define(["./core"], factory);
+ }
+ else {
+ // Global (browser)
+ factory(root.CryptoJS);
+ }
+}(this, function (CryptoJS) {
+
+ (function () {
+ // Shortcuts
+ var C = CryptoJS;
+ var C_lib = C.lib;
+ var Base = C_lib.Base;
+ var C_enc = C.enc;
+ var Utf8 = C_enc.Utf8;
+ var C_algo = C.algo;
+
+ /**
+ * HMAC algorithm.
+ */
+ var HMAC = C_algo.HMAC = Base.extend({
+ /**
+ * Initializes a newly created HMAC.
+ *
+ * @param {Hasher} hasher The hash algorithm to use.
+ * @param {WordArray|string} key The secret key.
+ *
+ * @example
+ *
+ * var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);
+ */
+ init: function (hasher, key) {
+ // Init hasher
+ hasher = this._hasher = new hasher.init();
+
+ // Convert string to WordArray, else assume WordArray already
+ if (typeof key == 'string') {
+ key = Utf8.parse(key);
+ }
+
+ // Shortcuts
+ var hasherBlockSize = hasher.blockSize;
+ var hasherBlockSizeBytes = hasherBlockSize * 4;
+
+ // Allow arbitrary length keys
+ if (key.sigBytes > hasherBlockSizeBytes) {
+ key = hasher.finalize(key);
+ }
+
+ // Clamp excess bits
+ key.clamp();
+
+ // Clone key for inner and outer pads
+ var oKey = this._oKey = key.clone();
+ var iKey = this._iKey = key.clone();
+
+ // Shortcuts
+ var oKeyWords = oKey.words;
+ var iKeyWords = iKey.words;
+
+ // XOR keys with pad constants
+ for (var i = 0; i < hasherBlockSize; i++) {
+ oKeyWords[i] ^= 0x5c5c5c5c;
+ iKeyWords[i] ^= 0x36363636;
+ }
+ oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;
+
+ // Set initial values
+ this.reset();
+ },
+
+ /**
+ * Resets this HMAC to its initial state.
+ *
+ * @example
+ *
+ * hmacHasher.reset();
+ */
+ reset: function () {
+ // Shortcut
+ var hasher = this._hasher;
+
+ // Reset
+ hasher.reset();
+ hasher.update(this._iKey);
+ },
+
+ /**
+ * Updates this HMAC with a message.
+ *
+ * @param {WordArray|string} messageUpdate The message to append.
+ *
+ * @return {HMAC} This HMAC instance.
+ *
+ * @example
+ *
+ * hmacHasher.update('message');
+ * hmacHasher.update(wordArray);
+ */
+ update: function (messageUpdate) {
+ this._hasher.update(messageUpdate);
+
+ // Chainable
+ return this;
+ },
+
+ /**
+ * Finalizes the HMAC computation.
+ * Note that the finalize operation is effectively a destructive, read-once operation.
+ *
+ * @param {WordArray|string} messageUpdate (Optional) A final message update.
+ *
+ * @return {WordArray} The HMAC.
+ *
+ * @example
+ *
+ * var hmac = hmacHasher.finalize();
+ * var hmac = hmacHasher.finalize('message');
+ * var hmac = hmacHasher.finalize(wordArray);
+ */
+ finalize: function (messageUpdate) {
+ // Shortcut
+ var hasher = this._hasher;
+
+ // Compute HMAC
+ var innerHash = hasher.finalize(messageUpdate);
+ hasher.reset();
+ var hmac = hasher.finalize(this._oKey.clone().concat(innerHash));
+
+ return hmac;
+ }
+ });
+ }());
+
+
+}));
+},{"156":156}],159:[function(_dereq_,module,exports){
+;(function (root, factory) {
+ if (typeof exports === "object") {
+ // CommonJS
+ module.exports = exports = factory(_dereq_(156));
+ }
+ else if (typeof define === "function" && define.amd) {
+ // AMD
+ define(["./core"], factory);
+ }
+ else {
+ // Global (browser)
+ factory(root.CryptoJS);
+ }
+}(this, function (CryptoJS) {
+
+ (function () {
+ // Shortcuts
+ var C = CryptoJS;
+ var C_lib = C.lib;
+ var WordArray = C_lib.WordArray;
+ var Hasher = C_lib.Hasher;
+ var C_algo = C.algo;
+
+ // Reusable object
+ var W = [];
+
+ /**
+ * SHA-1 hash algorithm.
+ */
+ var SHA1 = C_algo.SHA1 = Hasher.extend({
+ _doReset: function () {
+ this._hash = new WordArray.init([
+ 0x67452301, 0xefcdab89,
+ 0x98badcfe, 0x10325476,
+ 0xc3d2e1f0
+ ]);
+ },
+
+ _doProcessBlock: function (M, offset) {
+ // Shortcut
+ var H = this._hash.words;
+
+ // Working variables
+ var a = H[0];
+ var b = H[1];
+ var c = H[2];
+ var d = H[3];
+ var e = H[4];
+
+ // Computation
+ for (var i = 0; i < 80; i++) {
+ if (i < 16) {
+ W[i] = M[offset + i] | 0;
+ } else {
+ var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
+ W[i] = (n << 1) | (n >>> 31);
+ }
+
+ var t = ((a << 5) | (a >>> 27)) + e + W[i];
+ if (i < 20) {
+ t += ((b & c) | (~b & d)) + 0x5a827999;
+ } else if (i < 40) {
+ t += (b ^ c ^ d) + 0x6ed9eba1;
+ } else if (i < 60) {
+ t += ((b & c) | (b & d) | (c & d)) - 0x70e44324;
+ } else /* if (i < 80) */ {
+ t += (b ^ c ^ d) - 0x359d3e2a;
+ }
+
+ e = d;
+ d = c;
+ c = (b << 30) | (b >>> 2);
+ b = a;
+ a = t;
+ }
+
+ // Intermediate hash value
+ H[0] = (H[0] + a) | 0;
+ H[1] = (H[1] + b) | 0;
+ H[2] = (H[2] + c) | 0;
+ H[3] = (H[3] + d) | 0;
+ H[4] = (H[4] + e) | 0;
+ },
+
+ _doFinalize: function () {
+ // Shortcuts
+ var data = this._data;
+ var dataWords = data.words;
+
+ var nBitsTotal = this._nDataBytes * 8;
+ var nBitsLeft = data.sigBytes * 8;
+
+ // Add padding
+ dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
+ dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
+ dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;
+ data.sigBytes = dataWords.length * 4;
+
+ // Hash final blocks
+ this._process();
+
+ // Return final computed hash
+ return this._hash;
+ },
+
+ clone: function () {
+ var clone = Hasher.clone.call(this);
+ clone._hash = this._hash.clone();
+
+ return clone;
+ }
+ });
+
+ /**
+ * Shortcut function to the hasher's object interface.
+ *
+ * @param {WordArray|string} message The message to hash.
+ *
+ * @return {WordArray} The hash.
+ *
+ * @static
+ *
+ * @example
+ *
+ * var hash = CryptoJS.SHA1('message');
+ * var hash = CryptoJS.SHA1(wordArray);
+ */
+ C.SHA1 = Hasher._createHelper(SHA1);
+
+ /**
+ * Shortcut function to the HMAC's object interface.
+ *
+ * @param {WordArray|string} message The message to hash.
+ * @param {WordArray|string} key The secret key.
+ *
+ * @return {WordArray} The HMAC.
+ *
+ * @static
+ *
+ * @example
+ *
+ * var hmac = CryptoJS.HmacSHA1(message, key);
+ */
+ C.HmacSHA1 = Hasher._createHmacHelper(SHA1);
+ }());
+
+
+ return CryptoJS.SHA1;
+
+}));
+},{"156":156}],160:[function(_dereq_,module,exports){
+// uuid.js
+//
+// Copyright (c) 2010-2012 Robert Kieffer
+// MIT License - http://opensource.org/licenses/mit-license.php
+
+/*global window, require, define */
+(function(_window) {
+ 'use strict';
+
+ // Unique ID creation requires a high quality random # generator. We feature
+ // detect to determine the best RNG source, normalizing to a function that
+ // returns 128-bits of randomness, since that's what's usually required
+ var _rng, _mathRNG, _nodeRNG, _whatwgRNG, _previousRoot;
+
+ function setupBrowser() {
+ // Allow for MSIE11 msCrypto
+ var _crypto = _window.crypto || _window.msCrypto;
+
+ if (!_rng && _crypto && _crypto.getRandomValues) {
+ // WHATWG crypto-based RNG - http://wiki.whatwg.org/wiki/Crypto
+ //
+ // Moderately fast, high quality
+ try {
+ var _rnds8 = new Uint8Array(16);
+ _whatwgRNG = _rng = function whatwgRNG() {
+ _crypto.getRandomValues(_rnds8);
+ return _rnds8;
+ };
+ _rng();
+ } catch(e) {}
+ }
+
+ if (!_rng) {
+ // Math.random()-based (RNG)
+ //
+ // If all else fails, use Math.random(). It's fast, but is of unspecified
+ // quality.
+ var _rnds = new Array(16);
+ _mathRNG = _rng = function() {
+ for (var i = 0, r; i < 16; i++) {
+ if ((i & 0x03) === 0) { r = Math.random() * 0x100000000; }
+ _rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
+ }
+
+ return _rnds;
+ };
+ if ('undefined' !== typeof console && console.warn) {
+ console.warn("[SECURITY] node-uuid: crypto not usable, falling back to insecure Math.random()");
+ }
+ }
+ }
+
+ function setupNode() {
+ // Node.js crypto-based RNG - http://nodejs.org/docs/v0.6.2/api/crypto.html
+ //
+ // Moderately fast, high quality
+ if ('function' === typeof _dereq_) {
+ try {
+ var _rb = _dereq_('crypto').randomBytes;
+ _nodeRNG = _rng = _rb && function() {return _rb(16);};
+ _rng();
+ } catch(e) {}
+ }
+ }
+
+ if (_window) {
+ setupBrowser();
+ } else {
+ setupNode();
+ }
+
+ // Buffer class to use
+ var BufferClass = ('function' === typeof Buffer) ? Buffer : Array;
+
+ // Maps for number <-> hex string conversion
+ var _byteToHex = [];
+ var _hexToByte = {};
+ for (var i = 0; i < 256; i++) {
+ _byteToHex[i] = (i + 0x100).toString(16).substr(1);
+ _hexToByte[_byteToHex[i]] = i;
+ }
+
+ // **`parse()` - Parse a UUID into it's component bytes**
+ function parse(s, buf, offset) {
+ var i = (buf && offset) || 0, ii = 0;
+
+ buf = buf || [];
+ s.toLowerCase().replace(/[0-9a-f]{2}/g, function(oct) {
+ if (ii < 16) { // Don't overflow!
+ buf[i + ii++] = _hexToByte[oct];
+ }
+ });
+
+ // Zero out remaining bytes if string was short
+ while (ii < 16) {
+ buf[i + ii++] = 0;
+ }
+
+ return buf;
+ }
+
+ // **`unparse()` - Convert UUID byte array (ala parse()) into a string**
+ function unparse(buf, offset) {
+ var i = offset || 0, bth = _byteToHex;
+ return bth[buf[i++]] + bth[buf[i++]] +
+ bth[buf[i++]] + bth[buf[i++]] + '-' +
+ bth[buf[i++]] + bth[buf[i++]] + '-' +
+ bth[buf[i++]] + bth[buf[i++]] + '-' +
+ bth[buf[i++]] + bth[buf[i++]] + '-' +
+ bth[buf[i++]] + bth[buf[i++]] +
+ bth[buf[i++]] + bth[buf[i++]] +
+ bth[buf[i++]] + bth[buf[i++]];
+ }
+
+ // **`v1()` - Generate time-based UUID**
+ //
+ // Inspired by https://github.com/LiosK/UUID.js
+ // and http://docs.python.org/library/uuid.html
+
+ // random #'s we need to init node and clockseq
+ var _seedBytes = _rng();
+
+ // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
+ var _nodeId = [
+ _seedBytes[0] | 0x01,
+ _seedBytes[1], _seedBytes[2], _seedBytes[3], _seedBytes[4], _seedBytes[5]
+ ];
+
+ // Per 4.2.2, randomize (14 bit) clockseq
+ var _clockseq = (_seedBytes[6] << 8 | _seedBytes[7]) & 0x3fff;
+
+ // Previous uuid creation time
+ var _lastMSecs = 0, _lastNSecs = 0;
+
+ // See https://github.com/broofa/node-uuid for API details
+ function v1(options, buf, offset) {
+ var i = buf && offset || 0;
+ var b = buf || [];
+
+ options = options || {};
+
+ var clockseq = (options.clockseq != null) ? options.clockseq : _clockseq;
+
+ // UUID timestamps are 100 nano-second units since the Gregorian epoch,
+ // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so
+ // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
+ // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
+ var msecs = (options.msecs != null) ? options.msecs : new Date().getTime();
+
+ // Per 4.2.1.2, use count of uuid's generated during the current clock
+ // cycle to simulate higher resolution clock
+ var nsecs = (options.nsecs != null) ? options.nsecs : _lastNSecs + 1;
+
+ // Time since last uuid creation (in msecs)
+ var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000;
+
+ // Per 4.2.1.2, Bump clockseq on clock regression
+ if (dt < 0 && options.clockseq == null) {
+ clockseq = clockseq + 1 & 0x3fff;
+ }
+
+ // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
+ // time interval
+ if ((dt < 0 || msecs > _lastMSecs) && options.nsecs == null) {
+ nsecs = 0;
+ }
+
+ // Per 4.2.1.2 Throw error if too many uuids are requested
+ if (nsecs >= 10000) {
+ throw new Error('uuid.v1(): Can\'t create more than 10M uuids/sec');
+ }
+
+ _lastMSecs = msecs;
+ _lastNSecs = nsecs;
+ _clockseq = clockseq;
+
+ // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
+ msecs += 12219292800000;
+
+ // `time_low`
+ var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
+ b[i++] = tl >>> 24 & 0xff;
+ b[i++] = tl >>> 16 & 0xff;
+ b[i++] = tl >>> 8 & 0xff;
+ b[i++] = tl & 0xff;
+
+ // `time_mid`
+ var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
+ b[i++] = tmh >>> 8 & 0xff;
+ b[i++] = tmh & 0xff;
+
+ // `time_high_and_version`
+ b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
+ b[i++] = tmh >>> 16 & 0xff;
+
+ // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
+ b[i++] = clockseq >>> 8 | 0x80;
+
+ // `clock_seq_low`
+ b[i++] = clockseq & 0xff;
+
+ // `node`
+ var node = options.node || _nodeId;
+ for (var n = 0; n < 6; n++) {
+ b[i + n] = node[n];
+ }
+
+ return buf ? buf : unparse(b);
+ }
+
+ // **`v4()` - Generate random UUID**
+
+ // See https://github.com/broofa/node-uuid for API details
+ function v4(options, buf, offset) {
+ // Deprecated - 'format' argument, as supported in v1.2
+ var i = buf && offset || 0;
+
+ if (typeof(options) === 'string') {
+ buf = (options === 'binary') ? new BufferClass(16) : null;
+ options = null;
+ }
+ options = options || {};
+
+ var rnds = options.random || (options.rng || _rng)();
+
+ // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+ rnds[6] = (rnds[6] & 0x0f) | 0x40;
+ rnds[8] = (rnds[8] & 0x3f) | 0x80;
+
+ // Copy bytes to buffer, if provided
+ if (buf) {
+ for (var ii = 0; ii < 16; ii++) {
+ buf[i + ii] = rnds[ii];
+ }
+ }
+
+ return buf || unparse(rnds);
+ }
+
+ // Export public API
+ var uuid = v4;
+ uuid.v1 = v1;
+ uuid.v4 = v4;
+ uuid.parse = parse;
+ uuid.unparse = unparse;
+ uuid.BufferClass = BufferClass;
+ uuid._rng = _rng;
+ uuid._mathRNG = _mathRNG;
+ uuid._nodeRNG = _nodeRNG;
+ uuid._whatwgRNG = _whatwgRNG;
+
+ if (('undefined' !== typeof module) && module.exports) {
+ // Publish as node.js module
+ module.exports = uuid;
+ } else if (typeof define === 'function' && define.amd) {
+ // Publish as AMD module
+ define(function() {return uuid;});
+
+
+ } else {
+ // Publish as global (in browsers)
+ _previousRoot = _window.uuid;
+
+ // **`noConflict()` - (browser only) to reset global 'uuid' var**
+ uuid.noConflict = function() {
+ _window.uuid = _previousRoot;
+ return uuid;
+ };
+
+ _window.uuid = uuid;
+ }
+})('undefined' !== typeof window ? window : null);
+
+},{"undefined":undefined}],161:[function(_dereq_,module,exports){
+/*!
+ * depd
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+'use strict'
+
+/**
+ * Module exports.
+ * @public
+ */
+
+module.exports = depd
+
+/**
+ * Create deprecate for namespace in caller.
+ */
+
+function depd(namespace) {
+ if (!namespace) {
+ throw new TypeError('argument namespace is required')
+ }
+
+ function deprecate(message) {
+ // no-op in browser
+ }
+
+ deprecate._file = undefined
+ deprecate._ignored = true
+ deprecate._namespace = namespace
+ deprecate._traced = false
+ deprecate._warned = Object.create(null)
+
+ deprecate.function = wrapfunction
+ deprecate.property = wrapproperty
+
+ return deprecate
+}
+
+/**
+ * Return a wrapped function in a deprecation message.
+ *
+ * This is a no-op version of the wrapper, which does nothing but call
+ * validation.
+ */
+
+function wrapfunction(fn, message) {
+ if (typeof fn !== 'function') {
+ throw new TypeError('argument fn must be a function')
+ }
+
+ return fn
+}
+
+/**
+ * Wrap property in a deprecation message.
+ *
+ * This is a no-op version of the wrapper, which does nothing but call
+ * validation.
+ */
+
+function wrapproperty(obj, prop, message) {
+ if (!obj || (typeof obj !== 'object' && typeof obj !== 'function')) {
+ throw new TypeError('argument obj must be object')
+ }
+
+ var descriptor = Object.getOwnPropertyDescriptor(obj, prop)
+
+ if (!descriptor) {
+ throw new TypeError('must call property on owner object')
+ }
+
+ if (!descriptor.configurable) {
+ throw new TypeError('property must be configurable')
+ }
+
+ return
+}
+
+},{}],162:[function(_dereq_,module,exports){
+/*!
+ * Copyright (c) 2015 Chris O'Hara
+ *
+ * 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 (name, definition) {
+ if (typeof exports !== 'undefined' && typeof module !== 'undefined') {
+ module.exports = definition();
+ } else if (typeof define === 'function' && typeof define.amd === 'object') {
+ define(definition);
+ } else if (typeof define === 'function' && typeof define.petal === 'object') {
+ define(name, [], definition);
+ } else {
+ this[name] = definition();
+ }
+})('validator', function (validator) {
+
+ 'use strict';
+
+ validator = { version: '4.9.0', coerce: true };
+
+ var emailUserPart = /^[a-z\d!#\$%&'\*\+\-\/=\?\^_`{\|}~]+$/i;
+ var quotedEmailUser = /^([\s\x01-\x08\x0b\x0c\x0e-\x1f\x7f\x21\x23-\x5b\x5d-\x7e]|(\\[\x01-\x09\x0b\x0c\x0d-\x7f]))*$/i;
+
+ var emailUserUtf8Part = /^[a-z\d!#\$%&'\*\+\-\/=\?\^_`{\|}~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+$/i;
+ var quotedEmailUserUtf8 = /^([\s\x01-\x08\x0b\x0c\x0e-\x1f\x7f\x21\x23-\x5b\x5d-\x7e\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|(\\[\x01-\x09\x0b\x0c\x0d-\x7f\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))*$/i;
+
+ var displayName = /^[a-z\d!#\$%&'\*\+\-\/=\?\^_`{\|}~\.\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+[a-z\d!#\$%&'\*\+\-\/=\?\^_`{\|}~\.\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\s]*<(.+)>$/i;
+
+ var creditCard = /^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\d{3})\d{11})$/;
+
+ var isin = /^[A-Z]{2}[0-9A-Z]{9}[0-9]$/;
+
+ var isbn10Maybe = /^(?:[0-9]{9}X|[0-9]{10})$/
+ , isbn13Maybe = /^(?:[0-9]{13})$/;
+
+ var macAddress = /^([0-9a-fA-F][0-9a-fA-F]:){5}([0-9a-fA-F][0-9a-fA-F])$/;
+
+ var ipv4Maybe = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/
+ , ipv6Block = /^[0-9A-F]{1,4}$/i;
+
+ var uuid = {
+ '3': /^[0-9A-F]{8}-[0-9A-F]{4}-3[0-9A-F]{3}-[0-9A-F]{4}-[0-9A-F]{12}$/i
+ , '4': /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i
+ , '5': /^[0-9A-F]{8}-[0-9A-F]{4}-5[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i
+ , all: /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i
+ };
+
+ var alpha = {
+ 'en-US': /^[A-Z]+$/i,
+ 'de-DE': /^[A-ZÄÖÜß]+$/i,
+ 'es-ES': /^[A-ZÁÉÍÑÓÚÜ]+$/i,
+ 'fr-FR': /^[A-ZÀÂÆÇÉÈÊËÏÎÔŒÙÛÜŸ]+$/i,
+ 'nl-NL': /^[A-ZÉËÏÓÖÜ]+$/i,
+ 'pt-PT': /^[A-ZÃÁÀÂÇÉÊÍÕÓÔÚÜ]+$/i,
+ 'ru-RU': /^[А-ЯЁа-яё]+$/i
+ }
+ , alphanumeric = {
+ 'en-US': /^[0-9A-Z]+$/i,
+ 'de-DE': /^[0-9A-ZÄÖÜß]+$/i,
+ 'es-ES': /^[0-9A-ZÁÉÍÑÓÚÜ]+$/i,
+ 'fr-FR': /^[0-9A-ZÀÂÆÇÉÈÊËÏÎÔŒÙÛÜŸ]+$/i,
+ 'nl-NL': /^[0-9A-ZÉËÏÓÖÜ]+$/i,
+ 'pt-PT': /^[0-9A-ZÃÁÀÂÇÉÊÍÕÓÔÚÜ]+$/i,
+ 'ru-RU': /^[0-9А-ЯЁа-яё]+$/i
+ };
+
+ var englishLocales = ['AU', 'GB', 'HK', 'IN', 'NZ', 'ZA', 'ZM'];
+ for (var locale, i = 0; i < englishLocales.length; i++) {
+ locale = 'en-' + englishLocales[i];
+ alpha[locale] = alpha['en-US'];
+ alphanumeric[locale] = alphanumeric['en-US'];
+ }
+
+ var numeric = /^[-+]?[0-9]+$/
+ , int = /^(?:[-+]?(?:0|[1-9][0-9]*))$/
+ , float = /^(?:[-+]?(?:[0-9]+))?(?:\.[0-9]*)?(?:[eE][\+\-]?(?:[0-9]+))?$/
+ , hexadecimal = /^[0-9A-F]+$/i
+ , decimal = /^[-+]?([0-9]+|\.[0-9]+|[0-9]+\.[0-9]+)$/
+ , hexcolor = /^#?([0-9A-F]{3}|[0-9A-F]{6})$/i;
+
+ var ascii = /^[\x00-\x7F]+$/
+ , multibyte = /[^\x00-\x7F]/
+ , fullWidth = /[^\u0020-\u007E\uFF61-\uFF9F\uFFA0-\uFFDC\uFFE8-\uFFEE0-9a-zA-Z]/
+ , halfWidth = /[\u0020-\u007E\uFF61-\uFF9F\uFFA0-\uFFDC\uFFE8-\uFFEE0-9a-zA-Z]/;
+
+ var surrogatePair = /[\uD800-\uDBFF][\uDC00-\uDFFF]/;
+
+ var base64 = /^(?:[A-Z0-9+\/]{4})*(?:[A-Z0-9+\/]{2}==|[A-Z0-9+\/]{3}=|[A-Z0-9+\/]{4})$/i;
+
+ var phones = {
+ 'en-US': /^(\+?1)?[2-9]\d{2}[2-9](?!11)\d{6}$/,
+ 'de-DE': /^(\+?49[ \.\-])?([\(]{1}[0-9]{1,6}[\)])?([0-9 \.\-\/]{3,20})((x|ext|extension)[ ]?[0-9]{1,4})?$/,
+ 'el-GR': /^(\+?30)?(69\d{8})$/,
+ 'en-AU': /^(\+?61|0)4\d{8}$/,
+ 'en-GB': /^(\+?44|0)7\d{9}$/,
+ 'en-HK': /^(\+?852\-?)?[569]\d{3}\-?\d{4}$/,
+ 'en-IN': /^(\+?91|0)?[789]\d{9}$/,
+ 'en-NZ': /^(\+?64|0)2\d{7,9}$/,
+ 'en-ZA': /^(\+?27|0)\d{9}$/,
+ 'en-ZM': /^(\+?26)?09[567]\d{7}$/,
+ 'es-ES': /^(\+?34)?(6\d{1}|7[1234])\d{7}$/,
+ 'fi-FI': /^(\+?358|0)\s?(4(0|1|2|4|5)?|50)\s?(\d\s?){4,8}\d$/,
+ 'fr-FR': /^(\+?33|0)[67]\d{8}$/,
+ 'nb-NO': /^(\+?47)?[49]\d{7}$/,
+ 'nn-NO': /^(\+?47)?[49]\d{7}$/,
+ 'pt-BR': /^(\+?55|0)\-?[1-9]{2}\-?[2-9]{1}\d{3,4}\-?\d{4}$/,
+ 'pt-PT': /^(\+?351)?9[1236]\d{7}$/,
+ 'ru-RU': /^(\+?7|8)?9\d{9}$/,
+ 'vi-VN': /^(\+?84|0)?((1(2([0-9])|6([2-9])|88|99))|(9((?!5)[0-9])))([0-9]{7})$/,
+ 'zh-CN': /^(\+?0?86\-?)?((13\d|14[57]|15[^4,\D]|17[678]|18\d)\d{8}|170[059]\d{7})$/,
+ 'zh-TW': /^(\+?886\-?|0)?9\d{8}$/
+ };
+
+ // from http://goo.gl/0ejHHW
+ var iso8601 = /^([\+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24\:?00)([\.,]\d+(?!:))?)?(\17[0-5]\d([\.,]\d+)?)?([zZ]|([\+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/;
+
+ validator.extend = function (name, fn) {
+ validator[name] = function () {
+ var args = Array.prototype.slice.call(arguments);
+ args[0] = validator.toString(args[0]);
+ return fn.apply(validator, args);
+ };
+ };
+
+ //Right before exporting the validator object, pass each of the builtins
+ //through extend() so that their first argument is coerced to a string
+ validator.init = function () {
+ for (var name in validator) {
+ if (typeof validator[name] !== 'function' || name === 'toString' ||
+ name === 'toDate' || name === 'extend' || name === 'init' ||
+ name === 'isServerSide') {
+ continue;
+ }
+ validator.extend(name, validator[name]);
+ }
+ };
+
+ validator.isServerSide = function () {
+ return typeof module === 'object' && module &&
+ typeof module.exports === 'object' &&
+ typeof process === 'object' &&
+ typeof _dereq_ === 'function';
+ };
+
+ var depd = null;
+ validator.deprecation = function (msg) {
+ if (depd === null) {
+ if (!validator.isServerSide()) {
+ return;
+ }
+ depd = _dereq_(161)('validator');
+ }
+ depd(msg);
+ };
+
+ validator.toString = function (input) {
+ if (typeof input !== 'string') {
+ // The library validates strings only. Currently it coerces all input to a string, but this
+ // will go away in an upcoming major version change. Print a deprecation notice for now
+ if (!validator.coerce) {
+ throw new Error('this library validates strings only');
+ }
+ validator.deprecation('you tried to validate a ' + typeof input + ' but this library ' +
+ '(validator.js) validates strings only. Please update your code as this will ' +
+ 'be an error soon.');
+ }
+ if (typeof input === 'object' && input !== null) {
+ if (typeof input.toString === 'function') {
+ input = input.toString();
+ } else {
+ input = '[object Object]';
+ }
+ } else if (input === null || typeof input === 'undefined' || (isNaN(input) && !input.length)) {
+ input = '';
+ }
+ return '' + input;
+ };
+
+ validator.toDate = function (date) {
+ if (Object.prototype.toString.call(date) === '[object Date]') {
+ return date;
+ }
+ date = Date.parse(date);
+ return !isNaN(date) ? new Date(date) : null;
+ };
+
+ validator.toFloat = function (str) {
+ return parseFloat(str);
+ };
+
+ validator.toInt = function (str, radix) {
+ return parseInt(str, radix || 10);
+ };
+
+ validator.toBoolean = function (str, strict) {
+ if (strict) {
+ return str === '1' || str === 'true';
+ }
+ return str !== '0' && str !== 'false' && str !== '';
+ };
+
+ validator.equals = function (str, comparison) {
+ return str === validator.toString(comparison);
+ };
+
+ validator.contains = function (str, elem) {
+ return str.indexOf(validator.toString(elem)) >= 0;
+ };
+
+ validator.matches = function (str, pattern, modifiers) {
+ if (Object.prototype.toString.call(pattern) !== '[object RegExp]') {
+ pattern = new RegExp(pattern, modifiers);
+ }
+ return pattern.test(str);
+ };
+
+ var default_email_options = {
+ allow_display_name: false,
+ allow_utf8_local_part: true,
+ require_tld: true
+ };
+
+ validator.isEmail = function (str, options) {
+ options = merge(options, default_email_options);
+
+ if (options.allow_display_name) {
+ var display_email = str.match(displayName);
+ if (display_email) {
+ str = display_email[1];
+ }
+ }
+
+ var parts = str.split('@')
+ , domain = parts.pop()
+ , user = parts.join('@');
+
+ var lower_domain = domain.toLowerCase();
+ if (lower_domain === 'gmail.com' || lower_domain === 'googlemail.com') {
+ user = user.replace(/\./g, '').toLowerCase();
+ }
+
+ if (!validator.isByteLength(user, {max: 64}) ||
+ !validator.isByteLength(domain, {max: 256})) {
+ return false;
+ }
+
+ if (!validator.isFQDN(domain, {require_tld: options.require_tld})) {
+ return false;
+ }
+
+ if (user[0] === '"') {
+ user = user.slice(1, user.length - 1);
+ return options.allow_utf8_local_part ?
+ quotedEmailUserUtf8.test(user) :
+ quotedEmailUser.test(user);
+ }
+
+ var pattern = options.allow_utf8_local_part ?
+ emailUserUtf8Part : emailUserPart;
+
+ var user_parts = user.split('.');
+ for (var i = 0; i < user_parts.length; i++) {
+ if (!pattern.test(user_parts[i])) {
+ return false;
+ }
+ }
+
+ return true;
+ };
+
+ var default_url_options = {
+ protocols: [ 'http', 'https', 'ftp' ]
+ , require_tld: true
+ , require_protocol: false
+ , require_valid_protocol: true
+ , allow_underscores: false
+ , allow_trailing_dot: false
+ , allow_protocol_relative_urls: false
+ };
+
+ validator.isURL = function (url, options) {
+ if (!url || url.length >= 2083 || /\s/.test(url)) {
+ return false;
+ }
+ if (url.indexOf('mailto:') === 0) {
+ return false;
+ }
+ options = merge(options, default_url_options);
+ var protocol, auth, host, hostname, port,
+ port_str, split;
+ split = url.split('://');
+ if (split.length > 1) {
+ protocol = split.shift();
+ if (options.require_valid_protocol && options.protocols.indexOf(protocol) === -1) {
+ return false;
+ }
+ } else if (options.require_protocol) {
+ return false;
+ } else if (options.allow_protocol_relative_urls && url.substr(0, 2) === '//') {
+ split[0] = url.substr(2);
+ }
+ url = split.join('://');
+ split = url.split('#');
+ url = split.shift();
+
+ split = url.split('?');
+ url = split.shift();
+
+ split = url.split('/');
+ url = split.shift();
+ split = url.split('@');
+ if (split.length > 1) {
+ auth = split.shift();
+ if (auth.indexOf(':') >= 0 && auth.split(':').length > 2) {
+ return false;
+ }
+ }
+ hostname = split.join('@');
+ split = hostname.split(':');
+ host = split.shift();
+ if (split.length) {
+ port_str = split.join(':');
+ port = parseInt(port_str, 10);
+ if (!/^[0-9]+$/.test(port_str) || port <= 0 || port > 65535) {
+ return false;
+ }
+ }
+ if (!validator.isIP(host) && !validator.isFQDN(host, options) &&
+ host !== 'localhost') {
+ return false;
+ }
+ if (options.host_whitelist &&
+ options.host_whitelist.indexOf(host) === -1) {
+ return false;
+ }
+ if (options.host_blacklist &&
+ options.host_blacklist.indexOf(host) !== -1) {
+ return false;
+ }
+ return true;
+ };
+
+ validator.isMACAddress = function (str) {
+ return macAddress.test(str);
+ };
+
+ validator.isIP = function (str, version) {
+ version = version ? version + '' : '';
+ if (!version) {
+ return validator.isIP(str, 4) || validator.isIP(str, 6);
+ } else if (version === '4') {
+ if (!ipv4Maybe.test(str)) {
+ return false;
+ }
+ var parts = str.split('.').sort(function (a, b) {
+ return a - b;
+ });
+ return parts[3] <= 255;
+ } else if (version === '6') {
+ var blocks = str.split(':');
+ var foundOmissionBlock = false; // marker to indicate ::
+
+ // At least some OS accept the last 32 bits of an IPv6 address
+ // (i.e. 2 of the blocks) in IPv4 notation, and RFC 3493 says
+ // that '::ffff:a.b.c.d' is valid for IPv4-mapped IPv6 addresses,
+ // and '::a.b.c.d' is deprecated, but also valid.
+ var foundIPv4TransitionBlock = validator.isIP(blocks[blocks.length - 1], 4);
+ var expectedNumberOfBlocks = foundIPv4TransitionBlock ? 7 : 8;
+
+ if (blocks.length > expectedNumberOfBlocks)
+ return false;
+
+ // initial or final ::
+ if (str === '::') {
+ return true;
+ } else if (str.substr(0, 2) === '::') {
+ blocks.shift();
+ blocks.shift();
+ foundOmissionBlock = true;
+ } else if (str.substr(str.length - 2) === '::') {
+ blocks.pop();
+ blocks.pop();
+ foundOmissionBlock = true;
+ }
+
+ for (var i = 0; i < blocks.length; ++i) {
+ // test for a :: which can not be at the string start/end
+ // since those cases have been handled above
+ if (blocks[i] === '' && i > 0 && i < blocks.length -1) {
+ if (foundOmissionBlock)
+ return false; // multiple :: in address
+ foundOmissionBlock = true;
+ } else if (foundIPv4TransitionBlock && i == blocks.length - 1) {
+ // it has been checked before that the last
+ // block is a valid IPv4 address
+ } else if (!ipv6Block.test(blocks[i])) {
+ return false;
+ }
+ }
+
+ if (foundOmissionBlock) {
+ return blocks.length >= 1;
+ } else {
+ return blocks.length === expectedNumberOfBlocks;
+ }
+ }
+ return false;
+ };
+
+ var default_fqdn_options = {
+ require_tld: true
+ , allow_underscores: false
+ , allow_trailing_dot: false
+ };
+
+ validator.isFQDN = function (str, options) {
+ options = merge(options, default_fqdn_options);
+
+ /* Remove the optional trailing dot before checking validity */
+ if (options.allow_trailing_dot && str[str.length - 1] === '.') {
+ str = str.substring(0, str.length - 1);
+ }
+ var parts = str.split('.');
+ if (options.require_tld) {
+ var tld = parts.pop();
+ if (!parts.length || !/^([a-z\u00a1-\uffff]{2,}|xn[a-z0-9-]{2,})$/i.test(tld)) {
+ return false;
+ }
+ }
+ for (var part, i = 0; i < parts.length; i++) {
+ part = parts[i];
+ if (options.allow_underscores) {
+ if (part.indexOf('__') >= 0) {
+ return false;
+ }
+ part = part.replace(/_/g, '');
+ }
+ if (!/^[a-z\u00a1-\uffff0-9-]+$/i.test(part)) {
+ return false;
+ }
+ if (/[\uff01-\uff5e]/.test(part)) {
+ // disallow full-width chars
+ return false;
+ }
+ if (part[0] === '-' || part[part.length - 1] === '-') {
+ return false;
+ }
+ }
+ return true;
+ };
+
+ validator.isBoolean = function(str) {
+ return (['true', 'false', '1', '0'].indexOf(str) >= 0);
+ };
+
+ validator.isAlpha = function (str, locale) {
+ locale = locale || 'en-US';
+ if (locale in alpha) {
+ return alpha[locale].test(str);
+ }
+ throw new Error('Invalid locale \'' + locale + '\'');
+ };
+
+ validator.isAlphanumeric = function (str, locale) {
+ locale = locale || 'en-US';
+ if (locale in alphanumeric) {
+ return alphanumeric[locale].test(str);
+ }
+ throw new Error('Invalid locale \'' + locale + '\'');
+ };
+
+ validator.isNumeric = function (str) {
+ return numeric.test(str);
+ };
+
+ validator.isDecimal = function (str) {
+ return str !== '' && decimal.test(str);
+ };
+
+ validator.isHexadecimal = function (str) {
+ return hexadecimal.test(str);
+ };
+
+ validator.isHexColor = function (str) {
+ return hexcolor.test(str);
+ };
+
+ validator.isLowercase = function (str) {
+ return str === str.toLowerCase();
+ };
+
+ validator.isUppercase = function (str) {
+ return str === str.toUpperCase();
+ };
+
+ validator.isInt = function (str, options) {
+ options = options || {};
+ return int.test(str) && (!options.hasOwnProperty('min') || str >= options.min) && (!options.hasOwnProperty('max') || str <= options.max);
+ };
+
+ validator.isFloat = function (str, options) {
+ options = options || {};
+ if (str === '' || str === '.') {
+ return false;
+ }
+ return float.test(str) && (!options.hasOwnProperty('min') || str >= options.min) && (!options.hasOwnProperty('max') || str <= options.max);
+ };
+
+ validator.isDivisibleBy = function (str, num) {
+ return validator.toFloat(str) % parseInt(num, 10) === 0;
+ };
+
+ validator.isNull = function (str) {
+ return str.length === 0;
+ };
+
+ validator.isLength = function (str, options) {
+ var min, max;
+ if (typeof(options) === 'object') {
+ min = options.min || 0;
+ max = options.max;
+ } else { // backwards compatibility: isLength(str, min [, max])
+ min = arguments[1];
+ max = arguments[2];
+ }
+ var surrogatePairs = str.match(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g) || [];
+ var len = str.length - surrogatePairs.length;
+ return len >= min && (typeof max === 'undefined' || len <= max);
+ };
+ validator.isByteLength = function (str, options) {
+ var min, max;
+ if (typeof(options) === 'object') {
+ min = options.min || 0;
+ max = options.max;
+ } else { // backwards compatibility: isByteLength(str, min [, max])
+ min = arguments[1];
+ max = arguments[2];
+ }
+ var len = encodeURI(str).split(/%..|./).length - 1;
+ return len >= min && (typeof max === 'undefined' || len <= max);
+ };
+
+ validator.isUUID = function (str, version) {
+ var pattern = uuid[version ? version : 'all'];
+ return pattern && pattern.test(str);
+ };
+
+ function getTimezoneOffset(str) {
+ var iso8601Parts = str.match(iso8601)
+ , timezone, sign, hours, minutes;
+ if (!iso8601Parts) {
+ str = str.toLowerCase();
+ timezone = str.match(/(?:\s|gmt\s*)(-|\+)(\d{1,4})(\s|$)/);
+ if (!timezone) {
+ return str.indexOf('gmt') !== -1 ? 0 : null;
+ }
+ sign = timezone[1];
+ var offset = timezone[2];
+ if (offset.length === 3) {
+ offset = '0' + offset;
+ }
+ if (offset.length <= 2) {
+ hours = 0;
+ minutes = parseInt(offset);
+ } else {
+ hours = parseInt(offset.slice(0, 2));
+ minutes = parseInt(offset.slice(2, 4));
+ }
+ } else {
+ timezone = iso8601Parts[21];
+ if (!timezone) {
+ // if no hour/minute was provided, the date is GMT
+ return !iso8601Parts[12] ? 0 : null;
+ }
+ if (timezone === 'z' || timezone === 'Z') {
+ return 0;
+ }
+ sign = iso8601Parts[22];
+ if (timezone.indexOf(':') !== -1) {
+ hours = parseInt(iso8601Parts[23]);
+ minutes = parseInt(iso8601Parts[24]);
+ } else {
+ hours = 0;
+ minutes = parseInt(iso8601Parts[23]);
+ }
+ }
+ return (hours * 60 + minutes) * (sign === '-' ? 1 : -1);
+ }
+
+ validator.isDate = function (str) {
+ var normalizedDate = new Date(Date.parse(str));
+ if (isNaN(normalizedDate)) {
+ return false;
+ }
+
+ // normalizedDate is in the user's timezone. Apply the input
+ // timezone offset to the date so that the year and day match
+ // the input
+ var timezoneOffset = getTimezoneOffset(str);
+ if (timezoneOffset !== null) {
+ var timezoneDifference = normalizedDate.getTimezoneOffset() -
+ timezoneOffset;
+ normalizedDate = new Date(normalizedDate.getTime() +
+ 60000 * timezoneDifference);
+ }
+
+ var day = String(normalizedDate.getDate());
+ var dayOrYear, dayOrYearMatches, year;
+ //check for valid double digits that could be late days
+ //check for all matches since a string like '12/23' is a valid date
+ //ignore everything with nearby colons
+ dayOrYearMatches = str.match(/(^|[^:\d])[23]\d([^:\d]|$)/g);
+ if (!dayOrYearMatches) {
+ return true;
+ }
+ dayOrYear = dayOrYearMatches.map(function(digitString) {
+ return digitString.match(/\d+/g)[0];
+ }).join('/');
+
+ year = String(normalizedDate.getFullYear()).slice(-2);
+ if (dayOrYear === day || dayOrYear === year) {
+ return true;
+ } else if ((dayOrYear === (day + '/' + year)) || (dayOrYear === (year + '/' + day))) {
+ return true;
+ }
+ return false;
+ };
+
+ validator.isAfter = function (str, date) {
+ var comparison = validator.toDate(date || new Date())
+ , original = validator.toDate(str);
+ return !!(original && comparison && original > comparison);
+ };
+
+ validator.isBefore = function (str, date) {
+ var comparison = validator.toDate(date || new Date())
+ , original = validator.toDate(str);
+ return !!(original && comparison && original < comparison);
+ };
+
+ validator.isIn = function (str, options) {
+ var i;
+ if (Object.prototype.toString.call(options) === '[object Array]') {
+ var array = [];
+ for (i in options) {
+ array[i] = validator.toString(options[i]);
+ }
+ return array.indexOf(str) >= 0;
+ } else if (typeof options === 'object') {
+ return options.hasOwnProperty(str);
+ } else if (options && typeof options.indexOf === 'function') {
+ return options.indexOf(str) >= 0;
+ }
+ return false;
+ };
+
+ validator.isWhitelisted = function (str, chars) {
+ for (var i = str.length - 1; i >= 0; i--) {
+ if (chars.indexOf(str[i]) === -1) {
+ return false;
+ }
+ }
+
+ return true;
+ };
+
+ validator.isCreditCard = function (str) {
+ var sanitized = str.replace(/[^0-9]+/g, '');
+ if (!creditCard.test(sanitized)) {
+ return false;
+ }
+ var sum = 0, digit, tmpNum, shouldDouble;
+ for (var i = sanitized.length - 1; i >= 0; i--) {
+ digit = sanitized.substring(i, (i + 1));
+ tmpNum = parseInt(digit, 10);
+ if (shouldDouble) {
+ tmpNum *= 2;
+ if (tmpNum >= 10) {
+ sum += ((tmpNum % 10) + 1);
+ } else {
+ sum += tmpNum;
+ }
+ } else {
+ sum += tmpNum;
+ }
+ shouldDouble = !shouldDouble;
+ }
+ return !!((sum % 10) === 0 ? sanitized : false);
+ };
+
+ validator.isISIN = function (str) {
+ if (!isin.test(str)) {
+ return false;
+ }
+
+ var checksumStr = str.replace(/[A-Z]/g, function(character) {
+ return parseInt(character, 36);
+ });
+
+ var sum = 0, digit, tmpNum, shouldDouble = true;
+ for (var i = checksumStr.length - 2; i >= 0; i--) {
+ digit = checksumStr.substring(i, (i + 1));
+ tmpNum = parseInt(digit, 10);
+ if (shouldDouble) {
+ tmpNum *= 2;
+ if (tmpNum >= 10) {
+ sum += tmpNum + 1;
+ } else {
+ sum += tmpNum;
+ }
+ } else {
+ sum += tmpNum;
+ }
+ shouldDouble = !shouldDouble;
+ }
+
+ return parseInt(str.substr(str.length - 1), 10) === (10000 - sum) % 10;
+ };
+
+ validator.isISBN = function (str, version) {
+ version = version ? version + '' : '';
+ if (!version) {
+ return validator.isISBN(str, 10) || validator.isISBN(str, 13);
+ }
+ var sanitized = str.replace(/[\s-]+/g, '')
+ , checksum = 0, i;
+ if (version === '10') {
+ if (!isbn10Maybe.test(sanitized)) {
+ return false;
+ }
+ for (i = 0; i < 9; i++) {
+ checksum += (i + 1) * sanitized.charAt(i);
+ }
+ if (sanitized.charAt(9) === 'X') {
+ checksum += 10 * 10;
+ } else {
+ checksum += 10 * sanitized.charAt(9);
+ }
+ if ((checksum % 11) === 0) {
+ return !!sanitized;
+ }
+ } else if (version === '13') {
+ if (!isbn13Maybe.test(sanitized)) {
+ return false;
+ }
+ var factor = [ 1, 3 ];
+ for (i = 0; i < 12; i++) {
+ checksum += factor[i % 2] * sanitized.charAt(i);
+ }
+ if (sanitized.charAt(12) - ((10 - (checksum % 10)) % 10) === 0) {
+ return !!sanitized;
+ }
+ }
+ return false;
+ };
+
+ validator.isMobilePhone = function(str, locale) {
+ if (locale in phones) {
+ return phones[locale].test(str);
+ }
+ return false;
+ };
+
+ var default_currency_options = {
+ symbol: '$'
+ , require_symbol: false
+ , allow_space_after_symbol: false
+ , symbol_after_digits: false
+ , allow_negatives: true
+ , parens_for_negatives: false
+ , negative_sign_before_digits: false
+ , negative_sign_after_digits: false
+ , allow_negative_sign_placeholder: false
+ , thousands_separator: ','
+ , decimal_separator: '.'
+ , allow_space_after_digits: false
+ };
+
+ validator.isCurrency = function (str, options) {
+ options = merge(options, default_currency_options);
+
+ return currencyRegex(options).test(str);
+ };
+
+ validator.isJSON = function (str) {
+ try {
+ var obj = JSON.parse(str);
+ return !!obj && typeof obj === 'object';
+ } catch (e) {}
+ return false;
+ };
+
+ validator.isMultibyte = function (str) {
+ return multibyte.test(str);
+ };
+
+ validator.isAscii = function (str) {
+ return ascii.test(str);
+ };
+
+ validator.isFullWidth = function (str) {
+ return fullWidth.test(str);
+ };
+
+ validator.isHalfWidth = function (str) {
+ return halfWidth.test(str);
+ };
+
+ validator.isVariableWidth = function (str) {
+ return fullWidth.test(str) && halfWidth.test(str);
+ };
+
+ validator.isSurrogatePair = function (str) {
+ return surrogatePair.test(str);
+ };
+
+ validator.isBase64 = function (str) {
+ return base64.test(str);
+ };
+
+ validator.isMongoId = function (str) {
+ return validator.isHexadecimal(str) && str.length === 24;
+ };
+
+ validator.isISO8601 = function (str) {
+ return iso8601.test(str);
+ };
+
+ validator.ltrim = function (str, chars) {
+ var pattern = chars ? new RegExp('^[' + chars + ']+', 'g') : /^\s+/g;
+ return str.replace(pattern, '');
+ };
+
+ validator.rtrim = function (str, chars) {
+ var pattern = chars ? new RegExp('[' + chars + ']+$', 'g') : /\s+$/g;
+ return str.replace(pattern, '');
+ };
+
+ validator.trim = function (str, chars) {
+ var pattern = chars ? new RegExp('^[' + chars + ']+|[' + chars + ']+$', 'g') : /^\s+|\s+$/g;
+ return str.replace(pattern, '');
+ };
+
+ validator.escape = function (str) {
+ return (str.replace(/&/g, '&')
+ .replace(/"/g, '"')
+ .replace(/'/g, ''')
+ .replace(//g, '>')
+ .replace(/\//g, '/')
+ .replace(/\`/g, '`'));
+ };
+
+ validator.stripLow = function (str, keep_new_lines) {
+ var chars = keep_new_lines ? '\\x00-\\x09\\x0B\\x0C\\x0E-\\x1F\\x7F' : '\\x00-\\x1F\\x7F';
+ return validator.blacklist(str, chars);
+ };
+
+ validator.whitelist = function (str, chars) {
+ return str.replace(new RegExp('[^' + chars + ']+', 'g'), '');
+ };
+
+ validator.blacklist = function (str, chars) {
+ return str.replace(new RegExp('[' + chars + ']+', 'g'), '');
+ };
+
+ var default_normalize_email_options = {
+ lowercase: true,
+ remove_dots: true,
+ remove_extension: true
+ };
+
+ validator.normalizeEmail = function (email, options) {
+ options = merge(options, default_normalize_email_options);
+ if (!validator.isEmail(email)) {
+ return false;
+ }
+ var parts = email.split('@', 2);
+ parts[1] = parts[1].toLowerCase();
+ if (parts[1] === 'gmail.com' || parts[1] === 'googlemail.com') {
+ if (options.remove_extension) {
+ parts[0] = parts[0].split('+')[0];
+ }
+ if (options.remove_dots) {
+ parts[0] = parts[0].replace(/\./g, '');
+ }
+ if (!parts[0].length) {
+ return false;
+ }
+ parts[0] = parts[0].toLowerCase();
+ parts[1] = 'gmail.com';
+ } else if (options.lowercase) {
+ parts[0] = parts[0].toLowerCase();
+ }
+ return parts.join('@');
+ };
+
+ function merge(obj, defaults) {
+ obj = obj || {};
+ for (var key in defaults) {
+ if (typeof obj[key] === 'undefined') {
+ obj[key] = defaults[key];
+ }
+ }
+ return obj;
+ }
+
+ function currencyRegex(options) {
+ var symbol = '(\\' + options.symbol.replace(/\./g, '\\.') + ')' + (options.require_symbol ? '' : '?')
+ , negative = '-?'
+ , whole_dollar_amount_without_sep = '[1-9]\\d*'
+ , whole_dollar_amount_with_sep = '[1-9]\\d{0,2}(\\' + options.thousands_separator + '\\d{3})*'
+ , valid_whole_dollar_amounts = ['0', whole_dollar_amount_without_sep, whole_dollar_amount_with_sep]
+ , whole_dollar_amount = '(' + valid_whole_dollar_amounts.join('|') + ')?'
+ , decimal_amount = '(\\' + options.decimal_separator + '\\d{2})?';
+ var pattern = whole_dollar_amount + decimal_amount;
+ // default is negative sign before symbol, but there are two other options (besides parens)
+ if (options.allow_negatives && !options.parens_for_negatives) {
+ if (options.negative_sign_after_digits) {
+ pattern += negative;
+ }
+ else if (options.negative_sign_before_digits) {
+ pattern = negative + pattern;
+ }
+ }
+ // South African Rand, for example, uses R 123 (space) and R-123 (no space)
+ if (options.allow_negative_sign_placeholder) {
+ pattern = '( (?!\\-))?' + pattern;
+ }
+ else if (options.allow_space_after_symbol) {
+ pattern = ' ?' + pattern;
+ }
+ else if (options.allow_space_after_digits) {
+ pattern += '( (?!$))?';
+ }
+ if (options.symbol_after_digits) {
+ pattern += symbol;
+ } else {
+ pattern = symbol + pattern;
+ }
+ if (options.allow_negatives) {
+ if (options.parens_for_negatives) {
+ pattern = '(\\(' + pattern + '\\)|' + pattern + ')';
+ }
+ else if (!(options.negative_sign_before_digits || options.negative_sign_after_digits)) {
+ pattern = negative + pattern;
+ }
+ }
+ return new RegExp(
+ '^' +
+ // ensure there's a dollar and/or decimal amount, and that it doesn't start with a space or a negative sign followed by a space
+ '(?!-? )(?=.*\\d)' +
+ pattern +
+ '$'
+ );
+ }
+
+ validator.init();
+
+ return validator;
+
+});
+
+},{"161":161}],163:[function(_dereq_,module,exports){
+'use strict';
+
+_dereq_(152);
+_dereq_(148);
+
+if (!Object.assign) {
+ _dereq_(149);
+}
+
+if (!Object.setPrototypeOf) {
+ _dereq_(150);
+}
+
+if (typeof Promise === "undefined") {
+ _dereq_(151);
+}
+
+if (!Array.from) {
+ _dereq_(146);
+ _dereq_(147);
+}
+
+if (typeof Symbol === "undefined") {
+ _dereq_(153);
+}
+
+},{"146":146,"147":147,"148":148,"149":149,"150":150,"151":151,"152":152,"153":153}],164:[function(_dereq_,module,exports){
+"use strict";
+
+var Connector = _dereq_(23);
+var message = _dereq_(36);
+var WebSocket = _dereq_(165).WebSocket;
+
+/**
+ * @alias connector.WebSocketConnector
+ */
+
+var WebSocketConnector = function () {
+
+ /**
+ * @param {connector.Connector} connector a connector
+ * @return {connector.WebSocketConnector} a websocket connection
+ */
+ WebSocketConnector.create = function create(connector) {
+ if (!connector) throw new Error('No connector was provided, but connector is required for websocket connection!');
+
+ var websocket = this.websockets[connector.origin];
+
+ if (!websocket) {
+ websocket = new WebSocketConnector(connector);
+ this.websockets[connector.origin] = websocket;
+ }
+
+ return websocket;
+ };
+
+ /**
+ * @param {connector.Connector} connector
+ */
+
+
+ function WebSocketConnector(connector) {
+ babelHelpers.classCallCheck(this, WebSocketConnector);
+
+ this.host = connector.host;
+ this.port = connector.port;
+ this.secure = connector.secure;
+ this.basePath = connector.basePath;
+ this.connector = connector;
+ this.listeners = {};
+ }
+
+ /**
+ * Registers a handler for a topic.
+ * @param {string|Object} topic
+ * @param {Function} cb
+ */
+
+
+ WebSocketConnector.prototype.subscribe = function subscribe(topic, cb) {
+ topic = Object(topic) instanceof String ? topic : JSON.stringify(topic);
+ if (!this.listeners[topic]) {
+ this.listeners[topic] = [cb];
+ } else if (this.listeners[topic].indexOf(cb) == -1) {
+ this.listeners[topic].push(cb);
+ }
+ };
+
+ /**
+ * Deregisters a handler.
+ * @param {string|Object} topic
+ * @param {Function} cb
+ */
+
+
+ WebSocketConnector.prototype.unsubscribe = function unsubscribe(topic, cb) {
+ topic = Object(topic) instanceof String ? topic : JSON.stringify(topic);
+ if (this.listeners[topic]) {
+ var index = this.listeners[topic].indexOf(cb);
+ if (index != -1) {
+ this.listeners[topic].splice(index, 1);
+ }
+ }
+ };
+
+ WebSocketConnector.prototype.socketListener = function socketListener(event) {
+ var message = JSON.parse(event.data);
+ var topic = message.topic;
+ topic = Object(topic) instanceof String ? topic : JSON.stringify(topic);
+ if (this.listeners[topic]) {
+ this.listeners[topic].forEach(function (listener) {
+ listener(message);
+ });
+ }
+ };
+
+ /**
+ * Sends a websocket message over a lazily initialized websocket connection.
+ * @param {Object} msg
+ * @param {string} msg.topic
+ * @param {string} msg.token
+ */
+
+
+ WebSocketConnector.prototype.sendOverSocket = function sendOverSocket(msg) {
+ var _this = this;
+
+ //Lazy socket initialization
+ if (!this.socketOpen) {
+ //Resolve Promise on connect
+ this.socketOpen = new Promise(function (resolve, reject) {
+ _this.connector.send(new message.EventsUrl()).then(function (response) {
+ return response.entity.urls;
+ }, function () {
+ return null;
+ }).then(function (urls) {
+ var url = void 0;
+ if (urls) {
+ (function () {
+ var prefix = _this.secure ? "wss://" : "ws://";
+ urls = urls.filter(function (url) {
+ return url.indexOf(prefix) == 0;
+ });
+
+ var len = urls.length;
+ url = urls[Math.floor(Math.random() * len)];
+ })();
+ } else {
+ url = (_this.secure ? 'wss://' : 'ws://') + _this.host + ':' + _this.port + _this.basePath + '/events';
+ }
+
+ _this.socket = _this.createWebSocket(url);
+ _this.socket.onmessage = _this.socketListener.bind(_this);
+
+ _this.socket.onopen = resolve;
+ _this.socket.onerror = reject;
+
+ //Reset socket on close
+ _this.socket.onclose = function () {
+ _this.socket = null;
+ _this.socketOpen = null;
+ };
+ }).catch(reject);
+ });
+ }
+
+ this.socketOpen.then(function () {
+ var jsonMessage = JSON.stringify(msg);
+ _this.socket.send(jsonMessage);
+ });
+ };
+
+ WebSocketConnector.prototype.createWebSocket = function createWebSocket(destination) {
+ return new WebSocket(destination);
+ };
+
+ return WebSocketConnector;
+}();
+
+Object.assign(WebSocketConnector, /** @lends connector.WebSocketConnector */{
+ /**
+ * Map of all available connectors to their respective websocket connections
+ * @type connector.Connector[]
+ */
+ websockets: {}
+});
+
+module.exports = WebSocketConnector;
+
+},{"165":165,"23":23,"36":36}],165:[function(_dereq_,module,exports){
+"use strict";
+
+exports.WebSocket = window.WebSocket;
+
+},{}],166:[function(_dereq_,module,exports){
+'use strict';
+
+var db = _dereq_(35);
+
+module.exports = exports = db;
+
+exports.Observable = _dereq_(167);
+exports.connector.WebSocketConnector = _dereq_(164);
+exports.query.Node = _dereq_(168);
+exports.query.Stream = _dereq_(169);
+
+},{"164":164,"167":167,"168":168,"169":169,"35":35}],167:[function(_dereq_,module,exports){
+'use strict';
+
+/*
+ * loads the observalbe from the global context, the global Rx variable or try to load Rx.js, fallback to core-js shim
+ * The Observable can be overwritten by setting the require('baqend/streaming').Observable = Observable afterwards
+ */
+
+if (typeof Rx !== 'undefined') {
+ module.exports = Rx.Observable;
+} else {
+ try {
+ module.exports = _dereq_('rxjs/Observable').Observable;
+ } catch (e) {
+ if (typeof Observable == 'undefined') {
+ //load Observable shim
+ _dereq_(155);
+ _dereq_(154);
+ var sub = Observable.prototype.subscribe;
+
+ //patch subscribe until core-js implements the new proposal
+ //https://github.com/zloirock/core-js/issues/257
+ Observable.prototype.subscribe = function (onNext, onError, onComplete) {
+ if (onNext instanceof Function) {
+ return sub.call(this, {
+ next: onNext,
+ error: onError,
+ complete: onComplete
+ });
+ } else {
+ return sub.call(this, onNext);
+ }
+ };
+ }
+
+ module.exports = Observable;
+ }
+}
+
+},{"154":154,"155":155,"undefined":undefined}],168:[function(_dereq_,module,exports){
+"use strict";
+
+var Stream = _dereq_(169);
+var Node = _dereq_(56);
+
+/**
+ * @ignore
+ *
+ * @param {Object} options
+ * @param {query.Node} target
+ * @returns {Observable} an RxJS observable
+ * @memberOf query.Node.prototype
+ */
+Node.prototype._stream = function (options, target) {
+ var type = this.resultClass ? this.entityManager.metamodel.entity(this.resultClass) : null;
+ if (!type) {
+ throw new Error('Only typed queries can be executed.');
+ }
+
+ if (!target) {
+ target = this;
+ }
+
+ return new Stream(this.entityManager, type.name, this._serializeQuery(), options, this._serializeSort(), this.maxResults, this.firstResult, target).observable();
+};
+
+module.exports = Node;
+
+},{"169":169,"56":56}],169:[function(_dereq_,module,exports){
+"use strict";
+
+var Metadata = _dereq_(63);
+var WebSocketConnector = _dereq_(164);
+var lib = _dereq_(35);
+
+/**
+ * @alias query.Stream
+ */
+
+var Stream = function () {
+
+ /**
+ * Returns an RxJS observable.
+ *
+ * @returns {Observable} an RxJS observable
+ */
+ Stream.prototype.observable = function observable() {
+ var _this = this;
+
+ return new lib.Observable(function (observer) {
+ var callback = function callback(e) {
+ if (e.matchType === 'error') {
+ observer.error(e);
+ } else {
+ observer.next(e);
+ }
+ };
+
+ _this.on(_this.query.matchTypes, callback);
+ return function () {
+ _this.off(_this.query.matchTypes, callback);
+ };
+ });
+ };
+
+ /**
+ * @param {EntityManager} entityManager The owning entity manager of this query
+ * @param {string} bucket The Bucket on which the streaming query is performed
+ * @param {string} query The serialized query
+ * @param {Object} options an object containing parameters
+ * @param {string} sort the sort string
+ * @param {number} limit the count, i.e. the number of items in the result
+ * @param {number} offset offset, i.e. the number of items to skip
+ * @param {query.Node} target the target of the stream
+ */
+
+
+ function Stream(entityManager, bucket, query, options, sort, limit, offset, target) {
+ babelHelpers.classCallCheck(this, Stream);
+
+ var verifiedOptions = Stream.parseOptions(options);
+ this.entityManager = entityManager;
+ this.query = {
+ bucket: bucket,
+ matchTypes: verifiedOptions.matchTypes,
+ operations: verifiedOptions.operations,
+ initial: verifiedOptions.initial,
+ query: query,
+ sort: sort,
+ start: offset,
+ count: limit
+ };
+ this.callbacks = [];
+ this.topic = Stream.getTopic(this.query.bucket, this.query.query, this.query.start, this.query.count, this.query.sort, this.query.matchTypes, this.query.operations);
+ this.target = target;
+ this.socket = WebSocketConnector.create(entityManager._connector);
+ }
+
+ Stream.prototype.on = function on(matchTypes, callback) {
+ var wrappedCallback = this._wrapQueryCallback(callback);
+ this.socket.subscribe(this.topic, wrappedCallback);
+
+ var queryMessage = {
+ register: true,
+ topic: this.topic,
+ query: this.query
+ };
+
+ if (this.query.initial === true) {
+ queryMessage.fromstart = true;
+ }
+
+ this.socket.sendOverSocket(queryMessage);
+
+ this.callbacks.push({
+ matchTypes: matchTypes,
+ callback: callback,
+ topic: this.topic,
+ wrappedCallback: wrappedCallback,
+ queryMessage: queryMessage
+ });
+ };
+
+ Stream.getCachableQueryString = function getCachableQueryString(query, start, count, sort) {
+ var queryID = query;
+ if (Stream.isEmptyJSONString(query)) {
+ queryID = "{}";
+ }
+ if (start > 0) {
+ queryID += "&start=" + start;
+ }
+ if (count > 0) {
+ queryID += "&count=" + count;
+ }
+ if (!Stream.isEmptyJSONString(sort)) {
+ queryID += "&sort=" + sort;
+ }
+ return queryID;
+ };
+
+ Stream.getTopic = function getTopic(bucket, query, start, count, sort, matchTypes, operations) {
+ return [bucket, Stream.getCachableQueryString(query, start, count, sort), Stream.normalizeMatchTypes(matchTypes).join("_"), Stream.normalizeOperations(operations).join("_")].join("/");
+ };
+
+ Stream.isEmptyJSONString = function isEmptyJSONString(string) {
+ return string === undefined || string === null || /^\s*(\{\s*\})?\s*$/.test(string);
+ };
+
+ /**
+ * Valid options are:
+
+ initial: a Boolean indicating whether or not the initial result set should be delivered on creating the subscription
+ matchTypes: a list of match types
+ operations: a list of operations
+
+ *
+ *
+ * @param {Object} provided object containing options
+ * @returns {Object} an object containing VALID options
+ */
+
+
+ Stream.parseOptions = function parseOptions(provided) {
+ var verified = {
+ matchTypes: ['all'],
+ operations: ['any']
+ };
+
+ if (provided) {
+ if (provided.initial !== null && provided.initial !== undefined) {
+ if (typeof provided.initial === "boolean") {
+ verified.initial = provided.initial;
+ } else {
+ throw new Error('Option "initial" only permits Boolean values!');
+ }
+ }
+
+ if (provided.matchTypes) {
+ if (Array.isArray(provided.matchTypes)) {
+ verified.matchTypes = provided.matchTypes;
+ } else {
+ verified.matchTypes = [provided.matchTypes];
+ }
+
+ verified.matchTypes = Stream.normalizeMatchTypes(verified.matchTypes);
+ }
+
+ if (provided.operations) {
+ if (Array.isArray(provided.operations)) {
+ verified.operations = provided.operations;
+ } else {
+ verified.operations = [provided.operations];
+ }
+
+ verified.operations = Stream.normalizeOperations(verified.operations);
+ }
+
+ if (verified.matchTypes.indexOf('all') == -1 && verified.operations.indexOf('any') == -1) {
+ throw new Error('Only subscriptions for either operations or matchTypes are allowed. You cannot subscribe to a query using matchTypes and operations at the same time!');
+ }
+ }
+
+ // Apply default values if missing
+ if (verified.initial === null || verified.initial === undefined) {
+ verified.initial = true;
+ }
+
+ if (!verified.matchTypes) {
+ verified.matchTypes = ['all'];
+ }
+
+ if (!verified.operations) {
+ verified.operations = ['any'];
+ }
+
+ return verified;
+ };
+
+ Stream.normalizeMatchTypes = function normalizeMatchTypes(list) {
+ return Stream.normalizeSortedSet(list, 'all', "match types", ['add', 'change', 'changeIndex', 'match', 'remove']);
+ };
+
+ Stream.normalizeOperations = function normalizeOperations(list) {
+ return Stream.normalizeSortedSet(list, 'any', "operations", ['delete', 'insert', 'none', 'update']);
+ };
+
+ Stream.normalizeSortedSet = function normalizeSortedSet(list, wildcard, itemType, allowedItems) {
+ if (!list || list.length == 0) {
+ //undefined or empty list --> default value
+ return undefined;
+ }
+
+ // sort, remove duplicates and check whether all values are allowed
+ list.sort();
+ var item;
+ var lastItem = undefined;
+ for (var i = list.length - 1; i >= 0; i--) {
+ item = list[i];
+ if (!item) {
+ //undefined and null item in the list --> invalid!
+ throw new Error('undefined and null not allowed!');
+ }
+ if (item === lastItem) {
+ //remove duplicates
+ list.splice(i, 1);
+ }
+ if (item === wildcard) {
+ return [wildcard];
+ }
+ if (allowedItems.indexOf(item) == -1) {
+ //raise error on invalid elements
+ throw new Error(item + ' not allowed for ' + itemType + '! (permitted: ' + allowedItems + '.)');
+ }
+ lastItem = item;
+ }
+
+ return list;
+ };
+
+ Stream.prototype.off = function off(matchTypes, callback) {
+ var _this2 = this;
+
+ this.callbacks = this.callbacks.reduce(function (keep, el) {
+ if ((!callback || el.callback == callback) && (!matchTypes || el.matchTypes == matchTypes)) {
+ _this2.socket.unsubscribe(el.topic, el.wrappedCallback);
+ el.queryMessage.register = false;
+ _this2.socket.sendOverSocket(el.queryMessage);
+ } else {
+ keep.push(el);
+ }
+ return keep;
+ }, []);
+ };
+
+ Stream.prototype._wrapQueryCallback = function _wrapQueryCallback(cb) {
+ return function (msg) {
+ var _this3 = this;
+
+ msg.query = this.query;
+
+ if (msg.result) {
+ //Initial result received
+ var basicMatch = { matchType: "add", operation: 'none' };
+ var index = 0;
+ msg.result.forEach(function (obj) {
+ var entity = _this3._createObject(obj, false);
+ if (msg.ordered) {
+ basicMatch.index = index++;
+ }
+ var callback = _this3.createCallback(msg, basicMatch, entity, true);
+ cb(callback);
+ }, this);
+ }
+ if (msg.match) {
+ //Single Match received, hollow object for deletes
+ var obj = msg.match.object;
+ var entity = this._createObject(obj, msg.match.operation === "delete");
+ //Call wrapped callback
+ var callback = this.createCallback(msg, msg.match, entity, false);
+ cb(callback);
+ }
+ }.bind(this);
+ };
+
+ Stream.prototype.createCallback = function createCallback(msg, match, entity, init) {
+ var matchEvent = {
+ matchType: match.matchType,
+ operation: match.operation,
+ data: entity,
+ date: new Date(msg.date),
+ target: this.target,
+ initial: init
+ };
+ if (match.index !== undefined) {
+ matchEvent.index = match.index;
+ }
+ return matchEvent;
+ };
+
+ Stream.prototype._createObject = function _createObject(object, objectWasDeleted) {
+ var entity;
+ if (object) {
+ entity = this.entityManager.getReference(object.id);
+ if (entity.version < object.version || objectWasDeleted) {
+ var metadata = Metadata.get(entity);
+ if (objectWasDeleted) {
+ metadata.setRemoved();
+ } else {
+ metadata.setJson(object);
+ metadata.setPersistent();
+ }
+ }
+ }
+ return entity;
+ };
+
+ return Stream;
+}();
+
+module.exports = Stream;
+
+},{"164":164,"35":35,"63":63}]},{},[166])(166)
+});
\ No newline at end of file
diff --git a/dist/baqend-streaming.min.js b/dist/baqend-streaming.min.js
new file mode 100644
index 00000000..68249614
--- /dev/null
+++ b/dist/baqend-streaming.min.js
@@ -0,0 +1,7 @@
+/*! baqend 2.4.2 | Copyright (c) 2015 Baqend GmbH | MIT */
+!function(a){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=a();else if("function"==typeof define&&define.amd)define([],a);else{var b;b="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,b.DB=a()}}(function(){var a,b={};return b.typeof="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(a){return typeof a}:function(a){return a&&"function"==typeof Symbol&&a.constructor===Symbol&&a!==Symbol.prototype?"symbol":typeof a},b.classCallCheck=function(a,b){if(!(a instanceof b))throw new TypeError("Cannot call a class as a function")},b.createClass=function(){function a(a,b){for(var c=0;c0&&b.bloomFilter&&h.atob&&!h.isNode&&this.updateBloomFilter(b.bloomFilter))},c.prototype._createObjectFactory=function(a){Object.keys(a).forEach(function(a){var b=this.metamodel.managedType(a),c=b.name;this[c]?(b.typeConstructor=this[c],Object.defineProperty(this,c,{value:b.createObjectFactory(this)})):Object.defineProperty(this,c,{get:function(){return Object.defineProperty(this,c,{value:b.createObjectFactory(this)}),this[c]},set:function(a){b.typeConstructor=a},configurable:!0})},this)},c.prototype.send=function(a){var b=this;return a.tokenStorage=this.tokenStorage,this._connector.send(a).catch(function(a){throw a.status==o.BAD_CREDENTIALS&&b._logout(),a})},c.prototype.getReference=function(a,b){var c,d;b?(d=this.metamodel.entity(a),c=0==b.indexOf("/db/")?b:d.ref+"/"+encodeURIComponent(b)):(c=a,d=this.metamodel.entity(c.substring(0,c.indexOf("/",4))));var e=this._entities[c];if(!e){e=d.create();var f=l.get(e);f.id=c,f.setUnavailable(),this._attach(e)}return e},c.prototype.createQueryBuilder=function(a){return new i.Builder(this,a)},c.prototype.clear=function(){this._entities={}},c.prototype.close=function(){return this._connector=null,this.clear()},c.prototype.contains=function(a){return!!a&&this._entities[a.id]===a},c.prototype.containsById=function(a){return!(!a||!this._entities[a.id])},c.prototype.detach=function(a){var b=this,c=l.get(a);return c.withLock(function(){return b.removeReference(a),Promise.resolve(a)})},c.prototype.resolveDepth=function(a,b){var c=this;if(!b||!b.depth)return Promise.resolve(a);b.resolved=b.resolved||[];var d=[],e=Object.assign({},b,{depth:b.depth===!0||b.depth-1});return this.getSubEntities(a,1).forEach(function(a){null==a||~b.resolved.indexOf(a)||(b.resolved.push(a),d.push(c.load(a.id,null,e)))}),Promise.all(d).then(function(){return a})},c.prototype.load=function(a,b,c){var d=this;c=c||{};var f=this.getReference(a,b),g=l.get(f);if(!c.refresh&&c.local&&g.isAvailable)return this.resolveDepth(f,c);var h=new e.GetObject(g.bucket,g.key);return this.ensureCacheHeader(f.id,h,c.refresh),this.send(h).then(function(e){return f.version>e.entity.version?(c.refresh=!0,d.load(a,b,c)):(d.addToWhiteList(e.entity.id),e.status!=o.NOT_MODIFIED&&g.setJson(e.entity),g.setPersistent(),d.resolveDepth(f,c))},function(a){if(a.status==o.OBJECT_NOT_FOUND)return d.removeReference(f),g.setRemoved(),null;throw a})},c.prototype.insert=function(a,b){var c=this;b=b||{};var d;return this._save(a,b,function(a,b){if(a.version)throw new f.PersistentError("Existing objects can't be inserted.");return d=!a.id,new e.CreateObject(a.bucket,b)}).then(function(b){return d&&c._attach(a),b})},c.prototype.update=function(a,b){return b=b||{},this._save(a,b,function(a,c){if(!a.version)throw new f.PersistentError("New objects can't be inserted.");return b.force?(delete c.version,new e.ReplaceObject(a.bucket,a.key,c).ifMatch("*")):new e.ReplaceObject(a.bucket,a.key,c).ifMatch(a.version)})},c.prototype.save=function(a,b,c){b=b||{};var d=function(a,c){if(b.force){if(!a.id)throw new f.PersistentError("New special objects can't be forcedly saved.");return delete c.version,new e.ReplaceObject(a.bucket,a.key,c)}return a.version?new e.ReplaceObject(a.bucket,a.key,c).ifMatch(a.version):new e.CreateObject(a.bucket,c)};return c?this._locklessSave(a,b,d):this._save(a,b,d)},c.prototype.optimisticSave=function(a,b){var c=this;return l.get(a).withLock(function(){return c._optimisticSave(a,b)})},c.prototype._optimisticSave=function(a,b){var c=this,d=!1,e=function(){d=!0},f=Promise.resolve(b(a,e));return d?Promise.resolve(a):f.then(function(){return c.save(a,{},!0).catch(function(d){if(412==d.status)return c.refresh(a,{}).then(function(){return c._optimisticSave(a,b)});throw d})})},c.prototype._locklessSave=function(a,b,c){var d=this;this.attach(a);var e,f,g=l.get(a);if(g.isAvailable&&(f=g.getJson()),g.isDirty){b.refresh||g.setPersistent();var h=this.send(c(g,f)).then(function(c){return b.refresh?(g.setJson(c.entity),g.setPersistent()):g.setJsonMetadata(c.entity),a},function(b){if(b.status==o.OBJECT_NOT_FOUND)return d.removeReference(a),g.setRemoved(),null;throw g.setDirty(),b});e=[h]}else e=[Promise.resolve(a)];var i=Object.assign({},b);return i.depth=0,this.getSubEntities(a,b.depth).forEach(function(a){e.push(d._save(a,i,c))}),Promise.all(e).then(function(){return a})},c.prototype._save=function(a,b,c){var d=this;this.ensureBloomFilterFreshness();var e=l.get(a);return e.version&&this.addToBlackList(a.id),e.withLock(function(){return d._locklessSave(a,b,c)})},c.prototype.getSubEntities=function(a,b,c,d){var e=this;if(c=c||[],!b)return c;d=d||a;for(var f=l.get(a),g=f.type.references(),h=Array.isArray(g),i=0,g=h?g:g[Symbol.iterator]();;){var j;if(h){if(i>=g.length)break;j=g[i++]}else{if(i=g.next(),i.done)break;j=i.value}var k=j;this.getSubEntitiesByPath(a,k.path).forEach(function(a){~c.indexOf(a)||a==d||(c.push(a),c=e.getSubEntities(a,b===!0?b:b-1,c,d))})}return c},c.prototype.getSubEntitiesByPath=function(a,b){var c=this,d=[a];return b.forEach(function(a){var b=[];d.forEach(function(d){var e=d[a];if(e){var f=c.metamodel.managedType(d.constructor).getAttribute(a);if(f.isCollection)for(var g=e.entries(),h=Array.isArray(g),i=0,g=h?g:g[Symbol.iterator]();;){var j;if(h){if(i>=g.length)break;j=g[i++]}else{if(i=g.next(),i.done)break;j=i.value}var k=j;b.push(k[1]),f.keyType&&f.keyType.isEntity&&b.push(k[0])}else b.push(e)}}),d=b}),d},c.prototype.delete=function(a,b){var c=this;b=b||{},this.attach(a);var d=l.get(a);return d.withLock(function(){if(!d.version&&!b.force)throw new f.IllegalEntityError(a);var g=new e.DeleteObject(d.bucket,d.key);c.addToBlackList(a.id),b.force||g.ifMatch(d.version);var h=[c.send(g).then(function(){return c.removeReference(a),d.setRemoved(),a})],i=Object.assign({},b);return i.depth=0,c.getSubEntities(a,b.depth).forEach(function(a){h.push(c.delete(a,i))}),Promise.all(h).then(function(){return a})})},c.prototype.flush=function(a,b){},c.prototype.persist=function(a){this.attach(a)},c.prototype.refresh=function(a,b){return b=b||{},b.refresh=!0,this.load(a.id,null,b)},c.prototype.attach=function(a){if(!this.contains(a)){var b=this.metamodel.entity(a.constructor);if(!b)throw new f.IllegalEntityError(a);if(this.containsById(a))throw new f.EntityExistsError(a);this._attach(a)}},c.prototype._attach=function(a){var b=l.get(a);if(b.isAttached){if(b.db!=this)throw new f.EntityExistsError(a)}else b.db=this;b.id||"User"!=b.type.name&&"Role"!=b.type.name&&"logs.AppLog"!=b.type.name&&(b.id="/db/"+b.type.name+"/"+h.uuid()),b.id&&(this._entities[b.id]=a)},c.prototype.removeReference=function(a){var b=l.get(a);if(!b)throw new f.IllegalEntityError(a);delete this._entities[b.id]},c.prototype.register=function(a,b,c){var d=this,g=c>j.LoginOption.NO_LOGIN;if(this.me&&g)throw new f.PersistentError("User is already logged in.");return this.withLock(function(){var f=new e.Register({user:a,password:b,login:g});return d._userRequest(f,c)})},c.prototype.login=function(a,b,c){var d=this;if(this.me)throw new f.PersistentError("User is already logged in.");return this.withLock(function(){var f=new e.Login({username:a,password:b});return d._userRequest(f,c)})},c.prototype.logout=function(){var a=this;return this.withLock(function(){return a.send(new e.Logout).then(a._logout.bind(a))})},c.prototype.loginWithOAuth=function(a,b,c){if(this.me)throw new f.PersistentError("User is already logged in.");c=Object.assign({title:"Login with "+a,timeout:3e5,state:{},loginOption:!0},c);var d;if(!m[a+"OAuth"])throw new Error("OAuth provider "+a+" not supported.");d=new m[a+"OAuth"](b,c.scope,JSON.stringify(c.state));var e=this._userRequest(d,c.loginOption);open(d.request.path,c.title,"width="+c.width+",height="+c.height);return new Promise(function(a,b){var d=setTimeout(function(){b(new f.PersistentError("OAuth login timeout."))},c.timeout);e.then(a,b).then(function(){clearTimeout(d)})})},c.prototype.renew=function(){var a=this;return this.withLock(function(){var b=new e.Me;return a._userRequest(b,!0)})},c.prototype.newPassword=function(a,b,c){var d=this;return this.withLock(function(){var f=new e.NewPassword({username:a,password:b,newPassword:c});return d.send(f).then(function(a){return d._updateUser(a.entity)})})},c.prototype._updateUser=function(a,b){var c=this.getReference(a.id),d=l.get(c);return d.setJson(a),d.setPersistent(),b&&(this.me=c),c},c.prototype._logout=function(){this.me=null,this.token=null},c.prototype._userRequest=function(a,b){var c=this,d=b>j.LoginOption.NO_LOGIN;return d&&(this.tokenStorage.temporary=bc&&this._bloomFilterLock.withLock(function(){return a.refreshBloomFilter()})}},c.prototype.mustRevalidate=function(a){if(h.isNode)return!1;this.ensureBloomFilterFreshness();var b=this.isCachingDisabled||!this._bloomFilterLock.isReady;return b=b||!this.cacheWhiteList.has(a)&&(this.cacheBlackList.has(a)||this.bloomFilter.contains(a))},c.prototype.ensureCacheHeader=function(a,b,c){c=c||this.mustRevalidate(a),c&&b.noCache()},c.prototype.createURL=function(a,b){var c=this._connector.basePath+a,d=!1;return b&&this.me?(c=this.tokenStorage.signPath(c),d=!0):c=c.split("/").map(encodeURIComponent).join("/"),this.mustRevalidate(a)&&(c=c+(d?"&":"?")+"BCB"),this._connector.origin+c},c}(h.Lockable);p.prototype.List=Array,p.prototype.Set=Set,p.prototype.Map=Map,p.prototype.GeoPoint=a(5),c.exports=p},{19:19,20:20,21:21,25:25,34:34,36:36,4:4,5:5,59:59,63:63,70:70}],3:[function(a,c,d){"use strict";var e=a(36),f=a(52),g=a(70),h=(a(22),a(23)),i=a(2),j=function(a){function c(d){b.classCallCheck(this,c);var f=b.possibleConstructorReturn(this,a.call(this));d=Object(d)instanceof String?{host:d}:d||{},f._connector=null,f.metamodel=f.createMetamodel(),f.code=new g.Code(f.metamodel,f),f.tokenStorageFactory=g.TokenStorage.WEB_STORAGE||g.TokenStorage.GLOBAL,f.configure(d);var h=!0,i=new Promise(function(a){f._connected=a});return d.host?f.connect(d.host,d.port,d.secure,d.basePath):h=!1,f.tokenStorage||(h=!1,i=i.then(function(){return f.tokenStorageFactory.create(f._connector.origin)}).then(function(a){f.tokenStorage=a})),d.schema?(f._connectData=d,f.metamodel.init(d.schema)):(h=!1,i=i.then(function(){var a=new e.Connect;return a.withCredentials=!0,0===f.staleness&&a.noCache(),f.send(a)}).then(function(a){f._connectData=a.entity,void 0===f.staleness&&(f.staleness=f._connectData.bloomFilterRefresh||60),f.metamodel.isInitialized||f.metamodel.init(f._connectData.schema),f.tokenStorage.update(f._connectData.token)})),h||f.withLock(function(){return i},!0),f}return b.inherits(c,a),c.prototype._connected=function(){},c.prototype.configure=function(a){if(this._connector)throw new Error("The EntityManagerFactory can only be configured before is is connected.");a.tokenStorage&&(this.tokenStorage=a.tokenStorage),a.tokenStorageFactory&&(this.tokenStorageFactory=a.tokenStorageFactory),void 0!==a.staleness&&(this.staleness=a.staleness)},c.prototype.connect=function(a,b,c,d){if(this._connector)throw new Error("The EntityManagerFactory is already connected.");return Object(b)instanceof Boolean&&(c=b,b=0),this._connector=h.create(a,b,c,d),this._connected(),this.ready()},c.prototype.createMetamodel=function(){return new f.Metamodel(this)},c.prototype.createEntityManager=function(a){var b=this,c=new i(this);return this.isReady?c.connected(this._connector,this._connectData,a?this.tokenStorage:new g.TokenStorage(this._connector.origin)):c.withLock(function(){return b.ready().then(function(){c.connected(b._connector,b._connectData,a?b.tokenStorage:new g.TokenStorage(b._connector.origin))})},!0),c},c.prototype.send=function(a){return a.tokenStorage||(a.tokenStorage=this.tokenStorage),this._connector.send(a)},c}(g.Lockable);c.exports=j},{2:2,22:22,23:23,36:36,52:52,70:70}],4:[function(a,c,d){"use strict";var e=a(36),f=a(34),g=function(){function a(c){b.classCallCheck(this,a),this._connector=c.connector,this.entityManager=c,this.tid=null,this.rollbackOnly=!1,this.readSet=null,this.changeSet=null}return b.createClass(a,[{key:"isActive",get:function(){return Boolean(this.tid)}}]),a.prototype.begin=function(a,b){return this.yield().then(function(){var a=this.send(new e.PostTransaction).done(function(a){this.tid=a.tid,this.rollbackOnly=!1,this.readSet={},this.changeSet={}});return this.wait(a)}).then(a,b)},a.prototype.commit=function(a,b){return this.yield().then(function(){return this.getRollbackOnly()?this.rollback().then(function(){throw new f.RollbackError}):this.wait(this.entityManager.flush()).then(function(){var a=[];for(var b in this.readSet)a.push({oid:b,version:this.readSet[b]});var c=this.send(new e.PutTransactionCommitted(this.tid,a));return this.wait(c).then(function(a){this.tid=null,this.readSet=null,this.changeSet=null;var b=a.oids;for(var c in b){var d=b[c],e=this.entityManager.entities[c];if(e){var f=util.Metadata.get(e);"DELETED"==d||f.isDeleted?this.entityManager.removeReference(e):f.setJsonValue(f.type.version,d)}}})})}).then(a,b)},a.prototype.getRollbackOnly=function(){return this.rollbackOnly},a.prototype.rollback=function(a,b){return this.yield().then(function(){var a=this.send(new e.PutTransactionAborted(this.tid));this.wait(a).then(function(){return this.tid=null,this.readSet=null,this.changeSet=null,this.entityManager.clear()},function(){return this.entityManager.clear()})}).then(a,b)},a.prototype.setRollbackOnly=function(a,b){return this.yield().done(function(){this.rollbackOnly=!0})},a.prototype.isRead=function(a){return this.isActive&&a in this.readSet},a.prototype.setRead=function(a,b){this.isActive&&!this.isChanged(a)&&(this.readSet[a]=b)},a.prototype.isChanged=function(a){return this.isActive&&a in this.changeSet},a.prototype.setChanged=function(a){this.isActive&&(delete this.readSet[a],this.changeSet[a]=!0)},a}();c.exports=g},{34:34,36:36}],5:[function(a,c,d){"use strict";var e=function(){function a(c,d){b.classCallCheck(this,a);var e=void 0,f=void 0;if(Object(c)instanceof String){var g=c.indexOf(";");e=c.substring(0,g),f=c.substring(g+1)}else Object(c)instanceof Number?(e=c,f=d):Object(c)instanceof Array?(e=c[0],f=c[1]):c instanceof Object?(e=c.latitude,f=c.longitude):(e=0,f=0);if(this.longitude=f,this.latitude=e,this.latitude<-90||this.latitude>90)throw new Error("Latitude "+this.latitude+" is not in bound of -90 <= latitude <= 90");if(this.longitude<-180||this.longitude>180)throw new Error("Longitude "+this.longitude+" is not in bound of -180 <= longitude <= 180")}return a.current=function(){return new Promise(function(b,c){navigator.geolocation.getCurrentPosition(function(c){b(new a(c.coords.latitude,c.coords.longitude))},function(a){c(a)})})},a.prototype.kilometersTo=function(b){return Number((a.EARTH_RADIUS_IN_KILOMETERS*this.radiansTo(b)).toFixed(3))},a.prototype.milesTo=function(b){return Number((a.EARTH_RADIUS_IN_MILES*this.radiansTo(b)).toFixed(3))},a.prototype.radiansTo=function(b){var c=this,d=b,e=c.latitude*a.DEG_TO_RAD,f=d.latitude*a.DEG_TO_RAD,g=(d.longitude-c.longitude)*a.DEG_TO_RAD;return Math.acos(Math.sin(e)*Math.sin(f)+Math.cos(e)*Math.cos(f)*Math.cos(g))},a.prototype.toString=function(){return this.latitude+";"+this.longitude},a.prototype.toJSON=function(){return{latitude:this.latitude,longitude:this.longitude}},a}();e.DEG_TO_RAD=Math.PI/180,e.EARTH_RADIUS_IN_KILOMETERS=6371,e.EARTH_RADIUS_IN_MILES=3956,c.exports=e},{}],6:[function(a,b,c){"use strict";var d=a(3),e=a(2);e.prototype.binding=a(20),e.prototype.connector=a(28),e.prototype.error=a(34),e.prototype.message=a(36),e.prototype.metamodel=a(52),e.prototype.util=a(70),e.prototype.caching=a(22),e.prototype.query=a(59),e.prototype.EntityManager=a(2),e.prototype.EntityManagerFactory=a(3),e.prototype.EntityTransaction=a(4),e.prototype.Acl=a(1);var f=new d,g=f.createEntityManager(!0);g.configure=function(a){return f.configure(a),this},g.connect=function(a,b,c,d){return b instanceof Function&&(d=c,c=b,b=void 0),f.connect(a,b),this.ready(c,d)},c=b.exports=g,c.db=g,c.default=g},{1:1,2:2,20:20,22:22,28:28,3:3,34:34,36:36,4:4,52:52,59:59,70:70}],7:[function(a,c,d){"use strict";var e=function(){function a(){b.classCallCheck(this,a)}return a.prototype.getValue=function(a,b){return a[b.name]},a.prototype.setValue=function(a,b,c){a[b.name]=c},a}();c.exports=e},{}],8:[function(a,b,c){"use strict";var d=a(11),e=d.extend({get isRegistered(){return this._db.isDeviceRegistered},register:function(a,b,c,d,e){return c instanceof Function&&(e=d,d=c,c=null),this._db.registerDevice(a,b,c).then(d,e)},push:function(a,b,c){return this._db.pushDevice(a).then(b,c)}});e.PushMessage=a(66),b.exports=e},{11:11,66:66}],9:[function(a,c,d){"use strict";var e=(a(63),a(61),function(){function a(){b.classCallCheck(this,a)}return a.prototype.createProxy=function(a){return function(a){function c(){return b.classCallCheck(this,c),b.possibleConstructorReturn(this,a.apply(this,arguments))}return b.inherits(c,a),c}(a)},a.prototype.getIdentifier=function(a){return a.__d__},a.prototype.setIdentifier=function(a,b){Object.defineProperty(a,"__d__",{value:b})},a.prototype.enhance=function(a,b){if(b.__ype__!=a){if(b.hasOwnProperty("__ype__"))throw new Error("Type is already used by a different manager");Object.defineProperty(b,"__ype__",{value:a}),this.setIdentifier(b,a.ref),this.enhancePrototype(b.prototype,a)}},a.prototype.enhancePrototype=function(a,b){if(a.toString===Object.prototype.toString&&Object.defineProperty(a,"toString",{value:function(){return this._metadata.id||this._metadata.bucket},enumerable:!1}),b.superType&&"Object"==b.superType.name)for(var c=b.superType.declaredAttributes,d=Array.isArray(c),e=0,c=d?c:c[Symbol.iterator]();;){var f;if(d){if(e>=c.length)break;f=c[e++]}else{if(e=c.next(),e.done)break;f=e.value}var g=f;g.isMetadata||this.enhanceProperty(a,g)}for(var h=b.declaredAttributes,i=Array.isArray(h),j=0,h=i?h:h[Symbol.iterator]();;){var k;if(i){if(j>=h.length)break;k=h[j++]}else{if(j=h.next(),j.done)break;k=j.value}var l=k;this.enhanceProperty(a,l)}},a.prototype.enhanceProperty=function(a,b){var c="$"+b.name;Object.defineProperty(a,b.name,{get:function(){var a=this._metadata;return a.readAccess(),a[c]},set:function(a){var b=this._metadata;b.writeAccess(),b[c]=a},configurable:!0,enumerable:!0})},a}());c.exports=e},{61:61,63:63}],10:[function(a,c,d){"use strict";var e=a(15),f=function(a){function c(d){return b.classCallCheck(this,c),b.possibleConstructorReturn(this,a.call(this,d))}return b.inherits(c,a),c}(e);Object.defineProperties(f.prototype,{id:{get:function(){return this._metadata.id},set:function(a){if(this._metadata.id)throw new Error("The id can't be set twice: "+a);a+="",0==a.indexOf("/db/"+this._metadata.bucket+"/")?this._metadata.id=a:this.key=a},enumerable:!0},key:{get:function(){return this._metadata.key},set:function(a){this._metadata.key=a}},version:{get:function(){return this._metadata.version},enumerable:!0},acl:{get:function(){return this._metadata.acl},enumerable:!0},ready:{value:function(a){return this._metadata.ready(a)}},attach:{value:function(a){a.attach(this)}},save:{value:function(a,b,c){return a instanceof Function&&(c=b,b=a,a={}),this._metadata.db.save(this,a).then(b,c)}},insert:{value:function(a,b,c){return a instanceof Function&&(c=b,b=a,a={}),this._metadata.db.insert(this,a).then(b,c)}},update:{value:function(a,b,c){return a instanceof Function&&(c=b,b=a,a={}),this._metadata.db.update(this,a).then(b,c)}},load:{value:function(a,b,c){return a instanceof Function&&(c=b,b=a,a={}),a=a||{},a.local=!0,this._metadata.db.load(this.id,null,a).then(b,c)}},delete:{value:function(a,b,c){return a instanceof Function&&(c=b,b=a,a={}),this._metadata.db.delete(this,a).then(b,c)}},optimisticSave:{value:function(a,b,c){return this._metadata.db.optimisticSave(this,a).then(b,c)}},attr:{value:function(){throw new Error("Attr is not yet implemented.")}},validate:{value:function(){return this._metadata.db.validate(this)}},toJSON:{value:function(a){return this._metadata.getJson(a)}}}),c.exports=f},{15:15}],11:[function(a,b,c){"use strict";var d=a(16),e=d.extend({load:function(a,b,c,d){return b instanceof Function&&(d=c,c=b,b={}),this._db.load(this._managedType.typeConstructor,a,b).then(c,d)},fromJSON:function(a){var b=a.id?this._db.getReference(this._managedType.typeConstructor,a.id):this.newInstance(),c=b._metadata;return c.setJson(a),c.setDirty(),b},find:function(){return this._db.createQueryBuilder(this._managedType.typeConstructor)},partialUpdate:function(){throw new Error("partialUpdate is not yet implemented.")}});b.exports=e},{16:16}],12:[function(a,b,c){"use strict";function d(a){for(var b,c=1;b=arguments[c];++c)for(var d=Object.getOwnPropertyNames(b),e=Array.isArray(d),f=0,d=e?d:d[Symbol.iterator]();;){var g;if(e){if(f>=d.length)break;g=d[f++]}else{if(f=d.next(),f.done)break;g=f.value}var h=g;Object.defineProperty(a,h,Object.getOwnPropertyDescriptor(b,h))}return a}var e=d({extend:function(a){return d({},this,a)},create:function(a){var b=function(a){return b.newInstance(arguments)};return d(b,this),b.prototype=a.prototype,b._type=a,b},new:function(){return this.newInstance(arguments)},newInstance:function(a){var b;return b=a&&0!=a.length?new this._type(a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7],a[8],a[9]):new this._type}});b.exports=e},{}],13:[function(a,c,d){"use strict";var e=a(34),f=a(1),g=a(71),h=a(36),i=a(25).StatusCode,j="/file",k=j.length,l=function(){function a(c){if(b.classCallCheck(this,a),c=c||{},this._available=!1,Object(c)instanceof String){var d=c,e=d.indexOf("/","/file/".length);if(e==-1||0!=d.indexOf("/file/"))throw new Error("Invalid file reference "+d);this._id=d}else if(c.id)this._id=c.id,this._setMetadata(c);else{var f=void 0;if(c.path)f=c.path;else{var h=c.parent||"/www";if("/"!=h.charAt(h.length-1)&&(h+="/"),h.length<3)throw new Error("Invalid parent name: "+h);var i=c.name||c.data&&c.data.name||g.uuid();f=h+i}if("/"!=f.charAt(0)&&(f="/"+f),f.indexOf("//")!=-1||f.length<3)throw new Error("Invalid path: "+f);this._id=j+f,this._setMetadata(c)}this.isFolder="/"==this._id.charAt(this._id.length-1)}return b.createClass(a,[{key:"id",get:function(){return this._id}},{key:"url",get:function(){if(this.isFolder)throw new Error("Url can not be created for folders.");return this._url||(this._url=this._db.createURL(this.id,"www"!=this.bucket)),this._url}},{key:"name",get:function(){return this._name||(this._name=this._id.substring(this._id.lastIndexOf("/",this._id.length-2)+1)),this._name}},{key:"mimeType",get:function(){if(this.isFolder)throw new Error("A folder has no mimeType");return this._checkAvailable(),this._mimeType}},{key:"acl",get:function(){return this._checkAvailable(),this._acl}},{key:"lastModified",get:function(){if(this.isFolder)throw new Error("A folder has no lastModified");return this._checkAvailable(),this._lastModified}},{key:"eTag",get:function(){if(this.isFolder)throw new Error("A folder has no eTag");return this._checkAvailable(),this._eTag}},{key:"size",get:function(){if(this.isFolder)throw new Error("A folder has no size");return this._checkAvailable(),this._size}},{key:"bucket",get:function(){return this.id.substring(k+1,this.id.indexOf("/",k+1))}},{key:"key",get:function(){return this.id.substring(this.id.indexOf("/",k+1)+1)}},{key:"path",get:function(){return this.id.substring(k)}},{key:"parent",get:function(){return this.id.substring(k,this.id.lastIndexOf("/",this.id.length-2))}},{key:"isMetadataLoaded",get:function(){return this._available}}]),a.prototype.upload=function(a,b,c){var d=this;if(a=a||{},this.isFolder)throw new Error("A folder cannot be uploaded");this._setMetadata(a);var e=new h.UploadFile(this.bucket,this.key).entity(this._data,this._type).acl(this._acl);return e.progress(a.progress),this._size&&e.contentLength(this._size),this._mimeType&&e.mimeType(this._mimeType),this._conditional(e,a),this._db.addToBlackList(this.id),this._db.send(e).then(function(a){return d._data=null,d._type=null,d.fromJSON(a.entity),d}).then(b,c)},a.prototype.download=function(a,b,c){var d=this;if(a=a||{},this.isFolder)throw new Error("A folder cannot be downloaded");var e=a.type||"blob",f=new h.DownloadFile(this.bucket,this.key).responseType(e);return this._db.ensureCacheHeader(this.id,f,a.refresh),this._db.send(f).then(function(a){return d._db.addToWhiteList(d.id),d._fromHeaders(a.headers),a.entity},function(a){if(a.status==i.OBJECT_NOT_FOUND)return null;throw a}).then(b,c)},a.prototype.delete=function(a,b,c){if(a=a||{},this.isFolder)throw new Error("A folder cannot be deleted");var d=new h.DeleteFile(this.bucket,this.key);return this._conditional(d,a),this._db.addToBlackList(this.id),this._db.send(d).then(function(){return this}).then(b,c)},a.prototype._conditional=function(a,b){b.force||(this._lastModified&&a.ifUnmodifiedSince(this._lastModified),this._eTag&&a.ifMatch(this._eTag),this._lastModified||this._eTag||a.ifNoneMatch("*"))},a.prototype.loadMetadata=function(a,b,c){var d=this;if(a=a||{},this.isFolder)throw new Error("A folder has no matadata");var e=new h.GetFileMetadata(this.bucket,this.key);return this._db.ensureCacheHeader(this.id,e,a.refresh),this._db.send(e).then(function(a){return d._fromHeaders(a.headers),d},function(a){if(a.status==i.OBJECT_NOT_FOUND)return null;throw a}).then(b,c)},a.prototype.saveMetadata=function(a,b,c){var d=this;a=a||{};var e=this.toJSON();e.id=this._id;var f=new h.UpdateFileMetadata(this.bucket,this.key).entity(e);
+return this._conditional(f,a),this._db.send(f).then(function(a){return d.fromJSON(a),d})},a.prototype._setMetadata=function(a){var b=a.data,c=a.type,d=a.eTag,e=a.acl,g=a.size,h=a.mimeType,i=a.lastModified;if(b){if("undefined"!=typeof Blob&&b instanceof Blob)h=h||b.type;else if("data-url"==c){var j=b.match(/^data:(.+?)(;base64)?,.*$/);h=h||j[1]}this._data=b,this._type=c,this._size=g,this._mimeType=h,this._acl=e||this._acl||new f,this._available=!0}else this._available=!1;this._eTag=d||this._eTag,i&&(this._lastModified=new Date(i))},a.prototype._fromHeaders=function(a){this.fromJSON({eTag:a.etag?a.etag.substring(1,a.etag.length-1):null,lastModified:a["last-modified"],mimeType:a["content-type"],acl:a["baqend-acl"]&&JSON.parse(a["baqend-acl"]),contentLength:+a["baqend-size"]})},a.prototype.fromJSON=function(a){a.mimeType&&(this._mimeType=a.mimeType),a.lastModified&&(this._lastModified=new Date(a.lastModified)),a.eTag&&(this._eTag=a.eTag),this._acl=this._acl||new f,a.acl&&this._acl.fromJSON(a.acl),a.contentLength&&(this._size=a.contentLength),this._available=!0},a.prototype.toJSON=function(){var a={mimeType:this._mimeType,eTag:this._eTag,acl:this._acl,contentLength:this._size};return this._lastModified&&(a.lastModified=this._lastModified.toISOString()),a},a.prototype._checkAvailable=function(){if(!this._available)throw new e.PersistentError("The file metadata of "+this.id+" is not available.")},a}();c.exports=l},{1:1,25:25,34:34,36:36,71:71}],14:[function(a,b,c){"use strict";var d=a(12),e=a(13),f=a(36),g=a(65),h=d.extend({create:function(a){var b=d.create.call(this,e);return b._db=a,b},newInstance:function(a){var b=d.newInstance.call(this,a);return b._db=this._db,b},saveMetadata:function(a,b,c,d){var e=new f.SetFileBucketMetadata(a,b);return this._db.send(e).then(c,d)},loadMetadata:function(a,b,c,d){b=b||{};var e=new f.GetFileBucketMetadata(a);return this._db.send(e).then(function(a){var b={};return g.BASE_PERMISSIONS.forEach(function(c){b[c]=g.fromJSON(a.entity[c]||{})}),b},function(a){if(a.status==StatusCode.OBJECT_NOT_FOUND)return null;throw a}).then(c,d)},listBuckets:function(a,b){var c=this;return this._db.send(new f.ListBuckets).then(function(a){return a.entity.map(function(a){return c.new(a+"/")})}).then(a,b)},listFiles:function(a,b,c,d,e){var g=this;Object(a)instanceof String&&("/"!=a.charAt(a.length-1)&&(a+="/"),a=this.new({path:a}));var h=a.key,i=a.bucket;return b=b?b.key:null,this._db.send(new f.ListFiles(i,h,b,c)).then(function(a){return a.entity.map(function(a){return g.new(a)})}).then(d,e)}});b.exports=h},{12:12,13:13,36:36,65:65}],15:[function(a,c,d){"use strict";var e=a(63),f=function(){function a(c){b.classCallCheck(this,a),a.init(this,c)}return a.init=function(a,b){var c=a.constructor.__ype__;c&&Object.defineProperty(a,"_metadata",{value:e.create(c,a),configurable:!0}),b&&Object.assign(a,b)},a.extend=function(b){return b.prototype=Object.create(this.prototype,{constructor:{value:b,configurable:!0,writable:!0}}),b.extend=a.extend,b},a}();Object.defineProperties(f.prototype,{toJSON:{value:function(){return this._metadata.type.toJsonValue(this._metadata,this)}}}),c.exports=f},{63:63}],16:[function(a,b,c){"use strict";var d=a(12),e=(a(15),d.extend({create:function(a,b){var c=d.create.call(this,a.typeConstructor);return c.methods=c.prototype,c._managedType=a,c._db=b,c},newInstance:function(a){var b=a?d.newInstance.call(this,a):this._managedType.create(a);return b._metadata.db=this._db,b},fromJSON:function(a){var b=this.newInstance(),c=b._metadata;return this._managedType.fromJsonValue(c,a,b),b},addMethods:function(a){Object.assign(this.methods,a)},addMethod:function(a,b){this.methods[a]=b}}));b.exports=e},{12:12,15:15}],17:[function(a,c,d){"use strict";var e=a(10),f=a(18),g=function(a){function c(d){return b.classCallCheck(this,c),b.possibleConstructorReturn(this,a.call(this,d))}return b.inherits(c,a),c}(e);Object.defineProperties(g.prototype,{hasUser:{value:function(a){return this.users&&this.users.has(a)}},addUser:{value:function(a){if(!(a instanceof f))throw new Error("Only user instances can be added to a role.");this.users||(this.users=new Set),this.users.add(a)}},removeUser:{value:function(a){if(!(a instanceof f))throw new Error("Only user instances can be removed from a role.");this.users&&this.users.delete(a)}}}),c.exports=g},{10:10,18:18}],18:[function(a,c,d){"use strict";var e=a(10),f=function(a){function c(d){return b.classCallCheck(this,c),b.possibleConstructorReturn(this,a.call(this,d))}return b.inherits(c,a),c}(e);Object.defineProperties(f.prototype,{newPassword:{value:function(a,b,c,d){return this._metadata.db.newPassword(this.username,a,b).then(c,d)}}}),c.exports=f},{10:10}],19:[function(a,b,c){"use strict";var d=a(11),e=d.extend({get me(){return this._db.me},register:function(a,b,c,d,e){return c instanceof Function&&(e=d,d=c,c=!0),a=Object(a)instanceof String?this.fromJSON({username:a}):a,this._db.register(a,b,void 0===c||c).then(d,e)},login:function(a,b,c,d,e){return c instanceof Function&&(e=d,d=c,c=!0),this._db.login(a,b,void 0===c||c).then(d,e)},logout:function(a,b){return this._db.logout().then(a,b)},newPassword:function(a,b,c,d,e){return this._db.newPassword(a,b,c).then(d,e)}});e.LoginOption={NO_LOGIN:-1,SESSION_LOGIN:0,PERSIST_LOGIN:1},e.DefaultOptions={google:{width:585,height:545,scope:"email"},facebook:{width:1140,height:640,scope:"email"},github:{width:1040,height:580,scope:"user:email"},twitter:{width:740,height:730},linkedin:{width:630,height:530,scope:""}},["Google","Facebook","GitHub","Twitter","LinkedIn"].forEach(function(a){e["loginWith"+a]=function(b,c,d,f){return c instanceof Function&&(f=d,d=c,c={}),c=Object.assign({},e.DefaultOptions[a.toLowerCase()],c||{}),this._db.loginWithOAuth(a,b,c).then(d,f)}}),b.exports=e},{11:11}],20:[function(a,b,c){"use strict";c.Accessor=a(7),c.Enhancer=a(9),c.Factory=a(12),c.ManagedFactory=a(16),c.EntityFactory=a(11),c.UserFactory=a(19),c.DeviceFactory=a(8),c.FileFactory=a(14),c.Managed=a(15),c.Entity=a(10),c.Role=a(17),c.User=a(18),c.File=a(13)},{10:10,11:11,12:12,13:13,14:14,15:15,16:16,17:17,18:18,19:19,7:7,8:8,9:9}],21:[function(a,c,d){"use strict";var e=a(70).atob,f=function(){function a(c){b.classCallCheck(this,a),this.bytes=e(c.b),this.bits=c.m,this.hashes=c.h,this.creation=(new Date).getTime()}return a.prototype.contains=function(b){for(var c=a._getHashes(b,this.bits,this.hashes),d=Array.isArray(c),e=0,c=d?c:c[Symbol.iterator]();;){var f;if(d){if(e>=c.length)break;f=c[e++]}else{if(e=c.next(),e.done)break;f=e.value}var g=f;if(!this._isSet(g))return!1}return!0},a.prototype._isSet=function(a){var b=Math.floor(a/8),c=1<>>16)*g&65535)<<16)&4294967295,i=i<<15|i>>>17,i=(65535&i)*h+(((i>>>16)*h&65535)<<16)&4294967295,e^=i,e=e<<13|e>>>19,f=5*(65535&e)+((5*(e>>>16)&65535)<<16)&4294967295,e=(65535&f)+27492+(((f>>>16)+58964&65535)<<16);switch(i=0,c){case 3:i^=(255&b.charCodeAt(j+2))<<16;case 2:i^=(255&b.charCodeAt(j+1))<<8;case 1:i^=255&b.charCodeAt(j),i=(65535&i)*g+(((i>>>16)*g&65535)<<16)&4294967295,i=i<<15|i>>>17,i=(65535&i)*h+(((i>>>16)*h&65535)<<16)&4294967295,e^=i}return e^=b.length,e^=e>>>16,e=2246822507*(65535&e)+((2246822507*(e>>>16)&65535)<<16)&4294967295,e^=e>>>13,e=3266489909*(65535&e)+((3266489909*(e>>>16)&65535)<<16)&4294967295,e^=e>>>16,e>>>0},a}();c.exports=f},{70:70}],22:[function(a,b,c){"use strict";c.BloomFilter=a(21)},{21:21}],23:[function(a,c,d){"use strict";var e=a(32),f=(a(36),function(){function a(c,d,e,f){b.classCallCheck(this,a),this.host=c,this.port=d,this.secure=e,this.basePath=f,this.origin=a.toUri(c,d,e,"")}return a.create=function(b,c,d,e){if("undefined"!=typeof window&&(b||(b=window.location.hostname,c=Number(window.location.port)),void 0===d&&(d="https:"==window.location.protocol)),d=!!d,void 0===e&&(e=a.DEFAULT_BASE_PATH),b.indexOf("/")!=-1){var f=/^(https?):\/\/([^\/:]+|\[[^\]]+])(:(\d*))?(\/\w+)?\/?$/.exec(b);if(!f)throw new Error("The connection uri host "+b+" seems not to be valid");d="https"==f[1],b=f[2].replace(/(\[|])/g,""),c=f[4],e=f[5]||""}else"localhost"!=b&&/^[a-z0-9-]*$/.test(b)&&(b+=d?a.SSL_DOMAIN:a.HTTP_DOMAIN);c||(c=d?443:80);var g=a.toUri(b,c,d,e),h=this.connections[g];if(!h){for(var i in this.connectors){var j=this.connectors[i];if(j.isUsable&&j.isUsable(b,c,d,e)){h=new j(b,c,d,e);break}}if(!h)throw new Error("No connector is usable for the requested connection.");this.connections[g]=h}return h},a.toUri=function(a,b,c,d){var e=(c?"https://":"http://")+(a.indexOf(":")!=-1?"["+a+"]":a);return e+=c&&443!=b||!c&&80!=b?":"+b:"",e+=d},a.prototype.send=function(a){var b=this;"OAUTH"==a.request.method&&a.addRedirectOrigin(this.origin+this.basePath);var c={status:0};return new Promise(function(c){b.prepareRequest(a),b.doSend(a,a.request,c)}).then(function(a){return c=a}).then(function(){return b.prepareResponse(a,c)}).then(function(){return a.doReceive(c),c}).catch(function(a){throw c.entity=null,e.of(a)})},a.prototype.doSend=function(a,b,c){},a.prototype.prepareRequest=function(a){var b=a.mimeType();if(!b){var c=a.request.type;"json"==c?a.mimeType("application/json;charset=utf-8"):"text"==c&&a.mimeType("text/plain;charset=utf-8")}this.toFormat(a);var d=void 0;switch(a.responseType()){case"json":d="application/json";break;case"text":d="text/*";break;default:d="application/json,text/*;q=0.5,*/*;q=0.1"}if(a.accept()||a.accept(d),this.gzip){var e=a.ifNoneMatch();e&&'""'!==e&&"*"!=e&&a.ifNoneMatch(e.slice(0,-1)+'--gzip"')}if("/connect"==a.request.path)a.request.path=a.tokenStorage.signPath(this.basePath+a.request.path).substring(this.basePath.length),a.cacheControl()&&(a.request.path+=(a.tokenStorage.token?"&":"?")+"BCB");else if(a.tokenStorage){var f=a.tokenStorage.token;f&&a.header("authorization","BAT "+f)}},a.prototype.toFormat=function(a){},a.prototype.prepareResponse=function(a,b){var c=this;b.status=1223==b.status?204:b.status;var d=void 0,e=b.headers||{},f=b.entity;if(f&&(d=a.responseType(),!d||b.status>=400)){var g=e["content-type"]||e["Content-Type"];g&&g.indexOf("application/json")>-1&&(d="json")}if(e.etag&&(e.etag=e.etag.replace("--gzip","")),a.tokenStorage){var h=e["baqend-authorization-token"]||e["Baqend-Authorization-Token"];h&&a.tokenStorage.update(h)}return new Promise(function(a){a(f&&c.fromFormat(b,f,d))}).then(function(d){b.entity=d,a.request.path.indexOf("/connect")!=-1&&d&&(c.gzip=!!d.gzip)},function(a){throw new Error("Response was not valid "+d+": "+a.message)})},a.prototype.fromFormat=function(a,b,c){},a}());Object.assign(f,{DEFAULT_BASE_PATH:"/v1",HTTP_DOMAIN:".app.baqend.com",SSL_DOMAIN:"-bq.global.ssl.fastly.net",RESPONSE_HEADERS:["baqend-authorization-token","content-type","baqend-size","baqend-acl","etag","last-modified"],connectors:[],connections:{},gzip:!1}),c.exports=f},{32:32,36:36}],24:[function(a,c,d){"use strict";var e=a(23),f=a(27),g=function(a){function c(d,e,f,g){b.classCallCheck(this,c);var h=b.possibleConstructorReturn(this,a.call(this,d,e,f,g));return h.mid=0,h.messages={},h.doReceive=h.doReceive.bind(h),addEventListener("message",h.doReceive,!1),h}return b.inherits(c,a),c.isUsable=function(a,b,c){return"undefined"!=typeof window},c.prototype.load=function(a){this.iframe=document.createElement("iframe"),this.iframe.src=this.origin+this.basePath+a,this.iframe.setAttribute("style",c.style),document.body.appendChild(this.iframe),this.queue=[],this.iframe.addEventListener("load",this.onLoad.bind(this),!1)},c.prototype.onLoad=function(){for(var a=this.queue,b=0;b=400&&(g="json"),"stream"==g)return void c({status:e,headers:a.headers,entity:a});var f=g&&"text"!=g&&"json"!=g,h=[];f||a.setEncoding("utf-8"),a.on("data",function(a){h.push(a)}),a.on("end",function(){c({status:e,headers:a.headers,entity:f?Buffer.concat(h):h.join("")})})});h.on("error",function(a){c({status:0,error:a})}),"stream"==f?e.pipe(h):"buffer"==f?h.end(e):f?h.end(e,"utf8"):h.end()},d.prototype.parseCookie=function(a){for(var b,c=a.split(";"),d=0;b=c[d];++d)if(0==b.indexOf("Expires=")){var e=Date.parse(b.substring(8));if(e=400&&(d.responseType="text"),4==d.readyState){var a={headers:{},status:d.status,entity:d.response||d.responseText};e.RESPONSE_HEADERS.forEach(function(b){a.headers[b]=d.getResponseHeader(b)}),c(a)}},d.upload.onprogress=a.progress(),d.open(b.method,f,!0);var g=b.entity,h=b.headers;for(var i in h)d.setRequestHeader(i,h[i]);switch(d.withCredentials=a.withCredentials,a.responseType()){case"arraybuffer":d.responseType="arraybuffer";break;case"blob":case"data-url":case"base64":d.responseType="blob"}d.send(g)},c.prototype.fromFormat=function(a,c,d){if("json"==d)c=JSON.parse(c);else if("data-url"==d||"base64"==d){var e=function(){var a=new FileReader;return a.readAsDataURL(c),{v:new Promise(function(b,c){a.onload=b,a.onerror=c}).then(function(){var b=a.result;return"base64"==d&&(b=b.substring(b.indexOf(",")+1)),b})}}();if("object"===("undefined"==typeof e?"undefined":b.typeof(e)))return e.v}return c},c.prototype.toFormat=function(a){var b=a.request.type;if(b){var c=a.request.entity,d=a.mimeType();switch(b){case"blob":d=d||c.type;break;case"arraybuffer":case"form":break;case"data-url":var e=c.match(/^data:(.+?)(;base64)?,(.*)$/),f=e[2];if(c=e[3],b="blob",d=d||e[1],!f){c=decodeURIComponent(c);break}case"base64":for(var g=atob(c),h=g.length,i=new Uint8Array(h),j=0;ja.PersistentAttributeType.EMBEDDED}},{key:"isCollection",get:function(){return this.persistentAttributeType==a.PersistentAttributeType.ELEMENT_COLLECTION}}]),a.prototype.init=function(a,b){
+if(this.declaringType)throw new Error("The attribute is already initialized.");this.order=b,this.accessor=new e,this.declaringType=a},a.prototype.getValue=function(a){return this.accessor.getValue(a,this)},a.prototype.setValue=function(a,b){this.accessor.setValue(a,this,b)},a.prototype.getJsonValue=function(a,b){},a.prototype.setJsonValue=function(a,b,c){},a.prototype.toJSON=function(){},a}();f.PersistentAttributeType={BASIC:0,ELEMENT_COLLECTION:1,EMBEDDED:2,MANY_TO_MANY:3,MANY_TO_ONE:4,ONE_TO_MANY:5,ONE_TO_ONE:6},c.exports=f},{7:7}],38:[function(a,c,d){"use strict";function e(a){return a instanceof Date?a.toISOString().replace(/\.?0*Z/,"Z"):null}function f(a,b){var c="string"==typeof a?new Date(a):null;return b&&c&&b.toISOString()==c.toISOString()?b:c}var g=a(51),h=a(5),i=function(a){function c(d,e,f){b.classCallCheck(this,c),0!=d.indexOf("/db/")&&(d="/db/"+d);var g=b.possibleConstructorReturn(this,a.call(this,d,e));return g.noResolving=f,g}return b.inherits(c,a),b.createClass(c,[{key:"persistenceType",get:function(){return g.PersistenceType.BASIC}}]),c.prototype.toJsonValue=function(a,b){return null===b||void 0===b?null:this.typeConstructor(b)},c.prototype.fromJsonValue=function(a,b,c){return null===b||void 0===b?null:b},c.prototype.toString=function(){return"BasicType("+this.ref+")"},c}(g);Object.assign(i,{Boolean:new(function(a){function c(){return b.classCallCheck(this,c),b.possibleConstructorReturn(this,a.apply(this,arguments))}return b.inherits(c,a),c.prototype.fromJsonValue=function(b,c,d){return"string"==typeof c?"false"!==c:a.prototype.fromJsonValue.call(this,b,c,d)},c}(i))("Boolean",Boolean),Double:new(function(a){function c(){return b.classCallCheck(this,c),b.possibleConstructorReturn(this,a.apply(this,arguments))}return b.inherits(c,a),c.prototype.fromJsonValue=function(b,c,d){return"string"==typeof c?parseFloat(c):a.prototype.fromJsonValue.call(this,b,c,d)},c}(i))("Double",Number),Integer:new(function(a){function c(){return b.classCallCheck(this,c),b.possibleConstructorReturn(this,a.apply(this,arguments))}return b.inherits(c,a),c.prototype.fromJsonValue=function(b,c,d){return"string"==typeof c?parseInt(c):a.prototype.fromJsonValue.call(this,b,c,d)},c}(i))("Integer",Number),String:new(function(a){function c(){return b.classCallCheck(this,c),b.possibleConstructorReturn(this,a.apply(this,arguments))}return b.inherits(c,a),c}(i))("String",String),DateTime:new(function(a){function c(){return b.classCallCheck(this,c),b.possibleConstructorReturn(this,a.apply(this,arguments))}return b.inherits(c,a),c.prototype.toJsonValue=function(a,b){return e(b)},c.prototype.fromJsonValue=function(a,b,c){return f(b,c)},c}(i))("DateTime",Date),Date:new(function(a){function c(){return b.classCallCheck(this,c),b.possibleConstructorReturn(this,a.apply(this,arguments))}return b.inherits(c,a),c.prototype.toJsonValue=function(a,b){var c=e(b);return c?c.substring(0,c.indexOf("T")):null},c.prototype.fromJsonValue=function(a,b,c){return f(b,c)},c}(i))("Date",Date),Time:new(function(a){function c(){return b.classCallCheck(this,c),b.possibleConstructorReturn(this,a.apply(this,arguments))}return b.inherits(c,a),c.prototype.toJsonValue=function(a,b){var c=e(b);return c?c.substring(c.indexOf("T")+1):null},c.prototype.fromJsonValue=function(a,b,c){return"string"==typeof b?f("1970-01-01T"+b,c):b},c}(i))("Time",Date),GeoPoint:new(function(a){function c(){return b.classCallCheck(this,c),b.possibleConstructorReturn(this,a.apply(this,arguments))}return b.inherits(c,a),c.prototype.toJsonValue=function(a,b){return b instanceof h?b:null},c.prototype.fromJsonValue=function(a,b){return b?new h(b):null},c}(i))("GeoPoint",h),JsonArray:new(function(a){function c(){return b.classCallCheck(this,c),b.possibleConstructorReturn(this,a.apply(this,arguments))}return b.inherits(c,a),c.prototype.init=function(a){this._enhancer=a},c.prototype.toJsonValue=function(a,b){return Array.isArray(b)?b:null},c.prototype.fromJsonValue=function(a,b){return Array.isArray(b)?b:null},c}(i))("JsonArray",Array),JsonObject:new(function(a){function c(){return b.classCallCheck(this,c),b.possibleConstructorReturn(this,a.apply(this,arguments))}return b.inherits(c,a),c.prototype.init=function(a){this._enhancer=a},c.prototype.toJsonValue=function(a,b){return b&&b.constructor==Object?b:null},c}(i))("JsonObject",Object)}),c.exports=i},{5:5,51:51}],39:[function(a,c,d){"use strict";var e=a(48),f=function(a){function c(d,e){b.classCallCheck(this,c);var f=b.possibleConstructorReturn(this,a.call(this,d,e));return f.typeConstructor=null,f}return b.inherits(c,a),b.createClass(c,[{key:"collectionType",get:function(){return e.CollectionType.COLLECTION}}]),c}(e);c.exports=f},{48:48}],40:[function(a,c,d){"use strict";var e=function(){function a(c,d){if(b.classCallCheck(this,a),Object(c)instanceof String){var e={};e[c]=a.ASC,this.keys=[e]}else if(Object(c)instanceof Array)this.keys=c;else{if(!c)throw new Error("The keys parameter must be an String, Object or Array.");this.keys=[c]}this.drop=!1,this.unique=d===!0}return a.prototype.hasKey=function(a){for(var b=0;b1}},{key:"isUnique",get:function(){return this.unique}}]),a}();Object.assign(e,{ASC:"asc",DESC:"desc",GEO:"geo",fromJSON:function(a){return new e(a.keys,a.unique)}}),c.exports=e},{}],41:[function(a,c,d){"use strict";var e=a(44),f=a(51),g=a(20),h=function(a){function c(d,e){return b.classCallCheck(this,c),b.possibleConstructorReturn(this,a.call(this,d,e))}return b.inherits(c,a),b.createClass(c,[{key:"persistenceType",get:function(){return f.PersistenceType.EMBEDDABLE}}]),c.prototype.createProxyClass=function(){return this._enhancer.createProxy(g.Managed)},c.prototype.createObjectFactory=function(a){return g.ManagedFactory.create(this,a)},c.prototype.toJsonValue=function(b,c){return b._root&&c instanceof this.typeConstructor&&!c._metadata._root&&(c._metadata._root=b._root),a.prototype.toJsonValue.call(this,b,c)},c.prototype.fromJsonValue=function(b,c,d){return c&&(d instanceof this.typeConstructor||(d=this.create()),b._root&&!d._metadata._root&&(d._metadata._root=b._root)),a.prototype.fromJsonValue.call(this,b,c,d)},c.prototype.toString=function(){return"EmbeddableType("+this.ref+")"},c}(e);c.exports=h},{20:20,44:44,51:51}],42:[function(a,c,d){"use strict";var e=a(20),f=a(50),g=a(38),h=a(51),i=a(44),j=a(70),k=function(a){function c(d,e,f){b.classCallCheck(this,c);var g=b.possibleConstructorReturn(this,a.call(this,d,f));return g.declaredId=null,g.declaredVersion=null,g.declaredAcl=null,g.superType=e,g.loadPermission=new j.Permission,g.updatePermission=new j.Permission,g.deletePermission=new j.Permission,g.queryPermission=new j.Permission,g.schemaSubclassPermission=new j.Permission,g.insertPermission=new j.Permission,g}return b.inherits(c,a),b.createClass(c,[{key:"persistenceType",get:function(){return h.PersistenceType.ENTITY}},{key:"id",get:function(){return this.declaredId||this.superType.id}},{key:"version",get:function(){return this.declaredVersion||this.superType.version}},{key:"acl",get:function(){return this.declaredAcl||this.superType.acl}}]),c.prototype.createProxyClass=function(){var a=this.superType.typeConstructor;if(a===Object)switch(this.name){case"User":a=e.User;break;case"Role":a=e.Role;break;default:a=e.Entity}return this._enhancer.createProxy(a)},c.prototype.createObjectFactory=function(a){switch(this.name){case"User":return e.UserFactory.create(this,a);case"Device":return e.DeviceFactory.create(this,a);case"Object":return}return e.EntityFactory.create(this,a)},c.prototype.fromJsonValue=function(b,c,d,e){return e?a.prototype.fromJsonValue.call(this,b,c,d):c?b.db.getReference(c):null},c.prototype.toJsonValue=function(b,c,d){return d?a.prototype.toJsonValue.call(this,b,c):c instanceof this.typeConstructor?(c.attach(b.db),c.id):null},c.prototype.toString=function(){return"EntityType("+this.ref+")"},c.prototype.toJSON=function(){var b=a.prototype.toJSON.call(this);return b.acl.schemaSubclass=this.schemaSubclassPermission,b.acl.insert=this.insertPermission,b.acl.update=this.updatePermission,b.acl.delete=this.deletePermission,b.acl.query=this.queryPermission,b},c}(i),l=function(a){function c(){b.classCallCheck(this,c);var d=b.possibleConstructorReturn(this,a.call(this,k.Object.ref,null,Object));return d.declaredId=new f("id",g.String,!0),d.declaredId.init(d,0),d.declaredId.isId=!0,d.declaredVersion=new f("version",g.Double,!0),d.declaredVersion.init(d,1),d.declaredVersion.isVersion=!0,d.declaredAcl=new f("acl",g.JsonObject,!0),d.declaredAcl.init(d,2),d.declaredAcl.isAcl=!0,d.declaredAttributes=[d.declaredId,d.declaredVersion,d.declaredAcl],d}return b.inherits(c,a),b.createClass(c,null,[{key:"ref",get:function(){return"/db/Object"}}]),c}(k);k.Object=l,c.exports=k},{20:20,38:38,44:44,50:50,51:51,70:70}],43:[function(a,c,d){"use strict";var e=a(48),f=function(a){function c(d,e){b.classCallCheck(this,c);var f=b.possibleConstructorReturn(this,a.call(this,d,e));return f.typeConstructor=Array,f}return b.inherits(c,a),b.createClass(c,[{key:"collectionType",get:function(){return e.CollectionType.LIST}}],[{key:"ref",get:function(){return"/db/collection.List"}}]),c.prototype.getJsonValue=function(a,b){var c=this.getValue(b);if(c instanceof this.typeConstructor){for(var d=c.length,e=new Array(d),f=c.__persistedState__||[],g=f.length!=d,h=new Array(d),i=0;i=b.length)break;e=b[d++]}else{if(d=b.next(),d.done)break;e=d.value}var f=e;if(f.name===a||f.order===a)return f}return null},c.prototype.fromJsonValue=function(a,b,c){if(b)for(var d=this.attributes(),e=Array.isArray(d),f=0,d=e?d:d[Symbol.iterator]();;){var g;if(e){if(f>=d.length)break;g=d[f++]}else{if(f=d.next(),f.done)break;g=f.value}var h=g;h.isMetadata||h.setJsonValue(a,c,b[h.name])}else c=null;return c},c.prototype.toJsonValue=function(a,b){var c=null;if(b instanceof this.typeConstructor){c={};for(var d=this.attributes(),e=Array.isArray(d),f=0,d=e?d:d[Symbol.iterator]();;){var g;if(e){if(f>=d.length)break;g=d[f++]}else{if(f=d.next(),f.done)break;g=f.value}var h=g;h.isMetadata||(c[h.name]=h.getJsonValue(a,b))}}return c},c.prototype.toJSON=function(){var a={};a.class=this.ref,this.superType&&(a.superClass=this.superType.ref),this.isEmbeddable&&(a.embedded=!0),a.acl={load:this.loadPermission,schemaAdd:this.schemaAddPermission,schemaReplace:this.schemaReplacePermission};for(var b=a.fields={},c=this.declaredAttributes,d=Array.isArray(c),e=0,c=d?c:c[Symbol.iterator]();;){var f;if(d){if(e>=c.length)break;f=c[e++]}else{if(e=c.next(),e.done)break;f=e.value}var g=f;g.isMetadata||(b[g.name]=g)}return a},c.prototype.references=function(){var a,b=this.attributes(),c=[];return a={},a[Symbol.iterator]=function(){return this},a.next=function(){for(var a=b,d=Array.isArray(a),e=0,a=d?a:a[Symbol.iterator]();;){var f;if(d){if(e>=a.length)break;f=a[e++]}else{if(e=a.next(),e.done)break;f=e.value}var g=f,h=g.isCollection?g.elementType:g.type;if(h.isEntity)return{done:!1,value:{path:[g.name]}};if(h.isEmbeddable)for(var i=h.references(),j=Array.isArray(i),k=0,i=j?i:i[Symbol.iterator]();;){var l;if(j){if(k>=i.length)break;l=i[k++]}else{if(k=i.next(),k.done)break;l=k.value}var m=l;c.push({done:!1,value:{path:[g.name].concat(m.path)}})}}return c.length?c.pop():{done:!0}},a},c}(e);c.exports=i},{20:20,51:51,65:65,69:69}],45:[function(a,c,d){"use strict";var e=a(48),f=a(32),g=function(a){function c(d,e,f){b.classCallCheck(this,c);var g=b.possibleConstructorReturn(this,a.call(this,d,f));return g.keyType=e,g.typeConstructor=Map,g}return b.inherits(c,a),b.createClass(c,[{key:"collectionType",get:function(){return e.CollectionType.MAP}}],[{key:"ref",get:function(){return"/db/collection.Map"}}]),c.prototype.getJsonValue=function(a,b){var c=this.getValue(b);if(c instanceof this.typeConstructor){for(var d={},e=c.__persistedState__||{},g=c.__persistedSize__!==c.size,h={},i=c.entries(),j=Array.isArray(i),k=0,i=j?i:i[Symbol.iterator]();;){var l;if(j){if(k>=i.length)break;l=i[k++]}else{if(k=i.next(),k.done)break;l=k.value}var m=l;if(null===m[0]||void 0===m[0])throw new f("Map keys can't be null nor undefined.");var n=this.keyType.toJsonValue(a,m[0]);h[n]=this.elementType.toJsonValue(a,m[1]),d[n]=[m[0],m[1]],g|=(e[n]||[])[1]!==m[1]}return a.isReady||(Object.defineProperties(c,{__persistedState__:{value:d,configurable:!0},__persistedSize__:{value:c.size,configurable:!0}}),a.isPersistent&&g&&a.setDirty()),h}return null},c.prototype.setJsonValue=function(a,b,c){var d=null;if(c){d=this.getValue(b),d instanceof this.typeConstructor||(d=new this.typeConstructor);var e={},f=d.__persistedState__||{};d.clear();for(var g in c){var h=f[g]||[],i=this.keyType.fromJsonValue(a,g,h[0]),j=this.elementType.fromJsonValue(a,c[g],h[1]);e[g]=[i,d],d.set(i,j)}a.isReady||Object.defineProperties(d,{__persistedState__:{value:e,configurable:!0},__persistedSize__:{value:d.size,configurable:!0}})}this.setValue(b,d)},c.prototype.toJSON=function(){return{name:this.name,type:c.ref+"["+this.keyType.ref+","+this.elementType.ref+"]",order:this.order}},c}(e);c.exports=g},{32:32,48:48}],46:[function(a,c,d){"use strict";var e=(a(38),a(44)),f=a(42),g=a(9),h=a(47),i=a(40),j=a(61),k=a(25).StatusCode,l=a(36),m=function(a){function c(d){b.classCallCheck(this,c);var e=b.possibleConstructorReturn(this,a.call(this));return e.isInitialized=!1,e.entityManagerFactory=d,e.entities=null,e.embeddables=null,e.baseTypes=null,e._enhancer=new g,e}return b.inherits(c,a),c.prototype.init=function(a){if(this.isInitialized)throw new Error("Metamodel is already initialized.");this.fromJSON(a||[]),this.isInitialized=!0},c.prototype._getRef=function(a){var b;return Object(a)instanceof String?(b=a,0!=b.indexOf("/db/")&&(b="/db/"+a)):b=this._enhancer.getIdentifier(a),b},c.prototype.entity=function(a){var b=this._getRef(a);return b?this.entities[b]:null},c.prototype.baseType=function(a){var b=null;if(Object(a)instanceof String)b=this._getRef(a);else for(var c in this.baseTypes){var d=this.baseTypes[c];if(!d.noResolving&&d.typeConstructor==a){b=c;break}}return b?this.baseTypes[b]:null},c.prototype.embeddable=function(a){var b=this._getRef(a);return b?this.embeddables[b]:null},c.prototype.managedType=function(a){return this.baseType(a)||this.entity(a)||this.embeddable(a)},c.prototype.addType=function(a){var b;if(a.isBasic?b=this.baseTypes:a.isEmbeddable?(a.init(this._enhancer),b=this.embeddables):a.isEntity&&(a.init(this._enhancer),b=this.entities,null==a.superType&&a.ref!=f.Object.ref&&(a.superType=this.entity(f.Object.ref))),b[a.ref])throw new Error("The type "+a.ref+" is already declared.");return b[a.ref]=a},c.prototype.load=function(){var a=this;if(this.isInitialized)throw new Error("Metamodel is already initialized.");return this.withLock(function(){var b=new l.GetAllSchemas;return a.entityManagerFactory.send(b).then(function(b){return a.init(b.entity),a})})},c.prototype.save=function(a){var b=this;return this._send(a||this.toJSON()).then(function(){return b})},c.prototype.update=function(a){var b=this;return this._send(a).then(function(a){return b.fromJSON(a.entity),b})},c.prototype._send=function(a){var b=this;if(!this.isInitialized)throw new Error("Metamodel is not initialized.");return this.withLock(function(){var c;return c=a instanceof e?new l.UpdateSchema(a.name,a.toJSON()):new l.UpdateAllSchemas(a),b.entityManagerFactory.send(c)})},c.prototype.toJSON=function(){var a=[];for(var b in this.entities)a.push(this.entities[b]);for(b in this.embeddables)a.push(this.embeddables[b]);return a},c.prototype.fromJSON=function(a){var b=new h,c=b.buildModels(a);this.baseTypes={},this.embeddables={},this.entities={};for(var d in c){var e=c[d];this.addType(e)}},c.prototype.createIndex=function(a,b){b.drop=!1;var c=new l.CreateDropIndex(a,b.toJSON());return this.entityManagerFactory.send(c)},c.prototype.dropIndex=function(a,b){b.drop=!0;var c=new l.CreateDropIndex(a,b.toJSON());return this.entityManagerFactory.send(c)},c.prototype.dropAllIndexes=function(a){var b=new l.DropAllIndexes(a);return this.entityManagerFactory.send(b)},c.prototype.getIndexes=function(a){var b=new l.ListIndexes(a);return this.entityManagerFactory.send(b).then(function(a){return a.entity.map(function(a){return new i(a.keys,a.unique)})},function(a){if(a.status==k.BUCKET_NOT_FOUND||a.status==k.OBJECT_NOT_FOUND)return null;throw a})},c}(j);c.exports=m},{25:25,36:36,38:38,40:40,42:42,44:44,47:47,61:61,9:9}],47:[function(a,c,d){"use strict";var e=a(38),f=a(42),g=a(41),h=a(43),i=a(45),j=a(49),k=a(50),l=a(32),m=function(){function a(){b.classCallCheck(this,a),this.models={},this.modelDescriptors=null;for(var c=Object.keys(e),d=Array.isArray(c),f=0,c=d?c:c[Symbol.iterator]();;){var g;if(d){if(f>=c.length)break;g=c[f++]}else{if(f=c.next(),f.done)break;g=f.value}var h=g,i=e[h];i instanceof e&&(this.models[i.ref]=i)}}return a.prototype.getModel=function(a){return a in this.models?this.models[a]:this.models[a]=this.buildModel(a)},a.prototype.buildModels=function(a){this.modelDescriptors={};for(var b,c=0;b=a[c];++c)this.modelDescriptors[b.class]=b;for(var d in this.modelDescriptors)try{var e=this.getModel(d);this.buildAttributes(e)}catch(a){throw new l("Can't create model for entity class "+d,a)}return this.getModel(f.Object.ref),this.models},a.prototype.buildModel=function(a){var b,c=this.modelDescriptors[a];if(a==f.Object.ref)b=new f.Object;else{if(!c)throw new TypeError("No model available for "+a);if(c.embedded)b=new g(a);else{var d=c.superClass||f.Object.ref;b=new f(a,this.getModel(d))}}if(c){var e=c.acl;for(var h in e)b[h+"Permission"].fromJSON(e[h])}return b},a.prototype.buildAttributes=function(a){var b=this.modelDescriptors[a.ref],c=b.fields;for(var d in c){var e=c[d];a.getAttribute(d)||a.addAttribute(this.buildAttribute(e.name,e.type),e.order)}b.validationCode&&(a.validationCode=b.validationCode)},a.prototype.buildAttribute=function(a,b){if(0!=b.indexOf("/db/collection."))return new k(a,this.getModel(b));var c=b.substring(0,b.indexOf("[")),d=b.substring(b.indexOf("[")+1,b.indexOf("]")).trim();switch(c){case h.ref:return new h(a,this.getModel(d));case j.ref:return new j(a,this.getModel(d));case i.ref:var e=d.substring(0,d.indexOf(",")).trim();return d=d.substring(d.indexOf(",")+1).trim(),new i(a,this.getModel(e),this.getModel(d));default:throw new TypeError("No collection available for "+b)}},a}();c.exports=m},{32:32,38:38,41:41,42:42,43:43,45:45,49:49,50:50}],48:[function(a,c,d){"use strict";var e=a(37),f=function(a){function c(d,e){b.classCallCheck(this,c);var f=b.possibleConstructorReturn(this,a.call(this,d));return f.elementType=e,f.typeConstructor=null,f}return b.inherits(c,a),b.createClass(c,[{key:"persistentAttributeType",get:function(){return e.PersistentAttributeType.ELEMENT_COLLECTION}}]),c}(e);f.CollectionType={COLLECTION:0,LIST:1,MAP:2,SET:3},c.exports=f},{37:37}],49:[function(a,c,d){"use strict";var e=a(48),f=function(a){function c(d,e){b.classCallCheck(this,c);var f=b.possibleConstructorReturn(this,a.call(this,d,e));return f.typeConstructor=Set,f}return b.inherits(c,a),b.createClass(c,[{key:"collectionType",get:function(){return e.CollectionType.SET}}],[{key:"ref",get:function(){return"/db/collection.Set"}}]),c.prototype.getJsonValue=function(a,b){var c=this.getValue(b);if(c instanceof this.typeConstructor){for(var d={},e=c.__persistedState__||{},f=c.__persistedSize__!==c.size,g=[],h=c,i=Array.isArray(h),j=0,h=i?h:h[Symbol.iterator]();;){var k;if(i){if(j>=h.length)break;k=h[j++]}else{if(j=h.next(),j.done)break;k=j.value}var l=k,m=this.elementType.toJsonValue(a,l);g.push(m),d[m]=l,f|=e[m]!==l}return a.isReady||(Object.defineProperties(c,{__persistedState__:{value:d,configurable:!0},__persistedSize__:{value:c.size,configurable:!0}}),a.isPersistent&&f&&a.setDirty()),g}return null},c.prototype.setJsonValue=function(a,b,c){var d=null;if(c){d=this.getValue(b),d instanceof this.typeConstructor||(d=new this.typeConstructor);var e={},f=d.__persistedState__||{};d.clear();for(var g=0,h=c.length;ge.MAX_URI_SIZE?new f.AdhocQueryPOST(g.name,this.firstResult,this.maxResults,j).entity(i,"text"):new f.AdhocQuery(g.name,i,this.firstResult,this.maxResults,j),this.entityManager.send(h).then(function(b){return d._createResultList(b.entity,a)}).then(b,c)},c.prototype.singleResult=function(a,b,c){var d=this;a instanceof Function&&(c=b,b=a,a={});var g=this.resultClass?this.entityManager.metamodel.entity(this.resultClass):null;if(!g)throw new Error("Only typed queries can be executed.");var h,i=this._serializeQuery(),j=this._serializeSort(),k=this.entityManager._connector.host.length+i.length;return h=k>e.MAX_URI_SIZE?new f.AdhocQueryPOST(g.name,i,this.firstResult,1,j).entity(i,"text"):new f.AdhocQuery(g.name,i,this.firstResult,1,j),
+this.entityManager.send(h).then(function(b){return d._createResultList(b.entity,a)}).then(function(a){return a.length?a[0]:null}).then(b,c)},c.prototype.count=function(a,b){var c=this.resultClass?this.entityManager.metamodel.entity(this.resultClass):null;if(!c)throw new Error("Only typed queries can be executed.");var d,g=this._serializeQuery(),h=this.entityManager._connector.host.length+g.length;return d=h>e.MAX_URI_SIZE?new f.AdhocCountQueryPOST(c.name).entity(g,"text"):new f.AdhocCountQuery(c.name,g),this.entityManager.send(d).then(function(a){return a.entity.count}).then(a,b)},c.prototype._serializeQuery=function(){return JSON.stringify(this,function(a,b){var c=this[a];return Object(c)instanceof Date?{$date:b}:c instanceof h?c.id:b})},c.prototype._serializeSort=function(){return JSON.stringify(this._sort)},c.prototype._createResultList=function(a,b){return a.length?Promise.all(a.map(function(a){if(a.id){var c=this.entityManager.getReference(this.resultClass,a.id),d=g.get(c);return d.setJson(a),d.setPersistent(),this.entityManager.resolveDepth(c,b)}return this.entityManager.load(Object.keys(a)[0])},this)).then(function(a){return a.filter(function(a){return!!a})}):Promise.resolve([])},c.prototype._addOrder=function(a,b){return b?this._sort[a]=b:this._sort=a,this},c.prototype._addOffset=function(a){return this.firstResult=a,this},c.prototype._addLimit=function(a){return this.maxResults=a,this},c}(e);c.exports=i},{10:10,36:36,58:58,63:63}],57:[function(a,c,d){"use strict";var e=a(56),f=function(a){function c(d,e,f,g){b.classCallCheck(this,c);var h=b.possibleConstructorReturn(this,a.call(this,d,e));return h._operator=f,h._childs=g,h}return b.inherits(c,a),c.prototype.toJSON=function(){var a={};return a[this._operator]=this._childs,a},c}(e);c.exports=f},{56:56}],58:[function(a,c,d){"use strict";var e=function(){function a(c,d){b.classCallCheck(this,a),this.entityManager=c,this.resultClass=d}return a.prototype.ascending=function(a){return this._addOrder(a,1)},a.prototype.descending=function(a){return this._addOrder(a,-1)},a.prototype.sort=function(a){if(!(a instanceof Object)||Object.getPrototypeOf(a)!=Object.prototype)throw new Error("sort must be an object.");return this._addOrder(a)},a.prototype.offset=function(a){if(a<0)throw new Error("The offset can't be nagative.");return this._addOffset(a)},a.prototype.limit=function(a){if(a<0)throw new Error("The limit can't be nagative.");return this._addLimit(a)},a.prototype.resultList=function(a,b,c){},a.prototype.singleResult=function(a,b,c){},a.prototype.stream=function(a){},a.prototype.count=function(a,b){},a}();e.MAX_URI_SIZE=2e3,e.varargs=function(a,b){return Array.prototype.concat.apply([],Array.prototype.slice.call(b,a))},c.exports=e},{}],59:[function(a,b,c){"use strict";c.Builder=a(53),c.Condition=a(54),c.Filter=a(55),c.Node=a(56),c.Operator=a(57),c.Query=a(58)},{53:53,54:54,55:55,56:56,57:57,58:58}],60:[function(a,c,d){"use strict";var e=a(36),f=a(25).StatusCode,g=function(){function a(c,d){b.classCallCheck(this,a),this._metamodel=c,this.entityManagerFactory=d}return a.prototype.functionToString=function(a){if(!a)return"";var b=a.toString();return b=b.substring(b.indexOf("{")+1,b.lastIndexOf("}")),"\n"==b.charAt(0)&&(b=b.substring(1)),"\n"==b.charAt(b.length-1)&&(b=b.substring(0,b.length-1)),b},a.prototype.stringToFunction=function(a,b){return new Function(a,b)},a.prototype.loadModules=function(){var a=new e.GetAllModules;return this.entityManagerFactory.send(a).then(function(a){return a.entity})},a.prototype.loadCode=function(a,b,c){var d=this,g=Object(a)instanceof String?a:a.name,h=new e.GetBaqendCode(g,b).responseType("text");return this.entityManagerFactory.send(h).then(function(a){return d._parseCode(g,b,c,a.entity)},function(a){if(a.status==f.OBJECT_NOT_FOUND)return null;throw a})},a.prototype.saveCode=function(a,b,c){var d=this,f=Object(a)instanceof String?a:a.name,g=c instanceof Function,h=new e.SetBaqendCode(f,b).entity(g?this.functionToString(c):c,"text").responseType("text");return this.entityManagerFactory.send(h).then(function(a){return d._parseCode(f,b,g,a.entity)})},a.prototype.deleteCode=function(a,b){var c=this,d=Object(a)instanceof String?a:a.name,f=new e.DeleteBaqendCode(d,b);return this.entityManagerFactory.send(f).then(function(){return c._parseCode(d,b,!1,null)})},a.prototype._parseCode=function(a,b,c,d){if("validate"==b){var e=this._metamodel.entity(a);return e.validationCode=d,c?e.validationCode:d}return c?this.stringToFunction(["module","exports"],d):d},a}();c.exports=g},{25:25,36:36}],61:[function(a,c,d){"use strict";var e=function(){function a(){b.classCallCheck(this,a),this._isLocked=!1,this._readyPromise=Promise.resolve(this),this._deferred=null}return a.prototype.ready=function(a,b){return this._readyPromise.then(a,b)},a.prototype.withLock=function(a,b){if(this._isLocked)throw new Error("Current operation has not been finished.");var c=this;try{this._isLocked=!0;var d=a().then(function(a){return c._isLocked=!1,a},function(a){throw b||(c._isLocked=!1),a});return this._readyPromise=d.then(function(){return c},function(a){if(!b)return c;throw a}),d}catch(a){throw b?this._readyPromise=Promise.reject(a):this._isLocked=!1,a}},b.createClass(a,[{key:"isReady",get:function(){return!this._isLocked}}]),a}();c.exports=e},{}],62:[function(a,c,d){"use strict";var e=a(36),f=(a(25).StatusCode,function(){function a(){b.classCallCheck(this,a)}return a.create=function(a){function b(){c.log.apply(b,arguments)}for(var c=this.prototype,d=Object.getOwnPropertyNames(c),e=Array.isArray(d),f=0,d=e?d:d[Symbol.iterator]();;){var g;if(e){if(f>=d.length)break;g=d[f++]}else{if(f=d.next(),f.done)break;g=f.value}var h=g;Object.defineProperty(b,h,Object.getOwnPropertyDescriptor(c,h))}return b._init(a),b},a.prototype.log=function(c,d,e){var f=Array.prototype.slice.call(arguments);if(c=a.LEVELS.indexOf(f[0])==-1?"info":f.shift(),!(this.levelIndex>a.LEVELS.indexOf(c)))return d="string"==typeof f[0]?this._format(f.shift(),f):"[no message]",e=null,f.length&&"object"===b.typeof(f[f.length-1])&&(e=f.pop(),Array.isArray(e)&&(e={data:e})),f.length&&(d+=", "+f.join(", ")),this._log({date:new Date,message:d,level:c,user:this.entityManager.me&&this.entityManager.me.id,data:e})},a.prototype._format=function(b,c){if(0==c.length)return b;var d=String(b).replace(a.FORMAT_REGEXP,function(a){if("%%"===a)return"%";if(!c.length)return a;switch(a){case"%s":return String(c.shift());case"%d":return Number(c.shift());case"%j":try{return JSON.stringify(c.shift())}catch(a){return"[Circular]"}default:return a}});return d},a.prototype._init=function(b){var c=this;this.entityManager=b,this.levelIndex=2,a.LEVELS.forEach(function(a){c[a]=c.log.bind(c,a)})},a.prototype._log=function(a){return this.entityManager.isReady?this.entityManager.send(new e.CreateObject("logs.AppLog",a)):this.entityManager.ready(this._log.bind(this,a))},b.createClass(a,[{key:"level",get:function(){return a.LEVELS[this.levelIndex]},set:function(b){var c=a.LEVELS.indexOf(b);if(c==-1)throw new Error("Unknown logging level "+b);this.levelIndex=c}}]),a}());Object.assign(f,{LEVELS:["trace","debug","info","warn","error"],FORMAT_REGEXP:/%[sdj%]/g}),c.exports=f},{25:25,36:36}],63:[function(a,c,d){"use strict";var e=a(34),f=a(1),g=a(61),h=(a(20),function(c){function d(a,e){b.classCallCheck(this,d);var g=b.possibleConstructorReturn(this,c.call(this));return g._root=a,g._state=d.Type.DIRTY,g._enabled=!0,g.id=null,g.version=null,g.type=e,g.acl=new f(g),g}return b.inherits(d,c),d.create=function(a,b){var c;if(a.isEntity)c=new d(b,a);else{if(!a.isEmbeddable)throw new Error("Illegal type "+a);c={type:a,readAccess:function(){var a=this._root&&this._root._metadata;a&&a.readAccess()},writeAccess:function(){var a=this._root&&this._root._metadata;a&&a.writeAccess()}}}return c},d.get=function(a){return a._metadata},b.createClass(d,[{key:"db",get:function(){return this._db?this._db:this._db=a(6)},set:function(a){if(this._db)throw new Error("DB has already been set.");this._db=a}},{key:"bucket",get:function(){return this.type.name}},{key:"key",get:function(){if(!this._key&&this.id){var a=this.id.lastIndexOf("/");this._key=decodeURIComponent(this.id.substring(a+1))}return this._key},set:function(a){if(a+="",this.id)throw new Error("The id can't be set twice.");this.id="/db/"+this.bucket+"/"+encodeURIComponent(a),this._key=a}},{key:"isAttached",get:function(){return!!this._db}},{key:"isAvailable",get:function(){return this._state>d.Type.UNAVAILABLE}},{key:"isPersistent",get:function(){return this._state==d.Type.PERSISTENT}},{key:"isDirty",get:function(){return this._state==d.Type.DIRTY}}]),d.prototype.readAccess=function(){if(this._enabled&&!this.isAvailable)throw new e.PersistentError("This object "+this.id+" is not available.")},d.prototype.writeAccess=function(){if(this._enabled){if(!this.isAvailable)throw new e.PersistentError("This object "+this.id+" is not available.");this.setDirty()}},d.prototype.setUnavailable=function(){this._state=d.Type.UNAVAILABLE},d.prototype.setPersistent=function(){this._state=d.Type.PERSISTENT},d.prototype.setDirty=function(){this._state=d.Type.DIRTY},d.prototype.setRemoved=function(){this.isAvailable&&(this.setDirty(),this.version=null)},d.prototype.getJsonMetadata=function(){var a={};return this.id&&(a.id=this.id),this.version&&(a.version=this.version),a.acl=this.acl,a},d.prototype.setJsonMetadata=function(a){this.id||(this.id=a.id),a.version&&(this.version=a.version),this.acl.fromJSON(a.acl||{})},d.prototype.getJson=function(a){this._enabled=!1;var b=this.type.toJsonValue(this,this._root,!0);return this._enabled=!0,this.isAttached&&!a&&Object.assign(b,this.getJsonMetadata()),b},d.prototype.setJson=function(a){(a.id||a.version||a.acl)&&this.setJsonMetadata(a),this._enabled=!1,this.type.fromJsonValue(this,a,this._root,!0),this._enabled=!0},d}(g));h.Type={UNAVAILABLE:-1,PERSISTENT:0,DIRTY:1},c.exports=h},{1:1,20:20,34:34,6:6,61:61}],64:[function(a,c,d){"use strict";var e=a(36),f=function(){function a(c,d){b.classCallCheck(this,a),this._entityManager=c,this._connector=d}return a.prototype.get=function(a,b,c,d,f){b instanceof Function&&(f=c,d=b,c={},b=null),c instanceof Function&&(f=d,d=c,c={}),c=c||{};var g=new e.GetBaqendModule(a).addQueryString(b).responseType(c.responseType||null);return this._send(g,d,f)},a.prototype.post=function(a,b,c,d,f){c instanceof Function&&(f=d,d=c,c={}),c=c||{};var g=new e.PostBaqendModule(a).entity(b,c.requestType).mimeType(c.mimeType||null).responseType(c.responseType||null);return this._send(g,d,f)},a.prototype._send=function(a,b,c){return this._entityManager.send(a).then(function(a){return a.entity}).then(b,c)},a}();c.exports=f},{36:36}],65:[function(a,c,d){"use strict";var e=function(){function a(c){b.classCallCheck(this,a),this._rules={},this._metadata=c}return a.prototype.allRules=function(){return Object.keys(this._rules)},a.prototype.clear=function(){this._metadata&&this._metadata.writeAccess(),this._rules={}},a.prototype.copy=function(a){return this._metadata&&this._metadata.writeAccess(),this._rules=Object.assign({},a._rules),this},a.prototype.isPublicAllowed=function(){if("*"in this._rules)return!1;for(var a in this._rules)if("allow"==this._rules[a])return!1;return!0},a.prototype.setPublicAllowed=function(){this._metadata&&this._metadata.writeAccess();for(var a in this._rules)"allow"==this._rules[a]&&delete this._rules[a]},a.prototype.getRule=function(a){return this._rules[this._getRef(a)]},a.prototype.isAllowed=function(a){return"allow"==this._rules[this._getRef(a)]},a.prototype.isDenied=function(a){return"deny"==this._rules[this._getRef(a)]},a.prototype.allowAccess=function(a){var b=arguments;this._metadata&&this._metadata.writeAccess();for(var c=0;c=d.length)break;g=d[f++]}else{if(f=d.next(),f.done)break;g=f.value}var h=g;c.push(h.name)}var i=new Function(c,b);return function(a){var b=c.map(function(b){return a[b]});return i.apply({},b)}},a.prototype.is=function(a,b){return a instanceof Function&&(b=a,a="is"),b(this.value,e)===!1&&this.errors.push(a),this},b.createClass(a,[{key:"value",get:function(){return this._entity[this.key]}},{key:"isValid",get:function(){return 0==this.errors.length}}]),a.prototype._callMethod=function(a,b,c){return c=c||[],c.unshift(this.value),e[a].apply(this,c)===!1&&this.errors.push(b),this},a.prototype.toString=function(){return this.value},a.prototype.toJSON=function(){return{isValid:this.isValid,errors:this.errors}},a}());Object.keys(e).forEach(function(a){"function"==typeof e[a]&&"toString"!==a&&"toDate"!==a&&"extend"!==a&&"init"!==a&&(f.prototype[a]=function(b){return this._callMethod(a,b||a,Array.prototype.slice.call(arguments,b?1:0))})}),c.exports=f},{162:162,68:68}],70:[function(a,b,c){"use strict";b.exports=c=a(71),c.Metadata=a(63),c.Permission=a(65),c.Validator=a(69),c.ValidationResult=a(68),c.Code=a(60),c.Modules=a(64),c.Lockable=a(61),c.Logger=a(62),c.PushMessage=a(66),c.TokenStorage=a(67),c.uuid=a(160).v4},{160:160,60:60,61:61,62:62,63:63,64:64,65:65,66:66,67:67,68:68,69:69,71:71}],71:[function(a,b,c){"use strict";c.hmac=a(157),c.atob=window.atob,c.isNode=!1},{157:157}],72:[function(a,b,c){b.exports=function(a){if("function"!=typeof a)throw TypeError(a+" is not a function!");return a}},{}],73:[function(a,b,c){var d=a(144)("unscopables"),e=Array.prototype;void 0==e[d]&&a(94)(e,d,{}),b.exports=function(a){e[d][a]=!0}},{144:144,94:94}],74:[function(a,b,c){b.exports=function(a,b,c,d){if(!(a instanceof b)||void 0!==d&&d in a)throw TypeError(c+": incorrect invocation!");return a}},{}],75:[function(a,b,c){var d=a(102);b.exports=function(a){if(!d(a))throw TypeError(a+" is not an object!");return a}},{102:102}],76:[function(a,b,c){var d=a(137),e=a(138),f=a(135);b.exports=function(a){return function(b,c,g){var h,i=d(b),j=e(i.length),k=f(g,j);if(a&&c!=c){for(;j>k;)if(h=i[k++],h!=h)return!0}else for(;j>k;k++)if((a||k in i)&&i[k]===c)return a||k||0;return!a&&-1}}},{135:135,137:137,138:138}],77:[function(a,b,c){var d=a(78),e=a(144)("toStringTag"),f="Arguments"==d(function(){return arguments}()),g=function(a,b){try{return a[b]}catch(a){}};b.exports=function(a){var b,c,h;return void 0===a?"Undefined":null===a?"Null":"string"==typeof(c=g(b=Object(a),e))?c:f?d(b):"Object"==(h=d(b))&&"function"==typeof b.callee?"Arguments":h}},{144:144,78:78}],78:[function(a,b,c){var d={}.toString;b.exports=function(a){return d.call(a).slice(8,-1)}},{}],79:[function(a,b,c){"use strict";var d=a(115).f,e=a(114),f=a(126),g=a(83),h=a(74),i=a(84),j=a(91),k=a(105),l=a(107),m=a(129),n=a(85),o=a(111).fastKey,p=n?"_s":"size",q=function(a,b){var c,d=o(b);if("F"!==d)return a._i[d];for(c=a._f;c;c=c.n)if(c.k==b)return c};b.exports={getConstructor:function(a,b,c,k){var l=a(function(a,d){h(a,l,b,"_i"),a._i=e(null),a._f=void 0,a._l=void 0,a[p]=0,void 0!=d&&j(d,c,a[k],a)});return f(l.prototype,{clear:function(){for(var a=this,b=a._i,c=a._f;c;c=c.n)c.r=!0,c.p&&(c.p=c.p.n=void 0),delete b[c.i];a._f=a._l=void 0,a[p]=0},delete:function(a){var b=this,c=q(b,a);if(c){var d=c.n,e=c.p;delete b._i[c.i],c.r=!0,e&&(e.n=d),d&&(d.p=e),b._f==c&&(b._f=d),b._l==c&&(b._l=e),b[p]--}return!!c},forEach:function(a){h(this,l,"forEach");for(var b,c=g(a,arguments.length>1?arguments[1]:void 0,3);b=b?b.n:this._f;)for(c(b.v,b.k,this);b&&b.r;)b=b.p},has:function(a){return!!q(this,a)}}),n&&d(l.prototype,"size",{get:function(){return i(this[p])}}),l},def:function(a,b,c){var d,e,f=q(a,b);return f?f.v=c:(a._l=f={i:e=o(b,!0),k:b,v:c,p:d=a._l,n:void 0,r:!1},a._f||(a._f=f),d&&(d.n=f),a[p]++,"F"!==e&&(a._i[e]=f)),a},getEntry:q,setStrong:function(a,b,c){k(a,b,function(a,b){this._t=a,this._k=b,this._l=void 0},function(){for(var a=this,b=a._k,c=a._l;c&&c.r;)c=c.p;return a._t&&(a._l=c=c?c.n:a._t._f)?"keys"==b?l(0,c.k):"values"==b?l(0,c.v):l(0,[c.k,c.v]):(a._t=void 0,l(1))},c?"entries":"values",!c,!0),m(b)}}},{105:105,107:107,111:111,114:114,115:115,126:126,129:129,74:74,83:83,84:84,85:85,91:91}],80:[function(a,b,c){"use strict";var d=a(92),e=a(89),f=a(127),g=a(126),h=a(111),i=a(91),j=a(74),k=a(102),l=a(90),m=a(106),n=a(130),o=a(97);b.exports=function(a,b,c,p,q,r){var s=d[a],t=s,u=q?"set":"add",v=t&&t.prototype,w={},x=function(a){var b=v[a];f(v,a,"delete"==a?function(a){return!(r&&!k(a))&&b.call(this,0===a?0:a)}:"has"==a?function(a){return!(r&&!k(a))&&b.call(this,0===a?0:a)}:"get"==a?function(a){return r&&!k(a)?void 0:b.call(this,0===a?0:a)}:"add"==a?function(a){return b.call(this,0===a?0:a),this}:function(a,c){return b.call(this,0===a?0:a,c),this})};if("function"==typeof t&&(r||v.forEach&&!l(function(){(new t).entries().next()}))){var y=new t,z=y[u](r?{}:-0,1)!=y,A=l(function(){y.has(1)}),B=m(function(a){new t(a)}),C=!r&&l(function(){for(var a=new t,b=5;b--;)a[u](b,b);return!a.has(-0)});B||(t=b(function(b,c){j(b,t,a);var d=o(new s,b,t);return void 0!=c&&i(c,q,d[u],d),d}),t.prototype=v,v.constructor=t),(A||C)&&(x("delete"),x("has"),q&&x("get")),(C||z)&&x(u),r&&v.clear&&delete v.clear}else t=p.getConstructor(b,a,q,u),g(t.prototype,c),h.NEED=!0;return n(t,a),w[a]=t,e(e.G+e.W+e.F*(t!=s),w),r||p.setStrong(t,a,q),t}},{102:102,106:106,111:111,126:126,127:127,130:130,74:74,89:89,90:90,91:91,92:92,97:97}],81:[function(a,b,c){var d=b.exports={version:"2.4.0"};"number"==typeof __e&&(__e=d)},{}],82:[function(a,b,c){"use strict";var d=a(115),e=a(125);b.exports=function(a,b,c){b in a?d.f(a,b,e(0,c)):a[b]=c}},{115:115,125:125}],83:[function(a,b,c){var d=a(72);b.exports=function(a,b,c){if(d(a),void 0===b)return a;switch(c){case 1:return function(c){return a.call(b,c)};case 2:return function(c,d){return a.call(b,c,d)};case 3:return function(c,d,e){return a.call(b,c,d,e)}}return function(){return a.apply(b,arguments)}}},{72:72}],84:[function(a,b,c){b.exports=function(a){if(void 0==a)throw TypeError("Can't call method on "+a);return a}},{}],85:[function(a,b,c){b.exports=!a(90)(function(){return 7!=Object.defineProperty({},"a",{get:function(){return 7}}).a})},{90:90}],86:[function(a,b,c){var d=a(102),e=a(92).document,f=d(e)&&d(e.createElement);b.exports=function(a){return f?e.createElement(a):{}}},{102:102,92:92}],87:[function(a,b,c){b.exports="constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf".split(",")},{}],88:[function(a,b,c){var d=a(123),e=a(120),f=a(124);b.exports=function(a){var b=d(a),c=e.f;if(c)for(var g,h=c(a),i=f.f,j=0;h.length>j;)i.call(a,g=h[j++])&&b.push(g);return b}},{120:120,123:123,124:124}],89:[function(a,b,c){var d=a(92),e=a(81),f=a(94),g=a(127),h=a(83),i="prototype",j=function(a,b,c){var k,l,m,n,o=a&j.F,p=a&j.G,q=a&j.S,r=a&j.P,s=a&j.B,t=p?d:q?d[b]||(d[b]={}):(d[b]||{})[i],u=p?e:e[b]||(e[b]={}),v=u[i]||(u[i]={});p&&(c=b);for(k in c)l=!o&&t&&void 0!==t[k],m=(l?t:c)[k],n=s&&l?h(m,d):r&&"function"==typeof m?h(Function.call,m):m,t&&g(t,k,m,a&j.U),u[k]!=m&&f(u,k,n),r&&v[k]!=m&&(v[k]=m)};d.core=e,j.F=1,j.G=2,j.S=4,j.P=8,j.B=16,j.W=32,j.U=64,j.R=128,b.exports=j},{127:127,81:81,83:83,92:92,94:94}],90:[function(a,b,c){b.exports=function(a){try{return!!a()}catch(a){return!0}}},{}],91:[function(a,b,c){var d=a(83),e=a(103),f=a(100),g=a(75),h=a(138),i=a(145),j={},k={},c=b.exports=function(a,b,c,l,m){var n,o,p,q,r=m?function(){return a}:i(a),s=d(c,l,b?2:1),t=0;if("function"!=typeof r)throw TypeError(a+" is not iterable!");if(f(r)){for(n=h(a.length);n>t;t++)if(q=b?s(g(o=a[t])[0],o[1]):s(a[t]),q===j||q===k)return q}else for(p=r.call(a);!(o=p.next()).done;)if(q=e(p,s,o.value,b),q===j||q===k)return q};c.BREAK=j,c.RETURN=k},{100:100,103:103,138:138,145:145,75:75,83:83}],92:[function(a,b,c){var d=b.exports="undefined"!=typeof window&&window.Math==Math?window:"undefined"!=typeof self&&self.Math==Math?self:Function("return this")();"number"==typeof __g&&(__g=d)},{}],93:[function(a,b,c){var d={}.hasOwnProperty;b.exports=function(a,b){return d.call(a,b)}},{}],94:[function(a,b,c){var d=a(115),e=a(125);b.exports=a(85)?function(a,b,c){return d.f(a,b,e(1,c))}:function(a,b,c){return a[b]=c,a}},{115:115,125:125,85:85}],95:[function(a,b,c){b.exports=a(92).document&&document.documentElement},{92:92}],96:[function(a,b,c){b.exports=!a(85)&&!a(90)(function(){return 7!=Object.defineProperty(a(86)("div"),"a",{get:function(){return 7}}).a})},{85:85,86:86,90:90}],97:[function(a,b,c){var d=a(102),e=a(128).set;b.exports=function(a,b,c){var f,g=b.constructor;return g!==c&&"function"==typeof g&&(f=g.prototype)!==c.prototype&&d(f)&&e&&e(a,f),a}},{102:102,128:128}],98:[function(a,b,c){b.exports=function(a,b,c){var d=void 0===c;switch(b.length){case 0:return d?a():a.call(c);case 1:return d?a(b[0]):a.call(c,b[0]);case 2:return d?a(b[0],b[1]):a.call(c,b[0],b[1]);case 3:return d?a(b[0],b[1],b[2]):a.call(c,b[0],b[1],b[2]);case 4:return d?a(b[0],b[1],b[2],b[3]):a.call(c,b[0],b[1],b[2],b[3])}return a.apply(c,b)}},{}],99:[function(a,b,c){var d=a(78);b.exports=Object("z").propertyIsEnumerable(0)?Object:function(a){return"String"==d(a)?a.split(""):Object(a)}},{78:78}],100:[function(a,b,c){var d=a(108),e=a(144)("iterator"),f=Array.prototype;b.exports=function(a){return void 0!==a&&(d.Array===a||f[e]===a)}},{108:108,144:144}],101:[function(a,b,c){var d=a(78);b.exports=Array.isArray||function(a){return"Array"==d(a)}},{78:78}],102:[function(a,b,c){b.exports=function(a){return"object"==typeof a?null!==a:"function"==typeof a}},{}],103:[function(a,b,c){var d=a(75);b.exports=function(a,b,c,e){try{return e?b(d(c)[0],c[1]):b(c)}catch(b){var f=a.return;throw void 0!==f&&d(f.call(a)),b}}},{75:75}],104:[function(a,b,c){"use strict";var d=a(114),e=a(125),f=a(130),g={};a(94)(g,a(144)("iterator"),function(){return this}),b.exports=function(a,b,c){a.prototype=d(g,{next:e(1,c)}),f(a,b+" Iterator")}},{114:114,125:125,130:130,144:144,94:94}],105:[function(a,b,c){"use strict";var d=a(110),e=a(89),f=a(127),g=a(94),h=a(93),i=a(108),j=a(104),k=a(130),l=a(121),m=a(144)("iterator"),n=!([].keys&&"next"in[].keys()),o="@@iterator",p="keys",q="values",r=function(){return this};b.exports=function(a,b,c,s,t,u,v){j(c,b,s);var w,x,y,z=function(a){if(!n&&a in D)return D[a];switch(a){case p:return function(){return new c(this,a)};case q:return function(){return new c(this,a)}}return function(){return new c(this,a)}},A=b+" Iterator",B=t==q,C=!1,D=a.prototype,E=D[m]||D[o]||t&&D[t],F=E||z(t),G=t?B?z("entries"):F:void 0,H="Array"==b?D.entries||E:E;if(H&&(y=l(H.call(new a)),y!==Object.prototype&&(k(y,A,!0),d||h(y,m)||g(y,m,r))),B&&E&&E.name!==q&&(C=!0,F=function(){return E.call(this)}),d&&!v||!n&&!C&&D[m]||g(D,m,F),i[b]=F,i[A]=r,t)if(w={values:B?F:z(q),keys:u?F:z(p),entries:G},v)for(x in w)x in D||f(D,x,w[x]);else e(e.P+e.F*(n||C),b,w);return w}},{104:104,108:108,110:110,121:121,127:127,130:130,144:144,89:89,93:93,94:94}],106:[function(a,b,c){var d=a(144)("iterator"),e=!1;try{var f=[7][d]();f.return=function(){e=!0},Array.from(f,function(){throw 2})}catch(a){}b.exports=function(a,b){if(!b&&!e)return!1;var c=!1;try{var f=[7],g=f[d]();g.next=function(){return{done:c=!0}},f[d]=function(){return g},a(f)}catch(a){}return c}},{144:144}],107:[function(a,b,c){b.exports=function(a,b){return{value:b,done:!!a}}},{}],108:[function(a,b,c){b.exports={}},{}],109:[function(a,b,c){var d=a(123),e=a(137);b.exports=function(a,b){for(var c,f=e(a),g=d(f),h=g.length,i=0;h>i;)if(f[c=g[i++]]===b)return c}},{123:123,137:137}],110:[function(a,b,c){b.exports=!1},{}],111:[function(a,b,c){var d=a(141)("meta"),e=a(102),f=a(93),g=a(115).f,h=0,i=Object.isExtensible||function(){return!0},j=!a(90)(function(){return i(Object.preventExtensions({}))}),k=function(a){g(a,d,{value:{i:"O"+ ++h,w:{}}})},l=function(a,b){if(!e(a))return"symbol"==typeof a?a:("string"==typeof a?"S":"P")+a;if(!f(a,d)){if(!i(a))return"F";if(!b)return"E";k(a)}return a[d].i},m=function(a,b){if(!f(a,d)){if(!i(a))return!0;if(!b)return!1;k(a)}return a[d].w},n=function(a){return j&&o.NEED&&i(a)&&!f(a,d)&&k(a),a},o=b.exports={KEY:d,NEED:!1,fastKey:l,getWeak:m,onFreeze:n}},{102:102,115:115,141:141,90:90,93:93}],112:[function(a,b,c){var d=a(92),e=a(134).set,f=d.MutationObserver||d.WebKitMutationObserver,g=d.process,h=d.Promise,i="process"==a(78)(g);b.exports=function(){var a,b,c,j=function(){var d,e;for(i&&(d=g.domain)&&d.exit();a;){e=a.fn,a=a.next;try{e()}catch(d){throw a?c():b=void 0,d}}b=void 0,d&&d.enter()};if(i)c=function(){g.nextTick(j)};else if(f){var k=!0,l=document.createTextNode("");new f(j).observe(l,{characterData:!0}),c=function(){l.data=k=!k}}else if(h&&h.resolve){var m=h.resolve();c=function(){m.then(j)}}else c=function(){e.call(d,j)};return function(d){var e={fn:d,next:void 0};b&&(b.next=e),a||(a=e,c()),b=e}}},{134:134,78:78,92:92}],113:[function(a,b,c){"use strict";var d=a(123),e=a(120),f=a(124),g=a(139),h=a(99),i=Object.assign;b.exports=!i||a(90)(function(){var a={},b={},c=Symbol(),d="abcdefghijklmnopqrst";return a[c]=7,d.split("").forEach(function(a){b[a]=a}),7!=i({},a)[c]||Object.keys(i({},b)).join("")!=d})?function(a,b){for(var c=g(a),i=arguments.length,j=1,k=e.f,l=f.f;i>j;)for(var m,n=h(arguments[j++]),o=k?d(n).concat(k(n)):d(n),p=o.length,q=0;p>q;)l.call(n,m=o[q++])&&(c[m]=n[m]);return c}:i},{120:120,123:123,124:124,139:139,90:90,99:99}],114:[function(a,b,c){var d=a(75),e=a(116),f=a(87),g=a(131)("IE_PROTO"),h=function(){},i="prototype",j=function(){var b,c=a(86)("iframe"),d=f.length,e="<",g=">";for(c.style.display="none",a(95).appendChild(c),c.src="javascript:",b=c.contentWindow.document,b.open(),b.write(e+"script"+g+"document.F=Object"+e+"/script"+g),b.close(),j=b.F;d--;)delete j[i][f[d]];return j()};b.exports=Object.create||function(a,b){var c;return null!==a?(h[i]=d(a),c=new h,h[i]=null,c[g]=a):c=j(),void 0===b?c:e(c,b)}},{116:116,131:131,75:75,86:86,87:87,95:95}],115:[function(a,b,c){var d=a(75),e=a(96),f=a(140),g=Object.defineProperty;c.f=a(85)?Object.defineProperty:function(a,b,c){if(d(a),b=f(b,!0),d(c),e)try{return g(a,b,c)}catch(a){}if("get"in c||"set"in c)throw TypeError("Accessors not supported!");return"value"in c&&(a[b]=c.value),a}},{140:140,75:75,85:85,96:96}],116:[function(a,b,c){var d=a(115),e=a(75),f=a(123);b.exports=a(85)?Object.defineProperties:function(a,b){e(a);for(var c,g=f(b),h=g.length,i=0;h>i;)d.f(a,c=g[i++],b[c]);return a}},{115:115,123:123,75:75,85:85}],117:[function(a,b,c){var d=a(124),e=a(125),f=a(137),g=a(140),h=a(93),i=a(96),j=Object.getOwnPropertyDescriptor;c.f=a(85)?j:function(a,b){if(a=f(a),b=g(b,!0),i)try{return j(a,b)}catch(a){}if(h(a,b))return e(!d.f.call(a,b),a[b])}},{124:124,125:125,137:137,140:140,85:85,93:93,96:96}],118:[function(a,b,c){var d=a(137),e=a(119).f,f={}.toString,g="object"==typeof window&&window&&Object.getOwnPropertyNames?Object.getOwnPropertyNames(window):[],h=function(a){try{return e(a)}catch(a){return g.slice()}};b.exports.f=function(a){return g&&"[object Window]"==f.call(a)?h(a):e(d(a))}},{119:119,137:137}],119:[function(a,b,c){var d=a(122),e=a(87).concat("length","prototype");c.f=Object.getOwnPropertyNames||function(a){return d(a,e)}},{122:122,87:87}],120:[function(a,b,c){c.f=Object.getOwnPropertySymbols},{}],121:[function(a,b,c){var d=a(93),e=a(139),f=a(131)("IE_PROTO"),g=Object.prototype;b.exports=Object.getPrototypeOf||function(a){return a=e(a),d(a,f)?a[f]:"function"==typeof a.constructor&&a instanceof a.constructor?a.constructor.prototype:a instanceof Object?g:null}},{131:131,139:139,93:93}],122:[function(a,b,c){var d=a(93),e=a(137),f=a(76)(!1),g=a(131)("IE_PROTO");b.exports=function(a,b){var c,h=e(a),i=0,j=[];for(c in h)c!=g&&d(h,c)&&j.push(c);for(;b.length>i;)d(h,c=b[i++])&&(~f(j,c)||j.push(c));return j}},{131:131,137:137,76:76,93:93}],123:[function(a,b,c){var d=a(122),e=a(87);b.exports=Object.keys||function(a){return d(a,e)}},{122:122,87:87}],124:[function(a,b,c){c.f={}.propertyIsEnumerable},{}],125:[function(a,b,c){b.exports=function(a,b){return{enumerable:!(1&a),configurable:!(2&a),writable:!(4&a),value:b}}},{}],126:[function(a,b,c){var d=a(127);b.exports=function(a,b,c){for(var e in b)d(a,e,b[e],c);return a}},{127:127}],127:[function(a,b,c){var d=a(92),e=a(94),f=a(93),g=a(141)("src"),h="toString",i=Function[h],j=(""+i).split(h);a(81).inspectSource=function(a){return i.call(a)},(b.exports=function(a,b,c,h){var i="function"==typeof c;i&&(f(c,"name")||e(c,"name",b)),a[b]!==c&&(i&&(f(c,g)||e(c,g,a[b]?""+a[b]:j.join(String(b)))),a===d?a[b]=c:h?a[b]?a[b]=c:e(a,b,c):(delete a[b],
+e(a,b,c)))})(Function.prototype,h,function(){return"function"==typeof this&&this[g]||i.call(this)})},{141:141,81:81,92:92,93:93,94:94}],128:[function(a,b,c){var d=a(102),e=a(75),f=function(a,b){if(e(a),!d(b)&&null!==b)throw TypeError(b+": can't set as prototype!")};b.exports={set:Object.setPrototypeOf||("__proto__"in{}?function(b,c,d){try{d=a(83)(Function.call,a(117).f(Object.prototype,"__proto__").set,2),d(b,[]),c=!(b instanceof Array)}catch(a){c=!0}return function(a,b){return f(a,b),c?a.__proto__=b:d(a,b),a}}({},!1):void 0),check:f}},{102:102,117:117,75:75,83:83}],129:[function(a,b,c){"use strict";var d=a(92),e=a(115),f=a(85),g=a(144)("species");b.exports=function(a){var b=d[a];f&&b&&!b[g]&&e.f(b,g,{configurable:!0,get:function(){return this}})}},{115:115,144:144,85:85,92:92}],130:[function(a,b,c){var d=a(115).f,e=a(93),f=a(144)("toStringTag");b.exports=function(a,b,c){a&&!e(a=c?a:a.prototype,f)&&d(a,f,{configurable:!0,value:b})}},{115:115,144:144,93:93}],131:[function(a,b,c){var d=a(132)("keys"),e=a(141);b.exports=function(a){return d[a]||(d[a]=e(a))}},{132:132,141:141}],132:[function(a,b,c){var d=a(92),e="__core-js_shared__",f=d[e]||(d[e]={});b.exports=function(a){return f[a]||(f[a]={})}},{92:92}],133:[function(a,b,c){var d=a(75),e=a(72),f=a(144)("species");b.exports=function(a,b){var c,g=d(a).constructor;return void 0===g||void 0==(c=d(g)[f])?b:e(c)}},{144:144,72:72,75:75}],134:[function(a,b,c){var d,e,f,g=a(83),h=a(98),i=a(95),j=a(86),k=a(92),l=k.process,m=k.setImmediate,n=k.clearImmediate,o=k.MessageChannel,p=0,q={},r="onreadystatechange",s=function(){var a=+this;if(q.hasOwnProperty(a)){var b=q[a];delete q[a],b()}},t=function(a){s.call(a.data)};m&&n||(m=function(a){for(var b=[],c=1;arguments.length>c;)b.push(arguments[c++]);return q[++p]=function(){h("function"==typeof a?a:Function(a),b)},d(p),p},n=function(a){delete q[a]},"process"==a(78)(l)?d=function(a){l.nextTick(g(s,a,1))}:o?(e=new o,f=e.port2,e.port1.onmessage=t,d=g(f.postMessage,f,1)):k.addEventListener&&"function"==typeof postMessage&&!k.importScripts?(d=function(a){k.postMessage(a+"","*")},k.addEventListener("message",t,!1)):d=r in j("script")?function(a){i.appendChild(j("script"))[r]=function(){i.removeChild(this),s.call(a)}}:function(a){setTimeout(g(s,a,1),0)}),b.exports={set:m,clear:n}},{78:78,83:83,86:86,92:92,95:95,98:98}],135:[function(a,b,c){var d=a(136),e=Math.max,f=Math.min;b.exports=function(a,b){return a=d(a),a<0?e(a+b,0):f(a,b)}},{136:136}],136:[function(a,b,c){var d=Math.ceil,e=Math.floor;b.exports=function(a){return isNaN(a=+a)?0:(a>0?e:d)(a)}},{}],137:[function(a,b,c){var d=a(99),e=a(84);b.exports=function(a){return d(e(a))}},{84:84,99:99}],138:[function(a,b,c){var d=a(136),e=Math.min;b.exports=function(a){return a>0?e(d(a),9007199254740991):0}},{136:136}],139:[function(a,b,c){var d=a(84);b.exports=function(a){return Object(d(a))}},{84:84}],140:[function(a,b,c){var d=a(102);b.exports=function(a,b){if(!d(a))return a;var c,e;if(b&&"function"==typeof(c=a.toString)&&!d(e=c.call(a)))return e;if("function"==typeof(c=a.valueOf)&&!d(e=c.call(a)))return e;if(!b&&"function"==typeof(c=a.toString)&&!d(e=c.call(a)))return e;throw TypeError("Can't convert object to primitive value")}},{102:102}],141:[function(a,b,c){var d=0,e=Math.random();b.exports=function(a){return"Symbol(".concat(void 0===a?"":a,")_",(++d+e).toString(36))}},{}],142:[function(a,b,c){var d=a(92),e=a(81),f=a(110),g=a(143),h=a(115).f;b.exports=function(a){var b=e.Symbol||(e.Symbol=f?{}:d.Symbol||{});"_"==a.charAt(0)||a in b||h(b,a,{value:g.f(a)})}},{110:110,115:115,143:143,81:81,92:92}],143:[function(a,b,c){c.f=a(144)},{144:144}],144:[function(a,b,c){var d=a(132)("wks"),e=a(141),f=a(92).Symbol,g="function"==typeof f,h=b.exports=function(a){return d[a]||(d[a]=g&&f[a]||(g?f:e)("Symbol."+a))};h.store=d},{132:132,141:141,92:92}],145:[function(a,b,c){var d=a(77),e=a(144)("iterator"),f=a(108);b.exports=a(81).getIteratorMethod=function(a){if(void 0!=a)return a[e]||a["@@iterator"]||f[d(a)]}},{108:108,144:144,77:77,81:81}],146:[function(a,b,c){"use strict";var d=a(83),e=a(89),f=a(139),g=a(103),h=a(100),i=a(138),j=a(82),k=a(145);e(e.S+e.F*!a(106)(function(a){Array.from(a)}),"Array",{from:function(a){var b,c,e,l,m=f(a),n="function"==typeof this?this:Array,o=arguments.length,p=o>1?arguments[1]:void 0,q=void 0!==p,r=0,s=k(m);if(q&&(p=d(p,o>2?arguments[2]:void 0,2)),void 0==s||n==Array&&h(s))for(b=i(m.length),c=new n(b);b>r;r++)j(c,r,q?p(m[r],r):m[r]);else for(l=s.call(m),c=new n;!(e=l.next()).done;r++)j(c,r,q?g(l,p,[e.value,r],!0):e.value);return c.length=r,c}})},{100:100,103:103,106:106,138:138,139:139,145:145,82:82,83:83,89:89}],147:[function(a,b,c){"use strict";var d=a(73),e=a(107),f=a(108),g=a(137);b.exports=a(105)(Array,"Array",function(a,b){this._t=g(a),this._i=0,this._k=b},function(){var a=this._t,b=this._k,c=this._i++;return!a||c>=a.length?(this._t=void 0,e(1)):"keys"==b?e(0,c):"values"==b?e(0,a[c]):e(0,[c,a[c]])},"values"),f.Arguments=f.Array,d("keys"),d("values"),d("entries")},{105:105,107:107,108:108,137:137,73:73}],148:[function(a,b,c){"use strict";var d=a(79);b.exports=a(80)("Map",function(a){return function(){return a(this,arguments.length>0?arguments[0]:void 0)}},{get:function(a){var b=d.getEntry(this,a);return b&&b.v},set:function(a,b){return d.def(this,0===a?0:a,b)}},d,!0)},{79:79,80:80}],149:[function(a,b,c){var d=a(89);d(d.S+d.F,"Object",{assign:a(113)})},{113:113,89:89}],150:[function(a,b,c){var d=a(89);d(d.S,"Object",{setPrototypeOf:a(128).set})},{128:128,89:89}],151:[function(a,b,c){"use strict";var d,e,f,g=a(110),h=a(92),i=a(83),j=a(77),k=a(89),l=a(102),m=a(72),n=a(74),o=a(91),p=a(133),q=a(134).set,r=a(112)(),s="Promise",t=h.TypeError,u=h.process,v=h[s],u=h.process,w="process"==j(u),x=function(){},y=!!function(){try{var b=v.resolve(1),c=(b.constructor={})[a(144)("species")]=function(a){a(x,x)};return(w||"function"==typeof PromiseRejectionEvent)&&b.then(x)instanceof c}catch(a){}}(),z=function(a,b){return a===b||a===v&&b===f},A=function(a){var b;return!(!l(a)||"function"!=typeof(b=a.then))&&b},B=function(a){return z(v,a)?new C(a):new e(a)},C=e=function(a){var b,c;this.promise=new a(function(a,d){if(void 0!==b||void 0!==c)throw t("Bad Promise constructor");b=a,c=d}),this.resolve=m(b),this.reject=m(c)},D=function(a){try{a()}catch(a){return{error:a}}},E=function(a,b){if(!a._n){a._n=!0;var c=a._c;r(function(){for(var d=a._v,e=1==a._s,f=0,g=function(b){var c,f,g=e?b.ok:b.fail,h=b.resolve,i=b.reject,j=b.domain;try{g?(e||(2==a._h&&H(a),a._h=1),g===!0?c=d:(j&&j.enter(),c=g(d),j&&j.exit()),c===b.promise?i(t("Promise-chain cycle")):(f=A(c))?f.call(c,h,i):h(c)):i(d)}catch(a){i(a)}};c.length>f;)g(c[f++]);a._c=[],a._n=!1,b&&!a._h&&F(a)})}},F=function(a){q.call(h,function(){var b,c,d,e=a._v;if(G(a)&&(b=D(function(){w?u.emit("unhandledRejection",e,a):(c=h.onunhandledrejection)?c({promise:a,reason:e}):(d=h.console)&&d.error&&d.error("Unhandled promise rejection",e)}),a._h=w||G(a)?2:1),a._a=void 0,b)throw b.error})},G=function(a){if(1==a._h)return!1;for(var b,c=a._a||a._c,d=0;c.length>d;)if(b=c[d++],b.fail||!G(b.promise))return!1;return!0},H=function(a){q.call(h,function(){var b;w?u.emit("rejectionHandled",a):(b=h.onrejectionhandled)&&b({promise:a,reason:a._v})})},I=function(a){var b=this;b._d||(b._d=!0,b=b._w||b,b._v=a,b._s=2,b._a||(b._a=b._c.slice()),E(b,!0))},J=function(a){var b,c=this;if(!c._d){c._d=!0,c=c._w||c;try{if(c===a)throw t("Promise can't be resolved itself");(b=A(a))?r(function(){var d={_w:c,_d:!1};try{b.call(a,i(J,d,1),i(I,d,1))}catch(a){I.call(d,a)}}):(c._v=a,c._s=1,E(c,!1))}catch(a){I.call({_w:c,_d:!1},a)}}};y||(v=function(a){n(this,v,s,"_h"),m(a),d.call(this);try{a(i(J,this,1),i(I,this,1))}catch(a){I.call(this,a)}},d=function(a){this._c=[],this._a=void 0,this._s=0,this._d=!1,this._v=void 0,this._h=0,this._n=!1},d.prototype=a(126)(v.prototype,{then:function(a,b){var c=B(p(this,v));return c.ok="function"!=typeof a||a,c.fail="function"==typeof b&&b,c.domain=w?u.domain:void 0,this._c.push(c),this._a&&this._a.push(c),this._s&&E(this,!1),c.promise},catch:function(a){return this.then(void 0,a)}}),C=function(){var a=new d;this.promise=a,this.resolve=i(J,a,1),this.reject=i(I,a,1)}),k(k.G+k.W+k.F*!y,{Promise:v}),a(130)(v,s),a(129)(s),f=a(81)[s],k(k.S+k.F*!y,s,{reject:function(a){var b=B(this),c=b.reject;return c(a),b.promise}}),k(k.S+k.F*(g||!y),s,{resolve:function(a){if(a instanceof v&&z(a.constructor,this))return a;var b=B(this),c=b.resolve;return c(a),b.promise}}),k(k.S+k.F*!(y&&a(106)(function(a){v.all(a).catch(x)})),s,{all:function(a){var b=this,c=B(b),d=c.resolve,e=c.reject,f=D(function(){var c=[],f=0,g=1;o(a,!1,function(a){var h=f++,i=!1;c.push(void 0),g++,b.resolve(a).then(function(a){i||(i=!0,c[h]=a,--g||d(c))},e)}),--g||d(c)});return f&&e(f.error),c.promise},race:function(a){var b=this,c=B(b),d=c.reject,e=D(function(){o(a,!1,function(a){b.resolve(a).then(c.resolve,d)})});return e&&d(e.error),c.promise}})},{102:102,106:106,110:110,112:112,126:126,129:129,130:130,133:133,134:134,144:144,72:72,74:74,77:77,81:81,83:83,89:89,91:91,92:92}],152:[function(a,b,c){"use strict";var d=a(79);b.exports=a(80)("Set",function(a){return function(){return a(this,arguments.length>0?arguments[0]:void 0)}},{add:function(a){return d.def(this,a=0===a?0:a,a)}},d)},{79:79,80:80}],153:[function(a,b,c){"use strict";var d=a(92),e=a(93),f=a(85),g=a(89),h=a(127),i=a(111).KEY,j=a(90),k=a(132),l=a(130),m=a(141),n=a(144),o=a(143),p=a(142),q=a(109),r=a(88),s=a(101),t=a(75),u=a(137),v=a(140),w=a(125),x=a(114),y=a(118),z=a(117),A=a(115),B=a(123),C=z.f,D=A.f,E=y.f,F=d.Symbol,G=d.JSON,H=G&&G.stringify,I="prototype",J=n("_hidden"),K=n("toPrimitive"),L={}.propertyIsEnumerable,M=k("symbol-registry"),N=k("symbols"),O=k("op-symbols"),P=Object[I],Q="function"==typeof F,R=d.QObject,S=!R||!R[I]||!R[I].findChild,T=f&&j(function(){return 7!=x(D({},"a",{get:function(){return D(this,"a",{value:7}).a}})).a})?function(a,b,c){var d=C(P,b);d&&delete P[b],D(a,b,c),d&&a!==P&&D(P,b,d)}:D,U=function(a){var b=N[a]=x(F[I]);return b._k=a,b},V=Q&&"symbol"==typeof F.iterator?function(a){return"symbol"==typeof a}:function(a){return a instanceof F},W=function(a,b,c){return a===P&&W(O,b,c),t(a),b=v(b,!0),t(c),e(N,b)?(c.enumerable?(e(a,J)&&a[J][b]&&(a[J][b]=!1),c=x(c,{enumerable:w(0,!1)})):(e(a,J)||D(a,J,w(1,{})),a[J][b]=!0),T(a,b,c)):D(a,b,c)},X=function(a,b){t(a);for(var c,d=r(b=u(b)),e=0,f=d.length;f>e;)W(a,c=d[e++],b[c]);return a},Y=function(a,b){return void 0===b?x(a):X(x(a),b)},Z=function(a){var b=L.call(this,a=v(a,!0));return!(this===P&&e(N,a)&&!e(O,a))&&(!(b||!e(this,a)||!e(N,a)||e(this,J)&&this[J][a])||b)},$=function(a,b){if(a=u(a),b=v(b,!0),a!==P||!e(N,b)||e(O,b)){var c=C(a,b);return!c||!e(N,b)||e(a,J)&&a[J][b]||(c.enumerable=!0),c}},_=function(a){for(var b,c=E(u(a)),d=[],f=0;c.length>f;)e(N,b=c[f++])||b==J||b==i||d.push(b);return d},aa=function(a){for(var b,c=a===P,d=E(c?O:u(a)),f=[],g=0;d.length>g;)!e(N,b=d[g++])||c&&!e(P,b)||f.push(N[b]);return f};Q||(F=function(){if(this instanceof F)throw TypeError("Symbol is not a constructor!");var a=m(arguments.length>0?arguments[0]:void 0),b=function(c){this===P&&b.call(O,c),e(this,J)&&e(this[J],a)&&(this[J][a]=!1),T(this,a,w(1,c))};return f&&S&&T(P,a,{configurable:!0,set:b}),U(a)},h(F[I],"toString",function(){return this._k}),z.f=$,A.f=W,a(119).f=y.f=_,a(124).f=Z,a(120).f=aa,f&&!a(110)&&h(P,"propertyIsEnumerable",Z,!0),o.f=function(a){return U(n(a))}),g(g.G+g.W+g.F*!Q,{Symbol:F});for(var ba="hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables".split(","),ca=0;ba.length>ca;)n(ba[ca++]);for(var ba=B(n.store),ca=0;ba.length>ca;)p(ba[ca++]);g(g.S+g.F*!Q,"Symbol",{for:function(a){return e(M,a+="")?M[a]:M[a]=F(a)},keyFor:function(a){if(V(a))return q(M,a);throw TypeError(a+" is not a symbol!")},useSetter:function(){S=!0},useSimple:function(){S=!1}}),g(g.S+g.F*!Q,"Object",{create:Y,defineProperty:W,defineProperties:X,getOwnPropertyDescriptor:$,getOwnPropertyNames:_,getOwnPropertySymbols:aa}),G&&g(g.S+g.F*(!Q||j(function(){var a=F();return"[null]"!=H([a])||"{}"!=H({a:a})||"{}"!=H(Object(a))})),"JSON",{stringify:function(a){if(void 0!==a&&!V(a)){for(var b,c,d=[a],e=1;arguments.length>e;)d.push(arguments[e++]);return b=d[1],"function"==typeof b&&(c=b),!c&&s(b)||(b=function(a,b){if(c&&(b=c.call(this,a,b)),!V(b))return b}),d[1]=b,H.apply(G,d)}}}),F[I][K]||a(94)(F[I],K,F[I].valueOf),l(F,"Symbol"),l(Math,"Math",!0),l(d.JSON,"JSON",!0)},{101:101,109:109,110:110,111:111,114:114,115:115,117:117,118:118,119:119,120:120,123:123,124:124,125:125,127:127,130:130,132:132,137:137,140:140,141:141,142:142,143:143,144:144,75:75,85:85,88:88,89:89,90:90,92:92,93:93,94:94}],154:[function(a,b,c){"use strict";var d=a(89),e=a(92),f=a(81),g=a(112)(),h=a(144)("observable"),i=a(72),j=a(75),k=a(74),l=a(126),m=a(94),n=a(91),o=n.RETURN,p=function(a){return null==a?void 0:i(a)},q=function(a){var b=a._c;b&&(a._c=void 0,b())},r=function(a){return void 0===a._o},s=function(a){r(a)||(a._o=void 0,q(a))},t=function(a,b){j(a),this._c=void 0,this._o=a,a=new u(this);try{var c=b(a),d=c;null!=c&&("function"==typeof c.unsubscribe?c=function(){d.unsubscribe()}:i(c),this._c=c)}catch(b){return void a.error(b)}r(this)&&q(this)};t.prototype=l({},{unsubscribe:function(){s(this)}});var u=function(a){this._s=a};u.prototype=l({},{next:function(a){var b=this._s;if(!r(b)){var c=b._o;try{var d=p(c.next);if(d)return d.call(c,a)}catch(a){try{s(b)}finally{throw a}}}},error:function(a){var b=this._s;if(r(b))throw a;var c=b._o;b._o=void 0;try{var d=p(c.error);if(!d)throw a;a=d.call(c,a)}catch(a){try{q(b)}finally{throw a}}return q(b),a},complete:function(a){var b=this._s;if(!r(b)){var c=b._o;b._o=void 0;try{var d=p(c.complete);a=d?d.call(c,a):void 0}catch(a){try{q(b)}finally{throw a}}return q(b),a}}});var v=function(a){k(this,v,"Observable","_f")._f=i(a)};l(v.prototype,{subscribe:function(a){return new t(a,this._f)},forEach:function(a){var b=this;return new(f.Promise||e.Promise)(function(c,d){i(a);var e=b.subscribe({next:function(b){try{return a(b)}catch(a){d(a),e.unsubscribe()}},error:d,complete:c})})}}),l(v,{from:function(a){var b="function"==typeof this?this:v,c=p(j(a)[h]);if(c){var d=j(c.call(a));return d.constructor===b?d:new b(function(a){return d.subscribe(a)})}return new b(function(b){var c=!1;return g(function(){if(!c){try{if(n(a,!1,function(a){if(b.next(a),c)return o})===o)return}catch(a){if(c)throw a;return void b.error(a)}b.complete()}}),function(){c=!0}})},of:function(){for(var a=0,b=arguments.length,c=Array(b);a>>2]>>>24-f%4*8&255;b[d+f>>>2]|=g<<24-(d+f)%4*8}else for(var f=0;f>>2]=c[f>>>2];return this.sigBytes+=e,this},clamp:function(){var b=this.words,c=this.sigBytes;b[c>>>2]&=4294967295<<32-c%4*8,b.length=a.ceil(c/4)},clone:function(){var a=f.clone.call(this);return a.words=this.words.slice(0),a},random:function(b){for(var c,d=[],e=function(b){var b=b,c=987654321,d=4294967295;return function(){c=36969*(65535&c)+(c>>16)&d,b=18e3*(65535&b)+(b>>16)&d;var e=(c<<16)+b&d;return e/=4294967296,e+=.5,e*(a.random()>.5?1:-1)}},f=0;f>>2]>>>24-e%4*8&255;d.push((f>>>4).toString(16)),d.push((15&f).toString(16))}return d.join("")},parse:function(a){for(var b=a.length,c=[],d=0;d>>3]|=parseInt(a.substr(d,2),16)<<24-d%8*4;return new g.init(c,b/2)}},j=h.Latin1={stringify:function(a){for(var b=a.words,c=a.sigBytes,d=[],e=0;e>>2]>>>24-e%4*8&255;d.push(String.fromCharCode(f))}return d.join("")},parse:function(a){for(var b=a.length,c=[],d=0;d>>2]|=(255&a.charCodeAt(d))<<24-d%4*8;return new g.init(c,b)}},k=h.Utf8={stringify:function(a){try{return decodeURIComponent(escape(j.stringify(a)))}catch(a){throw new Error("Malformed UTF-8 data")}},parse:function(a){return j.parse(unescape(encodeURIComponent(a)))}},l=e.BufferedBlockAlgorithm=f.extend({reset:function(){this._data=new g.init,this._nDataBytes=0},_append:function(a){"string"==typeof a&&(a=k.parse(a)),this._data.concat(a),this._nDataBytes+=a.sigBytes},_process:function(b){var c=this._data,d=c.words,e=c.sigBytes,f=this.blockSize,h=4*f,i=e/h;i=b?a.ceil(i):a.max((0|i)-this._minBufferSize,0);var j=i*f,k=a.min(4*j,e);if(j){for(var l=0;ld&&(b=a.finalize(b)),b.clamp();for(var e=this._oKey=b.clone(),g=this._iKey=b.clone(),h=e.words,i=g.words,j=0;j>>31}var l=(d<<5|d>>>27)+i+g[j];l+=j<20?(e&f|~e&h)+1518500249:j<40?(e^f^h)+1859775393:j<60?(e&f|e&h|f&h)-1894007588:(e^f^h)-899497514,i=h,h=f,f=e<<30|e>>>2,e=d,d=l}c[0]=c[0]+d|0,c[1]=c[1]+e|0,c[2]=c[2]+f|0,c[3]=c[3]+h|0,c[4]=c[4]+i|0},_doFinalize:function(){var a=this._data,b=a.words,c=8*this._nDataBytes,d=8*a.sigBytes;return b[d>>>5]|=128<<24-d%32,b[(d+64>>>9<<4)+14]=Math.floor(c/4294967296),b[(d+64>>>9<<4)+15]=c,a.sigBytes=4*b.length,this._process(),this._hash},clone:function(){var a=e.clone.call(this);return a._hash=this._hash.clone(),a}});b.SHA1=e._createHelper(h),b.HmacSHA1=e._createHmacHelper(h)}(),a.SHA1})},{156:156}],160:[function(b,c,d){!function(d){"use strict";function e(){var a=d.crypto||d.msCrypto;if(!k&&a&&a.getRandomValues)try{var b=new Uint8Array(16);n=k=function(){return a.getRandomValues(b),b},k()}catch(a){}if(!k){var c=new Array(16);l=k=function(){for(var a,b=0;b<16;b++)0===(3&b)&&(a=4294967296*Math.random()),c[b]=a>>>((3&b)<<3)&255;return c},"undefined"!=typeof console&&console.warn&&console.warn("[SECURITY] node-uuid: crypto not usable, falling back to insecure Math.random()")}}function f(){if("function"==typeof b)try{var a=b("crypto").randomBytes;m=k=a&&function(){return a(16)},k()}catch(a){}}function g(a,b,c){var d=b&&c||0,e=0;for(b=b||[],a.toLowerCase().replace(/[0-9a-f]{2}/g,function(a){e<16&&(b[d+e++]=r[a])});e<16;)b[d+e++]=0;return b}function h(a,b){var c=b||0,d=q;return d[a[c++]]+d[a[c++]]+d[a[c++]]+d[a[c++]]+"-"+d[a[c++]]+d[a[c++]]+"-"+d[a[c++]]+d[a[c++]]+"-"+d[a[c++]]+d[a[c++]]+"-"+d[a[c++]]+d[a[c++]]+d[a[c++]]+d[a[c++]]+d[a[c++]]+d[a[c++]]}function i(a,b,c){var d=b&&c||0,e=b||[];a=a||{};var f=null!=a.clockseq?a.clockseq:v,g=null!=a.msecs?a.msecs:(new Date).getTime(),i=null!=a.nsecs?a.nsecs:x+1,j=g-w+(i-x)/1e4;if(j<0&&null==a.clockseq&&(f=f+1&16383),(j<0||g>w)&&null==a.nsecs&&(i=0),i>=1e4)throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");w=g,x=i,v=f,g+=122192928e5;var k=(1e4*(268435455&g)+i)%4294967296;e[d++]=k>>>24&255,e[d++]=k>>>16&255,e[d++]=k>>>8&255,e[d++]=255&k;var l=g/4294967296*1e4&268435455;e[d++]=l>>>8&255,e[d++]=255&l,e[d++]=l>>>24&15|16,e[d++]=l>>>16&255,e[d++]=f>>>8|128,e[d++]=255&f;for(var m=a.node||u,n=0;n<6;n++)e[d+n]=m[n];return b?b:h(e)}function j(a,b,c){var d=b&&c||0;"string"==typeof a&&(b="binary"===a?new p(16):null,a=null),a=a||{};var e=a.random||(a.rng||k)();if(e[6]=15&e[6]|64,e[8]=63&e[8]|128,b)for(var f=0;f<16;f++)b[d+f]=e[f];return b||h(e)}var k,l,m,n,o;d?e():f();for(var p="function"==typeof Buffer?Buffer:Array,q=[],r={},s=0;s<256;s++)q[s]=(s+256).toString(16).substr(1),r[q[s]]=s;var t=k(),u=[1|t[0],t[1],t[2],t[3],t[4],t[5]],v=16383&(t[6]<<8|t[7]),w=0,x=0,y=j;y.v1=i,y.v4=j,y.parse=g,y.unparse=h,y.BufferClass=p,y._rng=k,y._mathRNG=l,y._nodeRNG=m,y._whatwgRNG=n,"undefined"!=typeof c&&c.exports?c.exports=y:"function"==typeof a&&a.amd?a(function(){return y}):(o=d.uuid,y.noConflict=function(){return d.uuid=o,y},d.uuid=y)}("undefined"!=typeof window?window:null)},{undefined:void 0}],161:[function(a,b,c){"use strict";function d(a){function b(a){}if(!a)throw new TypeError("argument namespace is required");return b._file=void 0,b._ignored=!0,b._namespace=a,b._traced=!1,b._warned=Object.create(null),b.function=e,b.property=f,b}function e(a,b){if("function"!=typeof a)throw new TypeError("argument fn must be a function");return a}function f(a,b,c){if(!a||"object"!=typeof a&&"function"!=typeof a)throw new TypeError("argument obj must be object");var d=Object.getOwnPropertyDescriptor(a,b);if(!d)throw new TypeError("must call property on owner object");if(!d.configurable)throw new TypeError("property must be configurable")}b.exports=d},{}],162:[function(b,c,d){!function(b,e){"undefined"!=typeof d&&"undefined"!=typeof c?c.exports=e():"function"==typeof a&&"object"==typeof a.amd?a(e):"function"==typeof a&&"object"==typeof a.petal?a(b,[],e):this[b]=e()}("validator",function(a){"use strict";function d(a){var b,c,d,e,f=a.match(L);if(f){if(b=f[21],!b)return f[12]?null:0;if("z"===b||"Z"===b)return 0;c=f[22],b.indexOf(":")!==-1?(d=parseInt(f[23]),e=parseInt(f[24])):(d=0,e=parseInt(f[23]))}else{if(a=a.toLowerCase(),b=a.match(/(?:\s|gmt\s*)(-|\+)(\d{1,4})(\s|$)/),!b)return a.indexOf("gmt")!==-1?0:null;c=b[1];var g=b[2];3===g.length&&(g="0"+g),g.length<=2?(d=0,e=parseInt(g)):(d=parseInt(g.slice(0,2)),e=parseInt(g.slice(2,4)))}return(60*d+e)*("-"===c?1:-1)}function e(a,b){a=a||{};for(var c in b)"undefined"==typeof a[c]&&(a[c]=b[c]);return a}function f(a){var b="(\\"+a.symbol.replace(/\./g,"\\.")+")"+(a.require_symbol?"":"?"),c="-?",d="[1-9]\\d*",e="[1-9]\\d{0,2}(\\"+a.thousands_separator+"\\d{3})*",f=["0",d,e],g="("+f.join("|")+")?",h="(\\"+a.decimal_separator+"\\d{2})?",i=g+h;return a.allow_negatives&&!a.parens_for_negatives&&(a.negative_sign_after_digits?i+=c:a.negative_sign_before_digits&&(i=c+i)),a.allow_negative_sign_placeholder?i="( (?!\\-))?"+i:a.allow_space_after_symbol?i=" ?"+i:a.allow_space_after_digits&&(i+="( (?!$))?"),a.symbol_after_digits?i+=b:i=b+i,a.allow_negatives&&(a.parens_for_negatives?i="(\\("+i+"\\)|"+i+")":a.negative_sign_before_digits||a.negative_sign_after_digits||(i=c+i)),new RegExp("^(?!-? )(?=.*\\d)"+i+"$")}a={version:"4.9.0",coerce:!0};for(var g,h=/^[a-z\d!#\$%&'\*\+\-\/=\?\^_`{\|}~]+$/i,i=/^([\s\x01-\x08\x0b\x0c\x0e-\x1f\x7f\x21\x23-\x5b\x5d-\x7e]|(\\[\x01-\x09\x0b\x0c\x0d-\x7f]))*$/i,j=/^[a-z\d!#\$%&'\*\+\-\/=\?\^_`{\|}~\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+$/i,k=/^([\s\x01-\x08\x0b\x0c\x0e-\x1f\x7f\x21\x23-\x5b\x5d-\x7e\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|(\\[\x01-\x09\x0b\x0c\x0d-\x7f\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))*$/i,l=/^[a-z\d!#\$%&'\*\+\-\/=\?\^_`{\|}~\.\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+[a-z\d!#\$%&'\*\+\-\/=\?\^_`{\|}~\.\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF\s]*<(.+)>$/i,m=/^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\d{3})\d{11})$/,n=/^[A-Z]{2}[0-9A-Z]{9}[0-9]$/,o=/^(?:[0-9]{9}X|[0-9]{10})$/,p=/^(?:[0-9]{13})$/,q=/^([0-9a-fA-F][0-9a-fA-F]:){5}([0-9a-fA-F][0-9a-fA-F])$/,r=/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/,s=/^[0-9A-F]{1,4}$/i,t={3:/^[0-9A-F]{8}-[0-9A-F]{4}-3[0-9A-F]{3}-[0-9A-F]{4}-[0-9A-F]{12}$/i,4:/^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,5:/^[0-9A-F]{8}-[0-9A-F]{4}-5[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,all:/^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i},u={"en-US":/^[A-Z]+$/i,"de-DE":/^[A-ZÄÖÜß]+$/i,"es-ES":/^[A-ZÁÉÍÑÓÚÜ]+$/i,"fr-FR":/^[A-ZÀÂÆÇÉÈÊËÏÎÔŒÙÛÜŸ]+$/i,"nl-NL":/^[A-ZÉËÏÓÖÜ]+$/i,"pt-PT":/^[A-ZÃÁÀÂÇÉÊÍÕÓÔÚÜ]+$/i,"ru-RU":/^[А-ЯЁа-яё]+$/i},v={"en-US":/^[0-9A-Z]+$/i,"de-DE":/^[0-9A-ZÄÖÜß]+$/i,"es-ES":/^[0-9A-ZÁÉÍÑÓÚÜ]+$/i,"fr-FR":/^[0-9A-ZÀÂÆÇÉÈÊËÏÎÔŒÙÛÜŸ]+$/i,"nl-NL":/^[0-9A-ZÉËÏÓÖÜ]+$/i,"pt-PT":/^[0-9A-ZÃÁÀÂÇÉÊÍÕÓÔÚÜ]+$/i,"ru-RU":/^[0-9А-ЯЁа-яё]+$/i},w=["AU","GB","HK","IN","NZ","ZA","ZM"],x=0;x=0},a.matches=function(a,b,c){return"[object RegExp]"!==Object.prototype.toString.call(b)&&(b=new RegExp(b,c)),b.test(a)};var N={allow_display_name:!1,allow_utf8_local_part:!0,require_tld:!0};a.isEmail=function(b,c){if(c=e(c,N),c.allow_display_name){var d=b.match(l);d&&(b=d[1])}var f=b.split("@"),g=f.pop(),m=f.join("@"),n=g.toLowerCase();if("gmail.com"!==n&&"googlemail.com"!==n||(m=m.replace(/\./g,"").toLowerCase()),!a.isByteLength(m,{max:64})||!a.isByteLength(g,{max:256}))return!1;if(!a.isFQDN(g,{require_tld:c.require_tld}))return!1;if('"'===m[0])return m=m.slice(1,m.length-1),c.allow_utf8_local_part?k.test(m):i.test(m);for(var o=c.allow_utf8_local_part?j:h,p=m.split("."),q=0;q=2083||/\s/.test(b))return!1;if(0===b.indexOf("mailto:"))return!1;c=e(c,O);var d,f,g,h,i,j,k;if(k=b.split("://"),k.length>1){if(d=k.shift(),c.require_valid_protocol&&c.protocols.indexOf(d)===-1)return!1}else{if(c.require_protocol)return!1;c.allow_protocol_relative_urls&&"//"===b.substr(0,2)&&(k[0]=b.substr(2))}return b=k.join("://"),k=b.split("#"),b=k.shift(),k=b.split("?"),b=k.shift(),k=b.split("/"),b=k.shift(),k=b.split("@"),!(k.length>1&&(f=k.shift(),f.indexOf(":")>=0&&f.split(":").length>2))&&(h=k.join("@"),k=h.split(":"),g=k.shift(),!(k.length&&(j=k.join(":"),i=parseInt(j,10),!/^[0-9]+$/.test(j)||i<=0||i>65535))&&(!(!a.isIP(g)&&!a.isFQDN(g,c)&&"localhost"!==g)&&((!c.host_whitelist||c.host_whitelist.indexOf(g)!==-1)&&(!c.host_blacklist||c.host_blacklist.indexOf(g)===-1))))},a.isMACAddress=function(a){return q.test(a)},a.isIP=function(b,c){
+if(c=c?c+"":"",!c)return a.isIP(b,4)||a.isIP(b,6);if("4"===c){if(!r.test(b))return!1;var d=b.split(".").sort(function(a,b){return a-b});return d[3]<=255}if("6"===c){var e=b.split(":"),f=!1,g=a.isIP(e[e.length-1],4),h=g?7:8;if(e.length>h)return!1;if("::"===b)return!0;"::"===b.substr(0,2)?(e.shift(),e.shift(),f=!0):"::"===b.substr(b.length-2)&&(e.pop(),e.pop(),f=!0);for(var i=0;i0&&i=1:e.length===h}return!1};var P={require_tld:!0,allow_underscores:!1,allow_trailing_dot:!1};a.isFQDN=function(a,b){b=e(b,P),b.allow_trailing_dot&&"."===a[a.length-1]&&(a=a.substring(0,a.length-1));var c=a.split(".");if(b.require_tld){var d=c.pop();if(!c.length||!/^([a-z\u00a1-\uffff]{2,}|xn[a-z0-9-]{2,})$/i.test(d))return!1}for(var f,g=0;g=0)return!1;f=f.replace(/_/g,"")}if(!/^[a-z\u00a1-\uffff0-9-]+$/i.test(f))return!1;if(/[\uff01-\uff5e]/.test(f))return!1;if("-"===f[0]||"-"===f[f.length-1])return!1}return!0},a.isBoolean=function(a){return["true","false","1","0"].indexOf(a)>=0},a.isAlpha=function(a,b){if(b=b||"en-US",b in u)return u[b].test(a);throw new Error("Invalid locale '"+b+"'")},a.isAlphanumeric=function(a,b){if(b=b||"en-US",b in v)return v[b].test(a);throw new Error("Invalid locale '"+b+"'")},a.isNumeric=function(a){return y.test(a)},a.isDecimal=function(a){return""!==a&&C.test(a)},a.isHexadecimal=function(a){return B.test(a)},a.isHexColor=function(a){return D.test(a)},a.isLowercase=function(a){return a===a.toLowerCase()},a.isUppercase=function(a){return a===a.toUpperCase()},a.isInt=function(a,b){return b=b||{},z.test(a)&&(!b.hasOwnProperty("min")||a>=b.min)&&(!b.hasOwnProperty("max")||a<=b.max)},a.isFloat=function(a,b){return b=b||{},""!==a&&"."!==a&&(A.test(a)&&(!b.hasOwnProperty("min")||a>=b.min)&&(!b.hasOwnProperty("max")||a<=b.max))},a.isDivisibleBy=function(b,c){return a.toFloat(b)%parseInt(c,10)===0},a.isNull=function(a){return 0===a.length},a.isLength=function(a,b){var c,d;"object"==typeof b?(c=b.min||0,d=b.max):(c=arguments[1],d=arguments[2]);var e=a.match(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g)||[],f=a.length-e.length;return f>=c&&("undefined"==typeof d||f<=d)},a.isByteLength=function(a,b){var c,d;"object"==typeof b?(c=b.min||0,d=b.max):(c=arguments[1],d=arguments[2]);var e=encodeURI(a).split(/%..|./).length-1;return e>=c&&("undefined"==typeof d||e<=d)},a.isUUID=function(a,b){var c=t[b?b:"all"];return c&&c.test(a)},a.isDate=function(a){var b=new Date(Date.parse(a));if(isNaN(b))return!1;var c=d(a);if(null!==c){var e=b.getTimezoneOffset()-c;b=new Date(b.getTime()+6e4*e)}var f,g,h,i=String(b.getDate());return!(g=a.match(/(^|[^:\d])[23]\d([^:\d]|$)/g))||(f=g.map(function(a){return a.match(/\d+/g)[0]}).join("/"),h=String(b.getFullYear()).slice(-2),f===i||f===h||(f===i+"/"+h||f===h+"/"+i))},a.isAfter=function(b,c){var d=a.toDate(c||new Date),e=a.toDate(b);return!!(e&&d&&e>d)},a.isBefore=function(b,c){var d=a.toDate(c||new Date),e=a.toDate(b);return!!(e&&d&&e=0}return"object"==typeof c?c.hasOwnProperty(b):!(!c||"function"!=typeof c.indexOf)&&c.indexOf(b)>=0},a.isWhitelisted=function(a,b){for(var c=a.length-1;c>=0;c--)if(b.indexOf(a[c])===-1)return!1;return!0},a.isCreditCard=function(a){var b=a.replace(/[^0-9]+/g,"");if(!m.test(b))return!1;for(var c,d,e,f=0,g=b.length-1;g>=0;g--)c=b.substring(g,g+1),d=parseInt(c,10),e?(d*=2,f+=d>=10?d%10+1:d):f+=d,e=!e;return!(f%10!==0||!b)},a.isISIN=function(a){if(!n.test(a))return!1;for(var b,c,d=a.replace(/[A-Z]/g,function(a){return parseInt(a,36)}),e=0,f=!0,g=d.length-2;g>=0;g--)b=d.substring(g,g+1),c=parseInt(b,10),f?(c*=2,e+=c>=10?c+1:c):e+=c,f=!f;return parseInt(a.substr(a.length-1),10)===(1e4-e)%10},a.isISBN=function(b,c){if(c=c?c+"":"",!c)return a.isISBN(b,10)||a.isISBN(b,13);var d,e=b.replace(/[\s-]+/g,""),f=0;if("10"===c){if(!o.test(e))return!1;for(d=0;d<9;d++)f+=(d+1)*e.charAt(d);if(f+="X"===e.charAt(9)?100:10*e.charAt(9),f%11===0)return!!e}else if("13"===c){if(!p.test(e))return!1;var g=[1,3];for(d=0;d<12;d++)f+=g[d%2]*e.charAt(d);if(e.charAt(12)-(10-f%10)%10===0)return!!e}return!1},a.isMobilePhone=function(a,b){return b in K&&K[b].test(a)};var Q={symbol:"$",require_symbol:!1,allow_space_after_symbol:!1,symbol_after_digits:!1,allow_negatives:!0,parens_for_negatives:!1,negative_sign_before_digits:!1,negative_sign_after_digits:!1,allow_negative_sign_placeholder:!1,thousands_separator:",",decimal_separator:".",allow_space_after_digits:!1};a.isCurrency=function(a,b){return b=e(b,Q),f(b).test(a)},a.isJSON=function(a){try{var b=JSON.parse(a);return!!b&&"object"==typeof b}catch(a){}return!1},a.isMultibyte=function(a){return F.test(a)},a.isAscii=function(a){return E.test(a)},a.isFullWidth=function(a){return G.test(a)},a.isHalfWidth=function(a){return H.test(a)},a.isVariableWidth=function(a){return G.test(a)&&H.test(a)},a.isSurrogatePair=function(a){return I.test(a)},a.isBase64=function(a){return J.test(a)},a.isMongoId=function(b){return a.isHexadecimal(b)&&24===b.length},a.isISO8601=function(a){return L.test(a)},a.ltrim=function(a,b){var c=b?new RegExp("^["+b+"]+","g"):/^\s+/g;return a.replace(c,"")},a.rtrim=function(a,b){var c=b?new RegExp("["+b+"]+$","g"):/\s+$/g;return a.replace(c,"")},a.trim=function(a,b){var c=b?new RegExp("^["+b+"]+|["+b+"]+$","g"):/^\s+|\s+$/g;return a.replace(c,"")},a.escape=function(a){return a.replace(/&/g,"&").replace(/"/g,""").replace(/'/g,"'").replace(//g,">").replace(/\//g,"/").replace(/\`/g,"`")},a.stripLow=function(b,c){var d=c?"\\x00-\\x09\\x0B\\x0C\\x0E-\\x1F\\x7F":"\\x00-\\x1F\\x7F";return a.blacklist(b,d)},a.whitelist=function(a,b){return a.replace(new RegExp("[^"+b+"]+","g"),"")},a.blacklist=function(a,b){return a.replace(new RegExp("["+b+"]+","g"),"")};var R={lowercase:!0,remove_dots:!0,remove_extension:!0};return a.normalizeEmail=function(b,c){if(c=e(c,R),!a.isEmail(b))return!1;var d=b.split("@",2);if(d[1]=d[1].toLowerCase(),"gmail.com"===d[1]||"googlemail.com"===d[1]){if(c.remove_extension&&(d[0]=d[0].split("+")[0]),c.remove_dots&&(d[0]=d[0].replace(/\./g,"")),!d[0].length)return!1;d[0]=d[0].toLowerCase(),d[1]="gmail.com"}else c.lowercase&&(d[0]=d[0].toLowerCase());return d.join("@")},a.init(),a})},{161:161}],163:[function(a,b,c){"use strict";a(152),a(148),Object.assign||a(149),Object.setPrototypeOf||a(150),"undefined"==typeof Promise&&a(151),Array.from||(a(146),a(147)),"undefined"==typeof Symbol&&a(153)},{146:146,147:147,148:148,149:149,150:150,151:151,152:152,153:153}],164:[function(a,c,d){"use strict";var e=(a(23),a(36)),f=a(165).WebSocket,g=function(){function a(c){b.classCallCheck(this,a),this.host=c.host,this.port=c.port,this.secure=c.secure,this.basePath=c.basePath,this.connector=c,this.listeners={}}return a.create=function(b){if(!b)throw new Error("No connector was provided, but connector is required for websocket connection!");var c=this.websockets[b.origin];return c||(c=new a(b),this.websockets[b.origin]=c),c},a.prototype.subscribe=function(a,b){a=Object(a)instanceof String?a:JSON.stringify(a),this.listeners[a]?this.listeners[a].indexOf(b)==-1&&this.listeners[a].push(b):this.listeners[a]=[b]},a.prototype.unsubscribe=function(a,b){if(a=Object(a)instanceof String?a:JSON.stringify(a),this.listeners[a]){var c=this.listeners[a].indexOf(b);c!=-1&&this.listeners[a].splice(c,1)}},a.prototype.socketListener=function(a){var b=JSON.parse(a.data),c=b.topic;c=Object(c)instanceof String?c:JSON.stringify(c),this.listeners[c]&&this.listeners[c].forEach(function(a){a(b)})},a.prototype.sendOverSocket=function(a){var b=this;this.socketOpen||(this.socketOpen=new Promise(function(a,c){b.connector.send(new e.EventsUrl).then(function(a){return a.entity.urls},function(){return null}).then(function(d){var e=void 0;d?!function(){var a=b.secure?"wss://":"ws://";d=d.filter(function(b){return 0==b.indexOf(a)});var c=d.length;e=d[Math.floor(Math.random()*c)]}():e=(b.secure?"wss://":"ws://")+b.host+":"+b.port+b.basePath+"/events",b.socket=b.createWebSocket(e),b.socket.onmessage=b.socketListener.bind(b),b.socket.onopen=a,b.socket.onerror=c,b.socket.onclose=function(){b.socket=null,b.socketOpen=null}}).catch(c)})),this.socketOpen.then(function(){var c=JSON.stringify(a);b.socket.send(c)})},a.prototype.createWebSocket=function(a){return new f(a)},a}();Object.assign(g,{websockets:{}}),c.exports=g},{165:165,23:23,36:36}],165:[function(a,b,c){"use strict";c.WebSocket=window.WebSocket},{}],166:[function(a,b,c){"use strict";var d=a(35);b.exports=c=d,c.Observable=a(167),c.connector.WebSocketConnector=a(164),c.query.Node=a(168),c.query.Stream=a(169)},{164:164,167:167,168:168,169:169,35:35}],167:[function(a,b,c){"use strict";if("undefined"!=typeof Rx)b.exports=Rx.Observable;else try{b.exports=a("rxjs/Observable").Observable}catch(c){if("undefined"==typeof Observable){a(155),a(154);var d=Observable.prototype.subscribe;Observable.prototype.subscribe=function(a,b,c){return a instanceof Function?d.call(this,{next:a,error:b,complete:c}):d.call(this,a)}}b.exports=Observable}},{154:154,155:155,undefined:void 0}],168:[function(a,b,c){"use strict";var d=a(169),e=a(56);e.prototype._stream=function(a,b){var c=this.resultClass?this.entityManager.metamodel.entity(this.resultClass):null;if(!c)throw new Error("Only typed queries can be executed.");return b||(b=this),new d(this.entityManager,c.name,this._serializeQuery(),a,this._serializeSort(),this.maxResults,this.firstResult,b).observable()},b.exports=e},{169:169,56:56}],169:[function(a,c,d){"use strict";var e=a(63),f=a(164),g=a(35),h=function(){function a(c,d,e,g,h,i,j,k){b.classCallCheck(this,a);var l=a.parseOptions(g);this.entityManager=c,this.query={bucket:d,matchTypes:l.matchTypes,operations:l.operations,initial:l.initial,query:e,sort:h,start:j,count:i},this.callbacks=[],this.topic=a.getTopic(this.query.bucket,this.query.query,this.query.start,this.query.count,this.query.sort,this.query.matchTypes,this.query.operations),this.target=k,this.socket=f.create(c._connector)}return a.prototype.observable=function(){var a=this;return new g.Observable(function(b){var c=function(a){"error"===a.matchType?b.error(a):b.next(a)};return a.on(a.query.matchTypes,c),function(){a.off(a.query.matchTypes,c)}})},a.prototype.on=function(a,b){var c=this._wrapQueryCallback(b);this.socket.subscribe(this.topic,c);var d={register:!0,topic:this.topic,query:this.query};this.query.initial===!0&&(d.fromstart=!0),this.socket.sendOverSocket(d),this.callbacks.push({matchTypes:a,callback:b,topic:this.topic,wrappedCallback:c,queryMessage:d})},a.getCachableQueryString=function(b,c,d,e){var f=b;return a.isEmptyJSONString(b)&&(f="{}"),c>0&&(f+="&start="+c),d>0&&(f+="&count="+d),a.isEmptyJSONString(e)||(f+="&sort="+e),f},a.getTopic=function(b,c,d,e,f,g,h){return[b,a.getCachableQueryString(c,d,e,f),a.normalizeMatchTypes(g).join("_"),a.normalizeOperations(h).join("_")].join("/")},a.isEmptyJSONString=function(a){return void 0===a||null===a||/^\s*(\{\s*\})?\s*$/.test(a)},a.parseOptions=function(b){var c={matchTypes:["all"],operations:["any"]};if(b){if(null!==b.initial&&void 0!==b.initial){if("boolean"!=typeof b.initial)throw new Error('Option "initial" only permits Boolean values!');c.initial=b.initial}if(b.matchTypes&&(Array.isArray(b.matchTypes)?c.matchTypes=b.matchTypes:c.matchTypes=[b.matchTypes],c.matchTypes=a.normalizeMatchTypes(c.matchTypes)),b.operations&&(Array.isArray(b.operations)?c.operations=b.operations:c.operations=[b.operations],c.operations=a.normalizeOperations(c.operations)),c.matchTypes.indexOf("all")==-1&&c.operations.indexOf("any")==-1)throw new Error("Only subscriptions for either operations or matchTypes are allowed. You cannot subscribe to a query using matchTypes and operations at the same time!")}return null!==c.initial&&void 0!==c.initial||(c.initial=!0),c.matchTypes||(c.matchTypes=["all"]),c.operations||(c.operations=["any"]),c},a.normalizeMatchTypes=function(b){return a.normalizeSortedSet(b,"all","match types",["add","change","changeIndex","match","remove"])},a.normalizeOperations=function(b){return a.normalizeSortedSet(b,"any","operations",["delete","insert","none","update"])},a.normalizeSortedSet=function(a,b,c,d){if(a&&0!=a.length){a.sort();for(var e,f=void 0,g=a.length-1;g>=0;g--){if(e=a[g],!e)throw new Error("undefined and null not allowed!");if(e===f&&a.splice(g,1),e===b)return[b];if(d.indexOf(e)==-1)throw new Error(e+" not allowed for "+c+"! (permitted: "+d+".)");f=e}return a}},a.prototype.off=function(a,b){var c=this;this.callbacks=this.callbacks.reduce(function(d,e){return b&&e.callback!=b||a&&e.matchTypes!=a?d.push(e):(c.socket.unsubscribe(e.topic,e.wrappedCallback),e.queryMessage.register=!1,c.socket.sendOverSocket(e.queryMessage)),d},[])},a.prototype._wrapQueryCallback=function(a){return function(b){var c=this;if(b.query=this.query,b.result){var d={matchType:"add",operation:"none"},e=0;b.result.forEach(function(f){var g=c._createObject(f,!1);b.ordered&&(d.index=e++);var h=c.createCallback(b,d,g,!0);a(h)},this)}if(b.match){var f=b.match.object,g=this._createObject(f,"delete"===b.match.operation),h=this.createCallback(b,b.match,g,!1);a(h)}}.bind(this)},a.prototype.createCallback=function(a,b,c,d){var e={matchType:b.matchType,operation:b.operation,data:c,date:new Date(a.date),target:this.target,initial:d};return void 0!==b.index&&(e.index=b.index),e},a.prototype._createObject=function(a,b){var c;if(a&&(c=this.entityManager.getReference(a.id),c.version
+*
+* core.js - https://github.com/zloirock/core-js
+* Copyright (c) 2014-2016 Denis Pushkarev
+*
+* node-uuid - http://github.com/broofa/node-uuid
+* Copyright (c) 2010-2012 Robert Kieffer
+*
+* validator - http://github.com/chriso/validator.js
+* Copyright (c) 2015 Chris O'Hara
+*
+* Released under the MIT license
+*
+* Date: Wed, 09 Nov 2016 13:31:18 GMT
+*/
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.DB = f()}})(function(){var define,module,exports;var babelHelpers = {};
+babelHelpers.typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
+ return typeof obj;
+} : function (obj) {
+ return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+};
+
+babelHelpers.classCallCheck = function (instance, Constructor) {
+ if (!(instance instanceof Constructor)) {
+ throw new TypeError("Cannot call a class as a function");
+ }
+};
+
+babelHelpers.createClass = function () {
+ function defineProperties(target, props) {
+ for (var i = 0; i < props.length; i++) {
+ var descriptor = props[i];
+ descriptor.enumerable = descriptor.enumerable || false;
+ descriptor.configurable = true;
+ if ("value" in descriptor) descriptor.writable = true;
+ Object.defineProperty(target, descriptor.key, descriptor);
+ }
+ }
+
+ return function (Constructor, protoProps, staticProps) {
+ if (protoProps) defineProperties(Constructor.prototype, protoProps);
+ if (staticProps) defineProperties(Constructor, staticProps);
+ return Constructor;
+ };
+}();
+
+babelHelpers.defaults = function (obj, defaults) {
+ var keys = Object.getOwnPropertyNames(defaults);
+
+ for (var i = 0; i < keys.length; i++) {
+ var key = keys[i];
+ var value = Object.getOwnPropertyDescriptor(defaults, key);
+
+ if (value && value.configurable && obj[key] === undefined) {
+ Object.defineProperty(obj, key, value);
+ }
+ }
+
+ return obj;
+};
+
+babelHelpers.inherits = function (subClass, superClass) {
+ if (typeof superClass !== "function" && superClass !== null) {
+ throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+ }
+
+ subClass.prototype = Object.create(superClass && superClass.prototype, {
+ constructor: {
+ value: subClass,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ });
+ if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : babelHelpers.defaults(subClass, superClass);
+};
+
+babelHelpers.possibleConstructorReturn = function (self, call) {
+ if (!self) {
+ throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+ }
+
+ return call && (typeof call === "object" || typeof call === "function") ? call : self;
+};
+
+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);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;otrue If public access is allowed
+ */
+
+
+ Acl.prototype.isPublicReadAllowed = function isPublicReadAllowed() {
+ return this.read.isPublicAllowed();
+ };
+
+ /**
+ * Sets whenever all users and roles should have the permission to read the object.
+ * Note: All other allow read rules will be removed.
+ */
+
+
+ Acl.prototype.setPublicReadAllowed = function setPublicReadAllowed() {
+ return this.read.setPublicAllowed();
+ };
+
+ /**
+ * Checks whenever the user or role is explicit allowed to read the object.
+ *
+ * @param {model.User|model.Role|string} userOrRole The user or role to check for
+ * @return {boolean} true if read access is explicitly allowed for the given user or role
+ */
+
+
+ Acl.prototype.isReadAllowed = function isReadAllowed(userOrRole) {
+ return this.read.isAllowed(userOrRole);
+ };
+
+ /**
+ * Checks whenever the user or role is explicit denied to read the object
+ *
+ * @param {model.User|model.Role|string} userOrRole The user or role to check for
+ * @return {boolean} true if read access is explicitly denied for the given user or role
+ */
+
+
+ Acl.prototype.isReadDenied = function isReadDenied(userOrRole) {
+ return this.read.isDenied(userOrRole);
+ };
+
+ /**
+ * Allows the given user or rule to read the object
+ * @param {...(model.User|model.Role|string)} userOrRole The user or role to allow
+ * @return {Acl} this acl object
+ */
+
+
+ Acl.prototype.allowReadAccess = function allowReadAccess(userOrRole) {
+ Permission.prototype.allowAccess.apply(this.read, arguments);
+ return this;
+ };
+
+ /**
+ * Denies the given user or rule to read the object
+ * @param {...(model.User|model.Role|string)} userOrRole The user or role to deny
+ * @return {Acl} this acl object
+ */
+
+
+ Acl.prototype.denyReadAccess = function denyReadAccess(userOrRole) {
+ Permission.prototype.denyAccess.apply(this.read, arguments);
+ return this;
+ };
+
+ /**
+ * Deletes any read allow/deny rule for the given user or role
+ * @param {...(model.User|model.Role|string)} userOrRole The user or role
+ * @return {Acl} this acl object
+ */
+
+
+ Acl.prototype.deleteReadAccess = function deleteReadAccess(userOrRole) {
+ Permission.prototype.deleteAccess.apply(this.read, arguments);
+ return this;
+ };
+
+ /**
+ * Gets whenever all users and roles have the permission to write the object
+ * @return {boolean} true If public access is allowed
+ */
+
+
+ Acl.prototype.isPublicWriteAllowed = function isPublicWriteAllowed() {
+ return this.write.isPublicAllowed();
+ };
+
+ /**
+ * Sets whenever all users and roles should have the permission to write the object.
+ * Note: All other allow write rules will be removed.
+ */
+
+
+ Acl.prototype.setPublicWriteAllowed = function setPublicWriteAllowed() {
+ return this.write.setPublicAllowed();
+ };
+
+ /**
+ * Checks whenever the user or role is explicit allowed to write the object.
+ *
+ * @param {model.User|model.Role|string} userOrRole The user or role to check for
+ * @return {boolean} true if write access is explicitly allowed for the given user or role
+ */
+
+
+ Acl.prototype.isWriteAllowed = function isWriteAllowed(userOrRole) {
+ return this.write.isAllowed(userOrRole);
+ };
+
+ /**
+ * Checks whenever the user or role is explicit denied to write the object
+ *
+ * @param {model.User|model.Role|string} userOrRole The user or role to check for
+ * @return {boolean} true if write access is explicitly denied for the given user or role
+ */
+
+
+ Acl.prototype.isWriteDenied = function isWriteDenied(userOrRole) {
+ return this.write.isDenied(userOrRole);
+ };
+
+ /**
+ * Allows the given user or rule to write the object
+ * @param {...(model.User|model.Role|string)} userOrRole The user or role to allow
+ * @return {Acl} this acl object
+ */
+
+
+ Acl.prototype.allowWriteAccess = function allowWriteAccess(userOrRole) {
+ Permission.prototype.allowAccess.apply(this.write, arguments);
+ return this;
+ };
+
+ /**
+ * Denies the given user or rule to write the object
+ * @param {...(model.User|model.Role|string)} userOrRole The user or role to deny
+ * @return {Acl} this acl object
+ */
+
+
+ Acl.prototype.denyWriteAccess = function denyWriteAccess(userOrRole) {
+ Permission.prototype.denyAccess.apply(this.write, arguments);
+ return this;
+ };
+
+ /**
+ * Deletes any write allow/deny rule for the given user or role
+ * @param {...(model.User|model.Role|string)} userOrRole The user or role
+ * @return {Acl} this acl object
+ */
+
+
+ Acl.prototype.deleteWriteAccess = function deleteWriteAccess(userOrRole) {
+ Permission.prototype.deleteAccess.apply(this.write, arguments);
+ return this;
+ };
+
+ /**
+ * A Json representation of the set of rules
+ * @return {json}
+ */
+
+
+ Acl.prototype.toJSON = function toJSON() {
+ return {
+ read: this.read,
+ write: this.write
+ };
+ };
+
+ /**
+ * Sets the acl rules form json
+ * @param {json} json The json encoded acls
+ */
+
+
+ Acl.prototype.fromJSON = function fromJSON(json) {
+ this.read.fromJSON(json.read || {});
+ this.write.fromJSON(json.write || {});
+ };
+
+ return Acl;
+}();
+
+module.exports = Acl;
+
+},{"65":65}],2:[function(_dereq_,module,exports){
+"use strict";
+
+var message = _dereq_(36);
+var error = _dereq_(34);
+var binding = _dereq_(20);
+var util = _dereq_(70);
+var query = _dereq_(59);
+
+var UserFactory = _dereq_(19);
+var EntityTransaction = _dereq_(4);
+var Metadata = _dereq_(63);
+var Message = _dereq_(25);
+var BloomFilter = _dereq_(21);
+var StatusCode = Message.StatusCode;
+
+/**
+ * @alias EntityManager
+ * @extends util.Lockable
+ */
+
+var EntityManager = function (_util$Lockable) {
+ babelHelpers.inherits(EntityManager, _util$Lockable);
+ babelHelpers.createClass(EntityManager, [{
+ key: 'isOpen',
+
+
+ /**
+ * Determine whether the entity manager is open.
+ * true until the entity manager has been closed
+ * @type boolean
+ */
+ get: function get() {
+ return !!this._connector;
+ }
+
+ /**
+ * The authentication token if the user is logged in currently
+ * @type String
+ */
+
+ }, {
+ key: 'token',
+ get: function get() {
+ return this.tokenStorage.token;
+ },
+
+
+ /**
+ * The authentication token if the user is logged in currently
+ * @param {String} value
+ */
+ set: function set(value) {
+ this.tokenStorage.update(value);
+ }
+
+ /**
+ * @param {EntityManagerFactory} entityManagerFactory The factory which of this entityManager instance
+ */
+
+ }, {
+ key: 'isCachingDisabled',
+ get: function get() {
+ return !this.bloomFilter;
+ }
+ }]);
+
+ function EntityManager(entityManagerFactory) {
+ babelHelpers.classCallCheck(this, EntityManager);
+
+ /**
+ * Log messages can created by calling log directly as function, with a specific log level or with the helper
+ * methods, which a members of the log method.
+ *
+ * Logs will be filtered by the client logger and the before they persisted. The default log level is
+ * 'info' therefore all log messages below the given message aren't persisted.
+ *
+ * Examples:
+ *
+ // default log level ist info
+ db.log('test message %s', 'my string');
+ // info: test message my string
+ // pass a explicit log level as the first argument, one of ('trace', 'debug', 'info', 'warn', 'error')
+ db.log('warn', 'test message %d', 123);
+ // warn: test message 123
+ // debug log level will not be persisted by default, since the default logging level is info
+ db.log('debug', 'test message %j', {number: 123}, {});
+ // debug: test message {"number":123}
+ // data = {}
+ // One additional json object can be provided, which will be persisted together with the log entry
+ db.log('info', 'test message %s, %s', 'first', 'second', {number: 123});
+ // info: test message first, second
+ // data = {number: 123}
+ //use the log level helper
+ db.log.info('test message', 'first', 'second', {number: 123});
+ // info: test message first second
+ // data = {number: 123}
+ //change the default log level to trace, i.e. all log levels will be persisted, note that the log level can be
+ //additionally configured in the baqend
+ db.log.level = 'trace';
+ //trace will be persisted now
+ db.log.trace('test message', 'first', 'second', {number: 123});
+ // info: test message first second
+ // data = {number: 123}
+ *
+ *
+ * @type util.Logger
+ */
+ var _this = babelHelpers.possibleConstructorReturn(this, _util$Lockable.call(this));
+
+ _this.log = util.Logger.create(_this);
+
+ /**
+ * The connector used for requests
+ * @type connector.Connector
+ * @private
+ */
+ _this._connector = null;
+
+ /**
+ * All managed and cached entity instances
+ * @type Map
+ */
+ _this._entities = null;
+
+ /** @type EntityManagerFactory */
+ _this.entityManagerFactory = entityManagerFactory;
+
+ /** @type metamodel.Metamodel */
+ _this.metamodel = entityManagerFactory.metamodel;
+
+ /** @type util.Code */
+ _this.code = entityManagerFactory.code;
+
+ /** @type util.Modules */
+ _this.modules = null;
+
+ /**
+ * The current logged in user object
+ * @type model.User
+ */
+ _this.me = null;
+
+ /**
+ * Returns true if the device token is already registered, otherwise false.
+ * @type boolean
+ */
+ _this.isDeviceRegistered = false;
+
+ /**
+ * Returns the tokenStorage which will be used to authorize all requests.
+ * @type {util.TokenStorage}
+ */
+ _this.tokenStorage = null;
+
+ /**
+ * @type {caching.BloomFilter}
+ */
+ _this.bloomFilter = null;
+
+ /**
+ * Set of object ids that were revalidated after the Bloom filter was loaded.
+ */
+ _this.cacheWhiteList = null;
+
+ /**
+ * Set of object ids that were updated but are not yet included in the bloom filter.
+ * This set essentially implements revalidation by side effect which does not work in Chrome.
+ */
+ _this.cacheBlackList = null;
+
+ /**
+ * Bloom filter refresh interval in seconds.
+ *
+ * @type {number}
+ */
+ _this.bloomFilterRefresh = 60;
+
+ /**
+ * Bloom filter refresh Promise
+ *
+ */
+ _this._bloomFilterLock = new util.Lockable();
+ return _this;
+ }
+
+ /**
+ * Connects this entityManager, used for synchronous and asynchronous initialization
+ * @param {connector.Connector} connector
+ * @param {Object} connectData
+ * @param {util.TokenStorage} tokenStorage The used tokenStorage for token persistence
+ */
+
+
+ EntityManager.prototype.connected = function connected(connector, connectData, tokenStorage) {
+ this._connector = connector;
+ this.tokenStorage = tokenStorage;
+ this.bloomFilterRefresh = this.entityManagerFactory.staleness;
+ this._entities = {};
+
+ this.File = binding.FileFactory.create(this);
+ this._createObjectFactory(this.metamodel.embeddables);
+ this._createObjectFactory(this.metamodel.entities);
+
+ this.transaction = new EntityTransaction(this);
+ this.modules = new util.Modules(this, connector);
+
+ if (connectData) {
+ this.isDeviceRegistered = !!connectData.device;
+ if (connectData.user && connectData.token == tokenStorage.token) this._updateUser(connectData.user, true);
+
+ if (this.bloomFilterRefresh > 0 && connectData.bloomFilter && util.atob && !util.isNode) {
+ this.updateBloomFilter(connectData.bloomFilter);
+ }
+ }
+ };
+
+ /**
+ * @param {metamodel.ManagedType[]} types
+ * @return {binding.ManagedFactory}
+ * @private
+ */
+
+
+ EntityManager.prototype._createObjectFactory = function _createObjectFactory(types) {
+ Object.keys(types).forEach(function (ref) {
+ var type = this.metamodel.managedType(ref);
+ var name = type.name;
+
+ if (this[name]) {
+ type.typeConstructor = this[name];
+ Object.defineProperty(this, name, {
+ value: type.createObjectFactory(this)
+ });
+ } else {
+ Object.defineProperty(this, name, {
+ get: function get() {
+ Object.defineProperty(this, name, {
+ value: type.createObjectFactory(this)
+ });
+
+ return this[name];
+ },
+ set: function set(typeConstructor) {
+ type.typeConstructor = typeConstructor;
+ },
+
+ configurable: true
+ });
+ }
+ }, this);
+ };
+
+ EntityManager.prototype.send = function send(message) {
+ var _this2 = this;
+
+ message.tokenStorage = this.tokenStorage;
+ return this._connector.send(message).catch(function (e) {
+ if (e.status == StatusCode.BAD_CREDENTIALS) {
+ _this2._logout();
+ }
+ throw e;
+ });
+ };
+
+ /**
+ * Get an instance, whose state may be lazily fetched. If the requested instance does not exist
+ * in the database, the EntityNotFoundError is thrown when the instance state is first accessed.
+ * The application should not expect that the instance state will be available upon detachment,
+ * unless it was accessed by the application while the entity manager was open.
+ *
+ * @param {(Class|string)} entityClass
+ * @param {string=} key
+ */
+
+
+ EntityManager.prototype.getReference = function getReference(entityClass, key) {
+ var id, type;
+ if (key) {
+ type = this.metamodel.entity(entityClass);
+ if (key.indexOf('/db/') == 0) {
+ id = key;
+ } else {
+ id = type.ref + '/' + encodeURIComponent(key);
+ }
+ } else {
+ id = entityClass;
+ type = this.metamodel.entity(id.substring(0, id.indexOf('/', 4))); //skip /db/
+ }
+
+ var entity = this._entities[id];
+ if (!entity) {
+ entity = type.create();
+ var metadata = Metadata.get(entity);
+ metadata.id = id;
+ metadata.setUnavailable();
+
+ this._attach(entity);
+ }
+
+ return entity;
+ };
+
+ /**
+ * Creates an instance of Query.Builder for query creation and execution. The Query results are instances of the
+ * resultClass argument.
+ * @param {Class<*>=} resultClass - the type of the query result
+ * @return {query.Builder<*>} A query builder to create one ore more queries for the specified class
+ */
+
+
+ EntityManager.prototype.createQueryBuilder = function createQueryBuilder(resultClass) {
+ return new query.Builder(this, resultClass);
+ };
+
+ /**
+ * Clear the persistence context, causing all managed entities to become detached.
+ * Changes made to entities that have not been flushed to the database will not be persisted.
+ */
+
+
+ EntityManager.prototype.clear = function clear() {
+ this._entities = {};
+ };
+
+ /**
+ * Close an application-managed entity manager. After the close method has been invoked,
+ * all methods on the EntityManager instance and any Query and TypedQuery objects obtained from it
+ * will throw the IllegalStateError except for transaction, and isOpen (which will return false).
+ * If this method is called when the entity manager is associated with an active transaction,
+ * the persistence context remains managed until the transaction completes.
+ */
+
+
+ EntityManager.prototype.close = function close() {
+ this._connector = null;
+
+ return this.clear();
+ };
+
+ /**
+ * Check if the instance is a managed entity instance belonging to the current persistence context.
+ * @param {binding.Entity} entity - entity instance
+ * @returns {boolean} boolean indicating if entity is in persistence context
+ */
+
+
+ EntityManager.prototype.contains = function contains(entity) {
+ return !!entity && this._entities[entity.id] === entity;
+ };
+
+ /**
+ * Check if an object with the id from the given entity is already attached.
+ * @param {binding.Entity} entity - entity instance
+ * @returns {boolean} boolean indicating if entity with same id is attached
+ */
+
+
+ EntityManager.prototype.containsById = function containsById(entity) {
+ return !!(entity && this._entities[entity.id]);
+ };
+
+ /**
+ * Remove the given entity from the persistence context, causing a managed entity to become detached.
+ * Unflushed changes made to the entity if any (including removal of the entity),
+ * will not be synchronized to the database. Entities which previously referenced the detached entity will continue to reference it.
+ * @param {binding.Entity} entity - entity instance
+ */
+
+
+ EntityManager.prototype.detach = function detach(entity) {
+ var _this3 = this;
+
+ var state = Metadata.get(entity);
+ return state.withLock(function () {
+ _this3.removeReference(entity);
+ return Promise.resolve(entity);
+ });
+ };
+
+ /**
+ * Resolve the depth by loading the referenced objects of the given entity.
+ *
+ * @param {binding.Entity} entity - entity instance
+ * @param {Object} [options] The load options
+ * @return {Promise}
+ */
+
+
+ EntityManager.prototype.resolveDepth = function resolveDepth(entity, options) {
+ var _this4 = this;
+
+ if (!options || !options.depth) return Promise.resolve(entity);
+
+ options.resolved = options.resolved || [];
+ var promises = [];
+ var subOptions = Object.assign({}, options, {
+ depth: options.depth === true ? true : options.depth - 1
+ });
+ this.getSubEntities(entity, 1).forEach(function (subEntity) {
+ if (subEntity != null && !~options.resolved.indexOf(subEntity)) {
+ options.resolved.push(subEntity);
+ promises.push(_this4.load(subEntity.id, null, subOptions));
+ }
+ });
+
+ return Promise.all(promises).then(function () {
+ return entity;
+ });
+ };
+
+ /**
+ * Search for an entity of the specified oid.
+ * If the entity instance is contained in the persistence context, it is returned from there.
+ * @param {(Class|string)} entityClass - entity class
+ * @param {String} oid - Object ID
+ * @param {Object} [options] The load options.
+ * @return {Promise} the loaded entity or null
+ */
+
+
+ EntityManager.prototype.load = function load(entityClass, oid, options) {
+ var _this5 = this;
+
+ options = options || {};
+ var entity = this.getReference(entityClass, oid);
+ var state = Metadata.get(entity);
+
+ if (!options.refresh && options.local && state.isAvailable) {
+ return this.resolveDepth(entity, options);
+ }
+
+ var msg = new message.GetObject(state.bucket, state.key);
+
+ this.ensureCacheHeader(entity.id, msg, options.refresh);
+
+ return this.send(msg).then(function (response) {
+ // refresh object if loaded older version from cache
+ // chrome doesn't using cache when ifNoneMatch is set
+ if (entity.version > response.entity.version) {
+ options.refresh = true;
+ return _this5.load(entityClass, oid, options);
+ }
+
+ _this5.addToWhiteList(response.entity.id);
+
+ if (response.status != StatusCode.NOT_MODIFIED) {
+ state.setJson(response.entity);
+ }
+
+ state.setPersistent();
+
+ return _this5.resolveDepth(entity, options);
+ }, function (e) {
+ if (e.status == StatusCode.OBJECT_NOT_FOUND) {
+ _this5.removeReference(entity);
+ state.setRemoved();
+ return null;
+ } else {
+ throw e;
+ }
+ });
+ };
+
+ /**
+ * @param {binding.Entity} entity
+ * @param {Object} options
+ * @return {Promise}
+ */
+
+
+ EntityManager.prototype.insert = function insert(entity, options) {
+ var _this6 = this;
+
+ options = options || {};
+ var isNew;
+
+ return this._save(entity, options, function (state, json) {
+ if (state.version) throw new error.PersistentError('Existing objects can\'t be inserted.');
+
+ isNew = !state.id;
+
+ return new message.CreateObject(state.bucket, json);
+ }).then(function (val) {
+ if (isNew) _this6._attach(entity);
+
+ return val;
+ });
+ };
+
+ /**
+ * @param {binding.Entity} entity
+ * @param {Object} options
+ * @return {Promise}
+ */
+
+
+ EntityManager.prototype.update = function update(entity, options) {
+ options = options || {};
+
+ return this._save(entity, options, function (state, json) {
+ if (!state.version) throw new error.PersistentError("New objects can't be inserted.");
+
+ if (options.force) {
+ delete json.version;
+ return new message.ReplaceObject(state.bucket, state.key, json).ifMatch('*');
+ } else {
+ return new message.ReplaceObject(state.bucket, state.key, json).ifMatch(state.version);
+ }
+ });
+ };
+
+ /**
+ * @param {binding.Entity} entity
+ * @param {Object} options The save options
+ * @param {boolean=} withoutLock Set true to save the entity without locking
+ * @return {Promise}
+ */
+
+
+ EntityManager.prototype.save = function save(entity, options, withoutLock) {
+ options = options || {};
+
+ var msgFactory = function msgFactory(state, json) {
+ if (options.force) {
+ if (!state.id) throw new error.PersistentError("New special objects can't be forcedly saved.");
+
+ delete json.version;
+ return new message.ReplaceObject(state.bucket, state.key, json);
+ } else if (state.version) {
+ return new message.ReplaceObject(state.bucket, state.key, json).ifMatch(state.version);
+ } else {
+ return new message.CreateObject(state.bucket, json);
+ }
+ };
+
+ return withoutLock ? this._locklessSave(entity, options, msgFactory) : this._save(entity, options, msgFactory);
+ };
+
+ /**
+ * @param {binding.Entity} entity
+ * @param {Function} cb pre-safe callback
+ * @return {Promise}
+ */
+
+
+ EntityManager.prototype.optimisticSave = function optimisticSave(entity, cb) {
+ var _this7 = this;
+
+ return Metadata.get(entity).withLock(function () {
+ return _this7._optimisticSave(entity, cb);
+ });
+ };
+
+ /**
+ * @param {binding.Entity} entity
+ * @param {Function} cb pre-safe callback
+ * @return {Promise}
+ * @private
+ */
+
+
+ EntityManager.prototype._optimisticSave = function _optimisticSave(entity, cb) {
+ var _this8 = this;
+
+ var abort = false;
+ var abortFn = function abortFn() {
+ abort = true;
+ };
+ var promise = Promise.resolve(cb(entity, abortFn));
+
+ if (abort) return Promise.resolve(entity);
+
+ return promise.then(function () {
+ return _this8.save(entity, {}, true).catch(function (e) {
+ if (e.status == 412) {
+ return _this8.refresh(entity, {}).then(function () {
+ return _this8._optimisticSave(entity, cb);
+ });
+ } else {
+ throw e;
+ }
+ });
+ });
+ };
+
+ /**
+ * Save the object state without locking
+ * @param {binding.Entity} entity
+ * @param {Object} options
+ * @param {Function} msgFactory
+ * @return {Promise.}
+ * @private
+ */
+
+
+ EntityManager.prototype._locklessSave = function _locklessSave(entity, options, msgFactory) {
+ var _this9 = this;
+
+ this.attach(entity);
+ var state = Metadata.get(entity);
+ var refPromises;
+
+ var json;
+ if (state.isAvailable) {
+ //getting json will check all collections changes, therefore we must do it before proofing the dirty state
+ json = state.getJson();
+ }
+
+ if (state.isDirty) {
+ if (!options.refresh) {
+ state.setPersistent();
+ }
+
+ var sendPromise = this.send(msgFactory(state, json)).then(function (response) {
+ if (options.refresh) {
+ state.setJson(response.entity);
+ state.setPersistent();
+ } else {
+ state.setJsonMetadata(response.entity);
+ }
+ return entity;
+ }, function (e) {
+ if (e.status == StatusCode.OBJECT_NOT_FOUND) {
+ _this9.removeReference(entity);
+ state.setRemoved();
+ return null;
+ } else {
+ state.setDirty();
+ throw e;
+ }
+ });
+
+ refPromises = [sendPromise];
+ } else {
+ refPromises = [Promise.resolve(entity)];
+ }
+
+ var subOptions = Object.assign({}, options);
+ subOptions.depth = 0;
+ this.getSubEntities(entity, options.depth).forEach(function (sub) {
+ refPromises.push(_this9._save(sub, subOptions, msgFactory));
+ });
+
+ return Promise.all(refPromises).then(function () {
+ return entity;
+ });
+ };
+
+ /**
+ * Save and lock the object state
+ * @param {binding.Entity} entity
+ * @param {Object} options
+ * @param {Function} msgFactory
+ * @return {Promise.}
+ * @private
+ */
+
+
+ EntityManager.prototype._save = function _save(entity, options, msgFactory) {
+ var _this10 = this;
+
+ this.ensureBloomFilterFreshness();
+
+ var state = Metadata.get(entity);
+ if (state.version) {
+ this.addToBlackList(entity.id);
+ }
+
+ return state.withLock(function () {
+ return _this10._locklessSave(entity, options, msgFactory);
+ });
+ };
+
+ /**
+ * Returns all referenced sub entities for the given depth and root entity
+ * @param {binding.Entity} entity
+ * @param {boolean|number} depth
+ * @param {binding.Entity[]} [resolved]
+ * @param {binding.Entity=} initialEntity
+ * @returns {binding.Entity[]}
+ */
+
+
+ EntityManager.prototype.getSubEntities = function getSubEntities(entity, depth, resolved, initialEntity) {
+ var _this11 = this;
+
+ resolved = resolved || [];
+ if (!depth) {
+ return resolved;
+ }
+ initialEntity = initialEntity || entity;
+
+ var state = Metadata.get(entity);
+ for (var _iterator = state.type.references(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var value = _ref;
+
+ this.getSubEntitiesByPath(entity, value.path).forEach(function (subEntity) {
+ if (!~resolved.indexOf(subEntity) && subEntity != initialEntity) {
+ resolved.push(subEntity);
+ resolved = _this11.getSubEntities(subEntity, depth === true ? depth : depth - 1, resolved, initialEntity);
+ }
+ });
+ }
+
+ return resolved;
+ };
+
+ /**
+ * Returns all referenced one level sub entities for the given path
+ * @param {binding.Entity} entity
+ * @param {Array} path
+ * @returns {binding.Entity[]}
+ */
+
+
+ EntityManager.prototype.getSubEntitiesByPath = function getSubEntitiesByPath(entity, path) {
+ var _this12 = this;
+
+ var subEntities = [entity];
+
+ path.forEach(function (attributeName) {
+
+ var tmpSubEntities = [];
+ subEntities.forEach(function (subEntity) {
+ var curEntity = subEntity[attributeName];
+ if (!curEntity) return;
+
+ var attribute = _this12.metamodel.managedType(subEntity.constructor).getAttribute(attributeName);
+ if (attribute.isCollection) {
+ for (var _iterator2 = curEntity.entries(), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+ var _ref2;
+
+ if (_isArray2) {
+ if (_i2 >= _iterator2.length) break;
+ _ref2 = _iterator2[_i2++];
+ } else {
+ _i2 = _iterator2.next();
+ if (_i2.done) break;
+ _ref2 = _i2.value;
+ }
+
+ var entry = _ref2;
+
+ tmpSubEntities.push(entry[1]);
+ attribute.keyType && attribute.keyType.isEntity && tmpSubEntities.push(entry[0]);
+ }
+ } else {
+ tmpSubEntities.push(curEntity);
+ }
+ });
+ subEntities = tmpSubEntities;
+ });
+
+ return subEntities;
+ };
+
+ /**
+ * Delete the entity instance.
+ * @param {binding.Entity} entity
+ * @param {Object} options The delete options
+ * @return {Promise}
+ */
+
+
+ EntityManager.prototype['delete'] = function _delete(entity, options) {
+ var _this13 = this;
+
+ options = options || {};
+
+ this.attach(entity);
+ var state = Metadata.get(entity);
+
+ return state.withLock(function () {
+ if (!state.version && !options.force) throw new error.IllegalEntityError(entity);
+
+ var msg = new message.DeleteObject(state.bucket, state.key);
+
+ _this13.addToBlackList(entity.id);
+
+ if (!options.force) msg.ifMatch(state.version);
+
+ var refPromises = [_this13.send(msg).then(function () {
+ _this13.removeReference(entity);
+ state.setRemoved();
+ return entity;
+ })];
+
+ var subOptions = Object.assign({}, options);
+ subOptions.depth = 0;
+ _this13.getSubEntities(entity, options.depth).forEach(function (sub) {
+ refPromises.push(_this13.delete(sub, subOptions));
+ });
+
+ return Promise.all(refPromises).then(function () {
+ return entity;
+ });
+ });
+ };
+
+ /**
+ * Synchronize the persistence context to the underlying database.
+ *
+ * @returns {Promise<*>}
+ */
+
+
+ EntityManager.prototype.flush = function flush(doneCallback, failCallback) {}
+ // TODO: implement this
+
+
+ /**
+ * Make an instance managed and persistent.
+ * @param {binding.Entity} entity - entity instance
+ */
+ ;
+
+ EntityManager.prototype.persist = function persist(entity) {
+ this.attach(entity);
+ };
+
+ /**
+ * Refresh the state of the instance from the database, overwriting changes made to the entity, if any.
+ * @param {binding.Entity} entity - entity instance
+ * @param {Object} options The refresh options
+ * @return {Promise}
+ */
+
+
+ EntityManager.prototype.refresh = function refresh(entity, options) {
+ options = options || {};
+ options.refresh = true;
+
+ return this.load(entity.id, null, options);
+ };
+
+ /**
+ * Attach the instance to this database context, if it is not already attached
+ * @param {binding.Entity} entity The entity to attach
+ */
+
+
+ EntityManager.prototype.attach = function attach(entity) {
+ if (!this.contains(entity)) {
+ var type = this.metamodel.entity(entity.constructor);
+ if (!type) throw new error.IllegalEntityError(entity);
+
+ if (this.containsById(entity)) throw new error.EntityExistsError(entity);
+
+ this._attach(entity);
+ }
+ };
+
+ EntityManager.prototype._attach = function _attach(entity) {
+ var metadata = Metadata.get(entity);
+ if (metadata.isAttached) {
+ if (metadata.db != this) {
+ throw new error.EntityExistsError(entity);
+ }
+ } else {
+ metadata.db = this;
+ }
+
+ if (!metadata.id) {
+ if (metadata.type.name != 'User' && metadata.type.name != 'Role' && metadata.type.name != 'logs.AppLog') {
+ metadata.id = '/db/' + metadata.type.name + '/' + util.uuid();
+ }
+ }
+
+ if (metadata.id) {
+ this._entities[metadata.id] = entity;
+ }
+ };
+
+ EntityManager.prototype.removeReference = function removeReference(entity) {
+ var state = Metadata.get(entity);
+ if (!state) throw new error.IllegalEntityError(entity);
+
+ delete this._entities[state.id];
+ };
+
+ EntityManager.prototype.register = function register(user, password, loginOption) {
+ var _this14 = this;
+
+ var login = loginOption > UserFactory.LoginOption.NO_LOGIN;
+ if (this.me && login) {
+ throw new error.PersistentError('User is already logged in.');
+ }
+
+ return this.withLock(function () {
+ var msg = new message.Register({
+ user: user,
+ password: password,
+ login: login
+ });
+ return _this14._userRequest(msg, loginOption);
+ });
+ };
+
+ EntityManager.prototype.login = function login(username, password, loginOption) {
+ var _this15 = this;
+
+ if (this.me) throw new error.PersistentError('User is already logged in.');
+
+ return this.withLock(function () {
+ var msg = new message.Login({
+ username: username,
+ password: password
+ });
+
+ return _this15._userRequest(msg, loginOption);
+ });
+ };
+
+ EntityManager.prototype.logout = function logout() {
+ var _this16 = this;
+
+ return this.withLock(function () {
+ return _this16.send(new message.Logout()).then(_this16._logout.bind(_this16));
+ });
+ };
+
+ EntityManager.prototype.loginWithOAuth = function loginWithOAuth(provider, clientID, options) {
+ if (this.me) throw new error.PersistentError('User is already logged in.');
+
+ options = Object.assign({
+ title: "Login with " + provider,
+ timeout: 5 * 60 * 1000,
+ state: {},
+ loginOption: true
+ }, options);
+
+ var msg;
+ if (Message[provider + 'OAuth']) {
+ msg = new Message[provider + 'OAuth'](clientID, options.scope, JSON.stringify(options.state));
+ } else {
+ throw new Error('OAuth provider ' + provider + ' not supported.');
+ }
+
+ var req = this._userRequest(msg, options.loginOption);
+ var w = open(msg.request.path, options.title, 'width=' + options.width + ',height=' + options.height);
+
+ return new Promise(function (resolve, reject) {
+ var timeout = setTimeout(function () {
+ reject(new error.PersistentError('OAuth login timeout.'));
+ }, options.timeout);
+
+ req.then(resolve, reject).then(function () {
+ clearTimeout(timeout);
+ });
+ });
+ };
+
+ EntityManager.prototype.renew = function renew() {
+ var _this17 = this;
+
+ return this.withLock(function () {
+ var msg = new message.Me();
+ return _this17._userRequest(msg, true);
+ });
+ };
+
+ EntityManager.prototype.newPassword = function newPassword(username, password, _newPassword) {
+ var _this18 = this;
+
+ return this.withLock(function () {
+ var msg = new message.NewPassword({
+ username: username,
+ password: password,
+ newPassword: _newPassword
+ });
+
+ return _this18.send(msg).then(function (response) {
+ return _this18._updateUser(response.entity);
+ });
+ });
+ };
+
+ EntityManager.prototype._updateUser = function _updateUser(obj, updateMe) {
+ var user = this.getReference(obj.id);
+ var metadata = Metadata.get(user);
+ metadata.setJson(obj);
+ metadata.setPersistent();
+
+ if (updateMe) this.me = user;
+
+ return user;
+ };
+
+ EntityManager.prototype._logout = function _logout() {
+ this.me = null;
+ this.token = null;
+ };
+
+ EntityManager.prototype._userRequest = function _userRequest(msg, loginOption) {
+ var _this19 = this;
+
+ var login = loginOption > UserFactory.LoginOption.NO_LOGIN;
+ if (login) {
+ this.tokenStorage.temporary = loginOption < UserFactory.LoginOption.PERSIST_LOGIN;
+ }
+
+ return this.send(msg).then(function (response) {
+ if (response.entity) {
+ return _this19._updateUser(response.entity, login);
+ }
+ }, function (e) {
+ if (e.status == StatusCode.OBJECT_NOT_FOUND) {
+ if (login) _this19._logout();
+ return null;
+ } else {
+ throw e;
+ }
+ });
+ };
+
+ EntityManager.prototype.registerDevice = function registerDevice(os, token, device) {
+ var msg = new message.DeviceRegister({
+ token: token,
+ devicetype: os,
+ device: device
+ });
+
+ msg.withCredentials = true;
+ return this.send(msg);
+ };
+
+ EntityManager.prototype.checkDeviceRegistration = function checkDeviceRegistration() {
+ var _this20 = this;
+
+ return this.send(new message.DeviceRegistered()).then(function () {
+ return _this20.isDeviceRegistered = true;
+ }, function (e) {
+ if (e.status == StatusCode.OBJECT_NOT_FOUND) {
+ return _this20.isDeviceRegistered = false;
+ } else {
+ throw e;
+ }
+ });
+ };
+
+ EntityManager.prototype.pushDevice = function pushDevice(pushMessage) {
+ return this.send(new message.DevicePush(pushMessage));
+ };
+
+ /**
+ * The given entity will be checked by the validation code of the entity type.
+ *
+ * @param {binding.Entity} entity
+ * @returns {util.ValidationResult} result
+ */
+
+
+ EntityManager.prototype.validate = function validate(entity) {
+ var type = Metadata.get(entity).type;
+
+ var result = new util.ValidationResult();
+ for (var iter = type.attributes(), item; !(item = iter.next()).done;) {
+ var validate = new util.Validator(item.value.name, entity);
+ result.fields[validate.key] = validate;
+ }
+
+ var validationCode = type.validationCode;
+ if (validationCode) {
+ validationCode(result.fields);
+ }
+
+ return result;
+ };
+
+ /**
+ * Adds the given object id to the cacheWhiteList if needed.
+ * @param {string} objectId The id to add.
+ */
+
+
+ EntityManager.prototype.addToWhiteList = function addToWhiteList(objectId) {
+ if (!this.isCachingDisabled) {
+ if (this.bloomFilter.contains(objectId)) {
+ this.cacheWhiteList.add(objectId);
+ }
+ this.cacheBlackList.delete(objectId);
+ }
+ };
+
+ /**
+ * Adds the given object id to the cacheBlackList if needed.
+ * @param {string} objectId The id to add.
+ */
+
+
+ EntityManager.prototype.addToBlackList = function addToBlackList(objectId) {
+ if (!this.isCachingDisabled) {
+ if (!this.bloomFilter.contains(objectId)) {
+ this.cacheBlackList.add(objectId);
+ }
+ this.cacheWhiteList.delete(objectId);
+ }
+ };
+
+ EntityManager.prototype.refreshBloomFilter = function refreshBloomFilter() {
+ var _this21 = this;
+
+ if (this.isCachingDisabled) return Promise.resolve();
+
+ var msg = new message.GetBloomFilter();
+ return this.send(msg).then(function (response) {
+ _this21.updateBloomFilter(response.entity);
+ return _this21.bloomFilter;
+ });
+ };
+
+ EntityManager.prototype.updateBloomFilter = function updateBloomFilter(bloomFilter) {
+ this.bloomFilter = new BloomFilter(bloomFilter);
+ this.cacheWhiteList = new Set();
+ this.cacheBlackList = new Set();
+ };
+
+ /**
+ * Checks the freshness of the bloom filter and does a reload if necessary
+ */
+
+
+ EntityManager.prototype.ensureBloomFilterFreshness = function ensureBloomFilterFreshness() {
+ var _this22 = this;
+
+ if (this.isCachingDisabled) return;
+
+ var now = new Date().getTime();
+ var refreshRate = this.bloomFilterRefresh * 1000;
+
+ if (this._bloomFilterLock.isReady && now - this.bloomFilter.creation > refreshRate) {
+ this._bloomFilterLock.withLock(function () {
+ return _this22.refreshBloomFilter();
+ });
+ }
+ };
+
+ /**
+ * Checks for a given id, if revalidation is required, the resource is stale or caching was disabled
+ * @param {string} id The object id to check
+ * @returns {boolean} Indicates if the resource must be revalidated
+ */
+
+
+ EntityManager.prototype.mustRevalidate = function mustRevalidate(id) {
+ if (util.isNode) return false;
+
+ this.ensureBloomFilterFreshness();
+
+ var refresh = this.isCachingDisabled || !this._bloomFilterLock.isReady;
+ refresh = refresh || !this.cacheWhiteList.has(id) && (this.cacheBlackList.has(id) || this.bloomFilter.contains(id));
+ return refresh;
+ };
+
+ /**
+ *
+ * @param {string} id To check the bloom filter
+ * @param {connector.Message} message To attach the headers
+ * @param {boolean} refresh To force the reload headers
+ */
+
+
+ EntityManager.prototype.ensureCacheHeader = function ensureCacheHeader(id, message, refresh) {
+ refresh = refresh || this.mustRevalidate(id);
+
+ if (refresh) {
+ message.noCache();
+ }
+ };
+
+ /**
+ * Creates a absolute url for the given relative one
+ * @param {string} relativePath the relative url
+ * @param {boolean=} authorize indicates if authorization credentials should be generated and be attached to the url
+ * @return {string} a absolute url wich is optionaly signed with a resource token which authenticates the currently
+ * logged in user
+ */
+
+
+ EntityManager.prototype.createURL = function createURL(relativePath, authorize) {
+ var path = this._connector.basePath + relativePath;
+
+ var append = false;
+ if (authorize && this.me) {
+ path = this.tokenStorage.signPath(path);
+ append = true;
+ } else {
+ path = path.split('/').map(encodeURIComponent).join('/');
+ }
+
+ if (this.mustRevalidate(relativePath)) {
+ path = path + (append ? '&' : '?') + 'BCB';
+ }
+
+ return this._connector.origin + path;
+ };
+
+ return EntityManager;
+}(util.Lockable);
+
+/**
+ * Constructor for a new List collection
+ * @function
+ * @param {...*} args Same arguments can be passed as the Array constructor takes
+ * @return {void} The new created List
+ */
+
+
+EntityManager.prototype.List = Array;
+
+/**
+ * Constructor for a new Set collection
+ * @function
+ * @param {Iterable<*>=} collection The initial array or collection to initialize the new Set
+ * @return {void} The new created Set
+ */
+EntityManager.prototype.Set = Set;
+
+/**
+ * Constructor for a new Map collection
+ * @function
+ * @param {Iterable<*>=} collection The initial array or collection to initialize the new Map
+ * @return {void} The new created Map
+ */
+EntityManager.prototype.Map = Map;
+
+/**
+ * Constructor for a new GeoPoint
+ * @function
+ * @param {string|number|Object|Array} [latitude] A coordinate pair (latitude first), a GeoPoint like object or the GeoPoint's latitude
+ * @param {number=} longitude The GeoPoint's longitude
+ * @return {void} The new created GeoPoint
+ */
+EntityManager.prototype.GeoPoint = _dereq_(5);
+
+/**
+ * An User factory for user objects.
+ * The User factory can be called to create new instances of users or can be used to register/login/logout users.
+ * The created instances implements the {@link model.User} interface
+ * @name User
+ * @type binding.UserFactory
+ * @memberOf EntityManager.prototype
+ */
+
+/**
+ * An Role factory for role objects.
+ * The Role factory can be called to create new instances of roles, later on users can be attached to roles to manage the
+ * access permissions through this role
+ * The created instances implements the {@link model.Role} interface
+ * @name Role
+ * @memberOf EntityManager.prototype
+ * @type binding.EntityFactory
+ */
+
+/**
+ * An Device factory for user objects.
+ * The Device factory can be called to create new instances of devices or can be used to register, push to and
+ * check registration status of devices.
+ * @name Device
+ * @memberOf EntityManager.prototype
+ * @type binding.DeviceFactory
+ */
+
+/**
+ * An Object factory for entity or embedded objects,
+ * that can be accessed by the type name of the entity type.
+ * An object factory can be called to create new instances of the type.
+ * The created instances implements the {@link binding.Entity} or the {@link binding.Managed} interface
+ * whenever the class is an entity or embedded object
+ * @name [YourEntityClass: string]
+ * @memberOf EntityManager.prototype
+ * @type {*}
+ */
+
+/**
+ * A File factory for file objects.
+ * The file factory can be called to create new instances for files.
+ * The created instances implements the {@link binding.File} interface
+ * @name File
+ * @memberOf EntityManager.prototype
+ * @type binding.FileFactory
+ */
+
+module.exports = EntityManager;
+
+},{"19":19,"20":20,"21":21,"25":25,"34":34,"36":36,"4":4,"5":5,"59":59,"63":63,"70":70}],3:[function(_dereq_,module,exports){
+"use strict";
+
+var message = _dereq_(36);
+var metamodel = _dereq_(52);
+
+var util = _dereq_(70);
+var caching = _dereq_(22);
+var Connector = _dereq_(23);
+var EntityManager = _dereq_(2);
+
+/**
+ * @alias EntityManagerFactory
+ * @extends util.Lockable
+ */
+
+var EntityManagerFactory = function (_util$Lockable) {
+ babelHelpers.inherits(EntityManagerFactory, _util$Lockable);
+
+ EntityManagerFactory.prototype._connected = function _connected() {};
+
+ /**
+ * Creates a new EntityManagerFactory connected to the given destination
+ * @param {string|Object} [options] The destination to connect with, or an options object
+ * @param {string} [options.host] The destination to connect with
+ * @param {number} [options.port=80|443] The optional destination port to connect with
+ * @param {boolean} [options.secure=false] true To use a secure ssl encrypted connection
+ * @param {string} [options.basePath="/v1"] The base path of the api
+ * @param {Object} [options.schema=null] The serialized schema as json used to initialize the metamodel
+ * @param {util.TokenStorage} [options.tokenStorage] The tokenStorage which should be used by this emf
+ * @param {util.TokenStorageFactory} [options.tokenStorageFactory] The tokenStorage factory implementation which should
+ * be used for token storage
+ * @param {number} [options.staleness=60] The maximum staleness of objects that are acceptable while reading cached data
+ */
+
+
+ function EntityManagerFactory(options) {
+ babelHelpers.classCallCheck(this, EntityManagerFactory);
+
+ var _this = babelHelpers.possibleConstructorReturn(this, _util$Lockable.call(this));
+
+ options = Object(options) instanceof String ? { host: options } : options || {};
+
+ /** @type connector.Connector */
+ _this._connector = null;
+ /** @type metamodel.Metamodel */
+ _this.metamodel = _this.createMetamodel();
+ /** @type util.Code */
+ _this.code = new util.Code(_this.metamodel, _this);
+ /** @type util.TokenStorageFactory */
+ _this.tokenStorageFactory = util.TokenStorage.WEB_STORAGE || util.TokenStorage.GLOBAL;
+
+ _this.configure(options);
+
+ var isReady = true;
+ var ready = new Promise(function (success) {
+ _this._connected = success;
+ });
+
+ if (options.host) {
+ _this.connect(options.host, options.port, options.secure, options.basePath);
+ } else {
+ isReady = false;
+ }
+
+ if (!_this.tokenStorage) {
+ isReady = false;
+ ready = ready.then(function () {
+ return _this.tokenStorageFactory.create(_this._connector.origin);
+ }).then(function (tokenStorage) {
+ _this.tokenStorage = tokenStorage;
+ });
+ }
+
+ if (options.schema) {
+ _this._connectData = options;
+ _this.metamodel.init(options.schema);
+ } else {
+ isReady = false;
+ ready = ready.then(function () {
+ var msg = new message.Connect();
+ msg.withCredentials = true; //used for registered devices
+
+ if (_this.staleness === 0) msg.noCache();
+
+ return _this.send(msg);
+ }).then(function (response) {
+ _this._connectData = response.entity;
+
+ if (_this.staleness === undefined) {
+ _this.staleness = _this._connectData.bloomFilterRefresh || 60;
+ }
+
+ if (!_this.metamodel.isInitialized) _this.metamodel.init(_this._connectData.schema);
+
+ _this.tokenStorage.update(_this._connectData.token);
+ });
+ }
+
+ if (!isReady) {
+ _this.withLock(function () {
+ return ready;
+ }, true);
+ }
+ return _this;
+ }
+
+ /**
+ * Apply additional configurations to this EntityManagerFactory
+ * @param {Object} options The additional configuration options
+ * @param {util.TokenStorage} [options.tokenStorage] The tokenStorage which should be used by this emf
+ * @param {util.TokenStorageFactory} [options.tokenStorageFactory] The tokenStorage factory implementation which should
+ * be used for token storage
+ * @param {number} [options.staleness=60] The maximum staleness of objects that are acceptable while reading cached data,
+ * 0 to always bypass the browser cache
+ */
+
+
+ EntityManagerFactory.prototype.configure = function configure(options) {
+ if (this._connector) throw new Error('The EntityManagerFactory can only be configured before is is connected.');
+
+ if (options.tokenStorage) {
+ /** @type util.TokenStorage */
+ this.tokenStorage = options.tokenStorage;
+ }
+
+ if (options.tokenStorageFactory) {
+ this.tokenStorageFactory = options.tokenStorageFactory;
+ }
+
+ if (options.staleness !== undefined) {
+ /** @type number */
+ this.staleness = options.staleness;
+ }
+ };
+
+ /**
+ * Connects this EntityManager to the given destination
+ * @param {string} hostOrApp The host or the app name to connect with
+ * @param {number} [port=80|443] The port to connect to
+ * @param {boolean} [secure=false] true To use a secure connection
+ * @param {string} [basePath="/v1"] The base path of the api
+ */
+
+
+ EntityManagerFactory.prototype.connect = function connect(hostOrApp, port, secure, basePath) {
+ if (this._connector) throw new Error('The EntityManagerFactory is already connected.');
+
+ if (Object(port) instanceof Boolean) {
+ secure = port;
+ port = 0;
+ }
+
+ this._connector = Connector.create(hostOrApp, port, secure, basePath);
+
+ this._connected();
+ return this.ready();
+ };
+
+ /**
+ * Connects this EntityManager to the given destination
+ * @param {string} hostOrApp The host or the app name to connect with
+ * @param {boolean} [secure=false] true To use a secure connection
+ * @name connect
+ * @memberOf EntityManagerFactory.prototype
+ * @method
+ */
+
+ /**
+ * Creates a new Metamodel instance, which is not connected
+ * @return {metamodel.Metamodel} A new Metamodel instance
+ */
+
+
+ EntityManagerFactory.prototype.createMetamodel = function createMetamodel() {
+ return new metamodel.Metamodel(this);
+ };
+
+ /**
+ * Create a new application-managed EntityManager.
+ *
+ * @param {boolean=} useSharedTokenStorage The token storage to persist the authorization token, or
+ * true To use the shared token storage of the emf.
+ * false To use a instance based storage.
+ *
+ * @returns {EntityManager} a new entityManager
+ */
+
+
+ EntityManagerFactory.prototype.createEntityManager = function createEntityManager(useSharedTokenStorage) {
+ var _this2 = this;
+
+ var em = new EntityManager(this);
+
+ if (this.isReady) {
+ em.connected(this._connector, this._connectData, useSharedTokenStorage ? this.tokenStorage : new util.TokenStorage(this._connector.origin));
+ } else {
+ em.withLock(function () {
+ return _this2.ready().then(function () {
+ em.connected(_this2._connector, _this2._connectData, useSharedTokenStorage ? _this2.tokenStorage : new util.TokenStorage(_this2._connector.origin));
+ });
+ }, true);
+ }
+
+ return em;
+ };
+
+ EntityManagerFactory.prototype.send = function send(message) {
+ if (!message.tokenStorage) message.tokenStorage = this.tokenStorage;
+ return this._connector.send(message);
+ };
+
+ return EntityManagerFactory;
+}(util.Lockable);
+
+module.exports = EntityManagerFactory;
+
+},{"2":2,"22":22,"23":23,"36":36,"52":52,"70":70}],4:[function(_dereq_,module,exports){
+"use strict";
+
+var message = _dereq_(36);
+var error = _dereq_(34);
+
+/**
+ * @alias EntityTransaction
+ */
+
+var EntityTransaction = function () {
+ babelHelpers.createClass(EntityTransaction, [{
+ key: 'isActive',
+
+
+ /**
+ * Indicate whether a resource transaction is in progress.
+ * @returns {boolean} indicating whether transaction is in progress
+ */
+ get: function get() {
+ return Boolean(this.tid);
+ }
+
+ /**
+ * @param {EntityManager} entityManager
+ */
+
+ }]);
+
+ function EntityTransaction(entityManager) {
+ babelHelpers.classCallCheck(this, EntityTransaction);
+
+ this._connector = entityManager.connector;
+ this.entityManager = entityManager;
+
+ this.tid = null;
+ this.rollbackOnly = false;
+
+ this.readSet = null;
+ this.changeSet = null;
+ }
+
+ /**
+ * Start a resource transaction.
+ */
+
+
+ EntityTransaction.prototype.begin = function begin(doneCallback, failCallback) {
+ return this.yield().then(function () {
+ var result = this.send(new message.PostTransaction()).done(function (msg) {
+ this.tid = msg.tid;
+
+ this.rollbackOnly = false;
+ this.readSet = {};
+ this.changeSet = {};
+ });
+
+ return this.wait(result);
+ }).then(doneCallback, failCallback);
+ };
+
+ /**
+ * Commit the current resource transaction, writing any unflushed changes to the database.
+ */
+
+
+ EntityTransaction.prototype.commit = function commit(doneCallback, failCallback) {
+ return this.yield().then(function () {
+ if (this.getRollbackOnly()) {
+ return this.rollback().then(function () {
+ throw new error.RollbackError();
+ });
+ } else {
+ return this.wait(this.entityManager.flush()).then(function () {
+ var readSet = [];
+ for (var ref in this.readSet) {
+ readSet.push({
+ "oid": ref,
+ "version": this.readSet[ref]
+ });
+ }
+
+ var result = this.send(new message.PutTransactionCommitted(this.tid, readSet));
+
+ return this.wait(result).then(function (msg) {
+ this.tid = null;
+ this.readSet = null;
+ this.changeSet = null;
+
+ var oids = msg.oids;
+ for (var oid in oids) {
+ var version = oids[oid];
+ var entity = this.entityManager.entities[oid];
+
+ if (entity) {
+ var state = util.Metadata.get(entity);
+ if (version == 'DELETED' || state.isDeleted) {
+ this.entityManager.removeReference(entity);
+ } else {
+ state.setJsonValue(state.type.version, version);
+ }
+ }
+ }
+ });
+ });
+ }
+ }).then(doneCallback, failCallback);
+ };
+
+ /**
+ * Determine whether the current resource transaction has been marked for rollback.
+ * @returns {boolean} indicating whether the transaction has been marked for rollback
+ */
+
+
+ EntityTransaction.prototype.getRollbackOnly = function getRollbackOnly() {
+ return this.rollbackOnly;
+ };
+
+ /**
+ * Roll back the current resource transaction.
+ */
+
+
+ EntityTransaction.prototype.rollback = function rollback(doneCallback, failCallback) {
+ return this.yield().then(function () {
+ var result = this.send(new message.PutTransactionAborted(this.tid));
+
+ this.wait(result).then(function () {
+ this.tid = null;
+ this.readSet = null;
+ this.changeSet = null;
+ return this.entityManager.clear();
+ }, function () {
+ return this.entityManager.clear();
+ });
+ }).then(doneCallback, failCallback);
+ };
+
+ /**
+ * Mark the current resource transaction so that the only possible outcome of the transaction is for the transaction to be rolled back.
+ */
+
+
+ EntityTransaction.prototype.setRollbackOnly = function setRollbackOnly(context, onSuccess) {
+ return this.yield().done(function () {
+ this.rollbackOnly = true;
+ });
+ };
+
+ EntityTransaction.prototype.isRead = function isRead(identifier) {
+ return this.isActive && identifier in this.readSet;
+ };
+
+ EntityTransaction.prototype.setRead = function setRead(identifier, version) {
+ if (this.isActive && !this.isChanged(identifier)) {
+ this.readSet[identifier] = version;
+ }
+ };
+
+ EntityTransaction.prototype.isChanged = function isChanged(identifier) {
+ return this.isActive && identifier in this.changeSet;
+ };
+
+ EntityTransaction.prototype.setChanged = function setChanged(identifier) {
+ if (this.isActive) {
+ delete this.readSet[identifier];
+ this.changeSet[identifier] = true;
+ }
+ };
+
+ return EntityTransaction;
+}();
+
+module.exports = EntityTransaction;
+
+},{"34":34,"36":36}],5:[function(_dereq_,module,exports){
+"use strict";
+
+/**
+ * Creates a new GeoPoint instance
+ * From latitude and longitude
+ * From a json object
+ * Or an tuple of latitude and longitude
+ *
+ * @alias GeoPoint
+ */
+
+var GeoPoint = function () {
+
+ /**
+ * Creates a GeoPoint with the user's current location, if available.
+ * @return {Promise} A promise that will be resolved with a GeoPoint
+ */
+ GeoPoint.current = function current() {
+ return new Promise(function (resolve, reject) {
+ navigator.geolocation.getCurrentPosition(function (location) {
+ resolve(new GeoPoint(location.coords.latitude, location.coords.longitude));
+ }, function (error) {
+ reject(error);
+ });
+ });
+ };
+
+ /**
+ * @param {string|number|Object|Array} [latitude] A coordinate pair (latitude first), a GeoPoint like object or the GeoPoint's latitude
+ * @param {number=} longitude The GeoPoint's longitude
+ */
+
+
+ function GeoPoint(latitude, longitude) {
+ babelHelpers.classCallCheck(this, GeoPoint);
+
+ var lat = void 0,
+ lng = void 0;
+ if (Object(latitude) instanceof String) {
+ var index = latitude.indexOf(';');
+ lat = latitude.substring(0, index);
+ lng = latitude.substring(index + 1);
+ } else if (Object(latitude) instanceof Number) {
+ lat = latitude;
+ lng = longitude;
+ } else if (Object(latitude) instanceof Array) {
+ lat = latitude[0];
+ lng = latitude[1];
+ } else if (latitude instanceof Object) {
+ lat = latitude.latitude;
+ lng = latitude.longitude;
+ } else {
+ lat = 0;
+ lng = 0;
+ }
+
+ /**
+ * Longitude of the given point
+ * @type {number}
+ */
+ this.longitude = lng;
+
+ /**
+ * Latitude of the given point
+ * @type {number}
+ */
+ this.latitude = lat;
+
+ if (this.latitude < -90 || this.latitude > 90) {
+ throw new Error("Latitude " + this.latitude + " is not in bound of -90 <= latitude <= 90");
+ }
+
+ if (this.longitude < -180 || this.longitude > 180) {
+ throw new Error("Longitude " + this.longitude + " is not in bound of -180 <= longitude <= 180");
+ }
+ }
+
+ /**
+ * Returns the distance from this GeoPoint to another in kilometers.
+ * @param {GeoPoint} point another GeoPoint
+ * @return {number} The distance in kilometers
+ *
+ * @see GeoPoint#radiansTo
+ */
+
+
+ GeoPoint.prototype.kilometersTo = function kilometersTo(point) {
+ return Number((GeoPoint.EARTH_RADIUS_IN_KILOMETERS * this.radiansTo(point)).toFixed(3));
+ };
+
+ /**
+ * Returns the distance from this GeoPoint to another in miles.
+ * @param {GeoPoint} point another GeoPoint
+ * @return {number} The distance in miles
+ *
+ * @see GeoPoint#radiansTo
+ */
+
+
+ GeoPoint.prototype.milesTo = function milesTo(point) {
+ return Number((GeoPoint.EARTH_RADIUS_IN_MILES * this.radiansTo(point)).toFixed(3));
+ };
+
+ /**
+ * Computes the arc, in radian, between two WGS-84 positions.
+ *
+ * The haversine formula implementation is taken from:
+ * {@link http://www.movable-type.co.uk/scripts/latlong.html}
+ *
+ * Returns the distance from this GeoPoint to another in radians.
+ * @param {GeoPoint} point another GeoPoint
+ * @return {number} the arc, in radian, between two WGS-84 positions
+ *
+ * @see http://en.wikipedia.org/wiki/Haversine_formula
+ */
+
+
+ GeoPoint.prototype.radiansTo = function radiansTo(point) {
+ var from = this,
+ to = point;
+ var rad1 = from.latitude * GeoPoint.DEG_TO_RAD,
+ rad2 = to.latitude * GeoPoint.DEG_TO_RAD,
+ dLng = (to.longitude - from.longitude) * GeoPoint.DEG_TO_RAD;
+
+ return Math.acos(Math.sin(rad1) * Math.sin(rad2) + Math.cos(rad1) * Math.cos(rad2) * Math.cos(dLng));
+ };
+
+ /**
+ * A String representation in latitude, longitude format
+ * @return {string} The string representation of this class
+ */
+
+
+ GeoPoint.prototype.toString = function toString() {
+ return this.latitude + ';' + this.longitude;
+ };
+
+ /**
+ * Returns a JSON representation of the GeoPoint
+ * @return {json} A GeoJson object of this GeoPoint
+ */
+
+
+ GeoPoint.prototype.toJSON = function toJSON() {
+ return { latitude: this.latitude, longitude: this.longitude };
+ };
+
+ return GeoPoint;
+}();
+
+GeoPoint.DEG_TO_RAD = Math.PI / 180;
+
+/**
+ * The Earth radius in kilometers used by {@link GeoPoint#kilometersTo}
+ * @type {number}
+ */
+GeoPoint.EARTH_RADIUS_IN_KILOMETERS = 6371;
+
+/**
+ * The Earth radius in miles used by {@link GeoPoint#milesTo}
+ * @type {number}
+ */
+GeoPoint.EARTH_RADIUS_IN_MILES = 3956;
+
+module.exports = GeoPoint;
+
+},{}],6:[function(_dereq_,module,exports){
+'use strict';
+
+/**
+ * @interface baqend
+ * @extends EntityManager
+ */
+var EntityManagerFactory = _dereq_(3);
+var EntityManager = _dereq_(2);
+
+EntityManager.prototype.binding = _dereq_(20);
+EntityManager.prototype.connector = _dereq_(28);
+EntityManager.prototype.error = _dereq_(34);
+EntityManager.prototype.message = _dereq_(36);
+EntityManager.prototype.metamodel = _dereq_(52);
+EntityManager.prototype.util = _dereq_(70);
+EntityManager.prototype.caching = _dereq_(22);
+EntityManager.prototype.query = _dereq_(59);
+
+EntityManager.prototype.EntityManager = _dereq_(2);
+EntityManager.prototype.EntityManagerFactory = _dereq_(3);
+EntityManager.prototype.EntityTransaction = _dereq_(4);
+EntityManager.prototype.Acl = _dereq_(1);
+
+var emf = new EntityManagerFactory();
+var db = emf.createEntityManager(true);
+
+/**
+ * Configures the DB with additional config options
+ * @param {Object} options The additional configuration options
+ * @param {util.TokenStorage} [options.tokenStorage] The tokenStorage which should be used by this emf
+ * @param {util.TokenStorageFactory} [options.tokenStorageFactory] The tokenStorage factory implementation which should
+ * be used for token storage
+ * @param {number} [options.staleness=60] The maximum staleness of objects that are acceptable while reading cached data,
+ * 0 to always bypass the browser cache
+ * @function
+ * @return {baqend}
+ * @alias baqend#configure
+ */
+db.configure = function (options) {
+ emf.configure(options);
+ return this;
+};
+
+/**
+ * Connects the DB with the server and calls the callback on success
+ * @param {string} hostOrApp The host or the app name to connect with
+ * @param {boolean} [secure=false] true To use a secure connection
+ * @param {util.Lockable~callback=} doneCallback The callback, called when a connection is established and the
+ * SDK is ready to use
+ * @param {util.Lockable~callback=} failCallback When an error occurred while initializing the SDK
+ * @function
+ * @return {Promise}
+ * @alias baqend#connect
+ */
+db.connect = function (hostOrApp, secure, doneCallback, failCallback) {
+ if (secure instanceof Function) {
+ failCallback = doneCallback;
+ doneCallback = secure;
+ secure = undefined;
+ }
+
+ emf.connect(hostOrApp, secure);
+ return this.ready(doneCallback, failCallback);
+};
+
+exports = module.exports = db;
+//import {db} from 'baqend';
+exports.db = db;
+//import db from 'baqend';
+exports.default = db;
+
+},{"1":1,"2":2,"20":20,"22":22,"28":28,"3":3,"34":34,"36":36,"4":4,"52":52,"59":59,"70":70}],7:[function(_dereq_,module,exports){
+"use strict";
+
+/**
+ * @alias binding.Accessor
+ */
+
+var Accessor = function () {
+ function Accessor() {
+ babelHelpers.classCallCheck(this, Accessor);
+ }
+
+ /**
+ * @param {Object} object
+ * @param {metamodel.Attribute} attribute
+ * @returns {*}
+ */
+ Accessor.prototype.getValue = function getValue(object, attribute) {
+ return object[attribute.name];
+ };
+
+ /**
+ * @param {Object} object
+ * @param {metamodel.Attribute} attribute
+ * @param {*} value
+ */
+
+
+ Accessor.prototype.setValue = function setValue(object, attribute, value) {
+ object[attribute.name] = value;
+ };
+
+ return Accessor;
+}();
+
+module.exports = Accessor;
+
+},{}],8:[function(_dereq_,module,exports){
+"use strict";
+
+var EntityFactory = _dereq_(11);
+
+/**
+ * @class binding.DeviceFactory
+ * @extends binding.EntityFactory
+ *
+ * @param {Object=} properties initial properties to set on the instance
+ * @param {...*} arguments Additional constructor params passed through the type constructor
+ * @return {model.Device} The new managed instance
+ */
+var DeviceFactory = EntityFactory.extend( /** @lends binding.DeviceFactory.prototype */{
+
+ /**
+ * Returns true if the devices is already registered, otherwise false.
+ * @returns {boolean} Status of the device registration
+ */
+ get isRegistered() {
+ return this._db.isDeviceRegistered;
+ },
+
+ /**
+ * Register a new device with the given device token and OS.
+ * @param {string} os The OS of the device (IOS/Android)
+ * @param {string} token The GCM or APNS device token
+ * @param {model.Device=} device A optional device entity to set custom field values
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise}
+ */
+ register: function register(os, token, device, doneCallback, failCallback) {
+ if (device instanceof Function) {
+ failCallback = doneCallback;
+ doneCallback = device;
+ device = null;
+ }
+
+ return this._db.registerDevice(os, token, device).then(doneCallback, failCallback);
+ },
+
+
+ /**
+ * Uses the info from the given {util.PushMessage} message to send an push notification.
+ * @param {util.PushMessage} pushMessage to send an push notification.
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise}
+ */
+ push: function push(pushMessage, doneCallback, failCallback) {
+ return this._db.pushDevice(pushMessage).then(doneCallback, failCallback);
+ }
+});
+
+DeviceFactory.PushMessage = _dereq_(66);
+
+module.exports = DeviceFactory;
+
+},{"11":11,"66":66}],9:[function(_dereq_,module,exports){
+"use strict";
+
+var Metadata = _dereq_(63);
+var Lockable = _dereq_(61);
+
+/**
+ * @alias binding.Enhancer
+ */
+
+var Enhancer = function () {
+ function Enhancer() {
+ babelHelpers.classCallCheck(this, Enhancer);
+ }
+
+ /**
+ * @param {Class<*>} superClass
+ * @returns {Class<*>} typeConstructor
+ */
+ Enhancer.prototype.createProxy = function createProxy(superClass) {
+ return function (_superClass) {
+ babelHelpers.inherits(Proxy, _superClass);
+
+ function Proxy() {
+ babelHelpers.classCallCheck(this, Proxy);
+ return babelHelpers.possibleConstructorReturn(this, _superClass.apply(this, arguments));
+ }
+
+ return Proxy;
+ }(superClass);
+ };
+
+ /**
+ * @param {Class<*>} typeConstructor
+ * @returns {string}
+ */
+
+
+ Enhancer.prototype.getIdentifier = function getIdentifier(typeConstructor) {
+ return typeConstructor.__d__;
+ };
+
+ /**
+ * @param {Class<*>} typeConstructor
+ * @param {string} identifier
+ */
+
+
+ Enhancer.prototype.setIdentifier = function setIdentifier(typeConstructor, identifier) {
+ Object.defineProperty(typeConstructor, '__d__', {
+ value: identifier
+ });
+ };
+
+ /**
+ * @param {metamodel.ManagedType} type
+ * @param {Class<*>} typeConstructor
+ */
+
+
+ Enhancer.prototype.enhance = function enhance(type, typeConstructor) {
+ if (typeConstructor.__ype__ == type) return;
+
+ if (typeConstructor.hasOwnProperty('__ype__')) throw new Error('Type is already used by a different manager');
+
+ Object.defineProperty(typeConstructor, '__ype__', {
+ value: type
+ });
+
+ this.setIdentifier(typeConstructor, type.ref);
+ this.enhancePrototype(typeConstructor.prototype, type);
+ };
+
+ /**
+ * Enhance the prototype of the type
+ * @param {Object} proto
+ * @param {metamodel.ManagedType} type
+ */
+
+
+ Enhancer.prototype.enhancePrototype = function enhancePrototype(proto, type) {
+ if (proto.toString === Object.prototype.toString) {
+ // implements a better convenience toString method
+ Object.defineProperty(proto, 'toString', {
+ value: function toString() {
+ return this._metadata.id || this._metadata.bucket;
+ },
+ enumerable: false
+ });
+ }
+
+ // enhance all persistent object properties
+ if (type.superType && type.superType.name == 'Object') {
+ for (var _iterator = type.superType.declaredAttributes, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
+ var _ref;
+
+ if (_isArray) {
+ if (_i >= _iterator.length) break;
+ _ref = _iterator[_i++];
+ } else {
+ _i = _iterator.next();
+ if (_i.done) break;
+ _ref = _i.value;
+ }
+
+ var attr = _ref;
+
+ if (!attr.isMetadata) this.enhanceProperty(proto, attr);
+ }
+ }
+
+ // enhance all persistent properties
+ for (var _iterator2 = type.declaredAttributes, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
+ var _ref2;
+
+ if (_isArray2) {
+ if (_i2 >= _iterator2.length) break;
+ _ref2 = _iterator2[_i2++];
+ } else {
+ _i2 = _iterator2.next();
+ if (_i2.done) break;
+ _ref2 = _i2.value;
+ }
+
+ var _attr = _ref2;
+
+ this.enhanceProperty(proto, _attr);
+ }
+ };
+
+ /**
+ * @param {Object} proto
+ * @param {metamodel.Attribute} attribute
+ */
+
+
+ Enhancer.prototype.enhanceProperty = function enhanceProperty(proto, attribute) {
+ var name = '$' + attribute.name;
+ Object.defineProperty(proto, attribute.name, {
+ get: function get() {
+ var metadata = this._metadata;
+ metadata.readAccess();
+ return metadata[name];
+ },
+ set: function set(value) {
+ var metadata = this._metadata;
+ metadata.writeAccess();
+ metadata[name] = value;
+ },
+
+ configurable: true,
+ enumerable: true
+ });
+ };
+
+ return Enhancer;
+}();
+
+module.exports = Enhancer;
+
+},{"61":61,"63":63}],10:[function(_dereq_,module,exports){
+"use strict";
+
+var Managed = _dereq_(15);
+
+/**
+ * @alias binding.Entity
+ * @extends binding.Managed
+ */
+
+var Entity = function (_Managed) {
+ babelHelpers.inherits(Entity, _Managed);
+
+ /**
+ * The default constructor, copy all given properties to this object
+ * @param {Object=} properties - The optional properties to copy
+ */
+ function Entity(properties) {
+ babelHelpers.classCallCheck(this, Entity);
+ return babelHelpers.possibleConstructorReturn(this, _Managed.call(this, properties));
+ }
+
+ return Entity;
+}(Managed);
+
+Object.defineProperties(Entity.prototype, /** @lends binding.Entity.prototype */{
+ /**
+ * The unique id of this object
+ *
+ * Sets the unique id of this object, if the id is not formatted as an valid id,
+ * it will be used as the key component of the id has the same affect as setting the key
+ *
+ * @type string
+ */
+ id: {
+ get: function get() {
+ return this._metadata.id;
+ },
+ set: function set(value) {
+ if (this._metadata.id) throw new Error('The id can\'t be set twice: ' + value);
+
+ value += '';
+ if (value.indexOf('/db/' + this._metadata.bucket + '/') == 0) {
+ this._metadata.id = value;
+ } else {
+ this.key = value;
+ }
+ },
+
+ enumerable: true
+ },
+
+ /**
+ * The unique key part of the id
+ * When the key of the unique id is set an error will be thrown if an id is already set.
+ * @type string
+ */
+ key: {
+ get: function get() {
+ return this._metadata.key;
+ },
+ set: function set(value) {
+ this._metadata.key = value;
+ }
+ },
+
+ /**
+ * The version of this object
+ * @type number
+ */
+ version: {
+ get: function get() {
+ return this._metadata.version;
+ },
+
+ enumerable: true
+ },
+
+ /**
+ * The object read/write permissions
+ * @type Acl
+ */
+ acl: {
+ get: function get() {
+ return this._metadata.acl;
+ },
+
+ enumerable: true
+ },
+
+ /**
+ * Waits on the previously requested operation and calls the doneCallback if the operation is fulfilled
+ * @param {util.Lockable~callback=} doneCallback The callback which will be invoked when the previously
+ * operations on this object is completed.
+ * @return {Promise} A promise which completes successfully, when the previously requested
+ * operation completes
+ * @method
+ */
+ ready: {
+ value: function ready(doneCallback) {
+ return this._metadata.ready(doneCallback);
+ }
+ },
+
+ /**
+ * Attach this object to the given db
+ * @param {EntityManager} db The db which will be used for future crud operations
+ * @method
+ */
+ attach: {
+ value: function attach(db) {
+ db.attach(this);
+ }
+ },
+
+ /**
+ * Saves the object. Inserts the object if it doesn't exists and updates the object if the object exist.
+ * @param {Object} [options] The save options
+ * @param {boolean} [options.force=false] Force the save operation, the version will not be validated.
+ * @param {number|boolean} [options.depth=0] The object depth which will be saved. Depth 0 save this object only,
+ * true saves the objects by reachability.
+ * @param {boolean} [options.refresh=false] Refresh the local object state from remote.
+ * @param {binding.Entity~doneCallback=} doneCallback Called when the operation succeed.
+ * @param {binding.Entity~failCallback=} failCallback Called when the operation failed.
+ * @return {Promise} A Promise that will be fulfilled when the asynchronous operation completes.
+ * @method
+ */
+ save: {
+ value: function save(options, doneCallback, failCallback) {
+ if (options instanceof Function) {
+ failCallback = doneCallback;
+ doneCallback = options;
+ options = {};
+ }
+
+ return this._metadata.db.save(this, options).then(doneCallback, failCallback);
+ }
+ },
+
+ /**
+ * Inserts a new object. Inserts the object if it doesn't exists and raise an error if the object already exist.
+ * @param {Object} [options] The insertion options
+ * @param {number|boolean} [options.depth=0] The object depth which will be inserted. Depth 0 insert this object only,
+ *