conjur-asset-ui-api 1.1.0

data/vendor/prelude-ls/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "prelude-ls",
+  "version": "1.0.3",
+  "author": "George Zahariev <z@georgezahariev.com>",
+  "description": "prelude.ls is a functionally oriented utility library. It is powerful and flexible. Almost all of its functions are curried. It is written in, and is the recommended base library for, LiveScript.",
+  "keywords": [
+    "prelude",
+    "livescript",
+    "utility",
+    "ls",
+    "coffeescript",
+    "javascript",
+    "library",
+    "functional",
+    "array",
+    "list",
+    "object",
+    "string"
+  ],
+  "main": "lib/",
+  "files": [
+    "lib/",
+    "README.md",
+    "LICENSE"
+  ],
+  "homepage": "http://preludels.com",
+  "bugs": "https://github.com/gkz/prelude-ls/issues",
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "https://raw.github.com/gkz/prelude-ls/master/LICENSE"
+    }
+  ],
+  "engines": {
+    "node": ">= 0.8.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/gkz/prelude-ls.git"
+  },
+  "scripts": {
+    "test": "make test"
+  },
+  "devDependencies": {
+    "LiveScript": "~1.1.1",
+    "uglify-js": "~2.2.5",
+    "mocha": "~1.8.2",
+    "browserify": "~2.13.2"
+  }
+}

data/vendor/prelude-ls/package.ls

@@ -0,0 +1,46 @@
+name: 'prelude-ls'
+version: '1.0.3'
+
+author: 'George Zahariev <z@georgezahariev.com>'
+
+description: "prelude.ls is a functionally oriented utility library. It is powerful and flexible. Almost all of its functions are curried. It is written in, and is the recommended base library for, LiveScript."
+
+keywords:
+  'prelude'
+  'livescript'
+  'utility'
+  'ls'
+  'coffeescript'
+  'javascript'
+  'library'
+  'functional'
+  'array'
+  'list'
+  'object'
+  'string'
+
+main: 'lib/'
+files:
+  'lib/'
+  'README.md'
+  'LICENSE'
+
+homepage: 'http://preludels.com'
+bugs: 'https://github.com/gkz/prelude-ls/issues'
+licenses:
+  * type: 'MIT'
+    url: 'https://raw.github.com/gkz/prelude-ls/master/LICENSE'
+  ...
+engines:
+  node: '>= 0.8.0'
+repository:
+  type: 'git'
+  url: 'git://github.com/gkz/prelude-ls.git'
+scripts:
+  test: "make test"
+
+dev-dependencies:
+  LiveScript: '~1.1.1'
+  'uglify-js': '~2.2.5'
+  mocha: '~1.8.2'
+  browserify: '~2.13.2'

data/vendor/prelude-ls/src/Func.ls

@@ -0,0 +1,17 @@
+curry = (f) ->
+  curry$ f # using util method curry$ from livescript
+
+flip = (f, x, y) --> f y, x
+
+fix = (f) ->
+  ( (g, x) -> -> f(g g) ...arguments ) do
+    (g, x) -> -> f(g g) ...arguments
+
+apply = (f, list) -->
+  f.apply null, list
+
+#? memoize, wrap
+
+module.exports = {
+  curry, flip, fix, apply
+}

data/vendor/prelude-ls/src/List.ls

@@ -0,0 +1,299 @@
+each = (f, xs) -->
+  for x in xs then f x
+  xs
+
+map = (f, xs) -->
+  [f x for x in xs]
+
+compact = (xs) -->
+  [x for x in xs when x]
+
+filter = (f, xs) -->
+  [x for x in xs when f x]
+
+reject = (f, xs) -->
+  [x for x in xs when not f x]
+
+partition = (f, xs) -->
+  passed = []
+  failed = []
+  for x in xs
+    (if f x then passed else failed).push x
+  [passed, failed]
+
+find = (f, xs) -->
+  for x in xs when f x then return x
+  void
+
+head = first = (xs) ->
+  return void unless xs.length
+  xs.0
+
+tail = (xs) ->
+  return void unless xs.length
+  xs.slice 1
+
+last = (xs) ->
+  return void unless xs.length
+  xs[*-1]
+
+initial = (xs) ->
+  len = xs.length
+  return void unless len
+  xs.slice 0, len - 1
+
+empty = (xs) ->
+  not xs.length
+
+reverse = (xs) ->
+  xs.concat!.reverse!
+
+unique = (xs) ->
+  result = []
+  for x in xs when x not in result
+    result.push x
+  result
+
+fold = foldl = (f, memo, xs) -->
+  for x in xs then memo = f memo, x
+  memo
+
+fold1 = foldl1 = (f, xs) -->
+  fold f, xs.0, xs.slice 1
+
+foldr = (f, memo, xs) -->
+  fold f, memo, (xs.concat!.reverse!)
+
+foldr1 = (f, xs) -->
+  ys = xs.concat!.reverse!
+  fold f, ys.0, ys.slice 1
+
+unfoldr = (f, b) -->
+  result = []
+  x = b
+  while (f x)?
+    result.push that.0
+    x = that.1
+  result
+
+concat = (xss) ->
+  [].concat.apply [], xss
+
+concat-map = (f, xs) -->
+  [].concat.apply [], [f x for x in xs]
+
+flatten = (xs) -->
+  [].concat.apply [], [(if typeof! x is 'Array' then flatten x else x) for x in xs]
+
+difference = (xs, ...yss) ->
+  results = []
+  :outer for x in xs
+    for ys in yss
+      continue outer if x in ys
+    results.push x
+  results
+
+intersection = (xs, ...yss) ->
+  results = []
+  :outer for x in xs
+    for ys in yss
+      continue outer unless x in ys
+    results.push x
+  results
+
+union = (...xss) ->
+  results = []
+  for xs in xss
+    for x in xs
+      results.push x unless x in results
+  results
+
+count-by = (f, xs) -->
+  results = {}
+  for x in xs
+    key = f x
+    if key of results
+      results[key] += 1
+    else
+      results[key] = 1
+  results
+
+group-by = (f, xs) -->
+  results = {}
+  for x in xs
+    key = f x
+    if key of results
+      results[key].push x
+    else
+      results[key] = [x]
+  results
+
+and-list = (xs) ->
+  for x in xs when not x
+    return false
+  true
+
+or-list = (xs) ->
+  for x in xs when x
+    return true
+  false
+
+any = (f, xs) -->
+  for x in xs when f x
+    return true
+  false
+
+all = (f, xs) -->
+  for x in xs when not f x
+    return false
+  true
+
+sort = (xs) ->
+  xs.concat!.sort (x, y) ->
+    if x > y
+      1
+    else if x < y
+      -1
+    else
+      0
+
+sort-with = (f, xs) -->
+  return [] unless xs.length
+  xs.concat!.sort f
+
+sort-by = (f, xs) -->
+  return [] unless xs.length
+  xs.concat!.sort (x, y) ->
+    if (f x) > (f y)
+      1
+    else if (f x) < (f y)
+      -1
+    else
+      0
+
+sum = (xs) ->
+  result = 0
+  for x in xs
+    result += x
+  result
+
+product = (xs) ->
+  result = 1
+  for x in xs
+    result *= x
+  result
+
+mean = average = (xs) ->
+  sum = 0
+  len = xs.length
+  for i til len
+    sum += xs[i]
+  sum / len
+
+maximum = (xs) ->
+  max = xs.0
+  for x in xs.slice 1 when x > max
+    max = x
+  max
+
+minimum = (xs) ->
+  min = xs.0
+  for x in xs.slice 1 when x < min
+    min = x
+  min
+
+scan = scanl = (f, memo, xs) -->
+  last = memo
+  [memo] ++ [last = f last, x for x in xs]
+
+scan1 = scanl1 = (f, xs) -->
+  return void unless xs.length
+  scan f, xs.0, xs.slice 1
+
+scanr = (f, memo, xs) -->
+  xs = xs.concat!.reverse!
+  (scan f, memo, xs).reverse!
+
+scanr1 = (f, xs) -->
+  return void unless xs.length
+  xs = xs.concat!.reverse!
+  (scan f, xs.0, xs.slice 1).reverse!
+
+slice = (x, y, xs) -->
+  xs.slice x, y
+
+take = (n, xs) -->
+  if n <= 0
+    xs.slice 0, 0
+  else if not xs.length
+    xs
+  else
+    xs.slice 0, n
+
+drop = (n, xs) -->
+  if n <= 0 or not xs.length
+    xs
+  else
+    xs.slice n
+
+split-at = (n, xs) --> [(take n, xs), (drop n, xs)]
+
+take-while = (p, xs) -->
+  len = xs.length
+  return xs unless len
+  i = 0
+  while i < len and p xs[i]
+    i += 1
+  xs.slice 0 i
+
+drop-while = (p, xs) -->
+  len = xs.length
+  return xs unless len
+  i = 0
+  while i < len and p xs[i]
+    i += 1
+  xs.slice i
+
+span = (p, xs) --> [(take-while p, xs), (drop-while p, xs)]
+
+break-list = (p, xs) --> span (not) << p, xs
+
+zip = (xs, ys) -->
+  result = []
+  len = ys.length
+  for x, i in xs
+    break if i is len
+    result.push [x, ys[i]]
+  result
+
+zip-with = (f, xs, ys) -->
+  result = []
+  len = ys.length
+  for x, i in xs
+    break if i is len
+    result.push f x, ys[i]
+  result
+
+zip-all = (...xss) ->
+  min-length = 9e9
+  for xs in xss
+    min-length <?= xs.length
+  [[xs[i] for xs in xss] for i til min-length]
+
+zip-all-with = (f, ...xss) ->
+  min-length = 9e9
+  for xs in xss
+    min-length <?= xs.length
+  [f.apply(null, [xs[i] for xs in xss]) for i til min-length]
+
+module.exports = {
+  each, map, filter, compact, reject, partition, find,
+  head, first, tail, last, initial, empty,
+  reverse, difference, intersection, union, count-by, group-by,
+  fold, fold1, foldl, foldl1, foldr, foldr1, unfoldr, and-list, or-list,
+  any, all, unique, sort, sort-with, sort-by, sum, product, mean, average,
+  concat, concat-map, flatten,
+  maximum, minimum, scan, scan1, scanl, scanl1, scanr, scanr1,
+  slice, take, drop, split-at, take-while, drop-while, span, break-list,
+  zip, zip-with, zip-all, zip-all-with,
+}

data/vendor/prelude-ls/src/Num.ls

@@ -0,0 +1,83 @@
+max = (>?)
+
+min = (<?)
+
+negate = (x) -> -x
+
+abs = Math.abs
+
+signum = (x) ->
+  if x < 0
+    -1
+  else if x > 0
+    1
+  else
+    0
+
+quot = (x, y) --> ~~(x / y)
+
+rem = (%)
+
+div = (x, y) --> Math.floor x / y
+
+mod = (%%)
+
+recip = (1 /)
+
+pi = Math.PI
+
+tau = pi * 2
+
+exp = Math.exp
+
+sqrt = Math.sqrt
+
+ln = Math.log
+
+pow = (^)
+
+sin = Math.sin
+
+tan = Math.tan
+
+cos = Math.cos
+
+asin = Math.asin
+
+acos = Math.acos
+
+atan = Math.atan
+
+atan2 = (x, y) --> Math.atan2 x, y
+
+truncate = (x) -> ~~x
+
+round = Math.round
+
+ceiling = Math.ceil
+
+floor = Math.floor
+
+is-it-NaN = (x) -> x isnt x
+
+even = (x) -> x % 2 == 0
+
+odd = (x) -> x % 2 != 0
+
+gcd = (x, y) -->
+  x = Math.abs x
+  y = Math.abs y
+  until y is 0
+    z = x % y
+    x = y
+    y = z
+  x
+
+lcm = (x, y) -->
+  Math.abs Math.floor (x / (gcd x, y) * y)
+
+module.exports = {
+  max, min, negate, abs, signum, quot, rem, div, mod, recip,
+  pi, tau, exp, sqrt, ln, pow, sin, tan, cos, acos, asin, atan, atan2,
+  truncate, round, ceiling, floor, is-it-NaN, even, odd, gcd, lcm,
+}