python-version: '<3.11'

- name: Verify <3.11

run: python __tests__/verify-python.py 3.10

// Max safe segment length for coercion.

var MAX_SAFE_COMPONENT_LENGTH = 16

// The actual regexps go on exports.re

var re = exports.re = []

var src = exports.src = []

var t = exports.tokens = {}

var R = 0

t[n] = R++

}

// The following Regular Expressions can be used for tokenizing,

// validating, and parsing SemVer version strings.

tok('NUMERICIDENTIFIER')

src[t.NUMERICIDENTIFIER] = '0|[1-9]\\d*'

tok('NUMERICIDENTIFIERLOOSE')

// ## Non-numeric Identifier

// Zero or more digits, followed by a letter or hyphen, and then zero or

// more letters, digits, or hyphens.

tok('NONNUMERICIDENTIFIER')

// ## Main Version

// Three dot-separated numeric identifiers.

// Any combination of digits, letters, or hyphens.

tok('BUILDIDENTIFIER')

// ## Build Metadata

// Plus sign, followed by one or more period-separated build metadata

'(?:$|[^\\d])'

tok('COERCERTL')

re[t.COERCERTL] = new RegExp(src[t.COERCE], 'g')

// Tilde ranges.

// Meaning is "reasonably at or greater than"

tok('TILDETRIM')

src[t.TILDETRIM] = '(\\s*)' + src[t.LONETILDE] + '\\s+'

re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], 'g')

var tildeTrimReplace = '$1~'

tok('TILDE')

tok('CARETTRIM')

src[t.CARETTRIM] = '(\\s*)' + src[t.LONECARET] + '\\s+'

re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], 'g')

var caretTrimReplace = '$1^'

tok('CARET')

// this one has to use the /g flag

re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], 'g')

var comparatorTrimReplace = '$1$2$3'

// Something like `1.2.3 - 1.2.4`

debug(i, src[i])

if (!re[i]) {

re[i] = new RegExp(src[i])

}

}

return null

}

if (!r.test(version)) {

return null

}

this.options = options

this.loose = !!options.loose

if (!m) {

throw new TypeError('Invalid Version: ' + version)

return new Comparator(comp, options)

}

debug('comparator', comp, options)

this.options = options

this.loose = !!options.loose

var ANY = {}

Comparator.prototype.parse = function (comp) {

var m = comp.match(r)

if (!m) {

this.loose = !!options.loose

this.includePrerelease = !!options.includePrerelease

this.raw = range

return this.parseRange(range.trim())

}, this).filter(function (c) {

// throw out any that are not relevant for whatever reason

return c.length

})

if (!this.set.length) {

}

this.format()

Range.prototype.parseRange = function (range) {

var loose = this.options.loose

// `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`

range = range.replace(hr, hyphenReplace)

debug('hyphen replace', range)

// `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`

// `~ 1.2.3` => `~1.2.3`

// `^ 1.2.3` => `^1.2.3`

// normalize spaces

range = range.split(/\s+/).join(' ')

// At this point, the range is completely trimmed and

// ready to be split into comparators.

var set = range.split(' ').map(function (comp) {

return parseComparator(comp, this.options)

}, this).join(' ').split(/\s+/)

}

function replaceTilde (comp, options) {

return comp.replace(r, function (_, M, m, p, pr) {

debug('tilde', comp, _, M, m, p, pr)

var ret

function replaceCaret (comp, options) {

debug('caret', comp, options)

return comp.replace(r, function (_, M, m, p, pr) {

debug('caret', comp, _, M, m, p, pr)

var ret

function replaceXRange (comp, options) {

comp = comp.trim()

return comp.replace(r, function (ret, gtlt, M, m, p, pr) {

debug('xRange', comp, ret, gtlt, M, m, p, pr)

var xM = isX(M)

function replaceStars (comp, options) {

debug('replaceStars', comp, options)

// Looseness is ignored here. star is always as loose as it gets!

}

// This function is passed to string.replace(re[t.HYPHENRANGE])

var match = null

if (!options.rtl) {

} else {

// Find the right-most coercible string that does not share

// a terminus with a more left-ward coercible string.

// Stop when we get a match that ends at the string end, since no

// coercible string can be more right-ward without the same terminus.

var next

(!match || match.index + match[0].length !== version.length)

) {

if (!match ||

next.index + next[0].length !== match.index + match[0].length) {

match = next

}

}

// leave it in a clean state

}

if (match === null) {

var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {

if (k2 === undefined) k2 = k;

}) : (function(o, m, k, k2) {

if (k2 === undefined) k2 = k;

o[k2] = m[k];

var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {

if (k2 === undefined) k2 = k;

}) : (function(o, m, k, k2) {

if (k2 === undefined) k2 = k;

o[k2] = m[k];