Name: js-handler/node_modules/restify/node_modules/semver/semver.js 
1:
;(function (exports) { // nothing in here is node-specific.
2:
 
3:
// See http://semver.org/
4:
// This implementation is a *hair* less strict in that it allows
5:
// v1.2.3 things, and also tags that don't begin with a char.
6:
 
7:
var semver = "\\s*[v=]*\\s*([0-9]+)"        // major
8:
           + "\\.([0-9]+)"                  // minor
9:
           + "\\.([0-9]+)"                  // patch
10:
           + "(-[0-9]+-?)?"                 // build
11:
           + "([a-zA-Z-+][a-zA-Z0-9-\.:]*)?" // tag
12:
  , exprComparator = "^((<|>)?=?)\s*("+semver+")$|^$"
13:
  , xRangePlain = "[v=]*([0-9]+|x|X|\\*)"
14:
                + "(?:\\.([0-9]+|x|X|\\*)"
15:
                + "(?:\\.([0-9]+|x|X|\\*)"
16:
                + "([a-zA-Z-][a-zA-Z0-9-\.:]*)?)?)?"
17:
  , xRange = "((?:<|>)=?)?\\s*" + xRangePlain
18:
  , exprLoneSpermy = "(?:~>?)"
19:
  , exprSpermy = exprLoneSpermy + xRange
20:
  , expressions = exports.expressions =
21:
    { parse : new RegExp("^\\s*"+semver+"\\s*$")
22:
    , parsePackage : new RegExp("^\\s*([^\/]+)[[email protected]](" +semver+")\\s*$")
23:
    , parseRange : new RegExp(
24:
        "^\\s*(" + semver + ")\\s+-\\s+(" + semver + ")\\s*$")
25:
    , validComparator : new RegExp("^"+exprComparator+"$")
26:
    , parseXRange : new RegExp("^"+xRange+"$")
27:
    , parseSpermy : new RegExp("^"+exprSpermy+"$")
28:
    }
29:
 
30:
 
31:
Object.getOwnPropertyNames(expressions).forEach(function (i) {
32:
  exports[i] = function (str) {
33:
    return ("" + (str || "")).match(expressions[i])
34:
  }
35:
})
36:
 
37:
exports.rangeReplace = ">=$1 <=$7"
38:
exports.clean = clean
39:
exports.compare = compare
40:
exports.rcompare = rcompare
41:
exports.satisfies = satisfies
42:
exports.gt = gt
43:
exports.gte = gte
44:
exports.lt = lt
45:
exports.lte = lte
46:
exports.eq = eq
47:
exports.neq = neq
48:
exports.cmp = cmp
49:
exports.inc = inc
50:
 
51:
exports.valid = valid
52:
exports.validPackage = validPackage
53:
exports.validRange = validRange
54:
exports.maxSatisfying = maxSatisfying
55:
 
56:
exports.replaceStars = replaceStars
57:
exports.toComparators = toComparators
58:
 
59:
function stringify (version) {
60:
  var v = version
61:
  return [v[1]||'', v[2]||'', v[3]||''].join(".") + (v[4]||'') + (v[5]||'')
62:
}
63:
 
64:
function clean (version) {
65:
  version = exports.parse(version)
66:
  if (!version) return version
67:
  return stringify(version)
68:
}
69:
 
70:
function valid (version) {
71:
  if (typeof version !== "string") return null
72:
  return exports.parse(version) && version.trim().replace(/^[v=]+/, '')
73:
}
74:
 
75:
function validPackage (version) {
76:
  if (typeof version !== "string") return null
77:
  return version.match(expressions.parsePackage) && version.trim()
78:
}
79:
 
80:
// range can be one of:
81:
// "1.0.3 - 2.0.0" range, inclusive, like ">=1.0.3 <=2.0.0"
82:
// ">1.0.2" like 1.0.3 - 9999.9999.9999
83:
// ">=1.0.2" like 1.0.2 - 9999.9999.9999
84:
// "<2.0.0" like 0.0.0 - 1.9999.9999
85:
// ">1.0.2 <2.0.0" like 1.0.3 - 1.9999.9999
86:
var starExpression = /(<|>)?=?\s*\*/g
87:
  , starReplace = ""
88:
  , compTrimExpression = new RegExp("((<|>)?=|<|>)\\s*("
89:
                                    +semver+"|"+xRangePlain+")", "g")
90:
  , compTrimReplace = "$1$3"
91:
 
92:
function toComparators (range) {
93:
  var ret = (range || "").trim()
94:
    .replace(expressions.parseRange, exports.rangeReplace)
95:
    .replace(compTrimExpression, compTrimReplace)
96:
    .split(/\s+/)
97:
    .join(" ")
98:
    .split("||")
99:
    .map(function (orchunk) {
100:
      return orchunk
101:
        .replace(new RegExp("(" + exprLoneSpermy + ")\\s+"), "$1")
102:
        .split(" ")
103:
        .map(replaceXRanges)
104:
        .map(replaceSpermies)
105:
        .map(replaceStars)
106:
        .join(" ").trim()
107:
    })
108:
    .map(function (orchunk) {
109:
      return orchunk
110:
        .trim()
111:
        .split(/\s+/)
112:
        .filter(function (c) { return c.match(expressions.validComparator) })
113:
    })
114:
    .filter(function (c) { return c.length })
115:
  return ret
116:
}
117:
 
118:
function replaceStars (stars) {
119:
  return stars.trim().replace(starExpression, starReplace)
120:
}
121:
 
122:
// "2.x","2.x.x" --> ">=2.0.0- <2.1.0-"
123:
// "2.3.x" --> ">=2.3.0- <2.4.0-"
124:
function replaceXRanges (ranges) {
125:
  return ranges.split(/\s+/)
126:
               .map(replaceXRange)
127:
               .join(" ")
128:
}
129:
 
130:
function replaceXRange (version) {
131:
  return version.trim().replace(expressions.parseXRange,
132:
                                function (v, gtlt, M, m, p, t) {
133:
    var anyX = !M || M.toLowerCase() === "x" || M === "*"
134:
               || !m || m.toLowerCase() === "x" || m === "*"
135:
               || !p || p.toLowerCase() === "x" || p === "*"
136:
      , ret = v
137:
 
138:
    if (gtlt && anyX) {
139:
      // just replace x'es with zeroes
140:
      ;(!M || M === "*" || M.toLowerCase() === "x") && (M = 0)
141:
      ;(!m || m === "*" || m.toLowerCase() === "x") && (m = 0)
142:
      ;(!p || p === "*" || p.toLowerCase() === "x") && (p = 0)
143:
      ret = gtlt + M+"."+m+"."+p+"-"
144:
    } else if (!M || M === "*" || M.toLowerCase() === "x") {
145:
      ret = "*" // allow any
146:
    } else if (!m || m === "*" || m.toLowerCase() === "x") {
147:
      // append "-" onto the version, otherwise
148:
      // "1.x.x" matches "2.0.0beta", since the tag
149:
      // *lowers* the version value
150:
      ret = ">="+M+".0.0- <"+(+M+1)+".0.0-"
151:
    } else if (!p || p === "*" || p.toLowerCase() === "x") {
152:
      ret = ">="+M+"."+m+".0- <"+M+"."+(+m+1)+".0-"
153:
    }
154:
    return ret
155:
  })
156:
}
157:
 
158:
// ~, ~> --> * (any, kinda silly)
159:
// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0
160:
// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0
161:
// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0
162:
// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0
163:
// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0
164:
function replaceSpermies (version) {
165:
  return version.trim().replace(expressions.parseSpermy,
166:
                                function (v, gtlt, M, m, p, t) {
167:
    if (gtlt) throw new Error(
168:
      "Using '"+gtlt+"' with ~ makes no sense. Don't do it.")
169:
 
170:
    if (!M || M.toLowerCase() === "x") {
171:
      return ""
172:
    }
173:
    // ~1 == >=1.0.0- <2.0.0-
174:
    if (!m || m.toLowerCase() === "x") {
175:
      return ">="+M+".0.0- <"+(+M+1)+".0.0-"
176:
    }
177:
    // ~1.2 == >=1.2.0- <1.3.0-
178:
    if (!p || p.toLowerCase() === "x") {
179:
      return ">="+M+"."+m+".0- <"+M+"."+(+m+1)+".0-"
180:
    }
181:
    // ~1.2.3 == >=1.2.3- <1.3.0-
182:
    t = t || "-"
183:
    return ">="+M+"."+m+"."+p+t+" <"+M+"."+(+m+1)+".0-"
184:
  })
185:
}
186:
 
187:
function validRange (range) {
188:
  range = replaceStars(range)
189:
  var c = toComparators(range)
190:
  return (c.length === 0)
191:
       ? null
192:
       : c.map(function (c) { return c.join(" ") }).join("||")
193:
}
194:
 
195:
// returns the highest satisfying version in the list, or undefined
196:
function maxSatisfying (versions, range) {
197:
  return versions
198:
    .filter(function (v) { return satisfies(v, range) })
199:
    .sort(compare)
200:
    .pop()
201:
}
202:
function satisfies (version, range) {
203:
  version = valid(version)
204:
  if (!version) return false
205:
  range = toComparators(range)
206:
  for (var i = 0, l = range.length ; i < l ; i ++) {
207:
    var ok = false
208:
    for (var j = 0, ll = range[i].length ; j < ll ; j ++) {
209:
      var r = range[i][j]
210:
        , gtlt = r.charAt(0) === ">" ? gt
211:
               : r.charAt(0) === "<" ? lt
212:
               : false
213:
        , eq = r.charAt(!!gtlt) === "="
214:
        , sub = (!!eq) + (!!gtlt)
215:
      if (!gtlt) eq = true
216:
      r = r.substr(sub)
217:
      r = (r === "") ? r : valid(r)
218:
      ok = (r === "") || (eq && r === version) || (gtlt && gtlt(version, r))
219:
      if (!ok) break
220:
    }
221:
    if (ok) return true
222:
  }
223:
  return false
224:
}
225:
 
226:
// return v1 > v2 ? 1 : -1
227:
function compare (v1, v2) {
228:
  var g = gt(v1, v2)
229:
  return g === null ? 0 : g ? 1 : -1
230:
}
231:
 
232:
function rcompare (v1, v2) {
233:
  return compare(v2, v1)
234:
}
235:
 
236:
function lt (v1, v2) { return gt(v2, v1) }
237:
function gte (v1, v2) { return !lt(v1, v2) }
238:
function lte (v1, v2) { return !gt(v1, v2) }
239:
function eq (v1, v2) { return gt(v1, v2) === null }
240:
function neq (v1, v2) { return gt(v1, v2) !== null }
241:
function cmp (v1, c, v2) {
242:
  switch (c) {
243:
    case ">": return gt(v1, v2)
244:
    case "<": return lt(v1, v2)
245:
    case ">=": return gte(v1, v2)
246:
    case "<=": return lte(v1, v2)
247:
    case "==": return eq(v1, v2)
248:
    case "!=": return neq(v1, v2)
249:
    case "===": return v1 === v2
250:
    case "!==": return v1 !== v2
251:
    default: throw new Error("Y U NO USE VALID COMPARATOR!? "+c)
252:
  }
253:
}
254:
 
255:
// return v1 > v2
256:
function num (v) {
257:
  return v === undefined ? -1 : parseInt((v||"0").replace(/[^0-9]+/g, ''), 10)
258:
}
259:
function gt (v1, v2) {
260:
  v1 = exports.parse(v1)
261:
  v2 = exports.parse(v2)
262:
  if (!v1 || !v2) return false
263:
 
264:
  for (var i = 1; i < 5; i ++) {
265:
    v1[i] = num(v1[i])
266:
    v2[i] = num(v2[i])
267:
    if (v1[i] > v2[i]) return true
268:
    else if (v1[i] !== v2[i]) return false
269:
  }
270:
  // no tag is > than any tag, or use lexicographical order.
271:
  var tag1 = v1[5] || ""
272:
    , tag2 = v2[5] || ""
273:
 
274:
  // kludge: null means they were equal.  falsey, and detectable.
275:
  // embarrassingly overclever, though, I know.
276:
  return tag1 === tag2 ? null
277:
         : !tag1 ? true
278:
         : !tag2 ? false
279:
         : tag1 > tag2
280:
}
281:
 
282:
function inc (version, release) {
283:
  version = exports.parse(version)
284:
  if (!version) return null
285:
 
286:
  var parsedIndexLookup =
287:
    { 'major': 1
288:
    , 'minor': 2
289:
    , 'patch': 3
290:
    , 'build': 4 }
291:
  var incIndex = parsedIndexLookup[release]
292:
  if (incIndex === undefined) return null
293:
 
294:
  var current = num(version[incIndex])
295:
  version[incIndex] = current === -1 ? 1 : current + 1
296:
 
297:
  for (var i = incIndex + 1; i < 5; i ++) {
298:
    if (num(version[i]) !== -1) version[i] = "0"
299:
  }
300:
 
301:
  if (version[4]) version[4] = "-" + version[4]
302:
  version[5] = ""
303:
 
304:
  return stringify(version)
305:
}
306:
})(typeof exports === "object" ? exports : semver = {})