@neurosity/sdk 6.5.10 → 6.5.11

package/dist/browser/neurosity.iife.js

@@ -42871,7 +42871,7 @@ var Neurosity = (function (exports) {
           this.firebaseApp = new FirebaseApp(options);
           this.firebaseUser = new FirebaseUser(this.firebaseApp);
           this._selectedDevice.next(undefined);
-          this.status$ = heartbeatAwareStatus(this.observeNamespace("status").pipe(share())).pipe(filterInternalKeys(), shareReplay(1));
+          this.status$ = heartbeatAwareStatus(this.observeNamespace("status").pipe(shareReplay(1))).pipe(filterInternalKeys(), shareReplay(1));
           this.osVersion$ = this.observeNamespace("info/osVersion").pipe(shareReplay(1));
           this.firebaseUser.onAuthStateChanged().subscribe((user) => {
               this.user = user;
@@ -44511,7 +44511,7 @@ var Neurosity = (function (exports) {
   };
 
   // eslint-disable-next-line strict
-  var PlatformFormData = null;
+  var httpAdapter = null;
 
   /**
    * Determines if the given thing is a array or js object.
@@ -45965,7 +45965,7 @@ var Neurosity = (function (exports) {
   };
 
   const knownAdapters = {
-    http: PlatformFormData,
+    http: httpAdapter,
     xhr: xhrAdapter
   };
 
@@ -47281,7 +47281,6 @@ var Neurosity = (function (exports) {
       return fromArrayBuffer(value, encodingOrOffset, length)
     }
 
-
     if (typeof value === 'number') {
       throw new TypeError(
         'The "value" argument must not be of type number. Received type number'
@@ -47464,7 +47463,6 @@ var Neurosity = (function (exports) {
     }
   }
 
-
   function checked (length) {
     // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
     // length is NaN (which is otherwise coerced to zero.)
@@ -47575,7 +47573,6 @@ var Neurosity = (function (exports) {
     return buffer
   };
 
-
   function byteLength (string, encoding) {
     if (Buffer.isBuffer(string)) {
       return string.length
@@ -48172,7 +48169,6 @@ var Neurosity = (function (exports) {
     return decodeCodePointsArray(res)
   }
 
-
   // Based on http://stackoverflow.com/a/22747272/680742, the browser with
   // the lowest limit is Chrome, with 0x10000 args.
   // We go 1 magnitude less, for safety
@@ -50642,30 +50638,78 @@ var Neurosity = (function (exports) {
   // Max safe segment length for coercion.
   const MAX_SAFE_COMPONENT_LENGTH = 16;
 
+  // Max safe length for a build identifier. The max length minus 6 characters for
+  // the shortest version with a build 0.0.0+BUILD.
+  const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
+
+  const RELEASE_TYPES = [
+    'major',
+    'premajor',
+    'minor',
+    'preminor',
+    'patch',
+    'prepatch',
+    'prerelease',
+  ];
+
   var constants = {
-    SEMVER_SPEC_VERSION,
     MAX_LENGTH,
-    MAX_SAFE_INTEGER,
     MAX_SAFE_COMPONENT_LENGTH,
+    MAX_SAFE_BUILD_LENGTH,
+    MAX_SAFE_INTEGER,
+    RELEASE_TYPES,
+    SEMVER_SPEC_VERSION,
+    FLAG_INCLUDE_PRERELEASE: 0b001,
+    FLAG_LOOSE: 0b010,
   };
 
   var re_1 = createCommonjsModule(function (module, exports) {
-  const { MAX_SAFE_COMPONENT_LENGTH } = constants;
+  const {
+    MAX_SAFE_COMPONENT_LENGTH,
+    MAX_SAFE_BUILD_LENGTH,
+    MAX_LENGTH,
+  } = constants;
 
   exports = module.exports = {};
 
   // The actual regexps go on exports.re
   const re = exports.re = [];
+  const safeRe = exports.safeRe = [];
   const src = exports.src = [];
   const t = exports.t = {};
   let R = 0;
 
+  const LETTERDASHNUMBER = '[a-zA-Z0-9-]';
+
+  // Replace some greedy regex tokens to prevent regex dos issues. These regex are
+  // used internally via the safeRe object since all inputs in this library get
+  // normalized first to trim and collapse all extra whitespace. The original
+  // regexes are exported for userland consumption and lower level usage. A
+  // future breaking change could export the safer regex only with a note that
+  // all input should have extra whitespace removed.
+  const safeRegexReplacements = [
+    ['\\s', 1],
+    ['\\d', MAX_LENGTH],
+    [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],
+  ];
+
+  const makeSafeRegex = (value) => {
+    for (const [token, max] of safeRegexReplacements) {
+      value = value
+        .split(`${token}*`).join(`${token}{0,${max}}`)
+        .split(`${token}+`).join(`${token}{1,${max}}`);
+    }
+    return value
+  };
+
   const createToken = (name, value, isGlobal) => {
+    const safe = makeSafeRegex(value);
     const index = R++;
     debug_1(name, index, value);
     t[name] = index;
     src[index] = value;
     re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
+    safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined);
   };
 
   // The following Regular Expressions can be used for tokenizing,
@@ -50675,13 +50719,13 @@ var Neurosity = (function (exports) {
   // A single `0`, or a non-zero digit followed by zero or more digits.
 
   createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*');
-  createToken('NUMERICIDENTIFIERLOOSE', '[0-9]+');
+  createToken('NUMERICIDENTIFIERLOOSE', '\\d+');
 
   // ## Non-numeric Identifier
   // Zero or more digits, followed by a letter or hyphen, and then zero or
   // more letters, digits, or hyphens.
 
-  createToken('NONNUMERICIDENTIFIER', '\\d*[a-zA-Z-][a-zA-Z0-9-]*');
+  createToken('NONNUMERICIDENTIFIER', `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
 
   // ## Main Version
   // Three dot-separated numeric identifiers.
@@ -50716,7 +50760,7 @@ var Neurosity = (function (exports) {
   // ## Build Metadata Identifier
   // Any combination of digits, letters, or hyphens.
 
-  createToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+');
+  createToken('BUILDIDENTIFIER', `${LETTERDASHNUMBER}+`);
 
   // ## Build Metadata
   // Plus sign, followed by one or more period-separated build metadata
@@ -50776,12 +50820,17 @@ var Neurosity = (function (exports) {
 
   // Coercion.
   // Extract anything that could conceivably be a part of a valid semver
-  createToken('COERCE', `${'(^|[^\\d])' +
+  createToken('COERCEPLAIN', `${'(^|[^\\d])' +
               '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
                 `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
-                `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
+                `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+  createToken('COERCE', `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+  createToken('COERCEFULL', src[t.COERCEPLAIN] +
+                `(?:${src[t.PRERELEASE]})?` +
+                `(?:${src[t.BUILD]})?` +
                 `(?:$|[^\\d])`);
   createToken('COERCERTL', src[t.COERCE], true);
+  createToken('COERCERTLFULL', src[t.COERCEFULL], true);
 
   // Tilde ranges.
   // Meaning is "reasonably at or greater than"
@@ -50834,22 +50883,27 @@ var Neurosity = (function (exports) {
   createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$');
   });
   var re_2 = re_1.re;
-  var re_3 = re_1.src;
-  var re_4 = re_1.t;
-  var re_5 = re_1.tildeTrimReplace;
-  var re_6 = re_1.caretTrimReplace;
-  var re_7 = re_1.comparatorTrimReplace;
-
-  // parse out just the options we care about so we always get a consistent
-  // obj with keys in a consistent order.
-  const opts = ['includePrerelease', 'loose', 'rtl'];
-  const parseOptions = options =>
-    !options ? {}
-    : typeof options !== 'object' ? { loose: true }
-    : opts.filter(k => options[k]).reduce((o, k) => {
-      o[k] = true;
-      return o
-    }, {});
+  var re_3 = re_1.safeRe;
+  var re_4 = re_1.src;
+  var re_5 = re_1.t;
+  var re_6 = re_1.tildeTrimReplace;
+  var re_7 = re_1.caretTrimReplace;
+  var re_8 = re_1.comparatorTrimReplace;
+
+  // parse out just the options we care about
+  const looseOption = Object.freeze({ loose: true });
+  const emptyOpts = Object.freeze({ });
+  const parseOptions = options => {
+    if (!options) {
+      return emptyOpts
+    }
+
+    if (typeof options !== 'object') {
+      return looseOption
+    }
+
+    return options
+  };
   var parseOptions_1 = parseOptions;
 
   const numeric = /^[0-9]+$/;
@@ -50877,7 +50931,7 @@ var Neurosity = (function (exports) {
   };
 
   const { MAX_LENGTH: MAX_LENGTH$1, MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1 } = constants;
-  const { re: re$1, t: t$1 } = re_1;
+  const { safeRe: re$1, t: t$1 } = re_1;
 
 
   const { compareIdentifiers: compareIdentifiers$1 } = identifiers;
@@ -50893,7 +50947,7 @@ var Neurosity = (function (exports) {
           version = version.version;
         }
       } else if (typeof version !== 'string') {
-        throw new TypeError(`Invalid Version: ${version}`)
+        throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`)
       }
 
       if (version.length > MAX_LENGTH$1) {
@@ -51035,7 +51089,7 @@ var Neurosity = (function (exports) {
       do {
         const a = this.build[i];
         const b = other.build[i];
-        debug_1('prerelease compare', i, a, b);
+        debug_1('build compare', i, a, b);
         if (a === undefined && b === undefined) {
           return 0
         } else if (b === undefined) {
@@ -51052,36 +51106,36 @@ var Neurosity = (function (exports) {
 
     // preminor will bump the version up to the next minor release, and immediately
     // down to pre-release. premajor and prepatch work the same way.
-    inc (release, identifier) {
+    inc (release, identifier, identifierBase) {
       switch (release) {
         case 'premajor':
           this.prerelease.length = 0;
           this.patch = 0;
           this.minor = 0;
           this.major++;
-          this.inc('pre', identifier);
+          this.inc('pre', identifier, identifierBase);
           break
         case 'preminor':
           this.prerelease.length = 0;
           this.patch = 0;
           this.minor++;
-          this.inc('pre', identifier);
+          this.inc('pre', identifier, identifierBase);
           break
         case 'prepatch':
           // If this is already a prerelease, it will bump to the next version
           // drop any prereleases that might already exist, since they are not
           // relevant at this point.
           this.prerelease.length = 0;
-          this.inc('patch', identifier);
-          this.inc('pre', identifier);
+          this.inc('patch', identifier, identifierBase);
+          this.inc('pre', identifier, identifierBase);
           break
         // If the input is a non-prerelease version, this acts the same as
         // prepatch.
         case 'prerelease':
           if (this.prerelease.length === 0) {
-            this.inc('patch', identifier);
+            this.inc('patch', identifier, identifierBase);
           }
-          this.inc('pre', identifier);
+          this.inc('pre', identifier, identifierBase);
           break
 
         case 'major':
@@ -51123,9 +51177,15 @@ var Neurosity = (function (exports) {
           break
         // This probably shouldn't be used publicly.
         // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
-        case 'pre':
+        case 'pre': {
+          const base = Number(identifierBase) ? 1 : 0;
+
+          if (!identifier && identifierBase === false) {
+            throw new Error('invalid increment argument: identifier is empty')
+          }
+
           if (this.prerelease.length === 0) {
-            this.prerelease = [0];
+            this.prerelease = [base];
           } else {
             let i = this.prerelease.length;
             while (--i >= 0) {
@@ -51136,27 +51196,36 @@ var Neurosity = (function (exports) {
             }
             if (i === -1) {
               // didn't increment anything
-              this.prerelease.push(0);
+              if (identifier === this.prerelease.join('.') && identifierBase === false) {
+                throw new Error('invalid increment argument: identifier already exists')
+              }
+              this.prerelease.push(base);
             }
           }
           if (identifier) {
             // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
             // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+            let prerelease = [identifier, base];
+            if (identifierBase === false) {
+              prerelease = [identifier];
+            }
             if (compareIdentifiers$1(this.prerelease[0], identifier) === 0) {
               if (isNaN(this.prerelease[1])) {
-                this.prerelease = [identifier, 0];
+                this.prerelease = prerelease;
               }
             } else {
-              this.prerelease = [identifier, 0];
+              this.prerelease = prerelease;
             }
           }
           break
-
+        }
         default:
           throw new Error(`invalid increment argument: ${release}`)
       }
-      this.format();
-      this.raw = this.version;
+      this.raw = this.format();
+      if (this.build.length) {
+        this.raw += `+${this.build.join('.')}`;
+      }
       return this
     }
   }