How to use semver

isLowerThanOrEqualTo(otherVersion) {
    module.exports.validate(this.version);
    module.exports.validate(otherVersion);

    return semver.lte(otherVersion, this.version);
  }

function getRange(json, name) {
 if (has(json, name)) {
  const object = json[name]

  if (has(object, "esm")) {
   return validRange(object.esm)
  }
 }

 return null
}

const testIfKafkaVersion = (version, versionComparator) => {
 const scopedTest = (description, callback, testFn = test) => {
  return versionComparator(semver.coerce(process.env.KAFKA_VERSION), semver.coerce(version))
   ? testFn(description, callback)
   : test.skip(description, callback)
 }

 scopedTest.only = (description, callback) => scopedTest(description, callback, test.only)

 return scopedTest
}

// Helper to determine whether we should use mutagen or not
const shouldMutagen = (dockerVersion = '0.0.0') => {
 // Only do this on non linux
 if (process.platform !== 'darwin') return false;
 // Otherwise return if we have sufficient docker version
 return semver.gte(dockerVersion, '2.3.30');
}

getCurrentVersion().then(({ latest, beta }) => {
 console.log(`Current Latest: ${latest}, Beta: ${beta}`)
 const { major, minor } = parse(latest)
 const [tag, currentBeta] = prerelease(beta)
 const newStable = `${major}.${minor + 1}.0`
 const newBeta = sameStableVersion(newStable, beta) ? currentBeta + 1 : 0
 const newBetaVersion = `${newStable}-${tag}.${newBeta}`
 console.log(`New beta: ${newBetaVersion}`)
 console.log(`##vso[task.setvariable variable=PRE_RELEASE_VERSION;isOutput=true]${newBetaVersion}`)
})

function compatible(compatibleSDK) {
 return function (clientSDK) {
  if (typeof clientSDK === 'string') {
   clientSDK = fromString(clientSDK);
  } // REST API, or custom SDK


  if (!clientSDK) {
   return true;
  }

  const clientVersion = clientSDK.version;
  const compatiblityVersion = compatibleSDK[clientSDK.sdk];
  return semver.satisfies(clientVersion, compatiblityVersion);
 };
}

beforeAll(async () => {
    if (
     semver.satisfies(process.env.MONGODB_VERSION, '>=4.0.4') &&
     process.env.MONGODB_TOPOLOGY === 'replicaset' &&
     process.env.MONGODB_STORAGE_ENGINE === 'wiredTiger'
    ) {
     await reconfigureServer({
      databaseAdapter: undefined,
      databaseURI:
       'mongodb://localhost:27017/parseServerMongoAdapterTestDatabase?replicaSet=replicaset',
     });
    }
   });

releases.find((release) => !release.lts && semver.gte(release.version, '5.0.0'))

isPrerelease() {
    return Boolean(semver.prerelease(this.version));
  }

function majorStr (release) {
 return `v${semver.major(release.version)}.x`
}

getNewVersionFrom(input) {
    module.exports.validate(this.version);
    if (!module.exports.isValidInput(input)) {
      throw new Error(`Version should be either ${module.exports.SEMVER_INCREMENTS.join(', ')} or a valid semver version.`);
    }

    return module.exports.SEMVER_INCREMENTS.includes(input) ? semver.inc(this.version, input) : input;
  }

satisfies(range) {
    module.exports.validate(this.version);
    return semver.satisfies(this.version, range, {
      includePrerelease: true
    });
  }

isGreaterThanOrEqualTo(otherVersion) {
    module.exports.validate(this.version);
    module.exports.validate(otherVersion);

    return semver.gte(otherVersion, this.version);
  }

beforeAll(async () => {
    if (
     semver.satisfies(process.env.MONGODB_VERSION, '>=4.0.4') &&
     process.env.MONGODB_TOPOLOGY === 'replicaset' &&
     process.env.MONGODB_STORAGE_ENGINE === 'wiredTiger'
    ) {
     await reconfigureServer({
      databaseAdapter: undefined,
      databaseURI:
       'mongodb://localhost:27017/parseServerMongoAdapterTestDatabase?replicaSet=replicaset',
     });
    }
   });

function compatible(compatibleSDK) {
 return function(clientSDK) {
  if (typeof clientSDK === 'string') {
   clientSDK = fromString(clientSDK);
  }
  // REST API, or custom SDK
  if (!clientSDK) {
   return true;
  }
  const clientVersion = clientSDK.version;
  const compatiblityVersion = compatibleSDK[clientSDK.sdk];
  return semver.satisfies(clientVersion, compatiblityVersion);
 };
}