Brunobkr/llama.cpp_AlgMor24_github

1'use strict'2 3const Range = require('../classes/range.js')4const Comparator = require('../classes/comparator.js')5const { ANY } = Comparator6const satisfies = require('../functions/satisfies.js')7const compare = require('../functions/compare.js')8 9// Complex range `r1 || r2 || ...` is a subset of `R1 || R2 || ...` iff:10// - Every simple range `r1, r2, ...` is a null set, OR11// - Every simple range `r1, r2, ...` which is not a null set is a subset of12//   some `R1, R2, ...`13//14// Simple range `c1 c2 ...` is a subset of simple range `C1 C2 ...` iff:15// - If c is only the ANY comparator16//   - If C is only the ANY comparator, return true17//   - Else if in prerelease mode, return false18//   - else replace c with `[>=0.0.0]`19// - If C is only the ANY comparator20//   - if in prerelease mode, return true21//   - else replace C with `[>=0.0.0]`22// - Let EQ be the set of = comparators in c23// - If EQ is more than one, return true (null set)24// - Let GT be the highest > or >= comparator in c25// - Let LT be the lowest < or <= comparator in c26// - If GT and LT, and GT.semver > LT.semver, return true (null set)27// - If any C is a = range, and GT or LT are set, return false28// - If EQ29//   - If GT, and EQ does not satisfy GT, return true (null set)30//   - If LT, and EQ does not satisfy LT, return true (null set)31//   - If EQ satisfies every C, return true32//   - Else return false33// - If GT34//   - If GT.semver is lower than any > or >= comp in C, return false35//   - If GT is >=, and GT.semver does not satisfy every C, return false36//   - If GT.semver has a prerelease, and not in prerelease mode37//     - If no C has a prerelease and the GT.semver tuple, return false38// - If LT39//   - If LT.semver is greater than any < or <= comp in C, return false40//   - If LT is <=, and LT.semver does not satisfy every C, return false41//   - If LT.semver has a prerelease, and not in prerelease mode42//     - If no C has a prerelease and the LT.semver tuple, return false43// - Else return true44 45const subset = (sub, dom, options = {}) => {46  if (sub === dom) {47    return true48  }49 50  sub = new Range(sub, options)51  dom = new Range(dom, options)52  let sawNonNull = false53 54  OUTER: for (const simpleSub of sub.set) {55    for (const simpleDom of dom.set) {56      const isSub = simpleSubset(simpleSub, simpleDom, options)57      sawNonNull = sawNonNull || isSub !== null58      if (isSub) {59        continue OUTER60      }61    }62    // the null set is a subset of everything, but null simple ranges in63    // a complex range should be ignored.  so if we saw a non-null range,64    // then we know this isn't a subset, but if EVERY simple range was null,65    // then it is a subset.66    if (sawNonNull) {67      return false68    }69  }70  return true71}72 73const minimumVersionWithPreRelease = [new Comparator('>=0.0.0-0')]74const minimumVersion = [new Comparator('>=0.0.0')]75 76const simpleSubset = (sub, dom, options) => {77  if (sub === dom) {78    return true79  }80 81  if (sub.length === 1 && sub[0].semver === ANY) {82    if (dom.length === 1 && dom[0].semver === ANY) {83      return true84    } else if (options.includePrerelease) {85      sub = minimumVersionWithPreRelease86    } else {87      sub = minimumVersion88    }89  }90 91  if (dom.length === 1 && dom[0].semver === ANY) {92    if (options.includePrerelease) {93      return true94    } else {95      dom = minimumVersion96    }97  }98 99  const eqSet = new Set()100  let gt, lt101  for (const c of sub) {102    if (c.operator === '>' || c.operator === '>=') {103      gt = higherGT(gt, c, options)104    } else if (c.operator === '<' || c.operator === '<=') {105      lt = lowerLT(lt, c, options)106    } else {107      eqSet.add(c.semver)108    }109  }110 111  if (eqSet.size > 1) {112    return null113  }114 115  let gtltComp116  if (gt && lt) {117    gtltComp = compare(gt.semver, lt.semver, options)118    if (gtltComp > 0) {119      return null120    } else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) {121      return null122    }123  }124 125  // will iterate one or zero times126  for (const eq of eqSet) {127    if (gt && !satisfies(eq, String(gt), options)) {128      return null129    }130 131    if (lt && !satisfies(eq, String(lt), options)) {132      return null133    }134 135    for (const c of dom) {136      if (!satisfies(eq, String(c), options)) {137        return false138      }139    }140 141    return true142  }143 144  let higher, lower145  let hasDomLT, hasDomGT146  // if the subset has a prerelease, we need a comparator in the superset147  // with the same tuple and a prerelease, or it's not a subset148  let needDomLTPre = lt &&149    !options.includePrerelease &&150    lt.semver.prerelease.length ? lt.semver : false151  let needDomGTPre = gt &&152    !options.includePrerelease &&153    gt.semver.prerelease.length ? gt.semver : false154  // exception: <1.2.3-0 is the same as <1.2.3155  if (needDomLTPre && needDomLTPre.prerelease.length === 1 &&156      lt.operator === '<' && needDomLTPre.prerelease[0] === 0) {157    needDomLTPre = false158  }159 160  for (const c of dom) {161    hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>='162    hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<='163    if (gt) {164      if (needDomGTPre) {165        if (c.semver.prerelease && c.semver.prerelease.length &&166            c.semver.major === needDomGTPre.major &&167            c.semver.minor === needDomGTPre.minor &&168            c.semver.patch === needDomGTPre.patch) {169          needDomGTPre = false170        }171      }172      if (c.operator === '>' || c.operator === '>=') {173        higher = higherGT(gt, c, options)174        if (higher === c && higher !== gt) {175          return false176        }177      } else if (gt.operator === '>=' && !c.test(gt.semver)) {178        return false179      }180    }181    if (lt) {182      if (needDomLTPre) {183        if (c.semver.prerelease && c.semver.prerelease.length &&184            c.semver.major === needDomLTPre.major &&185            c.semver.minor === needDomLTPre.minor &&186            c.semver.patch === needDomLTPre.patch) {187          needDomLTPre = false188        }189      }190      if (c.operator === '<' || c.operator === '<=') {191        lower = lowerLT(lt, c, options)192        if (lower === c && lower !== lt) {193          return false194        }195      } else if (lt.operator === '<=' && !c.test(lt.semver)) {196        return false197      }198    }199    if (!c.operator && (lt || gt) && gtltComp !== 0) {200      return false201    }202  }203 204  // if there was a < or >, and nothing in the dom, then must be false205  // UNLESS it was limited by another range in the other direction.206  // Eg, >1.0.0 <1.0.1 is still a subset of <2.0.0207  if (gt && hasDomLT && !lt && gtltComp !== 0) {208    return false209  }210 211  if (lt && hasDomGT && !gt && gtltComp !== 0) {212    return false213  }214 215  // we needed a prerelease range in a specific tuple, but didn't get one216  // then this isn't a subset.  eg >=1.2.3-pre is not a subset of >=1.0.0,217  // because it includes prereleases in the 1.2.3 tuple218  if (needDomGTPre || needDomLTPre) {219    return false220  }221 222  return true223}224 225// >=1.2.3 is lower than >1.2.3226const higherGT = (a, b, options) => {227  if (!a) {228    return b229  }230  const comp = compare(a.semver, b.semver, options)231  return comp > 0 ? a232    : comp < 0 ? b233    : b.operator === '>' && a.operator === '>=' ? b234    : a235}236 237// <=1.2.3 is higher than <1.2.3238const lowerLT = (a, b, options) => {239  if (!a) {240    return b241  }242  const comp = compare(a.semver, b.semver, options)243  return comp < 0 ? a244    : comp > 0 ? b245    : b.operator === '<' && a.operator === '<=' ? b246    : a247}248 249module.exports = subset250