conjur-asset-ui 1.3.2 → 1.4.2

data/vendor/prelude-ls/package.json

@@ -1,50 +0,0 @@
-{
-  "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

@@ -1,46 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,299 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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,
-}