.-.-.-.-.-

PK1�\�-��
compare.jsnu�[���const SemVer = require('../classes/semver')
const compare = (a, b, loose) =>
  new SemVer(a, loose).compare(new SemVer(b, loose))

module.exports = compare
PK1�\+l���inc.jsnu�[���const SemVer = require('../classes/semver')

const inc = (version, release, options, identifier, identifierBase) => {
  if (typeof (options) === 'string') {
    identifierBase = identifier
    identifier = options
    options = undefined
  }

try {
    return new SemVer(
      version instanceof SemVer ? version.version : version,
      options
    ).inc(release, identifier, identifierBase).version
  } catch (er) {
    return null
  }
}
module.exports = inc
PK1�\�Jvvcompare-loose.jsnu�[���const compare = require('./compare')
const compareLoose = (a, b) => compare(a, b, true)
module.exports = compareLoose
PK1�\�\e�zzminor.jsnu�[���const SemVer = require('../classes/semver')
const minor = (a, loose) => new SemVer(a, loose).minor
module.exports = minor
PK1�\���zzpatch.jsnu�[���const SemVer = require('../classes/semver')
const patch = (a, loose) => new SemVer(a, loose).patch
module.exports = patch
PK1�\i�O�compare-build.jsnu�[���const SemVer = require('../classes/semver')
const compareBuild = (a, b, loose) => {
  const versionA = new SemVer(a, loose)
  const versionB = new SemVer(b, loose)
  return versionA.compare(versionB) || versionA.compareBuild(versionB)
}
module.exports = compareBuild
PK1�\H�x��
prerelease.jsnu�[���const parse = require('./parse')
const prerelease = (version, options) => {
  const parsed = parse(version, options)
  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
}
module.exports = prerelease
PK1�\r#�V��cmp.jsnu�[���const eq = require('./eq')
const neq = require('./neq')
const gt = require('./gt')
const gte = require('./gte')
const lt = require('./lt')
const lte = require('./lte')

const cmp = (a, op, b, loose) => {
  switch (op) {
    case '===':
      if (typeof a === 'object') {
        a = a.version
      }
      if (typeof b === 'object') {
        b = b.version
      }
      return a === b

case '!==':
      if (typeof a === 'object') {
        a = a.version
      }
      if (typeof b === 'object') {
        b = b.version
      }
      return a !== b

case '':
    case '=':
    case '==':
      return eq(a, b, loose)

case '!=':
      return neq(a, b, loose)

case '>':
      return gt(a, b, loose)

case '>=':
      return gte(a, b, loose)

case '<':
      return lt(a, b, loose)

case '<=':
      return lte(a, b, loose)

default:
      throw new TypeError(`Invalid operator: ${op}`)
  }
}
module.exports = cmp
PK1�\�+�rrneq.jsnu�[���const compare = require('./compare')
const neq = (a, b, loose) => compare(a, b, loose) !== 0
module.exports = neq
PK1�\:��Unngt.jsnu�[���const compare = require('./compare')
const gt = (a, b, loose) => compare(a, b, loose) > 0
module.exports = gt
PK1�\J�==parse.jsnu�[���const SemVer = require('../classes/semver')
const parse = (version, options, throwErrors = false) => {
  if (version instanceof SemVer) {
    return version
  }
  try {
    return new SemVer(version, options)
  } catch (er) {
    if (!throwErrors) {
      return null
    }
    throw er
  }
}

module.exports = parse
PK1�\Q�g��sort.jsnu�[���const compareBuild = require('./compare-build')
const sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose))
module.exports = sort
PK1�\KH��vvrcompare.jsnu�[���const compare = require('./compare')
const rcompare = (a, b, loose) => compare(b, a, loose)
module.exports = rcompare
PK1�\��DSqqlte.jsnu�[���const compare = require('./compare')
const lte = (a, b, loose) => compare(a, b, loose) <= 0
module.exports = lte
PK1�\�!W��	coerce.jsnu�[���const SemVer = require('../classes/semver')
const parse = require('./parse')
const { safeRe: re, t } = require('../internal/re')

const coerce = (version, options) => {
  if (version instanceof SemVer) {
    return version
  }

if (typeof version === 'number') {
    version = String(version)
  }

if (typeof version !== 'string') {
    return null
  }

options = options || {}

let match = null
  if (!options.rtl) {
    match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE])
  } else {
    // Find the right-most coercible string that does not share
    // a terminus with a more left-ward coercible string.
    // Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
    // With includePrerelease option set, '1.2.3.4-rc' wants to coerce '2.3.4-rc', not '2.3.4'
    //
    // Walk through the string checking with a /g regexp
    // Manually set the index so as to pick up overlapping matches.
    // 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.
    const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL]
    let next
    while ((next = coerceRtlRegex.exec(version)) &&
        (!match || match.index + match[0].length !== version.length)
    ) {
      if (!match ||
            next.index + next[0].length !== match.index + match[0].length) {
        match = next
      }
      coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length
    }
    // leave it in a clean state
    coerceRtlRegex.lastIndex = -1
  }

if (match === null) {
    return null
  }

const major = match[2]
  const minor = match[3] || '0'
  const patch = match[4] || '0'
  const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : ''
  const build = options.includePrerelease && match[6] ? `+${match[6]}` : ''

return parse(`${major}.${minor}.${patch}${prerelease}${build}`, options)
}
module.exports = coerce
PK1�\I�zzmajor.jsnu�[���const SemVer = require('../classes/semver')
const major = (a, loose) => new SemVer(a, loose).major
module.exports = major
PK1�\�,ppeq.jsnu�[���const compare = require('./compare')
const eq = (a, b, loose) => compare(a, b, loose) === 0
module.exports = eq
PK1�\���qqgte.jsnu�[���const compare = require('./compare')
const gte = (a, b, loose) => compare(a, b, loose) >= 0
module.exports = gte
PK1�\}zC���valid.jsnu�[���const parse = require('./parse')
const valid = (version, options) => {
  const v = parse(version, options)
  return v ? v.version : null
}
module.exports = valid
PK1�\������satisfies.jsnu�[���const Range = require('../classes/range')
const satisfies = (version, range, options) => {
  try {
    range = new Range(range, options)
  } catch (er) {
    return false
  }
  return range.test(version)
}
module.exports = satisfies
PK1�\�cƧ��clean.jsnu�[���const parse = require('./parse')
const clean = (version, options) => {
  const s = parse(version.trim().replace(/^[=v]+/, ''), options)
  return s ? s.version : null
}
module.exports = clean
PK1�\�ޝy��rsort.jsnu�[���const compareBuild = require('./compare-build')
const rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose))
module.exports = rsort
PK1�\;�}nnlt.jsnu�[���const compare = require('./compare')
const lt = (a, b, loose) => compare(a, b, loose) < 0
module.exports = lt
PK1�\��3[LLdiff.jsnu�[���const parse = require('./parse.js')

const diff = (version1, version2) => {
  const v1 = parse(version1, null, true)
  const v2 = parse(version2, null, true)
  const comparison = v1.compare(v2)

if (comparison === 0) {
    return null
  }

const v1Higher = comparison > 0
  const highVersion = v1Higher ? v1 : v2
  const lowVersion = v1Higher ? v2 : v1
  const highHasPre = !!highVersion.prerelease.length
  const lowHasPre = !!lowVersion.prerelease.length

if (lowHasPre && !highHasPre) {
    // Going from prerelease -> no prerelease requires some special casing

// If the low version has only a major, then it will always be a major
    // Some examples:
    // 1.0.0-1 -> 1.0.0
    // 1.0.0-1 -> 1.1.1
    // 1.0.0-1 -> 2.0.0
    if (!lowVersion.patch && !lowVersion.minor) {
      return 'major'
    }

// Otherwise it can be determined by checking the high version

if (highVersion.patch) {
      // anything higher than a patch bump would result in the wrong version
      return 'patch'
    }

if (highVersion.minor) {
      // anything higher than a minor bump would result in the wrong version
      return 'minor'
    }

// bumping major/minor/patch all have same result
    return 'major'
  }

// add the `pre` prefix if we are going to a prerelease version
  const prefix = highHasPre ? 'pre' : ''

if (v1.major !== v2.major) {
    return prefix + 'major'
  }

if (v1.minor !== v2.minor) {
    return prefix + 'minor'
  }

if (v1.patch !== v2.patch) {
    return prefix + 'patch'
  }

// high and low are preleases
  return 'prerelease'
}

module.exports = diff
PK1�\�-��
compare.jsnu�[���PK1�\+l����inc.jsnu�[���PK1�\�Jvv�compare-loose.jsnu�[���PK1�\�\e�zz�minor.jsnu�[���PK1�\���zzDpatch.jsnu�[���PK1�\i�O��compare-build.jsnu�[���PK1�\H�x��
Aprerelease.jsnu�[���PK1�\r#�V��Zcmp.jsnu�[���PK1�\�+�rrCneq.jsnu�[���PK1�\:��Unn�gt.jsnu�[���PK1�\J�==�parse.jsnu�[���PK1�\Q�g��sort.jsnu�[���PK1�\KH��vv�rcompare.jsnu�[���PK1�\��DSqq~lte.jsnu�[���PK1�\�!W��	%coerce.jsnu�[���PK1�\I�zz$major.jsnu�[���PK1�\�,pp�eq.jsnu�[���PK1�\���qq{gte.jsnu�[���PK1�\}zC���"valid.jsnu�[���PK1�\�������satisfies.jsnu�[���PK1�\�cƧ��!clean.jsnu�[���PK1�\�ޝy��rsort.jsnu�[���PK1�\;�}nn�lt.jsnu�[���PK1�\��3[LL�diff.jsnu�[���PK�%

/home/emeraadmin/.cpanel/../public_html/./node_modules/../wp-includes/../4d695/functions.zip