{"version":3,"sources":["../src/constants.ts","../src/regex.ts","../src/utils/parseOptions.ts","../src/utils/format.ts","../src/functions/parse.ts","../src/functions/clean.ts","../src/utils/compareIdentifiers.ts","../src/functions/compareCore.ts","../src/functions/compare.ts","../src/functions/eq.ts","../src/functions/gt.ts","../src/functions/gte.ts","../src/functions/lt.ts","../src/functions/lte.ts","../src/functions/neq.ts","../src/functions/cmp.ts","../src/functions/coerce.ts","../src/functions/compareBuild.ts","../src/functions/compareLoose.ts","../src/functions/diff.ts","../src/functions/inc.ts","../src/functions/major.ts","../src/functions/minor.ts","../src/functions/patch.ts","../src/functions/prerelease.ts","../src/functions/rcompare.ts","../src/functions/rsort.ts","../src/functions/sort.ts","../src/functions/valid.ts"],"names":["major","minor","patch","prerelease"],"mappings":"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","file":"index.cjs","sourcesContent":["// eslint-disable-next-line compat/compat\nexport const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991\n","// result of re[t.????] from https://github.com/npm/node-semver/blob/main/internal/re.js\n\n// FULL\n/**\n * Regular expression to match semver strings in the form `major.minor.patch-prerelease+build`\n */\nexport const FULL =\n /^v?(0|[1-9]\\d{0,256})\\.(0|[1-9]\\d{0,256})\\.(0|[1-9]\\d{0,256})(?:-((?:0|[1-9]\\d{0,256}|\\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250})(?:\\.(?:0|[1-9]\\d{0,256}|\\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250}))*))?(?:\\+([a-zA-Z0-9-]{1,250}(?:\\.[a-zA-Z0-9-]{1,250})*))?$/\n\nexport const LOOSE =\n /^[v=\\s]*(\\d{1,256})\\.(\\d{1,256})\\.(\\d{1,256})(?:-?((?:\\d{1,256}|\\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250})(?:\\.(?:\\d{1,256}|\\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250}))*))?(?:\\+([a-zA-Z0-9-]{1,250}(?:\\.[a-zA-Z0-9-]{1,250})*))?$/\n\nexport const COERCEFULL =\n /(^|[^\\d])(\\d{1,16})(?:\\.(\\d{1,16}))?(?:\\.(\\d{1,16}))?(?:(?:-((?:0|[1-9]\\d{0,256}|\\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250})(?:\\.(?:0|[1-9]\\d{0,256}|\\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250}))*)))?(?:(?:\\+([a-zA-Z0-9-]{1,250}(?:\\.[a-zA-Z0-9-]{1,250})*)))?(?:$|[^\\d])/\n\nexport const COERCE =\n /(^|[^\\d])(\\d{1,16})(?:\\.(\\d{1,16}))?(?:\\.(\\d{1,16}))?(?:$|[^\\d])/\n\nexport const COERCERTLFULL =\n /(^|[^\\d])(\\d{1,16})(?:\\.(\\d{1,16}))?(?:\\.(\\d{1,16}))?(?:(?:-((?:0|[1-9]\\d{0,256}|\\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250})(?:\\.(?:0|[1-9]\\d{0,256}|\\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250}))*)))?(?:(?:\\+([a-zA-Z0-9-]{1,250}(?:\\.[a-zA-Z0-9-]{1,250})*)))?(?:$|[^\\d])/g\n\nexport const COERCERTL =\n /(^|[^\\d])(\\d{1,16})(?:\\.(\\d{1,16}))?(?:\\.(\\d{1,16}))?(?:$|[^\\d])/g\n\nexport const PRERELEASE =\n /^(?:-((?:0|[1-9]\\d{0,256}|\\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250})(?:\\.(?:0|[1-9]\\d{0,256}|\\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250}))*))$/\n\nexport const PRERELEASELOOSE =\n /^(?:-?((?:\\d{1,256}|\\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250})(?:\\.(?:\\d{1,256}|\\d{0,256}[a-zA-Z-][a-zA-Z0-9-]{0,250}))*))$/\n","import { Options } from '../types/Options'\n\n// same as https://github.com/npm/node-semver/blob/main/internal/parse-options.js\nconst parseOptions = (options?: boolean | Options) => {\n if (!options) {\n return false\n } else if (typeof options !== 'object') {\n return true\n }\n return !!options.loose\n}\n\nexport default parseOptions\n","const format = (\n major: number,\n minor: number,\n patch: number,\n prerelease: ReadonlyArray,\n build: ReadonlyArray,\n) => {\n // version does not contain build\n let version = `${major}.${minor}.${patch}`\n if (prerelease.length) {\n version += `-${prerelease.join('.')}`\n }\n let fullVersion = version\n if (build.length) {\n fullVersion += `+${build.join('.')}`\n }\n return [version, fullVersion]\n}\n\nexport default format\n","import { MAX_SAFE_INTEGER } from '../constants'\nimport { Options } from '../types/Options'\nimport ParsedVersion from '../types/ParsedVersion'\nimport { FULL, LOOSE } from '../regex'\nimport parseOptions from '../utils/parseOptions'\nimport format from '../utils/format'\n\nconst MAX_LENGTH = 256\n\n// For internal use, used only by `parse()`\nconst parseThrow = (\n ver: string,\n optionsOrLoose?: boolean | Options,\n): ParsedVersion => {\n if (typeof ver !== 'string') {\n throw new TypeError(\n `Invalid version. Must be a string. Got type \"${typeof ver}\".`,\n )\n }\n\n if (ver.length > MAX_LENGTH) {\n throw new TypeError(`version is longer than ${MAX_LENGTH} characters`)\n }\n\n const loose = parseOptions(optionsOrLoose)\n\n const m = ver.trim().match(loose ? LOOSE : FULL)\n\n if (!m) {\n throw new TypeError(`Invalid Version: ${ver}`)\n }\n\n const major = +m[1]\n const minor = +m[2]\n const patch = +m[3]\n\n // we do check MAX_SAFE_INTEGER\n if (major > MAX_SAFE_INTEGER || major < 0) {\n throw new TypeError('Invalid major version')\n }\n\n if (minor > MAX_SAFE_INTEGER || minor < 0) {\n throw new TypeError('Invalid minor version')\n }\n\n if (patch > MAX_SAFE_INTEGER || patch < 0) {\n throw new TypeError('Invalid patch version')\n }\n\n const prerelease: ReadonlyArray = !m[4]\n ? []\n : m[4].split('.').map((id) => {\n if (/^[0-9]+$/.test(id)) {\n const num = +id\n if (num >= 0 && num < MAX_SAFE_INTEGER) {\n return num\n }\n }\n return id\n })\n\n const build = m[5] ? m[5].split('.') : []\n\n const [version, fullVersion] = format(major, minor, patch, prerelease, build)\n\n return { version, fullVersion, major, minor, patch, prerelease, build }\n}\n\n/**\n * Return the parsed version of a semver string, if the semver string is not valid, it returns `null` or throws an error depending on the value of `throwErrors`\n *\n * @param ver version string\n * @param optionsOrLoose an options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings\n * @param throwErrors whether to throw an error if the version string is invalid or if there are other errors. Defaults to `false`\n *\n * @returns parsed version object, or `null` if the version string is invalid or if there are other errors (if `throwErrors` is truthy, an error will be thrown instead of returning `null`)\n *\n * @throws TypeError if the version string is invalid or if there are other errors (if `throwErrors` is falsy, it will return `null` instead of throwing an error)\n *\n * @example\n * ```js\n * parse('1.2.3') // { version: '1.2.3', fullVersion: \"1.2.3\", major: 1, minor: 2, patch: 3, prerelease: [], build: [] }\n * parse('1.2.3-foo.bar+build.123') // { version: '1.2.3-foo.bar', fullVersion: \"1.2.3-foo.bar+build.123\", major: 1, minor: 2, patch: 3, prerelease: ['foo', 'bar'], build: ['build', '123'] }\n * parse('1.2') // null\n * parse('1.2', { loose: true }, true) // throws TypeError: Invalid Version: 1.2\n * ```\n *\n * @remarks build identifier (`[+BUILD]`) is taken into account\n */\nconst parse = (\n ver: string,\n optionsOrLoose?: boolean | Options,\n throwErrors?: T,\n): T extends true ? ParsedVersion : ParsedVersion | null => {\n try {\n return parseThrow(ver, optionsOrLoose)\n } catch (err) {\n if (!throwErrors) {\n return null as unknown as ParsedVersion\n }\n throw err\n }\n}\n\nexport default parse\n","import { Options } from '../types/Options'\nimport parse from './parse'\n\n/**\n * Returns cleaned (removed leading/trailing whitespace, remove '=', 'v' prefixes) and parsed version, or `null` if version is invalid.\n *\n * @param version version string\n * @param optionsOrLoose an options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings\n *\n * @returns cleaned version string or `null` if version is invalid\n *\n * @example\n * ```js\n * clean(' =v1.2.3 ') // '1.2.3'\n * ```\n */\nconst clean = (version: string, optionsOrLoose?: boolean | Options) => {\n const s = parse(version.trim().replace(/^[=v]+/, ''), optionsOrLoose)\n return s ? s.version : null\n}\n\nexport default clean\n","const numericRegex = /^[0-9]+$/\n\n/**\n * Compare two identifiers.\n *\n * @param a first identifier\n * @param b second identifier\n *\n * @returns\n * - `0` if `v1` == `v2`\n * - `1` if `v1` > `v2`\n * - `-1` if `v1` < `v2`\n *\n * @example\n * ```js\n * compareIdentifiers('3', '6') // -1\n * compareIdentifiers('s6g1', '6df4') // 1\n * ```\n */\nconst compareIdentifiers = (a: string | number, b: string | number) => {\n let _a: string | number = a.toString()\n let _b: string | number = b.toString()\n\n const anum = numericRegex.test(_a)\n const bnum = numericRegex.test(_b)\n\n if (anum && bnum) {\n _a = +_a\n _b = +_b\n }\n\n return _a === _b\n ? 0\n : anum && !bnum\n ? -1\n : bnum && !anum\n ? 1\n : _a < _b\n ? -1\n : 1\n}\n\nexport default compareIdentifiers\n","import compareIdentifiers from '../utils/compareIdentifiers'\nimport ParsedVersion from '../types/ParsedVersion'\n\nexport const compareMainCore = (\n parsedV1: ParsedVersion,\n parsedV2: ParsedVersion,\n) => {\n return (\n compareIdentifiers(parsedV1.major, parsedV2.major) ||\n compareIdentifiers(parsedV1.minor, parsedV2.minor) ||\n compareIdentifiers(parsedV1.patch, parsedV2.patch)\n )\n}\n\nconst comparePreCore = (\n prerelease1: ReadonlyArray,\n prerelease2: ReadonlyArray,\n): 0 | 1 | -1 => {\n // NOT having a prerelease is > having one\n if (prerelease1.length && !prerelease2.length) {\n return -1\n }\n if (!prerelease1.length && prerelease2.length) {\n return 1\n }\n if (!prerelease1.length && !prerelease2.length) {\n return 0\n }\n\n let i = 0\n while (true) {\n const a = prerelease1[i]\n const b = prerelease2[i]\n\n if (a === undefined && b === undefined) {\n return 0\n }\n if (b === undefined) {\n return 1\n }\n if (a === undefined) {\n return -1\n }\n if (a !== b) {\n return compareIdentifiers(a, b)\n }\n\n i++\n }\n}\n\nconst compareCore = (parsedV1: ParsedVersion, parsedV2: ParsedVersion) => {\n if (parsedV1.version === parsedV2.version) {\n return 0\n }\n return (\n compareMainCore(parsedV1, parsedV2) ||\n comparePreCore(parsedV1.prerelease, parsedV2.prerelease)\n )\n}\n\nexport default compareCore\n","import compareCore from './compareCore'\nimport { Options } from '../types/Options'\nimport parse from './parse'\n\n/**\n * Compares two versions excluding build identifiers (the bit after `+` in the semantic version string).\n *\n * @param v1 first version string\n * @param v2 second version string\n * @param optionsOrLoose an options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings\n *\n * @returns\n * - `0` if `v1` == `v2`\n * - `1` if `v1` > `v2`\n * - `-1` if `v1` < `v2`\n *\n * @example\n * ```js\n * compare('1.2.3', '1.2.2') // 1\n * ```\n *\n * @remarks `versionArray.sort(compare)` can sort in ascending order for `MAJOR.MINOR.PATCH[-PRERELEASE]`, excluding build identifier (`[+BUILD]`). This is different from `sort()`, which also sorts in ascending order but for the whole `MAJOR.MINOR.PATCH[-PRERELEASE][+BUILD]`\n */\nconst compare = (v1: string, v2: string, optionsOrLoose?: boolean | Options) =>\n compareCore(parse(v1, optionsOrLoose, true), parse(v2, optionsOrLoose, true))\n\nexport default compare\n","import compare from './compare'\nimport { Options } from '../types/Options'\n\n/**\n * v1 == v2 This is true if they're logically equivalent, even if they're not the exact same string. You already know how to compare strings.\n *\n * @param v1 first version string\n * @param v2 second version string\n * @param optionsOrLoose an options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings\n *\n * @returns `true` if v1 == v2, `false` if v1 != v2\n *\n * @example\n * ```js\n * eq('1.2.3', '1.2.3') // true\n * ```\n *\n * @remarks build identifier (`[+BUILD]`) is not taken into account\n */\nconst eq = (v1: string, v2: string, optionsOrLoose?: boolean | Options) =>\n compare(v1, v2, optionsOrLoose) === 0\n\nexport default eq\n","import compare from './compare'\nimport { Options } from '../types/Options'\n\n/**\n * v1 > v2 This is true if v1 is greater than v2.\n *\n * @param v1 first version string\n * @param v2 second version string\n * @param optionsOrLoose an options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings\n *\n * @returns `true` if v1 > v2, `false` if v1 <= v2\n *\n * @example\n * ```js\n * gt('1.2.3', '1.2.3') // false\n * ```\n *\n * @remarks build identifier (`[+BUILD]`) is not taken into account\n */\nconst gt = (v1: string, v2: string, optionsOrLoose?: boolean | Options) =>\n compare(v1, v2, optionsOrLoose) > 0\n\nexport default gt\n","import compare from './compare'\nimport { Options } from '../types/Options'\n\n/**\n * v1 >= v2 This is true if v1 is greater than or equivalent to v2.\n *\n * @param v1 first version string\n * @param v2 second version string\n * @param optionsOrLoose an options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings\n *\n * @returns `true` if v1 >= v2, `false` if v1 < v2\n *\n * @example\n * ```js\n * gte('1.2.3', '1.2.3') // true\n * ```\n *\n * @remarks build identifier (`[+BUILD]`) is not taken into account\n */\nconst gte = (v1: string, v2: string, optionsOrLoose?: boolean | Options) =>\n compare(v1, v2, optionsOrLoose) >= 0\n\nexport default gte\n","import compare from './compare'\nimport { Options } from '../types/Options'\n\n/**\n * v1 < v2 This is true if v1 is less than v2.\n *\n * @param v1 first version string\n * @param v2 second version string\n * @param optionsOrLoose an options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings\n *\n * @returns `true` if v1 < v2, `false` if v1 >= v2\n *\n * @example\n * ```js\n * lt('1.2.3', '2.0.2') // true\n * ```\n *\n * @remarks build identifier (`[+BUILD]`) is not taken into account\n **/\nconst lt = (v1: string, v2: string, optionsOrLoose?: boolean | Options) =>\n compare(v1, v2, optionsOrLoose) < 0\n\nexport default lt\n","import compare from './compare'\nimport { Options } from '../types/Options'\n\n/**\n * v1 <= v2 This is true if v1 is less than or equivalent to v2.\n *\n * @param v1 first version string\n * @param v2 second version string\n * @param optionsOrLoose an options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings\n *\n * @returns `true` if v1 <= v2, `false` if v1 > v2\n *\n * @example\n * ```js\n * lte('1.2.3', '1.2.3') // true\n * ```\n *\n * @remarks build identifier (`[+BUILD]`) is not taken into account\n **/\nconst lte = (v1: string, v2: string, optionsOrLoose?: boolean | Options) =>\n compare(v1, v2, optionsOrLoose) <= 0\n\nexport default lte\n","import compare from './compare'\nimport { Options } from '../types/Options'\n\n/**\n * v1 != v2 The opposite of eq.\n *\n * @param v1 first version string\n * @param v2 second version string\n *\n * @returns `true` if v1 != v2, `false` if v1 == v2\n *\n * @example\n * ```js\n * neq('1.2.3', '2.0.2') // true\n * ```\n *\n * @remarks build identifier (`[+BUILD]`) is not taken into account\n */\nconst neq = (v1: string, v2: string, optionsOrLoose?: boolean | Options) =>\n compare(v1, v2, optionsOrLoose) !== 0\n\nexport default neq\n","import eq from './eq'\nimport gt from './gt'\nimport gte from './gte'\nimport lt from './lt'\nimport lte from './lte'\nimport neq from './neq'\nimport { Options } from '../types/Options'\n\n/**\n * Operator string for `cmp()` (could be \"===\", \"!==\", \"\", \"=\", \"==\", \"!=\", \">\", \">=\", \"<\", \"<=\")\n */\nexport type Operator =\n | '==='\n | '!=='\n | ''\n | '='\n | '=='\n | '!='\n | '>'\n | '>='\n | '<'\n | '<='\n\n/**\n * Pass in a comparison string, and it'll call the corresponding semver comparison function.\n *\n * Throws if an invalid comparison string is provided.\n *\n * @param v1 first version string\n * @param operator operator string (could be \"===\", \"!==\", \"\", \"=\", \"==\", \"!=\", \">\", \">=\", \"<\", \"<=\")\n * @param v2 second version string\n * @param optionsOrLoose an options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings\n *\n * @returns `true` if the comparison is true, `false` otherwise\n *\n * @example\n * ```js\n * cmp('1.2.3', '>', '1.2.2') // true\n * ```\n *\n * @remarks build identifier (`[+BUILD]`) is not taken into account in all operations but \"===\" and \"!==\" which do simple comparison of the whole strings\n */\nexport const cmp = (\n v1: string,\n operator: Operator,\n v2: string,\n optionsOrLoose?: boolean | Options,\n) => {\n switch (operator) {\n case '===': {\n return v1 === v2\n }\n case '!==': {\n return v1 !== v2\n }\n case '':\n case '=':\n case '==': {\n return eq(v1, v2, optionsOrLoose)\n }\n case '!=': {\n return neq(v1, v2, optionsOrLoose)\n }\n case '>': {\n return gt(v1, v2, optionsOrLoose)\n }\n case '>=': {\n return gte(v1, v2, optionsOrLoose)\n }\n case '<': {\n return lt(v1, v2, optionsOrLoose)\n }\n case '<=': {\n return lte(v1, v2, optionsOrLoose)\n }\n default: {\n throw new TypeError(`Invalid operator: ${operator}`)\n }\n }\n}\n","import { CoerceOptions } from '../types/Options'\nimport { COERCE, COERCEFULL, COERCERTL, COERCERTLFULL } from '../regex'\nimport parse from './parse'\n\n/**\n * Coerces a string if possible\n *\n * @param version string to coerce\n * @param options options object\n * @returns version string (including build identifier if it exists) or null if the version string is invalid\n *\n * @example\n * ```js\n * coerce('1.2.3.4') // '1.2.3'\n * coerce('1.2.3.4', { rtl: true }) // '2.3.4'\n * ```\n *\n * @remarks build identifier (`[+BUILD]`) is taken into account\n */\nconst coerce = (\n version: string | number | null | undefined,\n options?: CoerceOptions,\n) => {\n let _version = version\n if (typeof _version === 'number') {\n _version = String(_version)\n }\n\n if (typeof _version !== 'string') {\n return null\n }\n\n options = options || {}\n\n let match = null\n if (!options.rtl) {\n match = _version.match(options.includePrerelease ? COERCEFULL : COERCE)\n } else {\n // Find the right-most coercible string that does not share\n // a terminus with a more left-ward coercible string.\n // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'\n // With includePrerelease option set, '1.2.3.4-rc' wants to coerce '2.3.4-rc', not '2.3.4'\n //\n // Walk through the string checking with a /g regexp\n // Manually set the index so as to pick up overlapping matches.\n // Stop when we get a match that ends at the string end, since no\n // coercible string can be more right-ward without the same terminus.\n const coerceRtlRegex = options.includePrerelease ? COERCERTLFULL : COERCERTL\n let next\n while (\n (next = coerceRtlRegex.exec(_version)) &&\n (!match || match.index + match[0].length !== _version.length)\n ) {\n if (\n !match ||\n next.index + next[0].length !== match.index + match[0].length\n ) {\n match = next\n }\n coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length\n }\n // leave it in a clean state\n coerceRtlRegex.lastIndex = -1\n }\n\n if (match === null) {\n return null\n }\n\n const major = match[2]\n const minor = match[3] || '0'\n const patch = match[4] || '0'\n const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : ''\n const build = options.includePrerelease && match[6] ? `+${match[6]}` : ''\n\n const parsed = parse(\n `${major}.${minor}.${patch}${prerelease}${build}`,\n options,\n )\n return parsed ? parsed.fullVersion : null\n}\n\nexport default coerce\n","import compareCore from './compareCore'\nimport compareIdentifiers from '../utils/compareIdentifiers'\nimport { Options } from '../types/Options'\nimport parse from './parse'\n\nconst compareBuildCore = (\n build1: ReadonlyArray,\n build2: ReadonlyArray,\n): 0 | 1 | -1 => {\n let i = 0\n while (true) {\n const a = build1[i]\n const b = build2[i]\n\n if (a === undefined && b === undefined) {\n return 0\n }\n if (b === undefined) {\n return 1\n }\n if (a === undefined) {\n return -1\n }\n if (a !== b) {\n return compareIdentifiers(a, b)\n }\n\n i++\n }\n}\n\n/**\n * Compares two versions including build identifiers (the bit after `+` in the semantic version string).\n *\n * @param v1 first version string\n * @param v2 second version string\n * @param optionsOrLoose an options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings\n *\n * @returns\n * - `0` if `v1` == `v2`\n * - `1` if `v1` > `v2`\n * - `-1` if `v1` < `v2`\n *\n * @example\n * ```js\n * compareBuild('1.2.3foo', '1.2.3-foo') // 0\n * ```\n */\nconst compareBuild = (\n v1: string,\n v2: string,\n optionsOrLoose?: boolean | Options,\n) => {\n const parsedV1 = parse(v1, optionsOrLoose, true)\n const parsedV2 = parse(v2, optionsOrLoose, true)\n return (\n compareCore(parsedV1, parsedV2) ||\n compareBuildCore(parsedV1.build, parsedV2.build)\n )\n}\n\nexport default compareBuild\n","import compare from './compare'\n\n/**\n * Compare with loose mode enabled\n *\n * @param v1 first version string\n * @param v2 second version string\n *\n * @returns\n * - `0` if `v1` == `v2`\n * - `1` if `v1` > `v2`\n * - `-1` if `v1` < `v2`\n *\n * @example\n * ```js\n * compareLoose('1.2.3', '1.2.3') // 0\n * ```\n *\n * @remarks build identifier (`[+BUILD]`) is not taken into account\n */\nconst compareLoose = (v1: string, v2: string) => compare(v1, v2, true)\n\nexport default compareLoose\n","import ReleaseType from '../types/ReleaseType'\nimport compareCore, { compareMainCore } from './compareCore'\nimport parse from './parse'\n\n/**\n * Get difference between two versions by the release type\n *\n * @param version1 first version string\n * @param version2 second version string\n * @returns difference between two versions by the release type (major, premajor, minor, preminor, patch, prepatch, or prerelease), or null if the versions are the same.\n *\n * @example\n * ```js\n * diff('1.2.3', '1.2.3') // null\n * diff('1.2.3', '1.2.4') // 'patch'\n * ```\n *\n * @remarks build identifier (`[+BUILD]`) is not taken into account\n */\nconst diff = (version1: string, version2: string) => {\n const v1 = parse(version1, false, true)\n const v2 = parse(version2, false, true)\n const comparison = compareCore(v1, v2)\n\n if (comparison === 0) {\n return null\n }\n\n const v1Higher = comparison > 0\n const highVersion = v1Higher ? v1 : v2\n const lowVersion = v1Higher ? v2 : v1\n const highHasPre = !!highVersion.prerelease.length\n const lowHasPre = !!lowVersion.prerelease.length\n\n if (lowHasPre && !highHasPre) {\n // Going from prerelease -> no prerelease requires some special casing\n\n // If the low version has only a major, then it will always be a major\n // Some examples:\n // 1.0.0-1 -> 1.0.0\n // 1.0.0-1 -> 1.1.1\n // 1.0.0-1 -> 2.0.0\n if (!lowVersion.patch && !lowVersion.minor) {\n return 'major'\n }\n\n // If the main part has no difference\n if (compareMainCore(lowVersion, highVersion) === 0) {\n if (lowVersion.minor && !lowVersion.patch) {\n return 'minor'\n }\n return 'patch'\n }\n }\n\n // add the `pre` prefix if we are going to a prerelease version\n const prefix = highHasPre ? 'pre' : ''\n\n if (v1.major !== v2.major) {\n return (prefix + 'major') as ReleaseType\n }\n\n if (v1.minor !== v2.minor) {\n return (prefix + 'minor') as ReleaseType\n }\n\n if (v1.patch !== v2.patch) {\n return (prefix + 'patch') as ReleaseType\n }\n\n // high and low are preleases\n return 'prerelease'\n}\n\nexport default diff\n","import { PRERELEASE, PRERELEASELOOSE } from '../regex'\nimport { Options } from '../types/Options'\nimport ParsedVersion from '../types/ParsedVersion'\nimport ReleaseType from '../types/ReleaseType'\nimport compareIdentifiers from '../utils/compareIdentifiers'\nimport format from '../utils/format'\nimport Mutable from '../utils/Mutable'\nimport parseOptions from '../utils/parseOptions'\nimport parse from './parse'\n\n// for internal use only. parsedVersion is mutable\nconst incCore = (\n parsedVersion: Mutable,\n release: ReleaseType | 'release' | 0, // 'release' means prerelease version bumps to stable version; 0 means any 'pre' (internal use)\n identifier?: string,\n identifierBase?: IdentifierBase | false,\n loose?: boolean,\n): ParsedVersion => {\n if (release === 0 || release.startsWith('pre')) {\n if (!identifier && identifierBase === false) {\n throw new Error('invalid increment argument: identifier is empty')\n }\n // Avoid an invalid semver results\n if (identifier) {\n const r = loose ? PRERELEASELOOSE : PRERELEASE\n const match = `-${identifier}`.match(r)\n if (!match || match[1] !== identifier) {\n throw new Error(`invalid identifier: ${identifier}`)\n }\n }\n }\n\n switch (release) {\n case 'premajor':\n parsedVersion.prerelease.length = 0\n parsedVersion.patch = 0\n parsedVersion.minor = 0\n parsedVersion.major++\n incCore(parsedVersion, 0, identifier, identifierBase, loose)\n break\n case 'preminor':\n parsedVersion.prerelease.length = 0\n parsedVersion.patch = 0\n parsedVersion.minor++\n incCore(parsedVersion, 0, identifier, identifierBase, loose)\n break\n case 'prepatch':\n // If this is already a prerelease, it will bump to the next version\n // drop any prereleases that might already exist, since they are not\n // relevant at this point.\n parsedVersion.prerelease.length = 0\n incCore(parsedVersion, 'patch', identifier, identifierBase, loose)\n incCore(parsedVersion, 0, identifier, identifierBase, loose)\n break\n // If the input is a non-prerelease version, this acts the same as\n // prepatch.\n case 'prerelease':\n if (parsedVersion.prerelease.length === 0) {\n incCore(parsedVersion, 'patch', identifier, identifierBase, loose)\n }\n incCore(parsedVersion, 0, identifier, identifierBase, loose)\n break\n case 'release':\n if (parsedVersion.prerelease.length === 0) {\n throw new Error(\n `version ${parsedVersion.fullVersion} is not a prerelease`,\n )\n }\n parsedVersion.prerelease.length = 0\n break\n\n case 'major':\n // If this is a pre-major version, bump up to the same major version.\n // Otherwise increment major.\n // 1.0.0-5 bumps to 1.0.0\n // 1.1.0 bumps to 2.0.0\n if (\n parsedVersion.minor !== 0 ||\n parsedVersion.patch !== 0 ||\n parsedVersion.prerelease.length === 0\n ) {\n parsedVersion.major++\n }\n parsedVersion.minor = 0\n parsedVersion.patch = 0\n parsedVersion.prerelease.length = 0\n break\n case 'minor':\n // If this is a pre-minor version, bump up to the same minor version.\n // Otherwise increment minor.\n // 1.2.0-5 bumps to 1.2.0\n // 1.2.1 bumps to 1.3.0\n if (parsedVersion.patch !== 0 || parsedVersion.prerelease.length === 0) {\n parsedVersion.minor++\n }\n parsedVersion.patch = 0\n parsedVersion.prerelease.length = 0\n break\n case 'patch':\n // If this is not a pre-release version, it will increment the patch.\n // If it is a pre-release it will bump up to the same patch version.\n // 1.2.0-5 patches to 1.2.0\n // 1.2.0 patches to 1.2.1\n if (parsedVersion.prerelease.length === 0) {\n parsedVersion.patch++\n }\n parsedVersion.prerelease.length = 0\n break\n // This probably shouldn't be used publicly.\n // 1.0.0 `0` would become 1.0.0-0 which is the wrong direction.\n case 0: {\n const base = Number(identifierBase) ? 1 : 0\n\n if (parsedVersion.prerelease.length === 0) {\n parsedVersion.prerelease = [base]\n } else {\n let i = parsedVersion.prerelease.length\n while (--i >= 0) {\n if (typeof parsedVersion.prerelease[i] === 'number') {\n ;(parsedVersion.prerelease[i] as number)++\n i = -2\n }\n }\n if (i === -1) {\n // didn't increment anything\n if (\n identifier === parsedVersion.prerelease.join('.') &&\n identifierBase === false\n ) {\n throw new Error(\n 'invalid increment argument: identifier already exists',\n )\n }\n parsedVersion.prerelease.push(base)\n }\n }\n if (identifier) {\n // 1.2.0-beta.1 bumps to 1.2.0-beta.2,\n // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0\n let prerelease = [identifier, base]\n if (identifierBase === false) {\n prerelease = [identifier]\n }\n if (compareIdentifiers(parsedVersion.prerelease[0], identifier) === 0) {\n if (isNaN(parsedVersion.prerelease[1] as number)) {\n parsedVersion.prerelease = prerelease\n }\n } else {\n parsedVersion.prerelease = prerelease\n }\n }\n break\n }\n default:\n throw new Error(`invalid increment argument: ${release}`)\n }\n const { major, minor, patch, prerelease, build } = parsedVersion\n const [version, fullVersion] = format(major, minor, patch, prerelease, build)\n return {\n version,\n fullVersion,\n major,\n minor,\n patch,\n prerelease,\n build,\n }\n}\n\n/**\n * The base to use for the identifier in `inc()`, could be '0' or '1'\n */\nexport type IdentifierBase = '0' | '1'\n\n/**\n * Return the version incremented by the release type (major, premajor, minor, preminor, patch, prepatch, or prerelease), or null if it's not valid.\n *\n * @param version - The version to increment\n * @param release - The release type to use, could be \"major\", \"premajor\", \"minor\", \"preminor\", \"patch\", \"prepatch\", \"prerelease\", 'release'\n * @param optionsOrLoose - An options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings **this param can be omitted, making `identifier` and `identifierBase` the third and the fourth params respectively**\n * @param identifier - The identifier to use for prerelease versions\n * @param identifierBase - The base to use for the identifier, could be '0' or '1'\n *\n * @returns The incremented version, or null if it's not valid\n *\n * @example\n * ```js\n * inc('1.2.3', 'minor') // '1.3.0'\n * inc('1.2.3', 'prerelease') // '1.2.4-0'\n * inc('1.2', 'minor') // null\n * ```\n */\nexport function inc(\n version: string,\n release: ReleaseType | 'release',\n optionsOrLoose?: boolean | Options,\n identifier?: string,\n identifierBase?: IdentifierBase | false,\n): string | null\nexport function inc(\n version: string,\n release: ReleaseType | 'release',\n identifier?: string,\n identifierBase?: IdentifierBase | false,\n): string | null\nexport function inc(\n version: string,\n release: ReleaseType | 'release',\n options?: boolean | Options | string,\n identifier?: string | IdentifierBase | false,\n identifierBase?: IdentifierBase | false | boolean,\n): string | null {\n let _options = options\n let _identifier = identifier\n let _identifierBase: IdentifierBase | false | boolean | undefined =\n identifierBase\n if (typeof _options === 'string') {\n _identifierBase = _identifier as IdentifierBase | false | undefined\n _identifier = _options\n _options = undefined\n }\n\n const loose = parseOptions(_options)\n\n try {\n return incCore(\n parse(version, _options, true) as Mutable,\n release,\n _identifier as string | undefined,\n _identifierBase as IdentifierBase | false | undefined,\n loose,\n ).version\n } catch {\n return null\n }\n}\n\n/**\n * Return the version incremented by the release type (major, premajor, minor, preminor, patch, prepatch, or prerelease)\n *\n * @param version - The version to increment\n * @param release - The release type to use, could be \"major\", \"premajor\", \"minor\", \"preminor\", \"patch\", \"prepatch\", \"prerelease\", 'release'\n * @param identifier - The identifier to use for prerelease versions\n * @param identifierBase - The base to use for the identifier, could be '0' or '1'\n * @param optionsOrLoose - An options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings\n *\n * @returns The incremented version\n *\n * @throws TypeError if the version string is invalid or if there are other errors\n *\n * @example\n * ```js\n * incThrow('1.2.3', 'minor') // '1.3.0'\n * incThrow('1.2', 'minor') // throws TypeError: Invalid Version: 1.2\n * ```\n *\n * @remarks unlike `inc()` which returns `null` if error occurs, this function could throw error\n */\nexport const incThrow = (\n version: string,\n release: ReleaseType | 'release',\n identifier?: string,\n identifierBase?: IdentifierBase | false,\n optionsOrLoose?: boolean | Options,\n): string => {\n const loose = parseOptions(optionsOrLoose)\n return incCore(\n parse(version, optionsOrLoose, true) as Mutable,\n release,\n identifier,\n identifierBase,\n loose,\n ).version\n}\n","import { Options } from '../types/Options'\nimport parse from './parse'\n\n/**\n * Return the major version number.\n *\n * @param version version string\n * @param optionsOrLoose an options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings\n *\n * @returns the major version number\n *\n * @example\n * ```js\n * major('1.2.3') // 1\n * ```\n */\nconst major = (version: string, optionsOrLoose?: boolean | Options) =>\n parse(version, optionsOrLoose, true).major\n\nexport default major\n","import { Options } from '../types/Options'\nimport parse from './parse'\n\n/**\n * Return the minor version number.\n *\n * @param version version string\n * @param optionsOrLoose an options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings\n *\n * @returns the minor version number\n *\n * @example\n * ```js\n * minor('1.2.3') // 2\n * ```\n */\nconst minor = (version: string, optionsOrLoose?: boolean | Options) =>\n parse(version, optionsOrLoose, true).minor\n\nexport default minor\n","import { Options } from '../types/Options'\nimport parse from './parse'\n\n/**\n * Return the patch version number.\n *\n * @param version version string\n * @param optionsOrLoose an options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings\n *\n * @returns the patch version number\n *\n * @example\n * ```js\n * patch('1.2.3') // 3\n * ```\n */\nconst patch = (version: string, optionsOrLoose?: boolean | Options) =>\n parse(version, optionsOrLoose, true).patch\n\nexport default patch\n","import { Options } from '../types/Options'\nimport parse from './parse'\n\n/**\n * Returns an array of prerelease components, or `null` if none exist.\n *\n * @param version version string\n * @param optionsOrLoose an options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings\n *\n * @returns an array of prerelease components, or `null` if none exist\n *\n * @example\n * ```js\n * prerelease('1.2.3-foo.bar+build.123') // ['foo', 'bar']\n * ```\n */\nconst prerelease = (version: string, optionsOrLoose?: boolean | Options) => {\n const parsed = parse(version, optionsOrLoose)\n return parsed && parsed.prerelease.length ? parsed.prerelease : null\n}\n\nexport default prerelease\n","import compare from './compare'\nimport { Options } from '../types/Options'\n\n/**\n * The reverse of compare.\n *\n * @param v1 first version string\n * @param v2 second version string\n * @param optionsOrLoose an options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings\n *\n * @remarks `versionArray.sort(rcompare)` can sort in descending order for `MAJOR.MINOR.PATCH[-PRERELEASE]`, excluding build identifier (`[+BUILD]`). This is different from `rsort()`, which also sorts in descending order but for the whole `MAJOR.MINOR.PATCH[-PRERELEASE][+BUILD]`\n *\n * @returns\n * - `0` if `v1` == `v2`\n * - `-1` if `v1` > `v2`\n * - `1` if `v1` < `v2`\n *\n * @example\n * ```js\n * rcompare('1.2.3', '1.2.4') // 1\n * ```\n */\nconst rcompare = (v1: string, v2: string, optionsOrLoose?: boolean | Options) =>\n compare(v2, v1, optionsOrLoose)\n\nexport default rcompare\n","import compareBuild from './compareBuild'\nimport { Options } from '../types/Options'\n\n/**\n * Sorts an array of version strings in descending order using `compareBuild()` (the whole version including build identifier (`[+BUILD]`) taken into account).\n *\n * @param list array of version strings\n * @param optionsOrLoose an options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings\n *\n * @returns the sorted array\n *\n * @example\n * ```js\n * rsort(['2.0.2', '1.2.3', '1.2.4', '1.2.4-foo.bar+build.123', '1.2.4-foo.bar+build.1234']) // [ \"2.0.2\", \"1.2.4\", \"1.2.4-foo.bar+build.1234\", \"1.2.4-foo.bar+build.123\", \"1.2.3\" ]\n * ```\n */\nconst rsort = (list: string[], optionsOrLoose?: boolean | Options) =>\n list.sort((v1: string, v2: string) => compareBuild(v2, v1, optionsOrLoose))\n\nexport default rsort\n","import compareBuild from './compareBuild'\nimport { Options } from '../types/Options'\n\n/**\n * Sorts an array of version strings in ascending order using `compareBuild()` (the whole version including build identifier (`[+BUILD]`) taken into account).\n *\n * @param list array of version strings\n * @param optionsOrLoose an options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings\n *\n * @returns the sorted array\n *\n * @example\n * ```js\n * sort(['2.0.2', '1.2.3', '1.2.4', '1.2.4-foo.bar+build.123', '1.2.4-foo.bar+build.1234']) // [ \"1.2.3\", \"1.2.4-foo.bar+build.123\", \"1.2.4-foo.bar+build.1234\", \"1.2.4\", \"2.0.2\" ]\n * ```\n */\nconst sort = (list: string[], optionsOrLoose?: boolean | Options) =>\n list.sort((v1: string, v2: string) => compareBuild(v1, v2, optionsOrLoose))\n\nexport default sort\n","import { Options } from '../types/Options'\nimport parse from './parse'\n\n/**\n * Return the parsed version as a string, or `null` if it's not valid.\n *\n * @param version version string\n * @param optionsOrLoose an options object `{ loose }` (where loose is the only available option) or a boolean indicating whether to enable loose mode. In loose mode, the parser is more forgiving with imperfectly formatted semver strings\n *\n * @returns the parsed version as a string, or `null` if it's not valid\n *\n * @example\n * ```js\n * valid('1.2.3') // '1.2.3'\n * valid('1.2.3-foo.bar+build.12345') // 1.2.3-foo.bar\n * valid('1.2') // null\n * ```\n */\nconst valid = (version: string, optionsOrLoose?: boolean | Options) => {\n const v = parse(version, optionsOrLoose)\n return v ? v.version : null\n}\n\nexport default valid\n"]}