@twilio/conversations 2.0.1-rc.8 → 2.0.1-rc.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -265,20 +265,20 @@ this.Twilio.Conversations = (function (exports) {
265
265
  var Deno = global$A.Deno;
266
266
  var versions = process$3 && process$3.versions || Deno && Deno.version;
267
267
  var v8 = versions && versions.v8;
268
- var match, version$3;
268
+ var match, version$2;
269
269
 
270
270
  if (v8) {
271
271
  match = v8.split('.');
272
- version$3 = match[0] < 4 ? 1 : match[0] + match[1];
272
+ version$2 = match[0] < 4 ? 1 : match[0] + match[1];
273
273
  } else if (userAgent$5) {
274
274
  match = userAgent$5.match(/Edge\/(\d+)/);
275
275
  if (!match || match[1] >= 74) {
276
276
  match = userAgent$5.match(/Chrome\/(\d+)/);
277
- if (match) version$3 = match[1];
277
+ if (match) version$2 = match[1];
278
278
  }
279
279
  }
280
280
 
281
- var engineV8Version = version$3 && +version$3;
281
+ var engineV8Version = version$2 && +version$2;
282
282
 
283
283
  /* eslint-disable es/no-symbol -- required for testing */
284
284
 
@@ -4497,7 +4497,7 @@ this.Twilio.Conversations = (function (exports) {
4497
4497
  * @return {Object} - With a property for each part of the pattern
4498
4498
  */
4499
4499
 
4500
- var parse$1 = parse_1 = lib.parse = function parse(durationString) {
4500
+ var parse = parse_1 = lib.parse = function parse(durationString) {
4501
4501
  // Slice away first entry in match-array
4502
4502
  return durationString.match(pattern).slice(1).reduce(function (prev, next, idx) {
4503
4503
  prev[objMap[idx]] = parseFloat(next) || 0;
@@ -4549,7 +4549,7 @@ this.Twilio.Conversations = (function (exports) {
4549
4549
  end: end,
4550
4550
  toSeconds: toSeconds,
4551
4551
  pattern: pattern,
4552
- parse: parse$1
4552
+ parse: parse
4553
4553
  };
4554
4554
 
4555
4555
  function ownKeys$4(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; }
@@ -12238,60 +12238,62 @@ this.Twilio.Conversations = (function (exports) {
12238
12238
  });
12239
12239
  })(stateMachine);
12240
12240
 
12241
- // Unique ID creation requires a high quality random # generator. In the browser we therefore
12242
- // require the crypto API and do not support built-in fallback to lower quality random number
12243
- // generators (like Math.random()).
12244
- var getRandomValues;
12245
- var rnds8 = new Uint8Array(16);
12246
- function rng() {
12247
- // lazy load so that environments that need to polyfill have a chance to do so
12248
- if (!getRandomValues) {
12249
- // getRandomValues needs to be invoked in a context where "this" is a Crypto implementation. Also,
12250
- // find the complete implementation of crypto (msCrypto) on IE11.
12251
- getRandomValues = typeof crypto !== 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto !== 'undefined' && typeof msCrypto.getRandomValues === 'function' && msCrypto.getRandomValues.bind(msCrypto);
12241
+ var rngBrowser = {exports: {}};
12252
12242
 
12253
- if (!getRandomValues) {
12254
- throw new Error('crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported');
12255
- }
12256
- }
12243
+ // browser this is a little complicated due to unknown quality of Math.random()
12244
+ // and inconsistent support for the `crypto` API. We do the best we can via
12245
+ // feature-detection
12246
+ // getRandomValues needs to be invoked in a context where "this" is a Crypto
12247
+ // implementation. Also, find the complete implementation of crypto on IE11.
12257
12248
 
12258
- return getRandomValues(rnds8);
12259
- }
12249
+ var getRandomValues = typeof crypto != 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto != 'undefined' && typeof window.msCrypto.getRandomValues == 'function' && msCrypto.getRandomValues.bind(msCrypto);
12250
+
12251
+ if (getRandomValues) {
12252
+ // WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto
12253
+ var rnds8 = new Uint8Array(16); // eslint-disable-line no-undef
12254
+
12255
+ rngBrowser.exports = function whatwgRNG() {
12256
+ getRandomValues(rnds8);
12257
+ return rnds8;
12258
+ };
12259
+ } else {
12260
+ // Math.random()-based (RNG)
12261
+ //
12262
+ // If all else fails, use Math.random(). It's fast, but is of unspecified
12263
+ // quality.
12264
+ var rnds = new Array(16);
12260
12265
 
12261
- var REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i;
12266
+ rngBrowser.exports = function mathRNG() {
12267
+ for (var i = 0, r; i < 16; i++) {
12268
+ if ((i & 0x03) === 0) r = Math.random() * 0x100000000;
12269
+ rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
12270
+ }
12262
12271
 
12263
- function validate(uuid) {
12264
- return typeof uuid === 'string' && REGEX.test(uuid);
12272
+ return rnds;
12273
+ };
12265
12274
  }
12266
12275
 
12267
12276
  /**
12268
12277
  * Convert array of 16 byte values to UUID string format of the form:
12269
12278
  * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
12270
12279
  */
12271
-
12272
12280
  var byteToHex = [];
12273
12281
 
12274
12282
  for (var i = 0; i < 256; ++i) {
12275
- byteToHex.push((i + 0x100).toString(16).substr(1));
12283
+ byteToHex[i] = (i + 0x100).toString(16).substr(1);
12276
12284
  }
12277
12285
 
12278
- function stringify(arr) {
12279
- var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; // Note: Be careful editing this code! It's been tuned for performance
12280
- // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
12286
+ function bytesToUuid$2(buf, offset) {
12287
+ var i = offset || 0;
12288
+ var bth = byteToHex; // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4
12281
12289
 
12282
- var uuid = (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + '-' + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + '-' + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + '-' + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + '-' + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase(); // Consistency check for valid UUID. If this throws, it's likely due to one
12283
- // of the following:
12284
- // - One or more input array values don't map to a hex octet (leading to
12285
- // "undefined" in the uuid)
12286
- // - Invalid input values for the RFC `version` or `variant` fields
12287
-
12288
- if (!validate(uuid)) {
12289
- throw TypeError('Stringified UUID is invalid');
12290
- }
12291
-
12292
- return uuid;
12290
+ return [bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], '-', bth[buf[i++]], bth[buf[i++]], '-', bth[buf[i++]], bth[buf[i++]], '-', bth[buf[i++]], bth[buf[i++]], '-', bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]]].join('');
12293
12291
  }
12294
12292
 
12293
+ var bytesToUuid_1 = bytesToUuid$2;
12294
+
12295
+ var rng$1 = rngBrowser.exports;
12296
+ var bytesToUuid$1 = bytesToUuid_1; // **`v1()` - Generate time-based UUID**
12295
12297
  //
12296
12298
  // Inspired by https://github.com/LiosK/UUID.js
12297
12299
  // and http://docs.python.org/library/uuid.html
@@ -12304,9 +12306,9 @@ this.Twilio.Conversations = (function (exports) {
12304
12306
  var _lastMSecs = 0;
12305
12307
  var _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details
12306
12308
 
12307
- function v1(options, buf, offset) {
12309
+ function v1$1(options, buf, offset) {
12308
12310
  var i = buf && offset || 0;
12309
- var b = buf || new Array(16);
12311
+ var b = buf || [];
12310
12312
  options = options || {};
12311
12313
  var node = options.node || _nodeId;
12312
12314
  var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not
@@ -12314,7 +12316,7 @@ this.Twilio.Conversations = (function (exports) {
12314
12316
  // system entropy. See #189
12315
12317
 
12316
12318
  if (node == null || clockseq == null) {
12317
- var seedBytes = options.random || (options.rng || rng)();
12319
+ var seedBytes = rng$1();
12318
12320
 
12319
12321
  if (node == null) {
12320
12322
  // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
@@ -12331,7 +12333,7 @@ this.Twilio.Conversations = (function (exports) {
12331
12333
  // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
12332
12334
 
12333
12335
 
12334
- var msecs = options.msecs !== undefined ? options.msecs : Date.now(); // Per 4.2.1.2, use count of uuid's generated during the current clock
12336
+ var msecs = options.msecs !== undefined ? options.msecs : new Date().getTime(); // Per 4.2.1.2, use count of uuid's generated during the current clock
12335
12337
  // cycle to simulate higher resolution clock
12336
12338
 
12337
12339
  var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs)
@@ -12350,7 +12352,7 @@ this.Twilio.Conversations = (function (exports) {
12350
12352
 
12351
12353
 
12352
12354
  if (nsecs >= 10000) {
12353
- throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");
12355
+ throw new Error('uuid.v1(): Can\'t create more than 10M uuids/sec');
12354
12356
  }
12355
12357
 
12356
12358
  _lastMSecs = msecs;
@@ -12381,320 +12383,22 @@ this.Twilio.Conversations = (function (exports) {
12381
12383
  b[i + n] = node[n];
12382
12384
  }
12383
12385
 
12384
- return buf || stringify(b);
12385
- }
12386
-
12387
- function parse(uuid) {
12388
- if (!validate(uuid)) {
12389
- throw TypeError('Invalid UUID');
12390
- }
12391
-
12392
- var v;
12393
- var arr = new Uint8Array(16); // Parse ########-....-....-....-............
12394
-
12395
- arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
12396
- arr[1] = v >>> 16 & 0xff;
12397
- arr[2] = v >>> 8 & 0xff;
12398
- arr[3] = v & 0xff; // Parse ........-####-....-....-............
12399
-
12400
- arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
12401
- arr[5] = v & 0xff; // Parse ........-....-####-....-............
12402
-
12403
- arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
12404
- arr[7] = v & 0xff; // Parse ........-....-....-####-............
12405
-
12406
- arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
12407
- arr[9] = v & 0xff; // Parse ........-....-....-....-############
12408
- // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
12409
-
12410
- arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000 & 0xff;
12411
- arr[11] = v / 0x100000000 & 0xff;
12412
- arr[12] = v >>> 24 & 0xff;
12413
- arr[13] = v >>> 16 & 0xff;
12414
- arr[14] = v >>> 8 & 0xff;
12415
- arr[15] = v & 0xff;
12416
- return arr;
12417
- }
12418
-
12419
- function stringToBytes(str) {
12420
- str = unescape(encodeURIComponent(str)); // UTF8 escape
12421
-
12422
- var bytes = [];
12423
-
12424
- for (var i = 0; i < str.length; ++i) {
12425
- bytes.push(str.charCodeAt(i));
12426
- }
12427
-
12428
- return bytes;
12429
- }
12430
-
12431
- var DNS = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
12432
- var URL$1 = '6ba7b811-9dad-11d1-80b4-00c04fd430c8';
12433
- function v35 (name, version, hashfunc) {
12434
- function generateUUID(value, namespace, buf, offset) {
12435
- if (typeof value === 'string') {
12436
- value = stringToBytes(value);
12437
- }
12438
-
12439
- if (typeof namespace === 'string') {
12440
- namespace = parse(namespace);
12441
- }
12442
-
12443
- if (namespace.length !== 16) {
12444
- throw TypeError('Namespace must be array-like (16 iterable integer values, 0-255)');
12445
- } // Compute hash of namespace and value, Per 4.3
12446
- // Future: Use spread syntax when supported on all platforms, e.g. `bytes =
12447
- // hashfunc([...namespace, ... value])`
12448
-
12449
-
12450
- var bytes = new Uint8Array(16 + value.length);
12451
- bytes.set(namespace);
12452
- bytes.set(value, namespace.length);
12453
- bytes = hashfunc(bytes);
12454
- bytes[6] = bytes[6] & 0x0f | version;
12455
- bytes[8] = bytes[8] & 0x3f | 0x80;
12456
-
12457
- if (buf) {
12458
- offset = offset || 0;
12459
-
12460
- for (var i = 0; i < 16; ++i) {
12461
- buf[offset + i] = bytes[i];
12462
- }
12463
-
12464
- return buf;
12465
- }
12466
-
12467
- return stringify(bytes);
12468
- } // Function#name is not settable on some platforms (#270)
12469
-
12470
-
12471
- try {
12472
- generateUUID.name = name; // eslint-disable-next-line no-empty
12473
- } catch (err) {} // For CommonJS default export support
12474
-
12475
-
12476
- generateUUID.DNS = DNS;
12477
- generateUUID.URL = URL$1;
12478
- return generateUUID;
12479
- }
12480
-
12481
- /*
12482
- * Browser-compatible JavaScript MD5
12483
- *
12484
- * Modification of JavaScript MD5
12485
- * https://github.com/blueimp/JavaScript-MD5
12486
- *
12487
- * Copyright 2011, Sebastian Tschan
12488
- * https://blueimp.net
12489
- *
12490
- * Licensed under the MIT license:
12491
- * https://opensource.org/licenses/MIT
12492
- *
12493
- * Based on
12494
- * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message
12495
- * Digest Algorithm, as defined in RFC 1321.
12496
- * Version 2.2 Copyright (C) Paul Johnston 1999 - 2009
12497
- * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
12498
- * Distributed under the BSD License
12499
- * See http://pajhome.org.uk/crypt/md5 for more info.
12500
- */
12501
- function md5(bytes) {
12502
- if (typeof bytes === 'string') {
12503
- var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
12504
-
12505
- bytes = new Uint8Array(msg.length);
12506
-
12507
- for (var i = 0; i < msg.length; ++i) {
12508
- bytes[i] = msg.charCodeAt(i);
12509
- }
12510
- }
12511
-
12512
- return md5ToHexEncodedArray(wordsToMd5(bytesToWords(bytes), bytes.length * 8));
12513
- }
12514
- /*
12515
- * Convert an array of little-endian words to an array of bytes
12516
- */
12517
-
12518
-
12519
- function md5ToHexEncodedArray(input) {
12520
- var output = [];
12521
- var length32 = input.length * 32;
12522
- var hexTab = '0123456789abcdef';
12523
-
12524
- for (var i = 0; i < length32; i += 8) {
12525
- var x = input[i >> 5] >>> i % 32 & 0xff;
12526
- var hex = parseInt(hexTab.charAt(x >>> 4 & 0x0f) + hexTab.charAt(x & 0x0f), 16);
12527
- output.push(hex);
12528
- }
12529
-
12530
- return output;
12386
+ return buf ? buf : bytesToUuid$1(b);
12531
12387
  }
12532
- /**
12533
- * Calculate output length with padding and bit length
12534
- */
12535
12388
 
12389
+ var v1_1 = v1$1;
12536
12390
 
12537
- function getOutputLength(inputLength8) {
12538
- return (inputLength8 + 64 >>> 9 << 4) + 14 + 1;
12539
- }
12540
- /*
12541
- * Calculate the MD5 of an array of little-endian words, and a bit length.
12542
- */
12543
-
12391
+ var rng = rngBrowser.exports;
12392
+ var bytesToUuid = bytesToUuid_1;
12544
12393
 
12545
- function wordsToMd5(x, len) {
12546
- /* append padding */
12547
- x[len >> 5] |= 0x80 << len % 32;
12548
- x[getOutputLength(len) - 1] = len;
12549
- var a = 1732584193;
12550
- var b = -271733879;
12551
- var c = -1732584194;
12552
- var d = 271733878;
12553
-
12554
- for (var i = 0; i < x.length; i += 16) {
12555
- var olda = a;
12556
- var oldb = b;
12557
- var oldc = c;
12558
- var oldd = d;
12559
- a = md5ff(a, b, c, d, x[i], 7, -680876936);
12560
- d = md5ff(d, a, b, c, x[i + 1], 12, -389564586);
12561
- c = md5ff(c, d, a, b, x[i + 2], 17, 606105819);
12562
- b = md5ff(b, c, d, a, x[i + 3], 22, -1044525330);
12563
- a = md5ff(a, b, c, d, x[i + 4], 7, -176418897);
12564
- d = md5ff(d, a, b, c, x[i + 5], 12, 1200080426);
12565
- c = md5ff(c, d, a, b, x[i + 6], 17, -1473231341);
12566
- b = md5ff(b, c, d, a, x[i + 7], 22, -45705983);
12567
- a = md5ff(a, b, c, d, x[i + 8], 7, 1770035416);
12568
- d = md5ff(d, a, b, c, x[i + 9], 12, -1958414417);
12569
- c = md5ff(c, d, a, b, x[i + 10], 17, -42063);
12570
- b = md5ff(b, c, d, a, x[i + 11], 22, -1990404162);
12571
- a = md5ff(a, b, c, d, x[i + 12], 7, 1804603682);
12572
- d = md5ff(d, a, b, c, x[i + 13], 12, -40341101);
12573
- c = md5ff(c, d, a, b, x[i + 14], 17, -1502002290);
12574
- b = md5ff(b, c, d, a, x[i + 15], 22, 1236535329);
12575
- a = md5gg(a, b, c, d, x[i + 1], 5, -165796510);
12576
- d = md5gg(d, a, b, c, x[i + 6], 9, -1069501632);
12577
- c = md5gg(c, d, a, b, x[i + 11], 14, 643717713);
12578
- b = md5gg(b, c, d, a, x[i], 20, -373897302);
12579
- a = md5gg(a, b, c, d, x[i + 5], 5, -701558691);
12580
- d = md5gg(d, a, b, c, x[i + 10], 9, 38016083);
12581
- c = md5gg(c, d, a, b, x[i + 15], 14, -660478335);
12582
- b = md5gg(b, c, d, a, x[i + 4], 20, -405537848);
12583
- a = md5gg(a, b, c, d, x[i + 9], 5, 568446438);
12584
- d = md5gg(d, a, b, c, x[i + 14], 9, -1019803690);
12585
- c = md5gg(c, d, a, b, x[i + 3], 14, -187363961);
12586
- b = md5gg(b, c, d, a, x[i + 8], 20, 1163531501);
12587
- a = md5gg(a, b, c, d, x[i + 13], 5, -1444681467);
12588
- d = md5gg(d, a, b, c, x[i + 2], 9, -51403784);
12589
- c = md5gg(c, d, a, b, x[i + 7], 14, 1735328473);
12590
- b = md5gg(b, c, d, a, x[i + 12], 20, -1926607734);
12591
- a = md5hh(a, b, c, d, x[i + 5], 4, -378558);
12592
- d = md5hh(d, a, b, c, x[i + 8], 11, -2022574463);
12593
- c = md5hh(c, d, a, b, x[i + 11], 16, 1839030562);
12594
- b = md5hh(b, c, d, a, x[i + 14], 23, -35309556);
12595
- a = md5hh(a, b, c, d, x[i + 1], 4, -1530992060);
12596
- d = md5hh(d, a, b, c, x[i + 4], 11, 1272893353);
12597
- c = md5hh(c, d, a, b, x[i + 7], 16, -155497632);
12598
- b = md5hh(b, c, d, a, x[i + 10], 23, -1094730640);
12599
- a = md5hh(a, b, c, d, x[i + 13], 4, 681279174);
12600
- d = md5hh(d, a, b, c, x[i], 11, -358537222);
12601
- c = md5hh(c, d, a, b, x[i + 3], 16, -722521979);
12602
- b = md5hh(b, c, d, a, x[i + 6], 23, 76029189);
12603
- a = md5hh(a, b, c, d, x[i + 9], 4, -640364487);
12604
- d = md5hh(d, a, b, c, x[i + 12], 11, -421815835);
12605
- c = md5hh(c, d, a, b, x[i + 15], 16, 530742520);
12606
- b = md5hh(b, c, d, a, x[i + 2], 23, -995338651);
12607
- a = md5ii(a, b, c, d, x[i], 6, -198630844);
12608
- d = md5ii(d, a, b, c, x[i + 7], 10, 1126891415);
12609
- c = md5ii(c, d, a, b, x[i + 14], 15, -1416354905);
12610
- b = md5ii(b, c, d, a, x[i + 5], 21, -57434055);
12611
- a = md5ii(a, b, c, d, x[i + 12], 6, 1700485571);
12612
- d = md5ii(d, a, b, c, x[i + 3], 10, -1894986606);
12613
- c = md5ii(c, d, a, b, x[i + 10], 15, -1051523);
12614
- b = md5ii(b, c, d, a, x[i + 1], 21, -2054922799);
12615
- a = md5ii(a, b, c, d, x[i + 8], 6, 1873313359);
12616
- d = md5ii(d, a, b, c, x[i + 15], 10, -30611744);
12617
- c = md5ii(c, d, a, b, x[i + 6], 15, -1560198380);
12618
- b = md5ii(b, c, d, a, x[i + 13], 21, 1309151649);
12619
- a = md5ii(a, b, c, d, x[i + 4], 6, -145523070);
12620
- d = md5ii(d, a, b, c, x[i + 11], 10, -1120210379);
12621
- c = md5ii(c, d, a, b, x[i + 2], 15, 718787259);
12622
- b = md5ii(b, c, d, a, x[i + 9], 21, -343485551);
12623
- a = safeAdd(a, olda);
12624
- b = safeAdd(b, oldb);
12625
- c = safeAdd(c, oldc);
12626
- d = safeAdd(d, oldd);
12627
- }
12628
-
12629
- return [a, b, c, d];
12630
- }
12631
- /*
12632
- * Convert an array bytes to an array of little-endian words
12633
- * Characters >255 have their high-byte silently ignored.
12634
- */
12635
-
12636
-
12637
- function bytesToWords(input) {
12638
- if (input.length === 0) {
12639
- return [];
12640
- }
12641
-
12642
- var length8 = input.length * 8;
12643
- var output = new Uint32Array(getOutputLength(length8));
12394
+ function v4$1(options, buf, offset) {
12395
+ var i = buf && offset || 0;
12644
12396
 
12645
- for (var i = 0; i < length8; i += 8) {
12646
- output[i >> 5] |= (input[i / 8] & 0xff) << i % 32;
12397
+ if (typeof options == 'string') {
12398
+ buf = options === 'binary' ? new Array(16) : null;
12399
+ options = null;
12647
12400
  }
12648
12401
 
12649
- return output;
12650
- }
12651
- /*
12652
- * Add integers, wrapping at 2^32. This uses 16-bit operations internally
12653
- * to work around bugs in some JS interpreters.
12654
- */
12655
-
12656
-
12657
- function safeAdd(x, y) {
12658
- var lsw = (x & 0xffff) + (y & 0xffff);
12659
- var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
12660
- return msw << 16 | lsw & 0xffff;
12661
- }
12662
- /*
12663
- * Bitwise rotate a 32-bit number to the left.
12664
- */
12665
-
12666
-
12667
- function bitRotateLeft(num, cnt) {
12668
- return num << cnt | num >>> 32 - cnt;
12669
- }
12670
- /*
12671
- * These functions implement the four basic operations the algorithm uses.
12672
- */
12673
-
12674
-
12675
- function md5cmn(q, a, b, x, s, t) {
12676
- return safeAdd(bitRotateLeft(safeAdd(safeAdd(a, q), safeAdd(x, t)), s), b);
12677
- }
12678
-
12679
- function md5ff(a, b, c, d, x, s, t) {
12680
- return md5cmn(b & c | ~b & d, a, b, x, s, t);
12681
- }
12682
-
12683
- function md5gg(a, b, c, d, x, s, t) {
12684
- return md5cmn(b & d | c & ~d, a, b, x, s, t);
12685
- }
12686
-
12687
- function md5hh(a, b, c, d, x, s, t) {
12688
- return md5cmn(b ^ c ^ d, a, b, x, s, t);
12689
- }
12690
-
12691
- function md5ii(a, b, c, d, x, s, t) {
12692
- return md5cmn(c ^ (b | ~d), a, b, x, s, t);
12693
- }
12694
-
12695
- var v3 = v35('v3', 0x30, md5);
12696
-
12697
- function v4(options, buf, offset) {
12698
12402
  options = options || {};
12699
12403
  var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
12700
12404
 
@@ -12702,139 +12406,22 @@ this.Twilio.Conversations = (function (exports) {
12702
12406
  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
12703
12407
 
12704
12408
  if (buf) {
12705
- offset = offset || 0;
12706
-
12707
- for (var i = 0; i < 16; ++i) {
12708
- buf[offset + i] = rnds[i];
12409
+ for (var ii = 0; ii < 16; ++ii) {
12410
+ buf[i + ii] = rnds[ii];
12709
12411
  }
12710
-
12711
- return buf;
12712
12412
  }
12713
12413
 
12714
- return stringify(rnds);
12414
+ return buf || bytesToUuid(rnds);
12715
12415
  }
12716
12416
 
12717
- // Adapted from Chris Veness' SHA1 code at
12718
- // http://www.movable-type.co.uk/scripts/sha1.html
12719
- function f(s, x, y, z) {
12720
- switch (s) {
12721
- case 0:
12722
- return x & y ^ ~x & z;
12723
-
12724
- case 1:
12725
- return x ^ y ^ z;
12726
-
12727
- case 2:
12728
- return x & y ^ x & z ^ y & z;
12729
-
12730
- case 3:
12731
- return x ^ y ^ z;
12732
- }
12733
- }
12734
-
12735
- function ROTL(x, n) {
12736
- return x << n | x >>> 32 - n;
12737
- }
12738
-
12739
- function sha1(bytes) {
12740
- var K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];
12741
- var H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
12742
-
12743
- if (typeof bytes === 'string') {
12744
- var msg = unescape(encodeURIComponent(bytes)); // UTF8 escape
12745
-
12746
- bytes = [];
12747
-
12748
- for (var i = 0; i < msg.length; ++i) {
12749
- bytes.push(msg.charCodeAt(i));
12750
- }
12751
- } else if (!Array.isArray(bytes)) {
12752
- // Convert Array-like to Array
12753
- bytes = Array.prototype.slice.call(bytes);
12754
- }
12755
-
12756
- bytes.push(0x80);
12757
- var l = bytes.length / 4 + 2;
12758
- var N = Math.ceil(l / 16);
12759
- var M = new Array(N);
12760
-
12761
- for (var _i = 0; _i < N; ++_i) {
12762
- var arr = new Uint32Array(16);
12763
-
12764
- for (var j = 0; j < 16; ++j) {
12765
- arr[j] = bytes[_i * 64 + j * 4] << 24 | bytes[_i * 64 + j * 4 + 1] << 16 | bytes[_i * 64 + j * 4 + 2] << 8 | bytes[_i * 64 + j * 4 + 3];
12766
- }
12767
-
12768
- M[_i] = arr;
12769
- }
12770
-
12771
- M[N - 1][14] = (bytes.length - 1) * 8 / Math.pow(2, 32);
12772
- M[N - 1][14] = Math.floor(M[N - 1][14]);
12773
- M[N - 1][15] = (bytes.length - 1) * 8 & 0xffffffff;
12774
-
12775
- for (var _i2 = 0; _i2 < N; ++_i2) {
12776
- var W = new Uint32Array(80);
12777
-
12778
- for (var t = 0; t < 16; ++t) {
12779
- W[t] = M[_i2][t];
12780
- }
12781
-
12782
- for (var _t = 16; _t < 80; ++_t) {
12783
- W[_t] = ROTL(W[_t - 3] ^ W[_t - 8] ^ W[_t - 14] ^ W[_t - 16], 1);
12784
- }
12785
-
12786
- var a = H[0];
12787
- var b = H[1];
12788
- var c = H[2];
12789
- var d = H[3];
12790
- var e = H[4];
12791
-
12792
- for (var _t2 = 0; _t2 < 80; ++_t2) {
12793
- var s = Math.floor(_t2 / 20);
12794
- var T = ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[_t2] >>> 0;
12795
- e = d;
12796
- d = c;
12797
- c = ROTL(b, 30) >>> 0;
12798
- b = a;
12799
- a = T;
12800
- }
12801
-
12802
- H[0] = H[0] + a >>> 0;
12803
- H[1] = H[1] + b >>> 0;
12804
- H[2] = H[2] + c >>> 0;
12805
- H[3] = H[3] + d >>> 0;
12806
- H[4] = H[4] + e >>> 0;
12807
- }
12808
-
12809
- return [H[0] >> 24 & 0xff, H[0] >> 16 & 0xff, H[0] >> 8 & 0xff, H[0] & 0xff, H[1] >> 24 & 0xff, H[1] >> 16 & 0xff, H[1] >> 8 & 0xff, H[1] & 0xff, H[2] >> 24 & 0xff, H[2] >> 16 & 0xff, H[2] >> 8 & 0xff, H[2] & 0xff, H[3] >> 24 & 0xff, H[3] >> 16 & 0xff, H[3] >> 8 & 0xff, H[3] & 0xff, H[4] >> 24 & 0xff, H[4] >> 16 & 0xff, H[4] >> 8 & 0xff, H[4] & 0xff];
12810
- }
12811
-
12812
- var v5 = v35('v5', 0x50, sha1);
12813
-
12814
- var nil = '00000000-0000-0000-0000-000000000000';
12815
-
12816
- function version$2(uuid) {
12817
- if (!validate(uuid)) {
12818
- throw TypeError('Invalid UUID');
12819
- }
12820
-
12821
- return parseInt(uuid.substr(14, 1), 16);
12822
- }
12823
-
12824
- var esmBrowser = /*#__PURE__*/Object.freeze({
12825
- __proto__: null,
12826
- v1: v1,
12827
- v3: v3,
12828
- v4: v4,
12829
- v5: v5,
12830
- NIL: nil,
12831
- version: version$2,
12832
- validate: validate,
12833
- stringify: stringify,
12834
- parse: parse
12835
- });
12417
+ var v4_1 = v4$1;
12836
12418
 
12837
- var require$$16 = /*@__PURE__*/getAugmentedNamespace(esmBrowser);
12419
+ var v1 = v1_1;
12420
+ var v4 = v4_1;
12421
+ var uuid$1 = v4;
12422
+ uuid$1.v1 = v1;
12423
+ uuid$1.v4 = v4;
12424
+ var uuid_1 = uuid$1;
12838
12425
 
12839
12426
  var typedArrayConstructor = {exports: {}};
12840
12427
 
@@ -15958,7 +15545,7 @@ this.Twilio.Conversations = (function (exports) {
15958
15545
  var declarativeTypeValidator = browser$6;
15959
15546
  var loglevelLog = loglevel.exports;
15960
15547
  var StateMachine = stateMachine.exports;
15961
- var uuid = require$$16;
15548
+ var uuid = uuid_1;
15962
15549
  var _wrapNativeSuper = wrapNativeSuper.exports;
15963
15550
  var operationRetrier = browser$4;
15964
15551
  var platform = platform$1.exports;
@@ -16606,7 +16193,7 @@ this.Twilio.Conversations = (function (exports) {
16606
16193
  }();
16607
16194
 
16608
16195
  var logInstance = new Logger("");
16609
- var version = "0.12.1-rc.5";
16196
+ var version = "0.12.1-rc.6";
16610
16197
  /**
16611
16198
  * Settings container for the Twilsock client library
16612
16199
  */
@@ -20459,7 +20046,7 @@ this.Twilio.Conversations = (function (exports) {
20459
20046
  var _slicedToArray = slicedToArray.exports;
20460
20047
  var _toConsumableArray = toConsumableArray.exports;
20461
20048
  var logger = loglevel.exports;
20462
- var uuid = require$$16;
20049
+ var uuid = uuid_1;
20463
20050
  var declarativeTypeValidator = browser$6;
20464
20051
 
20465
20052
  function _interopDefaultLegacy(e) {
@@ -22168,7 +21755,7 @@ this.Twilio.Conversations = (function (exports) {
22168
21755
  var loglevelLog = loglevel.exports;
22169
21756
  var _slicedToArray = slicedToArray.exports;
22170
21757
  var operationRetrier = browser$4;
22171
- var uuid = require$$16;
21758
+ var uuid = uuid_1;
22172
21759
  var _get = get$1.exports;
22173
21760
  var platform = platform$1.exports;
22174
21761
 
@@ -30965,7 +30552,7 @@ this.Twilio.Conversations = (function (exports) {
30965
30552
 
30966
30553
  __decorate([declarativeTypeValidator.validateTypes(declarativeTypeValidator.nonEmptyString), __metadata("design:type", Function), __metadata("design:paramtypes", [String]), __metadata("design:returntype", void 0)], InstantQuery.prototype, "updateIndexName", null);
30967
30554
 
30968
- var version$1 = "3.0.6-rc.5";
30555
+ var version$1 = "3.0.6-rc.6";
30969
30556
 
30970
30557
  function _createSuper$9(Derived) {
30971
30558
  var hasNativeReflectConstruct = _isNativeReflectConstruct$a();
@@ -40715,7 +40302,7 @@ this.Twilio.Conversations = (function (exports) {
40715
40302
  this.data = data.data || {};
40716
40303
  };
40717
40304
 
40718
- var version = "2.0.1-rc.8";
40305
+ var version = "2.0.1-rc.9";
40719
40306
 
40720
40307
  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; }
40721
40308
 
@@ -40883,7 +40470,7 @@ this.Twilio.Conversations = (function (exports) {
40883
40470
  case 0:
40884
40471
  _context3.next = 2;
40885
40472
  return this._makeRequest(method, url, requestBody, {
40886
- 'X-Twilio-Mutation-Id': v4()
40473
+ 'X-Twilio-Mutation-Id': uuid_1.v4()
40887
40474
  });
40888
40475
 
40889
40476
  case 2: