strong-tie/inbound-calls

1semver(1) -- The semantic versioner for npm2===========================================3 4## Install5 6```bash7npm install semver8````9 10## Usage11 12As a node module:13 14```js15const semver = require('semver')16 17semver.valid('1.2.3') // '1.2.3'18semver.valid('a.b.c') // null19semver.clean('  =v1.2.3   ') // '1.2.3'20semver.satisfies('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3') // true21semver.gt('1.2.3', '9.8.7') // false22semver.lt('1.2.3', '9.8.7') // true23semver.minVersion('>=1.0.0') // '1.0.0'24semver.valid(semver.coerce('v2')) // '2.0.0'25semver.valid(semver.coerce('42.6.7.9.3-alpha')) // '42.6.7'26```27 28You can also just load the module for the function that you care about if29you'd like to minimize your footprint.30 31```js32// load the whole API at once in a single object33const semver = require('semver')34 35// or just load the bits you need36// all of them listed here, just pick and choose what you want37 38// classes39const SemVer = require('semver/classes/semver')40const Comparator = require('semver/classes/comparator')41const Range = require('semver/classes/range')42 43// functions for working with versions44const semverParse = require('semver/functions/parse')45const semverValid = require('semver/functions/valid')46const semverClean = require('semver/functions/clean')47const semverInc = require('semver/functions/inc')48const semverDiff = require('semver/functions/diff')49const semverMajor = require('semver/functions/major')50const semverMinor = require('semver/functions/minor')51const semverPatch = require('semver/functions/patch')52const semverPrerelease = require('semver/functions/prerelease')53const semverCompare = require('semver/functions/compare')54const semverRcompare = require('semver/functions/rcompare')55const semverCompareLoose = require('semver/functions/compare-loose')56const semverCompareBuild = require('semver/functions/compare-build')57const semverSort = require('semver/functions/sort')58const semverRsort = require('semver/functions/rsort')59 60// low-level comparators between versions61const semverGt = require('semver/functions/gt')62const semverLt = require('semver/functions/lt')63const semverEq = require('semver/functions/eq')64const semverNeq = require('semver/functions/neq')65const semverGte = require('semver/functions/gte')66const semverLte = require('semver/functions/lte')67const semverCmp = require('semver/functions/cmp')68const semverCoerce = require('semver/functions/coerce')69 70// working with ranges71const semverSatisfies = require('semver/functions/satisfies')72const semverMaxSatisfying = require('semver/ranges/max-satisfying')73const semverMinSatisfying = require('semver/ranges/min-satisfying')74const semverToComparators = require('semver/ranges/to-comparators')75const semverMinVersion = require('semver/ranges/min-version')76const semverValidRange = require('semver/ranges/valid')77const semverOutside = require('semver/ranges/outside')78const semverGtr = require('semver/ranges/gtr')79const semverLtr = require('semver/ranges/ltr')80const semverIntersects = require('semver/ranges/intersects')81const semverSimplifyRange = require('semver/ranges/simplify')82const semverRangeSubset = require('semver/ranges/subset')83```84 85As a command-line utility:86 87```88$ semver -h89 90A JavaScript implementation of the https://semver.org/ specification91Copyright Isaac Z. Schlueter92 93Usage: semver [options] <version> [<version> [...]]94Prints valid versions sorted by SemVer precedence95 96Options:97-r --range <range>98        Print versions that match the specified range.99 100-i --increment [<level>]101        Increment a version by the specified level.  Level can102        be one of: major, minor, patch, premajor, preminor,103        prepatch, prerelease, or release.  Default level is 'patch'.104        Only one version may be specified.105 106--preid <identifier>107        Identifier to be used to prefix premajor, preminor,108        prepatch or prerelease version increments.109 110-l --loose111        Interpret versions and ranges loosely112 113-n <0|1>114        This is the base to be used for the prerelease identifier.115 116-p --include-prerelease117        Always include prerelease versions in range matching118 119-c --coerce120        Coerce a string into SemVer if possible121        (does not imply --loose)122 123--rtl124        Coerce version strings right to left125 126--ltr127        Coerce version strings left to right (default)128 129Program exits successfully if any valid version satisfies130all supplied ranges, and prints all satisfying versions.131 132If no satisfying versions are found, then exits failure.133 134Versions are printed in ascending order, so supplying135multiple versions to the utility will just sort them.136```137 138## Versions139 140A "version" is described by the `v2.0.0` specification found at141<https://semver.org/>.142 143A leading `"="` or `"v"` character is stripped off and ignored.144Support for stripping a leading "v" is kept for compatibility with `v1.0.0` of the SemVer145specification but should not be used anymore.146 147## Ranges148 149A `version range` is a set of `comparators` that specify versions150that satisfy the range.151 152A `comparator` is composed of an `operator` and a `version`.  The set153of primitive `operators` is:154 155* `<` Less than156* `<=` Less than or equal to157* `>` Greater than158* `>=` Greater than or equal to159* `=` Equal.  If no operator is specified, then equality is assumed,160  so this operator is optional but MAY be included.161 162For example, the comparator `>=1.2.7` would match the versions163`1.2.7`, `1.2.8`, `2.5.3`, and `1.3.9`, but not the versions `1.2.6`164or `1.1.0`. The comparator `>1` is equivalent to `>=2.0.0` and165would match the versions `2.0.0` and `3.1.0`, but not the versions166`1.0.1` or `1.1.0`.167 168Comparators can be joined by whitespace to form a `comparator set`,169which is satisfied by the **intersection** of all of the comparators170it includes.171 172A range is composed of one or more comparator sets, joined by `||`.  A173version matches a range if and only if every comparator in at least174one of the `||`-separated comparator sets is satisfied by the version.175 176For example, the range `>=1.2.7 <1.3.0` would match the versions177`1.2.7`, `1.2.8`, and `1.2.99`, but not the versions `1.2.6`, `1.3.0`,178or `1.1.0`.179 180The range `1.2.7 || >=1.2.9 <2.0.0` would match the versions `1.2.7`,181`1.2.9`, and `1.4.6`, but not the versions `1.2.8` or `2.0.0`.182 183### Prerelease Tags184 185If a version has a prerelease tag (for example, `1.2.3-alpha.3`) then186it will only be allowed to satisfy comparator sets if at least one187comparator with the same `[major, minor, patch]` tuple also has a188prerelease tag.189 190For example, the range `>1.2.3-alpha.3` would be allowed to match the191version `1.2.3-alpha.7`, but it would *not* be satisfied by192`3.4.5-alpha.9`, even though `3.4.5-alpha.9` is technically "greater193than" `1.2.3-alpha.3` according to the SemVer sort rules.  The version194range only accepts prerelease tags on the `1.2.3` version.195Version `3.4.5` *would* satisfy the range because it does not have a196prerelease flag, and `3.4.5` is greater than `1.2.3-alpha.7`.197 198The purpose of this behavior is twofold.  First, prerelease versions199frequently are updated very quickly, and contain many breaking changes200that are (by the author's design) not yet fit for public consumption.201Therefore, by default, they are excluded from range-matching202semantics.203 204Second, a user who has opted into using a prerelease version has205indicated the intent to use *that specific* set of206alpha/beta/rc versions.  By including a prerelease tag in the range,207the user is indicating that they are aware of the risk.  However, it208is still not appropriate to assume that they have opted into taking a209similar risk on the *next* set of prerelease versions.210 211Note that this behavior can be suppressed (treating all prerelease212versions as if they were normal versions, for range-matching)213by setting the `includePrerelease` flag on the options214object to any215[functions](https://github.com/npm/node-semver#functions) that do216range matching.217 218#### Prerelease Identifiers219 220The method `.inc` takes an additional `identifier` string argument that221will append the value of the string as a prerelease identifier:222 223```javascript224semver.inc('1.2.3', 'prerelease', 'beta')225// '1.2.4-beta.0'226```227 228command-line example:229 230```bash231$ semver 1.2.3 -i prerelease --preid beta2321.2.4-beta.0233```234 235Which then can be used to increment further:236 237```bash238$ semver 1.2.4-beta.0 -i prerelease2391.2.4-beta.1240```241 242To get out of the prerelease phase, use the `release` option:243 244```bash245$ semver 1.2.4-beta.1 -i release2461.2.4247```248 249#### Prerelease Identifier Base250 251The method `.inc` takes an optional parameter 'identifierBase' string252that will let you let your prerelease number as zero-based or one-based.253Set to `false` to omit the prerelease number altogether.254If you do not specify this parameter, it will default to zero-based.255 256```javascript257semver.inc('1.2.3', 'prerelease', 'beta', '1')258// '1.2.4-beta.1'259```260 261```javascript262semver.inc('1.2.3', 'prerelease', 'beta', false)263// '1.2.4-beta'264```265 266command-line example:267 268```bash269$ semver 1.2.3 -i prerelease --preid beta -n 12701.2.4-beta.1271```272 273```bash274$ semver 1.2.3 -i prerelease --preid beta -n false2751.2.4-beta276```277 278### Advanced Range Syntax279 280Advanced range syntax desugars to primitive comparators in281deterministic ways.282 283Advanced ranges may be combined in the same way as primitive284comparators using white space or `||`.285 286#### Hyphen Ranges `X.Y.Z - A.B.C`287 288Specifies an inclusive set.289 290* `1.2.3 - 2.3.4` := `>=1.2.3 <=2.3.4`291 292If a partial version is provided as the first version in the inclusive293range, then the missing pieces are replaced with zeroes.294 295* `1.2 - 2.3.4` := `>=1.2.0 <=2.3.4`296 297If a partial version is provided as the second version in the298inclusive range, then all versions that start with the supplied parts299of the tuple are accepted, but nothing that would be greater than the300provided tuple parts.301 302* `1.2.3 - 2.3` := `>=1.2.3 <2.4.0-0`303* `1.2.3 - 2` := `>=1.2.3 <3.0.0-0`304 305#### X-Ranges `1.2.x` `1.X` `1.2.*` `*`306 307Any of `X`, `x`, or `*` may be used to "stand in" for one of the308numeric values in the `[major, minor, patch]` tuple.309 310* `*` := `>=0.0.0` (Any non-prerelease version satisfies, unless311  `includePrerelease` is specified, in which case any version at all312  satisfies)313* `1.x` := `>=1.0.0 <2.0.0-0` (Matching major version)314* `1.2.x` := `>=1.2.0 <1.3.0-0` (Matching major and minor versions)315 316A partial version range is treated as an X-Range, so the special317character is in fact optional.318 319* `""` (empty string) := `*` := `>=0.0.0`320* `1` := `1.x.x` := `>=1.0.0 <2.0.0-0`321* `1.2` := `1.2.x` := `>=1.2.0 <1.3.0-0`322 323#### Tilde Ranges `~1.2.3` `~1.2` `~1`324 325Allows patch-level changes if a minor version is specified on the326comparator.  Allows minor-level changes if not.327 328* `~1.2.3` := `>=1.2.3 <1.(2+1).0` := `>=1.2.3 <1.3.0-0`329* `~1.2` := `>=1.2.0 <1.(2+1).0` := `>=1.2.0 <1.3.0-0` (Same as `1.2.x`)330* `~1` := `>=1.0.0 <(1+1).0.0` := `>=1.0.0 <2.0.0-0` (Same as `1.x`)331* `~0.2.3` := `>=0.2.3 <0.(2+1).0` := `>=0.2.3 <0.3.0-0`332* `~0.2` := `>=0.2.0 <0.(2+1).0` := `>=0.2.0 <0.3.0-0` (Same as `0.2.x`)333* `~0` := `>=0.0.0 <(0+1).0.0` := `>=0.0.0 <1.0.0-0` (Same as `0.x`)334* `~1.2.3-beta.2` := `>=1.2.3-beta.2 <1.3.0-0` Note that prereleases in335  the `1.2.3` version will be allowed, if they are greater than or336  equal to `beta.2`.  So, `1.2.3-beta.4` would be allowed, but337  `1.2.4-beta.2` would not, because it is a prerelease of a338  different `[major, minor, patch]` tuple.339 340#### Caret Ranges `^1.2.3` `^0.2.5` `^0.0.4`341 342Allows changes that do not modify the left-most non-zero element in the343`[major, minor, patch]` tuple.  In other words, this allows patch and344minor updates for versions `1.0.0` and above, patch updates for345versions `0.X >=0.1.0`, and *no* updates for versions `0.0.X`.346 347Many authors treat a `0.x` version as if the `x` were the major348"breaking-change" indicator.349 350Caret ranges are ideal when an author may make breaking changes351between `0.2.4` and `0.3.0` releases, which is a common practice.352However, it presumes that there will *not* be breaking changes between353`0.2.4` and `0.2.5`.  It allows for changes that are presumed to be354additive (but non-breaking), according to commonly observed practices.355 356* `^1.2.3` := `>=1.2.3 <2.0.0-0`357* `^0.2.3` := `>=0.2.3 <0.3.0-0`358* `^0.0.3` := `>=0.0.3 <0.0.4-0`359* `^1.2.3-beta.2` := `>=1.2.3-beta.2 <2.0.0-0` Note that prereleases in360  the `1.2.3` version will be allowed, if they are greater than or361  equal to `beta.2`.  So, `1.2.3-beta.4` would be allowed, but362  `1.2.4-beta.2` would not, because it is a prerelease of a363  different `[major, minor, patch]` tuple.364* `^0.0.3-beta` := `>=0.0.3-beta <0.0.4-0`  Note that prereleases in the365  `0.0.3` version *only* will be allowed, if they are greater than or366  equal to `beta`.  So, `0.0.3-pr.2` would be allowed.367 368When parsing caret ranges, a missing `patch` value desugars to the369number `0`, but will allow flexibility within that value, even if the370major and minor versions are both `0`.371 372* `^1.2.x` := `>=1.2.0 <2.0.0-0`373* `^0.0.x` := `>=0.0.0 <0.1.0-0`374* `^0.0` := `>=0.0.0 <0.1.0-0`375 376A missing `minor` and `patch` values will desugar to zero, but also377allow flexibility within those values, even if the major version is378zero.379 380* `^1.x` := `>=1.0.0 <2.0.0-0`381* `^0.x` := `>=0.0.0 <1.0.0-0`382 383### Range Grammar384 385Putting all this together, here is a Backus-Naur grammar for ranges,386for the benefit of parser authors:387 388```bnf389range-set  ::= range ( logical-or range ) *390logical-or ::= ( ' ' ) * '||' ( ' ' ) *391range      ::= hyphen | simple ( ' ' simple ) * | ''392hyphen     ::= partial ' - ' partial393simple     ::= primitive | partial | tilde | caret394primitive  ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial395partial    ::= xr ( '.' xr ( '.' xr qualifier ? )? )?396xr         ::= 'x' | 'X' | '*' | nr397nr         ::= '0' | ['1'-'9'] ( ['0'-'9'] ) *398tilde      ::= '~' partial399caret      ::= '^' partial400qualifier  ::= ( '-' pre )? ( '+' build )?401pre        ::= parts402build      ::= parts403parts      ::= part ( '.' part ) *404part       ::= nr | [-0-9A-Za-z]+405```406 407## Functions408 409All methods and classes take a final `options` object argument.  All410options in this object are `false` by default.  The options supported411are:412 413- `loose`: Be more forgiving about not-quite-valid semver strings.414  (Any resulting output will always be 100% strict compliant, of415  course.)  For backwards compatibility reasons, if the `options`416  argument is a boolean value instead of an object, it is interpreted417  to be the `loose` param.418- `includePrerelease`: Set to suppress the [default419  behavior](https://github.com/npm/node-semver#prerelease-tags) of420  excluding prerelease tagged versions from ranges unless they are421  explicitly opted into.422 423Strict-mode Comparators and Ranges will be strict about the SemVer424strings that they parse.425 426* `valid(v)`: Return the parsed version, or null if it's not valid.427* `inc(v, releaseType, options, identifier, identifierBase)`: 428  Return the version incremented by the release429  type (`major`, `premajor`, `minor`, `preminor`, `patch`,430  `prepatch`, `prerelease`, or `release`), or null if it's not valid431  * `premajor` in one call will bump the version up to the next major432    version and down to a prerelease of that major version.433    `preminor`, and `prepatch` work the same way.434  * If called from a non-prerelease version, `prerelease` will work the435    same as `prepatch`. It increments the patch version and then makes a436    prerelease. If the input version is already a prerelease it simply437    increments it.438  * `release` will remove any prerelease part of the version.439  * `identifier` can be used to prefix `premajor`, `preminor`,440    `prepatch`, or `prerelease` version increments. `identifierBase`441    is the base to be used for the `prerelease` identifier.442* `prerelease(v)`: Returns an array of prerelease components, or null443  if none exist. Example: `prerelease('1.2.3-alpha.1') -> ['alpha', 1]`444* `major(v)`: Return the major version number.445* `minor(v)`: Return the minor version number.446* `patch(v)`: Return the patch version number.447* `intersects(r1, r2, loose)`: Return true if the two supplied ranges448  or comparators intersect.449* `parse(v)`: Attempt to parse a string as a semantic version, returning either450  a `SemVer` object or `null`.451 452### Comparison453 454* `gt(v1, v2)`: `v1 > v2`455* `gte(v1, v2)`: `v1 >= v2`456* `lt(v1, v2)`: `v1 < v2`457* `lte(v1, v2)`: `v1 <= v2`458* `eq(v1, v2)`: `v1 == v2` This is true if they're logically equivalent,459  even if they're not the same string.  You already know how to460  compare strings.461* `neq(v1, v2)`: `v1 != v2` The opposite of `eq`.462* `cmp(v1, comparator, v2)`: Pass in a comparison string, and it'll call463  the corresponding function above.  `"==="` and `"!=="` do simple464  string comparison, but are included for completeness.  Throws if an465  invalid comparison string is provided.466* `compare(v1, v2)`: Return `0` if `v1 == v2`, or `1` if `v1` is greater, or `-1` if467  `v2` is greater.  Sorts in ascending order if passed to `Array.sort()`.468* `rcompare(v1, v2)`: The reverse of `compare`.  Sorts an array of versions469  in descending order when passed to `Array.sort()`.470* `compareBuild(v1, v2)`: The same as `compare` but considers `build` when two versions471  are equal.  Sorts in ascending order if passed to `Array.sort()`.472* `compareLoose(v1, v2)`: Short for `compare(v1, v2, { loose: true })`.473* `diff(v1, v2)`: Returns the difference between two versions by the release type474  (`major`, `premajor`, `minor`, `preminor`, `patch`, `prepatch`, or `prerelease`),475  or null if the versions are the same.476 477### Sorting478 479* `sort(versions)`: Returns a sorted array of versions based on the `compareBuild` 480  function.481* `rsort(versions)`: The reverse of `sort`. Returns an array of versions based on482  the `compareBuild` function in descending order.483 484### Comparators485 486* `intersects(comparator)`: Return true if the comparators intersect487 488### Ranges489 490* `validRange(range)`: Return the valid range or null if it's not valid.491* `satisfies(version, range)`: Return true if the version satisfies the492  range.493* `maxSatisfying(versions, range)`: Return the highest version in the list494  that satisfies the range, or `null` if none of them do.495* `minSatisfying(versions, range)`: Return the lowest version in the list496  that satisfies the range, or `null` if none of them do.497* `minVersion(range)`: Return the lowest version that can match498  the given range.499* `gtr(version, range)`: Return `true` if the version is greater than all the500  versions possible in the range.501* `ltr(version, range)`: Return `true` if the version is less than all the502  versions possible in the range.503* `outside(version, range, hilo)`: Return true if the version is outside504  the bounds of the range in either the high or low direction.  The505  `hilo` argument must be either the string `'>'` or `'<'`.  (This is506  the function called by `gtr` and `ltr`.)507* `intersects(range)`: Return true if any of the range comparators intersect.508* `simplifyRange(versions, range)`: Return a "simplified" range that509  matches the same items in the `versions` list as the range specified.  Note510  that it does *not* guarantee that it would match the same versions in all511  cases, only for the set of versions provided.  This is useful when512  generating ranges by joining together multiple versions with `||`513  programmatically, to provide the user with something a bit more514  ergonomic.  If the provided range is shorter in string-length than the515  generated range, then that is returned.516* `subset(subRange, superRange)`: Return `true` if the `subRange` range is517  entirely contained by the `superRange` range.518 519Note that, since ranges may be non-contiguous, a version might not be520greater than a range, less than a range, *or* satisfy a range!  For521example, the range `1.2 <1.2.9 || >2.0.0` would have a hole from `1.2.9`522until `2.0.0`, so version `1.2.10` would not be greater than the523range (because `2.0.1` satisfies, which is higher), nor less than the524range (since `1.2.8` satisfies, which is lower), and it also does not525satisfy the range.526 527If you want to know if a version satisfies or does not satisfy a528range, use the `satisfies(version, range)` function.529 530### Coercion531 532* `coerce(version, options)`: Coerces a string to semver if possible533 534This aims to provide a very forgiving translation of a non-semver string to535semver. It looks for the first digit in a string and consumes all536remaining characters which satisfy at least a partial semver (e.g., `1`,537`1.2`, `1.2.3`) up to the max permitted length (256 characters).  Longer538versions are simply truncated (`4.6.3.9.2-alpha2` becomes `4.6.3`).  All539surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes540`3.4.0`).  Only text which lacks digits will fail coercion (`version one`541is not valid).  The maximum length for any semver component considered for542coercion is 16 characters; longer components will be ignored543(`10000000000000000.4.7.4` becomes `4.7.4`).  The maximum value for any544semver component is `Number.MAX_SAFE_INTEGER || (2**53 - 1)`; higher value545components are invalid (`9999999999999999.4.7.4` is likely invalid).546 547If the `options.rtl` flag is set, then `coerce` will return the right-most548coercible tuple that does not share an ending index with a longer coercible549tuple.  For example, `1.2.3.4` will return `2.3.4` in rtl mode, not550`4.0.0`.  `1.2.3/4` will return `4.0.0`, because the `4` is not a part of551any other overlapping SemVer tuple.552 553If the `options.includePrerelease` flag is set, then the `coerce` result will contain554prerelease and build parts of a version.  For example, `1.2.3.4-rc.1+rev.2`555will preserve prerelease `rc.1` and build `rev.2` in the result.556 557### Clean558 559* `clean(version)`: Clean a string to be a valid semver if possible560 561This will return a cleaned and trimmed semver version. If the provided562version is not valid a null will be returned. This does not work for563ranges.564 565ex.566* `s.clean(' = v 2.1.5foo')`: `null`567* `s.clean(' = v 2.1.5foo', { loose: true })`: `'2.1.5-foo'`568* `s.clean(' = v 2.1.5-foo')`: `null`569* `s.clean(' = v 2.1.5-foo', { loose: true })`: `'2.1.5-foo'`570* `s.clean('=v2.1.5')`: `'2.1.5'`571* `s.clean('  =v2.1.5')`: `'2.1.5'`572* `s.clean('      2.1.5   ')`: `'2.1.5'`573* `s.clean('~1.0.0')`: `null`574 575## Constants576 577As a convenience, helper constants are exported to provide information about what `node-semver` supports:578 579### `RELEASE_TYPES`580 581- major582- premajor583- minor584- preminor585- patch586- prepatch587- prerelease588 589```590const semver = require('semver');591 592if (semver.RELEASE_TYPES.includes(arbitraryUserInput)) {593  console.log('This is a valid release type!');594} else {595  console.warn('This is NOT a valid release type!');596}597```598 599### `SEMVER_SPEC_VERSION`600 6012.0.0602 603```604const semver = require('semver');605 606console.log('We are currently using the semver specification version:', semver.SEMVER_SPEC_VERSION);607```608 609## Exported Modules610 611<!--612TODO: Make sure that all of these items are documented (classes aren't,613eg), and then pull the module name into the documentation for that specific614thing.615-->616 617You may pull in just the part of this semver utility that you need if you618are sensitive to packing and tree-shaking concerns.  The main619`require('semver')` export uses getter functions to lazily load the parts620of the API that are used.621 622The following modules are available:623 624* `require('semver')`625* `require('semver/classes')`626* `require('semver/classes/comparator')`627* `require('semver/classes/range')`628* `require('semver/classes/semver')`629* `require('semver/functions/clean')`630* `require('semver/functions/cmp')`631* `require('semver/functions/coerce')`632* `require('semver/functions/compare')`633* `require('semver/functions/compare-build')`634* `require('semver/functions/compare-loose')`635* `require('semver/functions/diff')`636* `require('semver/functions/eq')`637* `require('semver/functions/gt')`638* `require('semver/functions/gte')`639* `require('semver/functions/inc')`640* `require('semver/functions/lt')`641* `require('semver/functions/lte')`642* `require('semver/functions/major')`643* `require('semver/functions/minor')`644* `require('semver/functions/neq')`645* `require('semver/functions/parse')`646* `require('semver/functions/patch')`647* `require('semver/functions/prerelease')`648* `require('semver/functions/rcompare')`649* `require('semver/functions/rsort')`650* `require('semver/functions/satisfies')`651* `require('semver/functions/sort')`652* `require('semver/functions/valid')`653* `require('semver/ranges/gtr')`654* `require('semver/ranges/intersects')`655* `require('semver/ranges/ltr')`656* `require('semver/ranges/max-satisfying')`657* `require('semver/ranges/min-satisfying')`658* `require('semver/ranges/min-version')`659* `require('semver/ranges/outside')`660* `require('semver/ranges/simplify')`661* `require('semver/ranges/subset')`662* `require('semver/ranges/to-comparators')`663* `require('semver/ranges/valid')`664 665