miniplug/index.mjs

import assert from 'assert';
import Promise from 'bluebirdish';
import fetch from 'node-fetch';
import createDebug from 'debug';
import https from 'https';
import login from 'plug-login';
import socket from 'plug-socket';
import EventEmitter from 'events';

function delay (time) {
  return new Promise(function (resolve) {
    return setTimeout(resolve, time)
  })
}

/**
 * Create a linear incremental backoff function. Returns a function that wraps
 * a Promise-returning function.
 *
 * **Usage**
 *
 *   const func = () => Promise.resolve('done')
 *   const backoff = createBackoff({ increment: 200, max: 2200 })
 *   const throttled = backoff(func)
 *   throttled().then(console.log) // Resolves immediately
 *   throttled().then(console.log) // Resolves after 200 ms
 */
var linearPromiseBackoffQueue = function createBackoff (opts) {
  assert.equal(typeof opts, 'object', 'Expected an options object');
  assert.equal(typeof opts.increment, 'number', '`opts.increment` should be a number');
  assert.equal(typeof opts.max, 'number', '`opts.max` should be a number');

  var increment = opts.increment;
  var max = opts.max;
  var queuedCalls = 0;
  var currentDelay = 0;
  var lastCall = opts.Promise ? opts.Promise.resolve() : Promise.resolve();

  function queueCall () {
    queuedCalls += 1;
    // Keep increasing the delay as more calls are queued.
    currentDelay = Math.min(currentDelay + increment, max);
  }
  function unqueueCall () {
    queuedCalls -= 1;
    // If our queue is empty, reset the delay.
    if (queuedCalls === 0) {
      currentDelay = 0;
    }
  }

  return function (fn) { return function () {
    var self = this;
    var args = Array(arguments.length);
    for (var i = 0; i < arguments.length; i++) {
      args[i] = arguments[i];
    }
    queueCall();
    var waitDelay = currentDelay;

    // `result` will resolve with the result of the function call.
    var result = lastCall.then(function () {
      return fn.apply(self, args)
    });

    // `lastCall` will resolve after the backoff duration is over.
    lastCall = result
      .then(function () { return null }) // Ignore return value of previous call.
      .catch(function () { return null }) // Ignore errors.
      .then(function () { return delay(waitDelay) })
      .then(function (value) {
        unqueueCall();
        return value
      });

    return result
  } }
};

function polyfillGetOwnPropertyDescriptors (obj) {
  return Object.getOwnPropertyNames(obj).concat( Object.getOwnPropertySymbols(obj)).reduce((acc, name) => {
    acc[name] = Object.getOwnPropertyDescriptor(obj, name);
    return acc
  }, {})
}

var getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors || polyfillGetOwnPropertyDescriptors;

/**
 * Copy property descriptors.
 *
 * @param {object} base
 * @param {Array.<object>} others
 */
function copyProperties (base) {
  var others = [], len = arguments.length - 1;
  while ( len-- > 0 ) others[ len ] = arguments[ len + 1 ];

  others.forEach((obj) => {
    Object.defineProperties(base, getOwnPropertyDescriptors(obj));
  });
  return base
}

/**
 * Flatten nested arrays.
 *
 *     flatten([ 4, 5, [ 8, 7 ] ])
 *     // → [ 4, 5, 8, 7 ]
 *
 * @param {Array} arrs
 */
function flatten (arrs) {
  var ref;

  return (ref = []).concat.apply(ref, arrs)
}

/**
 * Get the ID for an object.
 *
 * @param {object} item
 * @param {string} idProp
 */
function getId (item, idProp) {
  if ( idProp === void 0 ) idProp = 'id';

  return typeof item === 'object' ? item[idProp] : item
}

/**
 * Get IDs for an array of objects.
 *
 * @param {Array.<object>} items
 */
function getIds (items, idProp) {
  if ( idProp === void 0 ) idProp = 'id';

  var arr = Array.isArray(items) ? items : [ items ];
  return arr.map((item) => getId(item, idProp))
}

/**
 * Parse a string timestamp from plug.dj.
 *
 * @param {string} timestamp
 */
function parseDate (timestamp) {
  return new Date(`${timestamp} UTC`)
}

/**
 * Fill in fn's arguments with ...args from the beginning of fn's arguments
 * list.
 *
 * @param {Function} fn
 * @param {...*} args
 */
function partial (fn) {
  var args = [], len = arguments.length - 1;
  while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];

  return function () {
    var rest = [], len = arguments.length;
    while ( len-- ) rest[ len ] = arguments[ len ];

    return fn.apply(void 0, args.concat( rest ));
  }
}

var ROLE = {
  NONE: 0,
  DJ: 1000,
  BOUNCER: 2000,
  MANAGER: 3000,
  COHOST: 4000,
  HOST: 5000,

  PROMOTER: 500,
  PLOT: 750,
  SITEMOD: 2500,
  AMBASSADOR: 3000,
  ADMIN: 5000
};

var MEDIA_SOURCE = {
  YOUTUBE: 1,
  SOUNDCLOUD: 2
};

var BAN_DURATION = {
  HOUR: 'h',
  DAY: 'd',
  PERMA: 'f'
};

var BAN_REASON = {
  SPAMMING: 1,
  VERBAL_ABUSE: 2,
  OFFENSIVE_PLAYS: 3,
  GENRE: 4,
  ATTITUDE: 5
};

var MUTE_DURATION = {
  SHORT: 's',
  MEDIUM: 'm',
  LONG: 'l'
};

var MUTE_REASON = {
  VIOLATING_RULES: 1,
  VERBAL_ABUSE: 2,
  SPAMMING: 3,
  LANGUAGE: 4,
  ATTITUDE: 5
};

var WAITLIST_BAN_DURATION = {
  SHORT: 's',
  MEDIUM: 'm',
  LONG: 'l',
  PERMA: 'f'
};

var WAITLIST_BAN_REASON = BAN_REASON;

var constants = /*#__PURE__*/Object.freeze({
  ROLE: ROLE,
  MEDIA_SOURCE: MEDIA_SOURCE,
  BAN_DURATION: BAN_DURATION,
  BAN_REASON: BAN_REASON,
  MUTE_DURATION: MUTE_DURATION,
  MUTE_REASON: MUTE_REASON,
  WAITLIST_BAN_DURATION: WAITLIST_BAN_DURATION,
  WAITLIST_BAN_REASON: WAITLIST_BAN_REASON
});

var captureStackTrace = Error.captureStackTrace || function (error) {
	var container = new Error();

	Object.defineProperty(error, 'stack', {
		configurable: true,
		get: function getStack() {
			var stack = container.stack;

			Object.defineProperty(this, 'stack', {
				value: stack
			});

			return stack;
		}
	});
};

function inherits(ctor, superCtor) {
	ctor.super_ = superCtor;
	ctor.prototype = Object.create(superCtor.prototype, {
		constructor: {
			value: ctor,
			enumerable: false,
			writable: true,
			configurable: true
		}
	});
}

var createErrorClass = function createErrorClass(className, setup) {
	if (typeof className !== 'string') {
		throw new TypeError('Expected className to be a string');
	}

	if (/[^0-9a-zA-Z_$]/.test(className)) {
		throw new Error('className contains invalid characters');
	}

	setup = setup || function (message) {
		this.message = message;
	};

	var ErrorClass = function () {
		Object.defineProperty(this, 'name', {
			configurable: true,
			value: className,
			writable: true
		});

		captureStackTrace(this, this.constructor);

		setup.apply(this, arguments);
	};

	inherits(ErrorClass, Error);

	return ErrorClass;
};

function setup (response, cause) {
  this.message = (response.body.data && response.body.data[0]) || cause.message;
  this.status = response.body.status;
  if (!this.response) { this.response = response; }
  this.cause = cause;
}

function setupFundsPP (response, cause) {
  setup.call(this, response, cause);
  this.message = 'You don\'t have enough Plug Points to unlock this.';
}

var RequestError = createErrorClass('RequestError', setup);
var BadLoginError = createErrorClass('BadLoginError', setup);
var NotAuthorizedError = createErrorClass('NotAuthorizedError', setup);
var NotFoundError = createErrorClass('NotFoundError', setup);
var NoValidPlaylistError = createErrorClass('NoValidPlaylistError', setup);
var NotEnoughPPError = createErrorClass('NotEnoughPPError', setupFundsPP);
var MaintenanceError = createErrorClass('MaintenanceError', setup);

var statusToError = {
  requestError: RequestError,
  badLogin: BadLoginError,
  notAuthorized: NotAuthorizedError,
  notFound: NotFoundError,
  noValidPlaylist: NoValidPlaylistError,
  maintenanceMode: MaintenanceError
};

var errorClasses = {
  RequestError,
  BadLoginError,
  NotAuthorizedError,
  NotFoundError,
  NoValidPlaylistError,
  NotEnoughPPError,
  MaintenanceError
};

function wrapResponseError (response, cause) {
  var ref = response.body;
  var status = ref.status;
  var data = ref.data;
  // Special cases
  if (status === 'requestError' && data && data[0] === 'fundsPP') {
    return new NotEnoughPPError(response, cause)
  }

  var ErrorClass = statusToError[status];
  if (ErrorClass) {
    return new ErrorClass(response, cause)
  }
  setup.call(cause, response, cause);
  return cause
}

/**
 * Reverse plug.dj's chat message escaping.
 */
function unescape (message) {
  return message
    .replace(/&#34;/g, '"')
    .replace(/&#39;/g, '\'')
    .replace(/&lt;/g, '<')
    .replace(/&gt;/g, '>')
    .replace(/&amp;/g, '&')
}

/**
 * Add methods to an object's prototype.
 */
function makeProto (obj, methods) {
  var proto = copyProperties({
    toJSON: () => obj
  }, methods);
  var instance = Object.create(proto);
  copyProperties(instance, obj);
  return instance
}

function wrapMessage (mp, message) {
  if (message.un) {
    message.un = unescape(message.un);
  }

  message.id = message.cid;
  message.message = unescape(message.message);
  message.user = mp.user(message.uid) ||
    mp.wrapUser({ id: message.uid, username: message.un });

  return makeProto(message, {
    own: () => mp.me().id === message.uid,

    chat: mp.chat,
    reply: partial(mp.chat, `@${message.un}`),
    emote: partial(mp.chat, `/me @${message.un}`),

    delete: partial(mp.deleteChat, message.cid),

    getUser () {
      var user = mp.user && mp.user(message.uid);
      return user ? Promise.resolve(user) : mp.getUser(message.uid)
    }
  })
}

function wrapHistoryEntry (mp, rawEntry) {
  var timestamp = parseDate(rawEntry.timestamp);

  rawEntry.timestamp = timestamp;
  // wrapMedia expects a playlist ID, but we don't know it--pass null instead.
  rawEntry.media = mp.wrapMedia(null, rawEntry.media);
  rawEntry.user = mp.wrapUser(rawEntry.user);

  if (rawEntry.room) {
    rawEntry.room = mp.wrapRoom(rawEntry.room);
  }

  return makeProto(rawEntry, {
    get time () { throw new Error('miniplug: \'HistoryEntry.time\' was renamed to \'HistoryEntry.timestamp\' in v1.8.0. Please update your code.') },
    get dj () { throw new Error('miniplug: \'HistoryEntry.dj\' does not work, use \'HistoryEntry.user\' instead. Please update your code.') },
    getUser: partial(mp.getUser, rawEntry.user.id),
    skip: partial(mp.skipDJ, rawEntry.user.id, rawEntry.id)
  })
}

function wrapInventoryProduct (mp, product) {
  // Rename the product.id property. The `id` property on inventory products
  // corresponds to the `name` property on store products in the plug.dj API.
  // Miniplug uses `name` for both for consistency.
  product.name = product.id;
  delete product.id;

  return makeProto(product, {})
}

function wrapMedia (mp, playlistId, media) {
  return makeProto(media, {
    update: partial(mp.updateMedia, playlistId, media.id),
    delete: () =>
      mp.deleteMedia(playlistId, [ media.id ])
  })
}

function wrapNotification (mp, notif) {
  notif.id = Number(notif.id);
  notif.timestamp = parseDate(notif.timestamp);

  if (notif.action === 'levelUp') {
    notif.level = Number(notif.value);
  }

  if (notif.action === 'gift') {
    var parts = notif.value.split('\u2800');
    notif.from = parts[0];
    notif.amount = Number(parts[1]);
  }

  if (notif.action === 'custom') {
    notif.message = notif.value;
  }

  return makeProto(notif, {
    acknowledge: partial(mp.acknowledgeNotification, notif.id)
  })
}

function wrapPlaylist (mp, playlist) {
  return makeProto(playlist, {
    delete: partial(mp.deletePlaylist, playlist.id),
    activate: partial(mp.activatePlaylist, playlist.id),
    rename: partial(mp.renamePlaylist, playlist.id),
    shuffle: partial(mp.shufflePlaylist, playlist.id),

    getMedia: () =>
      mp.getMedia(playlist.id)
        .map(partial(mp.wrapMedia, playlist.id))
        .tap(media => {
          // cachedMedia = media
        }),
    insert: (media, append) =>
      {
        if ( append === void 0 ) append = true;

        return mp.insertMedia(playlist.id, media, append);
  },
    move: (media, before) =>
      mp.moveMedia(playlist.id, media, before)
  })
}

function wrapRoom (mp, room) {
  if (room.welcome) {
    room.welcome = unescape(room.welcome);
  }
  if (room.description) {
    room.description = unescape(room.description);
  }

  room.isFavorite = room.favorite;
  delete room.favorite;

  return makeProto(room, {
    getHost: partial(mp.getUser, room.hostID),

    join: partial(mp.join, room.slug),

    favorite: partial(mp.favoriteRoom, room.id),
    unfavorite: partial(mp.unfavoriteRoom, room.id)
  })
}

function wrapStoreProduct (mp, product) {
  return makeProto(product, {
    purchase: partial(mp.purchase, product.id)
  })
}

function wrapUser (mp, user) {
  user.username = user.guest ? null : unescape(user.username || '');

  // Chat mention string for this user.
  var mention = `@${user.username}`;

  return makeProto(user, {
    hasPermission: (role) =>
      (user.role >= role || user.gRole >= role),
    hasGlobalPermission: (role) =>
      user.gRole >= role,

    chat: partial(mp.chat, mention),
    emote: partial(mp.chat, `/me ${mention}`),

    add: partial(mp.addDJ, user.id),
    move: partial(mp.moveDJ, user.id),
    remove: partial(mp.removeDJ, user.id),
    skip: partial(mp.skipDJ, user.id),

    befriend: partial(mp.befriend, user.id),
    rejectRequest: partial(mp.rejectFriendRequest, user.id),

    ignore: partial(mp.ignore, user.id),
    unignore: partial(mp.unignore, user.id),

    mute: partial(mp.mute, user.id),
    unmute: partial(mp.unmute, user.id),

    ban: partial(mp.ban, user.id),
    unban: partial(mp.unban, user.id),

    waitlistBan: partial(mp.waitlistBan, user.id),
    waitlistUnban: partial(mp.waitlistUnban, user.id),

    getHistory: partial(mp.getUserHistory, user.id),

    mention: () => mention,
    // Allows mentioning users by doing `Hello ${user}` in chat messages.
    toString: () => mention
  })
}

// Have to use a real class to get working inheritance from Array. Methods are
// still added inside wrapWaitlist, as usual.
class Waitlist extends Array {}

function wrapWaitlist (mp, waitlist) {
  var wrapped = Object.assign(new Waitlist(), {
    contains: (user) =>
      wrapped.some((waiting) => waiting.id === getId(user)),
    positionOf: (user) =>
      wrapped.findIndex((waiting) => waiting.id === getId(user)),
    toJSON: () => waitlist
  });

  waitlist.forEach((id) => {
    wrapped.push(mp.user(id) || mp.wrapUser({ id: id }));
  });

  return wrapped
}

function wrapWaitlistBan (mp, data) {
  data.username = unescape(data.username);
  data.moderator = unescape(data.moderator);

  var ban = {
    user: mp.user(data.id) || mp.wrapUser({ id: data.id, username: data.username }),
    moderator: mp.user(data.moderatorID) || mp.userByName(data.moderator) ||
      mp.wrapUser({ id: data.moderatorID, username: data.moderator }),
    moderatorName: data.moderator,
    reason: data.reason,
    duration: data.duration,
    timestamp: typeof data.timestamp === 'string'
      ? parseDate(data.timestamp)
      : data.timestamp
  };
  return makeProto(ban, {
    getUser: partial(mp.getUser, data.id),
    remove: partial(mp.waitlistUnban, data.id)
  })
}

function dataModelPlugin () {
  return (mp) => {
    Object.assign(mp, {
      wrapMessage: partial(wrapMessage, mp),
      wrapHistoryEntry: partial(wrapHistoryEntry, mp),
      wrapInventoryProduct: partial(wrapInventoryProduct, mp),
      wrapMedia: partial(wrapMedia, mp),
      wrapNotification: partial(wrapNotification, mp),
      wrapPlaylist: partial(wrapPlaylist, mp),
      wrapRoom: partial(wrapRoom, mp),
      wrapStoreProduct: partial(wrapStoreProduct, mp),
      wrapUser: partial(wrapUser, mp),
      wrapWaitlist: partial(wrapWaitlist, mp),
      wrapWaitlistBan: partial(wrapWaitlistBan, mp)
    });
  }
}

var Agent = https.Agent;
var debug = createDebug('miniplug:http');

function httpPlugin (httpOpts) {
  httpOpts = Object.assign({}, {backoff: (fn) => fn,
    agent: httpOpts.agent || new Agent({ keepAlive: true })},
    httpOpts);

  return (mp) => {
    var request = httpOpts.backoff((url, opts) => {
      if (!mp.connected) {
        return Promise.reject(new Error('No connection available. Use mp.connect() before calling other functions.'))
      }

      // wait until connections are complete before sending off requests
      return mp.connected
        .tap(() => debug(opts.method, url, opts.body || opts.query))
        .then((session) =>
          fetch(`${httpOpts.host}/_/${url}`, Object.assign({}, {agent: httpOpts.agent,
            headers: {
              cookie: session.cookie,
              'content-type': 'application/json'
            }},
            opts,
            {body: opts.body ? JSON.stringify(opts.body) : undefined}))
        )
        .then((response) => {
          return response.json().then((body) => {
            if (!response.ok || body.status !== 'ok') {
              throw Object.assign(new Error(
                body.data && body.data.length
                  ? body.data[0]
                  : body.status
              ), { response })
            }
            return body.data
          })
        })
        .catch((err) => {
          if (err && err.response) {
            throw wrapResponseError(err.response, err)
          }
          throw err
        })
    });

    var post = (url, data) => request(url, { method: 'post', body: data });
    var get = (url, data) => request(url, { method: 'get', query: data });
    var put = (url, data) => request(url, { method: 'put', body: data });
    var del = (url, data) => request(url, { method: 'delete', body: data });

    mp.request = request;
    mp.post = post;
    mp.get = get;
    mp.put = put;
    mp.del = del;
  }
}

var debug$1 = createDebug('miniplug:connect');
var debugWs = createDebug('miniplug:ws');
var MaintenanceError$1 = errorClasses.MaintenanceError;

function connectPlugin (options) {
  if ( options === void 0 ) options = {};

  return (mp) => {
    var loginOpts = {
      agent: options.agent,
      host: options.host,
      authToken: true
    };

    function connect (opts) {
      if ( opts === void 0 ) opts = {};

      debug$1('connecting', opts.email);

      var loginPromise = Promise.resolve(
        opts.email
          ? login.user(opts.email, opts.password, loginOpts)
          : login.guest(loginOpts)
      ).catch((err) => {
        if (err && err.status === 'maintenanceMode') {
          throw new MaintenanceError$1(err.response, err)
        }
        throw err
      });

      var ws = socket();
      ws.setMaxListeners(100);
      ws.on('action', (type, payload) => {
        debugWs(type, payload);
      });
      ws.on('close', () => {
        mp.emit('disconnected');
      });

      var connected = loginPromise
        .then((res) => new Promise((resolve, reject) => {
          ws.auth(res.token);
          ws.once('error', reject);

          mp.isConnected = true;
          mp.emit('login');

          var me = mp.getMe();
          ws.once('ack', () => {
            resolve({ cookie: res.cookie });
            ws.removeListener('error', reject);

            me.then((user) => mp.emit('connected', user));
          });
        }))
        .catch((err) => {
          mp.emit('error', err);
          throw err
        });

      mp.ws = ws;
      mp.connected = connected;

      // Return `mp` so you can do
      // mp = await miniplug().connect()
      return connected.then(() => mp)
    }

    mp.connect = connect;
  }
}

var debug$2 = createDebug('miniplug:users');

var GUEST_ID = 0;

var kGuestsCount = Symbol('Guests count');
var kUsers = Symbol('Users');
var kCurrentUser = Symbol('Me');

function usersPlugin () {
  return (mp) => {
    // local user cache/collection API
    mp[kGuestsCount] = 0;
    mp[kUsers] = [];

    function onUserJoin (user) {
      debug$2('join', user.id);
      if (user.guest) {
        mp[kGuestsCount] += 1;
        mp.emit('guestJoin');
      } else {
        user = mp.wrapUser(user);
        mp[kUsers].push(user);
        mp.emit('userJoin', user);
      }
    }

    function onUserLeave (id) {
      debug$2('leave', id);
      if (id === GUEST_ID) {
        if (mp[kGuestsCount] > 0) {
          mp[kGuestsCount] -= 1;
        }
        mp.emit('guestLeave');
      } else {
        var i = mp[kUsers].findIndex((user) => user.id === id);
        if (i !== -1) {
          var user = mp[kUsers][i];
          mp[kUsers].splice(i, 1);
          mp.emit('userLeave', user);
        }
      }
    }

    function onUserUpdate (props) {
      var user = mp.user(props.i);
      if (!user) { return }

      delete props.i;
      var oldProps = Object.keys(props).reduce((o, name) => {
        o[name] = user[name];
        return o
      }, {});

      Object.assign(user, props);

      mp.emit('userUpdate', user, oldProps);
    }

    // Emit `userUpdate` events for `role` updates.
    function onStaffUpdate (props) {
      props.u.forEach((ref) => {
        onUserUpdate({ i: ref.i, role: ref.p });

        mp.emit('modStaff', {
          moderator: mp.user(props.mi) || mp.wrapUser({ id: props.mi, username: props.m }),
          user: mp.user(ref.i) || mp.wrapUser({ id: ref.i, username: ref.n }),
          role: ref.p
        });
      });
    }

    mp.on('connected', (user) => {
      mp[kCurrentUser] = mp.wrapUser(user);

      mp.ws.on('userJoin', onUserJoin);
      mp.ws.on('userLeave', onUserLeave);
      mp.ws.on('userUpdate', onUserUpdate);
      mp.ws.on('modStaff', onStaffUpdate);
    });

    // keeping things in sync
    mp.on('roomState', (ref) => {
      var users = ref.users;
      var guests = ref.meta.guests;

      mp[kUsers] = users.map(mp.wrapUser);
      mp[kGuestsCount] = guests;
    });

    var me = () => mp[kCurrentUser];
    var userByProp = (prop) => (value) => {
      if (mp[kCurrentUser] && value === mp[kCurrentUser][prop]) {
        return mp[kCurrentUser]
      }
      return mp[kUsers].find((user) => user[prop] === value)
    };
    var user = userByProp('id');
    var userByName = userByProp('username');
    // Maybe include `me()` in the `users()` list in v3.0.0? I'm not
    // sure which is more expected.
    var users = () => mp[kUsers];
    var guests = () => mp[kGuestsCount];

    // REST API
    var getMe = () => mp.get('users/me').get(0).then(mp.wrapUser);
    var getUser = uid => mp.get(`users/${uid}`).get(0).then(mp.wrapUser);
    // pass IDs or arrays of IDs
    var getUsers = function () {
        var uids = [], len = arguments.length;
        while ( len-- ) uids[ len ] = arguments[ len ];

        return mp.post('users/bulk', {
        ids: flatten(uids)
      }).map(mp.wrapUser);
    };

    // current user & profile
    var saveSettings = partial(mp.put, 'users/settings');
    var setAvatar = (avatar) =>
      mp.put('users/avatar', { id: avatar });
    var setBadge = (badge) =>
      mp.put('users/badge', { id: badge });
    var setBlurb = (blurb) =>
      mp.put('profile/blurb', { blurb: blurb });
    var setLanguage = (lang) =>
      mp.put('users/language', { language: lang });
    var getTransactions = partial(mp.get, 'users/me/transactions');

    var validateUsername = (name) =>
      mp.get(`users/validate/${encodeURIComponent(name)}`)
        .get(0)
        .catch(() => Promise.reject(new Error('Username unavailable.')));

    // Public API
    Object.assign(mp, {
      // local
      me,
      user,
      userByName,
      users,
      guests,
      // remote
      getMe,
      getUser,
      getUsers,
      // setters
      saveSettings,
      setAvatar,
      setBadge,
      setBlurb,
      setLanguage,

      getTransactions,
      validateUsername
    });
  }
}

function ignoresPlugin () {
  return (mp) => {
    var getIgnoredUsers = partial(mp.get, 'ignores');
    var ignore = (uid) =>
      mp.post('ignores', { id: uid }).get(0);
    var unignore = (uid) =>
      mp.del(`ignores/${uid}`);

    Object.assign(mp, {
      getIgnoredUsers,
      ignore,
      unignore
    });
  }
}

function mutesPlugin () {
  return (mp) => {
    var getMutes = partial(mp.get, 'mutes');
    var mute = (uid, duration, reason) =>
      {
        if ( duration === void 0 ) duration = MUTE_DURATION.SHORT;
        if ( reason === void 0 ) reason = MUTE_REASON.VIOLATING_RULES;

        return mp.post('mutes', {
        userID: uid,
        duration: duration,
        reason: reason
      });
    };
    var unmute = (uid) =>
      mp.del(`mutes/${uid}`);

    Object.assign(mp, {
      getMutes,
      mute,
      unmute
    });

    function onModMute (ref) {
      mp.emit('modMute', {
        moderator: mp.user(ref.mi) || mp.wrapUser({ id: ref.mi, username: ref.m }),
        user: mp.user(ref.i) || mp.wrapUser({ id: ref.i, username: ref.t }),
        reason: ref.r,
        duration: ref.d
      });
    }

    mp.on('connected', (user) => {
      mp.ws.on('modMute', onModMute);
    });
  }
}

function bansPlugin () {
  return (mp) => {
    var getBans = partial(mp.get, 'bans');
    var ban = (uid, duration, reason) =>
      {
        if ( duration === void 0 ) duration = BAN_DURATION.HOUR;
        if ( reason === void 0 ) reason = BAN_REASON.SPAMMING;

        return mp.post('bans/add', {
        userID: uid,
        reason: reason,
        duration: duration
      }).get(0);
    };
    var unban = (uid) =>
      mp.del(`bans/${uid}`);

    Object.assign(mp, {
      getBans,
      ban,
      unban
    });

    function onBan (ref) {
      mp.emit('ban', {
        duration: ref.d,
        reason: ref.r
      });
    }

    function onModBan (ref) {
      mp.emit('modBan', {
        moderator: mp.user(ref.mi) || mp.wrapUser({ id: ref.mi }),
        username: ref.t,
        duration: ref.d
      });
    }

    mp.on('connected', (user) => {
      mp.ws.on('ban', onBan);
      mp.ws.on('modBan', onModBan);
    });
  }
}

var kNotifications = Symbol('Notifications');

function notificationsPlugin () {
  return (mp) => {
    mp[kNotifications] = [];

    function onNotify (notif) {
      mp[kNotifications].push(notif);
      mp.emit('notify', mp.wrapNotification(notif));
    }

    function onEarn (ref) {
      var me = mp.me();
      if (me) { Object.assign(me, ref); }
      mp.emit('earn', {
        xp: ref.xp,
        pp: ref.pp,
        level: ref.level
      });
    }

    function onSub (sub) {
      var me = mp.me();
      if (me) { me.sub = sub; }
      mp.emit('sub', sub);
    }

    function onGift (pp) {
      var me = mp.me();
      if (me) { Object.assign(me, { pp }); }
      mp.emit('gift', { pp });
    }

    mp.on('connected', (user) => {
      mp[kNotifications] = (user && user.notifications) || [];

      mp.ws.on('notify', onNotify);
      mp.ws.on('earn', onEarn);
      mp.ws.on('sub', onSub);
      mp.ws.on('gift', onGift);
    });

    Object.assign(mp, {
      notifications: () => mp[kNotifications].map(mp.wrapNotification),

      getNotifications: () =>
        mp.getMe()
          .then((me) => me.notifications || [])
          .tap((notifs) => {
            mp[kNotifications] = notifs;
          })
          .map(mp.wrapNotification),

      acknowledgeNotification: (id) =>
        mp.del(`notifications/${id}`).tap(() => {
          // Remove the notification from the local notifications list.
          mp[kNotifications] = mp[kNotifications]
            .filter((notif) => notif.id !== Number(id));
        })
    });
  }
}

var kCurrentHistoryEntry = Symbol('History entry');

function boothPlugin (opts) {
  if ( opts === void 0 ) opts = {};

  return (mp) => {
    // Local state API
    var historyEntry = () => mp[kCurrentHistoryEntry];
    var dj = () => mp[kCurrentHistoryEntry] ? mp[kCurrentHistoryEntry].user : null;
    var media = () => mp[kCurrentHistoryEntry] ? mp[kCurrentHistoryEntry].media : null;

    mp.on('roomState', (state) => {
      if (!state.playback.media) {
        mp[kCurrentHistoryEntry] = null;
        return
      }

      var timestamp = parseDate(state.playback.startTime);

      mp[kCurrentHistoryEntry] = mp.wrapHistoryEntry({
        id: state.playback.historyID,
        user: mp.user(state.booth.currentDJ),
        media: state.playback.media,
        timestamp: timestamp
      });

      // only for the current historyEntry
      mp[kCurrentHistoryEntry].playlistId = state.playback.playlistID;
    });

    // Socket API
    function onAdvance (event) {
      var previous = historyEntry();
      if (!event || !event.m) {
        mp[kCurrentHistoryEntry] = null;
        mp.emit('advance', null, previous);
        return
      }

      var historyId = event.h;
      var media = event.m;
      var djId = event.c;
      var playlistId = event.p;
      var timestamp = event.t;

      mp[kCurrentHistoryEntry] = mp.wrapHistoryEntry({
        id: historyId,
        user: mp.user(djId) || mp.wrapUser({ id: djId }),
        media: media,
        timestamp: timestamp
      });

      // only for the current historyEntry
      mp[kCurrentHistoryEntry].playlistId = playlistId;

      mp.emit('advance', historyEntry(), previous);
    }

    mp.on('connected', () => {
      mp.ws.on('advance', onAdvance);
    });

    // Rest API
    Object.assign(mp, {
      skipDJ: (uid, hid) =>
        mp.post('booth/skip', { userID: uid, historyID: hid }),
      skipMe: partial(mp.post, 'booth/skip/me')
    });

    Object.assign(mp, {
      historyEntry,
      dj,
      media
    });
  }
}

var debug$3 = createDebug('miniplug:waitlist');
var kWaitlist = Symbol('Waitlist');
var kLocked = Symbol('Waitlist locked');
var kCycles = Symbol('Waitlist cycles');

function waitlistPlugin () {
  return (mp) => {
    mp[kLocked] = false;
    mp[kCycles] = true;
    mp[kWaitlist] = mp.wrapWaitlist([]);

    mp.on('roomState', (state) => {
      mp[kWaitlist] = mp.wrapWaitlist(state.booth.waitingDJs);
      mp[kLocked] = state.booth.isLocked;
      mp[kCycles] = state.booth.shouldCycle;
      mp.emit('waitlistUpdate', mp.waitlist(), []);
    });

    function onDjListUpdate (ids) {
      debug$3('update', ids);

      var previous = mp.waitlist();

      mp[kWaitlist] = mp.wrapWaitlist(ids);
      mp.emit('waitlistUpdate', mp.waitlist(), previous);
    }

    function onAdvance (event) {
      if (event && event.d) {
        onDjListUpdate(event.d);
      } else {
        onDjListUpdate([]);
      }
    }

    function onModAddDj (ref) {
      mp.emit('modAddDj', {
        moderator: mp.user(ref.mi) || mp.wrapUser({ id: ref.mi, username: ref.m }),
        username: ref.t
      });
    }

    function onModMoveDj (ref) {
      mp.emit('modMoveDj', {
        moderator: mp.user(ref.mi) || mp.wrapUser({ id: ref.mi }),
        username: ref.u,
        movedFrom: ref.o,
        movedTo: ref.n
      });
    }

    function onModRemoveDj (ref) {
      mp.emit('modRemoveDj', {
        moderator: mp.user(ref.mi) || mp.wrapUser({ id: ref.mi }),
        username: ref.t,
        inBooth: ref.d
      });
    }

    function onModSkip (ref) {
      mp.emit('modSkip', mp.user(ref.mi) || mp.wrapUser({ id: ref.mi, username: ref.m }));
    }

    function onDjListCycle (ref) {
      var f = ref.f;
      var mi = ref.mi;

      mp[kCycles] = f;

      mp.emit('waitlistCycle', {
        shouldCycle: f,
        user: mp.user(mi) || mp.wrapUser({ id: mi })
      });
    }

    function onDjListLocked (ref) {
      var f = ref.f;
      var c = ref.c;
      var mi = ref.mi;

      mp[kLocked] = f;

      var user = mp.user(mi) || mp.wrapUser({ id: mi });
      mp.emit('waitlistLock', {
        locked: f,
        cleared: !!c,
        user
      });

      if (c) {
        mp.emit('waitlistClear', { user });
      }
    }

    function onSkip (ref) {
      mp.emit('skip', mp.user(ref) || mp.wrapUser({ id: ref }));
    }

    mp.on('connected', () => {
      mp.ws.on('djListUpdate', onDjListUpdate);
      mp.ws.on('advance', onAdvance);
      mp.ws.on('modAddDJ', onModAddDj);
      mp.ws.on('modMoveDJ', onModMoveDj);
      mp.ws.on('modRemoveDJ', onModRemoveDj);
      mp.ws.on('modSkip', onModSkip);
      mp.ws.on('djListCycle', onDjListCycle);
      mp.ws.on('djListLocked', onDjListLocked);
      mp.ws.on('skip', onSkip);
    });

    var setCycle = (val) =>
      {
        if ( val === void 0 ) val = true;

        return mp.put('booth/cycle', { shouldCycle: val });
    };

    Object.assign(mp, {
      waitlist: () => mp[kWaitlist],

      joinWaitlist: partial(mp.post, 'booth'),
      leaveWaitlist: partial(mp.del, 'booth'),

      isCycling: () => mp[kCycles],
      setCycle,
      enableCycle: partial(setCycle, true),
      disableCycle: partial(setCycle, false),

      isLocked: () => mp[kLocked],
      setLock: (locked, clear) =>
        {
          if ( locked === void 0 ) locked = true;
          if ( clear === void 0 ) clear = false;

          return mp.put('booth/lock', { isLocked: locked, removeAllDJs: clear });
    },
      lockWaitlist: (clear) =>
        {
          if ( clear === void 0 ) clear = false;

          return mp.setLock(true, clear);
    },
      unlockWaitlist: () =>
        mp.setLock(false, false),

      addDJ: (uid) =>
        mp.post('booth/add', { id: uid }),
      moveDJ: (uid, pos) =>
        mp.post('booth/move', { userID: uid, position: pos }),
      removeDJ: (uid) =>
        mp.del(`booth/remove/${uid}`)
    });
  }
}

function waitlistBansPlugin () {
  return (mp) => {
    var getWaitlistBans = () =>
      mp.get('booth/waitlistban').map(mp.wrapWaitlistBan);
    var waitlistBan = (id, duration, reason) =>
      {
        if ( duration === void 0 ) duration = WAITLIST_BAN_DURATION.SHORT;
        if ( reason === void 0 ) reason = WAITLIST_BAN_REASON.SPAMMING;

        return mp.post('booth/waitlistban', {
        userID: id,
        duration,
        reason
      });
    };
    var waitlistUnban = (id) =>
      mp.del(`booth/waitlistban/${id}`);

    mp.on('connected', () => {
      mp.ws.on('modWaitlistBan', (ban) => {
        var wrappedBan = mp.wrapWaitlistBan({
          moderator: ban.m,
          moderatorID: ban.mi,
          username: ban.t,
          id: ban.ti,
          duration: ban.d,
          reason: null,
          timestamp: new Date()
        });
        mp.emit('modWaitlistBan', wrappedBan);
      });
    });

    // Deprecations
    mp.on('newListener', (name) => {
      if (name === 'waitlistBan') {
        throw new Error('miniplug: the \'waitlistBan\' event was renamed to \'modWaitlistBan\' in 1.11.0. Please update your code.')
      }
    });

    Object.assign(mp, {
      getWaitlistBans,
      waitlistBan,
      waitlistUnban
    });
  }
}

function historyPlugin () {
  return (mp) => {
    var getRoomHistory = () =>
      mp.get('rooms/history').map(mp.wrapHistoryEntry);

    // Get the history for the logged-in user.
    var getOwnHistory = () =>
      mp.get('users/me/history').map(mp.wrapHistoryEntry);

    var getProfile = (id) =>
      mp.get(`profile/${id}`).get(0);

    // Get the history for another user.
    var getOtherHistory = (id) =>
      getProfile(id).get('history').map(mp.wrapHistoryEntry);

    // Get the history for a user. Defaults to the current user.
    var getUserHistory = (id) =>
      {
        if ( id === void 0 ) id = mp.me().id;

        return mp.me().id === id ? getOwnHistory() : getOtherHistory(id);
    };

    Object.assign(mp, {
      getRoomHistory,
      getUserHistory
    });
  }
}

var debug$4 = createDebug('miniplug:chat');

function chatPlugin (opts) {
  opts = Object.assign({}, {timeout: 7000,
    // allow users to pass their own rate limiting function,
    // this will get a sensible default at some point
    backoff: (fn) => fn},
    opts);

  return (mp) => {
    // translate raw socket events to wrapped miniplug events
    function onChat (msg) {
      debug$4('chat', msg.uid, msg.un, msg.message);
      mp.emit('chat', mp.wrapMessage(msg));
    }

    function onChatDelete (ref) {
      var c = ref.c;
      var mi = ref.mi;

      debug$4('chatDelete', mi, c);
      mp.emit('chatDelete', {
        cid: c,
        user: mp.user(mi) || mp.wrapUser({ id: mi })
      });
    }

    function onGifted (ref) {
      mp.emit('gifted', {
        sender: ref.s,
        recipient: ref.r
      });
    }

    mp.on('connected', () => {
      mp.ws.on('chat', onChat);
      mp.ws.on('chatDelete', onChatDelete);
      mp.ws.on('gifted', onGifted);
    });

    // REST API
    var deleteChat = (cid) =>
      mp.del(`chat/${cid}`);
    var getChatHistory = () =>
      mp.get(`chat/history`)
        .then((d) => d[0].history.map((msg) => Object.assign(
          mp.wrapMessage(msg),
          { user: mp.wrapUser(d[0].users.find((u) => u.id === msg.uid)) }
        )));

    // Socket API
    var chat = opts.backoff(function () {
      var args = [], len = arguments.length;
      while ( len-- ) args[ len ] = arguments[ len ];

      var ws = mp.ws;
      var message = args.join(' ');
      debug$4('send', message);
      ws.chat(message);
      // attempt to resolve when the message comes back
      return new Promise((resolve, reject) => {
        var intv = setTimeout(() => {
          mp.removeListener('chat', onChat);
          reject(new Error('Waiting for chat message to come back timed out.'));
        }, opts.timeout);

        var onChat = (chat) => {
          debug$4('is same?', chat.own(), message, chat.message);
          // TODO ensure that chat messages are unescaped enough for this
          // (they aren't)
          if (chat.own() && chat.message === message) {
            mp.removeListener('chat', onChat);
            clearTimeout(intv);
            resolve(chat);
          }
        };

        mp.on('chat', onChat);
      })
    });
    var emote = partial(chat, '/me');

    // Public API
    Object.assign(mp, {
      deleteChat,
      getChatHistory,
      chat,
      emote
    });
  }
}

function friendsPlugin () {
  return (mp) => {
    // Friendship events only include the requesting/accepting user's name.
    // Plug.dj refreshes its client-side friends or invites list when these
    // events come in. Miniplug requests the friends or invites list and emits
    // the events with a user object, so it's easy to respond to the events
    // using the `user.befriend` and `user.rejectRequest` methods.
    function onFriendRequest (name) {
      getFriendRequests().each((request) => {
        if (unescape(request.username) === unescape(name)) {
          mp.emit('friendRequest', mp.wrapUser(request));
        }
      });
    }

    function onFriendAccept (name) {
      getFriends().each((friend) => {
        if (friend.username === unescape(name)) {
          mp.emit('friendAccept', friend);
        }
      });
    }

    mp.on('connected', () => {
      mp.ws.on('friendRequest', onFriendRequest);
      mp.ws.on('friendAccept', onFriendAccept);
    });

    // REST Friend API
    var getFriends = () =>
      mp.get('friends').map(mp.wrapUser);
    var befriend = (uid) =>
      mp.post('friends', { id: uid });
    var unfriend = (uid) =>
      mp.del(`friends/${uid}`);
    var getFriendRequests = partial(mp.get, 'friends/invites');
    var rejectFriendRequest = (uid) =>
      mp.put('friends/ignore', { id: uid });

    // Public API
    Object.assign(mp, {
      getFriends,
      befriend,
      unfriend,
      getFriendRequests,
      rejectFriendRequest
    });
  }
}

var debug$5 = createDebug('miniplug:rooms');
var kCurrentRoom = Symbol('Current room');

function roomsPlugin () {
  return (mp) => {
    mp[kCurrentRoom] = null;

    mp.on('roomState', (state) => {
      mp[kCurrentRoom] = mp.wrapRoom(state.meta);
    });

    // Add a handler to process a room property update.
    //
    //  * `eventName` - Plug.dj socket event name for the property.
    //  * `sockProp` - Property name of the new value on the plug.dj socket
    //        event parameter.
    //  * `roomProp` - Property name for the value on the miniplug room object.
    function addUpdateHandler (eventName, sockProp, roomProp) {
      mp.ws.on(eventName, (data, targetSlug) => {
        var user = mp.user(data.u) || mp.wrapUser({ id: data.u });
        var value = data[sockProp];

        debug$5(eventName, user && user.id, value);

        if (mp[kCurrentRoom] && mp[kCurrentRoom].slug === targetSlug) {
          mp[kCurrentRoom][roomProp] = value;
        }

        mp.emit(eventName, value, user);
        mp.emit('roomUpdate', {
          [roomProp]: value
        }, user);
      });
    }

    mp.on('connected', () => {
      addUpdateHandler('roomNameUpdate', 'n', 'name');
      addUpdateHandler('roomDescriptionUpdate', 'd', 'description');
      addUpdateHandler('roomWelcomeUpdate', 'w', 'welcome');
      addUpdateHandler('roomMinChatLevelUpdate', 'm', 'minChatLevel');
    });

    var room = () => mp[kCurrentRoom];

    var getRooms = (query, page, limit) =>
      {
        if ( query === void 0 ) query = '';
        if ( page === void 0 ) page = 0;
        if ( limit === void 0 ) limit = 50;

        return mp.get('rooms', { q: query, page, limit })
        .map(mp.wrapRoom);
    };
    var getFavorites = (query, page, limit) =>
      {
        if ( query === void 0 ) query = '';
        if ( page === void 0 ) page = 0;
        if ( limit === void 0 ) limit = 50;

        return mp.get('rooms/favorites', { q: query, page, limit })
        .map(mp.wrapRoom);
    };
    var createRoom = (name, isPrivate) =>
      {
        if ( isPrivate === void 0 ) isPrivate = false;

        return mp.post('rooms', { name: name, private: isPrivate }).get(0);
    };
    var getMyRooms = () =>
      mp.get('rooms/me').map(mp.wrapRoom);

    var favoriteRoom = (rid) =>
      mp.post('rooms/favorites', { id: rid });
    var unfavoriteRoom = (rid) =>
      mp.del(`rooms/favorites/${rid}`);
    var join = (slug) =>
      mp.post('rooms/join', { slug: slug })
        .then(getRoomState)
        .then(room); // Return the current Room instance.
    var getRoomState = () =>
      mp.get('rooms/state').get(0)
        .tap(mp.emit.bind(mp, 'roomState'));

    var updateRoom = (patch) => {
      if (!room()) {
        return Promise.reject(new Error('You are not currently in a room.'))
      }
      return mp.post('rooms/update', patch)
    };

    var setRoomWelcome = (welcome) => updateRoom({ welcome });
    var setRoomDescription = (description) => updateRoom({ description });
    var setRoomName = (name) => updateRoom({ name });
    var setRoomMinChatLevel = (minChatLevel) => updateRoom({ minChatLevel });

    var validateRoomName = (name) =>
      mp.get(`rooms/validate/${encodeURIComponent(name)}`)
        .get(0)
        .catch(() => Promise.reject(new Error('Room name unavailable.')));

    Object.assign(mp, {
      // local
      room,
      // remote
      getRooms,
      getFavorites,
      getMyRooms,
      createRoom,
      validateRoomName,
      setRoomWelcome,
      setRoomDescription,
      setRoomName,
      setRoomMinChatLevel,
      // favorites
      favoriteRoom,
      unfavoriteRoom,
      // joining
      join,
      getRoomState
    });
  }
}

function playlistsPlugin () {
  return (mp) => {
    mp.on('connected', () => {
      mp.ws.on('playlistCycle', (id) => {
        mp.emit('playlistCycle', id);
      });
    });

    Object.assign(mp, {
      getPlaylists: () =>
        mp.get('playlists').map(mp.wrapPlaylist),
      getActivePlaylist: () =>
        mp.get('playlists')
          .filter((playlist) => playlist.active)
          .get(0).then(mp.wrapPlaylist),
      createPlaylist: (name/*, initialMedia */) =>
        mp.post('playlists', { name: name }),
      deletePlaylist: (pid) =>
        mp.del(`playlists/${pid}`),
      activatePlaylist: (pid) =>
        mp.put(`playlists/${pid}/activate`),
      renamePlaylist: (pid, name) =>
        mp.put(`playlists/${pid}/rename`, { name: name }),
      shufflePlaylist: (pid) =>
        mp.put(`playlists/${pid}/shuffle`),

      getMedia: (pid) =>
        mp.get(`playlists/${pid}/media`).map(partial(mp.wrapMedia, pid)),
      updateMedia: (pid, mid, author, title) =>
        mp.put(`playlists/${pid}/media/update`, {
          id: mid,
          author: author,
          title: title
        }).get(0),
      moveMedia: (pid, mids, before) =>
        mp.put(`playlists/${pid}/media/move`, {
          ids: getIds(mids),
          beforeID: getId(before)
        }),
      insertMedia: (pid, media, append) =>
        {
          if ( append === void 0 ) append = true;

          return mp.post(`playlists/${pid}/media/insert`, {
          media: media,
          append: append
        });
    },
      deleteMedia: (pid, mids) =>
        mp.post(`playlists/${pid}/media/delete`, {
          ids: getIds(mids)
        })
    });
  }
}

function storePlugin () {
  return (mp) => {
    var getProducts = (type, category) =>
      {
        if ( category === void 0 ) category = 'all';

        return mp.get(`store/products/${type}/${category}`).map(mp.wrapStoreProduct);
    };
    var getStoreAvatars = partial(getProducts, 'avatars');
    var getStoreBadges = partial(getProducts, 'badges');
    var getStoreMisc = partial(getProducts, 'misc');

    var getInventory = (type) =>
      mp.get(`store/inventory/${type}`).map(mp.wrapInventoryProduct);
    var getOwnedAvatars = partial(getInventory, 'avatars');
    var getOwnedBadges = partial(getInventory, 'badges');

    var purchase = (product) =>
      mp.post('store/purchase', { id: getId(product) }).get(0);

    var getNameChangeProductId = () =>
      getStoreMisc('username').get(0).get('id');
    var purchaseNameChange = (username) =>
      Promise.props({
        id: getNameChangeProductId(),
        username
      }).then(
        partial(mp.post, 'store/purchase/username')
      );

    Object.assign(mp, {
      getProducts,
      getStoreAvatars,
      getStoreBadges,
      getStoreMisc,
      getInventory,
      getOwnedAvatars,
      getOwnedBadges,
      purchase,
      purchaseNameChange
    });
  }
}

function systemPlugin () {
  return (mp) => {
    function onMessage (text) {
      mp.emit('systemMessage', text);
    }

    function onMaintenanceAlert (minutesLeft) {
      mp.emit('maintenanceAlert', minutesLeft);
    }

    function onMaintenance () {
      mp.emit('maintenance');
    }

    function onUpdate () {
      mp.emit('systemUpdate');
    }

    mp.on('connected', () => {
      mp.ws.on('plugMessage', onMessage);
      mp.ws.on('plugMaintenanceAlert', onMaintenanceAlert);
      mp.ws.on('plugMaintenance', onMaintenance);
      mp.ws.on('plugUpdate', onUpdate);
    });
  }
}

var kVoteStats = Symbol('Votes');
var kGrabs = Symbol('Grabs');

function votePlugin (opts) {
  if ( opts === void 0 ) opts = {};

  return function (mp) {
    mp[kVoteStats] = [];
    mp[kGrabs] = [];

    mp.on('advance', () => {
      mp[kVoteStats] = [];
      mp[kGrabs] = [];
    });

    function onVote (ref) {
      var i = ref.i;
      var v = ref.v;

      mp[kVoteStats].push({
        uid: i,
        vote: v
      });
      var user = mp.user(i) || mp.wrapUser({ id: i });
      mp.emit('vote', {
        user,
        vote: v
      });
    }

    function onGrab (uid) {
      mp[kGrabs].push(uid);
      var user = mp.user(uid) || mp.wrapUser({ id: uid });
      mp.emit('grab', user);
    }

    mp.on('connected', () => {
      mp.ws.on('vote', onVote);
      mp.ws.on('grab', onGrab);
    });

    mp.on('roomState', (state) => {
      mp[kGrabs] = Object.keys(state.grabs);
      mp[kVoteStats] = Object.keys(state.votes).map((uid) => ({
        uid,
        vote: state.votes[uid]
      }));
    });

    mp.score = () => {
      var map = mp[kVoteStats].reduce(
        (map, v) => Object.assign(map, { [v.uid]: v.vote }),
        {}
      );
      var positive = 0;
      var negative = 0;
      Object.keys(map).forEach((uid) => {
        if (map[uid] === 1) {
          positive++;
        } else if (map[uid] === -1) {
          negative++;
        }
      });
      return {
        positive,
        negative,
        grabs: mp[kGrabs].length,
        listeners: mp.users().length + mp.guests()
      }
    };

    var vote = (direction) =>
      mp.post('votes', {
        historyID: mp.historyEntry().id,
        direction: direction
      });

    Object.assign(mp, {
      grab: (targetPlaylist, hid) =>
        mp.post('grabs', { playlistID: targetPlaylist, historyID: hid }).get(0),

      vote,

      woot: partial(vote, 1),
      meh: partial(vote, -1)
    });
  }
}

// Exports

Object.assign(miniplug, {
  httpPlugin,
  connectPlugin,
  usersPlugin,
  ignoresPlugin,
  mutesPlugin,
  bansPlugin,
  notificationsPlugin,
  boothPlugin,
  waitlistPlugin,
  waitlistBansPlugin,
  historyPlugin,
  chatPlugin,
  friendsPlugin,
  roomsPlugin,
  playlistsPlugin,
  storePlugin,
  systemPlugin,
  votePlugin
}, constants, errorClasses);

// Implementation

var Agent$1 = https.Agent;
var debug$6 = createDebug('miniplug:miniplug');
var defaultOptions = {
  host: 'https://plug.dj'
};

function miniplug (opts) {
  if ( opts === void 0 ) opts = {};

  // Faux-inherit from EventEmitter.
  var emitter = new EventEmitter();
  emitter.setMaxListeners(100);
  var mp = Object.create(emitter);

  opts = Object.assign({}, defaultOptions,
    opts);

  if (typeof opts.agent === 'undefined') {
    opts.agent = new Agent$1({ keepAlive: true });
  }

  // trim trailing slashes
  var plugHost = opts.host.replace(/\/+$/, '');

  mp.on('login', () => debug$6('authenticated'));
  mp.on('connected', () => debug$6('connected'));

  // Super-Duper Advanced Plugin API
  function use (plugin) {
    plugin(mp);
    return mp
  }

  // make miniplug!
  mp.use = use;

  use(dataModelPlugin());
  use(httpPlugin({
    host: plugHost,
    agent: opts.agent,
    // This is the same backoff as used in Sooyou/plugged:
    // https://github.com/SooYou/plugged/blob/856bd0ef47307491c0ad95cba7006cd4721828fd/query.js#L4
    // And that seems pretty robust.
    backoff: linearPromiseBackoffQueue({ increment: 200, max: 2200, Promise })
  }));
  use(connectPlugin({
    host: plugHost,
    agent: opts.agent
  }));
  use(usersPlugin());
  use(ignoresPlugin());
  use(mutesPlugin());
  use(bansPlugin());
  use(notificationsPlugin());
  use(boothPlugin());
  use(waitlistPlugin());
  use(waitlistBansPlugin());
  use(historyPlugin());
  use(chatPlugin({
    backoff: linearPromiseBackoffQueue({ increment: 70, max: 700, Promise })
  }));
  use(friendsPlugin());
  use(roomsPlugin());
  use(playlistsPlugin());
  use(storePlugin());
  use(systemPlugin());
  use(votePlugin());

  // Misc
  Object.assign(mp, {
    // REST: News APIs
    getNews: partial(mp.get, 'news')
  });

  return mp
}

export default miniplug;
//# sourceMappingURL=index.mjs.map