@twilio/conversations 2.0.0-rc.3 → 2.0.1-canary.2

package/{dist → builds}/twilio-conversations.js

@@ -1833,11 +1833,11 @@ this.Twilio.Conversations = (function (exports) {
 	var wellKnownSymbol$l = wellKnownSymbol$s;
 
 	var TO_STRING_TAG$3 = wellKnownSymbol$l('toStringTag');
-	var test$2 = {};
+	var test$1 = {};
 
-	test$2[TO_STRING_TAG$3] = 'z';
+	test$1[TO_STRING_TAG$3] = 'z';
 
-	var toStringTagSupport = String(test$2) === '[object z]';
+	var toStringTagSupport = String(test$1) === '[object z]';
 
 	var TO_STRING_TAG_SUPPORT$2 = toStringTagSupport;
 	var classofRaw = classofRaw$1;
@@ -5018,7 +5018,7 @@ this.Twilio.Conversations = (function (exports) {
 	var toObject$8 = toObject$g;
 
 	var floor$6 = Math.floor;
-	var replace$2 = ''.replace;
+	var replace$1 = ''.replace;
 	var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g;
 	var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g;
 
@@ -5032,7 +5032,7 @@ this.Twilio.Conversations = (function (exports) {
 	    namedCaptures = toObject$8(namedCaptures);
 	    symbols = SUBSTITUTION_SYMBOLS;
 	  }
-	  return replace$2.call(replacement, symbols, function (match, ch) {
+	  return replace$1.call(replacement, symbols, function (match, ch) {
 	    var capture;
 	    switch (ch.charAt(0)) {
 	      case '$': return '$';
@@ -5224,1092 +5224,12 @@ this.Twilio.Conversations = (function (exports) {
 	  }
 	});
 
-	var rfc6902 = {};
-
-	var pointer = {};
-
-	Object.defineProperty(pointer, "__esModule", {
-	  value: true
-	});
-	pointer.Pointer = void 0;
-	/**
-	Unescape token part of a JSON Pointer string
-
-	`token` should *not* contain any '/' characters.
-
-	> Evaluation of each reference token begins by decoding any escaped
-	> character sequence.  This is performed by first transforming any
-	> occurrence of the sequence '~1' to '/', and then transforming any
-	> occurrence of the sequence '~0' to '~'.  By performing the
-	> substitutions in this order, an implementation avoids the error of
-	> turning '~01' first into '~1' and then into '/', which would be
-	> incorrect (the string '~01' correctly becomes '~1' after
-	> transformation).
-
-	Here's my take:
-
-	~1 is unescaped with higher priority than ~0 because it is a lower-order escape character.
-	I say "lower order" because '/' needs escaping due to the JSON Pointer serialization technique.
-	Whereas, '~' is escaped because escaping '/' uses the '~' character.
-	*/
-
-	function unescape(token) {
-	  return token.replace(/~1/g, '/').replace(/~0/g, '~');
-	}
-	/** Escape token part of a JSON Pointer string
-
-	> '~' needs to be encoded as '~0' and '/'
-	> needs to be encoded as '~1' when these characters appear in a
-	> reference token.
-
-	This is the exact inverse of `unescape()`, so the reverse replacements must take place in reverse order.
-	*/
-
-
-	function escape(token) {
-	  return token.replace(/~/g, '~0').replace(/\//g, '~1');
-	}
-	/**
-	JSON Pointer representation
-	*/
-
-
-	var Pointer =
-	/** @class */
-	function () {
-	  function Pointer(tokens) {
-	    if (tokens === void 0) {
-	      tokens = [''];
-	    }
-
-	    this.tokens = tokens;
-	  }
-	  /**
-	  `path` *must* be a properly escaped string.
-	  */
-
-
-	  Pointer.fromJSON = function (path) {
-	    var tokens = path.split('/').map(unescape);
-	    if (tokens[0] !== '') throw new Error("Invalid JSON Pointer: " + path);
-	    return new Pointer(tokens);
-	  };
-
-	  Pointer.prototype.toString = function () {
-	    return this.tokens.map(escape).join('/');
-	  };
-	  /**
-	  Returns an object with 'parent', 'key', and 'value' properties.
-	  In the special case that this Pointer's path == "",
-	  this object will be {parent: null, key: '', value: object}.
-	  Otherwise, parent and key will have the property such that parent[key] == value.
-	  */
-
-
-	  Pointer.prototype.evaluate = function (object) {
-	    var parent = null;
-	    var key = '';
-	    var value = object;
-
-	    for (var i = 1, l = this.tokens.length; i < l; i++) {
-	      parent = value;
-	      key = this.tokens[i]; // not sure if this the best way to handle non-existant paths...
-
-	      value = (parent || {})[key];
-	    }
-
-	    return {
-	      parent: parent,
-	      key: key,
-	      value: value
-	    };
-	  };
-
-	  Pointer.prototype.get = function (object) {
-	    return this.evaluate(object).value;
-	  };
-
-	  Pointer.prototype.set = function (object, value) {
-	    var cursor = object;
-
-	    for (var i = 1, l = this.tokens.length - 1, token = this.tokens[i]; i < l; i++) {
-	      // not sure if this the best way to handle non-existant paths...
-	      cursor = (cursor || {})[token];
-	    }
-
-	    if (cursor) {
-	      cursor[this.tokens[this.tokens.length - 1]] = value;
-	    }
-	  };
-
-	  Pointer.prototype.push = function (token) {
-	    // mutable
-	    this.tokens.push(token);
-	  };
-	  /**
-	  `token` should be a String. It'll be coerced to one anyway.
-	     immutable (shallowly)
-	  */
-
-
-	  Pointer.prototype.add = function (token) {
-	    var tokens = this.tokens.concat(String(token));
-	    return new Pointer(tokens);
-	  };
-
-	  return Pointer;
-	}();
-
-	pointer.Pointer = Pointer;
-
-	var patch = {};
-
-	var util = {};
-
-	(function (exports) {
-
-	  Object.defineProperty(exports, "__esModule", {
-	    value: true
-	  });
-	  exports.clone = exports.objectType = exports.hasOwnProperty = void 0;
-	  exports.hasOwnProperty = Object.prototype.hasOwnProperty;
-
-	  function objectType(object) {
-	    if (object === undefined) {
-	      return 'undefined';
-	    }
-
-	    if (object === null) {
-	      return 'null';
-	    }
-
-	    if (Array.isArray(object)) {
-	      return 'array';
-	    }
-
-	    return _typeof$4(object);
-	  }
-
-	  exports.objectType = objectType;
-	  /**
-	  Recursively copy a value.
-	  
-	  @param source - should be a JavaScript primitive, Array, or (plain old) Object.
-	  @returns copy of source where every Array and Object have been recursively
-	           reconstructed from their constituent elements
-	  */
-
-	  function clone(source) {
-	    // loose-equality checking for null is faster than strict checking for each of null/undefined/true/false
-	    // checking null first, then calling typeof, is faster than vice-versa
-	    if (source == null || _typeof$4(source) != 'object') {
-	      // short-circuiting is faster than a single return
-	      return source;
-	    } // x.constructor == Array is the fastest way to check if x is an Array
-
-
-	    if (source.constructor == Array) {
-	      // construction via imperative for-loop is faster than source.map(arrayVsObject)
-	      var length_1 = source.length; // setting the Array length during construction is faster than just `[]` or `new Array()`
-
-	      var arrayTarget = new Array(length_1);
-
-	      for (var i = 0; i < length_1; i++) {
-	        arrayTarget[i] = clone(source[i]);
-	      }
-
-	      return arrayTarget;
-	    } // Object
-
-
-	    var objectTarget = {}; // declaring the variable (with const) inside the loop is faster
-
-	    for (var key in source) {
-	      // hasOwnProperty costs a bit of performance, but it's semantically necessary
-	      // using a global helper is MUCH faster than calling source.hasOwnProperty(key)
-	      if (exports.hasOwnProperty.call(source, key)) {
-	        objectTarget[key] = clone(source[key]);
-	      }
-	    }
-
-	    return objectTarget;
-	  }
-
-	  exports.clone = clone;
-	})(util);
-
-	var equal = {};
-
-	Object.defineProperty(equal, "__esModule", {
-	  value: true
-	});
-	equal.compare = void 0;
-	var util_1$2 = util;
-	/**
-	Evaluate `left === right`, treating `left` and `right` as ordered lists.
-
-	@returns true iff `left` and `right` have identical lengths, and every element
-	         of `left` is equal to the corresponding element of `right`. Equality is
-	         determined recursivly, via `compare`.
-	*/
-
-	function compareArrays(left, right) {
-	  var length = left.length;
-
-	  if (length !== right.length) {
-	    return false;
-	  }
-
-	  for (var i = 0; i < length; i++) {
-	    if (!compare(left[i], right[i])) {
-	      return false;
-	    }
-	  }
-
-	  return true;
-	}
-	/**
-	Evaluate `left === right`, treating `left` and `right` as property maps.
-
-	@returns true iff every property in `left` has a value equal to the value of the
-	         corresponding property in `right`, and vice-versa, stopping as soon as
-	         possible. Equality is determined recursivly, via `compare`.
-	*/
-
-
-	function compareObjects(left, right) {
-	  var left_keys = Object.keys(left);
-	  var right_keys = Object.keys(right);
-	  var length = left_keys.length; // quick exit if the number of keys don't match up
-
-	  if (length !== right_keys.length) {
-	    return false;
-	  } // we don't know for sure that Set(left_keys) is equal to Set(right_keys),
-	  // much less that their values in left and right are equal, but if right
-	  // contains each key in left, we know it can't have any additional keys
-
-
-	  for (var i = 0; i < length; i++) {
-	    var key = left_keys[i];
-
-	    if (!util_1$2.hasOwnProperty.call(right, key) || !compare(left[key], right[key])) {
-	      return false;
-	    }
-	  }
-
-	  return true;
-	}
-	/**
-	`compare()` returns true if `left` and `right` are materially equal
-	(i.e., would produce equivalent JSON), false otherwise.
-
-	> Here, "equal" means that the value at the target location and the
-	> value conveyed by "value" are of the same JSON type, and that they
-	> are considered equal by the following rules for that type:
-	> o  strings: are considered equal if they contain the same number of
-	>    Unicode characters and their code points are byte-by-byte equal.
-	> o  numbers: are considered equal if their values are numerically
-	>    equal.
-	> o  arrays: are considered equal if they contain the same number of
-	>    values, and if each value can be considered equal to the value at
-	>    the corresponding position in the other array, using this list of
-	>    type-specific rules.
-	> o  objects: are considered equal if they contain the same number of
-	>    members, and if each member can be considered equal to a member in
-	>    the other object, by comparing their keys (as strings) and their
-	>    values (using this list of type-specific rules).
-	> o  literals (false, true, and null): are considered equal if they are
-	>    the same.
-	*/
-
-
-	function compare(left, right) {
-	  // strict equality handles literals, numbers, and strings (a sufficient but not necessary cause)
-	  if (left === right) {
-	    return true;
-	  }
-
-	  var left_type = util_1$2.objectType(left);
-	  var right_type = util_1$2.objectType(right); // check arrays
-
-	  if (left_type == 'array' && right_type == 'array') {
-	    return compareArrays(left, right);
-	  } // check objects
-
-
-	  if (left_type == 'object' && right_type == 'object') {
-	    return compareObjects(left, right);
-	  } // mismatched arrays & objects, etc., are always inequal
-
-
-	  return false;
-	}
-
-	equal.compare = compare;
-
-	var __extends = commonjsGlobal && commonjsGlobal.__extends || function () {
-	  var _extendStatics = function extendStatics(d, b) {
-	    _extendStatics = Object.setPrototypeOf || {
-	      __proto__: []
-	    } instanceof Array && function (d, b) {
-	      d.__proto__ = b;
-	    } || function (d, b) {
-	      for (var p in b) {
-	        if (b.hasOwnProperty(p)) d[p] = b[p];
-	      }
-	    };
-
-	    return _extendStatics(d, b);
-	  };
-
-	  return function (d, b) {
-	    _extendStatics(d, b);
-
-	    function __() {
-	      this.constructor = d;
-	    }
-
-	    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-	  };
-	}();
-
-	Object.defineProperty(patch, "__esModule", {
-	  value: true
-	});
-	patch.apply = patch.InvalidOperationError = patch.test = patch.copy = patch.move = patch.replace = patch.remove = patch.add = patch.TestError = patch.MissingError = void 0;
-	var pointer_1$1 = pointer;
-	var util_1$1 = util;
-	var equal_1$1 = equal;
-
-	var MissingError =
-	/** @class */
-	function (_super) {
-	  __extends(MissingError, _super);
-
-	  function MissingError(path) {
-	    var _this = _super.call(this, "Value required at path: " + path) || this;
-
-	    _this.path = path;
-	    _this.name = 'MissingError';
-	    return _this;
-	  }
-
-	  return MissingError;
-	}(Error);
-
-	patch.MissingError = MissingError;
-
-	var TestError =
-	/** @class */
-	function (_super) {
-	  __extends(TestError, _super);
-
-	  function TestError(actual, expected) {
-	    var _this = _super.call(this, "Test failed: " + actual + " != " + expected) || this;
-
-	    _this.actual = actual;
-	    _this.expected = expected;
-	    _this.name = 'TestError';
-	    return _this;
-	  }
-
-	  return TestError;
-	}(Error);
-
-	patch.TestError = TestError;
-
-	function _add(object, key, value) {
-	  if (Array.isArray(object)) {
-	    // `key` must be an index
-	    if (key == '-') {
-	      object.push(value);
-	    } else {
-	      var index = parseInt(key, 10);
-	      object.splice(index, 0, value);
-	    }
-	  } else {
-	    object[key] = value;
-	  }
-	}
-
-	function _remove(object, key) {
-	  if (Array.isArray(object)) {
-	    // '-' syntax doesn't make sense when removing
-	    var index = parseInt(key, 10);
-	    object.splice(index, 1);
-	  } else {
-	    // not sure what the proper behavior is when path = ''
-	    delete object[key];
-	  }
-	}
-	/**
-	>  o  If the target location specifies an array index, a new value is
-	>     inserted into the array at the specified index.
-	>  o  If the target location specifies an object member that does not
-	>     already exist, a new member is added to the object.
-	>  o  If the target location specifies an object member that does exist,
-	>     that member's value is replaced.
-	*/
-
-
-	function add(object, operation) {
-	  var endpoint = pointer_1$1.Pointer.fromJSON(operation.path).evaluate(object); // it's not exactly a "MissingError" in the same way that `remove` is -- more like a MissingParent, or something
-
-	  if (endpoint.parent === undefined) {
-	    return new MissingError(operation.path);
-	  }
-
-	  _add(endpoint.parent, endpoint.key, util_1$1.clone(operation.value));
-
-	  return null;
-	}
-
-	patch.add = add;
-	/**
-	> The "remove" operation removes the value at the target location.
-	> The target location MUST exist for the operation to be successful.
-	*/
-
-	function remove(object, operation) {
-	  // endpoint has parent, key, and value properties
-	  var endpoint = pointer_1$1.Pointer.fromJSON(operation.path).evaluate(object);
-
-	  if (endpoint.value === undefined) {
-	    return new MissingError(operation.path);
-	  } // not sure what the proper behavior is when path = ''
-
-
-	  _remove(endpoint.parent, endpoint.key);
-
-	  return null;
-	}
-
-	patch.remove = remove;
-	/**
-	> The "replace" operation replaces the value at the target location
-	> with a new value.  The operation object MUST contain a "value" member
-	> whose content specifies the replacement value.
-	> The target location MUST exist for the operation to be successful.
-
-	> This operation is functionally identical to a "remove" operation for
-	> a value, followed immediately by an "add" operation at the same
-	> location with the replacement value.
-
-	Even more simply, it's like the add operation with an existence check.
-	*/
-
-	function replace$1(object, operation) {
-	  var endpoint = pointer_1$1.Pointer.fromJSON(operation.path).evaluate(object);
-
-	  if (endpoint.parent === null) {
-	    return new MissingError(operation.path);
-	  } // this existence check treats arrays as a special case
-
-
-	  if (Array.isArray(endpoint.parent)) {
-	    if (parseInt(endpoint.key, 10) >= endpoint.parent.length) {
-	      return new MissingError(operation.path);
-	    }
-	  } else if (endpoint.value === undefined) {
-	    return new MissingError(operation.path);
-	  }
-
-	  endpoint.parent[endpoint.key] = operation.value;
-	  return null;
-	}
-
-	patch.replace = replace$1;
-	/**
-	> The "move" operation removes the value at a specified location and
-	> adds it to the target location.
-	> The operation object MUST contain a "from" member, which is a string
-	> containing a JSON Pointer value that references the location in the
-	> target document to move the value from.
-	> This operation is functionally identical to a "remove" operation on
-	> the "from" location, followed immediately by an "add" operation at
-	> the target location with the value that was just removed.
-
-	> The "from" location MUST NOT be a proper prefix of the "path"
-	> location; i.e., a location cannot be moved into one of its children.
-
-	TODO: throw if the check described in the previous paragraph fails.
-	*/
-
-	function move(object, operation) {
-	  var from_endpoint = pointer_1$1.Pointer.fromJSON(operation.from).evaluate(object);
-
-	  if (from_endpoint.value === undefined) {
-	    return new MissingError(operation.from);
-	  }
-
-	  var endpoint = pointer_1$1.Pointer.fromJSON(operation.path).evaluate(object);
-
-	  if (endpoint.parent === undefined) {
-	    return new MissingError(operation.path);
-	  }
-
-	  _remove(from_endpoint.parent, from_endpoint.key);
-
-	  _add(endpoint.parent, endpoint.key, from_endpoint.value);
-
-	  return null;
-	}
-
-	patch.move = move;
-	/**
-	> The "copy" operation copies the value at a specified location to the
-	> target location.
-	> The operation object MUST contain a "from" member, which is a string
-	> containing a JSON Pointer value that references the location in the
-	> target document to copy the value from.
-	> The "from" location MUST exist for the operation to be successful.
-
-	> This operation is functionally identical to an "add" operation at the
-	> target location using the value specified in the "from" member.
-
-	Alternatively, it's like 'move' without the 'remove'.
-	*/
-
-	function copy(object, operation) {
-	  var from_endpoint = pointer_1$1.Pointer.fromJSON(operation.from).evaluate(object);
-
-	  if (from_endpoint.value === undefined) {
-	    return new MissingError(operation.from);
-	  }
-
-	  var endpoint = pointer_1$1.Pointer.fromJSON(operation.path).evaluate(object);
-
-	  if (endpoint.parent === undefined) {
-	    return new MissingError(operation.path);
-	  }
-
-	  _add(endpoint.parent, endpoint.key, util_1$1.clone(from_endpoint.value));
-
-	  return null;
-	}
-
-	patch.copy = copy;
-	/**
-	> The "test" operation tests that a value at the target location is
-	> equal to a specified value.
-	> The operation object MUST contain a "value" member that conveys the
-	> value to be compared to the target location's value.
-	> The target location MUST be equal to the "value" value for the
-	> operation to be considered successful.
-	*/
-
-	function test$1(object, operation) {
-	  var endpoint = pointer_1$1.Pointer.fromJSON(operation.path).evaluate(object);
-	  var result = equal_1$1.compare(endpoint.value, operation.value);
-
-	  if (!result) {
-	    return new TestError(endpoint.value, operation.value);
-	  }
-
-	  return null;
-	}
-
-	patch.test = test$1;
-
-	var InvalidOperationError =
-	/** @class */
-	function (_super) {
-	  __extends(InvalidOperationError, _super);
-
-	  function InvalidOperationError(operation) {
-	    var _this = _super.call(this, "Invalid operation: " + operation.op) || this;
-
-	    _this.operation = operation;
-	    _this.name = 'InvalidOperationError';
-	    return _this;
-	  }
-
-	  return InvalidOperationError;
-	}(Error);
-
-	patch.InvalidOperationError = InvalidOperationError;
-	/**
-	Switch on `operation.op`, applying the corresponding patch function for each
-	case to `object`.
-	*/
-
-	function apply(object, operation) {
-	  // not sure why TypeScript can't infer typesafety of:
-	  //   {add, remove, replace, move, copy, test}[operation.op](object, operation)
-	  // (seems like a bug)
-	  switch (operation.op) {
-	    case 'add':
-	      return add(object, operation);
-
-	    case 'remove':
-	      return remove(object, operation);
-
-	    case 'replace':
-	      return replace$1(object, operation);
-
-	    case 'move':
-	      return move(object, operation);
-
-	    case 'copy':
-	      return copy(object, operation);
-
-	    case 'test':
-	      return test$1(object, operation);
-	  }
-
-	  return new InvalidOperationError(operation);
-	}
-
-	patch.apply = apply;
-
-	var diff = {};
-
-	Object.defineProperty(diff, "__esModule", {
-	  value: true
-	});
-	diff.diffAny = diff.diffObjects = diff.diffArrays = diff.intersection = diff.subtract = diff.isDestructive = void 0;
-	var equal_1 = equal;
-	var util_1 = util;
-
-	function isDestructive(_a) {
-	  var op = _a.op;
-	  return op === 'remove' || op === 'replace' || op === 'copy' || op === 'move';
-	}
-
-	diff.isDestructive = isDestructive;
-	/**
-	List the keys in `minuend` that are not in `subtrahend`.
-
-	A key is only considered if it is both 1) an own-property (o.hasOwnProperty(k))
-	of the object, and 2) has a value that is not undefined. This is to match JSON
-	semantics, where JSON object serialization drops keys with undefined values.
-
-	@param minuend Object of interest
-	@param subtrahend Object of comparison
-	@returns Array of keys that are in `minuend` but not in `subtrahend`.
-	*/
-
-	function subtract(minuend, subtrahend) {
-	  // initialize empty object; we only care about the keys, the values can be anything
-	  var obj = {}; // build up obj with all the properties of minuend
-
-	  for (var add_key in minuend) {
-	    if (util_1.hasOwnProperty.call(minuend, add_key) && minuend[add_key] !== undefined) {
-	      obj[add_key] = 1;
-	    }
-	  } // now delete all the properties of subtrahend from obj
-	  // (deleting a missing key has no effect)
-
-
-	  for (var del_key in subtrahend) {
-	    if (util_1.hasOwnProperty.call(subtrahend, del_key) && subtrahend[del_key] !== undefined) {
-	      delete obj[del_key];
-	    }
-	  } // finally, extract whatever keys remain in obj
-
-
-	  return Object.keys(obj);
-	}
-
-	diff.subtract = subtract;
-	/**
-	List the keys that shared by all `objects`.
-
-	The semantics of what constitutes a "key" is described in {@link subtract}.
-
-	@param objects Array of objects to compare
-	@returns Array of keys that are in ("own-properties" of) every object in `objects`.
-	*/
-
-	function intersection(objects) {
-	  var length = objects.length; // prepare empty counter to keep track of how many objects each key occurred in
-
-	  var counter = {}; // go through each object and increment the counter for each key in that object
-
-	  for (var i = 0; i < length; i++) {
-	    var object = objects[i];
-
-	    for (var key in object) {
-	      if (util_1.hasOwnProperty.call(object, key) && object[key] !== undefined) {
-	        counter[key] = (counter[key] || 0) + 1;
-	      }
-	    }
-	  } // now delete all keys from the counter that were not seen in every object
-
-
-	  for (var key in counter) {
-	    if (counter[key] < length) {
-	      delete counter[key];
-	    }
-	  } // finally, extract whatever keys remain in the counter
-
-
-	  return Object.keys(counter);
-	}
-
-	diff.intersection = intersection;
-
-	function isArrayAdd(array_operation) {
-	  return array_operation.op === 'add';
-	}
-
-	function isArrayRemove(array_operation) {
-	  return array_operation.op === 'remove';
-	}
-
-	function appendArrayOperation(base, operation) {
-	  return {
-	    // the new operation must be pushed on the end
-	    operations: base.operations.concat(operation),
-	    cost: base.cost + 1
-	  };
-	}
-	/**
-	Calculate the shortest sequence of operations to get from `input` to `output`,
-	using a dynamic programming implementation of the Levenshtein distance algorithm.
-
-	To get from the input ABC to the output AZ we could just delete all the input
-	and say "insert A, insert Z" and be done with it. That's what we do if the
-	input is empty. But we can be smarter.
-
-	          output
-	               A   Z
-	               -   -
-	          [0]  1   2
-	input A |  1  [0]  1
-	      B |  2  [1]  1
-	      C |  3   2  [2]
-
-	1) start at 0,0 (+0)
-	2) keep A (+0)
-	3) remove B (+1)
-	4) replace C with Z (+1)
-
-	If the `input` (source) is empty, they'll all be in the top row, resulting in an
-	array of 'add' operations.
-	If the `output` (target) is empty, everything will be in the left column,
-	resulting in an array of 'remove' operations.
-
-	@returns A list of add/remove/replace operations.
-	*/
-
-
-	function diffArrays(input, output, ptr, diff) {
-	  if (diff === void 0) {
-	    diff = diffAny;
-	  } // set up cost matrix (very simple initialization: just a map)
-
-
-	  var memo = {
-	    '0,0': {
-	      operations: [],
-	      cost: 0
-	    }
-	  };
-	  /**
-	  Calculate the cheapest sequence of operations required to get from
-	  input.slice(0, i) to output.slice(0, j).
-	  There may be other valid sequences with the same cost, but none cheaper.
-	     @param i The row in the layout above
-	  @param j The column in the layout above
-	  @returns An object containing a list of operations, along with the total cost
-	           of applying them (+1 for each add/remove/replace operation)
-	  */
-
-	  function dist(i, j) {
-	    // memoized
-	    var memo_key = i + "," + j;
-	    var memoized = memo[memo_key];
-
-	    if (memoized === undefined) {
-	      if (i > 0 && j > 0 && equal_1.compare(input[i - 1], output[j - 1])) {
-	        // equal (no operations => no cost)
-	        memoized = dist(i - 1, j - 1);
-	      } else {
-	        var alternatives = [];
-
-	        if (i > 0) {
-	          // NOT topmost row
-	          var remove_base = dist(i - 1, j);
-	          var remove_operation = {
-	            op: 'remove',
-	            index: i - 1
-	          };
-	          alternatives.push(appendArrayOperation(remove_base, remove_operation));
-	        }
-
-	        if (j > 0) {
-	          // NOT leftmost column
-	          var add_base = dist(i, j - 1);
-	          var add_operation = {
-	            op: 'add',
-	            index: i - 1,
-	            value: output[j - 1]
-	          };
-	          alternatives.push(appendArrayOperation(add_base, add_operation));
-	        }
-
-	        if (i > 0 && j > 0) {
-	          // TABLE MIDDLE
-	          // supposing we replaced it, compute the rest of the costs:
-	          var replace_base = dist(i - 1, j - 1); // okay, the general plan is to replace it, but we can be smarter,
-	          // recursing into the structure and replacing only part of it if
-	          // possible, but to do so we'll need the original value
-
-	          var replace_operation = {
-	            op: 'replace',
-	            index: i - 1,
-	            original: input[i - 1],
-	            value: output[j - 1]
-	          };
-	          alternatives.push(appendArrayOperation(replace_base, replace_operation));
-	        } // the only other case, i === 0 && j === 0, has already been memoized
-	        // the meat of the algorithm:
-	        // sort by cost to find the lowest one (might be several ties for lowest)
-	        // [4, 6, 7, 1, 2].sort((a, b) => a - b) -> [ 1, 2, 4, 6, 7 ]
-
-
-	        var best = alternatives.sort(function (a, b) {
-	          return a.cost - b.cost;
-	        })[0];
-	        memoized = best;
-	      }
-
-	      memo[memo_key] = memoized;
-	    }
-
-	    return memoized;
-	  } // handle weird objects masquerading as Arrays that don't have proper length
-	  // properties by using 0 for everything but positive numbers
-
-
-	  var input_length = isNaN(input.length) || input.length <= 0 ? 0 : input.length;
-	  var output_length = isNaN(output.length) || output.length <= 0 ? 0 : output.length;
-	  var array_operations = dist(input_length, output_length).operations;
-	  var padded_operations = array_operations.reduce(function (_a, array_operation) {
-	    var operations = _a[0],
-	        padding = _a[1];
-
-	    if (isArrayAdd(array_operation)) {
-	      var padded_index = array_operation.index + 1 + padding;
-	      var index_token = padded_index < input_length + padding ? String(padded_index) : '-';
-	      var operation = {
-	        op: array_operation.op,
-	        path: ptr.add(index_token).toString(),
-	        value: array_operation.value
-	      }; // padding++ // maybe only if array_operation.index > -1 ?
-
-	      return [operations.concat(operation), padding + 1];
-	    } else if (isArrayRemove(array_operation)) {
-	      var operation = {
-	        op: array_operation.op,
-	        path: ptr.add(String(array_operation.index + padding)).toString()
-	      }; // padding--
-
-	      return [operations.concat(operation), padding - 1];
-	    } else {
-	      // replace
-	      var replace_ptr = ptr.add(String(array_operation.index + padding));
-	      var replace_operations = diff(array_operation.original, array_operation.value, replace_ptr);
-	      return [operations.concat.apply(operations, replace_operations), padding];
-	    }
-	  }, [[], 0])[0];
-	  return padded_operations;
-	}
-
-	diff.diffArrays = diffArrays;
-
-	function diffObjects(input, output, ptr, diff) {
-	  if (diff === void 0) {
-	    diff = diffAny;
-	  } // if a key is in input but not output -> remove it
-
-
-	  var operations = [];
-	  subtract(input, output).forEach(function (key) {
-	    operations.push({
-	      op: 'remove',
-	      path: ptr.add(key).toString()
-	    });
-	  }); // if a key is in output but not input -> add it
-
-	  subtract(output, input).forEach(function (key) {
-	    operations.push({
-	      op: 'add',
-	      path: ptr.add(key).toString(),
-	      value: output[key]
-	    });
-	  }); // if a key is in both, diff it recursively
-
-	  intersection([input, output]).forEach(function (key) {
-	    operations.push.apply(operations, diff(input[key], output[key], ptr.add(key)));
-	  });
-	  return operations;
-	}
-
-	diff.diffObjects = diffObjects;
-	/**
-	`diffAny()` returns an empty array if `input` and `output` are materially equal
-	(i.e., would produce equivalent JSON); otherwise it produces an array of patches
-	that would transform `input` into `output`.
-	*/
-
-	function diffAny(input, output, ptr, diff) {
-	  if (diff === void 0) {
-	    diff = diffAny;
-	  } // strict equality handles literals, numbers, and strings (a sufficient but not necessary cause)
-
-
-	  if (input === output) {
-	    return [];
-	  }
-
-	  var input_type = util_1.objectType(input);
-	  var output_type = util_1.objectType(output);
-
-	  if (input_type == 'array' && output_type == 'array') {
-	    return diffArrays(input, output, ptr, diff);
-	  }
-
-	  if (input_type == 'object' && output_type == 'object') {
-	    return diffObjects(input, output, ptr, diff);
-	  } // at this point we know that input and output are materially different;
-	  // could be array -> object, object -> array, boolean -> undefined,
-	  // number -> string, or some other combination, but nothing that can be split
-	  // up into multiple patches: so `output` must replace `input` wholesale.
-
-
-	  return [{
-	    op: 'replace',
-	    path: ptr.toString(),
-	    value: output
-	  }];
-	}
-
-	diff.diffAny = diffAny;
-
-	Object.defineProperty(rfc6902, "__esModule", {
-	  value: true
-	});
-	rfc6902.createTests = createPatch_1 = rfc6902.createPatch = rfc6902.applyPatch = void 0;
-	var pointer_1 = pointer;
-	var patch_1 = patch;
-	var diff_1 = diff;
-	/**
-	Apply a 'application/json-patch+json'-type patch to an object.
-
-	`patch` *must* be an array of operations.
-
-	> Operation objects MUST have exactly one "op" member, whose value
-	> indicates the operation to perform.  Its value MUST be one of "add",
-	> "remove", "replace", "move", "copy", or "test"; other values are
-	> errors.
-
-	This method mutates the target object in-place.
-
-	@returns list of results, one for each operation: `null` indicated success,
-	         otherwise, the result will be an instance of one of the Error classes:
-	         MissingError, InvalidOperationError, or TestError.
-	*/
-
-	function applyPatch(object, patch) {
-	  return patch.map(function (operation) {
-	    return patch_1.apply(object, operation);
-	  });
-	}
-
-	rfc6902.applyPatch = applyPatch;
-
-	function wrapVoidableDiff(diff) {
-	  function wrappedDiff(input, output, ptr) {
-	    var custom_patch = diff(input, output, ptr); // ensure an array is always returned
-
-	    return Array.isArray(custom_patch) ? custom_patch : diff_1.diffAny(input, output, ptr, wrappedDiff);
-	  }
-
-	  return wrappedDiff;
-	}
-	/**
-	Produce a 'application/json-patch+json'-type patch to get from one object to
-	another.
-
-	This does not alter `input` or `output` unless they have a property getter with
-	side-effects (which is not a good idea anyway).
-
-	`diff` is called on each pair of comparable non-primitive nodes in the
-	`input`/`output` object trees, producing nested patches. Return `undefined`
-	to fall back to default behaviour.
-
-	Returns list of operations to perform on `input` to produce `output`.
-	*/
-
-
-	function createPatch(input, output, diff) {
-	  var ptr = new pointer_1.Pointer(); // a new Pointer gets a default path of [''] if not specified
-
-	  return (diff ? wrapVoidableDiff(diff) : diff_1.diffAny)(input, output, ptr);
-	}
-
-	var createPatch_1 = rfc6902.createPatch = createPatch;
-	/**
-	Create a test operation based on `input`'s current evaluation of the JSON
-	Pointer `path`; if such a pointer cannot be resolved, returns undefined.
-	*/
-
-	function createTest(input, path) {
-	  var endpoint = pointer_1.Pointer.fromJSON(path).evaluate(input);
-
-	  if (endpoint !== undefined) {
-	    return {
-	      op: 'test',
-	      path: path,
-	      value: endpoint.value
-	    };
-	  }
-	}
-	/**
-	Produce an 'application/json-patch+json'-type list of tests, to verify that
-	existing values in an object are identical to the those captured at some
-	checkpoint (whenever this function is called).
-
-	This does not alter `input` or `output` unless they have a property getter with
-	side-effects (which is not a good idea anyway).
-
-	Returns list of test operations.
-	*/
-
-
-	function createTests(input, patch) {
-	  var tests = new Array();
-	  patch.filter(diff_1.isDestructive).forEach(function (operation) {
-	    var pathTest = createTest(input, operation.path);
-	    if (pathTest) tests.push(pathTest);
-
-	    if ('from' in operation) {
-	      var fromTest = createTest(input, operation.from);
-	      if (fromTest) tests.push(fromTest);
-	    }
-	  });
-	  return tests;
-	}
-
-	rfc6902.createTests = createTests;
-
-	/**
-	 * Checks if objects are equal
-	 */
-
-	function isDeepEqual(o1, o2) {
-	  return createPatch_1(o1, o2).length === 0;
-	}
 	/**
 	 * Deep-clone an object. Note that this does not work on object containing
 	 * functions.
 	 * @param {object} obj - the object to deep-clone
 	 * @returns {object}
 	 */
-
-
 	function deepClone$1(obj) {
 	  return JSON.parse(JSON.stringify(obj));
 	}
@@ -8413,6 +7333,1926 @@ this.Twilio.Conversations = (function (exports) {
 
 	var ReplayEventEmitter_1 = browser$5.ReplayEventEmitter = ReplayEventEmitter;
 
+	var lodash_isequal = {exports: {}};
+
+	(function (module, exports) {
+	  /** Used as the size to enable large array optimizations. */
+	  var LARGE_ARRAY_SIZE = 200;
+	  /** Used to stand-in for `undefined` hash values. */
+
+	  var HASH_UNDEFINED = '__lodash_hash_undefined__';
+	  /** Used to compose bitmasks for value comparisons. */
+
+	  var COMPARE_PARTIAL_FLAG = 1,
+	      COMPARE_UNORDERED_FLAG = 2;
+	  /** Used as references for various `Number` constants. */
+
+	  var MAX_SAFE_INTEGER = 9007199254740991;
+	  /** `Object#toString` result references. */
+
+	  var argsTag = '[object Arguments]',
+	      arrayTag = '[object Array]',
+	      asyncTag = '[object AsyncFunction]',
+	      boolTag = '[object Boolean]',
+	      dateTag = '[object Date]',
+	      errorTag = '[object Error]',
+	      funcTag = '[object Function]',
+	      genTag = '[object GeneratorFunction]',
+	      mapTag = '[object Map]',
+	      numberTag = '[object Number]',
+	      nullTag = '[object Null]',
+	      objectTag = '[object Object]',
+	      promiseTag = '[object Promise]',
+	      proxyTag = '[object Proxy]',
+	      regexpTag = '[object RegExp]',
+	      setTag = '[object Set]',
+	      stringTag = '[object String]',
+	      symbolTag = '[object Symbol]',
+	      undefinedTag = '[object Undefined]',
+	      weakMapTag = '[object WeakMap]';
+	  var arrayBufferTag = '[object ArrayBuffer]',
+	      dataViewTag = '[object DataView]',
+	      float32Tag = '[object Float32Array]',
+	      float64Tag = '[object Float64Array]',
+	      int8Tag = '[object Int8Array]',
+	      int16Tag = '[object Int16Array]',
+	      int32Tag = '[object Int32Array]',
+	      uint8Tag = '[object Uint8Array]',
+	      uint8ClampedTag = '[object Uint8ClampedArray]',
+	      uint16Tag = '[object Uint16Array]',
+	      uint32Tag = '[object Uint32Array]';
+	  /**
+	   * Used to match `RegExp`
+	   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+	   */
+
+	  var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+	  /** Used to detect host constructors (Safari). */
+
+	  var reIsHostCtor = /^\[object .+?Constructor\]$/;
+	  /** Used to detect unsigned integer values. */
+
+	  var reIsUint = /^(?:0|[1-9]\d*)$/;
+	  /** Used to identify `toStringTag` values of typed arrays. */
+
+	  var typedArrayTags = {};
+	  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+	  typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
+	  /** Detect free variable `global` from Node.js. */
+
+	  var freeGlobal = _typeof$4(commonjsGlobal) == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+	  /** Detect free variable `self`. */
+
+	  var freeSelf = (typeof self === "undefined" ? "undefined" : _typeof$4(self)) == 'object' && self && self.Object === Object && self;
+	  /** Used as a reference to the global object. */
+
+	  var root = freeGlobal || freeSelf || Function('return this')();
+	  /** Detect free variable `exports`. */
+
+	  var freeExports = exports && !exports.nodeType && exports;
+	  /** Detect free variable `module`. */
+
+	  var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;
+	  /** Detect the popular CommonJS extension `module.exports`. */
+
+	  var moduleExports = freeModule && freeModule.exports === freeExports;
+	  /** Detect free variable `process` from Node.js. */
+
+	  var freeProcess = moduleExports && freeGlobal.process;
+	  /** Used to access faster Node.js helpers. */
+
+	  var nodeUtil = function () {
+	    try {
+	      return freeProcess && freeProcess.binding && freeProcess.binding('util');
+	    } catch (e) {}
+	  }();
+	  /* Node.js helper references. */
+
+
+	  var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+	  /**
+	   * A specialized version of `_.filter` for arrays without support for
+	   * iteratee shorthands.
+	   *
+	   * @private
+	   * @param {Array} [array] The array to iterate over.
+	   * @param {Function} predicate The function invoked per iteration.
+	   * @returns {Array} Returns the new filtered array.
+	   */
+
+	  function arrayFilter(array, predicate) {
+	    var index = -1,
+	        length = array == null ? 0 : array.length,
+	        resIndex = 0,
+	        result = [];
+
+	    while (++index < length) {
+	      var value = array[index];
+
+	      if (predicate(value, index, array)) {
+	        result[resIndex++] = value;
+	      }
+	    }
+
+	    return result;
+	  }
+	  /**
+	   * Appends the elements of `values` to `array`.
+	   *
+	   * @private
+	   * @param {Array} array The array to modify.
+	   * @param {Array} values The values to append.
+	   * @returns {Array} Returns `array`.
+	   */
+
+
+	  function arrayPush(array, values) {
+	    var index = -1,
+	        length = values.length,
+	        offset = array.length;
+
+	    while (++index < length) {
+	      array[offset + index] = values[index];
+	    }
+
+	    return array;
+	  }
+	  /**
+	   * A specialized version of `_.some` for arrays without support for iteratee
+	   * shorthands.
+	   *
+	   * @private
+	   * @param {Array} [array] The array to iterate over.
+	   * @param {Function} predicate The function invoked per iteration.
+	   * @returns {boolean} Returns `true` if any element passes the predicate check,
+	   *  else `false`.
+	   */
+
+
+	  function arraySome(array, predicate) {
+	    var index = -1,
+	        length = array == null ? 0 : array.length;
+
+	    while (++index < length) {
+	      if (predicate(array[index], index, array)) {
+	        return true;
+	      }
+	    }
+
+	    return false;
+	  }
+	  /**
+	   * The base implementation of `_.times` without support for iteratee shorthands
+	   * or max array length checks.
+	   *
+	   * @private
+	   * @param {number} n The number of times to invoke `iteratee`.
+	   * @param {Function} iteratee The function invoked per iteration.
+	   * @returns {Array} Returns the array of results.
+	   */
+
+
+	  function baseTimes(n, iteratee) {
+	    var index = -1,
+	        result = Array(n);
+
+	    while (++index < n) {
+	      result[index] = iteratee(index);
+	    }
+
+	    return result;
+	  }
+	  /**
+	   * The base implementation of `_.unary` without support for storing metadata.
+	   *
+	   * @private
+	   * @param {Function} func The function to cap arguments for.
+	   * @returns {Function} Returns the new capped function.
+	   */
+
+
+	  function baseUnary(func) {
+	    return function (value) {
+	      return func(value);
+	    };
+	  }
+	  /**
+	   * Checks if a `cache` value for `key` exists.
+	   *
+	   * @private
+	   * @param {Object} cache The cache to query.
+	   * @param {string} key The key of the entry to check.
+	   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	   */
+
+
+	  function cacheHas(cache, key) {
+	    return cache.has(key);
+	  }
+	  /**
+	   * Gets the value at `key` of `object`.
+	   *
+	   * @private
+	   * @param {Object} [object] The object to query.
+	   * @param {string} key The key of the property to get.
+	   * @returns {*} Returns the property value.
+	   */
+
+
+	  function getValue(object, key) {
+	    return object == null ? undefined : object[key];
+	  }
+	  /**
+	   * Converts `map` to its key-value pairs.
+	   *
+	   * @private
+	   * @param {Object} map The map to convert.
+	   * @returns {Array} Returns the key-value pairs.
+	   */
+
+
+	  function mapToArray(map) {
+	    var index = -1,
+	        result = Array(map.size);
+	    map.forEach(function (value, key) {
+	      result[++index] = [key, value];
+	    });
+	    return result;
+	  }
+	  /**
+	   * Creates a unary function that invokes `func` with its argument transformed.
+	   *
+	   * @private
+	   * @param {Function} func The function to wrap.
+	   * @param {Function} transform The argument transform.
+	   * @returns {Function} Returns the new function.
+	   */
+
+
+	  function overArg(func, transform) {
+	    return function (arg) {
+	      return func(transform(arg));
+	    };
+	  }
+	  /**
+	   * Converts `set` to an array of its values.
+	   *
+	   * @private
+	   * @param {Object} set The set to convert.
+	   * @returns {Array} Returns the values.
+	   */
+
+
+	  function setToArray(set) {
+	    var index = -1,
+	        result = Array(set.size);
+	    set.forEach(function (value) {
+	      result[++index] = value;
+	    });
+	    return result;
+	  }
+	  /** Used for built-in method references. */
+
+
+	  var arrayProto = Array.prototype,
+	      funcProto = Function.prototype,
+	      objectProto = Object.prototype;
+	  /** Used to detect overreaching core-js shims. */
+
+	  var coreJsData = root['__core-js_shared__'];
+	  /** Used to resolve the decompiled source of functions. */
+
+	  var funcToString = funcProto.toString;
+	  /** Used to check objects for own properties. */
+
+	  var hasOwnProperty = objectProto.hasOwnProperty;
+	  /** Used to detect methods masquerading as native. */
+
+	  var maskSrcKey = function () {
+	    var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+	    return uid ? 'Symbol(src)_1.' + uid : '';
+	  }();
+	  /**
+	   * Used to resolve the
+	   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	   * of values.
+	   */
+
+
+	  var nativeObjectToString = objectProto.toString;
+	  /** Used to detect if a method is native. */
+
+	  var reIsNative = RegExp('^' + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&').replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$');
+	  /** Built-in value references. */
+
+	  var Buffer = moduleExports ? root.Buffer : undefined,
+	      _Symbol = root.Symbol,
+	      Uint8Array = root.Uint8Array,
+	      propertyIsEnumerable = objectProto.propertyIsEnumerable,
+	      splice = arrayProto.splice,
+	      symToStringTag = _Symbol ? _Symbol.toStringTag : undefined;
+	  /* Built-in method references for those with the same name as other `lodash` methods. */
+
+	  var nativeGetSymbols = Object.getOwnPropertySymbols,
+	      nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,
+	      nativeKeys = overArg(Object.keys, Object);
+	  /* Built-in method references that are verified to be native. */
+
+	  var DataView = getNative(root, 'DataView'),
+	      Map = getNative(root, 'Map'),
+	      Promise = getNative(root, 'Promise'),
+	      Set = getNative(root, 'Set'),
+	      WeakMap = getNative(root, 'WeakMap'),
+	      nativeCreate = getNative(Object, 'create');
+	  /** Used to detect maps, sets, and weakmaps. */
+
+	  var dataViewCtorString = toSource(DataView),
+	      mapCtorString = toSource(Map),
+	      promiseCtorString = toSource(Promise),
+	      setCtorString = toSource(Set),
+	      weakMapCtorString = toSource(WeakMap);
+	  /** Used to convert symbols to primitives and strings. */
+
+	  var symbolProto = _Symbol ? _Symbol.prototype : undefined,
+	      symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+	  /**
+	   * Creates a hash object.
+	   *
+	   * @private
+	   * @constructor
+	   * @param {Array} [entries] The key-value pairs to cache.
+	   */
+
+	  function Hash(entries) {
+	    var index = -1,
+	        length = entries == null ? 0 : entries.length;
+	    this.clear();
+
+	    while (++index < length) {
+	      var entry = entries[index];
+	      this.set(entry[0], entry[1]);
+	    }
+	  }
+	  /**
+	   * Removes all key-value entries from the hash.
+	   *
+	   * @private
+	   * @name clear
+	   * @memberOf Hash
+	   */
+
+
+	  function hashClear() {
+	    this.__data__ = nativeCreate ? nativeCreate(null) : {};
+	    this.size = 0;
+	  }
+	  /**
+	   * Removes `key` and its value from the hash.
+	   *
+	   * @private
+	   * @name delete
+	   * @memberOf Hash
+	   * @param {Object} hash The hash to modify.
+	   * @param {string} key The key of the value to remove.
+	   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	   */
+
+
+	  function hashDelete(key) {
+	    var result = this.has(key) && delete this.__data__[key];
+	    this.size -= result ? 1 : 0;
+	    return result;
+	  }
+	  /**
+	   * Gets the hash value for `key`.
+	   *
+	   * @private
+	   * @name get
+	   * @memberOf Hash
+	   * @param {string} key The key of the value to get.
+	   * @returns {*} Returns the entry value.
+	   */
+
+
+	  function hashGet(key) {
+	    var data = this.__data__;
+
+	    if (nativeCreate) {
+	      var result = data[key];
+	      return result === HASH_UNDEFINED ? undefined : result;
+	    }
+
+	    return hasOwnProperty.call(data, key) ? data[key] : undefined;
+	  }
+	  /**
+	   * Checks if a hash value for `key` exists.
+	   *
+	   * @private
+	   * @name has
+	   * @memberOf Hash
+	   * @param {string} key The key of the entry to check.
+	   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	   */
+
+
+	  function hashHas(key) {
+	    var data = this.__data__;
+	    return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
+	  }
+	  /**
+	   * Sets the hash `key` to `value`.
+	   *
+	   * @private
+	   * @name set
+	   * @memberOf Hash
+	   * @param {string} key The key of the value to set.
+	   * @param {*} value The value to set.
+	   * @returns {Object} Returns the hash instance.
+	   */
+
+
+	  function hashSet(key, value) {
+	    var data = this.__data__;
+	    this.size += this.has(key) ? 0 : 1;
+	    data[key] = nativeCreate && value === undefined ? HASH_UNDEFINED : value;
+	    return this;
+	  } // Add methods to `Hash`.
+
+
+	  Hash.prototype.clear = hashClear;
+	  Hash.prototype['delete'] = hashDelete;
+	  Hash.prototype.get = hashGet;
+	  Hash.prototype.has = hashHas;
+	  Hash.prototype.set = hashSet;
+	  /**
+	   * Creates an list cache object.
+	   *
+	   * @private
+	   * @constructor
+	   * @param {Array} [entries] The key-value pairs to cache.
+	   */
+
+	  function ListCache(entries) {
+	    var index = -1,
+	        length = entries == null ? 0 : entries.length;
+	    this.clear();
+
+	    while (++index < length) {
+	      var entry = entries[index];
+	      this.set(entry[0], entry[1]);
+	    }
+	  }
+	  /**
+	   * Removes all key-value entries from the list cache.
+	   *
+	   * @private
+	   * @name clear
+	   * @memberOf ListCache
+	   */
+
+
+	  function listCacheClear() {
+	    this.__data__ = [];
+	    this.size = 0;
+	  }
+	  /**
+	   * Removes `key` and its value from the list cache.
+	   *
+	   * @private
+	   * @name delete
+	   * @memberOf ListCache
+	   * @param {string} key The key of the value to remove.
+	   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	   */
+
+
+	  function listCacheDelete(key) {
+	    var data = this.__data__,
+	        index = assocIndexOf(data, key);
+
+	    if (index < 0) {
+	      return false;
+	    }
+
+	    var lastIndex = data.length - 1;
+
+	    if (index == lastIndex) {
+	      data.pop();
+	    } else {
+	      splice.call(data, index, 1);
+	    }
+
+	    --this.size;
+	    return true;
+	  }
+	  /**
+	   * Gets the list cache value for `key`.
+	   *
+	   * @private
+	   * @name get
+	   * @memberOf ListCache
+	   * @param {string} key The key of the value to get.
+	   * @returns {*} Returns the entry value.
+	   */
+
+
+	  function listCacheGet(key) {
+	    var data = this.__data__,
+	        index = assocIndexOf(data, key);
+	    return index < 0 ? undefined : data[index][1];
+	  }
+	  /**
+	   * Checks if a list cache value for `key` exists.
+	   *
+	   * @private
+	   * @name has
+	   * @memberOf ListCache
+	   * @param {string} key The key of the entry to check.
+	   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	   */
+
+
+	  function listCacheHas(key) {
+	    return assocIndexOf(this.__data__, key) > -1;
+	  }
+	  /**
+	   * Sets the list cache `key` to `value`.
+	   *
+	   * @private
+	   * @name set
+	   * @memberOf ListCache
+	   * @param {string} key The key of the value to set.
+	   * @param {*} value The value to set.
+	   * @returns {Object} Returns the list cache instance.
+	   */
+
+
+	  function listCacheSet(key, value) {
+	    var data = this.__data__,
+	        index = assocIndexOf(data, key);
+
+	    if (index < 0) {
+	      ++this.size;
+	      data.push([key, value]);
+	    } else {
+	      data[index][1] = value;
+	    }
+
+	    return this;
+	  } // Add methods to `ListCache`.
+
+
+	  ListCache.prototype.clear = listCacheClear;
+	  ListCache.prototype['delete'] = listCacheDelete;
+	  ListCache.prototype.get = listCacheGet;
+	  ListCache.prototype.has = listCacheHas;
+	  ListCache.prototype.set = listCacheSet;
+	  /**
+	   * Creates a map cache object to store key-value pairs.
+	   *
+	   * @private
+	   * @constructor
+	   * @param {Array} [entries] The key-value pairs to cache.
+	   */
+
+	  function MapCache(entries) {
+	    var index = -1,
+	        length = entries == null ? 0 : entries.length;
+	    this.clear();
+
+	    while (++index < length) {
+	      var entry = entries[index];
+	      this.set(entry[0], entry[1]);
+	    }
+	  }
+	  /**
+	   * Removes all key-value entries from the map.
+	   *
+	   * @private
+	   * @name clear
+	   * @memberOf MapCache
+	   */
+
+
+	  function mapCacheClear() {
+	    this.size = 0;
+	    this.__data__ = {
+	      'hash': new Hash(),
+	      'map': new (Map || ListCache)(),
+	      'string': new Hash()
+	    };
+	  }
+	  /**
+	   * Removes `key` and its value from the map.
+	   *
+	   * @private
+	   * @name delete
+	   * @memberOf MapCache
+	   * @param {string} key The key of the value to remove.
+	   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	   */
+
+
+	  function mapCacheDelete(key) {
+	    var result = getMapData(this, key)['delete'](key);
+	    this.size -= result ? 1 : 0;
+	    return result;
+	  }
+	  /**
+	   * Gets the map value for `key`.
+	   *
+	   * @private
+	   * @name get
+	   * @memberOf MapCache
+	   * @param {string} key The key of the value to get.
+	   * @returns {*} Returns the entry value.
+	   */
+
+
+	  function mapCacheGet(key) {
+	    return getMapData(this, key).get(key);
+	  }
+	  /**
+	   * Checks if a map value for `key` exists.
+	   *
+	   * @private
+	   * @name has
+	   * @memberOf MapCache
+	   * @param {string} key The key of the entry to check.
+	   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	   */
+
+
+	  function mapCacheHas(key) {
+	    return getMapData(this, key).has(key);
+	  }
+	  /**
+	   * Sets the map `key` to `value`.
+	   *
+	   * @private
+	   * @name set
+	   * @memberOf MapCache
+	   * @param {string} key The key of the value to set.
+	   * @param {*} value The value to set.
+	   * @returns {Object} Returns the map cache instance.
+	   */
+
+
+	  function mapCacheSet(key, value) {
+	    var data = getMapData(this, key),
+	        size = data.size;
+	    data.set(key, value);
+	    this.size += data.size == size ? 0 : 1;
+	    return this;
+	  } // Add methods to `MapCache`.
+
+
+	  MapCache.prototype.clear = mapCacheClear;
+	  MapCache.prototype['delete'] = mapCacheDelete;
+	  MapCache.prototype.get = mapCacheGet;
+	  MapCache.prototype.has = mapCacheHas;
+	  MapCache.prototype.set = mapCacheSet;
+	  /**
+	   *
+	   * Creates an array cache object to store unique values.
+	   *
+	   * @private
+	   * @constructor
+	   * @param {Array} [values] The values to cache.
+	   */
+
+	  function SetCache(values) {
+	    var index = -1,
+	        length = values == null ? 0 : values.length;
+	    this.__data__ = new MapCache();
+
+	    while (++index < length) {
+	      this.add(values[index]);
+	    }
+	  }
+	  /**
+	   * Adds `value` to the array cache.
+	   *
+	   * @private
+	   * @name add
+	   * @memberOf SetCache
+	   * @alias push
+	   * @param {*} value The value to cache.
+	   * @returns {Object} Returns the cache instance.
+	   */
+
+
+	  function setCacheAdd(value) {
+	    this.__data__.set(value, HASH_UNDEFINED);
+
+	    return this;
+	  }
+	  /**
+	   * Checks if `value` is in the array cache.
+	   *
+	   * @private
+	   * @name has
+	   * @memberOf SetCache
+	   * @param {*} value The value to search for.
+	   * @returns {number} Returns `true` if `value` is found, else `false`.
+	   */
+
+
+	  function setCacheHas(value) {
+	    return this.__data__.has(value);
+	  } // Add methods to `SetCache`.
+
+
+	  SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+	  SetCache.prototype.has = setCacheHas;
+	  /**
+	   * Creates a stack cache object to store key-value pairs.
+	   *
+	   * @private
+	   * @constructor
+	   * @param {Array} [entries] The key-value pairs to cache.
+	   */
+
+	  function Stack(entries) {
+	    var data = this.__data__ = new ListCache(entries);
+	    this.size = data.size;
+	  }
+	  /**
+	   * Removes all key-value entries from the stack.
+	   *
+	   * @private
+	   * @name clear
+	   * @memberOf Stack
+	   */
+
+
+	  function stackClear() {
+	    this.__data__ = new ListCache();
+	    this.size = 0;
+	  }
+	  /**
+	   * Removes `key` and its value from the stack.
+	   *
+	   * @private
+	   * @name delete
+	   * @memberOf Stack
+	   * @param {string} key The key of the value to remove.
+	   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+	   */
+
+
+	  function stackDelete(key) {
+	    var data = this.__data__,
+	        result = data['delete'](key);
+	    this.size = data.size;
+	    return result;
+	  }
+	  /**
+	   * Gets the stack value for `key`.
+	   *
+	   * @private
+	   * @name get
+	   * @memberOf Stack
+	   * @param {string} key The key of the value to get.
+	   * @returns {*} Returns the entry value.
+	   */
+
+
+	  function stackGet(key) {
+	    return this.__data__.get(key);
+	  }
+	  /**
+	   * Checks if a stack value for `key` exists.
+	   *
+	   * @private
+	   * @name has
+	   * @memberOf Stack
+	   * @param {string} key The key of the entry to check.
+	   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+	   */
+
+
+	  function stackHas(key) {
+	    return this.__data__.has(key);
+	  }
+	  /**
+	   * Sets the stack `key` to `value`.
+	   *
+	   * @private
+	   * @name set
+	   * @memberOf Stack
+	   * @param {string} key The key of the value to set.
+	   * @param {*} value The value to set.
+	   * @returns {Object} Returns the stack cache instance.
+	   */
+
+
+	  function stackSet(key, value) {
+	    var data = this.__data__;
+
+	    if (data instanceof ListCache) {
+	      var pairs = data.__data__;
+
+	      if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {
+	        pairs.push([key, value]);
+	        this.size = ++data.size;
+	        return this;
+	      }
+
+	      data = this.__data__ = new MapCache(pairs);
+	    }
+
+	    data.set(key, value);
+	    this.size = data.size;
+	    return this;
+	  } // Add methods to `Stack`.
+
+
+	  Stack.prototype.clear = stackClear;
+	  Stack.prototype['delete'] = stackDelete;
+	  Stack.prototype.get = stackGet;
+	  Stack.prototype.has = stackHas;
+	  Stack.prototype.set = stackSet;
+	  /**
+	   * Creates an array of the enumerable property names of the array-like `value`.
+	   *
+	   * @private
+	   * @param {*} value The value to query.
+	   * @param {boolean} inherited Specify returning inherited property names.
+	   * @returns {Array} Returns the array of property names.
+	   */
+
+	  function arrayLikeKeys(value, inherited) {
+	    var isArr = isArray(value),
+	        isArg = !isArr && isArguments(value),
+	        isBuff = !isArr && !isArg && isBuffer(value),
+	        isType = !isArr && !isArg && !isBuff && isTypedArray(value),
+	        skipIndexes = isArr || isArg || isBuff || isType,
+	        result = skipIndexes ? baseTimes(value.length, String) : [],
+	        length = result.length;
+
+	    for (var key in value) {
+	      if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && ( // Safari 9 has enumerable `arguments.length` in strict mode.
+	      key == 'length' || // Node.js 0.10 has enumerable non-index properties on buffers.
+	      isBuff && (key == 'offset' || key == 'parent') || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+	      isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset') || // Skip index properties.
+	      isIndex(key, length)))) {
+	        result.push(key);
+	      }
+	    }
+
+	    return result;
+	  }
+	  /**
+	   * Gets the index at which the `key` is found in `array` of key-value pairs.
+	   *
+	   * @private
+	   * @param {Array} array The array to inspect.
+	   * @param {*} key The key to search for.
+	   * @returns {number} Returns the index of the matched value, else `-1`.
+	   */
+
+
+	  function assocIndexOf(array, key) {
+	    var length = array.length;
+
+	    while (length--) {
+	      if (eq(array[length][0], key)) {
+	        return length;
+	      }
+	    }
+
+	    return -1;
+	  }
+	  /**
+	   * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+	   * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+	   * symbols of `object`.
+	   *
+	   * @private
+	   * @param {Object} object The object to query.
+	   * @param {Function} keysFunc The function to get the keys of `object`.
+	   * @param {Function} symbolsFunc The function to get the symbols of `object`.
+	   * @returns {Array} Returns the array of property names and symbols.
+	   */
+
+
+	  function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+	    var result = keysFunc(object);
+	    return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+	  }
+	  /**
+	   * The base implementation of `getTag` without fallbacks for buggy environments.
+	   *
+	   * @private
+	   * @param {*} value The value to query.
+	   * @returns {string} Returns the `toStringTag`.
+	   */
+
+
+	  function baseGetTag(value) {
+	    if (value == null) {
+	      return value === undefined ? undefinedTag : nullTag;
+	    }
+
+	    return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+	  }
+	  /**
+	   * The base implementation of `_.isArguments`.
+	   *
+	   * @private
+	   * @param {*} value The value to check.
+	   * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+	   */
+
+
+	  function baseIsArguments(value) {
+	    return isObjectLike(value) && baseGetTag(value) == argsTag;
+	  }
+	  /**
+	   * The base implementation of `_.isEqual` which supports partial comparisons
+	   * and tracks traversed objects.
+	   *
+	   * @private
+	   * @param {*} value The value to compare.
+	   * @param {*} other The other value to compare.
+	   * @param {boolean} bitmask The bitmask flags.
+	   *  1 - Unordered comparison
+	   *  2 - Partial comparison
+	   * @param {Function} [customizer] The function to customize comparisons.
+	   * @param {Object} [stack] Tracks traversed `value` and `other` objects.
+	   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+	   */
+
+
+	  function baseIsEqual(value, other, bitmask, customizer, stack) {
+	    if (value === other) {
+	      return true;
+	    }
+
+	    if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
+	      return value !== value && other !== other;
+	    }
+
+	    return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
+	  }
+	  /**
+	   * A specialized version of `baseIsEqual` for arrays and objects which performs
+	   * deep comparisons and tracks traversed objects enabling objects with circular
+	   * references to be compared.
+	   *
+	   * @private
+	   * @param {Object} object The object to compare.
+	   * @param {Object} other The other object to compare.
+	   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+	   * @param {Function} customizer The function to customize comparisons.
+	   * @param {Function} equalFunc The function to determine equivalents of values.
+	   * @param {Object} [stack] Tracks traversed `object` and `other` objects.
+	   * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+	   */
+
+
+	  function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
+	    var objIsArr = isArray(object),
+	        othIsArr = isArray(other),
+	        objTag = objIsArr ? arrayTag : getTag(object),
+	        othTag = othIsArr ? arrayTag : getTag(other);
+	    objTag = objTag == argsTag ? objectTag : objTag;
+	    othTag = othTag == argsTag ? objectTag : othTag;
+	    var objIsObj = objTag == objectTag,
+	        othIsObj = othTag == objectTag,
+	        isSameTag = objTag == othTag;
+
+	    if (isSameTag && isBuffer(object)) {
+	      if (!isBuffer(other)) {
+	        return false;
+	      }
+
+	      objIsArr = true;
+	      objIsObj = false;
+	    }
+
+	    if (isSameTag && !objIsObj) {
+	      stack || (stack = new Stack());
+	      return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+	    }
+
+	    if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
+	      var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
+	          othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');
+
+	      if (objIsWrapped || othIsWrapped) {
+	        var objUnwrapped = objIsWrapped ? object.value() : object,
+	            othUnwrapped = othIsWrapped ? other.value() : other;
+	        stack || (stack = new Stack());
+	        return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+	      }
+	    }
+
+	    if (!isSameTag) {
+	      return false;
+	    }
+
+	    stack || (stack = new Stack());
+	    return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+	  }
+	  /**
+	   * The base implementation of `_.isNative` without bad shim checks.
+	   *
+	   * @private
+	   * @param {*} value The value to check.
+	   * @returns {boolean} Returns `true` if `value` is a native function,
+	   *  else `false`.
+	   */
+
+
+	  function baseIsNative(value) {
+	    if (!isObject(value) || isMasked(value)) {
+	      return false;
+	    }
+
+	    var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+	    return pattern.test(toSource(value));
+	  }
+	  /**
+	   * The base implementation of `_.isTypedArray` without Node.js optimizations.
+	   *
+	   * @private
+	   * @param {*} value The value to check.
+	   * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+	   */
+
+
+	  function baseIsTypedArray(value) {
+	    return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+	  }
+	  /**
+	   * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
+	   *
+	   * @private
+	   * @param {Object} object The object to query.
+	   * @returns {Array} Returns the array of property names.
+	   */
+
+
+	  function baseKeys(object) {
+	    if (!isPrototype(object)) {
+	      return nativeKeys(object);
+	    }
+
+	    var result = [];
+
+	    for (var key in Object(object)) {
+	      if (hasOwnProperty.call(object, key) && key != 'constructor') {
+	        result.push(key);
+	      }
+	    }
+
+	    return result;
+	  }
+	  /**
+	   * A specialized version of `baseIsEqualDeep` for arrays with support for
+	   * partial deep comparisons.
+	   *
+	   * @private
+	   * @param {Array} array The array to compare.
+	   * @param {Array} other The other array to compare.
+	   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+	   * @param {Function} customizer The function to customize comparisons.
+	   * @param {Function} equalFunc The function to determine equivalents of values.
+	   * @param {Object} stack Tracks traversed `array` and `other` objects.
+	   * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.
+	   */
+
+
+	  function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
+	    var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
+	        arrLength = array.length,
+	        othLength = other.length;
+
+	    if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+	      return false;
+	    } // Assume cyclic values are equal.
+
+
+	    var stacked = stack.get(array);
+
+	    if (stacked && stack.get(other)) {
+	      return stacked == other;
+	    }
+
+	    var index = -1,
+	        result = true,
+	        seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : undefined;
+	    stack.set(array, other);
+	    stack.set(other, array); // Ignore non-index properties.
+
+	    while (++index < arrLength) {
+	      var arrValue = array[index],
+	          othValue = other[index];
+
+	      if (customizer) {
+	        var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+	      }
+
+	      if (compared !== undefined) {
+	        if (compared) {
+	          continue;
+	        }
+
+	        result = false;
+	        break;
+	      } // Recursively compare arrays (susceptible to call stack limits).
+
+
+	      if (seen) {
+	        if (!arraySome(other, function (othValue, othIndex) {
+	          if (!cacheHas(seen, othIndex) && (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+	            return seen.push(othIndex);
+	          }
+	        })) {
+	          result = false;
+	          break;
+	        }
+	      } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+	        result = false;
+	        break;
+	      }
+	    }
+
+	    stack['delete'](array);
+	    stack['delete'](other);
+	    return result;
+	  }
+	  /**
+	   * A specialized version of `baseIsEqualDeep` for comparing objects of
+	   * the same `toStringTag`.
+	   *
+	   * **Note:** This function only supports comparing values with tags of
+	   * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.
+	   *
+	   * @private
+	   * @param {Object} object The object to compare.
+	   * @param {Object} other The other object to compare.
+	   * @param {string} tag The `toStringTag` of the objects to compare.
+	   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+	   * @param {Function} customizer The function to customize comparisons.
+	   * @param {Function} equalFunc The function to determine equivalents of values.
+	   * @param {Object} stack Tracks traversed `object` and `other` objects.
+	   * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+	   */
+
+
+	  function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
+	    switch (tag) {
+	      case dataViewTag:
+	        if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+	          return false;
+	        }
+
+	        object = object.buffer;
+	        other = other.buffer;
+
+	      case arrayBufferTag:
+	        if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
+	          return false;
+	        }
+
+	        return true;
+
+	      case boolTag:
+	      case dateTag:
+	      case numberTag:
+	        // Coerce booleans to `1` or `0` and dates to milliseconds.
+	        // Invalid dates are coerced to `NaN`.
+	        return eq(+object, +other);
+
+	      case errorTag:
+	        return object.name == other.name && object.message == other.message;
+
+	      case regexpTag:
+	      case stringTag:
+	        // Coerce regexes to strings and treat strings, primitives and objects,
+	        // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring
+	        // for more details.
+	        return object == other + '';
+
+	      case mapTag:
+	        var convert = mapToArray;
+
+	      case setTag:
+	        var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
+	        convert || (convert = setToArray);
+
+	        if (object.size != other.size && !isPartial) {
+	          return false;
+	        } // Assume cyclic values are equal.
+
+
+	        var stacked = stack.get(object);
+
+	        if (stacked) {
+	          return stacked == other;
+	        }
+
+	        bitmask |= COMPARE_UNORDERED_FLAG; // Recursively compare objects (susceptible to call stack limits).
+
+	        stack.set(object, other);
+	        var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+	        stack['delete'](object);
+	        return result;
+
+	      case symbolTag:
+	        if (symbolValueOf) {
+	          return symbolValueOf.call(object) == symbolValueOf.call(other);
+	        }
+
+	    }
+
+	    return false;
+	  }
+	  /**
+	   * A specialized version of `baseIsEqualDeep` for objects with support for
+	   * partial deep comparisons.
+	   *
+	   * @private
+	   * @param {Object} object The object to compare.
+	   * @param {Object} other The other object to compare.
+	   * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
+	   * @param {Function} customizer The function to customize comparisons.
+	   * @param {Function} equalFunc The function to determine equivalents of values.
+	   * @param {Object} stack Tracks traversed `object` and `other` objects.
+	   * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
+	   */
+
+
+	  function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
+	    var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
+	        objProps = getAllKeys(object),
+	        objLength = objProps.length,
+	        othProps = getAllKeys(other),
+	        othLength = othProps.length;
+
+	    if (objLength != othLength && !isPartial) {
+	      return false;
+	    }
+
+	    var index = objLength;
+
+	    while (index--) {
+	      var key = objProps[index];
+
+	      if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
+	        return false;
+	      }
+	    } // Assume cyclic values are equal.
+
+
+	    var stacked = stack.get(object);
+
+	    if (stacked && stack.get(other)) {
+	      return stacked == other;
+	    }
+
+	    var result = true;
+	    stack.set(object, other);
+	    stack.set(other, object);
+	    var skipCtor = isPartial;
+
+	    while (++index < objLength) {
+	      key = objProps[index];
+	      var objValue = object[key],
+	          othValue = other[key];
+
+	      if (customizer) {
+	        var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+	      } // Recursively compare objects (susceptible to call stack limits).
+
+
+	      if (!(compared === undefined ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+	        result = false;
+	        break;
+	      }
+
+	      skipCtor || (skipCtor = key == 'constructor');
+	    }
+
+	    if (result && !skipCtor) {
+	      var objCtor = object.constructor,
+	          othCtor = other.constructor; // Non `Object` object instances with different constructors are not equal.
+
+	      if (objCtor != othCtor && 'constructor' in object && 'constructor' in other && !(typeof objCtor == 'function' && objCtor instanceof objCtor && typeof othCtor == 'function' && othCtor instanceof othCtor)) {
+	        result = false;
+	      }
+	    }
+
+	    stack['delete'](object);
+	    stack['delete'](other);
+	    return result;
+	  }
+	  /**
+	   * Creates an array of own enumerable property names and symbols of `object`.
+	   *
+	   * @private
+	   * @param {Object} object The object to query.
+	   * @returns {Array} Returns the array of property names and symbols.
+	   */
+
+
+	  function getAllKeys(object) {
+	    return baseGetAllKeys(object, keys, getSymbols);
+	  }
+	  /**
+	   * Gets the data for `map`.
+	   *
+	   * @private
+	   * @param {Object} map The map to query.
+	   * @param {string} key The reference key.
+	   * @returns {*} Returns the map data.
+	   */
+
+
+	  function getMapData(map, key) {
+	    var data = map.__data__;
+	    return isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map;
+	  }
+	  /**
+	   * Gets the native function at `key` of `object`.
+	   *
+	   * @private
+	   * @param {Object} object The object to query.
+	   * @param {string} key The key of the method to get.
+	   * @returns {*} Returns the function if it's native, else `undefined`.
+	   */
+
+
+	  function getNative(object, key) {
+	    var value = getValue(object, key);
+	    return baseIsNative(value) ? value : undefined;
+	  }
+	  /**
+	   * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+	   *
+	   * @private
+	   * @param {*} value The value to query.
+	   * @returns {string} Returns the raw `toStringTag`.
+	   */
+
+
+	  function getRawTag(value) {
+	    var isOwn = hasOwnProperty.call(value, symToStringTag),
+	        tag = value[symToStringTag];
+
+	    try {
+	      value[symToStringTag] = undefined;
+	      var unmasked = true;
+	    } catch (e) {}
+
+	    var result = nativeObjectToString.call(value);
+
+	    if (unmasked) {
+	      if (isOwn) {
+	        value[symToStringTag] = tag;
+	      } else {
+	        delete value[symToStringTag];
+	      }
+	    }
+
+	    return result;
+	  }
+	  /**
+	   * Creates an array of the own enumerable symbols of `object`.
+	   *
+	   * @private
+	   * @param {Object} object The object to query.
+	   * @returns {Array} Returns the array of symbols.
+	   */
+
+
+	  var getSymbols = !nativeGetSymbols ? stubArray : function (object) {
+	    if (object == null) {
+	      return [];
+	    }
+
+	    object = Object(object);
+	    return arrayFilter(nativeGetSymbols(object), function (symbol) {
+	      return propertyIsEnumerable.call(object, symbol);
+	    });
+	  };
+	  /**
+	   * Gets the `toStringTag` of `value`.
+	   *
+	   * @private
+	   * @param {*} value The value to query.
+	   * @returns {string} Returns the `toStringTag`.
+	   */
+
+	  var getTag = baseGetTag; // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
+
+	  if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map && getTag(new Map()) != mapTag || Promise && getTag(Promise.resolve()) != promiseTag || Set && getTag(new Set()) != setTag || WeakMap && getTag(new WeakMap()) != weakMapTag) {
+	    getTag = function getTag(value) {
+	      var result = baseGetTag(value),
+	          Ctor = result == objectTag ? value.constructor : undefined,
+	          ctorString = Ctor ? toSource(Ctor) : '';
+
+	      if (ctorString) {
+	        switch (ctorString) {
+	          case dataViewCtorString:
+	            return dataViewTag;
+
+	          case mapCtorString:
+	            return mapTag;
+
+	          case promiseCtorString:
+	            return promiseTag;
+
+	          case setCtorString:
+	            return setTag;
+
+	          case weakMapCtorString:
+	            return weakMapTag;
+	        }
+	      }
+
+	      return result;
+	    };
+	  }
+	  /**
+	   * Checks if `value` is a valid array-like index.
+	   *
+	   * @private
+	   * @param {*} value The value to check.
+	   * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+	   * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+	   */
+
+
+	  function isIndex(value, length) {
+	    length = length == null ? MAX_SAFE_INTEGER : length;
+	    return !!length && (typeof value == 'number' || reIsUint.test(value)) && value > -1 && value % 1 == 0 && value < length;
+	  }
+	  /**
+	   * Checks if `value` is suitable for use as unique object key.
+	   *
+	   * @private
+	   * @param {*} value The value to check.
+	   * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+	   */
+
+
+	  function isKeyable(value) {
+	    var type = _typeof$4(value);
+
+	    return type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean' ? value !== '__proto__' : value === null;
+	  }
+	  /**
+	   * Checks if `func` has its source masked.
+	   *
+	   * @private
+	   * @param {Function} func The function to check.
+	   * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+	   */
+
+
+	  function isMasked(func) {
+	    return !!maskSrcKey && maskSrcKey in func;
+	  }
+	  /**
+	   * Checks if `value` is likely a prototype object.
+	   *
+	   * @private
+	   * @param {*} value The value to check.
+	   * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+	   */
+
+
+	  function isPrototype(value) {
+	    var Ctor = value && value.constructor,
+	        proto = typeof Ctor == 'function' && Ctor.prototype || objectProto;
+	    return value === proto;
+	  }
+	  /**
+	   * Converts `value` to a string using `Object.prototype.toString`.
+	   *
+	   * @private
+	   * @param {*} value The value to convert.
+	   * @returns {string} Returns the converted string.
+	   */
+
+
+	  function objectToString(value) {
+	    return nativeObjectToString.call(value);
+	  }
+	  /**
+	   * Converts `func` to its source code.
+	   *
+	   * @private
+	   * @param {Function} func The function to convert.
+	   * @returns {string} Returns the source code.
+	   */
+
+
+	  function toSource(func) {
+	    if (func != null) {
+	      try {
+	        return funcToString.call(func);
+	      } catch (e) {}
+
+	      try {
+	        return func + '';
+	      } catch (e) {}
+	    }
+
+	    return '';
+	  }
+	  /**
+	   * Performs a
+	   * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+	   * comparison between two values to determine if they are equivalent.
+	   *
+	   * @static
+	   * @memberOf _
+	   * @since 4.0.0
+	   * @category Lang
+	   * @param {*} value The value to compare.
+	   * @param {*} other The other value to compare.
+	   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+	   * @example
+	   *
+	   * var object = { 'a': 1 };
+	   * var other = { 'a': 1 };
+	   *
+	   * _.eq(object, object);
+	   * // => true
+	   *
+	   * _.eq(object, other);
+	   * // => false
+	   *
+	   * _.eq('a', 'a');
+	   * // => true
+	   *
+	   * _.eq('a', Object('a'));
+	   * // => false
+	   *
+	   * _.eq(NaN, NaN);
+	   * // => true
+	   */
+
+
+	  function eq(value, other) {
+	    return value === other || value !== value && other !== other;
+	  }
+	  /**
+	   * Checks if `value` is likely an `arguments` object.
+	   *
+	   * @static
+	   * @memberOf _
+	   * @since 0.1.0
+	   * @category Lang
+	   * @param {*} value The value to check.
+	   * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+	   *  else `false`.
+	   * @example
+	   *
+	   * _.isArguments(function() { return arguments; }());
+	   * // => true
+	   *
+	   * _.isArguments([1, 2, 3]);
+	   * // => false
+	   */
+
+
+	  var isArguments = baseIsArguments(function () {
+	    return arguments;
+	  }()) ? baseIsArguments : function (value) {
+	    return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');
+	  };
+	  /**
+	   * Checks if `value` is classified as an `Array` object.
+	   *
+	   * @static
+	   * @memberOf _
+	   * @since 0.1.0
+	   * @category Lang
+	   * @param {*} value The value to check.
+	   * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+	   * @example
+	   *
+	   * _.isArray([1, 2, 3]);
+	   * // => true
+	   *
+	   * _.isArray(document.body.children);
+	   * // => false
+	   *
+	   * _.isArray('abc');
+	   * // => false
+	   *
+	   * _.isArray(_.noop);
+	   * // => false
+	   */
+
+	  var isArray = Array.isArray;
+	  /**
+	   * Checks if `value` is array-like. A value is considered array-like if it's
+	   * not a function and has a `value.length` that's an integer greater than or
+	   * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+	   *
+	   * @static
+	   * @memberOf _
+	   * @since 4.0.0
+	   * @category Lang
+	   * @param {*} value The value to check.
+	   * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+	   * @example
+	   *
+	   * _.isArrayLike([1, 2, 3]);
+	   * // => true
+	   *
+	   * _.isArrayLike(document.body.children);
+	   * // => true
+	   *
+	   * _.isArrayLike('abc');
+	   * // => true
+	   *
+	   * _.isArrayLike(_.noop);
+	   * // => false
+	   */
+
+	  function isArrayLike(value) {
+	    return value != null && isLength(value.length) && !isFunction(value);
+	  }
+	  /**
+	   * Checks if `value` is a buffer.
+	   *
+	   * @static
+	   * @memberOf _
+	   * @since 4.3.0
+	   * @category Lang
+	   * @param {*} value The value to check.
+	   * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+	   * @example
+	   *
+	   * _.isBuffer(new Buffer(2));
+	   * // => true
+	   *
+	   * _.isBuffer(new Uint8Array(2));
+	   * // => false
+	   */
+
+
+	  var isBuffer = nativeIsBuffer || stubFalse;
+	  /**
+	   * Performs a deep comparison between two values to determine if they are
+	   * equivalent.
+	   *
+	   * **Note:** This method supports comparing arrays, array buffers, booleans,
+	   * date objects, error objects, maps, numbers, `Object` objects, regexes,
+	   * sets, strings, symbols, and typed arrays. `Object` objects are compared
+	   * by their own, not inherited, enumerable properties. Functions and DOM
+	   * nodes are compared by strict equality, i.e. `===`.
+	   *
+	   * @static
+	   * @memberOf _
+	   * @since 0.1.0
+	   * @category Lang
+	   * @param {*} value The value to compare.
+	   * @param {*} other The other value to compare.
+	   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+	   * @example
+	   *
+	   * var object = { 'a': 1 };
+	   * var other = { 'a': 1 };
+	   *
+	   * _.isEqual(object, other);
+	   * // => true
+	   *
+	   * object === other;
+	   * // => false
+	   */
+
+	  function isEqual(value, other) {
+	    return baseIsEqual(value, other);
+	  }
+	  /**
+	   * Checks if `value` is classified as a `Function` object.
+	   *
+	   * @static
+	   * @memberOf _
+	   * @since 0.1.0
+	   * @category Lang
+	   * @param {*} value The value to check.
+	   * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+	   * @example
+	   *
+	   * _.isFunction(_);
+	   * // => true
+	   *
+	   * _.isFunction(/abc/);
+	   * // => false
+	   */
+
+
+	  function isFunction(value) {
+	    if (!isObject(value)) {
+	      return false;
+	    } // The use of `Object#toString` avoids issues with the `typeof` operator
+	    // in Safari 9 which returns 'object' for typed arrays and other constructors.
+
+
+	    var tag = baseGetTag(value);
+	    return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+	  }
+	  /**
+	   * Checks if `value` is a valid array-like length.
+	   *
+	   * **Note:** This method is loosely based on
+	   * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+	   *
+	   * @static
+	   * @memberOf _
+	   * @since 4.0.0
+	   * @category Lang
+	   * @param {*} value The value to check.
+	   * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+	   * @example
+	   *
+	   * _.isLength(3);
+	   * // => true
+	   *
+	   * _.isLength(Number.MIN_VALUE);
+	   * // => false
+	   *
+	   * _.isLength(Infinity);
+	   * // => false
+	   *
+	   * _.isLength('3');
+	   * // => false
+	   */
+
+
+	  function isLength(value) {
+	    return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+	  }
+	  /**
+	   * Checks if `value` is the
+	   * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+	   * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+	   *
+	   * @static
+	   * @memberOf _
+	   * @since 0.1.0
+	   * @category Lang
+	   * @param {*} value The value to check.
+	   * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+	   * @example
+	   *
+	   * _.isObject({});
+	   * // => true
+	   *
+	   * _.isObject([1, 2, 3]);
+	   * // => true
+	   *
+	   * _.isObject(_.noop);
+	   * // => true
+	   *
+	   * _.isObject(null);
+	   * // => false
+	   */
+
+
+	  function isObject(value) {
+	    var type = _typeof$4(value);
+
+	    return value != null && (type == 'object' || type == 'function');
+	  }
+	  /**
+	   * Checks if `value` is object-like. A value is object-like if it's not `null`
+	   * and has a `typeof` result of "object".
+	   *
+	   * @static
+	   * @memberOf _
+	   * @since 4.0.0
+	   * @category Lang
+	   * @param {*} value The value to check.
+	   * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+	   * @example
+	   *
+	   * _.isObjectLike({});
+	   * // => true
+	   *
+	   * _.isObjectLike([1, 2, 3]);
+	   * // => true
+	   *
+	   * _.isObjectLike(_.noop);
+	   * // => false
+	   *
+	   * _.isObjectLike(null);
+	   * // => false
+	   */
+
+
+	  function isObjectLike(value) {
+	    return value != null && _typeof$4(value) == 'object';
+	  }
+	  /**
+	   * Checks if `value` is classified as a typed array.
+	   *
+	   * @static
+	   * @memberOf _
+	   * @since 3.0.0
+	   * @category Lang
+	   * @param {*} value The value to check.
+	   * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+	   * @example
+	   *
+	   * _.isTypedArray(new Uint8Array);
+	   * // => true
+	   *
+	   * _.isTypedArray([]);
+	   * // => false
+	   */
+
+
+	  var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+	  /**
+	   * Creates an array of the own enumerable property names of `object`.
+	   *
+	   * **Note:** Non-object values are coerced to objects. See the
+	   * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+	   * for more details.
+	   *
+	   * @static
+	   * @since 0.1.0
+	   * @memberOf _
+	   * @category Object
+	   * @param {Object} object The object to query.
+	   * @returns {Array} Returns the array of property names.
+	   * @example
+	   *
+	   * function Foo() {
+	   *   this.a = 1;
+	   *   this.b = 2;
+	   * }
+	   *
+	   * Foo.prototype.c = 3;
+	   *
+	   * _.keys(new Foo);
+	   * // => ['a', 'b'] (iteration order is not guaranteed)
+	   *
+	   * _.keys('hi');
+	   * // => ['0', '1']
+	   */
+
+	  function keys(object) {
+	    return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+	  }
+	  /**
+	   * This method returns a new empty array.
+	   *
+	   * @static
+	   * @memberOf _
+	   * @since 4.13.0
+	   * @category Util
+	   * @returns {Array} Returns the new empty array.
+	   * @example
+	   *
+	   * var arrays = _.times(2, _.stubArray);
+	   *
+	   * console.log(arrays);
+	   * // => [[], []]
+	   *
+	   * console.log(arrays[0] === arrays[1]);
+	   * // => false
+	   */
+
+
+	  function stubArray() {
+	    return [];
+	  }
+	  /**
+	   * This method returns `false`.
+	   *
+	   * @static
+	   * @memberOf _
+	   * @since 4.13.0
+	   * @category Util
+	   * @returns {boolean} Returns `false`.
+	   * @example
+	   *
+	   * _.times(2, _.stubFalse);
+	   * // => [false, false]
+	   */
+
+
+	  function stubFalse() {
+	    return false;
+	  }
+
+	  module.exports = isEqual;
+	})(lodash_isequal, lodash_isequal.exports);
+
+	var isEqual = lodash_isequal.exports;
+
 	function _createSuper$b(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct$c(); return function _createSuperInternal() { var Super = _getPrototypeOf$4(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf$4(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn$4(this, result); }; }
 
 	function _isNativeReflectConstruct$c() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
@@ -8574,7 +9414,7 @@ this.Twilio.Conversations = (function (exports) {
 	              case 9:
 	                updateAttributes = parseAttributes(value.value, "Retrieved malformed attributes from the server for user: ".concat(this.state.identity), log$a);
 
-	                if (!isDeepEqual(this.state.attributes, updateAttributes)) {
+	                if (!isEqual(this.state.attributes, updateAttributes)) {
 	                  this.state.attributes = updateAttributes;
 	                  updateReasons.push('attributes');
 	                }
@@ -15353,7 +16193,7 @@ this.Twilio.Conversations = (function (exports) {
 	  }();
 
 	  var logInstance = new Logger("");
-	  var version = "0.12.0-rc.1";
+	  var version = "0.12.1-rc.2";
 	  /**
 	   * Settings container for the Twilsock client library
 	   */
@@ -29892,7 +30732,7 @@ this.Twilio.Conversations = (function (exports) {
 
 	__decorate([declarativeTypeValidator.validateTypes(declarativeTypeValidator.nonEmptyString), __metadata("design:type", Function), __metadata("design:paramtypes", [String]), __metadata("design:returntype", void 0)], InstantQuery.prototype, "updateIndexName", null);
 
-	var version$1 = "3.0.5-rc.21";
+	var version$1 = "3.0.6-rc.2";
 
 	function _createSuper$9(Derived) {
 	  var hasNativeReflectConstruct = _isNativeReflectConstruct$a();
@@ -33880,7 +34720,7 @@ this.Twilio.Conversations = (function (exports) {
 	    return Network;
 	  }();
 
-	  var version = "0.5.1-rc.12";
+	  var version = "0.5.2-rc.2";
 
 	  var _class, _temp;
 
@@ -34328,7 +35168,7 @@ this.Twilio.Conversations = (function (exports) {
 	      var updateReasons = [];
 	      var updateAttributes = parseAttributes(data.attributes, 'Retrieved malformed attributes from the server for participant: ' + this.state.sid, log$7);
 
-	      if (data.attributes && !isDeepEqual(this.state.attributes, updateAttributes)) {
+	      if (data.attributes && !isEqual(this.state.attributes, updateAttributes)) {
 	        this.state.attributes = updateAttributes;
 	        updateReasons.push('attributes');
 	      }
@@ -35660,7 +36500,7 @@ this.Twilio.Conversations = (function (exports) {
 
 	      var updatedAttributes = parseAttributes(data.attributes, "Got malformed attributes for the message ".concat(this.sid), log$5);
 
-	      if (!isDeepEqual(this.state.attributes, updatedAttributes)) {
+	      if (!isEqual(this.state.attributes, updatedAttributes)) {
 	        this.state.attributes = updatedAttributes;
 	        updateReasons.push('attributes');
 	      }
@@ -37223,7 +38063,7 @@ this.Twilio.Conversations = (function (exports) {
 	            break;
 
 	          case fieldMappings.attributes:
-	            if (isDeepEqual(this.channelState.attributes, update.attributes)) {
+	            if (isEqual(this.channelState.attributes, update.attributes)) {
 	              break;
 	            }
 
@@ -37259,7 +38099,7 @@ this.Twilio.Conversations = (function (exports) {
 	              updateReasons.add(localKey);
 	            }
 
-	            if (isDeepEqual(this.channelState.lastMessage, {})) {
+	            if (isEqual(this.channelState.lastMessage, {})) {
 	              delete this.channelState.lastMessage;
 	            }
 
@@ -37272,7 +38112,7 @@ this.Twilio.Conversations = (function (exports) {
 	              state.dateUpdated = new Date(state.dateUpdated);
 	            }
 
-	            if (isDeepEqual(this.channelState.state, state)) {
+	            if (isEqual(this.channelState.state, state)) {
 	              break;
 	            }
 
@@ -37406,7 +38246,7 @@ this.Twilio.Conversations = (function (exports) {
 	          while (1) {
 	            switch (_context5.prev = _context5.next) {
 	              case 0:
-	                return _context5.abrupt("return", this.participantsEntity.addNonChatParticipant(proxyAddress, address, attributes !== null && attributes !== void 0 ? attributes : {}));
+	                return _context5.abrupt("return", this.participantsEntity.addNonChatParticipant(proxyAddress, address, attributes));
 
 	              case 1:
 	              case "end":
@@ -38700,7 +39540,7 @@ this.Twilio.Conversations = (function (exports) {
 	                conversationsMap = _context4.sent;
 	                _context4.next = 5;
 	                return conversationsMap.getItems({
-	                  from: sid
+	                  key: sid
 	                });
 
 	              case 5:
@@ -38938,7 +39778,7 @@ this.Twilio.Conversations = (function (exports) {
 	                  updateData.lastConsumedMessageIndex = data.lastConsumedMessageIndex;
 	                }
 
-	                if (!isDeepEqual(updateData, {})) {
+	                if (!isEqual(updateData, {})) {
 	                  conversation._update(updateData);
 	                }
 
@@ -39642,7 +40482,7 @@ this.Twilio.Conversations = (function (exports) {
 	  this.data = data.data || {};
 	};
 
-	var version = "2.0.0-rc.3";
+	var version = "2.0.1-rc.5";
 
 	function ownKeys$1(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
@@ -40726,6 +41566,13 @@ this.Twilio.Conversations = (function (exports) {
 	     * The factory method will automatically trigger connection.
 	     * Do not use it if you need finer-grained control.
 	     *
+	     * Since this method returns an already-initialized client, some of the events
+	     * will be lost because they happen *before* the initialization. It is
+	     * recommended that `client.onWithReplay` is used as opposed to `client.on`
+	     * for subscribing to client events. The `client.onWithReplay` will re-emit
+	     * the most recent value for a given event if it emitted before the
+	     * subscription.
+	     *
 	     * @param token Access token.
 	     * @param options Options to customize the client.
 	     * @returns Returns a fully initialized client.
@@ -40892,6 +41739,7 @@ this.Twilio.Conversations = (function (exports) {
 	exports.Media = Media;
 	exports.Message = Message;
 	exports.MessageBuilder = MessageBuilder;
+	exports.NotificationTypes = NotificationTypes;
 	exports.Participant = Participant;
 	exports.PushNotification = PushNotification;
 	exports.RestPaginator = RestPaginator;