lambda_pattern
Version:
module used for automating the lambda pattern of development
17,515 lines • 493 kB
JavaScript
#!/usr/bin/env node
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false
/******/ };
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/ // Load entry module and return exports
/******/ return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var ERR = __webpack_require__(1);
var word_wrap = __webpack_require__(2);
var commander = __webpack_require__(3);
var create_commander = __webpack_require__(4);
create_commander(commander, __dirname);
commander.parse(process.argv);
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 1 */
/***/ function(module, exports) {
module.exports = require("async-stacktrace");
/***/ },
/* 2 */
/***/ function(module, exports) {
module.exports = require("word-wrap");
/***/ },
/* 3 */
/***/ function(module, exports) {
module.exports = require("commander");
/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {
var ERR, word_wrap, create, set_up, get_metadata, build_tools, overwrite_tools, _;
'use strict';
ERR = __webpack_require__(1);
word_wrap = __webpack_require__(2);
create = __webpack_require__(5);
set_up = __webpack_require__(46);
get_metadata = __webpack_require__(382);
build_tools = __webpack_require__(383);
overwrite_tools = __webpack_require__(395);
_ = function _(commander, mu_src_path) {
var success_message, cb;
success_message = 'created a lambda pattern project in your current directory';
cb = function cb(e) {
if (e) {
return console.log(e);
}
console.log(success_message);
};
commander.command('create project_name').description('make a new lambda patern project').action(function (project_name) {
var err, gen_path, info;
console.log('+++ 1');
create(mu_src_path, process.cwd(), project_name, 2000, function (arguments, _$param0) {
err = _$param0;
if (ERR(err, cb)) {
return;
}
console.log('+++ 2');
gen_path = __dirname + '/' + project_name;
console.log('+++ 3');
get_metadata(gen_path, function (arguments, _$param1, _$param2) {
err = _$param1;
info = _$param2;
if (ERR(err, cb)) {
return;
}
console.log('+++ 4');
set_up(mu_src_path, gen_path, info, function (arguments, _$param3) {
err = _$param3;
if (ERR(err, cb)) {
return;
}
console.log('+++ 5');
build_tools(gen_path, function (arguments, _$param4) {
err = _$param4;
if (ERR(err, cb)) {
return;
}
console.log('+++ 6');
overwrite_tools(gen_path, function (arguments, _$param5) {
err = _$param5;
if (ERR(err, cb)) {
return;
}
console.log('+++ 7');
cb();
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
});
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 5 */
/***/ function(module, exports, __webpack_require__) {
var ERR, word_wrap, fs, _;
'use strict';
ERR = __webpack_require__(1);
word_wrap = __webpack_require__(2);
fs = __webpack_require__(6);
_ = function _(mu_src_path, root_path, project_name, year, cb) {
var skel_path, gen_path, err, readme, index, test_file, meta;
skel_path = mu_src_path + '/skeleton_data';
gen_path = root_path + '/' + project_name;
fs.copy(skel_path, gen_path, function (arguments, _$param0) {
err = _$param0;
if (ERR(err, cb)) {
return;
}
fs.readFile(gen_path + '/readme.md', 'utf8', function (arguments, _$param1, _$param2) {
err = _$param1;
readme = _$param2;
if (ERR(err, cb)) {
return;
}
readme = readme.replace(/\[\[project_name\]\]/g, project_name);
fs.writeFile(gen_path + '/readme.md', readme, function (arguments, _$param3) {
err = _$param3;
if (ERR(err, cb)) {
return;
}
fs.readFile(gen_path + '/_.es6', 'utf8', function (arguments, _$param4, _$param5) {
err = _$param4;
index = _$param5;
if (ERR(err, cb)) {
return;
}
index = index.replace(/\[\[project_name\]\]/g, project_name);
fs.writeFile(gen_path + '/_.es6', index, function (arguments, _$param6) {
err = _$param6;
if (ERR(err, cb)) {
return;
}
fs.readFile(gen_path + '/__test.es6', 'utf8', function (arguments, _$param7, _$param8) {
err = _$param7;
test_file = _$param8;
if (ERR(err, cb)) {
return;
}
test_file = test_file.replace(/\[\[project_name\]\]/g, project_name);
fs.writeFile(gen_path + '/__test.es6', test_file, function (arguments, _$param9) {
err = _$param9;
if (ERR(err, cb)) {
return;
}
fs.readFile(gen_path + '/meta/data.yaml', 'utf8', function (arguments, _$param10, _$param11) {
err = _$param10;
meta = _$param11;
if (ERR(err, cb)) {
return;
}
meta = meta.replace(/\[\[project_name\]\]/g, project_name);
fs.writeFile(gen_path + '/meta/data.yaml', meta, function (arguments, _$param12) {
err = _$param12;
if (ERR(err, cb)) {
return;
}
cb(null);
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {
var assign = __webpack_require__(7)
var fse = {}
var gfs = __webpack_require__(8)
// attach fs methods to fse
Object.keys(gfs).forEach(function (key) {
fse[key] = gfs[key]
})
var fs = fse
assign(fs, __webpack_require__(9))
assign(fs, __webpack_require__(19))
assign(fs, __webpack_require__(15))
assign(fs, __webpack_require__(22))
assign(fs, __webpack_require__(25))
assign(fs, __webpack_require__(31))
assign(fs, __webpack_require__(32))
assign(fs, __webpack_require__(33))
assign(fs, __webpack_require__(39))
assign(fs, __webpack_require__(40))
assign(fs, __webpack_require__(45))
module.exports = fs
// maintain backwards compatibility for awhile
var jsonfile = {}
Object.defineProperty(jsonfile, 'spaces', {
get: function () {
return fs.spaces // found in ./json
},
set: function (val) {
fs.spaces = val
}
})
module.exports.jsonfile = jsonfile // so users of fs-extra can modify jsonFile.spaces
/***/ },
/* 7 */
/***/ function(module, exports) {
// simple mutable assign
function assign () {
var args = [].slice.call(arguments).filter(function (i) { return i })
var dest = args.shift()
args.forEach(function (src) {
Object.keys(src).forEach(function (key) {
dest[key] = src[key]
})
})
return dest
}
module.exports = assign
/***/ },
/* 8 */
/***/ function(module, exports) {
module.exports = require("graceful-fs");
/***/ },
/* 9 */
/***/ function(module, exports, __webpack_require__) {
module.exports = {
copy: __webpack_require__(10)
}
/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {
var fs = __webpack_require__(8)
var path = __webpack_require__(11)
var ncp = __webpack_require__(12)
var mkdir = __webpack_require__(15)
function copy (src, dest, options, callback) {
if (typeof options === 'function' && !callback) {
callback = options
options = {}
} else if (typeof options === 'function' || options instanceof RegExp) {
options = {filter: options}
}
callback = callback || function () {}
options = options || {}
// Warn about using preserveTimestamps on 32-bit node:
if (options.preserveTimestamps && process.arch === 'ia32') {
console.warn('fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\n' +
'see https://github.com/jprichardson/node-fs-extra/issues/269')
}
// don't allow src and dest to be the same
var basePath = process.cwd()
var currentPath = path.resolve(basePath, src)
var targetPath = path.resolve(basePath, dest)
if (currentPath === targetPath) return callback(new Error('Source and destination must not be the same.'))
fs.lstat(src, function (err, stats) {
if (err) return callback(err)
var dir = null
if (stats.isDirectory()) {
var parts = dest.split(path.sep)
parts.pop()
dir = parts.join(path.sep)
} else {
dir = path.dirname(dest)
}
fs.exists(dir, function (dirExists) {
if (dirExists) return ncp(src, dest, options, callback)
mkdir.mkdirs(dir, function (err) {
if (err) return callback(err)
ncp(src, dest, options, callback)
})
})
})
}
module.exports = copy
/***/ },
/* 11 */
/***/ function(module, exports) {
module.exports = require("path");
/***/ },
/* 12 */
/***/ function(module, exports, __webpack_require__) {
// imported from ncp (this is temporary, will rewrite)
var fs = __webpack_require__(8)
var path = __webpack_require__(11)
var utimes = __webpack_require__(13)
function ncp (source, dest, options, callback) {
if (!callback) {
callback = options
options = {}
}
var basePath = process.cwd()
var currentPath = path.resolve(basePath, source)
var targetPath = path.resolve(basePath, dest)
var filter = options.filter
var transform = options.transform
var clobber = options.clobber !== false // default true
var dereference = options.dereference
var preserveTimestamps = options.preserveTimestamps === true
var started = 0
var finished = 0
var running = 0
var errored = false
startCopy(currentPath)
function startCopy (source) {
started++
if (filter) {
if (filter instanceof RegExp) {
console.warn('Warning: fs-extra: Passing a RegExp filter is deprecated, use a function')
if (!filter.test(source)) {
return doneOne(true)
}
} else if (typeof filter === 'function') {
if (!filter(source)) {
return doneOne(true)
}
}
}
return getStats(source)
}
function getStats (source) {
var stat = dereference ? fs.stat : fs.lstat
running++
stat(source, function (err, stats) {
if (err) return onError(err)
// We need to get the mode from the stats object and preserve it.
var item = {
name: source,
mode: stats.mode,
mtime: stats.mtime, // modified time
atime: stats.atime, // access time
stats: stats // temporary
}
if (stats.isDirectory()) {
return onDir(item)
} else if (stats.isFile() || stats.isCharacterDevice() || stats.isBlockDevice()) {
return onFile(item)
} else if (stats.isSymbolicLink()) {
// Symlinks don't really need to know about the mode.
return onLink(source)
}
})
}
function onFile (file) {
var target = file.name.replace(currentPath, targetPath.replace('$', '$$$$')) // escapes '$' with '$$'
isWritable(target, function (writable) {
if (writable) {
copyFile(file, target)
} else {
if (clobber) {
rmFile(target, function () {
copyFile(file, target)
})
} else {
var err = new Error('EEXIST: ' + target + ' already exists.')
err.code = 'EEXIST'
err.errno = -17
err.path = target
onError(err)
}
}
})
}
function copyFile (file, target) {
var readStream = fs.createReadStream(file.name)
var writeStream = fs.createWriteStream(target, { mode: file.mode })
readStream.on('error', onError)
writeStream.on('error', onError)
if (transform) {
transform(readStream, writeStream, file)
} else {
writeStream.on('open', function () {
readStream.pipe(writeStream)
})
}
writeStream.once('finish', function () {
fs.chmod(target, file.mode, function (err) {
if (err) return onError(err)
if (preserveTimestamps) {
utimes.utimesMillis(target, file.atime, file.mtime, function (err) {
if (err) return onError(err)
return doneOne()
})
} else {
doneOne()
}
})
})
}
function rmFile (file, done) {
fs.unlink(file, function (err) {
if (err) return onError(err)
return done()
})
}
function onDir (dir) {
var target = dir.name.replace(currentPath, targetPath.replace('$', '$$$$')) // escapes '$' with '$$'
isWritable(target, function (writable) {
if (writable) {
return mkDir(dir, target)
}
copyDir(dir.name)
})
}
function mkDir (dir, target) {
fs.mkdir(target, dir.mode, function (err) {
if (err) return onError(err)
// despite setting mode in fs.mkdir, doesn't seem to work
// so we set it here.
fs.chmod(target, dir.mode, function (err) {
if (err) return onError(err)
copyDir(dir.name)
})
})
}
function copyDir (dir) {
fs.readdir(dir, function (err, items) {
if (err) return onError(err)
items.forEach(function (item) {
startCopy(path.join(dir, item))
})
return doneOne()
})
}
function onLink (link) {
var target = link.replace(currentPath, targetPath)
fs.readlink(link, function (err, resolvedPath) {
if (err) return onError(err)
checkLink(resolvedPath, target)
})
}
function checkLink (resolvedPath, target) {
if (dereference) {
resolvedPath = path.resolve(basePath, resolvedPath)
}
isWritable(target, function (writable) {
if (writable) {
return makeLink(resolvedPath, target)
}
fs.readlink(target, function (err, targetDest) {
if (err) return onError(err)
if (dereference) {
targetDest = path.resolve(basePath, targetDest)
}
if (targetDest === resolvedPath) {
return doneOne()
}
return rmFile(target, function () {
makeLink(resolvedPath, target)
})
})
})
}
function makeLink (linkPath, target) {
fs.symlink(linkPath, target, function (err) {
if (err) return onError(err)
return doneOne()
})
}
function isWritable (path, done) {
fs.lstat(path, function (err) {
if (err) {
if (err.code === 'ENOENT') return done(true)
return done(false)
}
return done(false)
})
}
function onError (err) {
// ensure callback is defined & called only once:
if (!errored && callback !== undefined) {
errored = true
return callback(err)
}
}
function doneOne (skipped) {
if (!skipped) running--
finished++
if ((started === finished) && (running === 0)) {
if (callback !== undefined) {
return callback(null)
}
}
}
}
module.exports = ncp
/***/ },
/* 13 */
/***/ function(module, exports, __webpack_require__) {
var fs = __webpack_require__(8)
var path = __webpack_require__(11)
var os = __webpack_require__(14)
// HFS, ext{2,3}, FAT do not, Node.js v0.10 does not
function hasMillisResSync () {
var tmpfile = path.join('millis-test-sync' + Date.now().toString() + Math.random().toString().slice(2))
tmpfile = path.join(os.tmpdir(), tmpfile)
// 550 millis past UNIX epoch
var d = new Date(1435410243862)
fs.writeFileSync(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141')
var fd = fs.openSync(tmpfile, 'r+')
fs.futimesSync(fd, d, d)
fs.closeSync(fd)
return fs.statSync(tmpfile).mtime > 1435410243000
}
function hasMillisRes (callback) {
var tmpfile = path.join('millis-test' + Date.now().toString() + Math.random().toString().slice(2))
tmpfile = path.join(os.tmpdir(), tmpfile)
// 550 millis past UNIX epoch
var d = new Date(1435410243862)
fs.writeFile(tmpfile, 'https://github.com/jprichardson/node-fs-extra/pull/141', function (err) {
if (err) return callback(err)
fs.open(tmpfile, 'r+', function (err, fd) {
if (err) return callback(err)
fs.futimes(fd, d, d, function (err) {
if (err) return callback(err)
fs.close(fd, function (err) {
if (err) return callback(err)
fs.stat(tmpfile, function (err, stats) {
if (err) return callback(err)
callback(null, stats.mtime > 1435410243000)
})
})
})
})
})
}
function timeRemoveMillis (timestamp) {
if (typeof timestamp === 'number') {
return Math.floor(timestamp / 1000) * 1000
} else if (timestamp instanceof Date) {
return new Date(Math.floor(timestamp.getTime() / 1000) * 1000)
} else {
throw new Error('fs-extra: timeRemoveMillis() unknown parameter type')
}
}
function utimesMillis (path, atime, mtime, callback) {
// if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback)
fs.open(path, 'r+', function (err, fd) {
if (err) return callback(err)
fs.futimes(fd, atime, mtime, function (futimesErr) {
fs.close(fd, function (closeErr) {
if (callback) callback(futimesErr || closeErr)
})
})
})
}
module.exports = {
hasMillisRes: hasMillisRes,
hasMillisResSync: hasMillisResSync,
timeRemoveMillis: timeRemoveMillis,
utimesMillis: utimesMillis
}
/***/ },
/* 14 */
/***/ function(module, exports) {
module.exports = require("os");
/***/ },
/* 15 */
/***/ function(module, exports, __webpack_require__) {
module.exports = {
mkdirs: __webpack_require__(16),
mkdirsSync: __webpack_require__(18),
// alias
mkdirp: __webpack_require__(16),
mkdirpSync: __webpack_require__(18),
ensureDir: __webpack_require__(16),
ensureDirSync: __webpack_require__(18)
}
/***/ },
/* 16 */
/***/ function(module, exports, __webpack_require__) {
var fs = __webpack_require__(8)
var path = __webpack_require__(11)
var invalidWin32Path = __webpack_require__(17).invalidWin32Path
var o777 = parseInt('0777', 8)
function mkdirs (p, opts, callback, made) {
if (typeof opts === 'function') {
callback = opts
opts = {}
} else if (!opts || typeof opts !== 'object') {
opts = { mode: opts }
}
if (process.platform === 'win32' && invalidWin32Path(p)) {
var errInval = new Error(p + ' contains invalid WIN32 path characters.')
errInval.code = 'EINVAL'
return callback(errInval)
}
var mode = opts.mode
var xfs = opts.fs || fs
if (mode === undefined) {
mode = o777 & (~process.umask())
}
if (!made) made = null
callback = callback || function () {}
p = path.resolve(p)
xfs.mkdir(p, mode, function (er) {
if (!er) {
made = made || p
return callback(null, made)
}
switch (er.code) {
case 'ENOENT':
if (path.dirname(p) === p) return callback(er)
mkdirs(path.dirname(p), opts, function (er, made) {
if (er) callback(er, made)
else mkdirs(p, opts, callback, made)
})
break
// In the case of any other error, just see if there's a dir
// there already. If so, then hooray! If not, then something
// is borked.
default:
xfs.stat(p, function (er2, stat) {
// if the stat fails, then that's super weird.
// let the original error be the failure reason.
if (er2 || !stat.isDirectory()) callback(er, made)
else callback(null, made)
})
break
}
})
}
module.exports = mkdirs
/***/ },
/* 17 */
/***/ function(module, exports, __webpack_require__) {
'use strict'
var path = __webpack_require__(11)
// get drive on windows
function getRootPath (p) {
p = path.normalize(path.resolve(p)).split(path.sep)
if (p.length > 0) return p[0]
else return null
}
// http://stackoverflow.com/a/62888/10333 contains more accurate
// TODO: expand to include the rest
var INVALID_PATH_CHARS = /[<>:"|?*]/
function invalidWin32Path (p) {
var rp = getRootPath(p)
p = p.replace(rp, '')
return INVALID_PATH_CHARS.test(p)
}
module.exports = {
getRootPath: getRootPath,
invalidWin32Path: invalidWin32Path
}
/***/ },
/* 18 */
/***/ function(module, exports, __webpack_require__) {
var fs = __webpack_require__(8)
var path = __webpack_require__(11)
var invalidWin32Path = __webpack_require__(17).invalidWin32Path
var o777 = parseInt('0777', 8)
function mkdirsSync (p, opts, made) {
if (!opts || typeof opts !== 'object') {
opts = { mode: opts }
}
var mode = opts.mode
var xfs = opts.fs || fs
if (process.platform === 'win32' && invalidWin32Path(p)) {
var errInval = new Error(p + ' contains invalid WIN32 path characters.')
errInval.code = 'EINVAL'
throw errInval
}
if (mode === undefined) {
mode = o777 & (~process.umask())
}
if (!made) made = null
p = path.resolve(p)
try {
xfs.mkdirSync(p, mode)
made = made || p
} catch (err0) {
switch (err0.code) {
case 'ENOENT':
if (path.dirname(p) === p) throw err0
made = mkdirsSync(path.dirname(p), opts, made)
mkdirsSync(p, opts, made)
break
// In the case of any other error, just see if there's a dir
// there already. If so, then hooray! If not, then something
// is borked.
default:
var stat
try {
stat = xfs.statSync(p)
} catch (err1) {
throw err0
}
if (!stat.isDirectory()) throw err0
break
}
}
return made
}
module.exports = mkdirsSync
/***/ },
/* 19 */
/***/ function(module, exports, __webpack_require__) {
module.exports = {
copySync: __webpack_require__(20)
}
/***/ },
/* 20 */
/***/ function(module, exports, __webpack_require__) {
var fs = __webpack_require__(8)
var path = __webpack_require__(11)
var copyFileSync = __webpack_require__(21)
var mkdir = __webpack_require__(15)
function copySync (src, dest, options) {
if (typeof options === 'function' || options instanceof RegExp) {
options = {filter: options}
}
options = options || {}
options.recursive = !!options.recursive
// default to true for now
options.clobber = 'clobber' in options ? !!options.clobber : true
options.dereference = 'dereference' in options ? !!options.dereference : false
options.preserveTimestamps = 'preserveTimestamps' in options ? !!options.preserveTimestamps : false
options.filter = options.filter || function () { return true }
// Warn about using preserveTimestamps on 32-bit node:
if (options.preserveTimestamps && process.arch === 'ia32') {
console.warn('fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\n' +
'see https://github.com/jprichardson/node-fs-extra/issues/269')
}
var stats = (options.recursive && !options.dereference) ? fs.lstatSync(src) : fs.statSync(src)
var destFolder = path.dirname(dest)
var destFolderExists = fs.existsSync(destFolder)
var performCopy = false
if (stats.isFile()) {
if (options.filter instanceof RegExp) {
console.warn('Warning: fs-extra: Passing a RegExp filter is deprecated, use a function')
performCopy = options.filter.test(src)
} else if (typeof options.filter === 'function') performCopy = options.filter(src)
if (performCopy) {
if (!destFolderExists) mkdir.mkdirsSync(destFolder)
copyFileSync(src, dest, {clobber: options.clobber, preserveTimestamps: options.preserveTimestamps})
}
} else if (stats.isDirectory()) {
if (!fs.existsSync(dest)) mkdir.mkdirsSync(dest)
var contents = fs.readdirSync(src)
contents.forEach(function (content) {
var opts = options
opts.recursive = true
copySync(path.join(src, content), path.join(dest, content), opts)
})
} else if (options.recursive && stats.isSymbolicLink()) {
var srcPath = fs.readlinkSync(src)
fs.symlinkSync(srcPath, dest)
}
}
module.exports = copySync
/***/ },
/* 21 */
/***/ function(module, exports, __webpack_require__) {
var fs = __webpack_require__(8)
var BUF_LENGTH = 64 * 1024
var _buff = new Buffer(BUF_LENGTH)
function copyFileSync (srcFile, destFile, options) {
var clobber = options.clobber
var preserveTimestamps = options.preserveTimestamps
if (fs.existsSync(destFile)) {
if (clobber) {
fs.unlinkSync(destFile)
} else {
var err = new Error('EEXIST: ' + destFile + ' already exists.')
err.code = 'EEXIST'
err.errno = -17
err.path = destFile
throw err
}
}
var fdr = fs.openSync(srcFile, 'r')
var stat = fs.fstatSync(fdr)
var fdw = fs.openSync(destFile, 'w', stat.mode)
var bytesRead = 1
var pos = 0
while (bytesRead > 0) {
bytesRead = fs.readSync(fdr, _buff, 0, BUF_LENGTH, pos)
fs.writeSync(fdw, _buff, 0, bytesRead)
pos += bytesRead
}
if (preserveTimestamps) {
fs.futimesSync(fdw, stat.atime, stat.mtime)
}
fs.closeSync(fdr)
fs.closeSync(fdw)
}
module.exports = copyFileSync
/***/ },
/* 22 */
/***/ function(module, exports, __webpack_require__) {
var rimraf = __webpack_require__(23)
function removeSync (dir) {
return rimraf.sync(dir, {disableGlob: true})
}
function remove (dir, callback) {
var options = {disableGlob: true}
return callback ? rimraf(dir, options, callback) : rimraf(dir, options, function () {})
}
module.exports = {
remove: remove,
removeSync: removeSync
}
/***/ },
/* 23 */
/***/ function(module, exports, __webpack_require__) {
module.exports = rimraf
rimraf.sync = rimrafSync
var assert = __webpack_require__(24)
var path = __webpack_require__(11)
var fs = __webpack_require__(8)
var isWindows = (process.platform === 'win32')
function defaults (options) {
var methods = [
'unlink',
'chmod',
'stat',
'lstat',
'rmdir',
'readdir'
]
methods.forEach(function (m) {
options[m] = options[m] || fs[m]
m = m + 'Sync'
options[m] = options[m] || fs[m]
})
options.maxBusyTries = options.maxBusyTries || 3
}
function rimraf (p, options, cb) {
if (typeof options === 'function') {
cb = options
options = {}
}
assert(p, 'rimraf: missing path')
assert.equal(typeof p, 'string', 'rimraf: path should be a string')
assert.equal(typeof cb, 'function', 'rimraf: callback function required')
assert(options, 'rimraf: invalid options argument provided')
assert.equal(typeof options, 'object', 'rimraf: options should be object')
defaults(options)
var busyTries = 0
rimraf_(p, options, function CB (er) {
if (er) {
if (isWindows && (er.code === 'EBUSY' || er.code === 'ENOTEMPTY' || er.code === 'EPERM') &&
busyTries < options.maxBusyTries) {
busyTries++
var time = busyTries * 100
// try again, with the same exact callback as this one.
return setTimeout(function () {
rimraf_(p, options, CB)
}, time)
}
// already gone
if (er.code === 'ENOENT') er = null
}
cb(er)
})
}
// Two possible strategies.
// 1. Assume it's a file. unlink it, then do the dir stuff on EPERM or EISDIR
// 2. Assume it's a directory. readdir, then do the file stuff on ENOTDIR
//
// Both result in an extra syscall when you guess wrong. However, there
// are likely far more normal files in the world than directories. This
// is based on the assumption that a the average number of files per
// directory is >= 1.
//
// If anyone ever complains about this, then I guess the strategy could
// be made configurable somehow. But until then, YAGNI.
function rimraf_ (p, options, cb) {
assert(p)
assert(options)
assert(typeof cb === 'function')
// sunos lets the root user unlink directories, which is... weird.
// so we have to lstat here and make sure it's not a dir.
options.lstat(p, function (er, st) {
if (er && er.code === 'ENOENT') {
return cb(null)
}
// Windows can EPERM on stat. Life is suffering.
if (er && er.code === 'EPERM' && isWindows) {
fixWinEPERM(p, options, er, cb)
}
if (st && st.isDirectory()) {
return rmdir(p, options, er, cb)
}
options.unlink(p, function (er) {
if (er) {
if (er.code === 'ENOENT') {
return cb(null)
}
if (er.code === 'EPERM') {
return (isWindows)
? fixWinEPERM(p, options, er, cb)
: rmdir(p, options, er, cb)
}
if (er.code === 'EISDIR') {
return rmdir(p, options, er, cb)
}
}
return cb(er)
})
})
}
function fixWinEPERM (p, options, er, cb) {
assert(p)
assert(options)
assert(typeof cb === 'function')
if (er) {
assert(er instanceof Error)
}
options.chmod(p, 666, function (er2) {
if (er2) {
cb(er2.code === 'ENOENT' ? null : er)
} else {
options.stat(p, function (er3, stats) {
if (er3) {
cb(er3.code === 'ENOENT' ? null : er)
} else if (stats.isDirectory()) {
rmdir(p, options, er, cb)
} else {
options.unlink(p, cb)
}
})
}
})
}
function fixWinEPERMSync (p, options, er) {
assert(p)
assert(options)
if (er) {
assert(er instanceof Error)
}
try {
options.chmodSync(p, 666)
} catch (er2) {
if (er2.code === 'ENOENT') {
return
} else {
throw er
}
}
try {
var stats = options.statSync(p)
} catch (er3) {
if (er3.code === 'ENOENT') {
return
} else {
throw er
}
}
if (stats.isDirectory()) {
rmdirSync(p, options, er)
} else {
options.unlinkSync(p)
}
}
function rmdir (p, options, originalEr, cb) {
assert(p)
assert(options)
if (originalEr) {
assert(originalEr instanceof Error)
}
assert(typeof cb === 'function')
// try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS)
// if we guessed wrong, and it's not a directory, then
// raise the original error.
options.rmdir(p, function (er) {
if (er && (er.code === 'ENOTEMPTY' || er.code === 'EEXIST' || er.code === 'EPERM')) {
rmkids(p, options, cb)
} else if (er && er.code === 'ENOTDIR') {
cb(originalEr)
} else {
cb(er)
}
})
}
function rmkids (p, options, cb) {
assert(p)
assert(options)
assert(typeof cb === 'function')
options.readdir(p, function (er, files) {
if (er) {
return cb(er)
}
var n = files.length
if (n === 0) {
return options.rmdir(p, cb)
}
var errState
files.forEach(function (f) {
rimraf(path.join(p, f), options, function (er) {
if (errState) {
return
}
if (er) {
return cb(errState = er)
}
if (--n === 0) {
options.rmdir(p, cb)
}
})
})
})
}
// this looks simpler, and is strictly *faster*, but will
// tie up the JavaScript thread and fail on excessively
// deep directory trees.
function rimrafSync (p, options) {
options = options || {}
defaults(options)
assert(p, 'rimraf: missing path')
assert.equal(typeof p, 'string', 'rimraf: path should be a string')
assert(options, 'rimraf: missing options')
assert.equal(typeof options, 'object', 'rimraf: options should be object')
try {
var st = options.lstatSync(p)
} catch (er) {
if (er.code === 'ENOENT') {
return
}
// Windows can EPERM on stat. Life is suffering.
if (er.code === 'EPERM' && isWindows) {
fixWinEPERMSync(p, options, er)
}
}
try {
// sunos lets the root user unlink directories, which is... weird.
if (st && st.isDirectory()) {
rmdirSync(p, options, null)
} else {
options.unlinkSync(p)
}
} catch (er) {
if (er.code === 'ENOENT') {
return
}
if (er.code === 'EPERM') {
return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er)
}
if (er.code !== 'EISDIR') {
throw er
}
rmdirSync(p, options, er)
}
}
function rmdirSync (p, options, originalEr) {
assert(p)
assert(options)
if (originalEr) {
assert(originalEr instanceof Error)
}
try {
options.rmdirSync(p)
} catch (er) {
if (er.code === 'ENOENT') {
return
}
if (er.code === 'ENOTDIR') {
throw originalEr
}
if (er.code === 'ENOTEMPTY' || er.code === 'EEXIST' || er.code === 'EPERM') {
rmkidsSync(p, options)
}
}
}
function rmkidsSync (p, options) {
assert(p)
assert(options)
options.readdirSync(p).forEach(function (f) {
rimrafSync(path.join(p, f), options)
})
options.rmdirSync(p, options)
}
/***/ },
/* 24 */
/***/ function(module, exports) {
module.exports = require("assert");
/***/ },
/* 25 */
/***/ function(module, exports, __webpack_require__) {
var jsonFile = __webpack_require__(26)
jsonFile.outputJsonSync = __webpack_require__(29)
jsonFile.outputJson = __webpack_require__(30)
// aliases
jsonFile.outputJSONSync = __webpack_require__(29)
jsonFile.outputJSON = __webpack_require__(30)
module.exports = jsonFile
/***/ },
/* 26 */
/***/ function(module, exports, __webpack_require__) {
var jsonFile = __webpack_require__(27)
module.exports = {
// jsonfile exports
readJson: jsonFile.readFile,
readJSON: jsonFile.readFile,
readJsonSync: jsonFile.readFileSync,
readJSONSync: jsonFile.readFileSync,
writeJson: jsonFile.writeFile,
writeJSON: jsonFile.writeFile,
writeJsonSync: jsonFile.writeFileSync,
writeJSONSync: jsonFile.writeFileSync,
spaces: 2 // default in fs-extra
}
/***/ },
/* 27 */
/***/ function(module, exports, __webpack_require__) {
var _fs
try {
_fs = __webpack_require__(8)
} catch (_) {
_fs = __webpack_require__(28)
}
function readFile (file, options, callback) {
if (callback == null) {
callback = options
options = {}
}
if (typeof options === 'string') {
options = {encoding: options}
}
options = options || {}
var fs = options.fs || _fs
var shouldThrow = true
// DO NOT USE 'passParsingErrors' THE NAME WILL CHANGE!!!, use 'throws' instead
if ('passParsingErrors' in options) {
shouldThrow = options.passParsingErrors
} else if ('throws' in options) {
shouldThrow = options.throws
}
fs.readFile(file, options, function (err, data) {
if (err) return callback(err)
data = stripBom(data)
var obj
try {
obj = JSON.parse(data, options ? options.reviver : null)
} catch (err2) {
if (shouldThrow) {
err2.message = file + ': ' + err2.message
return callback(err2)
} else {
return callback(null, null)
}
}
callback(null, obj)
})
}
function readFileSync (file, options) {
options = options || {}
if (typeof options === 'string') {
options = {encoding: options}
}
var fs = options.fs || _fs
var shouldThrow = true
// DO NOT USE 'passParsingErrors' THE NAME WILL CHANGE!!!, use 'throws' instead
if ('passParsingErrors' in options) {
shouldThrow = options.passParsingErrors
} else if ('throws' in options) {
shouldThrow = options.throws
}
var content = fs.readFileSync(file, options)
content = stripBom(content)
try {
return JSON.parse(content, options.reviver)
} catch (err) {
if (shouldThrow) {
err.message = file + ': ' + err.message
throw err
} else {
return null
}
}
}
function writeFile (file, obj, options, callback) {
if (callback == null) {
callback = options
options = {}
}
options = options || {}
var fs = options.fs || _fs
var spaces = typeof options === 'object' && options !== null
? 'spaces' in options
? options.spaces : this.spaces
: this.spaces
var str = ''
try {
str = JSON.stringify(obj, options ? options.replacer : null, spaces) + '\n'
} catch (err) {
if (callback) return callback(err, null)
}
fs.writeFile(file, str, options, callback)
}
function writeFileSync (file, obj, options) {
options = options || {}
var fs = options.fs || _fs
var spaces = typeof options === 'object' && options !== null
? 'spaces' in options
? options.spaces : this.spaces
: this.spaces
var str = JSON.stringify(obj, options.replacer, spaces) + '\n'
// not sure if fs.writeFileSync returns anything, but just in case
return fs.writeFileSync(file, str, options)
}
function stripBom (content) {
// we do this because JSON.parse would convert it to a utf8 string if encoding wasn't specified
if (Buffer.isBuffer(content)) content = content.toString('utf8')
content = content.replace(/^\uFEFF/, '')
return content
}
var jsonfile = {
spaces: null,
readFile: readFile,
readFileSync: readFileSync,
writeFile: writeFile,
writeFileSync: writeFileSync
}
module.exports = jsonfile
/***/ },
/* 28 */
/***/ function(module, exports) {
module.exports = require("fs");
/***/ },
/* 29 */
/***/ function(module, exports, __webpack_require__) {
var fs = __webpack_require__(8)
var path = __webpack_require__(11)
var jsonFile = __webpack_require__(26)
var mkdir = __webpack_require__(15)
function outputJsonSync (file, data, options) {
var dir = path.dirname(file)
if (!fs.existsSync(dir)) {
mkdir.mkdirsSync(dir)
}
jsonFile.writeJsonSync(file, data, options)
}
module.exports = outputJsonSync
/***/ },
/* 30 */
/***/ function(module, exports, __webpack_require__) {
var fs = __webpack_require__(8)
var path = __webpack_require__(11)
var jsonFile = __webpack_require__(26)
var mkdir = __webpack_require__(15)
function outputJson (file, data, options, callback) {
if (typeof options === 'function') {
callback = options
options = {}
}
var dir = path.dirname(file)
fs.exists(dir, function (itDoes) {
if (itDoes) return jsonFile.writeJson(file, data, options, callback)
mkdir.mkdirs(dir, function (err) {
if (err) return callback(err)
jsonFile.writeJson(file, data, options, callback)
})
})
}
module.exports = outputJson
/***/ },
/* 31 */
/***/ function(module, exports, __webpack_require__) {
// most of this code was written by Andrew Kelley
// licensed under the BSD license: see
// https://github.com/andrewrk/node-mv/blob/master/package.json
// this needs a cleanup
var fs = __webpack_require__(8)
var ncp = __webpack_require__(12)
var path = __webpack_require__(11)
var remove = __webpack_require__(22).remove
var mkdirp = __webpack_require__(15).mkdirs
function mv (source, dest, options, callback) {
if (typeof options === 'function') {
callback = options
options = {}
}
var shouldMkdirp = ('mkdirp' in options) ? options.mkdirp : true
var clobber = ('clobber' in options) ? options.clobber : false
var limit = options.limit || 16
if (shouldMkdirp) {
mkdirs()
} else {
doRename()
}
function mkdirs () {
mkdirp(path.dirname(dest), function (err) {
if (err) return callback(err)
doRename()
})
}
function doRename () {
if (clobber) {
fs.rename(source, dest, function (err) {
if (!err) return callback()
if (err.code === 'ENOTEMPTY' || err.code === 'EEXIST') {
remove(dest, function (err) {
if (err) return callback(err)
options.clobber = false // just clobbered it, no need to do it again
mv(source, dest, options, callback)
})
return
}
// weird Windows shit
if (err.code === 'EPERM') {
setTimeout(function () {
remove(dest, function (err) {
if (err) return callback(err)
options.clobber = false
mv(source, dest, options, callback)
})
}, 200)
return
}
if (err.code !== 'EXDEV') return callback(err)
moveAcrossDevice(source, dest, clobber, limit, callback)
})
} else {
fs.link(source, dest, function (err) {
if (err) {
if (err.code === 'EXDEV' || err.code === 'EISDIR' || err.code === 'EPERM') {
moveAcrossDevice(source, dest, clobber, limit, callback)
return
}
callback(err)
return
}
fs.unlink(source, callback)
})
}
}
}
function moveAcrossDevice (source, dest, clobber, limit, callback) {
fs.stat(source, function (err, stat) {
if (err) {
callback(err)
return
}
if (stat.isDirectory()) {
moveDirAcrossDevice(source, dest, clobber, limit, callback)
} else {
moveFileAcrossDevice(source, dest, clobber, limit, callback)
}
})
}
function moveFileAcrossDevice (source, dest, clobber, limit, callback) {
var outFlags = clobber ? 'w' : 'wx'
var ins = fs.createReadStream(source)
var outs = fs.createWriteStream(dest, {flags: outFlags})
ins.on('error', function (err) {
ins.destroy()
outs.destroy()
outs.removeListener('close', onClose)
// may want to create a directory but `out` line above
// creates an empty file for us: See #108
// don't care about error here
fs.unlink(dest, function () {
// note: `err` here is from the input stream errror
if (err.code === 'EISDIR' || err.code === 'EPERM') {
moveDirAcrossDevice(source, dest, clobber, limit, callback)
} else {
callback(err)
}
})
})
outs.on('error', function (err) {
ins.destroy()
outs.destroy()
outs.removeListener('close', onClose)
callback(err)
})
outs.once('close', onClose)
ins.pipe(outs)
function onClose () {
fs.unlink(source, callback)
}
}
function moveDirAcrossDevice (source, dest, clobber, limit, callback) {
var options = {
stopOnErr: true,
clobber: false,
limit: limit
}
function startNcp () {
ncp(source, dest, options, function (errList) {
if (errList) return callback(errList[0])
remove(source, callback)
})
}
if (clobber) {
remove(dest, function (err) {
if (err) return callback(err)
startNcp()
})
} else {
startNcp()
}
}
module.exports = {
move: mv
}
/***/ },
/* 32 */
/***/ function(module, exports, __webpack_require__) {
var fs = __webpack_require__(28)
var path = __webpack_require__(11)
var mkdir = __webpack_require__(15)
var remove = __webpack_require__(22)
function emptyDir (dir, callback) {
callback = callback || function () {}
fs.readdir(dir, function (err, items) {
if (err) return mkdir.mkdirs(dir, callback)
items = items.map(function (item) {
return path.join(dir, item)
})
deleteItem()
function deleteItem () {
var item = items.pop()
if (!item) return callback()
remove.remove(item, function (err) {
if (err) return callback(err)
deleteItem()
})
}
})
}
function emptyDirSync (dir) {
var items
try {
items = fs.readdirSync(dir)
} catch (err) {
return mkdir.mkdirsSync(dir)
}
items.forEach(function (item) {
item = path.join(dir, item)
remove.removeSync(item)
})
}
module.exports = {
emptyDirSync: emptyDirSync,
emptydirSync: emptyDirSync,
emptyDir: emptyDir,
emptydir: emptyDir
}
/***/ },
/* 33 */
/***/ function(module, exports, __webpack_require__) {
var file = __webpack_require__(34)
var link = __webpack_require__(35)
var symlink = __webpack_require__(36)
module.exports = {
// file
createFile: file.createFile,
createFileSync: file.createFileSync,
ensureFile: file.createFile,
ensureFileSync: file.createFileSync,
// link
createLink: link.createLink,
createLinkSync: link.createLinkSync,
ensureLink: link.createLink,
ensureLinkSync: link.createLinkSync,
// symlink
createSymlink: symlink.createSymlink,
createSymlinkSync: symlink.createSymlinkSync,
ensureSymlink: symlink.createSymlink,
ensureSymlinkSync: symlink.createSymlinkSync
}
/***/ },
/* 34 */
/***/ function(module, exports, __webpack_require__) {
var path = __webpack_require__(11)
var fs = __webpack_require__(8)
var mkdir = __webpack_require__(15)
function createFile (file, callback) {
function makeFile () {
fs.writeFile(file, '', function (err) {
if (err) return callback(err)
callback()
})
}
fs.exists(file, function (fileExists) {
if (fileExists) return callback()
var dir = path.dirname(file)
fs.exists(dir, function (dirExists) {
if (dirExists) return makeFile()
mkdir.mkdirs(dir, function (err) {
if (err) return callback(err)
makeFile()
})
})
})
}
function createFileSync (file) {
if (fs.existsSync(file)) return
var dir = path.dirname(file)
if (!fs.existsSync(dir)) {
mkdir.mkdirsSync(dir)
}
fs.writeFileSync(file, '')
}
module.exports = {
createFile: createFile,
createFileSync: createFileSync,
// alias
ensureFile: createFile,
ensureFileSync: createFileSync
}
/***/ },
/* 35 */
/***/ function(module, exports, __webpack_require__) {
var path = __webpack_require__(11)
var fs = __webpack_require__(8)
var mkdir = __webpack_require__(15)
function createLink (srcpath, dstpath, callback) {
function makeLink (srcpath, dstpath) {
fs.link(srcpath, dstpath, function (err) {
if (err) return callback(err)
callback(null)
})
}
fs.exists(dstpath, function (destinationExists) {
if (destinationExists) return callback(null)
fs.lstat(srcpath, function (err, stat) {
if (err) {
err.message = err.message.replace('lstat', 'ensureLink')
return callback(err)
}
var dir = path.dirname(dstpath)
fs.exists(dir, function (dirExists) {
if (dirExists) return makeLink(srcpath, dstpath)
mkdir.mkdirs(dir, function (err) {
if (err) return callback(err)
makeLink(srcpath, dstpath)
})
})
})
})
}
function createLinkSync (srcpath, dstpath, callback) {
var destinationExists = fs.existsSync(dstpath)
if (destinationExists) return undefined
try {
fs.lstatSync(srcpath)
} catch (err) {
err.message = err.message.replace('lstat', 'ensureLink')
throw err
}
var dir = path.dirname(dstpath)
var dirExists = fs.existsSync(dir)
if (dirExists) return fs.linkSync(srcpath, dstpath)
mkdir.mkdirsSync(dir)
return fs.linkSync(srcpath, dstpath)
}
module.exports = {
createLink: createLink,
createLinkSync: createLinkSync,
// alias
ensureLink: createLink,
ensureLinkSync: createLinkSync
}
/***/ },
/* 36 */
/***/ function(module, exports, __webpack_require__) {
var path = __webpack_require__(11)
var fs = __webpack_require__(8)
var _mkdirs = __webpack_require__(15)
var mkdirs = _mkdirs.mkdirs
var mkdirsSync = _mkdirs.mkdirsSync
var _symlinkPaths = __webpack_require__(37)
var symlinkPaths = _symlinkPaths.symlinkPaths
var symlinkPathsSync = _symlinkPaths.symlinkPathsSync
var _symlinkType = __webpack_require__(38)
var symlinkType = _symlinkType.symlinkType
var symlinkTypeSync = _symlinkType.symlinkTypeSync
function createSymlink (srcpath, dstpath, type, callback) {
callback = (typeof type === 'function') ? type : callback
type = (typeof type === 'function') ? false : type
fs.exists(dstpath, function (destinationExists) {
if (destinationExists) return callback(null)
symlinkPaths(srcpath, dstpath, function (err, relative) {
if (err) return callback(err)
srcpath = relative.toDst
symlinkType(relative.toCwd, type, function (err, type) {
if (err) return callback(err)
var dir = path.dirname(dstpath)
fs.exists(dir, function (dirExists) {
if (dirExists) return fs.symlink(srcpath, dstpath, type, callback)
mkdirs(dir, function (err) {
if (err) return callback(err)
fs.symlink(srcpath, dstpath, type, callback)
})
})
})
})
})
}
function createSymlinkSync (srcpath, dstpath, type, callback) {
callback = (typeof type === 'function') ? type : callback
type = (typeof type === 'function') ? false : type
var destinationExists = fs.existsSync(dstpath)
if (destinationExists) return undefined
var relative = symlinkPathsSync(srcpath, dstpath)
srcpath = relative.toDst
type = symlinkTypeSync(relative.toCwd, type)
var dir = path.dirname(dstpath)
var exists = fs.existsSync(dir)
if (exists) return fs.symlinkSync(srcpath, dstpath, type)
mkdirsSync(dir)
return fs.symlinkSync(srcpath, dstpath, type)
}
module.exports = {
createSymlink: createSymlink,
createSymlinkSync: createSymlinkSync,
// alias
ensureSymlink: createSymlink,
ensureSymlinkSync: createSymlinkSync
}
/***/ },
/* 37 */
/***/ function(module, exports, __webpack_require__) {
var path = __webpack_require__(11)
// path.isAbsolute shim for Node.js 0.10 support
var fs = __webpack_require__(8)
/**
* Function that returns two types of paths, one relative to symlink, and one
* relative to the current working directory. Checks if path is absolute or
* relative. If the path is relative, this function checks if the path is
* relative to symlink or relative to current working directory. This is an
* initiative to find a smarter `srcpath` to supply when building symlinks.
* This allows you to determine which path to use out of one of three possible
* types of source paths. The first is an absolute path. This is detected by
* `path.isAbsolute()`. When an absolute path is provided, it is checked to
* see if it exists. If it does it's used, if not an error is returned
* (callback)/ thrown (sync). The other two options for `srcpath` are a
* relative url. By default Node's `fs.symlink` works by creating a symlink
* using `dstpath` and expects the `srcpath` to be relative to the newly
* created symlink. If you provide a `srcpath` that does not exist on the file
* system it results in a broken symlink. To minimize this, the function
* checks to see if the 'relative to symlink' source file exists, and if it
* does it will use it. If it does not, it checks if there's a file that
* exists that is relative to the current working directory, if does its used.
* This preserves the expectations of the original fs.symlink spec and adds
* the ability to pass in `relative to current working direcotry` paths.
*/
function symlinkPaths (srcpath, dstpath, callback) {
if (path.isAbsolute(srcpath)) {
return fs.lstat(srcpath, function (err, stat) {
if (err) {
err.message = err.message.replace('lstat', 'ensureSymlink')
return callback(err)
}
return callback(null, {
'toCwd': srcpath,
'toDst': srcpath
})
})
} else {
var dstdir = path.dirname(dstpath)
var relativeToDst = path.join(dstdir, srcpath)
return fs.exists(relativeToDst, function (exists) {
if (exists) {
return callback(null, {
'toCwd': relativeToDst,
'toDst': srcpath
})
} else {
return fs.lstat(srcpath, function (err, stat) {
if (err) {
err.message = err.message.replace('lstat', 'ensureSymlink')
return callback(err)
}
return callback(null, {
'toCwd': srcpath,
'toDst': path.relative(dstdir, srcpath)
})
})
}
})
}
}
function symlinkPathsSync (srcpath, dstpath) {
var exists
if (path.isAbsolute(srcpath)) {
exists = fs.existsSync(srcpath)
if (!exists) throw new Error('absolute srcpath does not exist')
return {
'toCwd': srcpath,
'toDst': srcpath
}
} else {
var dstdir = path.dirname(dstpath)
var relativeToDst = path.join(dstdir, srcpath)
exists = fs.existsSync(relativeToDst)
if (exists) {
return {
'toCwd': relativeToDst,
'toDst': srcpath
}
} else {
exists = fs.existsSync(srcpath)
if (!exists) throw new Error('relative srcpath does not exist')
return {
'toCwd': srcpath,
'toDst': path.relative(dstdir, srcpath)
}
}
}
}
module.exports = {
'symlinkPaths': symlinkPaths,
'symlinkPathsSync': symlinkPathsSync
}
/***/ },
/* 38 */
/***/ function(module, exports, __webpack_require__) {
var fs = __webpack_require__(8)
function symlinkType (srcpath, type, callback) {
callback = (typeof type === 'function') ? type : callback
type = (typeof type === 'function') ? false : type
if (type) return callback(null, type)
fs.lstat(srcpath, function (err, stats) {
if (err) return callback(null, 'file')
type = (stats && stats.isDirectory()) ? 'dir' : 'file'
callback(null, type)
})
}
function symlinkTypeSync (srcpath, type) {
if (type) return type
try {
var stats = fs.lstatSync(srcpath)
} catch (e) {
return 'file'
}
return (stats && stats.isDirectory()) ? 'dir' : 'file'
}
module.exports = {
symlinkType: symlinkType,
symlinkTypeSync: symlinkTypeSync
}
/***/ },
/* 39 */
/***/ function(module, exports, __webpack_require__) {
var path = __webpack_require__(11)
var fs = __webpack_require__(8)
var mkdir = __webpack_require__(15)
function outputFile (file, data, encoding, callback) {
if (typeof encoding === 'function') {
callback = encoding
encoding = 'utf8'
}
var dir = path.dirname(file)
fs.exists(dir, function (itDoes) {
if (itDoes) return fs.writeFile(file, data, encoding, callback)
mkdir.mkdirs(dir, function (err) {
if (err) return callback(err)
fs.writeFile(file, data, encoding, callback)
})
})
}
function outputFileSync (file, data, encoding) {
var dir = path.dirname(file)
if (fs.existsSync(dir)) {
return fs.writeFileSync.apply(fs, arguments)
}
mkdir.mkdirsSync(dir)
fs.writeFileSync.apply(fs, arguments)
}
module.exports = {
outputFile: outputFile,
outputFileSync: outputFileSync
}
/***/ },
/* 40 */
/***/ function(module, exports, __webpack_require__) {
var klaw = __webpack_require__(41)
module.exports = {
walk: klaw
}
/***/ },
/* 41 */
/***/ function(module, exports, __webpack_require__) {
var assert = __webpack_require__(24)
var fs
try {
fs = __webpack_require__(8)
} catch (e) {
fs = __webpack_require__(28)
}
var path = __webpack_require__(11)
var Readable = __webpack_require__(42).Readable
var util = __webpack_require__(43)
var assign = __webpack_require__(44)
function Walker (dir, options) {
assert.strictEqual(typeof dir, 'string', '`dir` parameter should be of type string. Got type: ' + typeof dir)
var defaultStreamOptions = { objectMode: true }
var defaultOpts = { queueMethod: 'shift', pathSorter: undefined, filter: undefined }
options = assign(defaultOpts, options, defaultStreamOptions)
Readable.call(this, options)
this.root = path.resolve(dir)
this.paths = [this.root]
this.options = options
this.fs = options.fs || fs // mock-fs
}
util.inherits(Walker, Readable)
Walker.prototype._read = function () {
if (this.paths.length === 0) return this.push(null)
var self = this
var pathItem = this.paths[this.options.queueMethod]()
self.fs.lstat(pathItem, function (err, stats) {
var item = { path: pathItem, stats: stats }
if (err) return self.emit('error', err, item)
if (!stats.isDirectory()) return self.push(item)
self.fs.readdir(pathItem, function (err, pathItems) {
if (err) {
self.push(item)
return self.emit('error', err, item)
}
pathItems = pathItems.map(function (part) { return path.join(pathItem, part) })
if (self.options.filter) pathItems = pathItems.filter(self.options.filter)
if (self.options.pathSorter) pathItems.sort(self.options.pathSorter)
pathItems.forEach(function (pi) { self.paths.push(pi) })
self.push(item)
})
})
}
function walk (root, options) {
return new Walker(root, options)
}
module.exports = walk
/***/ },
/* 42 */
/***/ function(module, exports) {
module.exports = require("stream");
/***/ },
/* 43 */
/***/ function(module, exports) {
module.exports = require("util");
/***/ },
/* 44 */
/***/ function(module, exports) {
// simple mutable assign (extracted from fs-extra)
// I really like object-assign package, but I wanted a lean package with zero deps
function _assign () {
var args = [].slice.call(arguments).filter(function (i) { return i })
var dest = args.shift()
args.forEach(function (src) {
Object.keys(src).forEach(function (key) {
dest[key] = src[key]
})
})
return dest
}
// thank you baby Jesus for Node v4 and Object.assign
module.exports = Object.assign || _assign
/***/ },
/* 45 */
/***/ function(module, exports, __webpack_require__) {
var fs = __webpack_require__(8)
var path = __webpack_require__(11)
var walkSync = function (dir, filelist) {
var files = fs.readdirSync(dir)
filelist = filelist || []
files.forEach(function (file) {
var nestedPath = path.join(dir, file)
if (fs.lstatSync(nestedPath).isDirectory()) {
filelist = walkSync(nestedPath, filelist)
} else {
filelist.push(nestedPath)
}
})
return filelist
}
module.exports = {
walkSync: walkSync
}
/***/ },
/* 46 */
/***/ function(module, exports, __webpack_require__) {
var ERR, word_wrap, mkdir, set_updatables_version, make_project, make_tools, _;
'use strict';
ERR = __webpack_require__(1);
word_wrap = __webpack_require__(2);
mkdir = __webpack_require__(6).mkdirp;
set_updatables_version = __webpack_require__(47);
make_project = __webpack_require__(56);
make_tools = __webpack_require__(381);
_ = function _(mu_src_path, root_path, metadata, cb) {
var err;
mkdir(root_path + '/generated_local', function (arguments, _$param0) {
err = _$param0;
if (ERR(err, cb)) {
return;
}
set_updatables_version(mu_src_path, root_path, 'HEAD', function (arguments, _$param1) {
err = _$param1;
if (ERR(err, cb)) {
return;
}
make_project(mu_src_path, root_path, metadata, function (arguments, _$param2) {
err = _$param2;
if (ERR(err, cb)) {
return;
}
make_tools(mu_src_path, root_path, metadata, cb);
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 47 */
/***/ function(module, exports, __webpack_require__) {
var ERR, word_wrap, archive, fs, mkdirp, create_read_stream, remove, move, find_project_root, _;
'use strict';
ERR = __webpack_require__(1);
word_wrap = __webpack_require__(2);
archive = __webpack_require__(48);
fs = __webpack_require__(6);
mkdirp = fs.mkdirp;
create_read_stream = fs.createReadStream;
remove = fs.remove;
move = fs.move;
find_project_root = __webpack_require__(55);
_ = function _(mu_src_path, root_path, version, cb) {
var move_updatables, cleanup;
(function () {
var err, tool_root;
mkdirp(root_path + '/generated_local', function (arguments, _$param0) {
err = _$param0;
if (ERR(err, cb)) {
return;
}
find_project_root(mu_src_path + '/mu_sub_repo', function (arguments, _$param1, _$param2) {
err = _$param1;
tool_root = _$param2;
if (ERR(err, cb)) {
return;
}
archive({
repoPath: tool_root + '/.git',
commit: version,
outputPath: root_path + '/generated_local/updatables.tar'
}, function (arguments, _$param3) {
err = _$param3;
if (ERR(err, cb)) {
return;
}
move_updatables();
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}());
move_updatables = function move_updatables() {
var err;
mkdirp(root_path + '/generated_local/updatables', function (arguments, _$param4) {
err = _$param4;
if (ERR(err, cb)) {
return;
}
create_read_stream(root_path + '/generated_local/updatables.tar').pipe(tar.extract(root_path + '/generated_local/updatables')).on('finish', cleanup).on('error', function (er) {
return ERR(er, cb);
});
}.bind(this, arguments));
};
cleanup = function cleanup() {
var err;
remove(root_path + '/generated_local/lambda_updatables', function (arguments, _$param5) {
err = _$param5;
if (ERR(err, cb)) {
return;
}
move(root_path + '/generated_local/updatables/gen/release/updatables', root_path + '/generated_local/lambda_updatables', function (arguments, _$param6) {
err = _$param6;
if (ERR(err, cb)) {
return;
}
remove(root_path + '/generated_local/updatables.tar', function (arguments, _$param7) {
err = _$param7;
if (ERR(err, cb)) {
return;
}
remove(root_path + '/generated_local/updatables', function (arguments, _$param8) {
err = _$param8;
if (ERR(err, cb)) {
return;
}
cb();
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
};
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 48 */
/***/ function(module, exports, __webpack_require__) {
var errorAdapter = __webpack_require__(49)
var q = __webpack_require__(52)
var exec = __webpack_require__(53).exec
var validate = __webpack_require__(54)
module.exports = function(data, cb) {
return validate(data)
.then(archive)
.nodeify(cb)
function archive() {
var deferred = q.defer()
var repoPath = data.repoPath
var outputPath = data.outputPath
var command = buildCommand(data)
var opts = {
cwd: repoPath
}
exec(command, opts, function(err, stdout, stderr) {
var error
if (err) {
error = errorAdapter.merge(err, {
namespace: 'git-archive'
})
error.stdout = stdout
error.stderr = stderr
return deferred.reject(error)
}
return deferred.resolve(outputPath)
})
return deferred.promise
}
};
function buildCommand(data) {
var commit = data.commit
var outputPath = data.outputPath
var command = 'git archive -o ' + outputPath + ' ' + commit
// allow optional flags to be passed
if (data.flags) {
command += ' ' + data.flags.join(' ')
}
return command
}
/***/ },
/* 49 */
/***/ function(module, exports, __webpack_require__) {
var errs = __webpack_require__(50)
module.exports = {
merge: merge,
create: create
}
function merge(error, opts) {
return errs.merge(error, opts)
}
function create(opts) {
return errs.create(opts)
}
// policy/call-ready.js:var errs = require('errs')
// policy/fork-child-process.js:var errs = require('errs')
// policy/register-with-zookeeper.js:var errs = require('errs')
// policy/watch.js:var errs = require('errs')
// validate/params/start.js:var errs = require('errs')
// validate/params/start.js: return errs.create({ description: 'missing field in params', field: field})
// policy/watch.js: var error = errs.merge(err, { namespace: 'watch' })
// policy/register-with-zookeeper.js: logThis.error = errs.merge(err, {namespace: 'registerWithZookeeper'})
// policy/fork-child-process.js: logger.error('fail: child process died', errs.merge(err, { namespace: 'forkChildProcess' }))
// policy/call-ready.js: var error = errs.merge(err, { namespace: 'callReady' })
/***/ },
/* 50 */
/***/ function(module, exports, __webpack_require__) {
/*
* errs.js: Simple error creation and passing utilities.
*
* (C) 2012, Nodejitsu Inc.
* MIT LICENSE
*
*/
var events = __webpack_require__(51),
util = __webpack_require__(43);
//
// Container for registered error types.
//
exports.registered = {};
//
// Add `Error.prototype.toJSON` if it doesn't exist.
//
if (!Error.prototype.toJSON) {
Object.defineProperty(Error.prototype, 'toJSON', {
enumerable: false,
value: function () {
return mixin({
message: this.message,
stack: this.stack,
arguments: this.arguments,
type: this.type
}, this);
}
});
}
//
// ### function create (type, opts)
// #### @type {string} **Optional** Registered error type to create
// #### @opts {string|object|Array|function} Options for creating the error:
// * `string`: Message for the error
// * `object`: Properties to include on the error
// * `array`: Message for the error (' ' joined).
// * `function`: Function to return error options.
//
// Creates a new error instance for with the specified `type`
// and `options`. If the `type` is not registered then a new
// `Error` instance will be created.
//
exports.create = function createErr(type, opts) {
if (!arguments[1] && !exports.registered[type]) {
opts = type;
type = null;
}
//
// If the `opts` has a `stack` property assume
// that it is already an error instance.
//
if (opts && opts.stack) {
return opts;
}
var message,
ErrorProto,
error;
//
// Parse arguments liberally for the message
//
if (typeof opts === 'function') {
opts = opts();
}
if (Array.isArray(opts)) {
message = opts.join(' ');
opts = null;
}
else if (opts) {
switch (typeof opts) {
case 'string':
message = opts || 'Unspecified error';
opts = null;
break;
case 'object':
message = (opts && opts.message) || 'Unspecified error';
break;
default:
message = 'Unspecified error';
break;
}
}
//
// Instantiate a new Error instance or a new
// registered error type (if it exists).
//
ErrorProto = type && exports.registered[type] || Error;
error = new (ErrorProto)(message);
if (!error.name || error.name === 'Error') {
error.name = (opts && opts.name) || ErrorProto.name || 'Error';
}
//
// Capture a stack trace if it does not already exist and
// remote the part of the stack trace referencing `errs.js`.
//
if (!error.stack) {
Error.call(error);
Error.captureStackTrace(error, createErr);
}
else {
error.stack = error.stack.split('\n');
error.stack.splice(1, 1);
error.stack = error.stack.join('\n');
}
//
// Copy all options to the new error instance.
//
if (opts) {
Object.keys(opts).forEach(function (key) {
error[key] = opts[key];
});
}
return error;
};
//
// ### function merge (err, type, opts)
// #### @err {error} The error to merge
// #### @type {string} **Optional** Registered error type to create
// #### @opts {string|object|Array|function} Options for creating the error:
// * `string`: Message for the error
// * `object`: Properties to include on the error
// * `array`: Message for the error (' ' joined).
// * `function`: Function to return error options.
//
// Merges an existing error with a new error instance for with
// the specified `type` and `options`.
//
exports.merge = function (err, type, opts) {
var merged = exports.create(type, opts);
//
// optional stuff that might be created by module
//
if (!Array.isArray(err) && typeof err === 'object') {
Object.keys(err).forEach(function (key) {
//
// in node v0.4 v8 errors where treated differently
// we need to make sure we aren't merging these properties
// http://code.google.com/p/v8/issues/detail?id=1215
//
if (['stack', 'type', 'arguments', 'message'].indexOf(key)===-1) {
merged[key] = err[key];
}
});
}
// merging
merged.name = merged.name || err.name;
merged.message = merged.message || err.message;
// override stack
merged.stack = err.stack || merged.stack;
// add human-readable errors
if (err.message) {
merged.description = err.message;
}
if (err.stack && err.stack.split) {
merged.stacktrace = err.stack.split("\n");
}
return merged;
};
//
// ### function handle (error, callback)
// #### @error {string|function|Array|object} Error to handle
// #### @callback {function|EventEmitter} **Optional** Continuation or stream to pass the error to.
// #### @stream {EventEmitter} **Optional** Explicit EventEmitter to use.
//
// Attempts to instantiate the given `error`. If the `error` is already a properly
// formed `error` object (with a `stack` property) it will not be modified.
//
// * If `callback` is a function, it is invoked with the `error`.
// * If `callback` is an `EventEmitter`, it emits the `error` event on
// that emitter and returns it.
// * If no `callback`, return a new `EventEmitter` which emits `error`
// on `process.nextTick()`.
//
exports.handle = function (error, callback, stream) {
error = exports.create(error);
if (typeof callback === 'function') {
callback(error);
}
if (typeof callback !== 'function' || stream) {
var emitter = stream || callback || new events.EventEmitter();
process.nextTick(function () { emitter.emit('error', error); });
return emitter;
}
};
//
// ### function register (type, proto)
// #### @type {string} **Optional** Type of the error to register.
// #### @proto {function} Constructor function of the error to register.
//
// Registers the specified `proto` to `type` for future calls to
// `errors.create(type, opts)`.
//
exports.register = function (type, proto) {
if (arguments.length === 1) {
proto = type;
type = proto.name.toLowerCase();
}
exports.registered[type] = proto;
};
//
// ### function unregister (type)
// #### @type {string} Type of the error to unregister.
//
// Unregisters the specified `type` for future calls to
// `errors.create(type, opts)`.
//
exports.unregister = function (type) {
delete exports.registered[type];
};
//
// ### function mixin (target [source0, source1, ...])
// Copies enumerable properties from `source0 ... sourceN`
// onto `target` and returns the resulting object.
//
function mixin(target) {
//
// Quickly and performantly (in V8) `Arrayify` arguments.
//
var len = arguments.length,
args = new Array(len - 1),
i = 1;
for (; i < len; i++) {
args[i - 1] = arguments[i];
}
args.forEach(function (o) {
Object.keys(o).forEach(function (attr) {
var getter = o.__lookupGetter__(attr),
setter = o.__lookupSetter__(attr);
if (!getter && !setter) {
target[attr] = o[attr];
}
else {
if (setter) { target.__defineSetter__(attr, setter) }
if (getter) { target.__defineGetter__(attr, getter) }
}
});
});
return target;
}
/***/ },
/* 51 */
/***/ function(module, exports) {
module.exports = require("events");
/***/ },
/* 52 */
/***/ function(module, exports, __webpack_require__) {
// vim:ts=4:sts=4:sw=4:
/*!
*
* Copyright 2009-2012 Kris Kowal under the terms of the MIT
* license found at http://github.com/kriskowal/q/raw/master/LICENSE
*
* With parts by Tyler Close
* Copyright 2007-2009 Tyler Close under the terms of the MIT X license found
* at http://www.opensource.org/licenses/mit-license.html
* Forked at ref_send.js version: 2009-05-11
*
* With parts by Mark Miller
* Copyright (C) 2011 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
(function (definition) {
// Turn off strict mode for this function so we can assign to global.Q
/* jshint strict: false */
// This file will function properly as a <script> tag, or a module
// using CommonJS and NodeJS or RequireJS module formats. In
// Common/Node/RequireJS, the module exports the Q API and when
// executed as a simple <script>, it creates a Q global instead.
// Montage Require
if (typeof bootstrap === "function") {
bootstrap("promise", definition);
// CommonJS
} else if (true) {
module.exports = definition();
// RequireJS
} else if (typeof define === "function" && define.amd) {
define(definition);
// SES (Secure EcmaScript)
} else if (typeof ses !== "undefined") {
if (!ses.ok()) {
return;
} else {
ses.makeQ = definition;
}
// <script>
} else {
Q = definition();
}
})(function () {
"use strict";
var hasStacks = false;
try {
throw new Error();
} catch (e) {
hasStacks = !!e.stack;
}
// All code after this point will be filtered from stack traces reported
// by Q.
var qStartingLine = captureLine();
var qFileName;
// shims
// used for fallback in "allResolved"
var noop = function () {};
// Use the fastest possible means to execute a task in a future turn
// of the event loop.
var nextTick =(function () {
// linked list of tasks (single, with head node)
var head = {task: void 0, next: null};
var tail = head;
var flushing = false;
var requestTick = void 0;
var isNodeJS = false;
function flush() {
/* jshint loopfunc: true */
while (head.next) {
head = head.next;
var task = head.task;
head.task = void 0;
var domain = head.domain;
if (domain) {
head.domain = void 0;
domain.enter();
}
try {
task();
} catch (e) {
if (isNodeJS) {
// In node, uncaught exceptions are considered fatal errors.
// Re-throw them synchronously to interrupt flushing!
// Ensure continuation if the uncaught exception is suppressed
// listening "uncaughtException" events (as domains does).
// Continue in next event to avoid tick recursion.
if (domain) {
domain.exit();
}
setTimeout(flush, 0);
if (domain) {
domain.enter();
}
throw e;
} else {
// In browsers, uncaught exceptions are not fatal.
// Re-throw them asynchronously to avoid slow-downs.
setTimeout(function() {
throw e;
}, 0);
}
}
if (domain) {
domain.exit();
}
}
flushing = false;
}
nextTick = function (task) {
tail = tail.next = {
task: task,
domain: isNodeJS && process.domain,
next: null
};
if (!flushing) {
flushing = true;
requestTick();
}
};
if (typeof process !== "undefined" && process.nextTick) {
// Node.js before 0.9. Note that some fake-Node environments, like the
// Mocha test runner, introduce a `process` global without a `nextTick`.
isNodeJS = true;
requestTick = function () {
process.nextTick(flush);
};
} else if (typeof setImmediate === "function") {
// In IE10, Node.js 0.9+, or https://github.com/NobleJS/setImmediate
if (typeof window !== "undefined") {
requestTick = setImmediate.bind(window, flush);
} else {
requestTick = function () {
setImmediate(flush);
};
}
} else if (typeof MessageChannel !== "undefined") {
// modern browsers
// http://www.nonblocking.io/2011/06/windownexttick.html
var channel = new MessageChannel();
// At least Safari Version 6.0.5 (8536.30.1) intermittently cannot create
// working message ports the first time a page loads.
channel.port1.onmessage = function () {
requestTick = requestPortTick;
channel.port1.onmessage = flush;
flush();
};
var requestPortTick = function () {
// Opera requires us to provide a message payload, regardless of
// whether we use it.
channel.port2.postMessage(0);
};
requestTick = function () {
setTimeout(flush, 0);
requestPortTick();
};
} else {
// old browsers
requestTick = function () {
setTimeout(flush, 0);
};
}
return nextTick;
})();
// Attempt to make generics safe in the face of downstream
// modifications.
// There is no situation where this is necessary.
// If you need a security guarantee, these primordials need to be
// deeply frozen anyway, and if you don’t need a security guarantee,
// this is just plain paranoid.
// However, this does have the nice side-effect of reducing the size
// of the code by reducing x.call() to merely x(), eliminating many
// hard-to-minify characters.
// See Mark Miller’s explanation of what this does.
// http://wiki.ecmascript.org/doku.php?id=conventions:safe_meta_programming
var call = Function.call;
function uncurryThis(f) {
return function () {
return call.apply(f, arguments);
};
}
// This is equivalent, but slower:
// uncurryThis = Function_bind.bind(Function_bind.call);
// http://jsperf.com/uncurrythis
var array_slice = uncurryThis(Array.prototype.slice);
var array_reduce = uncurryThis(
Array.prototype.reduce || function (callback, basis) {
var index = 0,
length = this.length;
// concerning the initial value, if one is not provided
if (arguments.length === 1) {
// seek to the first value in the array, accounting
// for the possibility that is is a sparse array
do {
if (index in this) {
basis = this[index++];
break;
}
if (++index >= length) {
throw new TypeError();
}
} while (1);
}
// reduce
for (; index < length; index++) {
// account for the possibility that the array is sparse
if (index in this) {
basis = callback(basis, this[index], index);
}
}
return basis;
}
);
var array_indexOf = uncurryThis(
Array.prototype.indexOf || function (value) {
// not a very good shim, but good enough for our one use of it
for (var i = 0; i < this.length; i++) {
if (this[i] === value) {
return i;
}
}
return -1;
}
);
var array_map = uncurryThis(
Array.prototype.map || function (callback, thisp) {
var self = this;
var collect = [];
array_reduce(self, function (undefined, value, index) {
collect.push(callback.call(thisp, value, index, self));
}, void 0);
return collect;
}
);
var object_create = Object.create || function (prototype) {
function Type() { }
Type.prototype = prototype;
return new Type();
};
var object_hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);
var object_keys = Object.keys || function (object) {
var keys = [];
for (var key in object) {
if (object_hasOwnProperty(object, key)) {
keys.push(key);
}
}
return keys;
};
var object_toString = uncurryThis(Object.prototype.toString);
function isObject(value) {
return value === Object(value);
}
// generator related shims
// FIXME: Remove this function once ES6 generators are in SpiderMonkey.
function isStopIteration(exception) {
return (
object_toString(exception) === "[object StopIteration]" ||
exception instanceof QReturnValue
);
}
// FIXME: Remove this helper and Q.return once ES6 generators are in
// SpiderMonkey.
var QReturnValue;
if (typeof ReturnValue !== "undefined") {
QReturnValue = ReturnValue;
} else {
QReturnValue = function (value) {
this.value = value;
};
}
// Until V8 3.19 / Chromium 29 is released, SpiderMonkey is the only
// engine that has a deployed base of browsers that support generators.
// However, SM's generators use the Python-inspired semantics of
// outdated ES6 drafts. We would like to support ES6, but we'd also
// like to make it possible to use generators in deployed browsers, so
// we also support Python-style generators. At some point we can remove
// this block.
var hasES6Generators;
try {
/* jshint evil: true, nonew: false */
new Function("(function* (){ yield 1; })");
hasES6Generators = true;
} catch (e) {
hasES6Generators = false;
}
// long stack traces
var STACK_JUMP_SEPARATOR = "From previous event:";
function makeStackTraceLong(error, promise) {
// If possible, transform the error stack trace by removing Node and Q
// cruft, then concatenating with the stack trace of `promise`. See #57.
if (hasStacks &&
promise.stack &&
typeof error === "object" &&
error !== null &&
error.stack &&
error.stack.indexOf(STACK_JUMP_SEPARATOR) === -1
) {
var stacks = [];
for (var p = promise; !!p; p = p.source) {
if (p.stack) {
stacks.unshift(p.stack);
}
}
stacks.unshift(error.stack);
var concatedStacks = stacks.join("\n" + STACK_JUMP_SEPARATOR + "\n");
error.stack = filterStackString(concatedStacks);
}
}
function filterStackString(stackString) {
var lines = stackString.split("\n");
var desiredLines = [];
for (var i = 0; i < lines.length; ++i) {
var line = lines[i];
if (!isInternalFrame(line) && !isNodeFrame(line) && line) {
desiredLines.push(line);
}
}
return desiredLines.join("\n");
}
function isNodeFrame(stackLine) {
return stackLine.indexOf("(module.js:") !== -1 ||
stackLine.indexOf("(node.js:") !== -1;
}
function getFileNameAndLineNumber(stackLine) {
// Named functions: "at functionName (filename:lineNumber:columnNumber)"
// In IE10 function name can have spaces ("Anonymous function") O_o
var attempt1 = /at .+ \((.+):(\d+):(?:\d+)\)$/.exec(stackLine);
if (attempt1) {
return [attempt1[1], Number(attempt1[2])];
}
// Anonymous functions: "at filename:lineNumber:columnNumber"
var attempt2 = /at ([^ ]+):(\d+):(?:\d+)$/.exec(stackLine);
if (attempt2) {
return [attempt2[1], Number(attempt2[2])];
}
// Firefox style: "function@filename:lineNumber or @filename:lineNumber"
var attempt3 = /.*@(.+):(\d+)$/.exec(stackLine);
if (attempt3) {
return [attempt3[1], Number(attempt3[2])];
}
}
function isInternalFrame(stackLine) {
var fileNameAndLineNumber = getFileNameAndLineNumber(stackLine);
if (!fileNameAndLineNumber) {
return false;
}
var fileName = fileNameAndLineNumber[0];
var lineNumber = fileNameAndLineNumber[1];
return fileName === qFileName &&
lineNumber >= qStartingLine &&
lineNumber <= qEndingLine;
}
// discover own file name and line number range for filtering stack
// traces
function captureLine() {
if (!hasStacks) {
return;
}
try {
throw new Error();
} catch (e) {
var lines = e.stack.split("\n");
var firstLine = lines[0].indexOf("@") > 0 ? lines[1] : lines[2];
var fileNameAndLineNumber = getFileNameAndLineNumber(firstLine);
if (!fileNameAndLineNumber) {
return;
}
qFileName = fileNameAndLineNumber[0];
return fileNameAndLineNumber[1];
}
}
function deprecate(callback, name, alternative) {
return function () {
if (typeof console !== "undefined" &&
typeof console.warn === "function") {
console.warn(name + " is deprecated, use " + alternative +
" instead.", new Error("").stack);
}
return callback.apply(callback, arguments);
};
}
// end of shims
// beginning of real work
/**
* Constructs a promise for an immediate reference, passes promises through, or
* coerces promises from different systems.
* @param value immediate reference or promise
*/
function Q(value) {
// If the object is already a Promise, return it directly. This enables
// the resolve function to both be used to created references from objects,
// but to tolerably coerce non-promises to promises.
if (isPromise(value)) {
return value;
}
// assimilate thenables
if (isPromiseAlike(value)) {
return coerce(value);
} else {
return fulfill(value);
}
}
Q.resolve = Q;
/**
* Performs a task in a future turn of the event loop.
* @param {Function} task
*/
Q.nextTick = nextTick;
/**
* Controls whether or not long stack traces will be on
*/
Q.longStackSupport = false;
/**
* Constructs a {promise, resolve, reject} object.
*
* `resolve` is a callback to invoke with a more resolved value for the
* promise. To fulfill the promise, invoke `resolve` with any value that is
* not a thenable. To reject the promise, invoke `resolve` with a rejected
* thenable, or invoke `reject` with the reason directly. To resolve the
* promise to another thenable, thus putting it in the same state, invoke
* `resolve` with that other thenable.
*/
Q.defer = defer;
function defer() {
// if "messages" is an "Array", that indicates that the promise has not yet
// been resolved. If it is "undefined", it has been resolved. Each
// element of the messages array is itself an array of complete arguments to
// forward to the resolved promise. We coerce the resolution value to a
// promise using the `resolve` function because it handles both fully
// non-thenable values and other thenables gracefully.
var messages = [], progressListeners = [], resolvedPromise;
var deferred = object_create(defer.prototype);
var promise = object_create(Promise.prototype);
promise.promiseDispatch = function (resolve, op, operands) {
var args = array_slice(arguments);
if (messages) {
messages.push(args);
if (op === "when" && operands[1]) { // progress operand
progressListeners.push(operands[1]);
}
} else {
nextTick(function () {
resolvedPromise.promiseDispatch.apply(resolvedPromise, args);
});
}
};
// XXX deprecated
promise.valueOf = deprecate(function () {
if (messages) {
return promise;
}
var nearerValue = nearer(resolvedPromise);
if (isPromise(nearerValue)) {
resolvedPromise = nearerValue; // shorten chain
}
return nearerValue;
}, "valueOf", "inspect");
promise.inspect = function () {
if (!resolvedPromise) {
return { state: "pending" };
}
return resolvedPromise.inspect();
};
if (Q.longStackSupport && hasStacks) {
try {
throw new Error();
} catch (e) {
// NOTE: don't try to use `Error.captureStackTrace` or transfer the
// accessor around; that causes memory leaks as per GH-111. Just
// reify the stack trace as a string ASAP.
//
// At the same time, cut off the first line; it's always just
// "[object Promise]\n", as per the `toString`.
promise.stack = e.stack.substring(e.stack.indexOf("\n") + 1);
}
}
// NOTE: we do the checks for `resolvedPromise` in each method, instead of
// consolidating them into `become`, since otherwise we'd create new
// promises with the lines `become(whatever(value))`. See e.g. GH-252.
function become(newPromise) {
resolvedPromise = newPromise;
promise.source = newPromise;
array_reduce(messages, function (undefined, message) {
nextTick(function () {
newPromise.promiseDispatch.apply(newPromise, message);
});
}, void 0);
messages = void 0;
progressListeners = void 0;
}
deferred.promise = promise;
deferred.resolve = function (value) {
if (resolvedPromise) {
return;
}
become(Q(value));
};
deferred.fulfill = function (value) {
if (resolvedPromise) {
return;
}
become(fulfill(value));
};
deferred.reject = function (reason) {
if (resolvedPromise) {
return;
}
become(reject(reason));
};
deferred.notify = function (progress) {
if (resolvedPromise) {
return;
}
array_reduce(progressListeners, function (undefined, progressListener) {
nextTick(function () {
progressListener(progress);
});
}, void 0);
};
return deferred;
}
/**
* Creates a Node-style callback that will resolve or reject the deferred
* promise.
* @returns a nodeback
*/
defer.prototype.makeNodeResolver = function () {
var self = this;
return function (error, value) {
if (error) {
self.reject(error);
} else if (arguments.length > 2) {
self.resolve(array_slice(arguments, 1));
} else {
self.resolve(value);
}
};
};
/**
* @param resolver {Function} a function that returns nothing and accepts
* the resolve, reject, and notify functions for a deferred.
* @returns a promise that may be resolved with the given resolve and reject
* functions, or rejected by a thrown exception in resolver
*/
Q.promise = promise;
function promise(resolver) {
if (typeof resolver !== "function") {
throw new TypeError("resolver must be a function.");
}
var deferred = defer();
try {
resolver(deferred.resolve, deferred.reject, deferred.notify);
} catch (reason) {
deferred.reject(reason);
}
return deferred.promise;
}
// XXX experimental. This method is a way to denote that a local value is
// serializable and should be immediately dispatched to a remote upon request,
// instead of passing a reference.
Q.passByCopy = function (object) {
//freeze(object);
//passByCopies.set(object, true);
return object;
};
Promise.prototype.passByCopy = function () {
//freeze(object);
//passByCopies.set(object, true);
return this;
};
/**
* If two promises eventually fulfill to the same value, promises that value,
* but otherwise rejects.
* @param x {Any*}
* @param y {Any*}
* @returns {Any*} a promise for x and y if they are the same, but a rejection
* otherwise.
*
*/
Q.join = function (x, y) {
return Q(x).join(y);
};
Promise.prototype.join = function (that) {
return Q([this, that]).spread(function (x, y) {
if (x === y) {
// TODO: "===" should be Object.is or equiv
return x;
} else {
throw new Error("Can't join: not the same: " + x + " " + y);
}
});
};
/**
* Returns a promise for the first of an array of promises to become fulfilled.
* @param answers {Array[Any*]} promises to race
* @returns {Any*} the first promise to be fulfilled
*/
Q.race = race;
function race(answerPs) {
return promise(function(resolve, reject) {
// Switch to this once we can assume at least ES5
// answerPs.forEach(function(answerP) {
// Q(answerP).then(resolve, reject);
// });
// Use this in the meantime
for (var i = 0, len = answerPs.length; i < len; i++) {
Q(answerPs[i]).then(resolve, reject);
}
});
}
Promise.prototype.race = function () {
return this.then(Q.race);
};
/**
* Constructs a Promise with a promise descriptor object and optional fallback
* function. The descriptor contains methods like when(rejected), get(name),
* set(name, value), post(name, args), and delete(name), which all
* return either a value, a promise for a value, or a rejection. The fallback
* accepts the operation name, a resolver, and any further arguments that would
* have been forwarded to the appropriate method above had a method been
* provided with the proper name. The API makes no guarantees about the nature
* of the returned object, apart from that it is usable whereever promises are
* bought and sold.
*/
Q.makePromise = Promise;
function Promise(descriptor, fallback, inspect) {
if (fallback === void 0) {
fallback = function (op) {
return reject(new Error(
"Promise does not support operation: " + op
));
};
}
if (inspect === void 0) {
inspect = function () {
return {state: "unknown"};
};
}
var promise = object_create(Promise.prototype);
promise.promiseDispatch = function (resolve, op, args) {
var result;
try {
if (descriptor[op]) {
result = descriptor[op].apply(promise, args);
} else {
result = fallback.call(promise, op, args);
}
} catch (exception) {
result = reject(exception);
}
if (resolve) {
resolve(result);
}
};
promise.inspect = inspect;
// XXX deprecated `valueOf` and `exception` support
if (inspect) {
var inspected = inspect();
if (inspected.state === "rejected") {
promise.exception = inspected.reason;
}
promise.valueOf = deprecate(function () {
var inspected = inspect();
if (inspected.state === "pending" ||
inspected.state === "rejected") {
return promise;
}
return inspected.value;
});
}
return promise;
}
Promise.prototype.toString = function () {
return "[object Promise]";
};
Promise.prototype.then = function (fulfilled, rejected, progressed) {
var self = this;
var deferred = defer();
var done = false; // ensure the untrusted promise makes at most a
// single call to one of the callbacks
function _fulfilled(value) {
try {
return typeof fulfilled === "function" ? fulfilled(value) : value;
} catch (exception) {
return reject(exception);
}
}
function _rejected(exception) {
if (typeof rejected === "function") {
makeStackTraceLong(exception, self);
try {
return rejected(exception);
} catch (newException) {
return reject(newException);
}
}
return reject(exception);
}
function _progressed(value) {
return typeof progressed === "function" ? progressed(value) : value;
}
nextTick(function () {
self.promiseDispatch(function (value) {
if (done) {
return;
}
done = true;
deferred.resolve(_fulfilled(value));
}, "when", [function (exception) {
if (done) {
return;
}
done = true;
deferred.resolve(_rejected(exception));
}]);
});
// Progress propagator need to be attached in the current tick.
self.promiseDispatch(void 0, "when", [void 0, function (value) {
var newValue;
var threw = false;
try {
newValue = _progressed(value);
} catch (e) {
threw = true;
if (Q.onerror) {
Q.onerror(e);
} else {
throw e;
}
}
if (!threw) {
deferred.notify(newValue);
}
}]);
return deferred.promise;
};
/**
* Registers an observer on a promise.
*
* Guarantees:
*
* 1. that fulfilled and rejected will be called only once.
* 2. that either the fulfilled callback or the rejected callback will be
* called, but not both.
* 3. that fulfilled and rejected will not be called in this turn.
*
* @param value promise or immediate reference to observe
* @param fulfilled function to be called with the fulfilled value
* @param rejected function to be called with the rejection exception
* @param progressed function to be called on any progress notifications
* @return promise for the return value from the invoked callback
*/
Q.when = when;
function when(value, fulfilled, rejected, progressed) {
return Q(value).then(fulfilled, rejected, progressed);
}
Promise.prototype.thenResolve = function (value) {
return this.then(function () { return value; });
};
Q.thenResolve = function (promise, value) {
return Q(promise).thenResolve(value);
};
Promise.prototype.thenReject = function (reason) {
return this.then(function () { throw reason; });
};
Q.thenReject = function (promise, reason) {
return Q(promise).thenReject(reason);
};
/**
* If an object is not a promise, it is as "near" as possible.
* If a promise is rejected, it is as "near" as possible too.
* If it’s a fulfilled promise, the fulfillment value is nearer.
* If it’s a deferred promise and the deferred has been resolved, the
* resolution is "nearer".
* @param object
* @returns most resolved (nearest) form of the object
*/
// XXX should we re-do this?
Q.nearer = nearer;
function nearer(value) {
if (isPromise(value)) {
var inspected = value.inspect();
if (inspected.state === "fulfilled") {
return inspected.value;
}
}
return value;
}
/**
* @returns whether the given object is a promise.
* Otherwise it is a fulfilled value.
*/
Q.isPromise = isPromise;
function isPromise(object) {
return isObject(object) &&
typeof object.promiseDispatch === "function" &&
typeof object.inspect === "function";
}
Q.isPromiseAlike = isPromiseAlike;
function isPromiseAlike(object) {
return isObject(object) && typeof object.then === "function";
}
/**
* @returns whether the given object is a pending promise, meaning not
* fulfilled or rejected.
*/
Q.isPending = isPending;
function isPending(object) {
return isPromise(object) && object.inspect().state === "pending";
}
Promise.prototype.isPending = function () {
return this.inspect().state === "pending";
};
/**
* @returns whether the given object is a value or fulfilled
* promise.
*/
Q.isFulfilled = isFulfilled;
function isFulfilled(object) {
return !isPromise(object) || object.inspect().state === "fulfilled";
}
Promise.prototype.isFulfilled = function () {
return this.inspect().state === "fulfilled";
};
/**
* @returns whether the given object is a rejected promise.
*/
Q.isRejected = isRejected;
function isRejected(object) {
return isPromise(object) && object.inspect().state === "rejected";
}
Promise.prototype.isRejected = function () {
return this.inspect().state === "rejected";
};
//// BEGIN UNHANDLED REJECTION TRACKING
// This promise library consumes exceptions thrown in handlers so they can be
// handled by a subsequent promise. The exceptions get added to this array when
// they are created, and removed when they are handled. Note that in ES6 or
// shimmed environments, this would naturally be a `Set`.
var unhandledReasons = [];
var unhandledRejections = [];
var unhandledReasonsDisplayed = false;
var trackUnhandledRejections = true;
function displayUnhandledReasons() {
if (
!unhandledReasonsDisplayed &&
typeof window !== "undefined" &&
!window.Touch &&
window.console
) {
console.warn("[Q] Unhandled rejection reasons (should be empty):",
unhandledReasons);
}
unhandledReasonsDisplayed = true;
}
function logUnhandledReasons() {
for (var i = 0; i < unhandledReasons.length; i++) {
var reason = unhandledReasons[i];
console.warn("Unhandled rejection reason:", reason);
}
}
function resetUnhandledRejections() {
unhandledReasons.length = 0;
unhandledRejections.length = 0;
unhandledReasonsDisplayed = false;
if (!trackUnhandledRejections) {
trackUnhandledRejections = true;
// Show unhandled rejection reasons if Node exits without handling an
// outstanding rejection. (Note that Browserify presently produces a
// `process` global without the `EventEmitter` `on` method.)
if (typeof process !== "undefined" && process.on) {
process.on("exit", logUnhandledReasons);
}
}
}
function trackRejection(promise, reason) {
if (!trackUnhandledRejections) {
return;
}
unhandledRejections.push(promise);
if (reason && typeof reason.stack !== "undefined") {
unhandledReasons.push(reason.stack);
} else {
unhandledReasons.push("(no stack) " + reason);
}
displayUnhandledReasons();
}
function untrackRejection(promise) {
if (!trackUnhandledRejections) {
return;
}
var at = array_indexOf(unhandledRejections, promise);
if (at !== -1) {
unhandledRejections.splice(at, 1);
unhandledReasons.splice(at, 1);
}
}
Q.resetUnhandledRejections = resetUnhandledRejections;
Q.getUnhandledReasons = function () {
// Make a copy so that consumers can't interfere with our internal state.
return unhandledReasons.slice();
};
Q.stopUnhandledRejectionTracking = function () {
resetUnhandledRejections();
if (typeof process !== "undefined" && process.on) {
process.removeListener("exit", logUnhandledReasons);
}
trackUnhandledRejections = false;
};
resetUnhandledRejections();
//// END UNHANDLED REJECTION TRACKING
/**
* Constructs a rejected promise.
* @param reason value describing the failure
*/
Q.reject = reject;
function reject(reason) {
var rejection = Promise({
"when": function (rejected) {
// note that the error has been handled
if (rejected) {
untrackRejection(this);
}
return rejected ? rejected(reason) : this;
}
}, function fallback() {
return this;
}, function inspect() {
return { state: "rejected", reason: reason };
});
// Note that the reason has not been handled.
trackRejection(rejection, reason);
return rejection;
}
/**
* Constructs a fulfilled promise for an immediate reference.
* @param value immediate reference
*/
Q.fulfill = fulfill;
function fulfill(value) {
return Promise({
"when": function () {
return value;
},
"get": function (name) {
return value[name];
},
"set": function (name, rhs) {
value[name] = rhs;
},
"delete": function (name) {
delete value[name];
},
"post": function (name, args) {
// Mark Miller proposes that post with no name should apply a
// promised function.
if (name === null || name === void 0) {
return value.apply(void 0, args);
} else {
return value[name].apply(value, args);
}
},
"apply": function (thisp, args) {
return value.apply(thisp, args);
},
"keys": function () {
return object_keys(value);
}
}, void 0, function inspect() {
return { state: "fulfilled", value: value };
});
}
/**
* Converts thenables to Q promises.
* @param promise thenable promise
* @returns a Q promise
*/
function coerce(promise) {
var deferred = defer();
nextTick(function () {
try {
promise.then(deferred.resolve, deferred.reject, deferred.notify);
} catch (exception) {
deferred.reject(exception);
}
});
return deferred.promise;
}
/**
* Annotates an object such that it will never be
* transferred away from this process over any promise
* communication channel.
* @param object
* @returns promise a wrapping of that object that
* additionally responds to the "isDef" message
* without a rejection.
*/
Q.master = master;
function master(object) {
return Promise({
"isDef": function () {}
}, function fallback(op, args) {
return dispatch(object, op, args);
}, function () {
return Q(object).inspect();
});
}
/**
* Spreads the values of a promised array of arguments into the
* fulfillment callback.
* @param fulfilled callback that receives variadic arguments from the
* promised array
* @param rejected callback that receives the exception if the promise
* is rejected.
* @returns a promise for the return value or thrown exception of
* either callback.
*/
Q.spread = spread;
function spread(value, fulfilled, rejected) {
return Q(value).spread(fulfilled, rejected);
}
Promise.prototype.spread = function (fulfilled, rejected) {
return this.all().then(function (array) {
return fulfilled.apply(void 0, array);
}, rejected);
};
/**
* The async function is a decorator for generator functions, turning
* them into asynchronous generators. Although generators are only part
* of the newest ECMAScript 6 drafts, this code does not cause syntax
* errors in older engines. This code should continue to work and will
* in fact improve over time as the language improves.
*
* ES6 generators are currently part of V8 version 3.19 with the
* --harmony-generators runtime flag enabled. SpiderMonkey has had them
* for longer, but under an older Python-inspired form. This function
* works on both kinds of generators.
*
* Decorates a generator function such that:
* - it may yield promises
* - execution will continue when that promise is fulfilled
* - the value of the yield expression will be the fulfilled value
* - it returns a promise for the return value (when the generator
* stops iterating)
* - the decorated function returns a promise for the return value
* of the generator or the first rejected promise among those
* yielded.
* - if an error is thrown in the generator, it propagates through
* every following yield until it is caught, or until it escapes
* the generator function altogether, and is translated into a
* rejection for the promise returned by the decorated generator.
*/
Q.async = async;
function async(makeGenerator) {
return function () {
// when verb is "send", arg is a value
// when verb is "throw", arg is an exception
function continuer(verb, arg) {
var result;
if (hasES6Generators) {
try {
result = generator[verb](arg);
} catch (exception) {
return reject(exception);
}
if (result.done) {
return result.value;
} else {
return when(result.value, callback, errback);
}
} else {
// FIXME: Remove this case when SM does ES6 generators.
try {
result = generator[verb](arg);
} catch (exception) {
if (isStopIteration(exception)) {
return exception.value;
} else {
return reject(exception);
}
}
return when(result, callback, errback);
}
}
var generator = makeGenerator.apply(this, arguments);
var callback = continuer.bind(continuer, "next");
var errback = continuer.bind(continuer, "throw");
return callback();
};
}
/**
* The spawn function is a small wrapper around async that immediately
* calls the generator and also ends the promise chain, so that any
* unhandled errors are thrown instead of forwarded to the error
* handler. This is useful because it's extremely common to run
* generators at the top-level to work with libraries.
*/
Q.spawn = spawn;
function spawn(makeGenerator) {
Q.done(Q.async(makeGenerator)());
}
// FIXME: Remove this interface once ES6 generators are in SpiderMonkey.
/**
* Throws a ReturnValue exception to stop an asynchronous generator.
*
* This interface is a stop-gap measure to support generator return
* values in older Firefox/SpiderMonkey. In browsers that support ES6
* generators like Chromium 29, just use "return" in your generator
* functions.
*
* @param value the return value for the surrounding generator
* @throws ReturnValue exception with the value.
* @example
* // ES6 style
* Q.async(function* () {
* var foo = yield getFooPromise();
* var bar = yield getBarPromise();
* return foo + bar;
* })
* // Older SpiderMonkey style
* Q.async(function () {
* var foo = yield getFooPromise();
* var bar = yield getBarPromise();
* Q.return(foo + bar);
* })
*/
Q["return"] = _return;
function _return(value) {
throw new QReturnValue(value);
}
/**
* The promised function decorator ensures that any promise arguments
* are settled and passed as values (`this` is also settled and passed
* as a value). It will also ensure that the result of a function is
* always a promise.
*
* @example
* var add = Q.promised(function (a, b) {
* return a + b;
* });
* add(Q(a), Q(B));
*
* @param {function} callback The function to decorate
* @returns {function} a function that has been decorated.
*/
Q.promised = promised;
function promised(callback) {
return function () {
return spread([this, all(arguments)], function (self, args) {
return callback.apply(self, args);
});
};
}
/**
* sends a message to a value in a future turn
* @param object* the recipient
* @param op the name of the message operation, e.g., "when",
* @param args further arguments to be forwarded to the operation
* @returns result {Promise} a promise for the result of the operation
*/
Q.dispatch = dispatch;
function dispatch(object, op, args) {
return Q(object).dispatch(op, args);
}
Promise.prototype.dispatch = function (op, args) {
var self = this;
var deferred = defer();
nextTick(function () {
self.promiseDispatch(deferred.resolve, op, args);
});
return deferred.promise;
};
/**
* Gets the value of a property in a future turn.
* @param object promise or immediate reference for target object
* @param name name of property to get
* @return promise for the property value
*/
Q.get = function (object, key) {
return Q(object).dispatch("get", [key]);
};
Promise.prototype.get = function (key) {
return this.dispatch("get", [key]);
};
/**
* Sets the value of a property in a future turn.
* @param object promise or immediate reference for object object
* @param name name of property to set
* @param value new value of property
* @return promise for the return value
*/
Q.set = function (object, key, value) {
return Q(object).dispatch("set", [key, value]);
};
Promise.prototype.set = function (key, value) {
return this.dispatch("set", [key, value]);
};
/**
* Deletes a property in a future turn.
* @param object promise or immediate reference for target object
* @param name name of property to delete
* @return promise for the return value
*/
Q.del = // XXX legacy
Q["delete"] = function (object, key) {
return Q(object).dispatch("delete", [key]);
};
Promise.prototype.del = // XXX legacy
Promise.prototype["delete"] = function (key) {
return this.dispatch("delete", [key]);
};
/**
* Invokes a method in a future turn.
* @param object promise or immediate reference for target object
* @param name name of method to invoke
* @param value a value to post, typically an array of
* invocation arguments for promises that
* are ultimately backed with `resolve` values,
* as opposed to those backed with URLs
* wherein the posted value can be any
* JSON serializable object.
* @return promise for the return value
*/
// bound locally because it is used by other methods
Q.mapply = // XXX As proposed by "Redsandro"
Q.post = function (object, name, args) {
return Q(object).dispatch("post", [name, args]);
};
Promise.prototype.mapply = // XXX As proposed by "Redsandro"
Promise.prototype.post = function (name, args) {
return this.dispatch("post", [name, args]);
};
/**
* Invokes a method in a future turn.
* @param object promise or immediate reference for target object
* @param name name of method to invoke
* @param ...args array of invocation arguments
* @return promise for the return value
*/
Q.send = // XXX Mark Miller's proposed parlance
Q.mcall = // XXX As proposed by "Redsandro"
Q.invoke = function (object, name /*...args*/) {
return Q(object).dispatch("post", [name, array_slice(arguments, 2)]);
};
Promise.prototype.send = // XXX Mark Miller's proposed parlance
Promise.prototype.mcall = // XXX As proposed by "Redsandro"
Promise.prototype.invoke = function (name /*...args*/) {
return this.dispatch("post", [name, array_slice(arguments, 1)]);
};
/**
* Applies the promised function in a future turn.
* @param object promise or immediate reference for target function
* @param args array of application arguments
*/
Q.fapply = function (object, args) {
return Q(object).dispatch("apply", [void 0, args]);
};
Promise.prototype.fapply = function (args) {
return this.dispatch("apply", [void 0, args]);
};
/**
* Calls the promised function in a future turn.
* @param object promise or immediate reference for target function
* @param ...args array of application arguments
*/
Q["try"] =
Q.fcall = function (object /* ...args*/) {
return Q(object).dispatch("apply", [void 0, array_slice(arguments, 1)]);
};
Promise.prototype.fcall = function (/*...args*/) {
return this.dispatch("apply", [void 0, array_slice(arguments)]);
};
/**
* Binds the promised function, transforming return values into a fulfilled
* promise and thrown errors into a rejected one.
* @param object promise or immediate reference for target function
* @param ...args array of application arguments
*/
Q.fbind = function (object /*...args*/) {
var promise = Q(object);
var args = array_slice(arguments, 1);
return function fbound() {
return promise.dispatch("apply", [
this,
args.concat(array_slice(arguments))
]);
};
};
Promise.prototype.fbind = function (/*...args*/) {
var promise = this;
var args = array_slice(arguments);
return function fbound() {
return promise.dispatch("apply", [
this,
args.concat(array_slice(arguments))
]);
};
};
/**
* Requests the names of the owned properties of a promised
* object in a future turn.
* @param object promise or immediate reference for target object
* @return promise for the keys of the eventually settled object
*/
Q.keys = function (object) {
return Q(object).dispatch("keys", []);
};
Promise.prototype.keys = function () {
return this.dispatch("keys", []);
};
/**
* Turns an array of promises into a promise for an array. If any of
* the promises gets rejected, the whole array is rejected immediately.
* @param {Array*} an array (or promise for an array) of values (or
* promises for values)
* @returns a promise for an array of the corresponding values
*/
// By Mark Miller
// http://wiki.ecmascript.org/doku.php?id=strawman:concurrency&rev=1308776521#allfulfilled
Q.all = all;
function all(promises) {
return when(promises, function (promises) {
var countDown = 0;
var deferred = defer();
array_reduce(promises, function (undefined, promise, index) {
var snapshot;
if (
isPromise(promise) &&
(snapshot = promise.inspect()).state === "fulfilled"
) {
promises[index] = snapshot.value;
} else {
++countDown;
when(
promise,
function (value) {
promises[index] = value;
if (--countDown === 0) {
deferred.resolve(promises);
}
},
deferred.reject,
function (progress) {
deferred.notify({ index: index, value: progress });
}
);
}
}, void 0);
if (countDown === 0) {
deferred.resolve(promises);
}
return deferred.promise;
});
}
Promise.prototype.all = function () {
return all(this);
};
/**
* Waits for all promises to be settled, either fulfilled or
* rejected. This is distinct from `all` since that would stop
* waiting at the first rejection. The promise returned by
* `allResolved` will never be rejected.
* @param promises a promise for an array (or an array) of promises
* (or values)
* @return a promise for an array of promises
*/
Q.allResolved = deprecate(allResolved, "allResolved", "allSettled");
function allResolved(promises) {
return when(promises, function (promises) {
promises = array_map(promises, Q);
return when(all(array_map(promises, function (promise) {
return when(promise, noop, noop);
})), function () {
return promises;
});
});
}
Promise.prototype.allResolved = function () {
return allResolved(this);
};
/**
* @see Promise#allSettled
*/
Q.allSettled = allSettled;
function allSettled(promises) {
return Q(promises).allSettled();
}
/**
* Turns an array of promises into a promise for an array of their states (as
* returned by `inspect`) when they have all settled.
* @param {Array[Any*]} values an array (or promise for an array) of values (or
* promises for values)
* @returns {Array[State]} an array of states for the respective values.
*/
Promise.prototype.allSettled = function () {
return this.then(function (promises) {
return all(array_map(promises, function (promise) {
promise = Q(promise);
function regardless() {
return promise.inspect();
}
return promise.then(regardless, regardless);
}));
});
};
/**
* Captures the failure of a promise, giving an oportunity to recover
* with a callback. If the given promise is fulfilled, the returned
* promise is fulfilled.
* @param {Any*} promise for something
* @param {Function} callback to fulfill the returned promise if the
* given promise is rejected
* @returns a promise for the return value of the callback
*/
Q.fail = // XXX legacy
Q["catch"] = function (object, rejected) {
return Q(object).then(void 0, rejected);
};
Promise.prototype.fail = // XXX legacy
Promise.prototype["catch"] = function (rejected) {
return this.then(void 0, rejected);
};
/**
* Attaches a listener that can respond to progress notifications from a
* promise's originating deferred. This listener receives the exact arguments
* passed to ``deferred.notify``.
* @param {Any*} promise for something
* @param {Function} callback to receive any progress notifications
* @returns the given promise, unchanged
*/
Q.progress = progress;
function progress(object, progressed) {
return Q(object).then(void 0, void 0, progressed);
}
Promise.prototype.progress = function (progressed) {
return this.then(void 0, void 0, progressed);
};
/**
* Provides an opportunity to observe the settling of a promise,
* regardless of whether the promise is fulfilled or rejected. Forwards
* the resolution to the returned promise when the callback is done.
* The callback can return a promise to defer completion.
* @param {Any*} promise
* @param {Function} callback to observe the resolution of the given
* promise, takes no arguments.
* @returns a promise for the resolution of the given promise when
* ``fin`` is done.
*/
Q.fin = // XXX legacy
Q["finally"] = function (object, callback) {
return Q(object)["finally"](callback);
};
Promise.prototype.fin = // XXX legacy
Promise.prototype["finally"] = function (callback) {
callback = Q(callback);
return this.then(function (value) {
return callback.fcall().then(function () {
return value;
});
}, function (reason) {
// TODO attempt to recycle the rejection with "this".
return callback.fcall().then(function () {
throw reason;
});
});
};
/**
* Terminates a chain of promises, forcing rejections to be
* thrown as exceptions.
* @param {Any*} promise at the end of a chain of promises
* @returns nothing
*/
Q.done = function (object, fulfilled, rejected, progress) {
return Q(object).done(fulfilled, rejected, progress);
};
Promise.prototype.done = function (fulfilled, rejected, progress) {
var onUnhandledError = function (error) {
// forward to a future turn so that ``when``
// does not catch it and turn it into a rejection.
nextTick(function () {
makeStackTraceLong(error, promise);
if (Q.onerror) {
Q.onerror(error);
} else {
throw error;
}
});
};
// Avoid unnecessary `nextTick`ing via an unnecessary `when`.
var promise = fulfilled || rejected || progress ?
this.then(fulfilled, rejected, progress) :
this;
if (typeof process === "object" && process && process.domain) {
onUnhandledError = process.domain.bind(onUnhandledError);
}
promise.then(void 0, onUnhandledError);
};
/**
* Causes a promise to be rejected if it does not get fulfilled before
* some milliseconds time out.
* @param {Any*} promise
* @param {Number} milliseconds timeout
* @param {String} custom error message (optional)
* @returns a promise for the resolution of the given promise if it is
* fulfilled before the timeout, otherwise rejected.
*/
Q.timeout = function (object, ms, message) {
return Q(object).timeout(ms, message);
};
Promise.prototype.timeout = function (ms, message) {
var deferred = defer();
var timeoutId = setTimeout(function () {
deferred.reject(new Error(message || "Timed out after " + ms + " ms"));
}, ms);
this.then(function (value) {
clearTimeout(timeoutId);
deferred.resolve(value);
}, function (exception) {
clearTimeout(timeoutId);
deferred.reject(exception);
}, deferred.notify);
return deferred.promise;
};
/**
* Returns a promise for the given value (or promised value), some
* milliseconds after it resolved. Passes rejections immediately.
* @param {Any*} promise
* @param {Number} milliseconds
* @returns a promise for the resolution of the given promise after milliseconds
* time has elapsed since the resolution of the given promise.
* If the given promise rejects, that is passed immediately.
*/
Q.delay = function (object, timeout) {
if (timeout === void 0) {
timeout = object;
object = void 0;
}
return Q(object).delay(timeout);
};
Promise.prototype.delay = function (timeout) {
return this.then(function (value) {
var deferred = defer();
setTimeout(function () {
deferred.resolve(value);
}, timeout);
return deferred.promise;
});
};
/**
* Passes a continuation to a Node function, which is called with the given
* arguments provided as an array, and returns a promise.
*
* Q.nfapply(FS.readFile, [__filename])
* .then(function (content) {
* })
*
*/
Q.nfapply = function (callback, args) {
return Q(callback).nfapply(args);
};
Promise.prototype.nfapply = function (args) {
var deferred = defer();
var nodeArgs = array_slice(args);
nodeArgs.push(deferred.makeNodeResolver());
this.fapply(nodeArgs).fail(deferred.reject);
return deferred.promise;
};
/**
* Passes a continuation to a Node function, which is called with the given
* arguments provided individually, and returns a promise.
* @example
* Q.nfcall(FS.readFile, __filename)
* .then(function (content) {
* })
*
*/
Q.nfcall = function (callback /*...args*/) {
var args = array_slice(arguments, 1);
return Q(callback).nfapply(args);
};
Promise.prototype.nfcall = function (/*...args*/) {
var nodeArgs = array_slice(arguments);
var deferred = defer();
nodeArgs.push(deferred.makeNodeResolver());
this.fapply(nodeArgs).fail(deferred.reject);
return deferred.promise;
};
/**
* Wraps a NodeJS continuation passing function and returns an equivalent
* version that returns a promise.
* @example
* Q.nfbind(FS.readFile, __filename)("utf-8")
* .then(console.log)
* .done()
*/
Q.nfbind =
Q.denodeify = function (callback /*...args*/) {
var baseArgs = array_slice(arguments, 1);
return function () {
var nodeArgs = baseArgs.concat(array_slice(arguments));
var deferred = defer();
nodeArgs.push(deferred.makeNodeResolver());
Q(callback).fapply(nodeArgs).fail(deferred.reject);
return deferred.promise;
};
};
Promise.prototype.nfbind =
Promise.prototype.denodeify = function (/*...args*/) {
var args = array_slice(arguments);
args.unshift(this);
return Q.denodeify.apply(void 0, args);
};
Q.nbind = function (callback, thisp /*...args*/) {
var baseArgs = array_slice(arguments, 2);
return function () {
var nodeArgs = baseArgs.concat(array_slice(arguments));
var deferred = defer();
nodeArgs.push(deferred.makeNodeResolver());
function bound() {
return callback.apply(thisp, arguments);
}
Q(bound).fapply(nodeArgs).fail(deferred.reject);
return deferred.promise;
};
};
Promise.prototype.nbind = function (/*thisp, ...args*/) {
var args = array_slice(arguments, 0);
args.unshift(this);
return Q.nbind.apply(void 0, args);
};
/**
* Calls a method of a Node-style object that accepts a Node-style
* callback with a given array of arguments, plus a provided callback.
* @param object an object that has the named method
* @param {String} name name of the method of object
* @param {Array} args arguments to pass to the method; the callback
* will be provided by Q and appended to these arguments.
* @returns a promise for the value or error
*/
Q.nmapply = // XXX As proposed by "Redsandro"
Q.npost = function (object, name, args) {
return Q(object).npost(name, args);
};
Promise.prototype.nmapply = // XXX As proposed by "Redsandro"
Promise.prototype.npost = function (name, args) {
var nodeArgs = array_slice(args || []);
var deferred = defer();
nodeArgs.push(deferred.makeNodeResolver());
this.dispatch("post", [name, nodeArgs]).fail(deferred.reject);
return deferred.promise;
};
/**
* Calls a method of a Node-style object that accepts a Node-style
* callback, forwarding the given variadic arguments, plus a provided
* callback argument.
* @param object an object that has the named method
* @param {String} name name of the method of object
* @param ...args arguments to pass to the method; the callback will
* be provided by Q and appended to these arguments.
* @returns a promise for the value or error
*/
Q.nsend = // XXX Based on Mark Miller's proposed "send"
Q.nmcall = // XXX Based on "Redsandro's" proposal
Q.ninvoke = function (object, name /*...args*/) {
var nodeArgs = array_slice(arguments, 2);
var deferred = defer();
nodeArgs.push(deferred.makeNodeResolver());
Q(object).dispatch("post", [name, nodeArgs]).fail(deferred.reject);
return deferred.promise;
};
Promise.prototype.nsend = // XXX Based on Mark Miller's proposed "send"
Promise.prototype.nmcall = // XXX Based on "Redsandro's" proposal
Promise.prototype.ninvoke = function (name /*...args*/) {
var nodeArgs = array_slice(arguments, 1);
var deferred = defer();
nodeArgs.push(deferred.makeNodeResolver());
this.dispatch("post", [name, nodeArgs]).fail(deferred.reject);
return deferred.promise;
};
/**
* If a function would like to support both Node continuation-passing-style and
* promise-returning-style, it can end its internal promise chain with
* `nodeify(nodeback)`, forwarding the optional nodeback argument. If the user
* elects to use a nodeback, the result will be sent there. If they do not
* pass a nodeback, they will receive the result promise.
* @param object a result (or a promise for a result)
* @param {Function} nodeback a Node.js-style callback
* @returns either the promise or nothing
*/
Q.nodeify = nodeify;
function nodeify(object, nodeback) {
return Q(object).nodeify(nodeback);
}
Promise.prototype.nodeify = function (nodeback) {
if (nodeback) {
this.then(function (value) {
nextTick(function () {
nodeback(null, value);
});
}, function (error) {
nextTick(function () {
nodeback(error);
});
});
} else {
return this;
}
};
// All code before this point will be filtered from stack traces.
var qEndingLine = captureLine();
return Q;
});
/***/ },
/* 53 */
/***/ function(module, exports) {
module.exports = require("child_process");
/***/ },
/* 54 */
/***/ function(module, exports, __webpack_require__) {
var errorAdapter = __webpack_require__(49)
var fs = __webpack_require__(28)
var q = __webpack_require__(52)
module.exports = function(params) {
var errors = requiredParams().map(exists).filter(stripNull)
if (errors.length > 0) {
return q.fcall(function() {
var error = errors[0]
throw error
})
}
return validateRepoPathExists(params)
function exists(field) {
var error
if (!params[field]) {
error = errorAdapter.create('field "' + field + '" is required', {
namespace: 'git-archive'
})
error.field = field
}
return error
}
};
function stripNull(error) {
return error
}
function validateRepoPathExists(params) {
var deferred = q.defer()
var repoPath = params.repoPath
fs.exists(repoPath, existsHandler)
return deferred.promise
function existsHandler(exists) {
var error
if (exists) {
return deferred.resolve(params)
}
error = errorAdapter.create('repoPath does not exist on disk', {
namespace: 'git-archive'
})
error.field = 'repoPath'
error.repoPath = repoPath
return deferred.reject(error)
}
}
function requiredParams() {
return ['commit', 'outputPath', 'repoPath']
}
/***/ },
/* 55 */
/***/ function(module, exports, __webpack_require__) {
var ERR, word_wrap, fs, _;
'use strict';
ERR = __webpack_require__(1);
word_wrap = __webpack_require__(2);
fs = __webpack_require__(6);
_ = function _(curr_path, cb) {
var err, exists;
fs.stat(curr_path + '/.git', function (arguments, _$param0, _$param1) {
err = _$param0;
exists = _$param1;
if (exists) {
return cb(null, curr_path);
}
_(curr_path + '/..', cb);
}.bind(this, arguments));
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 56 */
/***/ function(module, exports, __webpack_require__) {
var ERR, word_wrap, fs, read_file, remove, mkdir, copy, yarn_install, yaml, download_updatables, copy_if_exists, make_package_json, _;
'use strict';
ERR = __webpack_require__(1);
word_wrap = __webpack_require__(2);
fs = __webpack_require__(6);
read_file = fs.readFile;
remove = fs.remove;
mkdir = fs.mkdirp;
copy = fs.copy;
yarn_install = __webpack_require__(57);
yaml = __webpack_require__(64);
download_updatables = __webpack_require__(47);
copy_if_exists = __webpack_require__(65);
make_package_json = __webpack_require__(66);
_ = function _(mu_src_path, root_path, metadata, cb) {
var gen_path, err, deps, dev_deps;
gen_path = root_path + '/generated_local/project';
remove(gen_path, function (arguments, _$param0) {
err = _$param0;
if (ERR(err, cb)) {
return;
}
mkdir(gen_path, function (arguments, _$param1) {
err = _$param1;
if (ERR(err, cb)) {
return;
}
copy_if_exists(root_path + '/submodules', gen_path, function (arguments, _$param2) {
err = _$param2;
if (ERR(err, cb)) {
return;
}
copy(root_path + '/_.es6', gen_path + '/_.es6', function (arguments, _$param3) {
err = _$param3;
if (ERR(err, cb)) {
return;
}
copy(root_path + '/__test.es6', gen_path + '/__test.es6', function (arguments, _$param4) {
err = _$param4;
if (ERR(err, cb)) {
return;
}
download_updatables(mu_src_path, root_path, 'HEAD', function (arguments, _$param5) {
err = _$param5;
if (ERR(err, cb)) {
return;
}
read_file(root_path + '/meta/npm_dependencies.yaml', function (arguments, _$param6, _$param7) {
err = _$param6;
deps = _$param7;
if (ERR(err, cb)) {
return;
}
read_file(root_path + '/meta/npm_dev_dependencies.yaml', function (arguments, _$param8, _$param9) {
err = _$param8;
dev_deps = _$param9;
if (ERR(err, cb)) {
return;
}
make_package_json(mu_src_path, metadata, gen_path, yaml.safeLoad(deps), yaml.safeLoad(dev_deps), function (arguments, _$param10) {
err = _$param10;
if (ERR(err, cb)) {
return;
}
console.log('===== yarn 1 starting');
yarn_install(gen_path, function (arguments, _$param11) {
err = _$param11;
if (ERR(err, cb)) {
return;
}
console.log('===== yarn 1 finished');
cb();
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 57 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var ERR = __webpack_require__(1);
var word_wrap = __webpack_require__(2);
var yarn = __webpack_require__(58);
var gulp = __webpack_require__(63);
var _ = function _(path, cb) {
gulp.task('_', function () {
return gulp.src(path + '/package.json').pipe(yarn({ noBinLinks: true })).on('end', cb).on('error', cb);
});
gulp.start('_');
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 58 */
/***/ function(module, exports, __webpack_require__) {
/**
* Created by mwarapitiya on 10/23/16.
*/
'use strict';
var through2 = __webpack_require__(59);
var gutil = __webpack_require__(60);
var path = __webpack_require__(11);
var commandRunner = __webpack_require__(61);
var commandList = {
'package.json': {
cmd: 'yarn',
args: []
}
};
/**
*
* @param opts
* @returns {*}
*/
module.exports = function install(opts) {
var toRun = [];
var count = 0;
return through2({
objectMode: true
},
function (file, enc, callback) {
if (!file.path) {
callback();
}
var cmd = clone(commandList[path.basename(file.path)]);
if (cmd) {
if (opts && opts.production) {
cmd.args.push('--production');
} else if (opts && opts.dev) {
cmd.args.push('--dev');
}
if (opts && opts.force) {
cmd.args.push('--force');
}
if (opts && opts.flat) {
cmd.args.push('--flat');
}
if (opts && opts.noBinLinks) {
cmd.args.push('--no-bin-links');
}
if (opts && opts.ignoreEngines) {
cmd.args.push('--ignore-engines');
}
if (opts && opts.args) {
formatArguments(opts.args).forEach(function (arg) {
cmd.args.push(arg);
});
}
cmd.cwd = path.dirname(file.path);
toRun.push(cmd);
}
this.push(file);
callback();
},
function (callback) {
if (!toRun.length) {
return callback();
}
if (skipInstall()) {
log('Skipping yarn.', 'Run `' + gutil.colors.yellow(formatCommands(toRun)) + '` manually');
return callback();
} else {
toRun.forEach(function (command) {
commandRunner.run(command, function (err) {
if (err) {
log(err.message, ', run `' + gutil.colors.yellow(formatCommand(command)) + '` manually');
return callback(err);
}
done(callback, toRun.length);
});
});
}
}
);
function done(callback, length) {
if (++count === length) {
callback();
}
}
};
/**
* Logger
*/
function log() {
if (isTest()) {
return;
}
gutil.log.apply(gutil, [].slice.call(arguments));
}
/**
* Format commands
*/
function formatCommands(cmds) {
return cmds.map(formatCommand).join(' && ');
}
/**
* Format command
* @param command
* @returns {string}
*/
function formatCommand(command) {
return command.cmd + ' ' + command.args.join(' ');
}
/**
* Formant Arguments
* @param args
* @returns {*}
*/
function formatArguments(args) {
if (Array.isArray(args)) {
args.forEach(function (arg, index, arr) {
arr[index] = formatArgument(arg);
});
return args;
} else if (typeof args === 'string' || args instanceof String) {
return [formatArgument(args)];
} else {
log('Arguments are not passed in a valid format: ' + args);
return [];
}
}
/**
* Format argument
* @param arg
* @returns {*}
*/
function formatArgument(arg) {
var result = arg;
while (!result.match(/--.*/)) {
result = '-' + result;
}
return result;
}
/**
* Skip
* @returns {boolean}
*/
function skipInstall() {
return process.argv.slice(2).indexOf('--skip-yarn') >= 0;
}
/**
* is Test environment
* @returns {boolean}
*/
function isTest() {
return process.env.NODE_ENV === 'test';
}
/**
* clone object
* @param obj
* @returns {*}
*/
function clone(obj) {
if (Array.isArray(obj)) {
return obj.map(clone);
} else if (typeof obj === 'object') {
var copy = {};
Object.keys(obj).forEach(function (key) {
copy[key] = clone(obj[key]);
});
return copy;
} else {
return obj;
}
}
/***/ },
/* 59 */
/***/ function(module, exports) {
module.exports = require("through2");
/***/ },
/* 60 */
/***/ function(module, exports) {
module.exports = require("gulp-util");
/***/ },
/* 61 */
/***/ function(module, exports, __webpack_require__) {
/**
* Created by mwarapitiya on 10/23/16.
*/
var which = __webpack_require__(62);
var childProcess = __webpack_require__(53);
exports.run = function run(command, callback) {
which(command.cmd, function (err, cmdpath) {
if (err) {
callback(new Error('Can\'t yarn! `' + command.cmd + '` doesn\'t seem to be installed.'));
return;
}
var cmd = childProcess.spawn(cmdpath, command.args, {stdio: 'inherit', cwd: command.cwd || process.cwd()});
cmd.on('close', function (code) {
if (code !== 0) {
return callback(new Error(command.cmd + ' exited with non-zero code ' + code));
}
callback();
});
});
};
/***/ },
/* 62 */
/***/ function(module, exports) {
module.exports = require("which");
/***/ },
/* 63 */
/***/ function(module, exports) {
module.exports = require("gulp");
/***/ },
/* 64 */
/***/ function(module, exports) {
module.exports = require("js-yaml");
/***/ },
/* 65 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var ERR = __webpack_require__(1);
var word_wrap = __webpack_require__(2);
var fs = __webpack_require__(6);
var _ = function _(from, to, cb) {
var handle_response = function handle_response() {
cb();
};
fs.copy(from, to, handle_response);
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 66 */
/***/ function(module, exports, __webpack_require__) {
var ERR, word_wrap, r, merge, fs, apply_template, yaml, _;
'use strict';
ERR = __webpack_require__(1);
word_wrap = __webpack_require__(2);
r = __webpack_require__(67);
merge = __webpack_require__(376);
fs = __webpack_require__(6);
apply_template = __webpack_require__(380);
yaml = __webpack_require__(64);
_ = function _(mu_src_path, metadata, gen_path, deps, dev_deps, cb) {
var map_to_str, err, def_vals_yaml, def_vals, template, replace, s;
map_to_str = function map_to_str(i) {
var ret;
ret = r.map(function (pair) {
return '"' + pair[0] + '": "' + pair[1] + '"';
}, r.toPairs(i));
return ret.join(',\n ');
};
fs.readFile(mu_src_path + '/lambda_pattern/shared/default_package_values.yaml', 'utf8', function (arguments, _$param0, _$param1) {
err = _$param0;
def_vals_yaml = _$param1;
if (ERR(err, cb)) {
return;
}
def_vals = yaml.safeLoad(def_vals_yaml);
fs.readFile(mu_src_path + '/lambda_pattern/shared/package_template.json', 'utf8', function (arguments, _$param2, _$param3) {
err = _$param2;
template = _$param3;
if (ERR(err, cb)) {
return;
}
replace = merge([
metadata,
def_vals
]);
replace.dependencies = map_to_str(deps);
replace.dev_dependencies = map_to_str(dev_deps);
s = apply_template(template, replace);
fs.writeFile(gen_path + '/package.json', s, cb);
}.bind(this, arguments));
}.bind(this, arguments));
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 67 */
/***/ function(module, exports, __webpack_require__) {
module.exports = {
F: __webpack_require__(68),
T: __webpack_require__(72),
__: __webpack_require__(73),
add: __webpack_require__(74),
addIndex: __webpack_require__(76),
adjust: __webpack_require__(81),
all: __webpack_require__(83),
allPass: __webpack_require__(90),
always: __webpack_require__(69),
and: __webpack_require__(106),
any: __webpack_require__(107),
anyPass: __webpack_require__(109),
ap: __webpack_require__(110),
aperture: __webpack_require__(111),
append: __webpack_require__(114),
apply: __webpack_require__(115),
applySpec: __webpack_require__(116),
ascend: __webpack_require__(118),
assoc: __webpack_require__(119),
assocPath: __webpack_require__(120),
binary: __webpack_require__(122),
bind: __webpack_require__(97),
both: __webpack_require__(124),
call: __webpack_require__(128),
chain: __webpack_require__(130),
clamp: __webpack_require__(135),
clone: __webpack_require__(136),
comparator: __webpack_require__(140),
complement: __webpack_require__(141),
compose: __webpack_require__(143),
composeK: __webpack_require__(150),
composeP: __webpack_require__(151),
concat: __webpack_require__(154),
cond: __webpack_require__(172),
construct: __webpack_require__(173),
constructN: __webpack_require__(174),
contains: __webpack_require__(175),
converge: __webpack_require__(176),
countBy: __webpack_require__(177),
curry: __webpack_require__(129),
curryN: __webpack_require__(78),
dec: __webpack_require__(180),
descend: __webpack_require__(181),
defaultTo: __webpack_require__(182),
difference: __webpack_require__(183),
differenceWith: __webpack_require__(184),
dissoc: __webpack_require__(186),
dissocPath: __webpack_require__(187),
divide: __webpack_require__(188),
drop: __webpack_require__(189),
dropLast: __webpack_require__(191),
dropLastWhile: __webpack_require__(196),
dropRepeats: __webpack_require__(199),
dropRepeatsWith: __webpack_require__(201),
dropWhile: __webpack_require__(204),
either: __webpack_require__(206),
empty: __webpack_require__(208),
eqBy: __webpack_require__(209),
eqProps: __webpack_require__(210),
equals: __webpack_require__(159),
evolve: __webpack_require__(211),
filter: __webpack_require__(168),
find: __webpack_require__(212),
findIndex: __webpack_require__(214),
findLast: __webpack_require__(216),
findLastIndex: __webpack_require__(218),
flatten: __webpack_require__(220),
flip: __webpack_require__(221),
forEach: __webpack_require__(222),
forEachObjIndexed: __webpack_require__(223),
fromPairs: __webpack_require__(224),
groupBy: __webpack_require__(225),
groupWith: __webpack_require__(226),
gt: __webpack_require__(227),
gte: __webpack_require__(228),
has: __webpack_require__(229),
hasIn: __webpack_require__(230),
head: __webpack_require__(231),
identical: __webpack_require__(163),
identity: __webpack_require__(232),
ifElse: __webpack_require__(234),
inc: __webpack_require__(235),
indexBy: __webpack_require__(236),
indexOf: __webpack_require__(237),
init: __webpack_require__(238),
insert: __webpack_require__(239),
insertAll: __webpack_require__(240),
intersection: __webpack_require__(241),
intersectionWith: __webpack_require__(245),
intersperse: __webpack_require__(247),
into: __webpack_require__(248),
invert: __webpack_require__(253),
invertObj: __webpack_require__(254),
invoker: __webpack_require__(255),
is: __webpack_require__(256),
isArrayLike: __webpack_require__(98),
isEmpty: __webpack_require__(257),
isNil: __webpack_require__(258),
join: __webpack_require__(259),
juxt: __webpack_require__(260),
keys: __webpack_require__(101),
keysIn: __webpack_require__(261),
last: __webpack_require__(202),
lastIndexOf: __webpack_require__(262),
length: __webpack_require__(263),
lens: __webpack_require__(265),
lensIndex: __webpack_require__(266),
lensPath: __webpack_require__(268),
lensProp: __webpack_require__(270),
lift: __webpack_require__(126),
liftN: __webpack_require__(127),
lt: __webpack_require__(271),
lte: __webpack_require__(272),
map: __webpack_require__(93),
mapAccum: __webpack_require__(273),
mapAccumRight: __webpack_require__(274),
mapObjIndexed: __webpack_require__(275),
match: __webpack_require__(276),
mathMod: __webpack_require__(277),
max: __webpack_require__(91),
maxBy: __webpack_require__(278),
mean: __webpack_require__(279),
median: __webpack_require__(281),
memoize: __webpack_require__(282),
merge: __webpack_require__(283),
mergeAll: __webpack_require__(284),
mergeWith: __webpack_require__(285),
mergeWithKey: __webpack_require__(286),
min: __webpack_require__(287),
minBy: __webpack_require__(288),
modulo: __webpack_require__(289),
multiply: __webpack_require__(290),
nAry: __webpack_require__(123),
negate: __webpack_require__(291),
none: __webpack_require__(292),
not: __webpack_require__(142),
nth: __webpack_require__(203),
nthArg: __webpack_require__(293),
objOf: __webpack_require__(252),
of: __webpack_require__(294),
omit: __webpack_require__(296),
once: __webpack_require__(297),
or: __webpack_require__(207),
over: __webpack_require__(298),
pair: __webpack_require__(299),
partial: __webpack_require__(300),
partialRight: __webpack_require__(302),
partition: __webpack_require__(303),
path: __webpack_require__(269),
pathEq: __webpack_require__(304),
pathOr: __webpack_require__(305),
pathSatisfies: __webpack_require__(306),
pick: __webpack_require__(307),
pickAll: __webpack_require__(308),
pickBy: __webpack_require__(309),
pipe: __webpack_require__(144),
pipeK: __webpack_require__(310),
pipeP: __webpack_require__(152),
pluck: __webpack_require__(92),
prepend: __webpack_require__(311),
product: __webpack_require__(312),
project: __webpack_require__(313),
prop: __webpack_require__(104),
propEq: __webpack_require__(315),
propIs: __webpack_require__(316),
propOr: __webpack_require__(317),
propSatisfies: __webpack_require__(318),
props: __webpack_require__(319),
range: __webpack_require__(320),
reduce: __webpack_require__(105),
reduceBy: __webpack_require__(178),
reduceRight: __webpack_require__(321),
reduceWhile: __webpack_require__(322),
reduced: __webpack_require__(323),
reject: __webpack_require__(166),
remove: __webpack_require__(324),
repeat: __webpack_require__(325),
replace: __webpack_require__(327),
reverse: __webpack_require__(149),
scan: __webpack_require__(328),
sequence: __webpack_require__(329),
set: __webpack_require__(330),
slice: __webpack_require__(148),
sort: __webpack_require__(331),
sortBy: __webpack_require__(332),
sortWith: __webpack_require__(333),
split: __webpack_require__(334),
splitAt: __webpack_require__(335),
splitEvery: __webpack_require__(336),
splitWhen: __webpack_require__(337),
subtract: __webpack_require__(338),
sum: __webpack_require__(280),
symmetricDifference: __webpack_require__(339),
symmetricDifferenceWith: __webpack_require__(340),
tail: __webpack_require__(146),
take: __webpack_require__(193),
takeLast: __webpack_require__(341),
takeLastWhile: __webpack_require__(342),
takeWhile: __webpack_require__(343),
tap: __webpack_require__(345),
test: __webpack_require__(346),
times: __webpack_require__(326),
toLower: __webpack_require__(348),
toPairs: __webpack_require__(349),
toPairsIn: __webpack_require__(350),
toString: __webpack_require__(155),
toUpper: __webpack_require__(351),
transduce: __webpack_require__(352),
transpose: __webpack_require__(353),
traverse: __webpack_require__(354),
trim: __webpack_require__(355),
tryCatch: __webpack_require__(356),
type: __webpack_require__(139),
unapply: __webpack_require__(357),
unary: __webpack_require__(358),
uncurryN: __webpack_require__(359),
unfold: __webpack_require__(360),
union: __webpack_require__(361),
unionWith: __webpack_require__(362),
uniq: __webpack_require__(242),
uniqBy: __webpack_require__(243),
uniqWith: __webpack_require__(246),
unless: __webpack_require__(363),
unnest: __webpack_require__(364),
until: __webpack_require__(365),
update: __webpack_require__(267),
useWith: __webpack_require__(314),
values: __webpack_require__(117),
valuesIn: __webpack_require__(366),
view: __webpack_require__(367),
when: __webpack_require__(368),
where: __webpack_require__(369),
whereEq: __webpack_require__(370),
without: __webpack_require__(371),
xprod: __webpack_require__(372),
zip: __webpack_require__(373),
zipObj: __webpack_require__(374),
zipWith: __webpack_require__(375)
};
/***/ },
/* 68 */
/***/ function(module, exports, __webpack_require__) {
var always = __webpack_require__(69);
/**
* A function that always returns `false`. Any passed in parameters are ignored.
*
* @func
* @memberOf R
* @since v0.9.0
* @category Function
* @sig * -> Boolean
* @param {*}
* @return {Boolean}
* @see R.always, R.T
* @example
*
* R.F(); //=> false
*/
module.exports = always(false);
/***/ },
/* 69 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
/**
* Returns a function that always returns the given value. Note that for
* non-primitives the value returned is a reference to the original value.
*
* This function is known as `const`, `constant`, or `K` (for K combinator) in
* other languages and libraries.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Function
* @sig a -> (* -> a)
* @param {*} val The value to wrap in a function
* @return {Function} A Function :: * -> val.
* @example
*
* var t = R.always('Tee');
* t(); //=> 'Tee'
*/
module.exports = _curry1(function always(val) {
return function() {
return val;
};
});
/***/ },
/* 70 */
/***/ function(module, exports, __webpack_require__) {
var _isPlaceholder = __webpack_require__(71);
/**
* Optimized internal one-arity curry function.
*
* @private
* @category Function
* @param {Function} fn The function to curry.
* @return {Function} The curried function.
*/
module.exports = function _curry1(fn) {
return function f1(a) {
if (arguments.length === 0 || _isPlaceholder(a)) {
return f1;
} else {
return fn.apply(this, arguments);
}
};
};
/***/ },
/* 71 */
/***/ function(module, exports) {
module.exports = function _isPlaceholder(a) {
return a != null &&
typeof a === 'object' &&
a['@@functional/placeholder'] === true;
};
/***/ },
/* 72 */
/***/ function(module, exports, __webpack_require__) {
var always = __webpack_require__(69);
/**
* A function that always returns `true`. Any passed in parameters are ignored.
*
* @func
* @memberOf R
* @since v0.9.0
* @category Function
* @sig * -> Boolean
* @param {*}
* @return {Boolean}
* @see R.always, R.F
* @example
*
* R.T(); //=> true
*/
module.exports = always(true);
/***/ },
/* 73 */
/***/ function(module, exports) {
/**
* A special placeholder value used to specify "gaps" within curried functions,
* allowing partial application of any combination of arguments, regardless of
* their positions.
*
* If `g` is a curried ternary function and `_` is `R.__`, the following are
* equivalent:
*
* - `g(1, 2, 3)`
* - `g(_, 2, 3)(1)`
* - `g(_, _, 3)(1)(2)`
* - `g(_, _, 3)(1, 2)`
* - `g(_, 2, _)(1, 3)`
* - `g(_, 2)(1)(3)`
* - `g(_, 2)(1, 3)`
* - `g(_, 2)(_, 3)(1)`
*
* @constant
* @memberOf R
* @since v0.6.0
* @category Function
* @example
*
* var greet = R.replace('{name}', R.__, 'Hello, {name}!');
* greet('Alice'); //=> 'Hello, Alice!'
*/
module.exports = {'@@functional/placeholder': true};
/***/ },
/* 74 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Adds two values.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Math
* @sig Number -> Number -> Number
* @param {Number} a
* @param {Number} b
* @return {Number}
* @see R.subtract
* @example
*
* R.add(2, 3); //=> 5
* R.add(7)(10); //=> 17
*/
module.exports = _curry2(function add(a, b) {
return Number(a) + Number(b);
});
/***/ },
/* 75 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var _isPlaceholder = __webpack_require__(71);
/**
* Optimized internal two-arity curry function.
*
* @private
* @category Function
* @param {Function} fn The function to curry.
* @return {Function} The curried function.
*/
module.exports = function _curry2(fn) {
return function f2(a, b) {
switch (arguments.length) {
case 0:
return f2;
case 1:
return _isPlaceholder(a) ? f2
: _curry1(function(_b) { return fn(a, _b); });
default:
return _isPlaceholder(a) && _isPlaceholder(b) ? f2
: _isPlaceholder(a) ? _curry1(function(_a) { return fn(_a, b); })
: _isPlaceholder(b) ? _curry1(function(_b) { return fn(a, _b); })
: fn(a, b);
}
};
};
/***/ },
/* 76 */
/***/ function(module, exports, __webpack_require__) {
var _concat = __webpack_require__(77);
var _curry1 = __webpack_require__(70);
var curryN = __webpack_require__(78);
/**
* Creates a new list iteration function from an existing one by adding two new
* parameters to its callback function: the current index, and the entire list.
*
* This would turn, for instance, Ramda's simple `map` function into one that
* more closely resembles `Array.prototype.map`. Note that this will only work
* for functions in which the iteration callback function is the first
* parameter, and where the list is the last parameter. (This latter might be
* unimportant if the list parameter is not used.)
*
* @func
* @memberOf R
* @since v0.15.0
* @category Function
* @category List
* @sig ((a ... -> b) ... -> [a] -> *) -> (a ..., Int, [a] -> b) ... -> [a] -> *)
* @param {Function} fn A list iteration function that does not pass index or list to its callback
* @return {Function} An altered list iteration function that passes (item, index, list) to its callback
* @example
*
* var mapIndexed = R.addIndex(R.map);
* mapIndexed((val, idx) => idx + '-' + val, ['f', 'o', 'o', 'b', 'a', 'r']);
* //=> ['0-f', '1-o', '2-o', '3-b', '4-a', '5-r']
*/
module.exports = _curry1(function addIndex(fn) {
return curryN(fn.length, function() {
var idx = 0;
var origFn = arguments[0];
var list = arguments[arguments.length - 1];
var args = Array.prototype.slice.call(arguments, 0);
args[0] = function() {
var result = origFn.apply(this, _concat(arguments, [idx, list]));
idx += 1;
return result;
};
return fn.apply(this, args);
});
});
/***/ },
/* 77 */
/***/ function(module, exports) {
/**
* Private `concat` function to merge two array-like objects.
*
* @private
* @param {Array|Arguments} [set1=[]] An array-like object.
* @param {Array|Arguments} [set2=[]] An array-like object.
* @return {Array} A new, merged array.
* @example
*
* _concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]
*/
module.exports = function _concat(set1, set2) {
set1 = set1 || [];
set2 = set2 || [];
var idx;
var len1 = set1.length;
var len2 = set2.length;
var result = [];
idx = 0;
while (idx < len1) {
result[result.length] = set1[idx];
idx += 1;
}
idx = 0;
while (idx < len2) {
result[result.length] = set2[idx];
idx += 1;
}
return result;
};
/***/ },
/* 78 */
/***/ function(module, exports, __webpack_require__) {
var _arity = __webpack_require__(79);
var _curry1 = __webpack_require__(70);
var _curry2 = __webpack_require__(75);
var _curryN = __webpack_require__(80);
/**
* Returns a curried equivalent of the provided function, with the specified
* arity. The curried function has two unusual capabilities. First, its
* arguments needn't be provided one at a time. If `g` is `R.curryN(3, f)`, the
* following are equivalent:
*
* - `g(1)(2)(3)`
* - `g(1)(2, 3)`
* - `g(1, 2)(3)`
* - `g(1, 2, 3)`
*
* Secondly, the special placeholder value `R.__` may be used to specify
* "gaps", allowing partial application of any combination of arguments,
* regardless of their positions. If `g` is as above and `_` is `R.__`, the
* following are equivalent:
*
* - `g(1, 2, 3)`
* - `g(_, 2, 3)(1)`
* - `g(_, _, 3)(1)(2)`
* - `g(_, _, 3)(1, 2)`
* - `g(_, 2)(1)(3)`
* - `g(_, 2)(1, 3)`
* - `g(_, 2)(_, 3)(1)`
*
* @func
* @memberOf R
* @since v0.5.0
* @category Function
* @sig Number -> (* -> a) -> (* -> a)
* @param {Number} length The arity for the returned function.
* @param {Function} fn The function to curry.
* @return {Function} A new, curried function.
* @see R.curry
* @example
*
* var sumArgs = (...args) => R.sum(args);
*
* var curriedAddFourNumbers = R.curryN(4, sumArgs);
* var f = curriedAddFourNumbers(1, 2);
* var g = f(3);
* g(4); //=> 10
*/
module.exports = _curry2(function curryN(length, fn) {
if (length === 1) {
return _curry1(fn);
}
return _arity(length, _curryN(length, [], fn));
});
/***/ },
/* 79 */
/***/ function(module, exports) {
module.exports = function _arity(n, fn) {
/* eslint-disable no-unused-vars */
switch (n) {
case 0: return function() { return fn.apply(this, arguments); };
case 1: return function(a0) { return fn.apply(this, arguments); };
case 2: return function(a0, a1) { return fn.apply(this, arguments); };
case 3: return function(a0, a1, a2) { return fn.apply(this, arguments); };
case 4: return function(a0, a1, a2, a3) { return fn.apply(this, arguments); };
case 5: return function(a0, a1, a2, a3, a4) { return fn.apply(this, arguments); };
case 6: return function(a0, a1, a2, a3, a4, a5) { return fn.apply(this, arguments); };
case 7: return function(a0, a1, a2, a3, a4, a5, a6) { return fn.apply(this, arguments); };
case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) { return fn.apply(this, arguments); };
case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) { return fn.apply(this, arguments); };
case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) { return fn.apply(this, arguments); };
default: throw new Error('First argument to _arity must be a non-negative integer no greater than ten');
}
};
/***/ },
/* 80 */
/***/ function(module, exports, __webpack_require__) {
var _arity = __webpack_require__(79);
var _isPlaceholder = __webpack_require__(71);
/**
* Internal curryN function.
*
* @private
* @category Function
* @param {Number} length The arity of the curried function.
* @param {Array} received An array of arguments received thus far.
* @param {Function} fn The function to curry.
* @return {Function} The curried function.
*/
module.exports = function _curryN(length, received, fn) {
return function() {
var combined = [];
var argsIdx = 0;
var left = length;
var combinedIdx = 0;
while (combinedIdx < received.length || argsIdx < arguments.length) {
var result;
if (combinedIdx < received.length &&
(!_isPlaceholder(received[combinedIdx]) ||
argsIdx >= arguments.length)) {
result = received[combinedIdx];
} else {
result = arguments[argsIdx];
argsIdx += 1;
}
combined[combinedIdx] = result;
if (!_isPlaceholder(result)) {
left -= 1;
}
combinedIdx += 1;
}
return left <= 0 ? fn.apply(this, combined)
: _arity(left, _curryN(length, combined, fn));
};
};
/***/ },
/* 81 */
/***/ function(module, exports, __webpack_require__) {
var _concat = __webpack_require__(77);
var _curry3 = __webpack_require__(82);
/**
* Applies a function to the value at the given index of an array, returning a
* new copy of the array with the element at the given index replaced with the
* result of the function application.
*
* @func
* @memberOf R
* @since v0.14.0
* @category List
* @sig (a -> a) -> Number -> [a] -> [a]
* @param {Function} fn The function to apply.
* @param {Number} idx The index.
* @param {Array|Arguments} list An array-like object whose value
* at the supplied index will be replaced.
* @return {Array} A copy of the supplied array-like object with
* the element at index `idx` replaced with the value
* returned by applying `fn` to the existing element.
* @see R.update
* @example
*
* R.adjust(R.add(10), 1, [1, 2, 3]); //=> [1, 12, 3]
* R.adjust(R.add(10))(1)([1, 2, 3]); //=> [1, 12, 3]
* @symb R.adjust(f, -1, [a, b]) = [a, f(b)]
* @symb R.adjust(f, 0, [a, b]) = [f(a), b]
*/
module.exports = _curry3(function adjust(fn, idx, list) {
if (idx >= list.length || idx < -list.length) {
return list;
}
var start = idx < 0 ? list.length : 0;
var _idx = start + idx;
var _list = _concat(list);
_list[_idx] = fn(list[_idx]);
return _list;
});
/***/ },
/* 82 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var _curry2 = __webpack_require__(75);
var _isPlaceholder = __webpack_require__(71);
/**
* Optimized internal three-arity curry function.
*
* @private
* @category Function
* @param {Function} fn The function to curry.
* @return {Function} The curried function.
*/
module.exports = function _curry3(fn) {
return function f3(a, b, c) {
switch (arguments.length) {
case 0:
return f3;
case 1:
return _isPlaceholder(a) ? f3
: _curry2(function(_b, _c) { return fn(a, _b, _c); });
case 2:
return _isPlaceholder(a) && _isPlaceholder(b) ? f3
: _isPlaceholder(a) ? _curry2(function(_a, _c) { return fn(_a, b, _c); })
: _isPlaceholder(b) ? _curry2(function(_b, _c) { return fn(a, _b, _c); })
: _curry1(function(_c) { return fn(a, b, _c); });
default:
return _isPlaceholder(a) && _isPlaceholder(b) && _isPlaceholder(c) ? f3
: _isPlaceholder(a) && _isPlaceholder(b) ? _curry2(function(_a, _b) { return fn(_a, _b, c); })
: _isPlaceholder(a) && _isPlaceholder(c) ? _curry2(function(_a, _c) { return fn(_a, b, _c); })
: _isPlaceholder(b) && _isPlaceholder(c) ? _curry2(function(_b, _c) { return fn(a, _b, _c); })
: _isPlaceholder(a) ? _curry1(function(_a) { return fn(_a, b, c); })
: _isPlaceholder(b) ? _curry1(function(_b) { return fn(a, _b, c); })
: _isPlaceholder(c) ? _curry1(function(_c) { return fn(a, b, _c); })
: fn(a, b, c);
}
};
};
/***/ },
/* 83 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _dispatchable = __webpack_require__(84);
var _xall = __webpack_require__(87);
/**
* Returns `true` if all elements of the list match the predicate, `false` if
* there are any that don't.
*
* Dispatches to the `all` method of the second argument, if present.
*
* Acts as a transducer if a transformer is given in list position.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig (a -> Boolean) -> [a] -> Boolean
* @param {Function} fn The predicate function.
* @param {Array} list The array to consider.
* @return {Boolean} `true` if the predicate is satisfied by every element, `false`
* otherwise.
* @see R.any, R.none, R.transduce
* @example
*
* var equals3 = R.equals(3);
* R.all(equals3)([3, 3, 3, 3]); //=> true
* R.all(equals3)([3, 3, 1, 3]); //=> false
*/
module.exports = _curry2(_dispatchable(['all'], _xall, function all(fn, list) {
var idx = 0;
while (idx < list.length) {
if (!fn(list[idx])) {
return false;
}
idx += 1;
}
return true;
}));
/***/ },
/* 84 */
/***/ function(module, exports, __webpack_require__) {
var _isArray = __webpack_require__(85);
var _isTransformer = __webpack_require__(86);
/**
* Returns a function that dispatches with different strategies based on the
* object in list position (last argument). If it is an array, executes [fn].
* Otherwise, if it has a function with one of the given method names, it will
* execute that function (functor case). Otherwise, if it is a transformer,
* uses transducer [xf] to return a new transformer (transducer case).
* Otherwise, it will default to executing [fn].
*
* @private
* @param {Array} methodNames properties to check for a custom implementation
* @param {Function} xf transducer to initialize if object is transformer
* @param {Function} fn default ramda implementation
* @return {Function} A function that dispatches on object in list position
*/
module.exports = function _dispatchable(methodNames, xf, fn) {
return function() {
if (arguments.length === 0) {
return fn();
}
var args = Array.prototype.slice.call(arguments, 0);
var obj = args.pop();
if (!_isArray(obj)) {
var idx = 0;
while (idx < methodNames.length) {
if (typeof obj[methodNames[idx]] === 'function') {
return obj[methodNames[idx]].apply(obj, args);
}
idx += 1;
}
if (_isTransformer(obj)) {
var transducer = xf.apply(null, args);
return transducer(obj);
}
}
return fn.apply(this, arguments);
};
};
/***/ },
/* 85 */
/***/ function(module, exports) {
/**
* Tests whether or not an object is an array.
*
* @private
* @param {*} val The object to test.
* @return {Boolean} `true` if `val` is an array, `false` otherwise.
* @example
*
* _isArray([]); //=> true
* _isArray(null); //=> false
* _isArray({}); //=> false
*/
module.exports = Array.isArray || function _isArray(val) {
return (val != null &&
val.length >= 0 &&
Object.prototype.toString.call(val) === '[object Array]');
};
/***/ },
/* 86 */
/***/ function(module, exports) {
module.exports = function _isTransformer(obj) {
return typeof obj['@@transducer/step'] === 'function';
};
/***/ },
/* 87 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _reduced = __webpack_require__(88);
var _xfBase = __webpack_require__(89);
module.exports = (function() {
function XAll(f, xf) {
this.xf = xf;
this.f = f;
this.all = true;
}
XAll.prototype['@@transducer/init'] = _xfBase.init;
XAll.prototype['@@transducer/result'] = function(result) {
if (this.all) {
result = this.xf['@@transducer/step'](result, true);
}
return this.xf['@@transducer/result'](result);
};
XAll.prototype['@@transducer/step'] = function(result, input) {
if (!this.f(input)) {
this.all = false;
result = _reduced(this.xf['@@transducer/step'](result, false));
}
return result;
};
return _curry2(function _xall(f, xf) { return new XAll(f, xf); });
}());
/***/ },
/* 88 */
/***/ function(module, exports) {
module.exports = function _reduced(x) {
return x && x['@@transducer/reduced'] ? x :
{
'@@transducer/value': x,
'@@transducer/reduced': true
};
};
/***/ },
/* 89 */
/***/ function(module, exports) {
module.exports = {
init: function() {
return this.xf['@@transducer/init']();
},
result: function(result) {
return this.xf['@@transducer/result'](result);
}
};
/***/ },
/* 90 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var curryN = __webpack_require__(78);
var max = __webpack_require__(91);
var pluck = __webpack_require__(92);
var reduce = __webpack_require__(105);
/**
* Takes a list of predicates and returns a predicate that returns true for a
* given list of arguments if every one of the provided predicates is satisfied
* by those arguments.
*
* The function returned is a curried function whose arity matches that of the
* highest-arity predicate.
*
* @func
* @memberOf R
* @since v0.9.0
* @category Logic
* @sig [(*... -> Boolean)] -> (*... -> Boolean)
* @param {Array} predicates An array of predicates to check
* @return {Function} The combined predicate
* @see R.anyPass
* @example
*
* var isQueen = R.propEq('rank', 'Q');
* var isSpade = R.propEq('suit', '♠︎');
* var isQueenOfSpades = R.allPass([isQueen, isSpade]);
*
* isQueenOfSpades({rank: 'Q', suit: '♣︎'}); //=> false
* isQueenOfSpades({rank: 'Q', suit: '♠︎'}); //=> true
*/
module.exports = _curry1(function allPass(preds) {
return curryN(reduce(max, 0, pluck('length', preds)), function() {
var idx = 0;
var len = preds.length;
while (idx < len) {
if (!preds[idx].apply(this, arguments)) {
return false;
}
idx += 1;
}
return true;
});
});
/***/ },
/* 91 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Returns the larger of its two arguments.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Relation
* @sig Ord a => a -> a -> a
* @param {*} a
* @param {*} b
* @return {*}
* @see R.maxBy, R.min
* @example
*
* R.max(789, 123); //=> 789
* R.max('a', 'b'); //=> 'b'
*/
module.exports = _curry2(function max(a, b) { return b > a ? b : a; });
/***/ },
/* 92 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var map = __webpack_require__(93);
var prop = __webpack_require__(104);
/**
* Returns a new list by plucking the same named property off all objects in
* the list supplied.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig k -> [{k: v}] -> [v]
* @param {Number|String} key The key name to pluck off of each object.
* @param {Array} list The array to consider.
* @return {Array} The list of values for the given key.
* @see R.props
* @example
*
* R.pluck('a')([{a: 1}, {a: 2}]); //=> [1, 2]
* R.pluck(0)([[1, 2], [3, 4]]); //=> [1, 3]
* @symb R.pluck('x', [{x: 1, y: 2}, {x: 3, y: 4}, {x: 5, y: 6}]) = [1, 3, 5]
* @symb R.pluck(0, [[1, 2], [3, 4], [5, 6]]) = [1, 3, 5]
*/
module.exports = _curry2(function pluck(p, list) {
return map(prop(p), list);
});
/***/ },
/* 93 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _dispatchable = __webpack_require__(84);
var _map = __webpack_require__(94);
var _reduce = __webpack_require__(95);
var _xmap = __webpack_require__(100);
var curryN = __webpack_require__(78);
var keys = __webpack_require__(101);
/**
* Takes a function and
* a [functor](https://github.com/fantasyland/fantasy-land#functor),
* applies the function to each of the functor's values, and returns
* a functor of the same shape.
*
* Ramda provides suitable `map` implementations for `Array` and `Object`,
* so this function may be applied to `[1, 2, 3]` or `{x: 1, y: 2, z: 3}`.
*
* Dispatches to the `map` method of the second argument, if present.
*
* Acts as a transducer if a transformer is given in list position.
*
* Also treats functions as functors and will compose them together.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig Functor f => (a -> b) -> f a -> f b
* @param {Function} fn The function to be called on every element of the input `list`.
* @param {Array} list The list to be iterated over.
* @return {Array} The new list.
* @see R.transduce, R.addIndex
* @example
*
* var double = x => x * 2;
*
* R.map(double, [1, 2, 3]); //=> [2, 4, 6]
*
* R.map(double, {x: 1, y: 2, z: 3}); //=> {x: 2, y: 4, z: 6}
* @symb R.map(f, [a, b]) = [f(a), f(b)]
* @symb R.map(f, { x: a, y: b }) = { x: f(a), y: f(b) }
* @symb R.map(f, functor_o) = functor_o.map(f)
*/
module.exports = _curry2(_dispatchable(['map'], _xmap, function map(fn, functor) {
switch (Object.prototype.toString.call(functor)) {
case '[object Function]':
return curryN(functor.length, function() {
return fn.call(this, functor.apply(this, arguments));
});
case '[object Object]':
return _reduce(function(acc, key) {
acc[key] = fn(functor[key]);
return acc;
}, {}, keys(functor));
default:
return _map(fn, functor);
}
}));
/***/ },
/* 94 */
/***/ function(module, exports) {
module.exports = function _map(fn, functor) {
var idx = 0;
var len = functor.length;
var result = Array(len);
while (idx < len) {
result[idx] = fn(functor[idx]);
idx += 1;
}
return result;
};
/***/ },
/* 95 */
/***/ function(module, exports, __webpack_require__) {
var _xwrap = __webpack_require__(96);
var bind = __webpack_require__(97);
var isArrayLike = __webpack_require__(98);
module.exports = (function() {
function _arrayReduce(xf, acc, list) {
var idx = 0;
var len = list.length;
while (idx < len) {
acc = xf['@@transducer/step'](acc, list[idx]);
if (acc && acc['@@transducer/reduced']) {
acc = acc['@@transducer/value'];
break;
}
idx += 1;
}
return xf['@@transducer/result'](acc);
}
function _iterableReduce(xf, acc, iter) {
var step = iter.next();
while (!step.done) {
acc = xf['@@transducer/step'](acc, step.value);
if (acc && acc['@@transducer/reduced']) {
acc = acc['@@transducer/value'];
break;
}
step = iter.next();
}
return xf['@@transducer/result'](acc);
}
function _methodReduce(xf, acc, obj) {
return xf['@@transducer/result'](obj.reduce(bind(xf['@@transducer/step'], xf), acc));
}
var symIterator = (typeof Symbol !== 'undefined') ? Symbol.iterator : '@@iterator';
return function _reduce(fn, acc, list) {
if (typeof fn === 'function') {
fn = _xwrap(fn);
}
if (isArrayLike(list)) {
return _arrayReduce(fn, acc, list);
}
if (typeof list.reduce === 'function') {
return _methodReduce(fn, acc, list);
}
if (list[symIterator] != null) {
return _iterableReduce(fn, acc, list[symIterator]());
}
if (typeof list.next === 'function') {
return _iterableReduce(fn, acc, list);
}
throw new TypeError('reduce: list must be array or iterable');
};
}());
/***/ },
/* 96 */
/***/ function(module, exports) {
module.exports = (function() {
function XWrap(fn) {
this.f = fn;
}
XWrap.prototype['@@transducer/init'] = function() {
throw new Error('init not implemented on XWrap');
};
XWrap.prototype['@@transducer/result'] = function(acc) { return acc; };
XWrap.prototype['@@transducer/step'] = function(acc, x) {
return this.f(acc, x);
};
return function _xwrap(fn) { return new XWrap(fn); };
}());
/***/ },
/* 97 */
/***/ function(module, exports, __webpack_require__) {
var _arity = __webpack_require__(79);
var _curry2 = __webpack_require__(75);
/**
* Creates a function that is bound to a context.
* Note: `R.bind` does not provide the additional argument-binding capabilities of
* [Function.prototype.bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind).
*
* @func
* @memberOf R
* @since v0.6.0
* @category Function
* @category Object
* @sig (* -> *) -> {*} -> (* -> *)
* @param {Function} fn The function to bind to context
* @param {Object} thisObj The context to bind `fn` to
* @return {Function} A function that will execute in the context of `thisObj`.
* @see R.partial
* @example
*
* var log = R.bind(console.log, console);
* R.pipe(R.assoc('a', 2), R.tap(log), R.assoc('a', 3))({a: 1}); //=> {a: 3}
* // logs {a: 2}
* @symb R.bind(f, o)(a, b) = f.call(o, a, b)
*/
module.exports = _curry2(function bind(fn, thisObj) {
return _arity(fn.length, function() {
return fn.apply(thisObj, arguments);
});
});
/***/ },
/* 98 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var _isArray = __webpack_require__(85);
var _isString = __webpack_require__(99);
/**
* Tests whether or not an object is similar to an array.
*
* @func
* @memberOf R
* @since v0.5.0
* @category Type
* @category List
* @sig * -> Boolean
* @param {*} x The object to test.
* @return {Boolean} `true` if `x` has a numeric length property and extreme indices defined; `false` otherwise.
* @deprecated since v0.23.0
* @example
*
* R.isArrayLike([]); //=> true
* R.isArrayLike(true); //=> false
* R.isArrayLike({}); //=> false
* R.isArrayLike({length: 10}); //=> false
* R.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true
*/
module.exports = _curry1(function isArrayLike(x) {
if (_isArray(x)) { return true; }
if (!x) { return false; }
if (typeof x !== 'object') { return false; }
if (_isString(x)) { return false; }
if (x.nodeType === 1) { return !!x.length; }
if (x.length === 0) { return true; }
if (x.length > 0) {
return x.hasOwnProperty(0) && x.hasOwnProperty(x.length - 1);
}
return false;
});
/***/ },
/* 99 */
/***/ function(module, exports) {
module.exports = function _isString(x) {
return Object.prototype.toString.call(x) === '[object String]';
};
/***/ },
/* 100 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _xfBase = __webpack_require__(89);
module.exports = (function() {
function XMap(f, xf) {
this.xf = xf;
this.f = f;
}
XMap.prototype['@@transducer/init'] = _xfBase.init;
XMap.prototype['@@transducer/result'] = _xfBase.result;
XMap.prototype['@@transducer/step'] = function(result, input) {
return this.xf['@@transducer/step'](result, this.f(input));
};
return _curry2(function _xmap(f, xf) { return new XMap(f, xf); });
}());
/***/ },
/* 101 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var _has = __webpack_require__(102);
var _isArguments = __webpack_require__(103);
/**
* Returns a list containing the names of all the enumerable own properties of
* the supplied object.
* Note that the order of the output array is not guaranteed to be consistent
* across different JS platforms.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Object
* @sig {k: v} -> [k]
* @param {Object} obj The object to extract properties from
* @return {Array} An array of the object's own properties.
* @example
*
* R.keys({a: 1, b: 2, c: 3}); //=> ['a', 'b', 'c']
*/
module.exports = (function() {
// cover IE < 9 keys issues
var hasEnumBug = !({toString: null}).propertyIsEnumerable('toString');
var nonEnumerableProps = ['constructor', 'valueOf', 'isPrototypeOf', 'toString',
'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];
// Safari bug
var hasArgsEnumBug = (function() {
'use strict';
return arguments.propertyIsEnumerable('length');
}());
var contains = function contains(list, item) {
var idx = 0;
while (idx < list.length) {
if (list[idx] === item) {
return true;
}
idx += 1;
}
return false;
};
return typeof Object.keys === 'function' && !hasArgsEnumBug ?
_curry1(function keys(obj) {
return Object(obj) !== obj ? [] : Object.keys(obj);
}) :
_curry1(function keys(obj) {
if (Object(obj) !== obj) {
return [];
}
var prop, nIdx;
var ks = [];
var checkArgsLength = hasArgsEnumBug && _isArguments(obj);
for (prop in obj) {
if (_has(prop, obj) && (!checkArgsLength || prop !== 'length')) {
ks[ks.length] = prop;
}
}
if (hasEnumBug) {
nIdx = nonEnumerableProps.length - 1;
while (nIdx >= 0) {
prop = nonEnumerableProps[nIdx];
if (_has(prop, obj) && !contains(ks, prop)) {
ks[ks.length] = prop;
}
nIdx -= 1;
}
}
return ks;
});
}());
/***/ },
/* 102 */
/***/ function(module, exports) {
module.exports = function _has(prop, obj) {
return Object.prototype.hasOwnProperty.call(obj, prop);
};
/***/ },
/* 103 */
/***/ function(module, exports, __webpack_require__) {
var _has = __webpack_require__(102);
module.exports = (function() {
var toString = Object.prototype.toString;
return toString.call(arguments) === '[object Arguments]' ?
function _isArguments(x) { return toString.call(x) === '[object Arguments]'; } :
function _isArguments(x) { return _has('callee', x); };
}());
/***/ },
/* 104 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Returns a function that when supplied an object returns the indicated
* property of that object, if it exists.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Object
* @sig s -> {s: a} -> a | Undefined
* @param {String} p The property name
* @param {Object} obj The object to query
* @return {*} The value at `obj.p`.
* @see R.path
* @example
*
* R.prop('x', {x: 100}); //=> 100
* R.prop('x', {}); //=> undefined
*/
module.exports = _curry2(function prop(p, obj) { return obj[p]; });
/***/ },
/* 105 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
var _reduce = __webpack_require__(95);
/**
* Returns a single item by iterating through the list, successively calling
* the iterator function and passing it an accumulator value and the current
* value from the array, and then passing the result to the next call.
*
* The iterator function receives two values: *(acc, value)*. It may use
* `R.reduced` to shortcut the iteration.
*
* The arguments' order of `reduceRight`'s iterator function is *(value, acc)*.
*
* Note: `R.reduce` does not skip deleted or unassigned indices (sparse
* arrays), unlike the native `Array.prototype.reduce` method. For more details
* on this behavior, see:
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#Description
*
* Dispatches to the `reduce` method of the third argument, if present.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig ((a, b) -> a) -> a -> [b] -> a
* @param {Function} fn The iterator function. Receives two values, the accumulator and the
* current element from the array.
* @param {*} acc The accumulator value.
* @param {Array} list The list to iterate over.
* @return {*} The final, accumulated value.
* @see R.reduced, R.addIndex, R.reduceRight
* @example
*
* R.reduce(R.subtract, 0, [1, 2, 3, 4]) // => ((((0 - 1) - 2) - 3) - 4) = -10
* - -10
* / \ / \
* - 4 -6 4
* / \ / \
* - 3 ==> -3 3
* / \ / \
* - 2 -1 2
* / \ / \
* 0 1 0 1
*
* @symb R.reduce(f, a, [b, c, d]) = f(f(f(a, b), c), d)
*/
module.exports = _curry3(_reduce);
/***/ },
/* 106 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Returns `true` if both arguments are `true`; `false` otherwise.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Logic
* @sig a -> b -> a | b
* @param {Any} a
* @param {Any} b
* @return {Any} the first argument if it is falsy, otherwise the second argument.
* @see R.both
* @example
*
* R.and(true, true); //=> true
* R.and(true, false); //=> false
* R.and(false, true); //=> false
* R.and(false, false); //=> false
*/
module.exports = _curry2(function and(a, b) {
return a && b;
});
/***/ },
/* 107 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _dispatchable = __webpack_require__(84);
var _xany = __webpack_require__(108);
/**
* Returns `true` if at least one of elements of the list match the predicate,
* `false` otherwise.
*
* Dispatches to the `any` method of the second argument, if present.
*
* Acts as a transducer if a transformer is given in list position.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig (a -> Boolean) -> [a] -> Boolean
* @param {Function} fn The predicate function.
* @param {Array} list The array to consider.
* @return {Boolean} `true` if the predicate is satisfied by at least one element, `false`
* otherwise.
* @see R.all, R.none, R.transduce
* @example
*
* var lessThan0 = R.flip(R.lt)(0);
* var lessThan2 = R.flip(R.lt)(2);
* R.any(lessThan0)([1, 2]); //=> false
* R.any(lessThan2)([1, 2]); //=> true
*/
module.exports = _curry2(_dispatchable(['any'], _xany, function any(fn, list) {
var idx = 0;
while (idx < list.length) {
if (fn(list[idx])) {
return true;
}
idx += 1;
}
return false;
}));
/***/ },
/* 108 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _reduced = __webpack_require__(88);
var _xfBase = __webpack_require__(89);
module.exports = (function() {
function XAny(f, xf) {
this.xf = xf;
this.f = f;
this.any = false;
}
XAny.prototype['@@transducer/init'] = _xfBase.init;
XAny.prototype['@@transducer/result'] = function(result) {
if (!this.any) {
result = this.xf['@@transducer/step'](result, false);
}
return this.xf['@@transducer/result'](result);
};
XAny.prototype['@@transducer/step'] = function(result, input) {
if (this.f(input)) {
this.any = true;
result = _reduced(this.xf['@@transducer/step'](result, true));
}
return result;
};
return _curry2(function _xany(f, xf) { return new XAny(f, xf); });
}());
/***/ },
/* 109 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var curryN = __webpack_require__(78);
var max = __webpack_require__(91);
var pluck = __webpack_require__(92);
var reduce = __webpack_require__(105);
/**
* Takes a list of predicates and returns a predicate that returns true for a
* given list of arguments if at least one of the provided predicates is
* satisfied by those arguments.
*
* The function returned is a curried function whose arity matches that of the
* highest-arity predicate.
*
* @func
* @memberOf R
* @since v0.9.0
* @category Logic
* @sig [(*... -> Boolean)] -> (*... -> Boolean)
* @param {Array} predicates An array of predicates to check
* @return {Function} The combined predicate
* @see R.allPass
* @example
*
* var isClub = R.propEq('suit', '♣');
* var isSpade = R.propEq('suit', '♠');
* var isBlackCard = R.anyPass([isClub, isSpade]);
*
* isBlackCard({rank: '10', suit: '♣'}); //=> true
* isBlackCard({rank: 'Q', suit: '♠'}); //=> true
* isBlackCard({rank: 'Q', suit: '♦'}); //=> false
*/
module.exports = _curry1(function anyPass(preds) {
return curryN(reduce(max, 0, pluck('length', preds)), function() {
var idx = 0;
var len = preds.length;
while (idx < len) {
if (preds[idx].apply(this, arguments)) {
return true;
}
idx += 1;
}
return false;
});
});
/***/ },
/* 110 */
/***/ function(module, exports, __webpack_require__) {
var _concat = __webpack_require__(77);
var _curry2 = __webpack_require__(75);
var _reduce = __webpack_require__(95);
var map = __webpack_require__(93);
/**
* ap applies a list of functions to a list of values.
*
* Dispatches to the `ap` method of the second argument, if present. Also
* treats curried functions as applicatives.
*
* @func
* @memberOf R
* @since v0.3.0
* @category Function
* @sig [a -> b] -> [a] -> [b]
* @sig Apply f => f (a -> b) -> f a -> f b
* @param {Array} fns An array of functions
* @param {Array} vs An array of values
* @return {Array} An array of results of applying each of `fns` to all of `vs` in turn.
* @example
*
* R.ap([R.multiply(2), R.add(3)], [1,2,3]); //=> [2, 4, 6, 4, 5, 6]
* R.ap([R.concat('tasty '), R.toUpper], ['pizza', 'salad']); //=> ["tasty pizza", "tasty salad", "PIZZA", "SALAD"]
* @symb R.ap([f, g], [a, b]) = [f(a), f(b), g(a), g(b)]
*/
module.exports = _curry2(function ap(applicative, fn) {
return (
typeof applicative.ap === 'function' ?
applicative.ap(fn) :
typeof applicative === 'function' ?
function(x) { return applicative(x)(fn(x)); } :
// else
_reduce(function(acc, f) { return _concat(acc, map(f, fn)); }, [], applicative)
);
});
/***/ },
/* 111 */
/***/ function(module, exports, __webpack_require__) {
var _aperture = __webpack_require__(112);
var _curry2 = __webpack_require__(75);
var _dispatchable = __webpack_require__(84);
var _xaperture = __webpack_require__(113);
/**
* Returns a new list, composed of n-tuples of consecutive elements If `n` is
* greater than the length of the list, an empty list is returned.
*
* Acts as a transducer if a transformer is given in list position.
*
* @func
* @memberOf R
* @since v0.12.0
* @category List
* @sig Number -> [a] -> [[a]]
* @param {Number} n The size of the tuples to create
* @param {Array} list The list to split into `n`-length tuples
* @return {Array} The resulting list of `n`-length tuples
* @see R.transduce
* @example
*
* R.aperture(2, [1, 2, 3, 4, 5]); //=> [[1, 2], [2, 3], [3, 4], [4, 5]]
* R.aperture(3, [1, 2, 3, 4, 5]); //=> [[1, 2, 3], [2, 3, 4], [3, 4, 5]]
* R.aperture(7, [1, 2, 3, 4, 5]); //=> []
*/
module.exports = _curry2(_dispatchable([], _xaperture, _aperture));
/***/ },
/* 112 */
/***/ function(module, exports) {
module.exports = function _aperture(n, list) {
var idx = 0;
var limit = list.length - (n - 1);
var acc = new Array(limit >= 0 ? limit : 0);
while (idx < limit) {
acc[idx] = Array.prototype.slice.call(list, idx, idx + n);
idx += 1;
}
return acc;
};
/***/ },
/* 113 */
/***/ function(module, exports, __webpack_require__) {
var _concat = __webpack_require__(77);
var _curry2 = __webpack_require__(75);
var _xfBase = __webpack_require__(89);
module.exports = (function() {
function XAperture(n, xf) {
this.xf = xf;
this.pos = 0;
this.full = false;
this.acc = new Array(n);
}
XAperture.prototype['@@transducer/init'] = _xfBase.init;
XAperture.prototype['@@transducer/result'] = function(result) {
this.acc = null;
return this.xf['@@transducer/result'](result);
};
XAperture.prototype['@@transducer/step'] = function(result, input) {
this.store(input);
return this.full ? this.xf['@@transducer/step'](result, this.getCopy()) : result;
};
XAperture.prototype.store = function(input) {
this.acc[this.pos] = input;
this.pos += 1;
if (this.pos === this.acc.length) {
this.pos = 0;
this.full = true;
}
};
XAperture.prototype.getCopy = function() {
return _concat(Array.prototype.slice.call(this.acc, this.pos),
Array.prototype.slice.call(this.acc, 0, this.pos));
};
return _curry2(function _xaperture(n, xf) { return new XAperture(n, xf); });
}());
/***/ },
/* 114 */
/***/ function(module, exports, __webpack_require__) {
var _concat = __webpack_require__(77);
var _curry2 = __webpack_require__(75);
/**
* Returns a new list containing the contents of the given list, followed by
* the given element.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig a -> [a] -> [a]
* @param {*} el The element to add to the end of the new list.
* @param {Array} list The list of elements to add a new item to.
* list.
* @return {Array} A new list containing the elements of the old list followed by `el`.
* @see R.prepend
* @example
*
* R.append('tests', ['write', 'more']); //=> ['write', 'more', 'tests']
* R.append('tests', []); //=> ['tests']
* R.append(['tests'], ['write', 'more']); //=> ['write', 'more', ['tests']]
*/
module.exports = _curry2(function append(el, list) {
return _concat(list, [el]);
});
/***/ },
/* 115 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Applies function `fn` to the argument list `args`. This is useful for
* creating a fixed-arity function from a variadic function. `fn` should be a
* bound function if context is significant.
*
* @func
* @memberOf R
* @since v0.7.0
* @category Function
* @sig (*... -> a) -> [*] -> a
* @param {Function} fn The function which will be called with `args`
* @param {Array} args The arguments to call `fn` with
* @return {*} result The result, equivalent to `fn(...args)`
* @see R.call, R.unapply
* @example
*
* var nums = [1, 2, 3, -99, 42, 6, 7];
* R.apply(Math.max, nums); //=> 42
* @symb R.apply(f, [a, b, c]) = f(a, b, c)
*/
module.exports = _curry2(function apply(fn, args) {
return fn.apply(this, args);
});
/***/ },
/* 116 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var apply = __webpack_require__(115);
var curryN = __webpack_require__(78);
var map = __webpack_require__(93);
var max = __webpack_require__(91);
var pluck = __webpack_require__(92);
var reduce = __webpack_require__(105);
var values = __webpack_require__(117);
/**
* Given a spec object recursively mapping properties to functions, creates a
* function producing an object of the same structure, by mapping each property
* to the result of calling its associated function with the supplied arguments.
*
* @func
* @memberOf R
* @since v0.20.0
* @category Function
* @sig {k: ((a, b, ..., m) -> v)} -> ((a, b, ..., m) -> {k: v})
* @param {Object} spec an object recursively mapping properties to functions for
* producing the values for these properties.
* @return {Function} A function that returns an object of the same structure
* as `spec', with each property set to the value returned by calling its
* associated function with the supplied arguments.
* @see R.converge, R.juxt
* @example
*
* var getMetrics = R.applySpec({
* sum: R.add,
* nested: { mul: R.multiply }
* });
* getMetrics(2, 4); // => { sum: 6, nested: { mul: 8 } }
* @symb R.applySpec({ x: f, y: { z: g } })(a, b) = { x: f(a, b), y: { z: g(a, b) } }
*/
module.exports = _curry1(function applySpec(spec) {
spec = map(function(v) { return typeof v == 'function' ? v : applySpec(v); },
spec);
return curryN(reduce(max, 0, pluck('length', values(spec))),
function() {
var args = arguments;
return map(function(f) { return apply(f, args); }, spec);
});
});
/***/ },
/* 117 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var keys = __webpack_require__(101);
/**
* Returns a list of all the enumerable own properties of the supplied object.
* Note that the order of the output array is not guaranteed across different
* JS platforms.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Object
* @sig {k: v} -> [v]
* @param {Object} obj The object to extract values from
* @return {Array} An array of the values of the object's own properties.
* @example
*
* R.values({a: 1, b: 2, c: 3}); //=> [1, 2, 3]
*/
module.exports = _curry1(function values(obj) {
var props = keys(obj);
var len = props.length;
var vals = [];
var idx = 0;
while (idx < len) {
vals[idx] = obj[props[idx]];
idx += 1;
}
return vals;
});
/***/ },
/* 118 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* Makes an ascending comparator function out of a function that returns a value
* that can be compared with `<` and `>`.
*
* @func
* @memberOf R
* @since v0.23.0
* @category Function
* @sig Ord b => (a -> b) -> a -> a -> Number
* @param {Function} fn A function of arity one that returns a value that can be compared
* @param {*} a The first item to be compared.
* @param {*} b The second item to be compared.
* @return {Number} `-1` if fn(a) < fn(b), `1` if fn(b) < fn(a), otherwise `0`
* @example
*
* var byAge = R.ascend(R.prop('age'));
* var people = [
* // ...
* ];
* var peopleByYoungestFirst = R.sort(byAge, people);
*/
module.exports = _curry3(function ascend(fn, a, b) {
var aa = fn(a);
var bb = fn(b);
return aa < bb ? -1 : aa > bb ? 1 : 0;
});
/***/ },
/* 119 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* Makes a shallow clone of an object, setting or overriding the specified
* property with the given value. Note that this copies and flattens prototype
* properties onto the new object as well. All non-primitive properties are
* copied by reference.
*
* @func
* @memberOf R
* @since v0.8.0
* @category Object
* @sig String -> a -> {k: v} -> {k: v}
* @param {String} prop The property name to set
* @param {*} val The new value
* @param {Object} obj The object to clone
* @return {Object} A new object equivalent to the original except for the changed property.
* @see R.dissoc
* @example
*
* R.assoc('c', 3, {a: 1, b: 2}); //=> {a: 1, b: 2, c: 3}
*/
module.exports = _curry3(function assoc(prop, val, obj) {
var result = {};
for (var p in obj) {
result[p] = obj[p];
}
result[prop] = val;
return result;
});
/***/ },
/* 120 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
var _has = __webpack_require__(102);
var _isArray = __webpack_require__(85);
var _isInteger = __webpack_require__(121);
var assoc = __webpack_require__(119);
/**
* Makes a shallow clone of an object, setting or overriding the nodes required
* to create the given path, and placing the specific value at the tail end of
* that path. Note that this copies and flattens prototype properties onto the
* new object as well. All non-primitive properties are copied by reference.
*
* @func
* @memberOf R
* @since v0.8.0
* @category Object
* @typedefn Idx = String | Int
* @sig [Idx] -> a -> {a} -> {a}
* @param {Array} path the path to set
* @param {*} val The new value
* @param {Object} obj The object to clone
* @return {Object} A new object equivalent to the original except along the specified path.
* @see R.dissocPath
* @example
*
* R.assocPath(['a', 'b', 'c'], 42, {a: {b: {c: 0}}}); //=> {a: {b: {c: 42}}}
*
* // Any missing or non-object keys in path will be overridden
* R.assocPath(['a', 'b', 'c'], 42, {a: 5}); //=> {a: {b: {c: 42}}}
*/
module.exports = _curry3(function assocPath(path, val, obj) {
if (path.length === 0) {
return val;
}
var idx = path[0];
if (path.length > 1) {
var nextObj = _has(idx, obj) ? obj[idx] : _isInteger(path[1]) ? [] : {};
val = assocPath(Array.prototype.slice.call(path, 1), val, nextObj);
}
if (_isInteger(idx) && _isArray(obj)) {
var arr = [].concat(obj);
arr[idx] = val;
return arr;
} else {
return assoc(idx, val, obj);
}
});
/***/ },
/* 121 */
/***/ function(module, exports) {
/**
* Determine if the passed argument is an integer.
*
* @private
* @param {*} n
* @category Type
* @return {Boolean}
*/
module.exports = Number.isInteger || function _isInteger(n) {
return (n << 0) === n;
};
/***/ },
/* 122 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var nAry = __webpack_require__(123);
/**
* Wraps a function of any arity (including nullary) in a function that accepts
* exactly 2 parameters. Any extraneous parameters will not be passed to the
* supplied function.
*
* @func
* @memberOf R
* @since v0.2.0
* @category Function
* @sig (* -> c) -> (a, b -> c)
* @param {Function} fn The function to wrap.
* @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of
* arity 2.
* @example
*
* var takesThreeArgs = function(a, b, c) {
* return [a, b, c];
* };
* takesThreeArgs.length; //=> 3
* takesThreeArgs(1, 2, 3); //=> [1, 2, 3]
*
* var takesTwoArgs = R.binary(takesThreeArgs);
* takesTwoArgs.length; //=> 2
* // Only 2 arguments are passed to the wrapped function
* takesTwoArgs(1, 2, 3); //=> [1, 2, undefined]
* @symb R.binary(f)(a, b, c) = f(a, b)
*/
module.exports = _curry1(function binary(fn) {
return nAry(2, fn);
});
/***/ },
/* 123 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Wraps a function of any arity (including nullary) in a function that accepts
* exactly `n` parameters. Any extraneous parameters will not be passed to the
* supplied function.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Function
* @sig Number -> (* -> a) -> (* -> a)
* @param {Number} n The desired arity of the new function.
* @param {Function} fn The function to wrap.
* @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of
* arity `n`.
* @example
*
* var takesTwoArgs = (a, b) => [a, b];
*
* takesTwoArgs.length; //=> 2
* takesTwoArgs(1, 2); //=> [1, 2]
*
* var takesOneArg = R.nAry(1, takesTwoArgs);
* takesOneArg.length; //=> 1
* // Only `n` arguments are passed to the wrapped function
* takesOneArg(1, 2); //=> [1, undefined]
* @symb R.nAry(0, f)(a, b) = f()
* @symb R.nAry(1, f)(a, b) = f(a)
* @symb R.nAry(2, f)(a, b) = f(a, b)
*/
module.exports = _curry2(function nAry(n, fn) {
switch (n) {
case 0: return function() {return fn.call(this);};
case 1: return function(a0) {return fn.call(this, a0);};
case 2: return function(a0, a1) {return fn.call(this, a0, a1);};
case 3: return function(a0, a1, a2) {return fn.call(this, a0, a1, a2);};
case 4: return function(a0, a1, a2, a3) {return fn.call(this, a0, a1, a2, a3);};
case 5: return function(a0, a1, a2, a3, a4) {return fn.call(this, a0, a1, a2, a3, a4);};
case 6: return function(a0, a1, a2, a3, a4, a5) {return fn.call(this, a0, a1, a2, a3, a4, a5);};
case 7: return function(a0, a1, a2, a3, a4, a5, a6) {return fn.call(this, a0, a1, a2, a3, a4, a5, a6);};
case 8: return function(a0, a1, a2, a3, a4, a5, a6, a7) {return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7);};
case 9: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8) {return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8);};
case 10: return function(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) {return fn.call(this, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);};
default: throw new Error('First argument to nAry must be a non-negative integer no greater than ten');
}
});
/***/ },
/* 124 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _isFunction = __webpack_require__(125);
var and = __webpack_require__(106);
var lift = __webpack_require__(126);
/**
* A function which calls the two provided functions and returns the `&&`
* of the results.
* It returns the result of the first function if it is false-y and the result
* of the second function otherwise. Note that this is short-circuited,
* meaning that the second function will not be invoked if the first returns a
* false-y value.
*
* In addition to functions, `R.both` also accepts any fantasy-land compatible
* applicative functor.
*
* @func
* @memberOf R
* @since v0.12.0
* @category Logic
* @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)
* @param {Function} f A predicate
* @param {Function} g Another predicate
* @return {Function} a function that applies its arguments to `f` and `g` and `&&`s their outputs together.
* @see R.and
* @example
*
* var gt10 = R.gt(R.__, 10)
* var lt20 = R.lt(R.__, 20)
* var f = R.both(gt10, lt20);
* f(15); //=> true
* f(30); //=> false
*/
module.exports = _curry2(function both(f, g) {
return _isFunction(f) ?
function _both() {
return f.apply(this, arguments) && g.apply(this, arguments);
} :
lift(and)(f, g);
});
/***/ },
/* 125 */
/***/ function(module, exports) {
module.exports = function _isFunction(x) {
return Object.prototype.toString.call(x) === '[object Function]';
};
/***/ },
/* 126 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var liftN = __webpack_require__(127);
/**
* "lifts" a function of arity > 1 so that it may "map over" a list, Function or other
* object that satisfies the [FantasyLand Apply spec](https://github.com/fantasyland/fantasy-land#apply).
*
* @func
* @memberOf R
* @since v0.7.0
* @category Function
* @sig (*... -> *) -> ([*]... -> [*])
* @param {Function} fn The function to lift into higher context
* @return {Function} The lifted function.
* @see R.liftN
* @example
*
* var madd3 = R.lift((a, b, c) => a + b + c);
*
* madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]
*
* var madd5 = R.lift((a, b, c, d, e) => a + b + c + d + e);
*
* madd5([1,2], [3], [4, 5], [6], [7, 8]); //=> [21, 22, 22, 23, 22, 23, 23, 24]
*/
module.exports = _curry1(function lift(fn) {
return liftN(fn.length, fn);
});
/***/ },
/* 127 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _reduce = __webpack_require__(95);
var ap = __webpack_require__(110);
var curryN = __webpack_require__(78);
var map = __webpack_require__(93);
/**
* "lifts" a function to be the specified arity, so that it may "map over" that
* many lists, Functions or other objects that satisfy the [FantasyLand Apply spec](https://github.com/fantasyland/fantasy-land#apply).
*
* @func
* @memberOf R
* @since v0.7.0
* @category Function
* @sig Number -> (*... -> *) -> ([*]... -> [*])
* @param {Function} fn The function to lift into higher context
* @return {Function} The lifted function.
* @see R.lift, R.ap
* @example
*
* var madd3 = R.liftN(3, (...args) => R.sum(args));
* madd3([1,2,3], [1,2,3], [1]); //=> [3, 4, 5, 4, 5, 6, 5, 6, 7]
*/
module.exports = _curry2(function liftN(arity, fn) {
var lifted = curryN(arity, fn);
return curryN(arity, function() {
return _reduce(ap, map(lifted, arguments[0]), Array.prototype.slice.call(arguments, 1));
});
});
/***/ },
/* 128 */
/***/ function(module, exports, __webpack_require__) {
var curry = __webpack_require__(129);
/**
* Returns the result of calling its first argument with the remaining
* arguments. This is occasionally useful as a converging function for
* `R.converge`: the left branch can produce a function while the right branch
* produces a value to be passed to that function as an argument.
*
* @func
* @memberOf R
* @since v0.9.0
* @category Function
* @sig (*... -> a),*... -> a
* @param {Function} fn The function to apply to the remaining arguments.
* @param {...*} args Any number of positional arguments.
* @return {*}
* @see R.apply
* @example
*
* R.call(R.add, 1, 2); //=> 3
*
* var indentN = R.pipe(R.times(R.always(' ')),
* R.join(''),
* R.replace(/^(?!$)/gm));
*
* var format = R.converge(R.call, [
* R.pipe(R.prop('indent'), indentN),
* R.prop('value')
* ]);
*
* format({indent: 2, value: 'foo\nbar\nbaz\n'}); //=> ' foo\n bar\n baz\n'
* @symb R.call(f, a, b) = f(a, b)
*/
module.exports = curry(function call(fn) {
return fn.apply(this, Array.prototype.slice.call(arguments, 1));
});
/***/ },
/* 129 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var curryN = __webpack_require__(78);
/**
* Returns a curried equivalent of the provided function. The curried function
* has two unusual capabilities. First, its arguments needn't be provided one
* at a time. If `f` is a ternary function and `g` is `R.curry(f)`, the
* following are equivalent:
*
* - `g(1)(2)(3)`
* - `g(1)(2, 3)`
* - `g(1, 2)(3)`
* - `g(1, 2, 3)`
*
* Secondly, the special placeholder value `R.__` may be used to specify
* "gaps", allowing partial application of any combination of arguments,
* regardless of their positions. If `g` is as above and `_` is `R.__`, the
* following are equivalent:
*
* - `g(1, 2, 3)`
* - `g(_, 2, 3)(1)`
* - `g(_, _, 3)(1)(2)`
* - `g(_, _, 3)(1, 2)`
* - `g(_, 2)(1)(3)`
* - `g(_, 2)(1, 3)`
* - `g(_, 2)(_, 3)(1)`
*
* @func
* @memberOf R
* @since v0.1.0
* @category Function
* @sig (* -> a) -> (* -> a)
* @param {Function} fn The function to curry.
* @return {Function} A new, curried function.
* @see R.curryN
* @example
*
* var addFourNumbers = (a, b, c, d) => a + b + c + d;
*
* var curriedAddFourNumbers = R.curry(addFourNumbers);
* var f = curriedAddFourNumbers(1, 2);
* var g = f(3);
* g(4); //=> 10
*/
module.exports = _curry1(function curry(fn) {
return curryN(fn.length, fn);
});
/***/ },
/* 130 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _dispatchable = __webpack_require__(84);
var _makeFlat = __webpack_require__(131);
var _xchain = __webpack_require__(132);
var map = __webpack_require__(93);
/**
* `chain` maps a function over a list and concatenates the results. `chain`
* is also known as `flatMap` in some libraries
*
* Dispatches to the `chain` method of the second argument, if present,
* according to the [FantasyLand Chain spec](https://github.com/fantasyland/fantasy-land#chain).
*
* @func
* @memberOf R
* @since v0.3.0
* @category List
* @sig Chain m => (a -> m b) -> m a -> m b
* @param {Function} fn The function to map with
* @param {Array} list The list to map over
* @return {Array} The result of flat-mapping `list` with `fn`
* @example
*
* var duplicate = n => [n, n];
* R.chain(duplicate, [1, 2, 3]); //=> [1, 1, 2, 2, 3, 3]
*
* R.chain(R.append, R.head)([1, 2, 3]); //=> [1, 2, 3, 1]
*/
module.exports = _curry2(_dispatchable(['chain'], _xchain, function chain(fn, monad) {
if (typeof monad === 'function') {
return function(x) { return fn(monad(x))(x); };
}
return _makeFlat(false)(map(fn, monad));
}));
/***/ },
/* 131 */
/***/ function(module, exports, __webpack_require__) {
var isArrayLike = __webpack_require__(98);
/**
* `_makeFlat` is a helper function that returns a one-level or fully recursive
* function based on the flag passed in.
*
* @private
*/
module.exports = function _makeFlat(recursive) {
return function flatt(list) {
var value, jlen, j;
var result = [];
var idx = 0;
var ilen = list.length;
while (idx < ilen) {
if (isArrayLike(list[idx])) {
value = recursive ? flatt(list[idx]) : list[idx];
j = 0;
jlen = value.length;
while (j < jlen) {
result[result.length] = value[j];
j += 1;
}
} else {
result[result.length] = list[idx];
}
idx += 1;
}
return result;
};
};
/***/ },
/* 132 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _flatCat = __webpack_require__(133);
var map = __webpack_require__(93);
module.exports = _curry2(function _xchain(f, xf) {
return map(f, _flatCat(xf));
});
/***/ },
/* 133 */
/***/ function(module, exports, __webpack_require__) {
var _forceReduced = __webpack_require__(134);
var _reduce = __webpack_require__(95);
var _xfBase = __webpack_require__(89);
var isArrayLike = __webpack_require__(98);
module.exports = (function() {
var preservingReduced = function(xf) {
return {
'@@transducer/init': _xfBase.init,
'@@transducer/result': function(result) {
return xf['@@transducer/result'](result);
},
'@@transducer/step': function(result, input) {
var ret = xf['@@transducer/step'](result, input);
return ret['@@transducer/reduced'] ? _forceReduced(ret) : ret;
}
};
};
return function _xcat(xf) {
var rxf = preservingReduced(xf);
return {
'@@transducer/init': _xfBase.init,
'@@transducer/result': function(result) {
return rxf['@@transducer/result'](result);
},
'@@transducer/step': function(result, input) {
return !isArrayLike(input) ? _reduce(rxf, result, [input]) : _reduce(rxf, result, input);
}
};
};
}());
/***/ },
/* 134 */
/***/ function(module, exports) {
module.exports = function _forceReduced(x) {
return {
'@@transducer/value': x,
'@@transducer/reduced': true
};
};
/***/ },
/* 135 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* Restricts a number to be within a range.
*
* Also works for other ordered types such as Strings and Dates.
*
* @func
* @memberOf R
* @since v0.20.0
* @category Relation
* @sig Ord a => a -> a -> a -> a
* @param {Number} minimum The lower limit of the clamp (inclusive)
* @param {Number} maximum The upper limit of the clamp (inclusive)
* @param {Number} value Value to be clamped
* @return {Number} Returns `minimum` when `val < minimum`, `maximum` when `val > maximum`, returns `val` otherwise
* @example
*
* R.clamp(1, 10, -5) // => 1
* R.clamp(1, 10, 15) // => 10
* R.clamp(1, 10, 4) // => 4
*/
module.exports = _curry3(function clamp(min, max, value) {
if (min > max) {
throw new Error('min must not be greater than max in clamp(min, max, value)');
}
return value < min ? min :
value > max ? max :
value;
});
/***/ },
/* 136 */
/***/ function(module, exports, __webpack_require__) {
var _clone = __webpack_require__(137);
var _curry1 = __webpack_require__(70);
/**
* Creates a deep copy of the value which may contain (nested) `Array`s and
* `Object`s, `Number`s, `String`s, `Boolean`s and `Date`s. `Function`s are
* assigned by reference rather than copied
*
* Dispatches to a `clone` method if present.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Object
* @sig {*} -> {*}
* @param {*} value The object or array to clone
* @return {*} A deeply cloned copy of `val`
* @example
*
* var objects = [{}, {}, {}];
* var objectsClone = R.clone(objects);
* objects === objectsClone; //=> false
* objects[0] === objectsClone[0]; //=> false
*/
module.exports = _curry1(function clone(value) {
return value != null && typeof value.clone === 'function' ?
value.clone() :
_clone(value, [], [], true);
});
/***/ },
/* 137 */
/***/ function(module, exports, __webpack_require__) {
var _cloneRegExp = __webpack_require__(138);
var type = __webpack_require__(139);
/**
* Copies an object.
*
* @private
* @param {*} value The value to be copied
* @param {Array} refFrom Array containing the source references
* @param {Array} refTo Array containing the copied source references
* @param {Boolean} deep Whether or not to perform deep cloning.
* @return {*} The copied value.
*/
module.exports = function _clone(value, refFrom, refTo, deep) {
var copy = function copy(copiedValue) {
var len = refFrom.length;
var idx = 0;
while (idx < len) {
if (value === refFrom[idx]) {
return refTo[idx];
}
idx += 1;
}
refFrom[idx + 1] = value;
refTo[idx + 1] = copiedValue;
for (var key in value) {
copiedValue[key] = deep ?
_clone(value[key], refFrom, refTo, true) : value[key];
}
return copiedValue;
};
switch (type(value)) {
case 'Object': return copy({});
case 'Array': return copy([]);
case 'Date': return new Date(value.valueOf());
case 'RegExp': return _cloneRegExp(value);
default: return value;
}
};
/***/ },
/* 138 */
/***/ function(module, exports) {
module.exports = function _cloneRegExp(pattern) {
return new RegExp(pattern.source, (pattern.global ? 'g' : '') +
(pattern.ignoreCase ? 'i' : '') +
(pattern.multiline ? 'm' : '') +
(pattern.sticky ? 'y' : '') +
(pattern.unicode ? 'u' : ''));
};
/***/ },
/* 139 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
/**
* Gives a single-word string description of the (native) type of a value,
* returning such answers as 'Object', 'Number', 'Array', or 'Null'. Does not
* attempt to distinguish user Object types any further, reporting them all as
* 'Object'.
*
* @func
* @memberOf R
* @since v0.8.0
* @category Type
* @sig (* -> {*}) -> String
* @param {*} val The value to test
* @return {String}
* @example
*
* R.type({}); //=> "Object"
* R.type(1); //=> "Number"
* R.type(false); //=> "Boolean"
* R.type('s'); //=> "String"
* R.type(null); //=> "Null"
* R.type([]); //=> "Array"
* R.type(/[A-z]/); //=> "RegExp"
*/
module.exports = _curry1(function type(val) {
return val === null ? 'Null' :
val === undefined ? 'Undefined' :
Object.prototype.toString.call(val).slice(8, -1);
});
/***/ },
/* 140 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
/**
* Makes a comparator function out of a function that reports whether the first
* element is less than the second.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Function
* @sig (a, b -> Boolean) -> (a, b -> Number)
* @param {Function} pred A predicate function of arity two which will return `true` if the first argument
* is less than the second, `false` otherwise
* @return {Function} A Function :: a -> b -> Int that returns `-1` if a < b, `1` if b < a, otherwise `0`
* @example
*
* var byAge = R.comparator((a, b) => a.age < b.age);
* var people = [
* // ...
* ];
* var peopleByIncreasingAge = R.sort(byAge, people);
*/
module.exports = _curry1(function comparator(pred) {
return function(a, b) {
return pred(a, b) ? -1 : pred(b, a) ? 1 : 0;
};
});
/***/ },
/* 141 */
/***/ function(module, exports, __webpack_require__) {
var lift = __webpack_require__(126);
var not = __webpack_require__(142);
/**
* Takes a function `f` and returns a function `g` such that if called with the same arguments
* when `f` returns a "truthy" value, `g` returns `false` and when `f` returns a "falsy" value `g` returns `true`.
*
* `R.complement` may be applied to any functor
*
* @func
* @memberOf R
* @since v0.12.0
* @category Logic
* @sig (*... -> *) -> (*... -> Boolean)
* @param {Function} f
* @return {Function}
* @see R.not
* @example
*
* var isNotNil = R.complement(R.isNil);
* isNil(null); //=> true
* isNotNil(null); //=> false
* isNil(7); //=> false
* isNotNil(7); //=> true
*/
module.exports = lift(not);
/***/ },
/* 142 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
/**
* A function that returns the `!` of its argument. It will return `true` when
* passed false-y value, and `false` when passed a truth-y one.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Logic
* @sig * -> Boolean
* @param {*} a any value
* @return {Boolean} the logical inverse of passed argument.
* @see R.complement
* @example
*
* R.not(true); //=> false
* R.not(false); //=> true
* R.not(0); //=> true
* R.not(1); //=> false
*/
module.exports = _curry1(function not(a) {
return !a;
});
/***/ },
/* 143 */
/***/ function(module, exports, __webpack_require__) {
var pipe = __webpack_require__(144);
var reverse = __webpack_require__(149);
/**
* Performs right-to-left function composition. The rightmost function may have
* any arity; the remaining functions must be unary.
*
* **Note:** The result of compose is not automatically curried.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Function
* @sig ((y -> z), (x -> y), ..., (o -> p), ((a, b, ..., n) -> o)) -> ((a, b, ..., n) -> z)
* @param {...Function} ...functions The functions to compose
* @return {Function}
* @see R.pipe
* @example
*
* var classyGreeting = (firstName, lastName) => "The name's " + lastName + ", " + firstName + " " + lastName
* var yellGreeting = R.compose(R.toUpper, classyGreeting);
* yellGreeting('James', 'Bond'); //=> "THE NAME'S BOND, JAMES BOND"
*
* R.compose(Math.abs, R.add(1), R.multiply(2))(-4) //=> 7
*
* @symb R.compose(f, g, h)(a, b) = f(g(h(a, b)))
*/
module.exports = function compose() {
if (arguments.length === 0) {
throw new Error('compose requires at least one argument');
}
return pipe.apply(this, reverse(arguments));
};
/***/ },
/* 144 */
/***/ function(module, exports, __webpack_require__) {
var _arity = __webpack_require__(79);
var _pipe = __webpack_require__(145);
var reduce = __webpack_require__(105);
var tail = __webpack_require__(146);
/**
* Performs left-to-right function composition. The leftmost function may have
* any arity; the remaining functions must be unary.
*
* In some libraries this function is named `sequence`.
*
* **Note:** The result of pipe is not automatically curried.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Function
* @sig (((a, b, ..., n) -> o), (o -> p), ..., (x -> y), (y -> z)) -> ((a, b, ..., n) -> z)
* @param {...Function} functions
* @return {Function}
* @see R.compose
* @example
*
* var f = R.pipe(Math.pow, R.negate, R.inc);
*
* f(3, 4); // -(3^4) + 1
* @symb R.pipe(f, g, h)(a, b) = h(g(f(a, b)))
*/
module.exports = function pipe() {
if (arguments.length === 0) {
throw new Error('pipe requires at least one argument');
}
return _arity(arguments[0].length,
reduce(_pipe, arguments[0], tail(arguments)));
};
/***/ },
/* 145 */
/***/ function(module, exports) {
module.exports = function _pipe(f, g) {
return function() {
return g.call(this, f.apply(this, arguments));
};
};
/***/ },
/* 146 */
/***/ function(module, exports, __webpack_require__) {
var _checkForMethod = __webpack_require__(147);
var _curry1 = __webpack_require__(70);
var slice = __webpack_require__(148);
/**
* Returns all but the first element of the given list or string (or object
* with a `tail` method).
*
* Dispatches to the `slice` method of the first argument, if present.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig [a] -> [a]
* @sig String -> String
* @param {*} list
* @return {*}
* @see R.head, R.init, R.last
* @example
*
* R.tail([1, 2, 3]); //=> [2, 3]
* R.tail([1, 2]); //=> [2]
* R.tail([1]); //=> []
* R.tail([]); //=> []
*
* R.tail('abc'); //=> 'bc'
* R.tail('ab'); //=> 'b'
* R.tail('a'); //=> ''
* R.tail(''); //=> ''
*/
module.exports = _curry1(_checkForMethod('tail', slice(1, Infinity)));
/***/ },
/* 147 */
/***/ function(module, exports, __webpack_require__) {
var _isArray = __webpack_require__(85);
/**
* This checks whether a function has a [methodname] function. If it isn't an
* array it will execute that function otherwise it will default to the ramda
* implementation.
*
* @private
* @param {Function} fn ramda implemtation
* @param {String} methodname property to check for a custom implementation
* @return {Object} Whatever the return value of the method is.
*/
module.exports = function _checkForMethod(methodname, fn) {
return function() {
var length = arguments.length;
if (length === 0) {
return fn();
}
var obj = arguments[length - 1];
return (_isArray(obj) || typeof obj[methodname] !== 'function') ?
fn.apply(this, arguments) :
obj[methodname].apply(obj, Array.prototype.slice.call(arguments, 0, length - 1));
};
};
/***/ },
/* 148 */
/***/ function(module, exports, __webpack_require__) {
var _checkForMethod = __webpack_require__(147);
var _curry3 = __webpack_require__(82);
/**
* Returns the elements of the given list or string (or object with a `slice`
* method) from `fromIndex` (inclusive) to `toIndex` (exclusive).
*
* Dispatches to the `slice` method of the third argument, if present.
*
* @func
* @memberOf R
* @since v0.1.4
* @category List
* @sig Number -> Number -> [a] -> [a]
* @sig Number -> Number -> String -> String
* @param {Number} fromIndex The start index (inclusive).
* @param {Number} toIndex The end index (exclusive).
* @param {*} list
* @return {*}
* @example
*
* R.slice(1, 3, ['a', 'b', 'c', 'd']); //=> ['b', 'c']
* R.slice(1, Infinity, ['a', 'b', 'c', 'd']); //=> ['b', 'c', 'd']
* R.slice(0, -1, ['a', 'b', 'c', 'd']); //=> ['a', 'b', 'c']
* R.slice(-3, -1, ['a', 'b', 'c', 'd']); //=> ['b', 'c']
* R.slice(0, 3, 'ramda'); //=> 'ram'
*/
module.exports = _curry3(_checkForMethod('slice', function slice(fromIndex, toIndex, list) {
return Array.prototype.slice.call(list, fromIndex, toIndex);
}));
/***/ },
/* 149 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var _isString = __webpack_require__(99);
/**
* Returns a new list or string with the elements or characters in reverse
* order.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig [a] -> [a]
* @sig String -> String
* @param {Array|String} list
* @return {Array|String}
* @example
*
* R.reverse([1, 2, 3]); //=> [3, 2, 1]
* R.reverse([1, 2]); //=> [2, 1]
* R.reverse([1]); //=> [1]
* R.reverse([]); //=> []
*
* R.reverse('abc'); //=> 'cba'
* R.reverse('ab'); //=> 'ba'
* R.reverse('a'); //=> 'a'
* R.reverse(''); //=> ''
*/
module.exports = _curry1(function reverse(list) {
return _isString(list) ? list.split('').reverse().join('') :
Array.prototype.slice.call(list, 0).reverse();
});
/***/ },
/* 150 */
/***/ function(module, exports, __webpack_require__) {
var chain = __webpack_require__(130);
var compose = __webpack_require__(143);
var map = __webpack_require__(93);
/**
* Returns the right-to-left Kleisli composition of the provided functions,
* each of which must return a value of a type supported by [`chain`](#chain).
*
* `R.composeK(h, g, f)` is equivalent to `R.compose(R.chain(h), R.chain(g), R.chain(f))`.
*
* @func
* @memberOf R
* @since v0.16.0
* @category Function
* @sig Chain m => ((y -> m z), (x -> m y), ..., (a -> m b)) -> (a -> m z)
* @param {...Function} ...functions The functions to compose
* @return {Function}
* @see R.pipeK
* @example
*
* // get :: String -> Object -> Maybe *
* var get = R.curry((propName, obj) => Maybe(obj[propName]))
*
* // getStateCode :: Maybe String -> Maybe String
* var getStateCode = R.composeK(
* R.compose(Maybe.of, R.toUpper),
* get('state'),
* get('address'),
* get('user'),
* );
* getStateCode({"user":{"address":{"state":"ny"}}}); //=> Maybe.Just("NY")
* getStateCode({}); //=> Maybe.Nothing()
* @symb R.composeK(f, g, h)(a) = R.chain(f, R.chain(g, h(a)))
*/
module.exports = function composeK() {
if (arguments.length === 0) {
throw new Error('composeK requires at least one argument');
}
var init = Array.prototype.slice.call(arguments);
var last = init.pop();
return compose(compose.apply(this, map(chain, init)), last);
};
/***/ },
/* 151 */
/***/ function(module, exports, __webpack_require__) {
var pipeP = __webpack_require__(152);
var reverse = __webpack_require__(149);
/**
* Performs right-to-left composition of one or more Promise-returning
* functions. The rightmost function may have any arity; the remaining
* functions must be unary.
*
* @func
* @memberOf R
* @since v0.10.0
* @category Function
* @sig ((y -> Promise z), (x -> Promise y), ..., (a -> Promise b)) -> (a -> Promise z)
* @param {...Function} functions The functions to compose
* @return {Function}
* @see R.pipeP
* @example
*
* var db = {
* users: {
* JOE: {
* name: 'Joe',
* followers: ['STEVE', 'SUZY']
* }
* }
* }
*
* // We'll pretend to do a db lookup which returns a promise
* var lookupUser = (userId) => Promise.resolve(db.users[userId])
* var lookupFollowers = (user) => Promise.resolve(user.followers)
* lookupUser('JOE').then(lookupFollowers)
*
* // followersForUser :: String -> Promise [UserId]
* var followersForUser = R.composeP(lookupFollowers, lookupUser);
* followersForUser('JOE').then(followers => console.log('Followers:', followers))
* // Followers: ["STEVE","SUZY"]
*/
module.exports = function composeP() {
if (arguments.length === 0) {
throw new Error('composeP requires at least one argument');
}
return pipeP.apply(this, reverse(arguments));
};
/***/ },
/* 152 */
/***/ function(module, exports, __webpack_require__) {
var _arity = __webpack_require__(79);
var _pipeP = __webpack_require__(153);
var reduce = __webpack_require__(105);
var tail = __webpack_require__(146);
/**
* Performs left-to-right composition of one or more Promise-returning
* functions. The leftmost function may have any arity; the remaining functions
* must be unary.
*
* @func
* @memberOf R
* @since v0.10.0
* @category Function
* @sig ((a -> Promise b), (b -> Promise c), ..., (y -> Promise z)) -> (a -> Promise z)
* @param {...Function} functions
* @return {Function}
* @see R.composeP
* @example
*
* // followersForUser :: String -> Promise [User]
* var followersForUser = R.pipeP(db.getUserById, db.getFollowers);
*/
module.exports = function pipeP() {
if (arguments.length === 0) {
throw new Error('pipeP requires at least one argument');
}
return _arity(arguments[0].length,
reduce(_pipeP, arguments[0], tail(arguments)));
};
/***/ },
/* 153 */
/***/ function(module, exports) {
module.exports = function _pipeP(f, g) {
return function() {
var ctx = this;
return f.apply(ctx, arguments).then(function(x) {
return g.call(ctx, x);
});
};
};
/***/ },
/* 154 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _isArray = __webpack_require__(85);
var _isFunction = __webpack_require__(125);
var toString = __webpack_require__(155);
/**
* Returns the result of concatenating the given lists or strings.
*
* Note: `R.concat` expects both arguments to be of the same type,
* unlike the native `Array.prototype.concat` method. It will throw
* an error if you `concat` an Array with a non-Array value.
*
* Dispatches to the `concat` method of the first argument, if present.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig [a] -> [a] -> [a]
* @sig String -> String -> String
* @param {Array|String} firstList The first list
* @param {Array|String} secondList The second list
* @return {Array|String} A list consisting of the elements of `firstList` followed by the elements of
* `secondList`.
*
* @example
*
* R.concat('ABC', 'DEF'); // 'ABCDEF'
* R.concat([4, 5, 6], [1, 2, 3]); //=> [4, 5, 6, 1, 2, 3]
* R.concat([], []); //=> []
*/
module.exports = _curry2(function concat(a, b) {
if (a == null || !_isFunction(a.concat)) {
throw new TypeError(toString(a) + ' does not have a method named "concat"');
}
if (_isArray(a) && !_isArray(b)) {
throw new TypeError(toString(b) + ' is not an array');
}
return a.concat(b);
});
/***/ },
/* 155 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var _toString = __webpack_require__(156);
/**
* Returns the string representation of the given value. `eval`'ing the output
* should result in a value equivalent to the input value. Many of the built-in
* `toString` methods do not satisfy this requirement.
*
* If the given value is an `[object Object]` with a `toString` method other
* than `Object.prototype.toString`, this method is invoked with no arguments
* to produce the return value. This means user-defined constructor functions
* can provide a suitable `toString` method. For example:
*
* function Point(x, y) {
* this.x = x;
* this.y = y;
* }
*
* Point.prototype.toString = function() {
* return 'new Point(' + this.x + ', ' + this.y + ')';
* };
*
* R.toString(new Point(1, 2)); //=> 'new Point(1, 2)'
*
* @func
* @memberOf R
* @since v0.14.0
* @category String
* @sig * -> String
* @param {*} val
* @return {String}
* @example
*
* R.toString(42); //=> '42'
* R.toString('abc'); //=> '"abc"'
* R.toString([1, 2, 3]); //=> '[1, 2, 3]'
* R.toString({foo: 1, bar: 2, baz: 3}); //=> '{"bar": 2, "baz": 3, "foo": 1}'
* R.toString(new Date('2001-02-03T04:05:06Z')); //=> 'new Date("2001-02-03T04:05:06.000Z")'
*/
module.exports = _curry1(function toString(val) { return _toString(val, []); });
/***/ },
/* 156 */
/***/ function(module, exports, __webpack_require__) {
var _contains = __webpack_require__(157);
var _map = __webpack_require__(94);
var _quote = __webpack_require__(164);
var _toISOString = __webpack_require__(165);
var keys = __webpack_require__(101);
var reject = __webpack_require__(166);
module.exports = function _toString(x, seen) {
var recur = function recur(y) {
var xs = seen.concat([x]);
return _contains(y, xs) ? '<Circular>' : _toString(y, xs);
};
// mapPairs :: (Object, [String]) -> [String]
var mapPairs = function(obj, keys) {
return _map(function(k) { return _quote(k) + ': ' + recur(obj[k]); }, keys.slice().sort());
};
switch (Object.prototype.toString.call(x)) {
case '[object Arguments]':
return '(function() { return arguments; }(' + _map(recur, x).join(', ') + '))';
case '[object Array]':
return '[' + _map(recur, x).concat(mapPairs(x, reject(function(k) { return /^\d+$/.test(k); }, keys(x)))).join(', ') + ']';
case '[object Boolean]':
return typeof x === 'object' ? 'new Boolean(' + recur(x.valueOf()) + ')' : x.toString();
case '[object Date]':
return 'new Date(' + (isNaN(x.valueOf()) ? recur(NaN) : _quote(_toISOString(x))) + ')';
case '[object Null]':
return 'null';
case '[object Number]':
return typeof x === 'object' ? 'new Number(' + recur(x.valueOf()) + ')' : 1 / x === -Infinity ? '-0' : x.toString(10);
case '[object String]':
return typeof x === 'object' ? 'new String(' + recur(x.valueOf()) + ')' : _quote(x);
case '[object Undefined]':
return 'undefined';
default:
if (typeof x.toString === 'function') {
var repr = x.toString();
if (repr !== '[object Object]') {
return repr;
}
}
return '{' + mapPairs(x, keys(x)).join(', ') + '}';
}
};
/***/ },
/* 157 */
/***/ function(module, exports, __webpack_require__) {
var _indexOf = __webpack_require__(158);
module.exports = function _contains(a, list) {
return _indexOf(list, a, 0) >= 0;
};
/***/ },
/* 158 */
/***/ function(module, exports, __webpack_require__) {
var equals = __webpack_require__(159);
module.exports = function _indexOf(list, a, idx) {
var inf, item;
// Array.prototype.indexOf doesn't exist below IE9
if (typeof list.indexOf === 'function') {
switch (typeof a) {
case 'number':
if (a === 0) {
// manually crawl the list to distinguish between +0 and -0
inf = 1 / a;
while (idx < list.length) {
item = list[idx];
if (item === 0 && 1 / item === inf) {
return idx;
}
idx += 1;
}
return -1;
} else if (a !== a) {
// NaN
while (idx < list.length) {
item = list[idx];
if (typeof item === 'number' && item !== item) {
return idx;
}
idx += 1;
}
return -1;
}
// non-zero numbers can utilise Set
return list.indexOf(a, idx);
// all these types can utilise Set
case 'string':
case 'boolean':
case 'function':
case 'undefined':
return list.indexOf(a, idx);
case 'object':
if (a === null) {
// null can utilise Set
return list.indexOf(a, idx);
}
}
}
// anything else not covered above, defer to R.equals
while (idx < list.length) {
if (equals(list[idx], a)) {
return idx;
}
idx += 1;
}
return -1;
};
/***/ },
/* 159 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _equals = __webpack_require__(160);
/**
* Returns `true` if its arguments are equivalent, `false` otherwise. Handles
* cyclical data structures.
*
* Dispatches symmetrically to the `equals` methods of both arguments, if
* present.
*
* @func
* @memberOf R
* @since v0.15.0
* @category Relation
* @sig a -> b -> Boolean
* @param {*} a
* @param {*} b
* @return {Boolean}
* @example
*
* R.equals(1, 1); //=> true
* R.equals(1, '1'); //=> false
* R.equals([1, 2, 3], [1, 2, 3]); //=> true
*
* var a = {}; a.v = a;
* var b = {}; b.v = b;
* R.equals(a, b); //=> true
*/
module.exports = _curry2(function equals(a, b) {
return _equals(a, b, [], []);
});
/***/ },
/* 160 */
/***/ function(module, exports, __webpack_require__) {
var _arrayFromIterator = __webpack_require__(161);
var _functionName = __webpack_require__(162);
var _has = __webpack_require__(102);
var identical = __webpack_require__(163);
var keys = __webpack_require__(101);
var type = __webpack_require__(139);
module.exports = function _equals(a, b, stackA, stackB) {
if (identical(a, b)) {
return true;
}
if (type(a) !== type(b)) {
return false;
}
if (a == null || b == null) {
return false;
}
if (typeof a.equals === 'function' || typeof b.equals === 'function') {
return typeof a.equals === 'function' && a.equals(b) &&
typeof b.equals === 'function' && b.equals(a);
}
switch (type(a)) {
case 'Arguments':
case 'Array':
case 'Object':
if (typeof a.constructor === 'function' &&
_functionName(a.constructor) === 'Promise') {
return a === b;
}
break;
case 'Boolean':
case 'Number':
case 'String':
if (!(typeof a === typeof b && identical(a.valueOf(), b.valueOf()))) {
return false;
}
break;
case 'Date':
if (!identical(a.valueOf(), b.valueOf())) {
return false;
}
break;
case 'Error':
return a.name === b.name && a.message === b.message;
case 'RegExp':
if (!(a.source === b.source &&
a.global === b.global &&
a.ignoreCase === b.ignoreCase &&
a.multiline === b.multiline &&
a.sticky === b.sticky &&
a.unicode === b.unicode)) {
return false;
}
break;
case 'Map':
case 'Set':
if (!_equals(_arrayFromIterator(a.entries()), _arrayFromIterator(b.entries()), stackA, stackB)) {
return false;
}
break;
case 'Int8Array':
case 'Uint8Array':
case 'Uint8ClampedArray':
case 'Int16Array':
case 'Uint16Array':
case 'Int32Array':
case 'Uint32Array':
case 'Float32Array':
case 'Float64Array':
break;
case 'ArrayBuffer':
break;
default:
// Values of other types are only equal if identical.
return false;
}
var keysA = keys(a);
if (keysA.length !== keys(b).length) {
return false;
}
var idx = stackA.length - 1;
while (idx >= 0) {
if (stackA[idx] === a) {
return stackB[idx] === b;
}
idx -= 1;
}
stackA.push(a);
stackB.push(b);
idx = keysA.length - 1;
while (idx >= 0) {
var key = keysA[idx];
if (!(_has(key, b) && _equals(b[key], a[key], stackA, stackB))) {
return false;
}
idx -= 1;
}
stackA.pop();
stackB.pop();
return true;
};
/***/ },
/* 161 */
/***/ function(module, exports) {
module.exports = function _arrayFromIterator(iter) {
var list = [];
var next;
while (!(next = iter.next()).done) {
list.push(next.value);
}
return list;
};
/***/ },
/* 162 */
/***/ function(module, exports) {
module.exports = function _functionName(f) {
// String(x => x) evaluates to "x => x", so the pattern may not match.
var match = String(f).match(/^function (\w*)/);
return match == null ? '' : match[1];
};
/***/ },
/* 163 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Returns true if its arguments are identical, false otherwise. Values are
* identical if they reference the same memory. `NaN` is identical to `NaN`;
* `0` and `-0` are not identical.
*
* @func
* @memberOf R
* @since v0.15.0
* @category Relation
* @sig a -> a -> Boolean
* @param {*} a
* @param {*} b
* @return {Boolean}
* @example
*
* var o = {};
* R.identical(o, o); //=> true
* R.identical(1, 1); //=> true
* R.identical(1, '1'); //=> false
* R.identical([], []); //=> false
* R.identical(0, -0); //=> false
* R.identical(NaN, NaN); //=> true
*/
module.exports = _curry2(function identical(a, b) {
// SameValue algorithm
if (a === b) { // Steps 1-5, 7-10
// Steps 6.b-6.e: +0 != -0
return a !== 0 || 1 / a === 1 / b;
} else {
// Step 6.a: NaN == NaN
return a !== a && b !== b;
}
});
/***/ },
/* 164 */
/***/ function(module, exports) {
module.exports = function _quote(s) {
var escaped = s
.replace(/\\/g, '\\\\')
.replace(/[\b]/g, '\\b') // \b matches word boundary; [\b] matches backspace
.replace(/\f/g, '\\f')
.replace(/\n/g, '\\n')
.replace(/\r/g, '\\r')
.replace(/\t/g, '\\t')
.replace(/\v/g, '\\v')
.replace(/\0/g, '\\0');
return '"' + escaped.replace(/"/g, '\\"') + '"';
};
/***/ },
/* 165 */
/***/ function(module, exports) {
/**
* Polyfill from <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString>.
*/
module.exports = (function() {
var pad = function pad(n) { return (n < 10 ? '0' : '') + n; };
return typeof Date.prototype.toISOString === 'function' ?
function _toISOString(d) {
return d.toISOString();
} :
function _toISOString(d) {
return (
d.getUTCFullYear() + '-' +
pad(d.getUTCMonth() + 1) + '-' +
pad(d.getUTCDate()) + 'T' +
pad(d.getUTCHours()) + ':' +
pad(d.getUTCMinutes()) + ':' +
pad(d.getUTCSeconds()) + '.' +
(d.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) + 'Z'
);
};
}());
/***/ },
/* 166 */
/***/ function(module, exports, __webpack_require__) {
var _complement = __webpack_require__(167);
var _curry2 = __webpack_require__(75);
var filter = __webpack_require__(168);
/**
* The complement of `filter`.
*
* Acts as a transducer if a transformer is given in list position.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig Filterable f => (a -> Boolean) -> f a -> f a
* @param {Function} pred
* @param {Array} filterable
* @return {Array}
* @see R.filter, R.transduce, R.addIndex
* @example
*
* var isOdd = (n) => n % 2 === 1;
*
* R.reject(isOdd, [1, 2, 3, 4]); //=> [2, 4]
*
* R.reject(isOdd, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}
*/
module.exports = _curry2(function reject(pred, filterable) {
return filter(_complement(pred), filterable);
});
/***/ },
/* 167 */
/***/ function(module, exports) {
module.exports = function _complement(f) {
return function() {
return !f.apply(this, arguments);
};
};
/***/ },
/* 168 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _dispatchable = __webpack_require__(84);
var _filter = __webpack_require__(169);
var _isObject = __webpack_require__(170);
var _reduce = __webpack_require__(95);
var _xfilter = __webpack_require__(171);
var keys = __webpack_require__(101);
/**
* Takes a predicate and a "filterable", and returns a new filterable of the
* same type containing the members of the given filterable which satisfy the
* given predicate.
*
* Dispatches to the `filter` method of the second argument, if present.
*
* Acts as a transducer if a transformer is given in list position.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig Filterable f => (a -> Boolean) -> f a -> f a
* @param {Function} pred
* @param {Array} filterable
* @return {Array}
* @see R.reject, R.transduce, R.addIndex
* @example
*
* var isEven = n => n % 2 === 0;
*
* R.filter(isEven, [1, 2, 3, 4]); //=> [2, 4]
*
* R.filter(isEven, {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, d: 4}
*/
module.exports = _curry2(_dispatchable(['filter'], _xfilter, function(pred, filterable) {
return (
_isObject(filterable) ?
_reduce(function(acc, key) {
if (pred(filterable[key])) {
acc[key] = filterable[key];
}
return acc;
}, {}, keys(filterable)) :
// else
_filter(pred, filterable)
);
}));
/***/ },
/* 169 */
/***/ function(module, exports) {
module.exports = function _filter(fn, list) {
var idx = 0;
var len = list.length;
var result = [];
while (idx < len) {
if (fn(list[idx])) {
result[result.length] = list[idx];
}
idx += 1;
}
return result;
};
/***/ },
/* 170 */
/***/ function(module, exports) {
module.exports = function _isObject(x) {
return Object.prototype.toString.call(x) === '[object Object]';
};
/***/ },
/* 171 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _xfBase = __webpack_require__(89);
module.exports = (function() {
function XFilter(f, xf) {
this.xf = xf;
this.f = f;
}
XFilter.prototype['@@transducer/init'] = _xfBase.init;
XFilter.prototype['@@transducer/result'] = _xfBase.result;
XFilter.prototype['@@transducer/step'] = function(result, input) {
return this.f(input) ? this.xf['@@transducer/step'](result, input) : result;
};
return _curry2(function _xfilter(f, xf) { return new XFilter(f, xf); });
}());
/***/ },
/* 172 */
/***/ function(module, exports, __webpack_require__) {
var _arity = __webpack_require__(79);
var _curry1 = __webpack_require__(70);
var map = __webpack_require__(93);
var max = __webpack_require__(91);
var reduce = __webpack_require__(105);
/**
* Returns a function, `fn`, which encapsulates `if/else, if/else, ...` logic.
* `R.cond` takes a list of [predicate, transformer] pairs. All of the arguments
* to `fn` are applied to each of the predicates in turn until one returns a
* "truthy" value, at which point `fn` returns the result of applying its
* arguments to the corresponding transformer. If none of the predicates
* matches, `fn` returns undefined.
*
* @func
* @memberOf R
* @since v0.6.0
* @category Logic
* @sig [[(*... -> Boolean),(*... -> *)]] -> (*... -> *)
* @param {Array} pairs A list of [predicate, transformer]
* @return {Function}
* @example
*
* var fn = R.cond([
* [R.equals(0), R.always('water freezes at 0°C')],
* [R.equals(100), R.always('water boils at 100°C')],
* [R.T, temp => 'nothing special happens at ' + temp + '°C']
* ]);
* fn(0); //=> 'water freezes at 0°C'
* fn(50); //=> 'nothing special happens at 50°C'
* fn(100); //=> 'water boils at 100°C'
*/
module.exports = _curry1(function cond(pairs) {
var arity = reduce(max,
0,
map(function(pair) { return pair[0].length; }, pairs));
return _arity(arity, function() {
var idx = 0;
while (idx < pairs.length) {
if (pairs[idx][0].apply(this, arguments)) {
return pairs[idx][1].apply(this, arguments);
}
idx += 1;
}
});
});
/***/ },
/* 173 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var constructN = __webpack_require__(174);
/**
* Wraps a constructor function inside a curried function that can be called
* with the same arguments and returns the same type.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Function
* @sig (* -> {*}) -> (* -> {*})
* @param {Function} fn The constructor function to wrap.
* @return {Function} A wrapped, curried constructor function.
* @example
*
* // Constructor function
* function Animal(kind) {
* this.kind = kind;
* };
* Animal.prototype.sighting = function() {
* return "It's a " + this.kind + "!";
* }
*
* var AnimalConstructor = R.construct(Animal)
*
* // Notice we no longer need the 'new' keyword:
* AnimalConstructor('Pig'); //=> {"kind": "Pig", "sighting": function (){...}};
*
* var animalTypes = ["Lion", "Tiger", "Bear"];
* var animalSighting = R.invoker(0, 'sighting');
* var sightNewAnimal = R.compose(animalSighting, AnimalConstructor);
* R.map(sightNewAnimal, animalTypes); //=> ["It's a Lion!", "It's a Tiger!", "It's a Bear!"]
*/
module.exports = _curry1(function construct(Fn) {
return constructN(Fn.length, Fn);
});
/***/ },
/* 174 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var curry = __webpack_require__(129);
var nAry = __webpack_require__(123);
/**
* Wraps a constructor function inside a curried function that can be called
* with the same arguments and returns the same type. The arity of the function
* returned is specified to allow using variadic constructor functions.
*
* @func
* @memberOf R
* @since v0.4.0
* @category Function
* @sig Number -> (* -> {*}) -> (* -> {*})
* @param {Number} n The arity of the constructor function.
* @param {Function} Fn The constructor function to wrap.
* @return {Function} A wrapped, curried constructor function.
* @example
*
* // Variadic Constructor function
* function Salad() {
* this.ingredients = arguments;
* };
* Salad.prototype.recipe = function() {
* var instructions = R.map((ingredient) => (
* 'Add a whollop of ' + ingredient, this.ingredients)
* )
* return R.join('\n', instructions)
* }
*
* var ThreeLayerSalad = R.constructN(3, Salad)
*
* // Notice we no longer need the 'new' keyword, and the constructor is curried for 3 arguments.
* var salad = ThreeLayerSalad('Mayonnaise')('Potato Chips')('Ketchup')
* console.log(salad.recipe());
* // Add a whollop of Mayonnaise
* // Add a whollop of Potato Chips
* // Add a whollop of Potato Ketchup
*/
module.exports = _curry2(function constructN(n, Fn) {
if (n > 10) {
throw new Error('Constructor with greater than ten arguments');
}
if (n === 0) {
return function() { return new Fn(); };
}
return curry(nAry(n, function($0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
switch (arguments.length) {
case 1: return new Fn($0);
case 2: return new Fn($0, $1);
case 3: return new Fn($0, $1, $2);
case 4: return new Fn($0, $1, $2, $3);
case 5: return new Fn($0, $1, $2, $3, $4);
case 6: return new Fn($0, $1, $2, $3, $4, $5);
case 7: return new Fn($0, $1, $2, $3, $4, $5, $6);
case 8: return new Fn($0, $1, $2, $3, $4, $5, $6, $7);
case 9: return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8);
case 10: return new Fn($0, $1, $2, $3, $4, $5, $6, $7, $8, $9);
}
}));
});
/***/ },
/* 175 */
/***/ function(module, exports, __webpack_require__) {
var _contains = __webpack_require__(157);
var _curry2 = __webpack_require__(75);
/**
* Returns `true` if the specified value is equal, in `R.equals` terms, to at
* least one element of the given list; `false` otherwise.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig a -> [a] -> Boolean
* @param {Object} a The item to compare against.
* @param {Array} list The array to consider.
* @return {Boolean} `true` if an equivalent item is in the list, `false` otherwise.
* @see R.any
* @example
*
* R.contains(3, [1, 2, 3]); //=> true
* R.contains(4, [1, 2, 3]); //=> false
* R.contains({ name: 'Fred' }, [{ name: 'Fred' }]); //=> true
* R.contains([42], [[42]]); //=> true
*/
module.exports = _curry2(_contains);
/***/ },
/* 176 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _map = __webpack_require__(94);
var curryN = __webpack_require__(78);
var max = __webpack_require__(91);
var pluck = __webpack_require__(92);
var reduce = __webpack_require__(105);
/**
* Accepts a converging function and a list of branching functions and returns
* a new function. When invoked, this new function is applied to some
* arguments, each branching function is applied to those same arguments. The
* results of each branching function are passed as arguments to the converging
* function to produce the return value.
*
* @func
* @memberOf R
* @since v0.4.2
* @category Function
* @sig (x1 -> x2 -> ... -> z) -> [(a -> b -> ... -> x1), (a -> b -> ... -> x2), ...] -> (a -> b -> ... -> z)
* @param {Function} after A function. `after` will be invoked with the return values of
* `fn1` and `fn2` as its arguments.
* @param {Array} functions A list of functions.
* @return {Function} A new function.
* @see R.useWith
* @example
*
* var average = R.converge(R.divide, [R.sum, R.length])
* average([1, 2, 3, 4, 5, 6, 7]) //=> 4
*
* var strangeConcat = R.converge(R.concat, [R.toUpper, R.toLower])
* strangeConcat("Yodel") //=> "YODELyodel"
*
* @symb R.converge(f, [g, h])(a, b) = f(g(a, b), h(a, b))
*/
module.exports = _curry2(function converge(after, fns) {
return curryN(reduce(max, 0, pluck('length', fns)), function() {
var args = arguments;
var context = this;
return after.apply(context, _map(function(fn) {
return fn.apply(context, args);
}, fns));
});
});
/***/ },
/* 177 */
/***/ function(module, exports, __webpack_require__) {
var reduceBy = __webpack_require__(178);
/**
* Counts the elements of a list according to how many match each value of a
* key generated by the supplied function. Returns an object mapping the keys
* produced by `fn` to the number of occurrences in the list. Note that all
* keys are coerced to strings because of how JavaScript objects work.
*
* Acts as a transducer if a transformer is given in list position.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Relation
* @sig (a -> String) -> [a] -> {*}
* @param {Function} fn The function used to map values to keys.
* @param {Array} list The list to count elements from.
* @return {Object} An object mapping keys to number of occurrences in the list.
* @example
*
* var numbers = [1.0, 1.1, 1.2, 2.0, 3.0, 2.2];
* R.countBy(Math.floor)(numbers); //=> {'1': 3, '2': 2, '3': 1}
*
* var letters = ['a', 'b', 'A', 'a', 'B', 'c'];
* R.countBy(R.toLower)(letters); //=> {'a': 3, 'b': 2, 'c': 1}
*/
module.exports = reduceBy(function(acc, elem) { return acc + 1; }, 0);
/***/ },
/* 178 */
/***/ function(module, exports, __webpack_require__) {
var _curryN = __webpack_require__(80);
var _dispatchable = __webpack_require__(84);
var _has = __webpack_require__(102);
var _reduce = __webpack_require__(95);
var _xreduceBy = __webpack_require__(179);
/**
* Groups the elements of the list according to the result of calling
* the String-returning function `keyFn` on each element and reduces the elements
* of each group to a single value via the reducer function `valueFn`.
*
* This function is basically a more general `groupBy` function.
*
* Acts as a transducer if a transformer is given in list position.
*
* @func
* @memberOf R
* @since v0.20.0
* @category List
* @sig ((a, b) -> a) -> a -> (b -> String) -> [b] -> {String: a}
* @param {Function} valueFn The function that reduces the elements of each group to a single
* value. Receives two values, accumulator for a particular group and the current element.
* @param {*} acc The (initial) accumulator value for each group.
* @param {Function} keyFn The function that maps the list's element into a key.
* @param {Array} list The array to group.
* @return {Object} An object with the output of `keyFn` for keys, mapped to the output of
* `valueFn` for elements which produced that key when passed to `keyFn`.
* @see R.groupBy, R.reduce
* @example
*
* var reduceToNamesBy = R.reduceBy((acc, student) => acc.concat(student.name), []);
* var namesByGrade = reduceToNamesBy(function(student) {
* var score = student.score;
* return score < 65 ? 'F' :
* score < 70 ? 'D' :
* score < 80 ? 'C' :
* score < 90 ? 'B' : 'A';
* });
* var students = [{name: 'Lucy', score: 92},
* {name: 'Drew', score: 85},
* // ...
* {name: 'Bart', score: 62}];
* namesByGrade(students);
* // {
* // 'A': ['Lucy'],
* // 'B': ['Drew']
* // // ...,
* // 'F': ['Bart']
* // }
*/
module.exports = _curryN(4, [], _dispatchable([], _xreduceBy,
function reduceBy(valueFn, valueAcc, keyFn, list) {
return _reduce(function(acc, elt) {
var key = keyFn(elt);
acc[key] = valueFn(_has(key, acc) ? acc[key] : valueAcc, elt);
return acc;
}, {}, list);
}));
/***/ },
/* 179 */
/***/ function(module, exports, __webpack_require__) {
var _curryN = __webpack_require__(80);
var _has = __webpack_require__(102);
var _xfBase = __webpack_require__(89);
module.exports = (function() {
function XReduceBy(valueFn, valueAcc, keyFn, xf) {
this.valueFn = valueFn;
this.valueAcc = valueAcc;
this.keyFn = keyFn;
this.xf = xf;
this.inputs = {};
}
XReduceBy.prototype['@@transducer/init'] = _xfBase.init;
XReduceBy.prototype['@@transducer/result'] = function(result) {
var key;
for (key in this.inputs) {
if (_has(key, this.inputs)) {
result = this.xf['@@transducer/step'](result, this.inputs[key]);
if (result['@@transducer/reduced']) {
result = result['@@transducer/value'];
break;
}
}
}
this.inputs = null;
return this.xf['@@transducer/result'](result);
};
XReduceBy.prototype['@@transducer/step'] = function(result, input) {
var key = this.keyFn(input);
this.inputs[key] = this.inputs[key] || [key, this.valueAcc];
this.inputs[key][1] = this.valueFn(this.inputs[key][1], input);
return result;
};
return _curryN(4, [],
function _xreduceBy(valueFn, valueAcc, keyFn, xf) {
return new XReduceBy(valueFn, valueAcc, keyFn, xf);
});
}());
/***/ },
/* 180 */
/***/ function(module, exports, __webpack_require__) {
var add = __webpack_require__(74);
/**
* Decrements its argument.
*
* @func
* @memberOf R
* @since v0.9.0
* @category Math
* @sig Number -> Number
* @param {Number} n
* @return {Number} n - 1
* @see R.inc
* @example
*
* R.dec(42); //=> 41
*/
module.exports = add(-1);
/***/ },
/* 181 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* Makes a descending comparator function out of a function that returns a value
* that can be compared with `<` and `>`.
*
* @func
* @memberOf R
* @since v0.23.0
* @category Function
* @sig Ord b => (a -> b) -> a -> a -> Number
* @param {Function} fn A function of arity one that returns a value that can be compared
* @param {*} a The first item to be compared.
* @param {*} b The second item to be compared.
* @return {Number} `-1` if fn(a) > fn(b), `1` if fn(b) > fn(a), otherwise `0`
* @example
*
* var byAge = R.descend(R.prop('age'));
* var people = [
* // ...
* ];
* var peopleByOldestFirst = R.sort(byAge, people);
*/
module.exports = _curry3(function descend(fn, a, b) {
var aa = fn(a);
var bb = fn(b);
return aa > bb ? -1 : aa < bb ? 1 : 0;
});
/***/ },
/* 182 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Returns the second argument if it is not `null`, `undefined` or `NaN`
* otherwise the first argument is returned.
*
* @func
* @memberOf R
* @since v0.10.0
* @category Logic
* @sig a -> b -> a | b
* @param {a} default The default value.
* @param {b} val `val` will be returned instead of `default` unless `val` is `null`, `undefined` or `NaN`.
* @return {*} The second value if it is not `null`, `undefined` or `NaN`, otherwise the default value
* @example
*
* var defaultTo42 = R.defaultTo(42);
*
* defaultTo42(null); //=> 42
* defaultTo42(undefined); //=> 42
* defaultTo42('Ramda'); //=> 'Ramda'
* // parseInt('string') results in NaN
* defaultTo42(parseInt('string')); //=> 42
*/
module.exports = _curry2(function defaultTo(d, v) {
return v == null || v !== v ? d : v;
});
/***/ },
/* 183 */
/***/ function(module, exports, __webpack_require__) {
var _contains = __webpack_require__(157);
var _curry2 = __webpack_require__(75);
/**
* Finds the set (i.e. no duplicates) of all elements in the first list not
* contained in the second list. Objects and Arrays are compared are compared
* in terms of value equality, not reference equality.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Relation
* @sig [*] -> [*] -> [*]
* @param {Array} list1 The first list.
* @param {Array} list2 The second list.
* @return {Array} The elements in `list1` that are not in `list2`.
* @see R.differenceWith, R.symmetricDifference, R.symmetricDifferenceWith
* @example
*
* R.difference([1,2,3,4], [7,6,5,4,3]); //=> [1,2]
* R.difference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5]
* R.difference([{a: 1}, {b: 2}], [{a: 1}, {c: 3}]) //=> [{b: 2}]
*/
module.exports = _curry2(function difference(first, second) {
var out = [];
var idx = 0;
var firstLen = first.length;
while (idx < firstLen) {
if (!_contains(first[idx], second) && !_contains(first[idx], out)) {
out[out.length] = first[idx];
}
idx += 1;
}
return out;
});
/***/ },
/* 184 */
/***/ function(module, exports, __webpack_require__) {
var _containsWith = __webpack_require__(185);
var _curry3 = __webpack_require__(82);
/**
* Finds the set (i.e. no duplicates) of all elements in the first list not
* contained in the second list. Duplication is determined according to the
* value returned by applying the supplied predicate to two list elements.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Relation
* @sig ((a, a) -> Boolean) -> [a] -> [a] -> [a]
* @param {Function} pred A predicate used to test whether two items are equal.
* @param {Array} list1 The first list.
* @param {Array} list2 The second list.
* @return {Array} The elements in `list1` that are not in `list2`.
* @see R.difference, R.symmetricDifference, R.symmetricDifferenceWith
* @example
*
* var cmp = (x, y) => x.a === y.a;
* var l1 = [{a: 1}, {a: 2}, {a: 3}];
* var l2 = [{a: 3}, {a: 4}];
* R.differenceWith(cmp, l1, l2); //=> [{a: 1}, {a: 2}]
*/
module.exports = _curry3(function differenceWith(pred, first, second) {
var out = [];
var idx = 0;
var firstLen = first.length;
while (idx < firstLen) {
if (!_containsWith(pred, first[idx], second) &&
!_containsWith(pred, first[idx], out)) {
out.push(first[idx]);
}
idx += 1;
}
return out;
});
/***/ },
/* 185 */
/***/ function(module, exports) {
module.exports = function _containsWith(pred, x, list) {
var idx = 0;
var len = list.length;
while (idx < len) {
if (pred(x, list[idx])) {
return true;
}
idx += 1;
}
return false;
};
/***/ },
/* 186 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Returns a new object that does not contain a `prop` property.
*
* @func
* @memberOf R
* @since v0.10.0
* @category Object
* @sig String -> {k: v} -> {k: v}
* @param {String} prop The name of the property to dissociate
* @param {Object} obj The object to clone
* @return {Object} A new object equivalent to the original but without the specified property
* @see R.assoc
* @example
*
* R.dissoc('b', {a: 1, b: 2, c: 3}); //=> {a: 1, c: 3}
*/
module.exports = _curry2(function dissoc(prop, obj) {
var result = {};
for (var p in obj) {
result[p] = obj[p];
}
delete result[prop];
return result;
});
/***/ },
/* 187 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var assoc = __webpack_require__(119);
var dissoc = __webpack_require__(186);
/**
* Makes a shallow clone of an object, omitting the property at the given path.
* Note that this copies and flattens prototype properties onto the new object
* as well. All non-primitive properties are copied by reference.
*
* @func
* @memberOf R
* @since v0.11.0
* @category Object
* @sig [String] -> {k: v} -> {k: v}
* @param {Array} path The path to the value to omit
* @param {Object} obj The object to clone
* @return {Object} A new object without the property at path
* @see R.assocPath
* @example
*
* R.dissocPath(['a', 'b', 'c'], {a: {b: {c: 42}}}); //=> {a: {b: {}}}
*/
module.exports = _curry2(function dissocPath(path, obj) {
switch (path.length) {
case 0:
return obj;
case 1:
return dissoc(path[0], obj);
default:
var head = path[0];
var tail = Array.prototype.slice.call(path, 1);
return obj[head] == null ? obj : assoc(head, dissocPath(tail, obj[head]), obj);
}
});
/***/ },
/* 188 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Divides two numbers. Equivalent to `a / b`.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Math
* @sig Number -> Number -> Number
* @param {Number} a The first value.
* @param {Number} b The second value.
* @return {Number} The result of `a / b`.
* @see R.multiply
* @example
*
* R.divide(71, 100); //=> 0.71
*
* var half = R.divide(R.__, 2);
* half(42); //=> 21
*
* var reciprocal = R.divide(1);
* reciprocal(4); //=> 0.25
*/
module.exports = _curry2(function divide(a, b) { return a / b; });
/***/ },
/* 189 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _dispatchable = __webpack_require__(84);
var _xdrop = __webpack_require__(190);
var slice = __webpack_require__(148);
/**
* Returns all but the first `n` elements of the given list, string, or
* transducer/transformer (or object with a `drop` method).
*
* Dispatches to the `drop` method of the second argument, if present.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig Number -> [a] -> [a]
* @sig Number -> String -> String
* @param {Number} n
* @param {[a]} list
* @return {[a]} A copy of list without the first `n` elements
* @see R.take, R.transduce, R.dropLast, R.dropWhile
* @example
*
* R.drop(1, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']
* R.drop(2, ['foo', 'bar', 'baz']); //=> ['baz']
* R.drop(3, ['foo', 'bar', 'baz']); //=> []
* R.drop(4, ['foo', 'bar', 'baz']); //=> []
* R.drop(3, 'ramda'); //=> 'da'
*/
module.exports = _curry2(_dispatchable(['drop'], _xdrop, function drop(n, xs) {
return slice(Math.max(0, n), Infinity, xs);
}));
/***/ },
/* 190 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _xfBase = __webpack_require__(89);
module.exports = (function() {
function XDrop(n, xf) {
this.xf = xf;
this.n = n;
}
XDrop.prototype['@@transducer/init'] = _xfBase.init;
XDrop.prototype['@@transducer/result'] = _xfBase.result;
XDrop.prototype['@@transducer/step'] = function(result, input) {
if (this.n > 0) {
this.n -= 1;
return result;
}
return this.xf['@@transducer/step'](result, input);
};
return _curry2(function _xdrop(n, xf) { return new XDrop(n, xf); });
}());
/***/ },
/* 191 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _dispatchable = __webpack_require__(84);
var _dropLast = __webpack_require__(192);
var _xdropLast = __webpack_require__(195);
/**
* Returns a list containing all but the last `n` elements of the given `list`.
*
* @func
* @memberOf R
* @since v0.16.0
* @category List
* @sig Number -> [a] -> [a]
* @sig Number -> String -> String
* @param {Number} n The number of elements of `list` to skip.
* @param {Array} list The list of elements to consider.
* @return {Array} A copy of the list with only the first `list.length - n` elements
* @see R.takeLast, R.drop, R.dropWhile, R.dropLastWhile
* @example
*
* R.dropLast(1, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']
* R.dropLast(2, ['foo', 'bar', 'baz']); //=> ['foo']
* R.dropLast(3, ['foo', 'bar', 'baz']); //=> []
* R.dropLast(4, ['foo', 'bar', 'baz']); //=> []
* R.dropLast(3, 'ramda'); //=> 'ra'
*/
module.exports = _curry2(_dispatchable([], _xdropLast, _dropLast));
/***/ },
/* 192 */
/***/ function(module, exports, __webpack_require__) {
var take = __webpack_require__(193);
module.exports = function dropLast(n, xs) {
return take(n < xs.length ? xs.length - n : 0, xs);
};
/***/ },
/* 193 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _dispatchable = __webpack_require__(84);
var _xtake = __webpack_require__(194);
var slice = __webpack_require__(148);
/**
* Returns the first `n` elements of the given list, string, or
* transducer/transformer (or object with a `take` method).
*
* Dispatches to the `take` method of the second argument, if present.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig Number -> [a] -> [a]
* @sig Number -> String -> String
* @param {Number} n
* @param {*} list
* @return {*}
* @see R.drop
* @example
*
* R.take(1, ['foo', 'bar', 'baz']); //=> ['foo']
* R.take(2, ['foo', 'bar', 'baz']); //=> ['foo', 'bar']
* R.take(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']
* R.take(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']
* R.take(3, 'ramda'); //=> 'ram'
*
* var personnel = [
* 'Dave Brubeck',
* 'Paul Desmond',
* 'Eugene Wright',
* 'Joe Morello',
* 'Gerry Mulligan',
* 'Bob Bates',
* 'Joe Dodge',
* 'Ron Crotty'
* ];
*
* var takeFive = R.take(5);
* takeFive(personnel);
* //=> ['Dave Brubeck', 'Paul Desmond', 'Eugene Wright', 'Joe Morello', 'Gerry Mulligan']
* @symb R.take(-1, [a, b]) = [a, b]
* @symb R.take(0, [a, b]) = []
* @symb R.take(1, [a, b]) = [a]
* @symb R.take(2, [a, b]) = [a, b]
*/
module.exports = _curry2(_dispatchable(['take'], _xtake, function take(n, xs) {
return slice(0, n < 0 ? Infinity : n, xs);
}));
/***/ },
/* 194 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _reduced = __webpack_require__(88);
var _xfBase = __webpack_require__(89);
module.exports = (function() {
function XTake(n, xf) {
this.xf = xf;
this.n = n;
this.i = 0;
}
XTake.prototype['@@transducer/init'] = _xfBase.init;
XTake.prototype['@@transducer/result'] = _xfBase.result;
XTake.prototype['@@transducer/step'] = function(result, input) {
this.i += 1;
var ret = this.n === 0 ? result : this.xf['@@transducer/step'](result, input);
return this.i >= this.n ? _reduced(ret) : ret;
};
return _curry2(function _xtake(n, xf) { return new XTake(n, xf); });
}());
/***/ },
/* 195 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _xfBase = __webpack_require__(89);
module.exports = (function() {
function XDropLast(n, xf) {
this.xf = xf;
this.pos = 0;
this.full = false;
this.acc = new Array(n);
}
XDropLast.prototype['@@transducer/init'] = _xfBase.init;
XDropLast.prototype['@@transducer/result'] = function(result) {
this.acc = null;
return this.xf['@@transducer/result'](result);
};
XDropLast.prototype['@@transducer/step'] = function(result, input) {
if (this.full) {
result = this.xf['@@transducer/step'](result, this.acc[this.pos]);
}
this.store(input);
return result;
};
XDropLast.prototype.store = function(input) {
this.acc[this.pos] = input;
this.pos += 1;
if (this.pos === this.acc.length) {
this.pos = 0;
this.full = true;
}
};
return _curry2(function _xdropLast(n, xf) { return new XDropLast(n, xf); });
}());
/***/ },
/* 196 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _dispatchable = __webpack_require__(84);
var _dropLastWhile = __webpack_require__(197);
var _xdropLastWhile = __webpack_require__(198);
/**
* Returns a new list excluding all the tailing elements of a given list which
* satisfy the supplied predicate function. It passes each value from the right
* to the supplied predicate function, skipping elements until the predicate
* function returns a `falsy` value. The predicate function is applied to one argument:
* *(value)*.
*
* @func
* @memberOf R
* @since v0.16.0
* @category List
* @sig (a -> Boolean) -> [a] -> [a]
* @param {Function} predicate The function to be called on each element
* @param {Array} list The collection to iterate over.
* @return {Array} A new array without any trailing elements that return `falsy` values from the `predicate`.
* @see R.takeLastWhile, R.addIndex, R.drop, R.dropWhile
* @example
*
* var lteThree = x => x <= 3;
*
* R.dropLastWhile(lteThree, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3, 4]
*/
module.exports = _curry2(_dispatchable([], _xdropLastWhile, _dropLastWhile));
/***/ },
/* 197 */
/***/ function(module, exports) {
module.exports = function dropLastWhile(pred, list) {
var idx = list.length - 1;
while (idx >= 0 && pred(list[idx])) {
idx -= 1;
}
return Array.prototype.slice.call(list, 0, idx + 1);
};
/***/ },
/* 198 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _reduce = __webpack_require__(95);
var _xfBase = __webpack_require__(89);
module.exports = (function() {
function XDropLastWhile(fn, xf) {
this.f = fn;
this.retained = [];
this.xf = xf;
}
XDropLastWhile.prototype['@@transducer/init'] = _xfBase.init;
XDropLastWhile.prototype['@@transducer/result'] = function(result) {
this.retained = null;
return this.xf['@@transducer/result'](result);
};
XDropLastWhile.prototype['@@transducer/step'] = function(result, input) {
return this.f(input) ? this.retain(result, input)
: this.flush(result, input);
};
XDropLastWhile.prototype.flush = function(result, input) {
result = _reduce(
this.xf['@@transducer/step'],
result,
this.retained
);
this.retained = [];
return this.xf['@@transducer/step'](result, input);
};
XDropLastWhile.prototype.retain = function(result, input) {
this.retained.push(input);
return result;
};
return _curry2(function _xdropLastWhile(fn, xf) { return new XDropLastWhile(fn, xf); });
}());
/***/ },
/* 199 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var _dispatchable = __webpack_require__(84);
var _xdropRepeatsWith = __webpack_require__(200);
var dropRepeatsWith = __webpack_require__(201);
var equals = __webpack_require__(159);
/**
* Returns a new list without any consecutively repeating elements. `R.equals`
* is used to determine equality.
*
* Acts as a transducer if a transformer is given in list position.
*
* @func
* @memberOf R
* @since v0.14.0
* @category List
* @sig [a] -> [a]
* @param {Array} list The array to consider.
* @return {Array} `list` without repeating elements.
* @see R.transduce
* @example
*
* R.dropRepeats([1, 1, 1, 2, 3, 4, 4, 2, 2]); //=> [1, 2, 3, 4, 2]
*/
module.exports = _curry1(_dispatchable([], _xdropRepeatsWith(equals), dropRepeatsWith(equals)));
/***/ },
/* 200 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _xfBase = __webpack_require__(89);
module.exports = (function() {
function XDropRepeatsWith(pred, xf) {
this.xf = xf;
this.pred = pred;
this.lastValue = undefined;
this.seenFirstValue = false;
}
XDropRepeatsWith.prototype['@@transducer/init'] = _xfBase.init;
XDropRepeatsWith.prototype['@@transducer/result'] = _xfBase.result;
XDropRepeatsWith.prototype['@@transducer/step'] = function(result, input) {
var sameAsLast = false;
if (!this.seenFirstValue) {
this.seenFirstValue = true;
} else if (this.pred(this.lastValue, input)) {
sameAsLast = true;
}
this.lastValue = input;
return sameAsLast ? result : this.xf['@@transducer/step'](result, input);
};
return _curry2(function _xdropRepeatsWith(pred, xf) { return new XDropRepeatsWith(pred, xf); });
}());
/***/ },
/* 201 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _dispatchable = __webpack_require__(84);
var _xdropRepeatsWith = __webpack_require__(200);
var last = __webpack_require__(202);
/**
* Returns a new list without any consecutively repeating elements. Equality is
* determined by applying the supplied predicate to each pair of consecutive elements. The
* first element in a series of equal elements will be preserved.
*
* Acts as a transducer if a transformer is given in list position.
*
* @func
* @memberOf R
* @since v0.14.0
* @category List
* @sig (a, a -> Boolean) -> [a] -> [a]
* @param {Function} pred A predicate used to test whether two items are equal.
* @param {Array} list The array to consider.
* @return {Array} `list` without repeating elements.
* @see R.transduce
* @example
*
* var l = [1, -1, 1, 3, 4, -4, -4, -5, 5, 3, 3];
* R.dropRepeatsWith(R.eqBy(Math.abs), l); //=> [1, 3, 4, -5, 3]
*/
module.exports = _curry2(_dispatchable([], _xdropRepeatsWith, function dropRepeatsWith(pred, list) {
var result = [];
var idx = 1;
var len = list.length;
if (len !== 0) {
result[0] = list[0];
while (idx < len) {
if (!pred(last(result), list[idx])) {
result[result.length] = list[idx];
}
idx += 1;
}
}
return result;
}));
/***/ },
/* 202 */
/***/ function(module, exports, __webpack_require__) {
var nth = __webpack_require__(203);
/**
* Returns the last element of the given list or string.
*
* @func
* @memberOf R
* @since v0.1.4
* @category List
* @sig [a] -> a | Undefined
* @sig String -> String
* @param {*} list
* @return {*}
* @see R.init, R.head, R.tail
* @example
*
* R.last(['fi', 'fo', 'fum']); //=> 'fum'
* R.last([]); //=> undefined
*
* R.last('abc'); //=> 'c'
* R.last(''); //=> ''
*/
module.exports = nth(-1);
/***/ },
/* 203 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _isString = __webpack_require__(99);
/**
* Returns the nth element of the given list or string. If n is negative the
* element at index length + n is returned.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig Number -> [a] -> a | Undefined
* @sig Number -> String -> String
* @param {Number} offset
* @param {*} list
* @return {*}
* @example
*
* var list = ['foo', 'bar', 'baz', 'quux'];
* R.nth(1, list); //=> 'bar'
* R.nth(-1, list); //=> 'quux'
* R.nth(-99, list); //=> undefined
*
* R.nth(2, 'abc'); //=> 'c'
* R.nth(3, 'abc'); //=> ''
* @symb R.nth(-1, [a, b, c]) = c
* @symb R.nth(0, [a, b, c]) = a
* @symb R.nth(1, [a, b, c]) = b
*/
module.exports = _curry2(function nth(offset, list) {
var idx = offset < 0 ? list.length + offset : offset;
return _isString(list) ? list.charAt(idx) : list[idx];
});
/***/ },
/* 204 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _dispatchable = __webpack_require__(84);
var _xdropWhile = __webpack_require__(205);
/**
* Returns a new list excluding the leading elements of a given list which
* satisfy the supplied predicate function. It passes each value to the supplied
* predicate function, skipping elements while the predicate function returns
* `true`. The predicate function is applied to one argument: *(value)*.
*
* Dispatches to the `dropWhile` method of the second argument, if present.
*
* Acts as a transducer if a transformer is given in list position.
*
* @func
* @memberOf R
* @since v0.9.0
* @category List
* @sig (a -> Boolean) -> [a] -> [a]
* @param {Function} fn The function called per iteration.
* @param {Array} list The collection to iterate over.
* @return {Array} A new array.
* @see R.takeWhile, R.transduce, R.addIndex
* @example
*
* var lteTwo = x => x <= 2;
*
* R.dropWhile(lteTwo, [1, 2, 3, 4, 3, 2, 1]); //=> [3, 4, 3, 2, 1]
*/
module.exports = _curry2(_dispatchable(['dropWhile'], _xdropWhile, function dropWhile(pred, list) {
var idx = 0;
var len = list.length;
while (idx < len && pred(list[idx])) {
idx += 1;
}
return Array.prototype.slice.call(list, idx);
}));
/***/ },
/* 205 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _xfBase = __webpack_require__(89);
module.exports = (function() {
function XDropWhile(f, xf) {
this.xf = xf;
this.f = f;
}
XDropWhile.prototype['@@transducer/init'] = _xfBase.init;
XDropWhile.prototype['@@transducer/result'] = _xfBase.result;
XDropWhile.prototype['@@transducer/step'] = function(result, input) {
if (this.f) {
if (this.f(input)) {
return result;
}
this.f = null;
}
return this.xf['@@transducer/step'](result, input);
};
return _curry2(function _xdropWhile(f, xf) { return new XDropWhile(f, xf); });
}());
/***/ },
/* 206 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _isFunction = __webpack_require__(125);
var lift = __webpack_require__(126);
var or = __webpack_require__(207);
/**
* A function wrapping calls to the two functions in an `||` operation,
* returning the result of the first function if it is truth-y and the result
* of the second function otherwise. Note that this is short-circuited,
* meaning that the second function will not be invoked if the first returns a
* truth-y value.
*
* In addition to functions, `R.either` also accepts any fantasy-land compatible
* applicative functor.
*
* @func
* @memberOf R
* @since v0.12.0
* @category Logic
* @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)
* @param {Function} f a predicate
* @param {Function} g another predicate
* @return {Function} a function that applies its arguments to `f` and `g` and `||`s their outputs together.
* @see R.or
* @example
*
* var gt10 = x => x > 10;
* var even = x => x % 2 === 0;
* var f = R.either(gt10, even);
* f(101); //=> true
* f(8); //=> true
*/
module.exports = _curry2(function either(f, g) {
return _isFunction(f) ?
function _either() {
return f.apply(this, arguments) || g.apply(this, arguments);
} :
lift(or)(f, g);
});
/***/ },
/* 207 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Returns `true` if one or both of its arguments are `true`. Returns `false`
* if both arguments are `false`.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Logic
* @sig a -> b -> a | b
* @param {Any} a
* @param {Any} b
* @return {Any} the first argument if truthy, otherwise the second argument.
* @see R.either
* @example
*
* R.or(true, true); //=> true
* R.or(true, false); //=> true
* R.or(false, true); //=> true
* R.or(false, false); //=> false
*/
module.exports = _curry2(function or(a, b) {
return a || b;
});
/***/ },
/* 208 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var _isArguments = __webpack_require__(103);
var _isArray = __webpack_require__(85);
var _isObject = __webpack_require__(170);
var _isString = __webpack_require__(99);
/**
* Returns the empty value of its argument's type. Ramda defines the empty
* value of Array (`[]`), Object (`{}`), String (`''`), and Arguments. Other
* types are supported if they define `<Type>.empty` and/or
* `<Type>.prototype.empty`.
*
* Dispatches to the `empty` method of the first argument, if present.
*
* @func
* @memberOf R
* @since v0.3.0
* @category Function
* @sig a -> a
* @param {*} x
* @return {*}
* @example
*
* R.empty(Just(42)); //=> Nothing()
* R.empty([1, 2, 3]); //=> []
* R.empty('unicorns'); //=> ''
* R.empty({x: 1, y: 2}); //=> {}
*/
module.exports = _curry1(function empty(x) {
return (
(x != null && typeof x.empty === 'function') ?
x.empty() :
(x != null && x.constructor != null && typeof x.constructor.empty === 'function') ?
x.constructor.empty() :
_isArray(x) ?
[] :
_isString(x) ?
'' :
_isObject(x) ?
{} :
_isArguments(x) ?
(function() { return arguments; }()) :
// else
void 0
);
});
/***/ },
/* 209 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
var equals = __webpack_require__(159);
/**
* Takes a function and two values in its domain and returns `true` if the
* values map to the same value in the codomain; `false` otherwise.
*
* @func
* @memberOf R
* @since v0.18.0
* @category Relation
* @sig (a -> b) -> a -> a -> Boolean
* @param {Function} f
* @param {*} x
* @param {*} y
* @return {Boolean}
* @example
*
* R.eqBy(Math.abs, 5, -5); //=> true
*/
module.exports = _curry3(function eqBy(f, x, y) {
return equals(f(x), f(y));
});
/***/ },
/* 210 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
var equals = __webpack_require__(159);
/**
* Reports whether two objects have the same value, in `R.equals` terms, for
* the specified property. Useful as a curried predicate.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Object
* @sig k -> {k: v} -> {k: v} -> Boolean
* @param {String} prop The name of the property to compare
* @param {Object} obj1
* @param {Object} obj2
* @return {Boolean}
*
* @example
*
* var o1 = { a: 1, b: 2, c: 3, d: 4 };
* var o2 = { a: 10, b: 20, c: 3, d: 40 };
* R.eqProps('a', o1, o2); //=> false
* R.eqProps('c', o1, o2); //=> true
*/
module.exports = _curry3(function eqProps(prop, obj1, obj2) {
return equals(obj1[prop], obj2[prop]);
});
/***/ },
/* 211 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Creates a new object by recursively evolving a shallow copy of `object`,
* according to the `transformation` functions. All non-primitive properties
* are copied by reference.
*
* A `transformation` function will not be invoked if its corresponding key
* does not exist in the evolved object.
*
* @func
* @memberOf R
* @since v0.9.0
* @category Object
* @sig {k: (v -> v)} -> {k: v} -> {k: v}
* @param {Object} transformations The object specifying transformation functions to apply
* to the object.
* @param {Object} object The object to be transformed.
* @return {Object} The transformed object.
* @example
*
* var tomato = {firstName: ' Tomato ', data: {elapsed: 100, remaining: 1400}, id:123};
* var transformations = {
* firstName: R.trim,
* lastName: R.trim, // Will not get invoked.
* data: {elapsed: R.add(1), remaining: R.add(-1)}
* };
* R.evolve(transformations, tomato); //=> {firstName: 'Tomato', data: {elapsed: 101, remaining: 1399}, id:123}
*/
module.exports = _curry2(function evolve(transformations, object) {
var result = {};
var transformation, key, type;
for (key in object) {
transformation = transformations[key];
type = typeof transformation;
result[key] = type === 'function' ? transformation(object[key])
: transformation && type === 'object' ? evolve(transformation, object[key])
: object[key];
}
return result;
});
/***/ },
/* 212 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _dispatchable = __webpack_require__(84);
var _xfind = __webpack_require__(213);
/**
* Returns the first element of the list which matches the predicate, or
* `undefined` if no element matches.
*
* Dispatches to the `find` method of the second argument, if present.
*
* Acts as a transducer if a transformer is given in list position.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig (a -> Boolean) -> [a] -> a | undefined
* @param {Function} fn The predicate function used to determine if the element is the
* desired one.
* @param {Array} list The array to consider.
* @return {Object} The element found, or `undefined`.
* @see R.transduce
* @example
*
* var xs = [{a: 1}, {a: 2}, {a: 3}];
* R.find(R.propEq('a', 2))(xs); //=> {a: 2}
* R.find(R.propEq('a', 4))(xs); //=> undefined
*/
module.exports = _curry2(_dispatchable(['find'], _xfind, function find(fn, list) {
var idx = 0;
var len = list.length;
while (idx < len) {
if (fn(list[idx])) {
return list[idx];
}
idx += 1;
}
}));
/***/ },
/* 213 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _reduced = __webpack_require__(88);
var _xfBase = __webpack_require__(89);
module.exports = (function() {
function XFind(f, xf) {
this.xf = xf;
this.f = f;
this.found = false;
}
XFind.prototype['@@transducer/init'] = _xfBase.init;
XFind.prototype['@@transducer/result'] = function(result) {
if (!this.found) {
result = this.xf['@@transducer/step'](result, void 0);
}
return this.xf['@@transducer/result'](result);
};
XFind.prototype['@@transducer/step'] = function(result, input) {
if (this.f(input)) {
this.found = true;
result = _reduced(this.xf['@@transducer/step'](result, input));
}
return result;
};
return _curry2(function _xfind(f, xf) { return new XFind(f, xf); });
}());
/***/ },
/* 214 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _dispatchable = __webpack_require__(84);
var _xfindIndex = __webpack_require__(215);
/**
* Returns the index of the first element of the list which matches the
* predicate, or `-1` if no element matches.
*
* Acts as a transducer if a transformer is given in list position.
*
* @func
* @memberOf R
* @since v0.1.1
* @category List
* @sig (a -> Boolean) -> [a] -> Number
* @param {Function} fn The predicate function used to determine if the element is the
* desired one.
* @param {Array} list The array to consider.
* @return {Number} The index of the element found, or `-1`.
* @see R.transduce
* @example
*
* var xs = [{a: 1}, {a: 2}, {a: 3}];
* R.findIndex(R.propEq('a', 2))(xs); //=> 1
* R.findIndex(R.propEq('a', 4))(xs); //=> -1
*/
module.exports = _curry2(_dispatchable([], _xfindIndex, function findIndex(fn, list) {
var idx = 0;
var len = list.length;
while (idx < len) {
if (fn(list[idx])) {
return idx;
}
idx += 1;
}
return -1;
}));
/***/ },
/* 215 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _reduced = __webpack_require__(88);
var _xfBase = __webpack_require__(89);
module.exports = (function() {
function XFindIndex(f, xf) {
this.xf = xf;
this.f = f;
this.idx = -1;
this.found = false;
}
XFindIndex.prototype['@@transducer/init'] = _xfBase.init;
XFindIndex.prototype['@@transducer/result'] = function(result) {
if (!this.found) {
result = this.xf['@@transducer/step'](result, -1);
}
return this.xf['@@transducer/result'](result);
};
XFindIndex.prototype['@@transducer/step'] = function(result, input) {
this.idx += 1;
if (this.f(input)) {
this.found = true;
result = _reduced(this.xf['@@transducer/step'](result, this.idx));
}
return result;
};
return _curry2(function _xfindIndex(f, xf) { return new XFindIndex(f, xf); });
}());
/***/ },
/* 216 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _dispatchable = __webpack_require__(84);
var _xfindLast = __webpack_require__(217);
/**
* Returns the last element of the list which matches the predicate, or
* `undefined` if no element matches.
*
* Acts as a transducer if a transformer is given in list position.
*
* @func
* @memberOf R
* @since v0.1.1
* @category List
* @sig (a -> Boolean) -> [a] -> a | undefined
* @param {Function} fn The predicate function used to determine if the element is the
* desired one.
* @param {Array} list The array to consider.
* @return {Object} The element found, or `undefined`.
* @see R.transduce
* @example
*
* var xs = [{a: 1, b: 0}, {a:1, b: 1}];
* R.findLast(R.propEq('a', 1))(xs); //=> {a: 1, b: 1}
* R.findLast(R.propEq('a', 4))(xs); //=> undefined
*/
module.exports = _curry2(_dispatchable([], _xfindLast, function findLast(fn, list) {
var idx = list.length - 1;
while (idx >= 0) {
if (fn(list[idx])) {
return list[idx];
}
idx -= 1;
}
}));
/***/ },
/* 217 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _xfBase = __webpack_require__(89);
module.exports = (function() {
function XFindLast(f, xf) {
this.xf = xf;
this.f = f;
}
XFindLast.prototype['@@transducer/init'] = _xfBase.init;
XFindLast.prototype['@@transducer/result'] = function(result) {
return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.last));
};
XFindLast.prototype['@@transducer/step'] = function(result, input) {
if (this.f(input)) {
this.last = input;
}
return result;
};
return _curry2(function _xfindLast(f, xf) { return new XFindLast(f, xf); });
}());
/***/ },
/* 218 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _dispatchable = __webpack_require__(84);
var _xfindLastIndex = __webpack_require__(219);
/**
* Returns the index of the last element of the list which matches the
* predicate, or `-1` if no element matches.
*
* Acts as a transducer if a transformer is given in list position.
*
* @func
* @memberOf R
* @since v0.1.1
* @category List
* @sig (a -> Boolean) -> [a] -> Number
* @param {Function} fn The predicate function used to determine if the element is the
* desired one.
* @param {Array} list The array to consider.
* @return {Number} The index of the element found, or `-1`.
* @see R.transduce
* @example
*
* var xs = [{a: 1, b: 0}, {a:1, b: 1}];
* R.findLastIndex(R.propEq('a', 1))(xs); //=> 1
* R.findLastIndex(R.propEq('a', 4))(xs); //=> -1
*/
module.exports = _curry2(_dispatchable([], _xfindLastIndex, function findLastIndex(fn, list) {
var idx = list.length - 1;
while (idx >= 0) {
if (fn(list[idx])) {
return idx;
}
idx -= 1;
}
return -1;
}));
/***/ },
/* 219 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _xfBase = __webpack_require__(89);
module.exports = (function() {
function XFindLastIndex(f, xf) {
this.xf = xf;
this.f = f;
this.idx = -1;
this.lastIdx = -1;
}
XFindLastIndex.prototype['@@transducer/init'] = _xfBase.init;
XFindLastIndex.prototype['@@transducer/result'] = function(result) {
return this.xf['@@transducer/result'](this.xf['@@transducer/step'](result, this.lastIdx));
};
XFindLastIndex.prototype['@@transducer/step'] = function(result, input) {
this.idx += 1;
if (this.f(input)) {
this.lastIdx = this.idx;
}
return result;
};
return _curry2(function _xfindLastIndex(f, xf) { return new XFindLastIndex(f, xf); });
}());
/***/ },
/* 220 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var _makeFlat = __webpack_require__(131);
/**
* Returns a new list by pulling every item out of it (and all its sub-arrays)
* and putting them in a new array, depth-first.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig [a] -> [b]
* @param {Array} list The array to consider.
* @return {Array} The flattened list.
* @see R.unnest
* @example
*
* R.flatten([1, 2, [3, 4], 5, [6, [7, 8, [9, [10, 11], 12]]]]);
* //=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
*/
module.exports = _curry1(_makeFlat(true));
/***/ },
/* 221 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var curry = __webpack_require__(129);
/**
* Returns a new function much like the supplied one, except that the first two
* arguments' order is reversed.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Function
* @sig (a -> b -> c -> ... -> z) -> (b -> a -> c -> ... -> z)
* @param {Function} fn The function to invoke with its first two parameters reversed.
* @return {*} The result of invoking `fn` with its first two parameters' order reversed.
* @example
*
* var mergeThree = (a, b, c) => [].concat(a, b, c);
*
* mergeThree(1, 2, 3); //=> [1, 2, 3]
*
* R.flip(mergeThree)(1, 2, 3); //=> [2, 1, 3]
* @symb R.flip(f)(a, b, c) = f(b, a, c)
*/
module.exports = _curry1(function flip(fn) {
return curry(function(a, b) {
var args = Array.prototype.slice.call(arguments, 0);
args[0] = b;
args[1] = a;
return fn.apply(this, args);
});
});
/***/ },
/* 222 */
/***/ function(module, exports, __webpack_require__) {
var _checkForMethod = __webpack_require__(147);
var _curry2 = __webpack_require__(75);
/**
* Iterate over an input `list`, calling a provided function `fn` for each
* element in the list.
*
* `fn` receives one argument: *(value)*.
*
* Note: `R.forEach` does not skip deleted or unassigned indices (sparse
* arrays), unlike the native `Array.prototype.forEach` method. For more
* details on this behavior, see:
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach#Description
*
* Also note that, unlike `Array.prototype.forEach`, Ramda's `forEach` returns
* the original array. In some libraries this function is named `each`.
*
* Dispatches to the `forEach` method of the second argument, if present.
*
* @func
* @memberOf R
* @since v0.1.1
* @category List
* @sig (a -> *) -> [a] -> [a]
* @param {Function} fn The function to invoke. Receives one argument, `value`.
* @param {Array} list The list to iterate over.
* @return {Array} The original list.
* @see R.addIndex
* @example
*
* var printXPlusFive = x => console.log(x + 5);
* R.forEach(printXPlusFive, [1, 2, 3]); //=> [1, 2, 3]
* // logs 6
* // logs 7
* // logs 8
* @symb R.forEach(f, [a, b, c]) = [a, b, c]
*/
module.exports = _curry2(_checkForMethod('forEach', function forEach(fn, list) {
var len = list.length;
var idx = 0;
while (idx < len) {
fn(list[idx]);
idx += 1;
}
return list;
}));
/***/ },
/* 223 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var keys = __webpack_require__(101);
/**
* Iterate over an input `object`, calling a provided function `fn` for each
* key and value in the object.
*
* `fn` receives three argument: *(value, key, obj)*.
*
* @func
* @memberOf R
* @since v0.23.0
* @category Object
* @sig ((a, String, StrMap a) -> Any) -> StrMap a -> StrMap a
* @param {Function} fn The function to invoke. Receives three argument, `value`, `key`, `obj`.
* @param {Object} obj The object to iterate over.
* @return {Object} The original object.
* @example
*
* var printKeyConcatValue = (value, key) => console.log(key + ':' + value);
* R.forEachObjIndexed(printKeyConcatValue, {x: 1, y: 2}); //=> {x: 1, y: 2}
* // logs x:1
* // logs y:2
* @symb R.forEachObjIndexed(f, {x: a, y: b}) = {x: a, y: b}
*/
module.exports = _curry2(function forEachObjIndexed(fn, obj) {
var keyList = keys(obj);
var idx = 0;
while (idx < keyList.length) {
var key = keyList[idx];
fn(obj[key], key, obj);
idx += 1;
}
return obj;
});
/***/ },
/* 224 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
/**
* Creates a new object from a list key-value pairs. If a key appears in
* multiple pairs, the rightmost pair is included in the object.
*
* @func
* @memberOf R
* @since v0.3.0
* @category List
* @sig [[k,v]] -> {k: v}
* @param {Array} pairs An array of two-element arrays that will be the keys and values of the output object.
* @return {Object} The object made by pairing up `keys` and `values`.
* @see R.toPairs, R.pair
* @example
*
* R.fromPairs([['a', 1], ['b', 2], ['c', 3]]); //=> {a: 1, b: 2, c: 3}
*/
module.exports = _curry1(function fromPairs(pairs) {
var result = {};
var idx = 0;
while (idx < pairs.length) {
result[pairs[idx][0]] = pairs[idx][1];
idx += 1;
}
return result;
});
/***/ },
/* 225 */
/***/ function(module, exports, __webpack_require__) {
var _checkForMethod = __webpack_require__(147);
var _curry2 = __webpack_require__(75);
var reduceBy = __webpack_require__(178);
/**
* Splits a list into sub-lists stored in an object, based on the result of
* calling a String-returning function on each element, and grouping the
* results according to values returned.
*
* Dispatches to the `groupBy` method of the second argument, if present.
*
* Acts as a transducer if a transformer is given in list position.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig (a -> String) -> [a] -> {String: [a]}
* @param {Function} fn Function :: a -> String
* @param {Array} list The array to group
* @return {Object} An object with the output of `fn` for keys, mapped to arrays of elements
* that produced that key when passed to `fn`.
* @see R.transduce
* @example
*
* var byGrade = R.groupBy(function(student) {
* var score = student.score;
* return score < 65 ? 'F' :
* score < 70 ? 'D' :
* score < 80 ? 'C' :
* score < 90 ? 'B' : 'A';
* });
* var students = [{name: 'Abby', score: 84},
* {name: 'Eddy', score: 58},
* // ...
* {name: 'Jack', score: 69}];
* byGrade(students);
* // {
* // 'A': [{name: 'Dianne', score: 99}],
* // 'B': [{name: 'Abby', score: 84}]
* // // ...,
* // 'F': [{name: 'Eddy', score: 58}]
* // }
*/
module.exports = _curry2(_checkForMethod('groupBy', reduceBy(function(acc, item) {
if (acc == null) {
acc = [];
}
acc.push(item);
return acc;
}, null)));
/***/ },
/* 226 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Takes a list and returns a list of lists where each sublist's elements are
* all "equal" according to the provided equality function.
*
* @func
* @memberOf R
* @since v0.21.0
* @category List
* @sig ((a, a) → Boolean) → [a] → [[a]]
* @param {Function} fn Function for determining whether two given (adjacent)
* elements should be in the same group
* @param {Array} list The array to group. Also accepts a string, which will be
* treated as a list of characters.
* @return {List} A list that contains sublists of equal elements,
* whose concatenations are equal to the original list.
* @example
*
* R.groupWith(R.equals, [0, 1, 1, 2, 3, 5, 8, 13, 21])
* //=> [[0], [1, 1], [2], [3], [5], [8], [13], [21]]
*
* R.groupWith((a, b) => a % 2 === b % 2, [0, 1, 1, 2, 3, 5, 8, 13, 21])
* //=> [[0], [1, 1], [2], [3, 5], [8], [13, 21]]
*
* R.groupWith(R.eqBy(isVowel), 'aestiou')
* //=> ['ae', 'st', 'iou']
*/
module.exports = _curry2(function(fn, list) {
var res = [];
var idx = 0;
var len = list.length;
while (idx < len) {
var nextidx = idx + 1;
while (nextidx < len && fn(list[idx], list[nextidx])) {
nextidx += 1;
}
res.push(list.slice(idx, nextidx));
idx = nextidx;
}
return res;
});
/***/ },
/* 227 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Returns `true` if the first argument is greater than the second; `false`
* otherwise.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Relation
* @sig Ord a => a -> a -> Boolean
* @param {*} a
* @param {*} b
* @return {Boolean}
* @see R.lt
* @example
*
* R.gt(2, 1); //=> true
* R.gt(2, 2); //=> false
* R.gt(2, 3); //=> false
* R.gt('a', 'z'); //=> false
* R.gt('z', 'a'); //=> true
*/
module.exports = _curry2(function gt(a, b) { return a > b; });
/***/ },
/* 228 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Returns `true` if the first argument is greater than or equal to the second;
* `false` otherwise.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Relation
* @sig Ord a => a -> a -> Boolean
* @param {Number} a
* @param {Number} b
* @return {Boolean}
* @see R.lte
* @example
*
* R.gte(2, 1); //=> true
* R.gte(2, 2); //=> true
* R.gte(2, 3); //=> false
* R.gte('a', 'z'); //=> false
* R.gte('z', 'a'); //=> true
*/
module.exports = _curry2(function gte(a, b) { return a >= b; });
/***/ },
/* 229 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _has = __webpack_require__(102);
/**
* Returns whether or not an object has an own property with the specified name
*
* @func
* @memberOf R
* @since v0.7.0
* @category Object
* @sig s -> {s: x} -> Boolean
* @param {String} prop The name of the property to check for.
* @param {Object} obj The object to query.
* @return {Boolean} Whether the property exists.
* @example
*
* var hasName = R.has('name');
* hasName({name: 'alice'}); //=> true
* hasName({name: 'bob'}); //=> true
* hasName({}); //=> false
*
* var point = {x: 0, y: 0};
* var pointHas = R.has(R.__, point);
* pointHas('x'); //=> true
* pointHas('y'); //=> true
* pointHas('z'); //=> false
*/
module.exports = _curry2(_has);
/***/ },
/* 230 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Returns whether or not an object or its prototype chain has a property with
* the specified name
*
* @func
* @memberOf R
* @since v0.7.0
* @category Object
* @sig s -> {s: x} -> Boolean
* @param {String} prop The name of the property to check for.
* @param {Object} obj The object to query.
* @return {Boolean} Whether the property exists.
* @example
*
* function Rectangle(width, height) {
* this.width = width;
* this.height = height;
* }
* Rectangle.prototype.area = function() {
* return this.width * this.height;
* };
*
* var square = new Rectangle(2, 2);
* R.hasIn('width', square); //=> true
* R.hasIn('area', square); //=> true
*/
module.exports = _curry2(function hasIn(prop, obj) {
return prop in obj;
});
/***/ },
/* 231 */
/***/ function(module, exports, __webpack_require__) {
var nth = __webpack_require__(203);
/**
* Returns the first element of the given list or string. In some libraries
* this function is named `first`.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig [a] -> a | Undefined
* @sig String -> String
* @param {Array|String} list
* @return {*}
* @see R.tail, R.init, R.last
* @example
*
* R.head(['fi', 'fo', 'fum']); //=> 'fi'
* R.head([]); //=> undefined
*
* R.head('abc'); //=> 'a'
* R.head(''); //=> ''
*/
module.exports = nth(0);
/***/ },
/* 232 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var _identity = __webpack_require__(233);
/**
* A function that does nothing but return the parameter supplied to it. Good
* as a default or placeholder function.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Function
* @sig a -> a
* @param {*} x The value to return.
* @return {*} The input value, `x`.
* @example
*
* R.identity(1); //=> 1
*
* var obj = {};
* R.identity(obj) === obj; //=> true
* @symb R.identity(a) = a
*/
module.exports = _curry1(_identity);
/***/ },
/* 233 */
/***/ function(module, exports) {
module.exports = function _identity(x) { return x; };
/***/ },
/* 234 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
var curryN = __webpack_require__(78);
/**
* Creates a function that will process either the `onTrue` or the `onFalse`
* function depending upon the result of the `condition` predicate.
*
* @func
* @memberOf R
* @since v0.8.0
* @category Logic
* @sig (*... -> Boolean) -> (*... -> *) -> (*... -> *) -> (*... -> *)
* @param {Function} condition A predicate function
* @param {Function} onTrue A function to invoke when the `condition` evaluates to a truthy value.
* @param {Function} onFalse A function to invoke when the `condition` evaluates to a falsy value.
* @return {Function} A new unary function that will process either the `onTrue` or the `onFalse`
* function depending upon the result of the `condition` predicate.
* @see R.unless, R.when
* @example
*
* var incCount = R.ifElse(
* R.has('count'),
* R.over(R.lensProp('count'), R.inc),
* R.assoc('count', 1)
* );
* incCount({}); //=> { count: 1 }
* incCount({ count: 1 }); //=> { count: 2 }
*/
module.exports = _curry3(function ifElse(condition, onTrue, onFalse) {
return curryN(Math.max(condition.length, onTrue.length, onFalse.length),
function _ifElse() {
return condition.apply(this, arguments) ? onTrue.apply(this, arguments) : onFalse.apply(this, arguments);
}
);
});
/***/ },
/* 235 */
/***/ function(module, exports, __webpack_require__) {
var add = __webpack_require__(74);
/**
* Increments its argument.
*
* @func
* @memberOf R
* @since v0.9.0
* @category Math
* @sig Number -> Number
* @param {Number} n
* @return {Number} n + 1
* @see R.dec
* @example
*
* R.inc(42); //=> 43
*/
module.exports = add(1);
/***/ },
/* 236 */
/***/ function(module, exports, __webpack_require__) {
var reduceBy = __webpack_require__(178);
/**
* Given a function that generates a key, turns a list of objects into an
* object indexing the objects by the given key. Note that if multiple
* objects generate the same value for the indexing key only the last value
* will be included in the generated object.
*
* Acts as a transducer if a transformer is given in list position.
*
* @func
* @memberOf R
* @since v0.19.0
* @category List
* @sig (a -> String) -> [{k: v}] -> {k: {k: v}}
* @param {Function} fn Function :: a -> String
* @param {Array} array The array of objects to index
* @return {Object} An object indexing each array element by the given property.
* @example
*
* var list = [{id: 'xyz', title: 'A'}, {id: 'abc', title: 'B'}];
* R.indexBy(R.prop('id'), list);
* //=> {abc: {id: 'abc', title: 'B'}, xyz: {id: 'xyz', title: 'A'}}
*/
module.exports = reduceBy(function(acc, elem) { return elem; }, null);
/***/ },
/* 237 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _indexOf = __webpack_require__(158);
var _isArray = __webpack_require__(85);
/**
* Returns the position of the first occurrence of an item in an array, or -1
* if the item is not included in the array. `R.equals` is used to determine
* equality.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig a -> [a] -> Number
* @param {*} target The item to find.
* @param {Array} xs The array to search in.
* @return {Number} the index of the target, or -1 if the target is not found.
* @see R.lastIndexOf
* @example
*
* R.indexOf(3, [1,2,3,4]); //=> 2
* R.indexOf(10, [1,2,3,4]); //=> -1
*/
module.exports = _curry2(function indexOf(target, xs) {
return typeof xs.indexOf === 'function' && !_isArray(xs) ?
xs.indexOf(target) :
_indexOf(xs, target, 0);
});
/***/ },
/* 238 */
/***/ function(module, exports, __webpack_require__) {
var slice = __webpack_require__(148);
/**
* Returns all but the last element of the given list or string.
*
* @func
* @memberOf R
* @since v0.9.0
* @category List
* @sig [a] -> [a]
* @sig String -> String
* @param {*} list
* @return {*}
* @see R.last, R.head, R.tail
* @example
*
* R.init([1, 2, 3]); //=> [1, 2]
* R.init([1, 2]); //=> [1]
* R.init([1]); //=> []
* R.init([]); //=> []
*
* R.init('abc'); //=> 'ab'
* R.init('ab'); //=> 'a'
* R.init('a'); //=> ''
* R.init(''); //=> ''
*/
module.exports = slice(0, -1);
/***/ },
/* 239 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* Inserts the supplied element into the list, at index `index`. _Note that
* this is not destructive_: it returns a copy of the list with the changes.
* <small>No lists have been harmed in the application of this function.</small>
*
* @func
* @memberOf R
* @since v0.2.2
* @category List
* @sig Number -> a -> [a] -> [a]
* @param {Number} index The position to insert the element
* @param {*} elt The element to insert into the Array
* @param {Array} list The list to insert into
* @return {Array} A new Array with `elt` inserted at `index`.
* @example
*
* R.insert(2, 'x', [1,2,3,4]); //=> [1,2,'x',3,4]
*/
module.exports = _curry3(function insert(idx, elt, list) {
idx = idx < list.length && idx >= 0 ? idx : list.length;
var result = Array.prototype.slice.call(list, 0);
result.splice(idx, 0, elt);
return result;
});
/***/ },
/* 240 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* Inserts the sub-list into the list, at index `index`. _Note that this is not
* destructive_: it returns a copy of the list with the changes.
* <small>No lists have been harmed in the application of this function.</small>
*
* @func
* @memberOf R
* @since v0.9.0
* @category List
* @sig Number -> [a] -> [a] -> [a]
* @param {Number} index The position to insert the sub-list
* @param {Array} elts The sub-list to insert into the Array
* @param {Array} list The list to insert the sub-list into
* @return {Array} A new Array with `elts` inserted starting at `index`.
* @example
*
* R.insertAll(2, ['x','y','z'], [1,2,3,4]); //=> [1,2,'x','y','z',3,4]
*/
module.exports = _curry3(function insertAll(idx, elts, list) {
idx = idx < list.length && idx >= 0 ? idx : list.length;
return [].concat(Array.prototype.slice.call(list, 0, idx),
elts,
Array.prototype.slice.call(list, idx));
});
/***/ },
/* 241 */
/***/ function(module, exports, __webpack_require__) {
var _contains = __webpack_require__(157);
var _curry2 = __webpack_require__(75);
var _filter = __webpack_require__(169);
var flip = __webpack_require__(221);
var uniq = __webpack_require__(242);
/**
* Combines two lists into a set (i.e. no duplicates) composed of those
* elements common to both lists.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Relation
* @sig [*] -> [*] -> [*]
* @param {Array} list1 The first list.
* @param {Array} list2 The second list.
* @return {Array} The list of elements found in both `list1` and `list2`.
* @see R.intersectionWith
* @example
*
* R.intersection([1,2,3,4], [7,6,5,4,3]); //=> [4, 3]
*/
module.exports = _curry2(function intersection(list1, list2) {
var lookupList, filteredList;
if (list1.length > list2.length) {
lookupList = list1;
filteredList = list2;
} else {
lookupList = list2;
filteredList = list1;
}
return uniq(_filter(flip(_contains)(lookupList), filteredList));
});
/***/ },
/* 242 */
/***/ function(module, exports, __webpack_require__) {
var identity = __webpack_require__(232);
var uniqBy = __webpack_require__(243);
/**
* Returns a new list containing only one copy of each element in the original
* list. `R.equals` is used to determine equality.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig [a] -> [a]
* @param {Array} list The array to consider.
* @return {Array} The list of unique items.
* @example
*
* R.uniq([1, 1, 2, 1]); //=> [1, 2]
* R.uniq([1, '1']); //=> [1, '1']
* R.uniq([[42], [42]]); //=> [[42]]
*/
module.exports = uniqBy(identity);
/***/ },
/* 243 */
/***/ function(module, exports, __webpack_require__) {
var _Set = __webpack_require__(244);
var _curry2 = __webpack_require__(75);
/**
* Returns a new list containing only one copy of each element in the original
* list, based upon the value returned by applying the supplied function to
* each list element. Prefers the first item if the supplied function produces
* the same value on two items. `R.equals` is used for comparison.
*
* @func
* @memberOf R
* @since v0.16.0
* @category List
* @sig (a -> b) -> [a] -> [a]
* @param {Function} fn A function used to produce a value to use during comparisons.
* @param {Array} list The array to consider.
* @return {Array} The list of unique items.
* @example
*
* R.uniqBy(Math.abs, [-1, -5, 2, 10, 1, 2]); //=> [-1, -5, 2, 10]
*/
module.exports = _curry2(function uniqBy(fn, list) {
var set = new _Set();
var result = [];
var idx = 0;
var appliedItem, item;
while (idx < list.length) {
item = list[idx];
appliedItem = fn(item);
if (set.add(appliedItem)) {
result.push(item);
}
idx += 1;
}
return result;
});
/***/ },
/* 244 */
/***/ function(module, exports, __webpack_require__) {
var _contains = __webpack_require__(157);
// A simple Set type that honours R.equals semantics
module.exports = (function() {
function _Set() {
/* globals Set */
this._nativeSet = typeof Set === 'function' ? new Set() : null;
this._items = {};
}
// until we figure out why jsdoc chokes on this
// @param item The item to add to the Set
// @returns {boolean} true if the item did not exist prior, otherwise false
//
_Set.prototype.add = function(item) {
return !hasOrAdd(item, true, this);
};
//
// @param item The item to check for existence in the Set
// @returns {boolean} true if the item exists in the Set, otherwise false
//
_Set.prototype.has = function(item) {
return hasOrAdd(item, false, this);
};
//
// Combines the logic for checking whether an item is a member of the set and
// for adding a new item to the set.
//
// @param item The item to check or add to the Set instance.
// @param shouldAdd If true, the item will be added to the set if it doesn't
// already exist.
// @param set The set instance to check or add to.
// @return {boolean} true if the item already existed, otherwise false.
//
function hasOrAdd(item, shouldAdd, set) {
var type = typeof item;
var prevSize, newSize;
switch (type) {
case 'string':
case 'number':
// distinguish between +0 and -0
if (item === 0 && 1 / item === -Infinity) {
if (set._items['-0']) {
return true;
} else {
if (shouldAdd) {
set._items['-0'] = true;
}
return false;
}
}
// these types can all utilise the native Set
if (set._nativeSet !== null) {
if (shouldAdd) {
prevSize = set._nativeSet.size;
set._nativeSet.add(item);
newSize = set._nativeSet.size;
return newSize === prevSize;
} else {
return set._nativeSet.has(item);
}
} else {
if (!(type in set._items)) {
if (shouldAdd) {
set._items[type] = {};
set._items[type][item] = true;
}
return false;
} else if (item in set._items[type]) {
return true;
} else {
if (shouldAdd) {
set._items[type][item] = true;
}
return false;
}
}
case 'boolean':
// set._items['boolean'] holds a two element array
// representing [ falseExists, trueExists ]
if (type in set._items) {
var bIdx = item ? 1 : 0;
if (set._items[type][bIdx]) {
return true;
} else {
if (shouldAdd) {
set._items[type][bIdx] = true;
}
return false;
}
} else {
if (shouldAdd) {
set._items[type] = item ? [false, true] : [true, false];
}
return false;
}
case 'function':
// compare functions for reference equality
if (set._nativeSet !== null) {
if (shouldAdd) {
prevSize = set._nativeSet.size;
set._nativeSet.add(item);
newSize = set._nativeSet.size;
return newSize === prevSize;
} else {
return set._nativeSet.has(item);
}
} else {
if (!(type in set._items)) {
if (shouldAdd) {
set._items[type] = [item];
}
return false;
}
if (!_contains(item, set._items[type])) {
if (shouldAdd) {
set._items[type].push(item);
}
return false;
}
return true;
}
case 'undefined':
if (set._items[type]) {
return true;
} else {
if (shouldAdd) {
set._items[type] = true;
}
return false;
}
case 'object':
if (item === null) {
if (!set._items['null']) {
if (shouldAdd) {
set._items['null'] = true;
}
return false;
}
return true;
}
/* falls through */
default:
// reduce the search size of heterogeneous sets by creating buckets
// for each type.
type = Object.prototype.toString.call(item);
if (!(type in set._items)) {
if (shouldAdd) {
set._items[type] = [item];
}
return false;
}
// scan through all previously applied items
if (!_contains(item, set._items[type])) {
if (shouldAdd) {
set._items[type].push(item);
}
return false;
}
return true;
}
}
return _Set;
}());
/***/ },
/* 245 */
/***/ function(module, exports, __webpack_require__) {
var _containsWith = __webpack_require__(185);
var _curry3 = __webpack_require__(82);
var uniqWith = __webpack_require__(246);
/**
* Combines two lists into a set (i.e. no duplicates) composed of those
* elements common to both lists. Duplication is determined according to the
* value returned by applying the supplied predicate to two list elements.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Relation
* @sig ((a, a) -> Boolean) -> [a] -> [a] -> [a]
* @param {Function} pred A predicate function that determines whether
* the two supplied elements are equal.
* @param {Array} list1 One list of items to compare
* @param {Array} list2 A second list of items to compare
* @return {Array} A new list containing those elements common to both lists.
* @see R.intersection
* @example
*
* var buffaloSpringfield = [
* {id: 824, name: 'Richie Furay'},
* {id: 956, name: 'Dewey Martin'},
* {id: 313, name: 'Bruce Palmer'},
* {id: 456, name: 'Stephen Stills'},
* {id: 177, name: 'Neil Young'}
* ];
* var csny = [
* {id: 204, name: 'David Crosby'},
* {id: 456, name: 'Stephen Stills'},
* {id: 539, name: 'Graham Nash'},
* {id: 177, name: 'Neil Young'}
* ];
*
* R.intersectionWith(R.eqBy(R.prop('id')), buffaloSpringfield, csny);
* //=> [{id: 456, name: 'Stephen Stills'}, {id: 177, name: 'Neil Young'}]
*/
module.exports = _curry3(function intersectionWith(pred, list1, list2) {
var lookupList, filteredList;
if (list1.length > list2.length) {
lookupList = list1;
filteredList = list2;
} else {
lookupList = list2;
filteredList = list1;
}
var results = [];
var idx = 0;
while (idx < filteredList.length) {
if (_containsWith(pred, filteredList[idx], lookupList)) {
results[results.length] = filteredList[idx];
}
idx += 1;
}
return uniqWith(pred, results);
});
/***/ },
/* 246 */
/***/ function(module, exports, __webpack_require__) {
var _containsWith = __webpack_require__(185);
var _curry2 = __webpack_require__(75);
/**
* Returns a new list containing only one copy of each element in the original
* list, based upon the value returned by applying the supplied predicate to
* two list elements. Prefers the first item if two items compare equal based
* on the predicate.
*
* @func
* @memberOf R
* @since v0.2.0
* @category List
* @sig (a, a -> Boolean) -> [a] -> [a]
* @param {Function} pred A predicate used to test whether two items are equal.
* @param {Array} list The array to consider.
* @return {Array} The list of unique items.
* @example
*
* var strEq = R.eqBy(String);
* R.uniqWith(strEq)([1, '1', 2, 1]); //=> [1, 2]
* R.uniqWith(strEq)([{}, {}]); //=> [{}]
* R.uniqWith(strEq)([1, '1', 1]); //=> [1]
* R.uniqWith(strEq)(['1', 1, 1]); //=> ['1']
*/
module.exports = _curry2(function uniqWith(pred, list) {
var idx = 0;
var len = list.length;
var result = [];
var item;
while (idx < len) {
item = list[idx];
if (!_containsWith(pred, item, result)) {
result[result.length] = item;
}
idx += 1;
}
return result;
});
/***/ },
/* 247 */
/***/ function(module, exports, __webpack_require__) {
var _checkForMethod = __webpack_require__(147);
var _curry2 = __webpack_require__(75);
/**
* Creates a new list with the separator interposed between elements.
*
* Dispatches to the `intersperse` method of the second argument, if present.
*
* @func
* @memberOf R
* @since v0.14.0
* @category List
* @sig a -> [a] -> [a]
* @param {*} separator The element to add to the list.
* @param {Array} list The list to be interposed.
* @return {Array} The new list.
* @example
*
* R.intersperse('n', ['ba', 'a', 'a']); //=> ['ba', 'n', 'a', 'n', 'a']
*/
module.exports = _curry2(_checkForMethod('intersperse', function intersperse(separator, list) {
var out = [];
var idx = 0;
var length = list.length;
while (idx < length) {
if (idx === length - 1) {
out.push(list[idx]);
} else {
out.push(list[idx], separator);
}
idx += 1;
}
return out;
}));
/***/ },
/* 248 */
/***/ function(module, exports, __webpack_require__) {
var _clone = __webpack_require__(137);
var _curry3 = __webpack_require__(82);
var _isTransformer = __webpack_require__(86);
var _reduce = __webpack_require__(95);
var _stepCat = __webpack_require__(249);
/**
* Transforms the items of the list with the transducer and appends the
* transformed items to the accumulator using an appropriate iterator function
* based on the accumulator type.
*
* The accumulator can be an array, string, object or a transformer. Iterated
* items will be appended to arrays and concatenated to strings. Objects will
* be merged directly or 2-item arrays will be merged as key, value pairs.
*
* The accumulator can also be a transformer object that provides a 2-arity
* reducing iterator function, step, 0-arity initial value function, init, and
* 1-arity result extraction function result. The step function is used as the
* iterator function in reduce. The result function is used to convert the
* final accumulator into the return type and in most cases is R.identity. The
* init function is used to provide the initial accumulator.
*
* The iteration is performed with R.reduce after initializing the transducer.
*
* @func
* @memberOf R
* @since v0.12.0
* @category List
* @sig a -> (b -> b) -> [c] -> a
* @param {*} acc The initial accumulator value.
* @param {Function} xf The transducer function. Receives a transformer and returns a transformer.
* @param {Array} list The list to iterate over.
* @return {*} The final, accumulated value.
* @example
*
* var numbers = [1, 2, 3, 4];
* var transducer = R.compose(R.map(R.add(1)), R.take(2));
*
* R.into([], transducer, numbers); //=> [2, 3]
*
* var intoArray = R.into([]);
* intoArray(transducer, numbers); //=> [2, 3]
*/
module.exports = _curry3(function into(acc, xf, list) {
return _isTransformer(acc) ?
_reduce(xf(acc), acc['@@transducer/init'](), list) :
_reduce(xf(_stepCat(acc)), _clone(acc, [], [], false), list);
});
/***/ },
/* 249 */
/***/ function(module, exports, __webpack_require__) {
var _assign = __webpack_require__(250);
var _identity = __webpack_require__(233);
var _isTransformer = __webpack_require__(86);
var isArrayLike = __webpack_require__(98);
var objOf = __webpack_require__(252);
module.exports = (function() {
var _stepCatArray = {
'@@transducer/init': Array,
'@@transducer/step': function(xs, x) {
xs.push(x);
return xs;
},
'@@transducer/result': _identity
};
var _stepCatString = {
'@@transducer/init': String,
'@@transducer/step': function(a, b) { return a + b; },
'@@transducer/result': _identity
};
var _stepCatObject = {
'@@transducer/init': Object,
'@@transducer/step': function(result, input) {
return _assign(
result,
isArrayLike(input) ? objOf(input[0], input[1]) : input
);
},
'@@transducer/result': _identity
};
return function _stepCat(obj) {
if (_isTransformer(obj)) {
return obj;
}
if (isArrayLike(obj)) {
return _stepCatArray;
}
if (typeof obj === 'string') {
return _stepCatString;
}
if (typeof obj === 'object') {
return _stepCatObject;
}
throw new Error('Cannot create transformer for ' + obj);
};
}());
/***/ },
/* 250 */
/***/ function(module, exports, __webpack_require__) {
var _objectAssign = __webpack_require__(251);
module.exports =
typeof Object.assign === 'function' ? Object.assign : _objectAssign;
/***/ },
/* 251 */
/***/ function(module, exports, __webpack_require__) {
var _has = __webpack_require__(102);
// Based on https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
module.exports = function _objectAssign(target) {
if (target == null) {
throw new TypeError('Cannot convert undefined or null to object');
}
var output = Object(target);
var idx = 1;
var length = arguments.length;
while (idx < length) {
var source = arguments[idx];
if (source != null) {
for (var nextKey in source) {
if (_has(nextKey, source)) {
output[nextKey] = source[nextKey];
}
}
}
idx += 1;
}
return output;
};
/***/ },
/* 252 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Creates an object containing a single key:value pair.
*
* @func
* @memberOf R
* @since v0.18.0
* @category Object
* @sig String -> a -> {String:a}
* @param {String} key
* @param {*} val
* @return {Object}
* @see R.pair
* @example
*
* var matchPhrases = R.compose(
* R.objOf('must'),
* R.map(R.objOf('match_phrase'))
* );
* matchPhrases(['foo', 'bar', 'baz']); //=> {must: [{match_phrase: 'foo'}, {match_phrase: 'bar'}, {match_phrase: 'baz'}]}
*/
module.exports = _curry2(function objOf(key, val) {
var obj = {};
obj[key] = val;
return obj;
});
/***/ },
/* 253 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var _has = __webpack_require__(102);
var keys = __webpack_require__(101);
/**
* Same as R.invertObj, however this accounts for objects with duplicate values
* by putting the values into an array.
*
* @func
* @memberOf R
* @since v0.9.0
* @category Object
* @sig {s: x} -> {x: [ s, ... ]}
* @param {Object} obj The object or array to invert
* @return {Object} out A new object with keys
* in an array.
* @example
*
* var raceResultsByFirstName = {
* first: 'alice',
* second: 'jake',
* third: 'alice',
* };
* R.invert(raceResultsByFirstName);
* //=> { 'alice': ['first', 'third'], 'jake':['second'] }
*/
module.exports = _curry1(function invert(obj) {
var props = keys(obj);
var len = props.length;
var idx = 0;
var out = {};
while (idx < len) {
var key = props[idx];
var val = obj[key];
var list = _has(val, out) ? out[val] : (out[val] = []);
list[list.length] = key;
idx += 1;
}
return out;
});
/***/ },
/* 254 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var keys = __webpack_require__(101);
/**
* Returns a new object with the keys of the given object as values, and the
* values of the given object, which are coerced to strings, as keys. Note
* that the last key found is preferred when handling the same value.
*
* @func
* @memberOf R
* @since v0.9.0
* @category Object
* @sig {s: x} -> {x: s}
* @param {Object} obj The object or array to invert
* @return {Object} out A new object
* @example
*
* var raceResults = {
* first: 'alice',
* second: 'jake'
* };
* R.invertObj(raceResults);
* //=> { 'alice': 'first', 'jake':'second' }
*
* // Alternatively:
* var raceResults = ['alice', 'jake'];
* R.invertObj(raceResults);
* //=> { 'alice': '0', 'jake':'1' }
*/
module.exports = _curry1(function invertObj(obj) {
var props = keys(obj);
var len = props.length;
var idx = 0;
var out = {};
while (idx < len) {
var key = props[idx];
out[obj[key]] = key;
idx += 1;
}
return out;
});
/***/ },
/* 255 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _isFunction = __webpack_require__(125);
var curryN = __webpack_require__(78);
var toString = __webpack_require__(155);
/**
* Turns a named method with a specified arity into a function that can be
* called directly supplied with arguments and a target object.
*
* The returned function is curried and accepts `arity + 1` parameters where
* the final parameter is the target object.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Function
* @sig Number -> String -> (a -> b -> ... -> n -> Object -> *)
* @param {Number} arity Number of arguments the returned function should take
* before the target object.
* @param {String} method Name of the method to call.
* @return {Function} A new curried function.
* @example
*
* var sliceFrom = R.invoker(1, 'slice');
* sliceFrom(6, 'abcdefghijklm'); //=> 'ghijklm'
* var sliceFrom6 = R.invoker(2, 'slice')(6);
* sliceFrom6(8, 'abcdefghijklm'); //=> 'gh'
* @symb R.invoker(0, 'method')(o) = o['method']()
* @symb R.invoker(1, 'method')(a, o) = o['method'](a)
* @symb R.invoker(2, 'method')(a, b, o) = o['method'](a, b)
*/
module.exports = _curry2(function invoker(arity, method) {
return curryN(arity + 1, function() {
var target = arguments[arity];
if (target != null && _isFunction(target[method])) {
return target[method].apply(target, Array.prototype.slice.call(arguments, 0, arity));
}
throw new TypeError(toString(target) + ' does not have a method named "' + method + '"');
});
});
/***/ },
/* 256 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* See if an object (`val`) is an instance of the supplied constructor. This
* function will check up the inheritance chain, if any.
*
* @func
* @memberOf R
* @since v0.3.0
* @category Type
* @sig (* -> {*}) -> a -> Boolean
* @param {Object} ctor A constructor
* @param {*} val The value to test
* @return {Boolean}
* @example
*
* R.is(Object, {}); //=> true
* R.is(Number, 1); //=> true
* R.is(Object, 1); //=> false
* R.is(String, 's'); //=> true
* R.is(String, new String('')); //=> true
* R.is(Object, new String('')); //=> true
* R.is(Object, 's'); //=> false
* R.is(Number, {}); //=> false
*/
module.exports = _curry2(function is(Ctor, val) {
return val != null && val.constructor === Ctor || val instanceof Ctor;
});
/***/ },
/* 257 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var empty = __webpack_require__(208);
var equals = __webpack_require__(159);
/**
* Returns `true` if the given value is its type's empty value; `false`
* otherwise.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Logic
* @sig a -> Boolean
* @param {*} x
* @return {Boolean}
* @see R.empty
* @example
*
* R.isEmpty([1, 2, 3]); //=> false
* R.isEmpty([]); //=> true
* R.isEmpty(''); //=> true
* R.isEmpty(null); //=> false
* R.isEmpty({}); //=> true
* R.isEmpty({length: 0}); //=> false
*/
module.exports = _curry1(function isEmpty(x) {
return x != null && equals(x, empty(x));
});
/***/ },
/* 258 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
/**
* Checks if the input value is `null` or `undefined`.
*
* @func
* @memberOf R
* @since v0.9.0
* @category Type
* @sig * -> Boolean
* @param {*} x The value to test.
* @return {Boolean} `true` if `x` is `undefined` or `null`, otherwise `false`.
* @example
*
* R.isNil(null); //=> true
* R.isNil(undefined); //=> true
* R.isNil(0); //=> false
* R.isNil([]); //=> false
*/
module.exports = _curry1(function isNil(x) { return x == null; });
/***/ },
/* 259 */
/***/ function(module, exports, __webpack_require__) {
var invoker = __webpack_require__(255);
/**
* Returns a string made by inserting the `separator` between each element and
* concatenating all the elements into a single string.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig String -> [a] -> String
* @param {Number|String} separator The string used to separate the elements.
* @param {Array} xs The elements to join into a string.
* @return {String} str The string made by concatenating `xs` with `separator`.
* @see R.split
* @example
*
* var spacer = R.join(' ');
* spacer(['a', 2, 3.4]); //=> 'a 2 3.4'
* R.join('|', [1, 2, 3]); //=> '1|2|3'
*/
module.exports = invoker(1, 'join');
/***/ },
/* 260 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var converge = __webpack_require__(176);
/**
* juxt applies a list of functions to a list of values.
*
* @func
* @memberOf R
* @since v0.19.0
* @category Function
* @sig [(a, b, ..., m) -> n] -> ((a, b, ..., m) -> [n])
* @param {Array} fns An array of functions
* @return {Function} A function that returns a list of values after applying each of the original `fns` to its parameters.
* @see R.applySpec
* @example
*
* var getRange = R.juxt([Math.min, Math.max]);
* getRange(3, 4, 9, -3); //=> [-3, 9]
* @symb R.juxt([f, g, h])(a, b) = [f(a, b), g(a, b), h(a, b)]
*/
module.exports = _curry1(function juxt(fns) {
return converge(function() { return Array.prototype.slice.call(arguments, 0); }, fns);
});
/***/ },
/* 261 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
/**
* Returns a list containing the names of all the properties of the supplied
* object, including prototype properties.
* Note that the order of the output array is not guaranteed to be consistent
* across different JS platforms.
*
* @func
* @memberOf R
* @since v0.2.0
* @category Object
* @sig {k: v} -> [k]
* @param {Object} obj The object to extract properties from
* @return {Array} An array of the object's own and prototype properties.
* @example
*
* var F = function() { this.x = 'X'; };
* F.prototype.y = 'Y';
* var f = new F();
* R.keysIn(f); //=> ['x', 'y']
*/
module.exports = _curry1(function keysIn(obj) {
var prop;
var ks = [];
for (prop in obj) {
ks[ks.length] = prop;
}
return ks;
});
/***/ },
/* 262 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _isArray = __webpack_require__(85);
var equals = __webpack_require__(159);
/**
* Returns the position of the last occurrence of an item in an array, or -1 if
* the item is not included in the array. `R.equals` is used to determine
* equality.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig a -> [a] -> Number
* @param {*} target The item to find.
* @param {Array} xs The array to search in.
* @return {Number} the index of the target, or -1 if the target is not found.
* @see R.indexOf
* @example
*
* R.lastIndexOf(3, [-1,3,3,0,1,2,3,4]); //=> 6
* R.lastIndexOf(10, [1,2,3,4]); //=> -1
*/
module.exports = _curry2(function lastIndexOf(target, xs) {
if (typeof xs.lastIndexOf === 'function' && !_isArray(xs)) {
return xs.lastIndexOf(target);
} else {
var idx = xs.length - 1;
while (idx >= 0) {
if (equals(xs[idx], target)) {
return idx;
}
idx -= 1;
}
return -1;
}
});
/***/ },
/* 263 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var _isNumber = __webpack_require__(264);
/**
* Returns the number of elements in the array by returning `list.length`.
*
* @func
* @memberOf R
* @since v0.3.0
* @category List
* @sig [a] -> Number
* @param {Array} list The array to inspect.
* @return {Number} The length of the array.
* @example
*
* R.length([]); //=> 0
* R.length([1, 2, 3]); //=> 3
*/
module.exports = _curry1(function length(list) {
return list != null && _isNumber(list.length) ? list.length : NaN;
});
/***/ },
/* 264 */
/***/ function(module, exports) {
module.exports = function _isNumber(x) {
return Object.prototype.toString.call(x) === '[object Number]';
};
/***/ },
/* 265 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var map = __webpack_require__(93);
/**
* Returns a lens for the given getter and setter functions. The getter "gets"
* the value of the focus; the setter "sets" the value of the focus. The setter
* should not mutate the data structure.
*
* @func
* @memberOf R
* @since v0.8.0
* @category Object
* @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
* @sig (s -> a) -> ((a, s) -> s) -> Lens s a
* @param {Function} getter
* @param {Function} setter
* @return {Lens}
* @see R.view, R.set, R.over, R.lensIndex, R.lensProp
* @example
*
* var xLens = R.lens(R.prop('x'), R.assoc('x'));
*
* R.view(xLens, {x: 1, y: 2}); //=> 1
* R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2}
* R.over(xLens, R.negate, {x: 1, y: 2}); //=> {x: -1, y: 2}
*/
module.exports = _curry2(function lens(getter, setter) {
return function(toFunctorFn) {
return function(target) {
return map(
function(focus) {
return setter(focus, target);
},
toFunctorFn(getter(target))
);
};
};
});
/***/ },
/* 266 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var lens = __webpack_require__(265);
var nth = __webpack_require__(203);
var update = __webpack_require__(267);
/**
* Returns a lens whose focus is the specified index.
*
* @func
* @memberOf R
* @since v0.14.0
* @category Object
* @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
* @sig Number -> Lens s a
* @param {Number} n
* @return {Lens}
* @see R.view, R.set, R.over
* @example
*
* var headLens = R.lensIndex(0);
*
* R.view(headLens, ['a', 'b', 'c']); //=> 'a'
* R.set(headLens, 'x', ['a', 'b', 'c']); //=> ['x', 'b', 'c']
* R.over(headLens, R.toUpper, ['a', 'b', 'c']); //=> ['A', 'b', 'c']
*/
module.exports = _curry1(function lensIndex(n) {
return lens(nth(n), update(n));
});
/***/ },
/* 267 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
var adjust = __webpack_require__(81);
var always = __webpack_require__(69);
/**
* Returns a new copy of the array with the element at the provided index
* replaced with the given value.
*
* @func
* @memberOf R
* @since v0.14.0
* @category List
* @sig Number -> a -> [a] -> [a]
* @param {Number} idx The index to update.
* @param {*} x The value to exist at the given index of the returned array.
* @param {Array|Arguments} list The source array-like object to be updated.
* @return {Array} A copy of `list` with the value at index `idx` replaced with `x`.
* @see R.adjust
* @example
*
* R.update(1, 11, [0, 1, 2]); //=> [0, 11, 2]
* R.update(1)(11)([0, 1, 2]); //=> [0, 11, 2]
* @symb R.update(-1, a, [b, c]) = [b, a]
* @symb R.update(0, a, [b, c]) = [a, c]
* @symb R.update(1, a, [b, c]) = [b, a]
*/
module.exports = _curry3(function update(idx, x, list) {
return adjust(always(x), idx, list);
});
/***/ },
/* 268 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var assocPath = __webpack_require__(120);
var lens = __webpack_require__(265);
var path = __webpack_require__(269);
/**
* Returns a lens whose focus is the specified path.
*
* @func
* @memberOf R
* @since v0.19.0
* @category Object
* @typedefn Idx = String | Int
* @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
* @sig [Idx] -> Lens s a
* @param {Array} path The path to use.
* @return {Lens}
* @see R.view, R.set, R.over
* @example
*
* var xHeadYLens = R.lensPath(['x', 0, 'y']);
*
* R.view(xHeadYLens, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});
* //=> 2
* R.set(xHeadYLens, 1, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});
* //=> {x: [{y: 1, z: 3}, {y: 4, z: 5}]}
* R.over(xHeadYLens, R.negate, {x: [{y: 2, z: 3}, {y: 4, z: 5}]});
* //=> {x: [{y: -2, z: 3}, {y: 4, z: 5}]}
*/
module.exports = _curry1(function lensPath(p) {
return lens(path(p), assocPath(p));
});
/***/ },
/* 269 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Retrieve the value at a given path.
*
* @func
* @memberOf R
* @since v0.2.0
* @category Object
* @typedefn Idx = String | Int
* @sig [Idx] -> {a} -> a | Undefined
* @param {Array} path The path to use.
* @param {Object} obj The object to retrieve the nested property from.
* @return {*} The data at `path`.
* @see R.prop
* @example
*
* R.path(['a', 'b'], {a: {b: 2}}); //=> 2
* R.path(['a', 'b'], {c: {b: 2}}); //=> undefined
*/
module.exports = _curry2(function path(paths, obj) {
var val = obj;
var idx = 0;
while (idx < paths.length) {
if (val == null) {
return;
}
val = val[paths[idx]];
idx += 1;
}
return val;
});
/***/ },
/* 270 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var assoc = __webpack_require__(119);
var lens = __webpack_require__(265);
var prop = __webpack_require__(104);
/**
* Returns a lens whose focus is the specified property.
*
* @func
* @memberOf R
* @since v0.14.0
* @category Object
* @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
* @sig String -> Lens s a
* @param {String} k
* @return {Lens}
* @see R.view, R.set, R.over
* @example
*
* var xLens = R.lensProp('x');
*
* R.view(xLens, {x: 1, y: 2}); //=> 1
* R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2}
* R.over(xLens, R.negate, {x: 1, y: 2}); //=> {x: -1, y: 2}
*/
module.exports = _curry1(function lensProp(k) {
return lens(prop(k), assoc(k));
});
/***/ },
/* 271 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Returns `true` if the first argument is less than the second; `false`
* otherwise.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Relation
* @sig Ord a => a -> a -> Boolean
* @param {*} a
* @param {*} b
* @return {Boolean}
* @see R.gt
* @example
*
* R.lt(2, 1); //=> false
* R.lt(2, 2); //=> false
* R.lt(2, 3); //=> true
* R.lt('a', 'z'); //=> true
* R.lt('z', 'a'); //=> false
*/
module.exports = _curry2(function lt(a, b) { return a < b; });
/***/ },
/* 272 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Returns `true` if the first argument is less than or equal to the second;
* `false` otherwise.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Relation
* @sig Ord a => a -> a -> Boolean
* @param {Number} a
* @param {Number} b
* @return {Boolean}
* @see R.gte
* @example
*
* R.lte(2, 1); //=> false
* R.lte(2, 2); //=> true
* R.lte(2, 3); //=> true
* R.lte('a', 'z'); //=> true
* R.lte('z', 'a'); //=> false
*/
module.exports = _curry2(function lte(a, b) { return a <= b; });
/***/ },
/* 273 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* The mapAccum function behaves like a combination of map and reduce; it
* applies a function to each element of a list, passing an accumulating
* parameter from left to right, and returning a final value of this
* accumulator together with the new list.
*
* The iterator function receives two arguments, *acc* and *value*, and should
* return a tuple *[acc, value]*.
*
* @func
* @memberOf R
* @since v0.10.0
* @category List
* @sig (acc -> x -> (acc, y)) -> acc -> [x] -> (acc, [y])
* @param {Function} fn The function to be called on every element of the input `list`.
* @param {*} acc The accumulator value.
* @param {Array} list The list to iterate over.
* @return {*} The final, accumulated value.
* @see R.addIndex, R.mapAccumRight
* @example
*
* var digits = ['1', '2', '3', '4'];
* var appender = (a, b) => [a + b, a + b];
*
* R.mapAccum(appender, 0, digits); //=> ['01234', ['01', '012', '0123', '01234']]
* @symb R.mapAccum(f, a, [b, c, d]) = [
* f(f(f(a, b)[0], c)[0], d)[0],
* [
* f(a, b)[1],
* f(f(a, b)[0], c)[1],
* f(f(f(a, b)[0], c)[0], d)[1]
* ]
* ]
*/
module.exports = _curry3(function mapAccum(fn, acc, list) {
var idx = 0;
var len = list.length;
var result = [];
var tuple = [acc];
while (idx < len) {
tuple = fn(tuple[0], list[idx]);
result[idx] = tuple[1];
idx += 1;
}
return [tuple[0], result];
});
/***/ },
/* 274 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* The mapAccumRight function behaves like a combination of map and reduce; it
* applies a function to each element of a list, passing an accumulating
* parameter from right to left, and returning a final value of this
* accumulator together with the new list.
*
* Similar to `mapAccum`, except moves through the input list from the right to
* the left.
*
* The iterator function receives two arguments, *value* and *acc*, and should
* return a tuple *[value, acc]*.
*
* @func
* @memberOf R
* @since v0.10.0
* @category List
* @sig (x-> acc -> (y, acc)) -> acc -> [x] -> ([y], acc)
* @param {Function} fn The function to be called on every element of the input `list`.
* @param {*} acc The accumulator value.
* @param {Array} list The list to iterate over.
* @return {*} The final, accumulated value.
* @see R.addIndex, R.mapAccum
* @example
*
* var digits = ['1', '2', '3', '4'];
* var append = (a, b) => [a + b, a + b];
*
* R.mapAccumRight(append, 5, digits); //=> [['12345', '2345', '345', '45'], '12345']
* @symb R.mapAccumRight(f, a, [b, c, d]) = [
* [
* f(b, f(c, f(d, a)[0])[0])[1],
* f(c, f(d, a)[0])[1],
* f(d, a)[1],
* ]
* f(b, f(c, f(d, a)[0])[0])[0],
* ]
*/
module.exports = _curry3(function mapAccumRight(fn, acc, list) {
var idx = list.length - 1;
var result = [];
var tuple = [acc];
while (idx >= 0) {
tuple = fn(list[idx], tuple[0]);
result[idx] = tuple[1];
idx -= 1;
}
return [result, tuple[0]];
});
/***/ },
/* 275 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _reduce = __webpack_require__(95);
var keys = __webpack_require__(101);
/**
* An Object-specific version of `map`. The function is applied to three
* arguments: *(value, key, obj)*. If only the value is significant, use
* `map` instead.
*
* @func
* @memberOf R
* @since v0.9.0
* @category Object
* @sig ((*, String, Object) -> *) -> Object -> Object
* @param {Function} fn
* @param {Object} obj
* @return {Object}
* @see R.map
* @example
*
* var values = { x: 1, y: 2, z: 3 };
* var prependKeyAndDouble = (num, key, obj) => key + (num * 2);
*
* R.mapObjIndexed(prependKeyAndDouble, values); //=> { x: 'x2', y: 'y4', z: 'z6' }
*/
module.exports = _curry2(function mapObjIndexed(fn, obj) {
return _reduce(function(acc, key) {
acc[key] = fn(obj[key], key, obj);
return acc;
}, {}, keys(obj));
});
/***/ },
/* 276 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Tests a regular expression against a String. Note that this function will
* return an empty array when there are no matches. This differs from
* [`String.prototype.match`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match)
* which returns `null` when there are no matches.
*
* @func
* @memberOf R
* @since v0.1.0
* @category String
* @sig RegExp -> String -> [String | Undefined]
* @param {RegExp} rx A regular expression.
* @param {String} str The string to match against
* @return {Array} The list of matches or empty array.
* @see R.test
* @example
*
* R.match(/([a-z]a)/g, 'bananas'); //=> ['ba', 'na', 'na']
* R.match(/a/, 'b'); //=> []
* R.match(/a/, null); //=> TypeError: null does not have a method named "match"
*/
module.exports = _curry2(function match(rx, str) {
return str.match(rx) || [];
});
/***/ },
/* 277 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _isInteger = __webpack_require__(121);
/**
* mathMod behaves like the modulo operator should mathematically, unlike the
* `%` operator (and by extension, R.modulo). So while "-17 % 5" is -2,
* mathMod(-17, 5) is 3. mathMod requires Integer arguments, and returns NaN
* when the modulus is zero or negative.
*
* @func
* @memberOf R
* @since v0.3.0
* @category Math
* @sig Number -> Number -> Number
* @param {Number} m The dividend.
* @param {Number} p the modulus.
* @return {Number} The result of `b mod a`.
* @example
*
* R.mathMod(-17, 5); //=> 3
* R.mathMod(17, 5); //=> 2
* R.mathMod(17, -5); //=> NaN
* R.mathMod(17, 0); //=> NaN
* R.mathMod(17.2, 5); //=> NaN
* R.mathMod(17, 5.3); //=> NaN
*
* var clock = R.mathMod(R.__, 12);
* clock(15); //=> 3
* clock(24); //=> 0
*
* var seventeenMod = R.mathMod(17);
* seventeenMod(3); //=> 2
* seventeenMod(4); //=> 1
* seventeenMod(10); //=> 7
*/
module.exports = _curry2(function mathMod(m, p) {
if (!_isInteger(m)) { return NaN; }
if (!_isInteger(p) || p < 1) { return NaN; }
return ((m % p) + p) % p;
});
/***/ },
/* 278 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* Takes a function and two values, and returns whichever value produces the
* larger result when passed to the provided function.
*
* @func
* @memberOf R
* @since v0.8.0
* @category Relation
* @sig Ord b => (a -> b) -> a -> a -> a
* @param {Function} f
* @param {*} a
* @param {*} b
* @return {*}
* @see R.max, R.minBy
* @example
*
* // square :: Number -> Number
* var square = n => n * n;
*
* R.maxBy(square, -3, 2); //=> -3
*
* R.reduce(R.maxBy(square), 0, [3, -5, 4, 1, -2]); //=> -5
* R.reduce(R.maxBy(square), 0, []); //=> 0
*/
module.exports = _curry3(function maxBy(f, a, b) {
return f(b) > f(a) ? b : a;
});
/***/ },
/* 279 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var sum = __webpack_require__(280);
/**
* Returns the mean of the given list of numbers.
*
* @func
* @memberOf R
* @since v0.14.0
* @category Math
* @sig [Number] -> Number
* @param {Array} list
* @return {Number}
* @example
*
* R.mean([2, 7, 9]); //=> 6
* R.mean([]); //=> NaN
*/
module.exports = _curry1(function mean(list) {
return sum(list) / list.length;
});
/***/ },
/* 280 */
/***/ function(module, exports, __webpack_require__) {
var add = __webpack_require__(74);
var reduce = __webpack_require__(105);
/**
* Adds together all the elements of a list.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Math
* @sig [Number] -> Number
* @param {Array} list An array of numbers
* @return {Number} The sum of all the numbers in the list.
* @see R.reduce
* @example
*
* R.sum([2,4,6,8,100,1]); //=> 121
*/
module.exports = reduce(add, 0);
/***/ },
/* 281 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var mean = __webpack_require__(279);
/**
* Returns the median of the given list of numbers.
*
* @func
* @memberOf R
* @since v0.14.0
* @category Math
* @sig [Number] -> Number
* @param {Array} list
* @return {Number}
* @example
*
* R.median([2, 9, 7]); //=> 7
* R.median([7, 2, 10, 9]); //=> 8
* R.median([]); //=> NaN
*/
module.exports = _curry1(function median(list) {
var len = list.length;
if (len === 0) {
return NaN;
}
var width = 2 - len % 2;
var idx = (len - width) / 2;
return mean(Array.prototype.slice.call(list, 0).sort(function(a, b) {
return a < b ? -1 : a > b ? 1 : 0;
}).slice(idx, idx + width));
});
/***/ },
/* 282 */
/***/ function(module, exports, __webpack_require__) {
var _arity = __webpack_require__(79);
var _curry1 = __webpack_require__(70);
var _has = __webpack_require__(102);
var toString = __webpack_require__(155);
/**
* Creates a new function that, when invoked, caches the result of calling `fn`
* for a given argument set and returns the result. Subsequent calls to the
* memoized `fn` with the same argument set will not result in an additional
* call to `fn`; instead, the cached result for that set of arguments will be
* returned.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Function
* @sig (*... -> a) -> (*... -> a)
* @param {Function} fn The function to memoize.
* @return {Function} Memoized version of `fn`.
* @example
*
* var count = 0;
* var factorial = R.memoize(n => {
* count += 1;
* return R.product(R.range(1, n + 1));
* });
* factorial(5); //=> 120
* factorial(5); //=> 120
* factorial(5); //=> 120
* count; //=> 1
*/
module.exports = _curry1(function memoize(fn) {
var cache = {};
return _arity(fn.length, function() {
var key = toString(arguments);
if (!_has(key, cache)) {
cache[key] = fn.apply(this, arguments);
}
return cache[key];
});
});
/***/ },
/* 283 */
/***/ function(module, exports, __webpack_require__) {
var _assign = __webpack_require__(250);
var _curry2 = __webpack_require__(75);
/**
* Create a new object with the own properties of the first object merged with
* the own properties of the second object. If a key exists in both objects,
* the value from the second object will be used.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Object
* @sig {k: v} -> {k: v} -> {k: v}
* @param {Object} l
* @param {Object} r
* @return {Object}
* @see R.mergeWith, R.mergeWithKey
* @example
*
* R.merge({ 'name': 'fred', 'age': 10 }, { 'age': 40 });
* //=> { 'name': 'fred', 'age': 40 }
*
* var resetToDefault = R.merge(R.__, {x: 0});
* resetToDefault({x: 5, y: 2}); //=> {x: 0, y: 2}
* @symb R.merge({ x: 1, y: 2 }, { y: 5, z: 3 }) = { x: 1, y: 5, z: 3 }
*/
module.exports = _curry2(function merge(l, r) {
return _assign({}, l, r);
});
/***/ },
/* 284 */
/***/ function(module, exports, __webpack_require__) {
var _assign = __webpack_require__(250);
var _curry1 = __webpack_require__(70);
/**
* Merges a list of objects together into one object.
*
* @func
* @memberOf R
* @since v0.10.0
* @category List
* @sig [{k: v}] -> {k: v}
* @param {Array} list An array of objects
* @return {Object} A merged object.
* @see R.reduce
* @example
*
* R.mergeAll([{foo:1},{bar:2},{baz:3}]); //=> {foo:1,bar:2,baz:3}
* R.mergeAll([{foo:1},{foo:2},{bar:2}]); //=> {foo:2,bar:2}
* @symb R.mergeAll([{ x: 1 }, { y: 2 }, { z: 3 }]) = { x: 1, y: 2, z: 3 }
*/
module.exports = _curry1(function mergeAll(list) {
return _assign.apply(null, [{}].concat(list));
});
/***/ },
/* 285 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
var mergeWithKey = __webpack_require__(286);
/**
* Creates a new object with the own properties of the two provided objects. If
* a key exists in both objects, the provided function is applied to the values
* associated with the key in each object, with the result being used as the
* value associated with the key in the returned object. The key will be
* excluded from the returned object if the resulting value is `undefined`.
*
* @func
* @memberOf R
* @since v0.19.0
* @category Object
* @sig (a -> a -> a) -> {a} -> {a} -> {a}
* @param {Function} fn
* @param {Object} l
* @param {Object} r
* @return {Object}
* @see R.merge, R.mergeWithKey
* @example
*
* R.mergeWith(R.concat,
* { a: true, values: [10, 20] },
* { b: true, values: [15, 35] });
* //=> { a: true, b: true, values: [10, 20, 15, 35] }
*/
module.exports = _curry3(function mergeWith(fn, l, r) {
return mergeWithKey(function(_, _l, _r) {
return fn(_l, _r);
}, l, r);
});
/***/ },
/* 286 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
var _has = __webpack_require__(102);
/**
* Creates a new object with the own properties of the two provided objects. If
* a key exists in both objects, the provided function is applied to the key
* and the values associated with the key in each object, with the result being
* used as the value associated with the key in the returned object. The key
* will be excluded from the returned object if the resulting value is
* `undefined`.
*
* @func
* @memberOf R
* @since v0.19.0
* @category Object
* @sig (String -> a -> a -> a) -> {a} -> {a} -> {a}
* @param {Function} fn
* @param {Object} l
* @param {Object} r
* @return {Object}
* @see R.merge, R.mergeWith
* @example
*
* let concatValues = (k, l, r) => k == 'values' ? R.concat(l, r) : r
* R.mergeWithKey(concatValues,
* { a: true, thing: 'foo', values: [10, 20] },
* { b: true, thing: 'bar', values: [15, 35] });
* //=> { a: true, b: true, thing: 'bar', values: [10, 20, 15, 35] }
* @symb R.mergeWithKey(f, { x: 1, y: 2 }, { y: 5, z: 3 }) = { x: 1, y: f('y', 2, 5), z: 3 }
*/
module.exports = _curry3(function mergeWithKey(fn, l, r) {
var result = {};
var k;
for (k in l) {
if (_has(k, l)) {
result[k] = _has(k, r) ? fn(k, l[k], r[k]) : l[k];
}
}
for (k in r) {
if (_has(k, r) && !(_has(k, result))) {
result[k] = r[k];
}
}
return result;
});
/***/ },
/* 287 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Returns the smaller of its two arguments.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Relation
* @sig Ord a => a -> a -> a
* @param {*} a
* @param {*} b
* @return {*}
* @see R.minBy, R.max
* @example
*
* R.min(789, 123); //=> 123
* R.min('a', 'b'); //=> 'a'
*/
module.exports = _curry2(function min(a, b) { return b < a ? b : a; });
/***/ },
/* 288 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* Takes a function and two values, and returns whichever value produces the
* smaller result when passed to the provided function.
*
* @func
* @memberOf R
* @since v0.8.0
* @category Relation
* @sig Ord b => (a -> b) -> a -> a -> a
* @param {Function} f
* @param {*} a
* @param {*} b
* @return {*}
* @see R.min, R.maxBy
* @example
*
* // square :: Number -> Number
* var square = n => n * n;
*
* R.minBy(square, -3, 2); //=> 2
*
* R.reduce(R.minBy(square), Infinity, [3, -5, 4, 1, -2]); //=> 1
* R.reduce(R.minBy(square), Infinity, []); //=> Infinity
*/
module.exports = _curry3(function minBy(f, a, b) {
return f(b) < f(a) ? b : a;
});
/***/ },
/* 289 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Divides the first parameter by the second and returns the remainder. Note
* that this function preserves the JavaScript-style behavior for modulo. For
* mathematical modulo see `mathMod`.
*
* @func
* @memberOf R
* @since v0.1.1
* @category Math
* @sig Number -> Number -> Number
* @param {Number} a The value to the divide.
* @param {Number} b The pseudo-modulus
* @return {Number} The result of `b % a`.
* @see R.mathMod
* @example
*
* R.modulo(17, 3); //=> 2
* // JS behavior:
* R.modulo(-17, 3); //=> -2
* R.modulo(17, -3); //=> 2
*
* var isOdd = R.modulo(R.__, 2);
* isOdd(42); //=> 0
* isOdd(21); //=> 1
*/
module.exports = _curry2(function modulo(a, b) { return a % b; });
/***/ },
/* 290 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Multiplies two numbers. Equivalent to `a * b` but curried.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Math
* @sig Number -> Number -> Number
* @param {Number} a The first value.
* @param {Number} b The second value.
* @return {Number} The result of `a * b`.
* @see R.divide
* @example
*
* var double = R.multiply(2);
* var triple = R.multiply(3);
* double(3); //=> 6
* triple(4); //=> 12
* R.multiply(2, 5); //=> 10
*/
module.exports = _curry2(function multiply(a, b) { return a * b; });
/***/ },
/* 291 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
/**
* Negates its argument.
*
* @func
* @memberOf R
* @since v0.9.0
* @category Math
* @sig Number -> Number
* @param {Number} n
* @return {Number}
* @example
*
* R.negate(42); //=> -42
*/
module.exports = _curry1(function negate(n) { return -n; });
/***/ },
/* 292 */
/***/ function(module, exports, __webpack_require__) {
var _complement = __webpack_require__(167);
var _curry2 = __webpack_require__(75);
var _dispatchable = __webpack_require__(84);
var _xany = __webpack_require__(108);
var any = __webpack_require__(107);
/**
* Returns `true` if no elements of the list match the predicate, `false`
* otherwise.
*
* Dispatches to the `any` method of the second argument, if present.
*
* @func
* @memberOf R
* @since v0.12.0
* @category List
* @sig (a -> Boolean) -> [a] -> Boolean
* @param {Function} fn The predicate function.
* @param {Array} list The array to consider.
* @return {Boolean} `true` if the predicate is not satisfied by every element, `false` otherwise.
* @see R.all, R.any
* @example
*
* var isEven = n => n % 2 === 0;
*
* R.none(isEven, [1, 3, 5, 7, 9, 11]); //=> true
* R.none(isEven, [1, 3, 5, 7, 8, 11]); //=> false
*/
module.exports = _curry2(_complement(_dispatchable(['any'], _xany, any)));
/***/ },
/* 293 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var curryN = __webpack_require__(78);
var nth = __webpack_require__(203);
/**
* Returns a function which returns its nth argument.
*
* @func
* @memberOf R
* @since v0.9.0
* @category Function
* @sig Number -> *... -> *
* @param {Number} n
* @return {Function}
* @example
*
* R.nthArg(1)('a', 'b', 'c'); //=> 'b'
* R.nthArg(-1)('a', 'b', 'c'); //=> 'c'
* @symb R.nthArg(-1)(a, b, c) = c
* @symb R.nthArg(0)(a, b, c) = a
* @symb R.nthArg(1)(a, b, c) = b
*/
module.exports = _curry1(function nthArg(n) {
var arity = n < 0 ? 1 : n + 1;
return curryN(arity, function() {
return nth(n, arguments);
});
});
/***/ },
/* 294 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var _of = __webpack_require__(295);
/**
* Returns a singleton array containing the value provided.
*
* Note this `of` is different from the ES6 `of`; See
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of
*
* @func
* @memberOf R
* @since v0.3.0
* @category Function
* @sig a -> [a]
* @param {*} x any value
* @return {Array} An array wrapping `x`.
* @example
*
* R.of(null); //=> [null]
* R.of([42]); //=> [[42]]
*/
module.exports = _curry1(_of);
/***/ },
/* 295 */
/***/ function(module, exports) {
module.exports = function _of(x) { return [x]; };
/***/ },
/* 296 */
/***/ function(module, exports, __webpack_require__) {
var _contains = __webpack_require__(157);
var _curry2 = __webpack_require__(75);
/**
* Returns a partial copy of an object omitting the keys specified.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Object
* @sig [String] -> {String: *} -> {String: *}
* @param {Array} names an array of String property names to omit from the new object
* @param {Object} obj The object to copy from
* @return {Object} A new object with properties from `names` not on it.
* @see R.pick
* @example
*
* R.omit(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {b: 2, c: 3}
*/
module.exports = _curry2(function omit(names, obj) {
var result = {};
for (var prop in obj) {
if (!_contains(prop, names)) {
result[prop] = obj[prop];
}
}
return result;
});
/***/ },
/* 297 */
/***/ function(module, exports, __webpack_require__) {
var _arity = __webpack_require__(79);
var _curry1 = __webpack_require__(70);
/**
* Accepts a function `fn` and returns a function that guards invocation of
* `fn` such that `fn` can only ever be called once, no matter how many times
* the returned function is invoked. The first value calculated is returned in
* subsequent invocations.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Function
* @sig (a... -> b) -> (a... -> b)
* @param {Function} fn The function to wrap in a call-only-once wrapper.
* @return {Function} The wrapped function.
* @example
*
* var addOneOnce = R.once(x => x + 1);
* addOneOnce(10); //=> 11
* addOneOnce(addOneOnce(50)); //=> 11
*/
module.exports = _curry1(function once(fn) {
var called = false;
var result;
return _arity(fn.length, function() {
if (called) {
return result;
}
called = true;
result = fn.apply(this, arguments);
return result;
});
});
/***/ },
/* 298 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* Returns the result of "setting" the portion of the given data structure
* focused by the given lens to the result of applying the given function to
* the focused value.
*
* @func
* @memberOf R
* @since v0.16.0
* @category Object
* @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
* @sig Lens s a -> (a -> a) -> s -> s
* @param {Lens} lens
* @param {*} v
* @param {*} x
* @return {*}
* @see R.prop, R.lensIndex, R.lensProp
* @example
*
* var headLens = R.lensIndex(0);
*
* R.over(headLens, R.toUpper, ['foo', 'bar', 'baz']); //=> ['FOO', 'bar', 'baz']
*/
module.exports = (function() {
// `Identity` is a functor that holds a single value, where `map` simply
// transforms the held value with the provided function.
var Identity = function(x) {
return {value: x, map: function(f) { return Identity(f(x)); }};
};
return _curry3(function over(lens, f, x) {
// The value returned by the getter function is first transformed with `f`,
// then set as the value of an `Identity`. This is then mapped over with the
// setter function of the lens.
return lens(function(y) { return Identity(f(y)); })(x).value;
});
}());
/***/ },
/* 299 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Takes two arguments, `fst` and `snd`, and returns `[fst, snd]`.
*
* @func
* @memberOf R
* @since v0.18.0
* @category List
* @sig a -> b -> (a,b)
* @param {*} fst
* @param {*} snd
* @return {Array}
* @see R.objOf, R.of
* @example
*
* R.pair('foo', 'bar'); //=> ['foo', 'bar']
*/
module.exports = _curry2(function pair(fst, snd) { return [fst, snd]; });
/***/ },
/* 300 */
/***/ function(module, exports, __webpack_require__) {
var _concat = __webpack_require__(77);
var _createPartialApplicator = __webpack_require__(301);
/**
* Takes a function `f` and a list of arguments, and returns a function `g`.
* When applied, `g` returns the result of applying `f` to the arguments
* provided initially followed by the arguments provided to `g`.
*
* @func
* @memberOf R
* @since v0.10.0
* @category Function
* @sig ((a, b, c, ..., n) -> x) -> [a, b, c, ...] -> ((d, e, f, ..., n) -> x)
* @param {Function} f
* @param {Array} args
* @return {Function}
* @see R.partialRight
* @example
*
* var multiply2 = (a, b) => a * b;
* var double = R.partial(multiply2, [2]);
* double(2); //=> 4
*
* var greet = (salutation, title, firstName, lastName) =>
* salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';
*
* var sayHello = R.partial(greet, ['Hello']);
* var sayHelloToMs = R.partial(sayHello, ['Ms.']);
* sayHelloToMs('Jane', 'Jones'); //=> 'Hello, Ms. Jane Jones!'
* @symb R.partial(f, [a, b])(c, d) = f(a, b, c, d)
*/
module.exports = _createPartialApplicator(_concat);
/***/ },
/* 301 */
/***/ function(module, exports, __webpack_require__) {
var _arity = __webpack_require__(79);
var _curry2 = __webpack_require__(75);
module.exports = function _createPartialApplicator(concat) {
return _curry2(function(fn, args) {
return _arity(Math.max(0, fn.length - args.length), function() {
return fn.apply(this, concat(args, arguments));
});
});
};
/***/ },
/* 302 */
/***/ function(module, exports, __webpack_require__) {
var _concat = __webpack_require__(77);
var _createPartialApplicator = __webpack_require__(301);
var flip = __webpack_require__(221);
/**
* Takes a function `f` and a list of arguments, and returns a function `g`.
* When applied, `g` returns the result of applying `f` to the arguments
* provided to `g` followed by the arguments provided initially.
*
* @func
* @memberOf R
* @since v0.10.0
* @category Function
* @sig ((a, b, c, ..., n) -> x) -> [d, e, f, ..., n] -> ((a, b, c, ...) -> x)
* @param {Function} f
* @param {Array} args
* @return {Function}
* @see R.partial
* @example
*
* var greet = (salutation, title, firstName, lastName) =>
* salutation + ', ' + title + ' ' + firstName + ' ' + lastName + '!';
*
* var greetMsJaneJones = R.partialRight(greet, ['Ms.', 'Jane', 'Jones']);
*
* greetMsJaneJones('Hello'); //=> 'Hello, Ms. Jane Jones!'
* @symb R.partialRight(f, [a, b])(c, d) = f(c, d, a, b)
*/
module.exports = _createPartialApplicator(flip(_concat));
/***/ },
/* 303 */
/***/ function(module, exports, __webpack_require__) {
var filter = __webpack_require__(168);
var juxt = __webpack_require__(260);
var reject = __webpack_require__(166);
/**
* Takes a predicate and a list or other "filterable" object and returns the
* pair of filterable objects of the same type of elements which do and do not
* satisfy, the predicate, respectively.
*
* @func
* @memberOf R
* @since v0.1.4
* @category List
* @sig Filterable f => (a -> Boolean) -> f a -> [f a, f a]
* @param {Function} pred A predicate to determine which side the element belongs to.
* @param {Array} filterable the list (or other filterable) to partition.
* @return {Array} An array, containing first the subset of elements that satisfy the
* predicate, and second the subset of elements that do not satisfy.
* @see R.filter, R.reject
* @example
*
* R.partition(R.contains('s'), ['sss', 'ttt', 'foo', 'bars']);
* // => [ [ 'sss', 'bars' ], [ 'ttt', 'foo' ] ]
*
* R.partition(R.contains('s'), { a: 'sss', b: 'ttt', foo: 'bars' });
* // => [ { a: 'sss', foo: 'bars' }, { b: 'ttt' } ]
*/
module.exports = juxt([filter, reject]);
/***/ },
/* 304 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
var equals = __webpack_require__(159);
var path = __webpack_require__(269);
/**
* Determines whether a nested path on an object has a specific value, in
* `R.equals` terms. Most likely used to filter a list.
*
* @func
* @memberOf R
* @since v0.7.0
* @category Relation
* @typedefn Idx = String | Int
* @sig [Idx] -> a -> {a} -> Boolean
* @param {Array} path The path of the nested property to use
* @param {*} val The value to compare the nested property with
* @param {Object} obj The object to check the nested property in
* @return {Boolean} `true` if the value equals the nested object property,
* `false` otherwise.
* @example
*
* var user1 = { address: { zipCode: 90210 } };
* var user2 = { address: { zipCode: 55555 } };
* var user3 = { name: 'Bob' };
* var users = [ user1, user2, user3 ];
* var isFamous = R.pathEq(['address', 'zipCode'], 90210);
* R.filter(isFamous, users); //=> [ user1 ]
*/
module.exports = _curry3(function pathEq(_path, val, obj) {
return equals(path(_path, obj), val);
});
/***/ },
/* 305 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
var defaultTo = __webpack_require__(182);
var path = __webpack_require__(269);
/**
* If the given, non-null object has a value at the given path, returns the
* value at that path. Otherwise returns the provided default value.
*
* @func
* @memberOf R
* @since v0.18.0
* @category Object
* @typedefn Idx = String | Int
* @sig a -> [Idx] -> {a} -> a
* @param {*} d The default value.
* @param {Array} p The path to use.
* @param {Object} obj The object to retrieve the nested property from.
* @return {*} The data at `path` of the supplied object or the default value.
* @example
*
* R.pathOr('N/A', ['a', 'b'], {a: {b: 2}}); //=> 2
* R.pathOr('N/A', ['a', 'b'], {c: {b: 2}}); //=> "N/A"
*/
module.exports = _curry3(function pathOr(d, p, obj) {
return defaultTo(d, path(p, obj));
});
/***/ },
/* 306 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
var path = __webpack_require__(269);
/**
* Returns `true` if the specified object property at given path satisfies the
* given predicate; `false` otherwise.
*
* @func
* @memberOf R
* @since v0.19.0
* @category Logic
* @typedefn Idx = String | Int
* @sig (a -> Boolean) -> [Idx] -> {a} -> Boolean
* @param {Function} pred
* @param {Array} propPath
* @param {*} obj
* @return {Boolean}
* @see R.propSatisfies, R.path
* @example
*
* R.pathSatisfies(y => y > 0, ['x', 'y'], {x: {y: 2}}); //=> true
*/
module.exports = _curry3(function pathSatisfies(pred, propPath, obj) {
return propPath.length > 0 && pred(path(propPath, obj));
});
/***/ },
/* 307 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Returns a partial copy of an object containing only the keys specified. If
* the key does not exist, the property is ignored.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Object
* @sig [k] -> {k: v} -> {k: v}
* @param {Array} names an array of String property names to copy onto a new object
* @param {Object} obj The object to copy from
* @return {Object} A new object with only properties from `names` on it.
* @see R.omit, R.props
* @example
*
* R.pick(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}
* R.pick(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1}
*/
module.exports = _curry2(function pick(names, obj) {
var result = {};
var idx = 0;
while (idx < names.length) {
if (names[idx] in obj) {
result[names[idx]] = obj[names[idx]];
}
idx += 1;
}
return result;
});
/***/ },
/* 308 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Similar to `pick` except that this one includes a `key: undefined` pair for
* properties that don't exist.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Object
* @sig [k] -> {k: v} -> {k: v}
* @param {Array} names an array of String property names to copy onto a new object
* @param {Object} obj The object to copy from
* @return {Object} A new object with only properties from `names` on it.
* @see R.pick
* @example
*
* R.pickAll(['a', 'd'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, d: 4}
* R.pickAll(['a', 'e', 'f'], {a: 1, b: 2, c: 3, d: 4}); //=> {a: 1, e: undefined, f: undefined}
*/
module.exports = _curry2(function pickAll(names, obj) {
var result = {};
var idx = 0;
var len = names.length;
while (idx < len) {
var name = names[idx];
result[name] = obj[name];
idx += 1;
}
return result;
});
/***/ },
/* 309 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Returns a partial copy of an object containing only the keys that satisfy
* the supplied predicate.
*
* @func
* @memberOf R
* @since v0.8.0
* @category Object
* @sig (v, k -> Boolean) -> {k: v} -> {k: v}
* @param {Function} pred A predicate to determine whether or not a key
* should be included on the output object.
* @param {Object} obj The object to copy from
* @return {Object} A new object with only properties that satisfy `pred`
* on it.
* @see R.pick, R.filter
* @example
*
* var isUpperCase = (val, key) => key.toUpperCase() === key;
* R.pickBy(isUpperCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}
*/
module.exports = _curry2(function pickBy(test, obj) {
var result = {};
for (var prop in obj) {
if (test(obj[prop], prop, obj)) {
result[prop] = obj[prop];
}
}
return result;
});
/***/ },
/* 310 */
/***/ function(module, exports, __webpack_require__) {
var composeK = __webpack_require__(150);
var reverse = __webpack_require__(149);
/**
* Returns the left-to-right Kleisli composition of the provided functions,
* each of which must return a value of a type supported by [`chain`](#chain).
*
* `R.pipeK(f, g, h)` is equivalent to `R.pipe(R.chain(f), R.chain(g), R.chain(h))`.
*
* @func
* @memberOf R
* @since v0.16.0
* @category Function
* @sig Chain m => ((a -> m b), (b -> m c), ..., (y -> m z)) -> (a -> m z)
* @param {...Function}
* @return {Function}
* @see R.composeK
* @example
*
* // parseJson :: String -> Maybe *
* // get :: String -> Object -> Maybe *
*
* // getStateCode :: Maybe String -> Maybe String
* var getStateCode = R.pipeK(
* parseJson,
* get('user'),
* get('address'),
* get('state'),
* R.compose(Maybe.of, R.toUpper)
* );
*
* getStateCode('{"user":{"address":{"state":"ny"}}}');
* //=> Just('NY')
* getStateCode('[Invalid JSON]');
* //=> Nothing()
* @symb R.pipeK(f, g, h)(a) = R.chain(h, R.chain(g, f(a)))
*/
module.exports = function pipeK() {
if (arguments.length === 0) {
throw new Error('pipeK requires at least one argument');
}
return composeK.apply(this, reverse(arguments));
};
/***/ },
/* 311 */
/***/ function(module, exports, __webpack_require__) {
var _concat = __webpack_require__(77);
var _curry2 = __webpack_require__(75);
/**
* Returns a new list with the given element at the front, followed by the
* contents of the list.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig a -> [a] -> [a]
* @param {*} el The item to add to the head of the output list.
* @param {Array} list The array to add to the tail of the output list.
* @return {Array} A new array.
* @see R.append
* @example
*
* R.prepend('fee', ['fi', 'fo', 'fum']); //=> ['fee', 'fi', 'fo', 'fum']
*/
module.exports = _curry2(function prepend(el, list) {
return _concat([el], list);
});
/***/ },
/* 312 */
/***/ function(module, exports, __webpack_require__) {
var multiply = __webpack_require__(290);
var reduce = __webpack_require__(105);
/**
* Multiplies together all the elements of a list.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Math
* @sig [Number] -> Number
* @param {Array} list An array of numbers
* @return {Number} The product of all the numbers in the list.
* @see R.reduce
* @example
*
* R.product([2,4,6,8,100,1]); //=> 38400
*/
module.exports = reduce(multiply, 1);
/***/ },
/* 313 */
/***/ function(module, exports, __webpack_require__) {
var _map = __webpack_require__(94);
var identity = __webpack_require__(232);
var pickAll = __webpack_require__(308);
var useWith = __webpack_require__(314);
/**
* Reasonable analog to SQL `select` statement.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Object
* @category Relation
* @sig [k] -> [{k: v}] -> [{k: v}]
* @param {Array} props The property names to project
* @param {Array} objs The objects to query
* @return {Array} An array of objects with just the `props` properties.
* @example
*
* var abby = {name: 'Abby', age: 7, hair: 'blond', grade: 2};
* var fred = {name: 'Fred', age: 12, hair: 'brown', grade: 7};
* var kids = [abby, fred];
* R.project(['name', 'grade'], kids); //=> [{name: 'Abby', grade: 2}, {name: 'Fred', grade: 7}]
*/
module.exports = useWith(_map, [pickAll, identity]); // passing `identity` gives correct arity
/***/ },
/* 314 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var curryN = __webpack_require__(78);
/**
* Accepts a function `fn` and a list of transformer functions and returns a
* new curried function. When the new function is invoked, it calls the
* function `fn` with parameters consisting of the result of calling each
* supplied handler on successive arguments to the new function.
*
* If more arguments are passed to the returned function than transformer
* functions, those arguments are passed directly to `fn` as additional
* parameters. If you expect additional arguments that don't need to be
* transformed, although you can ignore them, it's best to pass an identity
* function so that the new function reports the correct arity.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Function
* @sig (x1 -> x2 -> ... -> z) -> [(a -> x1), (b -> x2), ...] -> (a -> b -> ... -> z)
* @param {Function} fn The function to wrap.
* @param {Array} transformers A list of transformer functions
* @return {Function} The wrapped function.
* @see R.converge
* @example
*
* R.useWith(Math.pow, [R.identity, R.identity])(3, 4); //=> 81
* R.useWith(Math.pow, [R.identity, R.identity])(3)(4); //=> 81
* R.useWith(Math.pow, [R.dec, R.inc])(3, 4); //=> 32
* R.useWith(Math.pow, [R.dec, R.inc])(3)(4); //=> 32
* @symb R.useWith(f, [g, h])(a, b) = f(g(a), h(b))
*/
module.exports = _curry2(function useWith(fn, transformers) {
return curryN(transformers.length, function() {
var args = [];
var idx = 0;
while (idx < transformers.length) {
args.push(transformers[idx].call(this, arguments[idx]));
idx += 1;
}
return fn.apply(this, args.concat(Array.prototype.slice.call(arguments, transformers.length)));
});
});
/***/ },
/* 315 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
var equals = __webpack_require__(159);
/**
* Returns `true` if the specified object property is equal, in `R.equals`
* terms, to the given value; `false` otherwise.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Relation
* @sig String -> a -> Object -> Boolean
* @param {String} name
* @param {*} val
* @param {*} obj
* @return {Boolean}
* @see R.equals, R.propSatisfies
* @example
*
* var abby = {name: 'Abby', age: 7, hair: 'blond'};
* var fred = {name: 'Fred', age: 12, hair: 'brown'};
* var rusty = {name: 'Rusty', age: 10, hair: 'brown'};
* var alois = {name: 'Alois', age: 15, disposition: 'surly'};
* var kids = [abby, fred, rusty, alois];
* var hasBrownHair = R.propEq('hair', 'brown');
* R.filter(hasBrownHair, kids); //=> [fred, rusty]
*/
module.exports = _curry3(function propEq(name, val, obj) {
return equals(val, obj[name]);
});
/***/ },
/* 316 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
var is = __webpack_require__(256);
/**
* Returns `true` if the specified object property is of the given type;
* `false` otherwise.
*
* @func
* @memberOf R
* @since v0.16.0
* @category Type
* @sig Type -> String -> Object -> Boolean
* @param {Function} type
* @param {String} name
* @param {*} obj
* @return {Boolean}
* @see R.is, R.propSatisfies
* @example
*
* R.propIs(Number, 'x', {x: 1, y: 2}); //=> true
* R.propIs(Number, 'x', {x: 'foo'}); //=> false
* R.propIs(Number, 'x', {}); //=> false
*/
module.exports = _curry3(function propIs(type, name, obj) {
return is(type, obj[name]);
});
/***/ },
/* 317 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
var _has = __webpack_require__(102);
/**
* If the given, non-null object has an own property with the specified name,
* returns the value of that property. Otherwise returns the provided default
* value.
*
* @func
* @memberOf R
* @since v0.6.0
* @category Object
* @sig a -> String -> Object -> a
* @param {*} val The default value.
* @param {String} p The name of the property to return.
* @param {Object} obj The object to query.
* @return {*} The value of given property of the supplied object or the default value.
* @example
*
* var alice = {
* name: 'ALICE',
* age: 101
* };
* var favorite = R.prop('favoriteLibrary');
* var favoriteWithDefault = R.propOr('Ramda', 'favoriteLibrary');
*
* favorite(alice); //=> undefined
* favoriteWithDefault(alice); //=> 'Ramda'
*/
module.exports = _curry3(function propOr(val, p, obj) {
return (obj != null && _has(p, obj)) ? obj[p] : val;
});
/***/ },
/* 318 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* Returns `true` if the specified object property satisfies the given
* predicate; `false` otherwise.
*
* @func
* @memberOf R
* @since v0.16.0
* @category Logic
* @sig (a -> Boolean) -> String -> {String: a} -> Boolean
* @param {Function} pred
* @param {String} name
* @param {*} obj
* @return {Boolean}
* @see R.propEq, R.propIs
* @example
*
* R.propSatisfies(x => x > 0, 'x', {x: 1, y: 2}); //=> true
*/
module.exports = _curry3(function propSatisfies(pred, name, obj) {
return pred(obj[name]);
});
/***/ },
/* 319 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Acts as multiple `prop`: array of keys in, array of values out. Preserves
* order.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Object
* @sig [k] -> {k: v} -> [v]
* @param {Array} ps The property names to fetch
* @param {Object} obj The object to query
* @return {Array} The corresponding values or partially applied function.
* @example
*
* R.props(['x', 'y'], {x: 1, y: 2}); //=> [1, 2]
* R.props(['c', 'a', 'b'], {b: 2, a: 1}); //=> [undefined, 1, 2]
*
* var fullName = R.compose(R.join(' '), R.props(['first', 'last']));
* fullName({last: 'Bullet-Tooth', age: 33, first: 'Tony'}); //=> 'Tony Bullet-Tooth'
*/
module.exports = _curry2(function props(ps, obj) {
var len = ps.length;
var out = [];
var idx = 0;
while (idx < len) {
out[idx] = obj[ps[idx]];
idx += 1;
}
return out;
});
/***/ },
/* 320 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _isNumber = __webpack_require__(264);
/**
* Returns a list of numbers from `from` (inclusive) to `to` (exclusive).
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig Number -> Number -> [Number]
* @param {Number} from The first number in the list.
* @param {Number} to One more than the last number in the list.
* @return {Array} The list of numbers in tthe set `[a, b)`.
* @example
*
* R.range(1, 5); //=> [1, 2, 3, 4]
* R.range(50, 53); //=> [50, 51, 52]
*/
module.exports = _curry2(function range(from, to) {
if (!(_isNumber(from) && _isNumber(to))) {
throw new TypeError('Both arguments to range must be numbers');
}
var result = [];
var n = from;
while (n < to) {
result.push(n);
n += 1;
}
return result;
});
/***/ },
/* 321 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* Returns a single item by iterating through the list, successively calling
* the iterator function and passing it an accumulator value and the current
* value from the array, and then passing the result to the next call.
*
* Similar to `reduce`, except moves through the input list from the right to
* the left.
*
* The iterator function receives two values: *(value, acc)*, while the arguments'
* order of `reduce`'s iterator function is *(acc, value)*.
*
* Note: `R.reduceRight` does not skip deleted or unassigned indices (sparse
* arrays), unlike the native `Array.prototype.reduce` method. For more details
* on this behavior, see:
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight#Description
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig (a, b -> b) -> b -> [a] -> b
* @param {Function} fn The iterator function. Receives two values, the current element from the array
* and the accumulator.
* @param {*} acc The accumulator value.
* @param {Array} list The list to iterate over.
* @return {*} The final, accumulated value.
* @see R.reduce, R.addIndex
* @example
*
* R.reduceRight(R.subtract, 0, [1, 2, 3, 4]) // => (1 - (2 - (3 - (4 - 0)))) = -2
* - -2
* / \ / \
* 1 - 1 3
* / \ / \
* 2 - ==> 2 -1
* / \ / \
* 3 - 3 4
* / \ / \
* 4 0 4 0
*
* @symb R.reduceRight(f, a, [b, c, d]) = f(b, f(c, f(d, a)))
*/
module.exports = _curry3(function reduceRight(fn, acc, list) {
var idx = list.length - 1;
while (idx >= 0) {
acc = fn(list[idx], acc);
idx -= 1;
}
return acc;
});
/***/ },
/* 322 */
/***/ function(module, exports, __webpack_require__) {
var _curryN = __webpack_require__(80);
var _reduce = __webpack_require__(95);
var _reduced = __webpack_require__(88);
/**
* Like `reduce`, `reduceWhile` returns a single item by iterating through
* the list, successively calling the iterator function. `reduceWhile` also
* takes a predicate that is evaluated before each step. If the predicate returns
* `false`, it "short-circuits" the iteration and returns the current value
* of the accumulator.
*
* @func
* @memberOf R
* @since v0.22.0
* @category List
* @sig ((a, b) -> Boolean) -> ((a, b) -> a) -> a -> [b] -> a
* @param {Function} pred The predicate. It is passed the accumulator and the
* current element.
* @param {Function} fn The iterator function. Receives two values, the
* accumulator and the current element.
* @param {*} a The accumulator value.
* @param {Array} list The list to iterate over.
* @return {*} The final, accumulated value.
* @see R.reduce, R.reduced
* @example
*
* var isOdd = (acc, x) => x % 2 === 1;
* var xs = [1, 3, 5, 60, 777, 800];
* R.reduceWhile(isOdd, R.add, 0, xs); //=> 9
*
* var ys = [2, 4, 6]
* R.reduceWhile(isOdd, R.add, 111, ys); //=> 111
*/
module.exports = _curryN(4, [], function _reduceWhile(pred, fn, a, list) {
return _reduce(function(acc, x) {
return pred(acc, x) ? fn(acc, x) : _reduced(acc);
}, a, list);
});
/***/ },
/* 323 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var _reduced = __webpack_require__(88);
/**
* Returns a value wrapped to indicate that it is the final value of the reduce
* and transduce functions. The returned value should be considered a black
* box: the internal structure is not guaranteed to be stable.
*
* Note: this optimization is unavailable to functions not explicitly listed
* above. For instance, it is not currently supported by reduceRight.
*
* @func
* @memberOf R
* @since v0.15.0
* @category List
* @sig a -> *
* @param {*} x The final value of the reduce.
* @return {*} The wrapped value.
* @see R.reduce, R.transduce
* @example
*
* R.reduce(
* R.pipe(R.add, R.when(R.gte(R.__, 10), R.reduced)),
* 0,
* [1, 2, 3, 4, 5]) // 10
*/
module.exports = _curry1(_reduced);
/***/ },
/* 324 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* Removes the sub-list of `list` starting at index `start` and containing
* `count` elements. _Note that this is not destructive_: it returns a copy of
* the list with the changes.
* <small>No lists have been harmed in the application of this function.</small>
*
* @func
* @memberOf R
* @since v0.2.2
* @category List
* @sig Number -> Number -> [a] -> [a]
* @param {Number} start The position to start removing elements
* @param {Number} count The number of elements to remove
* @param {Array} list The list to remove from
* @return {Array} A new Array with `count` elements from `start` removed.
* @example
*
* R.remove(2, 3, [1,2,3,4,5,6,7,8]); //=> [1,2,6,7,8]
*/
module.exports = _curry3(function remove(start, count, list) {
var result = Array.prototype.slice.call(list, 0);
result.splice(start, count);
return result;
});
/***/ },
/* 325 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var always = __webpack_require__(69);
var times = __webpack_require__(326);
/**
* Returns a fixed list of size `n` containing a specified identical value.
*
* @func
* @memberOf R
* @since v0.1.1
* @category List
* @sig a -> n -> [a]
* @param {*} value The value to repeat.
* @param {Number} n The desired size of the output list.
* @return {Array} A new array containing `n` `value`s.
* @example
*
* R.repeat('hi', 5); //=> ['hi', 'hi', 'hi', 'hi', 'hi']
*
* var obj = {};
* var repeatedObjs = R.repeat(obj, 5); //=> [{}, {}, {}, {}, {}]
* repeatedObjs[0] === repeatedObjs[1]; //=> true
* @symb R.repeat(a, 0) = []
* @symb R.repeat(a, 1) = [a]
* @symb R.repeat(a, 2) = [a, a]
*/
module.exports = _curry2(function repeat(value, n) {
return times(always(value), n);
});
/***/ },
/* 326 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Calls an input function `n` times, returning an array containing the results
* of those function calls.
*
* `fn` is passed one argument: The current value of `n`, which begins at `0`
* and is gradually incremented to `n - 1`.
*
* @func
* @memberOf R
* @since v0.2.3
* @category List
* @sig (Number -> a) -> Number -> [a]
* @param {Function} fn The function to invoke. Passed one argument, the current value of `n`.
* @param {Number} n A value between `0` and `n - 1`. Increments after each function call.
* @return {Array} An array containing the return values of all calls to `fn`.
* @example
*
* R.times(R.identity, 5); //=> [0, 1, 2, 3, 4]
* @symb R.times(f, 0) = []
* @symb R.times(f, 1) = [f(0)]
* @symb R.times(f, 2) = [f(0), f(1)]
*/
module.exports = _curry2(function times(fn, n) {
var len = Number(n);
var idx = 0;
var list;
if (len < 0 || isNaN(len)) {
throw new RangeError('n must be a non-negative number');
}
list = new Array(len);
while (idx < len) {
list[idx] = fn(idx);
idx += 1;
}
return list;
});
/***/ },
/* 327 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* Replace a substring or regex match in a string with a replacement.
*
* @func
* @memberOf R
* @since v0.7.0
* @category String
* @sig RegExp|String -> String -> String -> String
* @param {RegExp|String} pattern A regular expression or a substring to match.
* @param {String} replacement The string to replace the matches with.
* @param {String} str The String to do the search and replacement in.
* @return {String} The result.
* @example
*
* R.replace('foo', 'bar', 'foo foo foo'); //=> 'bar foo foo'
* R.replace(/foo/, 'bar', 'foo foo foo'); //=> 'bar foo foo'
*
* // Use the "g" (global) flag to replace all occurrences:
* R.replace(/foo/g, 'bar', 'foo foo foo'); //=> 'bar bar bar'
*/
module.exports = _curry3(function replace(regex, replacement, str) {
return str.replace(regex, replacement);
});
/***/ },
/* 328 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* Scan is similar to reduce, but returns a list of successively reduced values
* from the left
*
* @func
* @memberOf R
* @since v0.10.0
* @category List
* @sig (a,b -> a) -> a -> [b] -> [a]
* @param {Function} fn The iterator function. Receives two values, the accumulator and the
* current element from the array
* @param {*} acc The accumulator value.
* @param {Array} list The list to iterate over.
* @return {Array} A list of all intermediately reduced values.
* @example
*
* var numbers = [1, 2, 3, 4];
* var factorials = R.scan(R.multiply, 1, numbers); //=> [1, 1, 2, 6, 24]
* @symb R.scan(f, a, [b, c]) = [a, f(a, b), f(f(a, b), c)]
*/
module.exports = _curry3(function scan(fn, acc, list) {
var idx = 0;
var len = list.length;
var result = [acc];
while (idx < len) {
acc = fn(acc, list[idx]);
result[idx + 1] = acc;
idx += 1;
}
return result;
});
/***/ },
/* 329 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var ap = __webpack_require__(110);
var map = __webpack_require__(93);
var prepend = __webpack_require__(311);
var reduceRight = __webpack_require__(321);
/**
* Transforms a [Traversable](https://github.com/fantasyland/fantasy-land#traversable)
* of [Applicative](https://github.com/fantasyland/fantasy-land#applicative) into an
* Applicative of Traversable.
*
* Dispatches to the `sequence` method of the second argument, if present.
*
* @func
* @memberOf R
* @since v0.19.0
* @category List
* @sig (Applicative f, Traversable t) => (a -> f a) -> t (f a) -> f (t a)
* @param {Function} of
* @param {*} traversable
* @return {*}
* @see R.traverse
* @example
*
* R.sequence(Maybe.of, [Just(1), Just(2), Just(3)]); //=> Just([1, 2, 3])
* R.sequence(Maybe.of, [Just(1), Just(2), Nothing()]); //=> Nothing()
*
* R.sequence(R.of, Just([1, 2, 3])); //=> [Just(1), Just(2), Just(3)]
* R.sequence(R.of, Nothing()); //=> [Nothing()]
*/
module.exports = _curry2(function sequence(of, traversable) {
return typeof traversable.sequence === 'function' ?
traversable.sequence(of) :
reduceRight(function(x, acc) { return ap(map(prepend, x), acc); },
of([]),
traversable);
});
/***/ },
/* 330 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
var always = __webpack_require__(69);
var over = __webpack_require__(298);
/**
* Returns the result of "setting" the portion of the given data structure
* focused by the given lens to the given value.
*
* @func
* @memberOf R
* @since v0.16.0
* @category Object
* @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
* @sig Lens s a -> a -> s -> s
* @param {Lens} lens
* @param {*} v
* @param {*} x
* @return {*}
* @see R.prop, R.lensIndex, R.lensProp
* @example
*
* var xLens = R.lensProp('x');
*
* R.set(xLens, 4, {x: 1, y: 2}); //=> {x: 4, y: 2}
* R.set(xLens, 8, {x: 1, y: 2}); //=> {x: 8, y: 2}
*/
module.exports = _curry3(function set(lens, v, x) {
return over(lens, always(v), x);
});
/***/ },
/* 331 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Returns a copy of the list, sorted according to the comparator function,
* which should accept two values at a time and return a negative number if the
* first value is smaller, a positive number if it's larger, and zero if they
* are equal. Please note that this is a **copy** of the list. It does not
* modify the original.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig (a,a -> Number) -> [a] -> [a]
* @param {Function} comparator A sorting function :: a -> b -> Int
* @param {Array} list The list to sort
* @return {Array} a new array with its elements sorted by the comparator function.
* @example
*
* var diff = function(a, b) { return a - b; };
* R.sort(diff, [4,2,7,5]); //=> [2, 4, 5, 7]
*/
module.exports = _curry2(function sort(comparator, list) {
return Array.prototype.slice.call(list, 0).sort(comparator);
});
/***/ },
/* 332 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Sorts the list according to the supplied function.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Relation
* @sig Ord b => (a -> b) -> [a] -> [a]
* @param {Function} fn
* @param {Array} list The list to sort.
* @return {Array} A new list sorted by the keys generated by `fn`.
* @example
*
* var sortByFirstItem = R.sortBy(R.prop(0));
* var sortByNameCaseInsensitive = R.sortBy(R.compose(R.toLower, R.prop('name')));
* var pairs = [[-1, 1], [-2, 2], [-3, 3]];
* sortByFirstItem(pairs); //=> [[-3, 3], [-2, 2], [-1, 1]]
* var alice = {
* name: 'ALICE',
* age: 101
* };
* var bob = {
* name: 'Bob',
* age: -10
* };
* var clara = {
* name: 'clara',
* age: 314.159
* };
* var people = [clara, bob, alice];
* sortByNameCaseInsensitive(people); //=> [alice, bob, clara]
*/
module.exports = _curry2(function sortBy(fn, list) {
return Array.prototype.slice.call(list, 0).sort(function(a, b) {
var aa = fn(a);
var bb = fn(b);
return aa < bb ? -1 : aa > bb ? 1 : 0;
});
});
/***/ },
/* 333 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Sorts a list according to a list of comparators.
*
* @func
* @memberOf R
* @since v0.23.0
* @category Relation
* @sig [a -> a -> Number] -> [a] -> [a]
* @param {Array} functions A list of comparator functions.
* @param {Array} list The list to sort.
* @return {Array} A new list sorted according to the comarator functions.
* @example
*
* var alice = {
* name: 'alice',
* age: 40
* };
* var bob = {
* name: 'bob',
* age: 30
* };
* var clara = {
* name: 'clara',
* age: 40
* };
* var people = [clara, bob, alice];
* var ageNameSort = R.sortWith([
* R.descend(R.prop('age')),
* R.ascend(R.prop('name'))
* ]);
* ageNameSort(people); //=> [alice, clara, bob]
*/
module.exports = _curry2(function sortWith(fns, list) {
return Array.prototype.slice.call(list, 0).sort(function(a, b) {
var result = 0;
var i = 0;
while (result === 0 && i < fns.length) {
result = fns[i](a, b);
i += 1;
}
return result;
});
});
/***/ },
/* 334 */
/***/ function(module, exports, __webpack_require__) {
var invoker = __webpack_require__(255);
/**
* Splits a string into an array of strings based on the given
* separator.
*
* @func
* @memberOf R
* @since v0.1.0
* @category String
* @sig (String | RegExp) -> String -> [String]
* @param {String|RegExp} sep The pattern.
* @param {String} str The string to separate into an array.
* @return {Array} The array of strings from `str` separated by `str`.
* @see R.join
* @example
*
* var pathComponents = R.split('/');
* R.tail(pathComponents('/usr/local/bin/node')); //=> ['usr', 'local', 'bin', 'node']
*
* R.split('.', 'a.b.c.xyz.d'); //=> ['a', 'b', 'c', 'xyz', 'd']
*/
module.exports = invoker(1, 'split');
/***/ },
/* 335 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var length = __webpack_require__(263);
var slice = __webpack_require__(148);
/**
* Splits a given list or string at a given index.
*
* @func
* @memberOf R
* @since v0.19.0
* @category List
* @sig Number -> [a] -> [[a], [a]]
* @sig Number -> String -> [String, String]
* @param {Number} index The index where the array/string is split.
* @param {Array|String} array The array/string to be split.
* @return {Array}
* @example
*
* R.splitAt(1, [1, 2, 3]); //=> [[1], [2, 3]]
* R.splitAt(5, 'hello world'); //=> ['hello', ' world']
* R.splitAt(-1, 'foobar'); //=> ['fooba', 'r']
*/
module.exports = _curry2(function splitAt(index, array) {
return [slice(0, index, array), slice(index, length(array), array)];
});
/***/ },
/* 336 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var slice = __webpack_require__(148);
/**
* Splits a collection into slices of the specified length.
*
* @func
* @memberOf R
* @since v0.16.0
* @category List
* @sig Number -> [a] -> [[a]]
* @sig Number -> String -> [String]
* @param {Number} n
* @param {Array} list
* @return {Array}
* @example
*
* R.splitEvery(3, [1, 2, 3, 4, 5, 6, 7]); //=> [[1, 2, 3], [4, 5, 6], [7]]
* R.splitEvery(3, 'foobarbaz'); //=> ['foo', 'bar', 'baz']
*/
module.exports = _curry2(function splitEvery(n, list) {
if (n <= 0) {
throw new Error('First argument to splitEvery must be a positive integer');
}
var result = [];
var idx = 0;
while (idx < list.length) {
result.push(slice(idx, idx += n, list));
}
return result;
});
/***/ },
/* 337 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Takes a list and a predicate and returns a pair of lists with the following properties:
*
* - the result of concatenating the two output lists is equivalent to the input list;
* - none of the elements of the first output list satisfies the predicate; and
* - if the second output list is non-empty, its first element satisfies the predicate.
*
* @func
* @memberOf R
* @since v0.19.0
* @category List
* @sig (a -> Boolean) -> [a] -> [[a], [a]]
* @param {Function} pred The predicate that determines where the array is split.
* @param {Array} list The array to be split.
* @return {Array}
* @example
*
* R.splitWhen(R.equals(2), [1, 2, 3, 1, 2, 3]); //=> [[1], [2, 3, 1, 2, 3]]
*/
module.exports = _curry2(function splitWhen(pred, list) {
var idx = 0;
var len = list.length;
var prefix = [];
while (idx < len && !pred(list[idx])) {
prefix.push(list[idx]);
idx += 1;
}
return [prefix, Array.prototype.slice.call(list, idx)];
});
/***/ },
/* 338 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Subtracts its second argument from its first argument.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Math
* @sig Number -> Number -> Number
* @param {Number} a The first value.
* @param {Number} b The second value.
* @return {Number} The result of `a - b`.
* @see R.add
* @example
*
* R.subtract(10, 8); //=> 2
*
* var minus5 = R.subtract(R.__, 5);
* minus5(17); //=> 12
*
* var complementaryAngle = R.subtract(90);
* complementaryAngle(30); //=> 60
* complementaryAngle(72); //=> 18
*/
module.exports = _curry2(function subtract(a, b) {
return Number(a) - Number(b);
});
/***/ },
/* 339 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var concat = __webpack_require__(154);
var difference = __webpack_require__(183);
/**
* Finds the set (i.e. no duplicates) of all elements contained in the first or
* second list, but not both.
*
* @func
* @memberOf R
* @since v0.19.0
* @category Relation
* @sig [*] -> [*] -> [*]
* @param {Array} list1 The first list.
* @param {Array} list2 The second list.
* @return {Array} The elements in `list1` or `list2`, but not both.
* @see R.symmetricDifferenceWith, R.difference, R.differenceWith
* @example
*
* R.symmetricDifference([1,2,3,4], [7,6,5,4,3]); //=> [1,2,7,6,5]
* R.symmetricDifference([7,6,5,4,3], [1,2,3,4]); //=> [7,6,5,1,2]
*/
module.exports = _curry2(function symmetricDifference(list1, list2) {
return concat(difference(list1, list2), difference(list2, list1));
});
/***/ },
/* 340 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
var concat = __webpack_require__(154);
var differenceWith = __webpack_require__(184);
/**
* Finds the set (i.e. no duplicates) of all elements contained in the first or
* second list, but not both. Duplication is determined according to the value
* returned by applying the supplied predicate to two list elements.
*
* @func
* @memberOf R
* @since v0.19.0
* @category Relation
* @sig ((a, a) -> Boolean) -> [a] -> [a] -> [a]
* @param {Function} pred A predicate used to test whether two items are equal.
* @param {Array} list1 The first list.
* @param {Array} list2 The second list.
* @return {Array} The elements in `list1` or `list2`, but not both.
* @see R.symmetricDifference, R.difference, R.differenceWith
* @example
*
* var eqA = R.eqBy(R.prop('a'));
* var l1 = [{a: 1}, {a: 2}, {a: 3}, {a: 4}];
* var l2 = [{a: 3}, {a: 4}, {a: 5}, {a: 6}];
* R.symmetricDifferenceWith(eqA, l1, l2); //=> [{a: 1}, {a: 2}, {a: 5}, {a: 6}]
*/
module.exports = _curry3(function symmetricDifferenceWith(pred, list1, list2) {
return concat(differenceWith(pred, list1, list2), differenceWith(pred, list2, list1));
});
/***/ },
/* 341 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var drop = __webpack_require__(189);
/**
* Returns a new list containing the last `n` elements of the given list.
* If `n > list.length`, returns a list of `list.length` elements.
*
* @func
* @memberOf R
* @since v0.16.0
* @category List
* @sig Number -> [a] -> [a]
* @sig Number -> String -> String
* @param {Number} n The number of elements to return.
* @param {Array} xs The collection to consider.
* @return {Array}
* @see R.dropLast
* @example
*
* R.takeLast(1, ['foo', 'bar', 'baz']); //=> ['baz']
* R.takeLast(2, ['foo', 'bar', 'baz']); //=> ['bar', 'baz']
* R.takeLast(3, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']
* R.takeLast(4, ['foo', 'bar', 'baz']); //=> ['foo', 'bar', 'baz']
* R.takeLast(3, 'ramda'); //=> 'mda'
*/
module.exports = _curry2(function takeLast(n, xs) {
return drop(n >= 0 ? xs.length - n : 0, xs);
});
/***/ },
/* 342 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Returns a new list containing the last `n` elements of a given list, passing
* each value to the supplied predicate function, and terminating when the
* predicate function returns `false`. Excludes the element that caused the
* predicate function to fail. The predicate function is passed one argument:
* *(value)*.
*
* @func
* @memberOf R
* @since v0.16.0
* @category List
* @sig (a -> Boolean) -> [a] -> [a]
* @param {Function} fn The function called per iteration.
* @param {Array} list The collection to iterate over.
* @return {Array} A new array.
* @see R.dropLastWhile, R.addIndex
* @example
*
* var isNotOne = x => x !== 1;
*
* R.takeLastWhile(isNotOne, [1, 2, 3, 4]); //=> [2, 3, 4]
*/
module.exports = _curry2(function takeLastWhile(fn, list) {
var idx = list.length - 1;
while (idx >= 0 && fn(list[idx])) {
idx -= 1;
}
return Array.prototype.slice.call(list, idx + 1);
});
/***/ },
/* 343 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _dispatchable = __webpack_require__(84);
var _xtakeWhile = __webpack_require__(344);
/**
* Returns a new list containing the first `n` elements of a given list,
* passing each value to the supplied predicate function, and terminating when
* the predicate function returns `false`. Excludes the element that caused the
* predicate function to fail. The predicate function is passed one argument:
* *(value)*.
*
* Dispatches to the `takeWhile` method of the second argument, if present.
*
* Acts as a transducer if a transformer is given in list position.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig (a -> Boolean) -> [a] -> [a]
* @param {Function} fn The function called per iteration.
* @param {Array} list The collection to iterate over.
* @return {Array} A new array.
* @see R.dropWhile, R.transduce, R.addIndex
* @example
*
* var isNotFour = x => x !== 4;
*
* R.takeWhile(isNotFour, [1, 2, 3, 4, 3, 2, 1]); //=> [1, 2, 3]
*/
module.exports = _curry2(_dispatchable(['takeWhile'], _xtakeWhile, function takeWhile(fn, list) {
var idx = 0;
var len = list.length;
while (idx < len && fn(list[idx])) {
idx += 1;
}
return Array.prototype.slice.call(list, 0, idx);
}));
/***/ },
/* 344 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _reduced = __webpack_require__(88);
var _xfBase = __webpack_require__(89);
module.exports = (function() {
function XTakeWhile(f, xf) {
this.xf = xf;
this.f = f;
}
XTakeWhile.prototype['@@transducer/init'] = _xfBase.init;
XTakeWhile.prototype['@@transducer/result'] = _xfBase.result;
XTakeWhile.prototype['@@transducer/step'] = function(result, input) {
return this.f(input) ? this.xf['@@transducer/step'](result, input) : _reduced(result);
};
return _curry2(function _xtakeWhile(f, xf) { return new XTakeWhile(f, xf); });
}());
/***/ },
/* 345 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Runs the given function with the supplied object, then returns the object.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Function
* @sig (a -> *) -> a -> a
* @param {Function} fn The function to call with `x`. The return value of `fn` will be thrown away.
* @param {*} x
* @return {*} `x`.
* @example
*
* var sayX = x => console.log('x is ' + x);
* R.tap(sayX, 100); //=> 100
* // logs 'x is 100'
* @symb R.tap(f, a) = a
*/
module.exports = _curry2(function tap(fn, x) {
fn(x);
return x;
});
/***/ },
/* 346 */
/***/ function(module, exports, __webpack_require__) {
var _cloneRegExp = __webpack_require__(138);
var _curry2 = __webpack_require__(75);
var _isRegExp = __webpack_require__(347);
var toString = __webpack_require__(155);
/**
* Determines whether a given string matches a given regular expression.
*
* @func
* @memberOf R
* @since v0.12.0
* @category String
* @sig RegExp -> String -> Boolean
* @param {RegExp} pattern
* @param {String} str
* @return {Boolean}
* @see R.match
* @example
*
* R.test(/^x/, 'xyz'); //=> true
* R.test(/^y/, 'xyz'); //=> false
*/
module.exports = _curry2(function test(pattern, str) {
if (!_isRegExp(pattern)) {
throw new TypeError('‘test’ requires a value of type RegExp as its first argument; received ' + toString(pattern));
}
return _cloneRegExp(pattern).test(str);
});
/***/ },
/* 347 */
/***/ function(module, exports) {
module.exports = function _isRegExp(x) {
return Object.prototype.toString.call(x) === '[object RegExp]';
};
/***/ },
/* 348 */
/***/ function(module, exports, __webpack_require__) {
var invoker = __webpack_require__(255);
/**
* The lower case version of a string.
*
* @func
* @memberOf R
* @since v0.9.0
* @category String
* @sig String -> String
* @param {String} str The string to lower case.
* @return {String} The lower case version of `str`.
* @see R.toUpper
* @example
*
* R.toLower('XYZ'); //=> 'xyz'
*/
module.exports = invoker(0, 'toLowerCase');
/***/ },
/* 349 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var _has = __webpack_require__(102);
/**
* Converts an object into an array of key, value arrays. Only the object's
* own properties are used.
* Note that the order of the output array is not guaranteed to be consistent
* across different JS platforms.
*
* @func
* @memberOf R
* @since v0.4.0
* @category Object
* @sig {String: *} -> [[String,*]]
* @param {Object} obj The object to extract from
* @return {Array} An array of key, value arrays from the object's own properties.
* @see R.fromPairs
* @example
*
* R.toPairs({a: 1, b: 2, c: 3}); //=> [['a', 1], ['b', 2], ['c', 3]]
*/
module.exports = _curry1(function toPairs(obj) {
var pairs = [];
for (var prop in obj) {
if (_has(prop, obj)) {
pairs[pairs.length] = [prop, obj[prop]];
}
}
return pairs;
});
/***/ },
/* 350 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
/**
* Converts an object into an array of key, value arrays. The object's own
* properties and prototype properties are used. Note that the order of the
* output array is not guaranteed to be consistent across different JS
* platforms.
*
* @func
* @memberOf R
* @since v0.4.0
* @category Object
* @sig {String: *} -> [[String,*]]
* @param {Object} obj The object to extract from
* @return {Array} An array of key, value arrays from the object's own
* and prototype properties.
* @example
*
* var F = function() { this.x = 'X'; };
* F.prototype.y = 'Y';
* var f = new F();
* R.toPairsIn(f); //=> [['x','X'], ['y','Y']]
*/
module.exports = _curry1(function toPairsIn(obj) {
var pairs = [];
for (var prop in obj) {
pairs[pairs.length] = [prop, obj[prop]];
}
return pairs;
});
/***/ },
/* 351 */
/***/ function(module, exports, __webpack_require__) {
var invoker = __webpack_require__(255);
/**
* The upper case version of a string.
*
* @func
* @memberOf R
* @since v0.9.0
* @category String
* @sig String -> String
* @param {String} str The string to upper case.
* @return {String} The upper case version of `str`.
* @see R.toLower
* @example
*
* R.toUpper('abc'); //=> 'ABC'
*/
module.exports = invoker(0, 'toUpperCase');
/***/ },
/* 352 */
/***/ function(module, exports, __webpack_require__) {
var _reduce = __webpack_require__(95);
var _xwrap = __webpack_require__(96);
var curryN = __webpack_require__(78);
/**
* Initializes a transducer using supplied iterator function. Returns a single
* item by iterating through the list, successively calling the transformed
* iterator function and passing it an accumulator value and the current value
* from the array, and then passing the result to the next call.
*
* The iterator function receives two values: *(acc, value)*. It will be
* wrapped as a transformer to initialize the transducer. A transformer can be
* passed directly in place of an iterator function. In both cases, iteration
* may be stopped early with the `R.reduced` function.
*
* A transducer is a function that accepts a transformer and returns a
* transformer and can be composed directly.
*
* A transformer is an an object that provides a 2-arity reducing iterator
* function, step, 0-arity initial value function, init, and 1-arity result
* extraction function, result. The step function is used as the iterator
* function in reduce. The result function is used to convert the final
* accumulator into the return type and in most cases is R.identity. The init
* function can be used to provide an initial accumulator, but is ignored by
* transduce.
*
* The iteration is performed with R.reduce after initializing the transducer.
*
* @func
* @memberOf R
* @since v0.12.0
* @category List
* @sig (c -> c) -> (a,b -> a) -> a -> [b] -> a
* @param {Function} xf The transducer function. Receives a transformer and returns a transformer.
* @param {Function} fn The iterator function. Receives two values, the accumulator and the
* current element from the array. Wrapped as transformer, if necessary, and used to
* initialize the transducer
* @param {*} acc The initial accumulator value.
* @param {Array} list The list to iterate over.
* @return {*} The final, accumulated value.
* @see R.reduce, R.reduced, R.into
* @example
*
* var numbers = [1, 2, 3, 4];
* var transducer = R.compose(R.map(R.add(1)), R.take(2));
*
* R.transduce(transducer, R.flip(R.append), [], numbers); //=> [2, 3]
*/
module.exports = curryN(4, function transduce(xf, fn, acc, list) {
return _reduce(xf(typeof fn === 'function' ? _xwrap(fn) : fn), acc, list);
});
/***/ },
/* 353 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
/**
* Transposes the rows and columns of a 2D list.
* When passed a list of `n` lists of length `x`,
* returns a list of `x` lists of length `n`.
*
*
* @func
* @memberOf R
* @since v0.19.0
* @category List
* @sig [[a]] -> [[a]]
* @param {Array} list A 2D list
* @return {Array} A 2D list
* @example
*
* R.transpose([[1, 'a'], [2, 'b'], [3, 'c']]) //=> [[1, 2, 3], ['a', 'b', 'c']]
* R.transpose([[1, 2, 3], ['a', 'b', 'c']]) //=> [[1, 'a'], [2, 'b'], [3, 'c']]
*
* If some of the rows are shorter than the following rows, their elements are skipped:
*
* R.transpose([[10, 11], [20], [], [30, 31, 32]]) //=> [[10, 20, 30], [11, 31], [32]]
* @symb R.transpose([[a], [b], [c]]) = [a, b, c]
* @symb R.transpose([[a, b], [c, d]]) = [[a, c], [b, d]]
* @symb R.transpose([[a, b], [c]]) = [[a, c], [b]]
*/
module.exports = _curry1(function transpose(outerlist) {
var i = 0;
var result = [];
while (i < outerlist.length) {
var innerlist = outerlist[i];
var j = 0;
while (j < innerlist.length) {
if (typeof result[j] === 'undefined') {
result[j] = [];
}
result[j].push(innerlist[j]);
j += 1;
}
i += 1;
}
return result;
});
/***/ },
/* 354 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
var map = __webpack_require__(93);
var sequence = __webpack_require__(329);
/**
* Maps an [Applicative](https://github.com/fantasyland/fantasy-land#applicative)-returning
* function over a [Traversable](https://github.com/fantasyland/fantasy-land#traversable),
* then uses [`sequence`](#sequence) to transform the resulting Traversable of Applicative
* into an Applicative of Traversable.
*
* Dispatches to the `sequence` method of the third argument, if present.
*
* @func
* @memberOf R
* @since v0.19.0
* @category List
* @sig (Applicative f, Traversable t) => (a -> f a) -> (a -> f b) -> t a -> f (t b)
* @param {Function} of
* @param {Function} f
* @param {*} traversable
* @return {*}
* @see R.sequence
* @example
*
* // Returns `Nothing` if the given divisor is `0`
* safeDiv = n => d => d === 0 ? Nothing() : Just(n / d)
*
* R.traverse(Maybe.of, safeDiv(10), [2, 4, 5]); //=> Just([5, 2.5, 2])
* R.traverse(Maybe.of, safeDiv(10), [2, 0, 5]); //=> Nothing
*/
module.exports = _curry3(function traverse(of, f, traversable) {
return sequence(of, map(f, traversable));
});
/***/ },
/* 355 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
/**
* Removes (strips) whitespace from both ends of the string.
*
* @func
* @memberOf R
* @since v0.6.0
* @category String
* @sig String -> String
* @param {String} str The string to trim.
* @return {String} Trimmed version of `str`.
* @example
*
* R.trim(' xyz '); //=> 'xyz'
* R.map(R.trim, R.split(',', 'x, y, z')); //=> ['x', 'y', 'z']
*/
module.exports = (function() {
var ws = '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003' +
'\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028' +
'\u2029\uFEFF';
var zeroWidth = '\u200b';
var hasProtoTrim = (typeof String.prototype.trim === 'function');
if (!hasProtoTrim || (ws.trim() || !zeroWidth.trim())) {
return _curry1(function trim(str) {
var beginRx = new RegExp('^[' + ws + '][' + ws + ']*');
var endRx = new RegExp('[' + ws + '][' + ws + ']*$');
return str.replace(beginRx, '').replace(endRx, '');
});
} else {
return _curry1(function trim(str) {
return str.trim();
});
}
}());
/***/ },
/* 356 */
/***/ function(module, exports, __webpack_require__) {
var _arity = __webpack_require__(79);
var _concat = __webpack_require__(77);
var _curry2 = __webpack_require__(75);
/**
* `tryCatch` takes two functions, a `tryer` and a `catcher`. The returned
* function evaluates the `tryer`; if it does not throw, it simply returns the
* result. If the `tryer` *does* throw, the returned function evaluates the
* `catcher` function and returns its result. Note that for effective
* composition with this function, both the `tryer` and `catcher` functions
* must return the same type of results.
*
* @func
* @memberOf R
* @since v0.20.0
* @category Function
* @sig (...x -> a) -> ((e, ...x) -> a) -> (...x -> a)
* @param {Function} tryer The function that may throw.
* @param {Function} catcher The function that will be evaluated if `tryer` throws.
* @return {Function} A new function that will catch exceptions and send then to the catcher.
* @example
*
* R.tryCatch(R.prop('x'), R.F)({x: true}); //=> true
* R.tryCatch(R.prop('x'), R.F)(null); //=> false
*/
module.exports = _curry2(function _tryCatch(tryer, catcher) {
return _arity(tryer.length, function() {
try {
return tryer.apply(this, arguments);
} catch (e) {
return catcher.apply(this, _concat([e], arguments));
}
});
});
/***/ },
/* 357 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
/**
* Takes a function `fn`, which takes a single array argument, and returns a
* function which:
*
* - takes any number of positional arguments;
* - passes these arguments to `fn` as an array; and
* - returns the result.
*
* In other words, R.unapply derives a variadic function from a function which
* takes an array. R.unapply is the inverse of R.apply.
*
* @func
* @memberOf R
* @since v0.8.0
* @category Function
* @sig ([*...] -> a) -> (*... -> a)
* @param {Function} fn
* @return {Function}
* @see R.apply
* @example
*
* R.unapply(JSON.stringify)(1, 2, 3); //=> '[1,2,3]'
* @symb R.unapply(f)(a, b) = f([a, b])
*/
module.exports = _curry1(function unapply(fn) {
return function() {
return fn(Array.prototype.slice.call(arguments, 0));
};
});
/***/ },
/* 358 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
var nAry = __webpack_require__(123);
/**
* Wraps a function of any arity (including nullary) in a function that accepts
* exactly 1 parameter. Any extraneous parameters will not be passed to the
* supplied function.
*
* @func
* @memberOf R
* @since v0.2.0
* @category Function
* @sig (* -> b) -> (a -> b)
* @param {Function} fn The function to wrap.
* @return {Function} A new function wrapping `fn`. The new function is guaranteed to be of
* arity 1.
* @example
*
* var takesTwoArgs = function(a, b) {
* return [a, b];
* };
* takesTwoArgs.length; //=> 2
* takesTwoArgs(1, 2); //=> [1, 2]
*
* var takesOneArg = R.unary(takesTwoArgs);
* takesOneArg.length; //=> 1
* // Only 1 argument is passed to the wrapped function
* takesOneArg(1, 2); //=> [1, undefined]
* @symb R.unary(f)(a, b, c) = f(a)
*/
module.exports = _curry1(function unary(fn) {
return nAry(1, fn);
});
/***/ },
/* 359 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var curryN = __webpack_require__(78);
/**
* Returns a function of arity `n` from a (manually) curried function.
*
* @func
* @memberOf R
* @since v0.14.0
* @category Function
* @sig Number -> (a -> b) -> (a -> c)
* @param {Number} length The arity for the returned function.
* @param {Function} fn The function to uncurry.
* @return {Function} A new function.
* @see R.curry
* @example
*
* var addFour = a => b => c => d => a + b + c + d;
*
* var uncurriedAddFour = R.uncurryN(4, addFour);
* uncurriedAddFour(1, 2, 3, 4); //=> 10
*/
module.exports = _curry2(function uncurryN(depth, fn) {
return curryN(depth, function() {
var currentDepth = 1;
var value = fn;
var idx = 0;
var endIdx;
while (currentDepth <= depth && typeof value === 'function') {
endIdx = currentDepth === depth ? arguments.length : idx + value.length;
value = value.apply(this, Array.prototype.slice.call(arguments, idx, endIdx));
currentDepth += 1;
idx = endIdx;
}
return value;
});
});
/***/ },
/* 360 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Builds a list from a seed value. Accepts an iterator function, which returns
* either false to stop iteration or an array of length 2 containing the value
* to add to the resulting list and the seed to be used in the next call to the
* iterator function.
*
* The iterator function receives one argument: *(seed)*.
*
* @func
* @memberOf R
* @since v0.10.0
* @category List
* @sig (a -> [b]) -> * -> [b]
* @param {Function} fn The iterator function. receives one argument, `seed`, and returns
* either false to quit iteration or an array of length two to proceed. The element
* at index 0 of this array will be added to the resulting array, and the element
* at index 1 will be passed to the next call to `fn`.
* @param {*} seed The seed value.
* @return {Array} The final list.
* @example
*
* var f = n => n > 50 ? false : [-n, n + 10];
* R.unfold(f, 10); //=> [-10, -20, -30, -40, -50]
* @symb R.unfold(f, x) = [f(x)[0], f(f(x)[1])[0], f(f(f(x)[1])[1])[0], ...]
*/
module.exports = _curry2(function unfold(fn, seed) {
var pair = fn(seed);
var result = [];
while (pair && pair.length) {
result[result.length] = pair[0];
pair = fn(pair[1]);
}
return result;
});
/***/ },
/* 361 */
/***/ function(module, exports, __webpack_require__) {
var _concat = __webpack_require__(77);
var _curry2 = __webpack_require__(75);
var compose = __webpack_require__(143);
var uniq = __webpack_require__(242);
/**
* Combines two lists into a set (i.e. no duplicates) composed of the elements
* of each list.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Relation
* @sig [*] -> [*] -> [*]
* @param {Array} as The first list.
* @param {Array} bs The second list.
* @return {Array} The first and second lists concatenated, with
* duplicates removed.
* @example
*
* R.union([1, 2, 3], [2, 3, 4]); //=> [1, 2, 3, 4]
*/
module.exports = _curry2(compose(uniq, _concat));
/***/ },
/* 362 */
/***/ function(module, exports, __webpack_require__) {
var _concat = __webpack_require__(77);
var _curry3 = __webpack_require__(82);
var uniqWith = __webpack_require__(246);
/**
* Combines two lists into a set (i.e. no duplicates) composed of the elements
* of each list. Duplication is determined according to the value returned by
* applying the supplied predicate to two list elements.
*
* @func
* @memberOf R
* @since v0.1.0
* @category Relation
* @sig (a -> a -> Boolean) -> [*] -> [*] -> [*]
* @param {Function} pred A predicate used to test whether two items are equal.
* @param {Array} list1 The first list.
* @param {Array} list2 The second list.
* @return {Array} The first and second lists concatenated, with
* duplicates removed.
* @see R.union
* @example
*
* var l1 = [{a: 1}, {a: 2}];
* var l2 = [{a: 1}, {a: 4}];
* R.unionWith(R.eqBy(R.prop('a')), l1, l2); //=> [{a: 1}, {a: 2}, {a: 4}]
*/
module.exports = _curry3(function unionWith(pred, list1, list2) {
return uniqWith(pred, _concat(list1, list2));
});
/***/ },
/* 363 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* Tests the final argument by passing it to the given predicate function. If
* the predicate is not satisfied, the function will return the result of
* calling the `whenFalseFn` function with the same argument. If the predicate
* is satisfied, the argument is returned as is.
*
* @func
* @memberOf R
* @since v0.18.0
* @category Logic
* @sig (a -> Boolean) -> (a -> a) -> a -> a
* @param {Function} pred A predicate function
* @param {Function} whenFalseFn A function to invoke when the `pred` evaluates
* to a falsy value.
* @param {*} x An object to test with the `pred` function and
* pass to `whenFalseFn` if necessary.
* @return {*} Either `x` or the result of applying `x` to `whenFalseFn`.
* @see R.ifElse, R.when
* @example
*
* // coerceArray :: (a|[a]) -> [a]
* var coerceArray = R.unless(R.isArrayLike, R.of);
* coerceArray([1, 2, 3]); //=> [1, 2, 3]
* coerceArray(1); //=> [1]
*/
module.exports = _curry3(function unless(pred, whenFalseFn, x) {
return pred(x) ? x : whenFalseFn(x);
});
/***/ },
/* 364 */
/***/ function(module, exports, __webpack_require__) {
var _identity = __webpack_require__(233);
var chain = __webpack_require__(130);
/**
* Shorthand for `R.chain(R.identity)`, which removes one level of nesting from
* any [Chain](https://github.com/fantasyland/fantasy-land#chain).
*
* @func
* @memberOf R
* @since v0.3.0
* @category List
* @sig Chain c => c (c a) -> c a
* @param {*} list
* @return {*}
* @see R.flatten, R.chain
* @example
*
* R.unnest([1, [2], [[3]]]); //=> [1, 2, [3]]
* R.unnest([[1, 2], [3, 4], [5, 6]]); //=> [1, 2, 3, 4, 5, 6]
*/
module.exports = chain(_identity);
/***/ },
/* 365 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* Takes a predicate, a transformation function, and an initial value,
* and returns a value of the same type as the initial value.
* It does so by applying the transformation until the predicate is satisfied,
* at which point it returns the satisfactory value.
*
* @func
* @memberOf R
* @since v0.20.0
* @category Logic
* @sig (a -> Boolean) -> (a -> a) -> a -> a
* @param {Function} pred A predicate function
* @param {Function} fn The iterator function
* @param {*} init Initial value
* @return {*} Final value that satisfies predicate
* @example
*
* R.until(R.gt(R.__, 100), R.multiply(2))(1) // => 128
*/
module.exports = _curry3(function until(pred, fn, init) {
var val = init;
while (!pred(val)) {
val = fn(val);
}
return val;
});
/***/ },
/* 366 */
/***/ function(module, exports, __webpack_require__) {
var _curry1 = __webpack_require__(70);
/**
* Returns a list of all the properties, including prototype properties, of the
* supplied object.
* Note that the order of the output array is not guaranteed to be consistent
* across different JS platforms.
*
* @func
* @memberOf R
* @since v0.2.0
* @category Object
* @sig {k: v} -> [v]
* @param {Object} obj The object to extract values from
* @return {Array} An array of the values of the object's own and prototype properties.
* @example
*
* var F = function() { this.x = 'X'; };
* F.prototype.y = 'Y';
* var f = new F();
* R.valuesIn(f); //=> ['X', 'Y']
*/
module.exports = _curry1(function valuesIn(obj) {
var prop;
var vs = [];
for (prop in obj) {
vs[vs.length] = obj[prop];
}
return vs;
});
/***/ },
/* 367 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Returns a "view" of the given data structure, determined by the given lens.
* The lens's focus determines which portion of the data structure is visible.
*
* @func
* @memberOf R
* @since v0.16.0
* @category Object
* @typedefn Lens s a = Functor f => (a -> f a) -> s -> f s
* @sig Lens s a -> s -> a
* @param {Lens} lens
* @param {*} x
* @return {*}
* @see R.prop, R.lensIndex, R.lensProp
* @example
*
* var xLens = R.lensProp('x');
*
* R.view(xLens, {x: 1, y: 2}); //=> 1
* R.view(xLens, {x: 4, y: 2}); //=> 4
*/
module.exports = (function() {
// `Const` is a functor that effectively ignores the function given to `map`.
var Const = function(x) {
return {value: x, map: function() { return this; }};
};
return _curry2(function view(lens, x) {
// Using `Const` effectively ignores the setter function of the `lens`,
// leaving the value returned by the getter function unmodified.
return lens(Const)(x).value;
});
}());
/***/ },
/* 368 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* Tests the final argument by passing it to the given predicate function. If
* the predicate is satisfied, the function will return the result of calling
* the `whenTrueFn` function with the same argument. If the predicate is not
* satisfied, the argument is returned as is.
*
* @func
* @memberOf R
* @since v0.18.0
* @category Logic
* @sig (a -> Boolean) -> (a -> a) -> a -> a
* @param {Function} pred A predicate function
* @param {Function} whenTrueFn A function to invoke when the `condition`
* evaluates to a truthy value.
* @param {*} x An object to test with the `pred` function and
* pass to `whenTrueFn` if necessary.
* @return {*} Either `x` or the result of applying `x` to `whenTrueFn`.
* @see R.ifElse, R.unless
* @example
*
* // truncate :: String -> String
* var truncate = R.when(
* R.propSatisfies(R.gt(R.__, 10), 'length'),
* R.pipe(R.take(10), R.append('…'), R.join(''))
* );
* truncate('12345'); //=> '12345'
* truncate('0123456789ABC'); //=> '0123456789…'
*/
module.exports = _curry3(function when(pred, whenTrueFn, x) {
return pred(x) ? whenTrueFn(x) : x;
});
/***/ },
/* 369 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var _has = __webpack_require__(102);
/**
* Takes a spec object and a test object; returns true if the test satisfies
* the spec. Each of the spec's own properties must be a predicate function.
* Each predicate is applied to the value of the corresponding property of the
* test object. `where` returns true if all the predicates return true, false
* otherwise.
*
* `where` is well suited to declaratively expressing constraints for other
* functions such as `filter` and `find`.
*
* @func
* @memberOf R
* @since v0.1.1
* @category Object
* @sig {String: (* -> Boolean)} -> {String: *} -> Boolean
* @param {Object} spec
* @param {Object} testObj
* @return {Boolean}
* @example
*
* // pred :: Object -> Boolean
* var pred = R.where({
* a: R.equals('foo'),
* b: R.complement(R.equals('bar')),
* x: R.gt(__, 10),
* y: R.lt(__, 20)
* });
*
* pred({a: 'foo', b: 'xxx', x: 11, y: 19}); //=> true
* pred({a: 'xxx', b: 'xxx', x: 11, y: 19}); //=> false
* pred({a: 'foo', b: 'bar', x: 11, y: 19}); //=> false
* pred({a: 'foo', b: 'xxx', x: 10, y: 19}); //=> false
* pred({a: 'foo', b: 'xxx', x: 11, y: 20}); //=> false
*/
module.exports = _curry2(function where(spec, testObj) {
for (var prop in spec) {
if (_has(prop, spec) && !spec[prop](testObj[prop])) {
return false;
}
}
return true;
});
/***/ },
/* 370 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
var equals = __webpack_require__(159);
var map = __webpack_require__(93);
var where = __webpack_require__(369);
/**
* Takes a spec object and a test object; returns true if the test satisfies
* the spec, false otherwise. An object satisfies the spec if, for each of the
* spec's own properties, accessing that property of the object gives the same
* value (in `R.equals` terms) as accessing that property of the spec.
*
* `whereEq` is a specialization of [`where`](#where).
*
* @func
* @memberOf R
* @since v0.14.0
* @category Object
* @sig {String: *} -> {String: *} -> Boolean
* @param {Object} spec
* @param {Object} testObj
* @return {Boolean}
* @see R.where
* @example
*
* // pred :: Object -> Boolean
* var pred = R.whereEq({a: 1, b: 2});
*
* pred({a: 1}); //=> false
* pred({a: 1, b: 2}); //=> true
* pred({a: 1, b: 2, c: 3}); //=> true
* pred({a: 1, b: 1}); //=> false
*/
module.exports = _curry2(function whereEq(spec, testObj) {
return where(map(equals, spec), testObj);
});
/***/ },
/* 371 */
/***/ function(module, exports, __webpack_require__) {
var _contains = __webpack_require__(157);
var _curry2 = __webpack_require__(75);
var flip = __webpack_require__(221);
var reject = __webpack_require__(166);
/**
* Returns a new list without values in the first argument.
* `R.equals` is used to determine equality.
*
* Acts as a transducer if a transformer is given in list position.
*
* @func
* @memberOf R
* @since v0.19.0
* @category List
* @sig [a] -> [a] -> [a]
* @param {Array} list1 The values to be removed from `list2`.
* @param {Array} list2 The array to remove values from.
* @return {Array} The new array without values in `list1`.
* @see R.transduce
* @example
*
* R.without([1, 2], [1, 2, 1, 3, 4]); //=> [3, 4]
*/
module.exports = _curry2(function(xs, list) {
return reject(flip(_contains)(xs), list);
});
/***/ },
/* 372 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Creates a new list out of the two supplied by creating each possible pair
* from the lists.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig [a] -> [b] -> [[a,b]]
* @param {Array} as The first list.
* @param {Array} bs The second list.
* @return {Array} The list made by combining each possible pair from
* `as` and `bs` into pairs (`[a, b]`).
* @example
*
* R.xprod([1, 2], ['a', 'b']); //=> [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
* @symb R.xprod([a, b], [c, d]) = [[a, c], [a, d], [b, c], [b, d]]
*/
module.exports = _curry2(function xprod(a, b) { // = xprodWith(prepend); (takes about 3 times as long...)
var idx = 0;
var ilen = a.length;
var j;
var jlen = b.length;
var result = [];
while (idx < ilen) {
j = 0;
while (j < jlen) {
result[result.length] = [a[idx], b[j]];
j += 1;
}
idx += 1;
}
return result;
});
/***/ },
/* 373 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Creates a new list out of the two supplied by pairing up equally-positioned
* items from both lists. The returned list is truncated to the length of the
* shorter of the two input lists.
* Note: `zip` is equivalent to `zipWith(function(a, b) { return [a, b] })`.
*
* @func
* @memberOf R
* @since v0.1.0
* @category List
* @sig [a] -> [b] -> [[a,b]]
* @param {Array} list1 The first array to consider.
* @param {Array} list2 The second array to consider.
* @return {Array} The list made by pairing up same-indexed elements of `list1` and `list2`.
* @example
*
* R.zip([1, 2, 3], ['a', 'b', 'c']); //=> [[1, 'a'], [2, 'b'], [3, 'c']]
* @symb R.zip([a, b, c], [d, e, f]) = [[a, d], [b, e], [c, f]]
*/
module.exports = _curry2(function zip(a, b) {
var rv = [];
var idx = 0;
var len = Math.min(a.length, b.length);
while (idx < len) {
rv[idx] = [a[idx], b[idx]];
idx += 1;
}
return rv;
});
/***/ },
/* 374 */
/***/ function(module, exports, __webpack_require__) {
var _curry2 = __webpack_require__(75);
/**
* Creates a new object out of a list of keys and a list of values.
* Key/value pairing is truncated to the length of the shorter of the two lists.
* Note: `zipObj` is equivalent to `pipe(zipWith(pair), fromPairs)`.
*
* @func
* @memberOf R
* @since v0.3.0
* @category List
* @sig [String] -> [*] -> {String: *}
* @param {Array} keys The array that will be properties on the output object.
* @param {Array} values The list of values on the output object.
* @return {Object} The object made by pairing up same-indexed elements of `keys` and `values`.
* @example
*
* R.zipObj(['a', 'b', 'c'], [1, 2, 3]); //=> {a: 1, b: 2, c: 3}
*/
module.exports = _curry2(function zipObj(keys, values) {
var idx = 0;
var len = Math.min(keys.length, values.length);
var out = {};
while (idx < len) {
out[keys[idx]] = values[idx];
idx += 1;
}
return out;
});
/***/ },
/* 375 */
/***/ function(module, exports, __webpack_require__) {
var _curry3 = __webpack_require__(82);
/**
* Creates a new list out of the two supplied by applying the function to each
* equally-positioned pair in the lists. The returned list is truncated to the
* length of the shorter of the two input lists.
*
* @function
* @memberOf R
* @since v0.1.0
* @category List
* @sig (a,b -> c) -> [a] -> [b] -> [c]
* @param {Function} fn The function used to combine the two elements into one value.
* @param {Array} list1 The first array to consider.
* @param {Array} list2 The second array to consider.
* @return {Array} The list made by combining same-indexed elements of `list1` and `list2`
* using `fn`.
* @example
*
* var f = (x, y) => {
* // ...
* };
* R.zipWith(f, [1, 2, 3], ['a', 'b', 'c']);
* //=> [f(1, 'a'), f(2, 'b'), f(3, 'c')]
* @symb R.zipWith(fn, [a, b, c], [d, e, f]) = [fn(a, d), fn(b, e), fn(c, f)]
*/
module.exports = _curry3(function zipWith(fn, a, b) {
var rv = [];
var idx = 0;
var len = Math.min(a.length, b.length);
while (idx < len) {
rv[idx] = fn(a[idx], b[idx]);
idx += 1;
}
return rv;
});
/***/ },
/* 376 */
/***/ function(module, exports, __webpack_require__) {
var sort = __webpack_require__(377);
var ObjectMergeOverride = function(objects) {
"use strict";
var output = {},
objectsSorted;
return (function run() {
if (typeof objects !== 'object') {
throw new Error('Need object with objects to merge!');
}
objectsSorted = sort(objects);
return mergeConfig();
}());
function mergeConfig() {
/* objectsSorted looks like:
{1: {prop: value, prop2, value2}
{2: {prop: value, prop2, value2}
{3: {prop: value, prop2, value2}}
*/
for (var key in objectsSorted) {
if (!objectsSorted.hasOwnProperty(key)) {
continue;
}
var currentObject = objectsSorted[key];
for (var property in currentObject) {
if (!currentObject.hasOwnProperty(property)) {
continue;
}
setPropertyInOutputObject(property, currentObject);
}
}
return output;
}
function setPropertyInOutputObject(property, currentObject) {
if (hasFalsyValue(output[property])) {
output[property] = currentObject[property];
}
}
function hasFalsyValue(property) {
return (property === undefined || property === null);
}
};
module.exports = ObjectMergeOverride;
/***/ },
/* 377 */
/***/ function(module, exports, __webpack_require__) {
/*!
* sort-keys <https://github.com/helpers/sort-keys>
*
* Copyright (c) 2014 Brian Woodward, Jon Schlinkert, contributors.
* Licensed under the MIT License
*/
'use strict';
var sortDesc = __webpack_require__(378);
var sortAsc = __webpack_require__(379);
module.exports = function (obj, options) {
var sort = {desc: sortDesc, asc: sortAsc};
var fn, opts = {}, keys = Object.keys(obj);
// if `options` is an array, assume it's keys
if (Array.isArray(options)) {
opts.keys = options;
options = {};
// if `options` is a function, assume it's a sorting function
} else if (typeof options === 'function') {
fn = options;
} else {
for (var opt in options) {
if (options.hasOwnProperty(opt)) {
opts[opt] = options[opt]
}
}
}
// Default sort order is descending
fn = opts.sort || sortDesc;
if (Boolean(opts.sortOrder)) {
fn = sort[opts.sortOrder.toLowerCase()];
}
if (Boolean(opts.sortBy)) {
keys = opts.sortBy(obj);
fn = null;
}
if (Boolean(opts.keys)) {
keys = opts.keys;
if (!opts.sort && !opts.sortOrder && !opts.sortBy) {
fn = null;
}
}
if (fn) {
keys = keys.sort(fn);
}
var o = {};
var len = keys.length;
var i = -1;
while (++i < len) {
o[keys[i]] = obj[keys[i]];
}
return o;
};
/***/ },
/* 378 */
/***/ function(module, exports) {
/*!
* sort-desc <https://github.com/helpers/sort-desc>
*
* Copyright (c) 2014 Jon Schlinkert, contributors.
* Licensed under the MIT License
*/
'use strict';
module.exports = function (a, b) {
return a < b ? -1 : 1;
};
/***/ },
/* 379 */
/***/ function(module, exports) {
/*!
* sort-asc <https://github.com/helpers/sort-asc>
*
* Copyright (c) 2014 Jon Schlinkert, contributors.
* Licensed under the MIT License
*/
'use strict';
module.exports = function (a, b) {
return b < a ? -1 : 1;
};
/***/ },
/* 380 */
/***/ function(module, exports) {
var nargs = /\{([0-9a-zA-Z_]+)\}/g
module.exports = template
function template(string) {
var args
if (arguments.length === 2 && typeof arguments[1] === "object") {
args = arguments[1]
} else {
args = new Array(arguments.length - 1)
for (var i = 1; i < arguments.length; ++i) {
args[i - 1] = arguments[i]
}
}
if (!args || !args.hasOwnProperty) {
args = {}
}
return string.replace(nargs, function replaceArg(match, i, index) {
var result
if (string[index - 1] === "{" &&
string[index + match.length] === "}") {
return i
} else {
result = args.hasOwnProperty(i) ? args[i] : null
if (result === null || result === undefined) {
return ""
}
return result
}
})
}
/***/ },
/* 381 */
/***/ function(module, exports, __webpack_require__) {
var ERR, word_wrap, fs, read_file, remove, mkdir, copy, yarn_install, yaml, copy_if_exists, make_package_json, _;
'use strict';
ERR = __webpack_require__(1);
word_wrap = __webpack_require__(2);
fs = __webpack_require__(6);
read_file = fs.readFile;
remove = fs.remove;
mkdir = fs.mkdirp;
copy = fs.copy;
yarn_install = __webpack_require__(57);
yaml = __webpack_require__(64);
copy_if_exists = __webpack_require__(65);
make_package_json = __webpack_require__(66);
_ = function _(mu_src_path, root_path, metadata, cb) {
var gen_path, err, dev_deps;
gen_path = root_path + '/generated_local/tools';
remove(gen_path, function (arguments, _$param0) {
err = _$param0;
if (ERR(err, cb)) {
return;
}
mkdir(gen_path, function (arguments, _$param1) {
err = _$param1;
if (ERR(err, cb)) {
return;
}
copy_if_exists(root_path + '/tools', gen_path, function (arguments, _$param2) {
err = _$param2;
if (ERR(err, cb)) {
return;
}
read_file(root_path + '/tools/npm_dev_dependencies.yaml', function (arguments, _$param3, _$param4) {
err = _$param3;
dev_deps = _$param4;
if (ERR(err, cb)) {
return;
}
mkdir(root_path + '/generated/tools', function (arguments, _$param5) {
err = _$param5;
if (ERR(err, cb)) {
return;
}
make_package_json(mu_src_path, metadata, root_path + '/generated/tools', {}, yaml.safeLoad(dev_deps), function (arguments, _$param6) {
err = _$param6;
if (ERR(err, cb)) {
return;
}
make_package_json(mu_src_path, metadata, gen_path, {}, yaml.safeLoad(dev_deps), function (arguments, _$param7) {
err = _$param7;
if (ERR(err, cb)) {
return;
}
console.log('====== yarn 2 started');
yarn_install(root_path + '/generated/tools', function (arguments, _$param8) {
err = _$param8;
if (ERR(err, cb)) {
return;
}
console.log('====== yarn 2 finished');
console.log('====== yarn 3 started');
copy(root_path + '/generated/tools/node_modules', gen_path + '/node_modules', function (arguments, _$param9) {
err = _$param9;
if (ERR(err, cb)) {
return;
}
console.log('====== yarn 3 finished');
cb();
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 382 */
/***/ function(module, exports, __webpack_require__) {
var ERR, word_wrap, fs, yaml, find_project_root, _;
'use strict';
ERR = __webpack_require__(1);
word_wrap = __webpack_require__(2);
fs = __webpack_require__(6);
yaml = __webpack_require__(64);
find_project_root = __webpack_require__(55);
_ = function _(root_path, cb) {
var err, metadata;
fs.readFile(root_path + '/meta/data.yaml', 'utf8', function (arguments, _$param0, _$param1) {
err = _$param0;
metadata = _$param1;
if (ERR(err, cb)) {
return;
}
cb(null, yaml.safeLoad(metadata), root_path);
}.bind(this, arguments));
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 383 */
/***/ function(module, exports, __webpack_require__) {
var ERR, word_wrap, fs, move_if_exists, copy_if_exists, modify_es6, convert_es6, webpack, _;
'use strict';
ERR = __webpack_require__(1);
word_wrap = __webpack_require__(2);
fs = __webpack_require__(6);
move_if_exists = __webpack_require__(384);
copy_if_exists = __webpack_require__(65);
modify_es6 = __webpack_require__(385);
convert_es6 = __webpack_require__(391);
webpack = __webpack_require__(392);
_ = function _(root_path, cb) {
var err;
move_if_exists(root_path + '/generated_local/tools/package.json', root_path + '/generated_local/tools_package.json', function (arguments, _$param0) {
err = _$param0;
if (ERR(err, cb)) {
return;
}
move_if_exists(root_path + '/generated_local/tools/node_modules', root_path + '/generated_local/tools_node_modules', function (arguments, _$param1) {
err = _$param1;
if (ERR(err, cb)) {
return;
}
fs.remove(root_path + '/generated_local/tools', function (arguments, _$param2) {
err = _$param2;
if (ERR(err, cb)) {
return;
}
copy_if_exists(root_path + '/tools', root_path + '/generated_local/tools', function (arguments, _$param3) {
err = _$param3;
if (ERR(err, cb)) {
return;
}
move_if_exists(root_path + '/generated_local/tools_node_modules', root_path + '/generated_local/tools/node_modules', function (arguments, _$param4) {
err = _$param4;
if (ERR(err, cb)) {
return;
}
move_if_exists(root_path + '/generated_local/tools_package.json', root_path + '/generated_local/tools/package.json', function (arguments, _$param5) {
err = _$param5;
if (ERR(err, cb)) {
return;
}
modify_es6(root_path + '/generated_local/tools', function (arguments, _$param6) {
err = _$param6;
if (ERR(err, cb)) {
return;
}
convert_es6(root_path + '/generated_local/tools', function (arguments, _$param7) {
err = _$param7;
if (ERR(err, cb)) {
return;
}
console.log('++++ A');
webpack(root_path + '/generated_local/tools', function (arguments, _$param8) {
err = _$param8;
if (ERR(err, cb)) {
return;
}
console.log('++++ B');
cb(null);
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 384 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var ERR = __webpack_require__(1);
var word_wrap = __webpack_require__(2);
var fs = __webpack_require__(6);
var _ = function _(from, to, cb) {
var handle_response = function handle_response() {
cb();
};
fs.move(from, to, handle_response);
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 385 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var ERR = __webpack_require__(1);
var word_wrap = __webpack_require__(2);
var gulp = __webpack_require__(63);
var debug = __webpack_require__(386);
var insert = __webpack_require__(387);
var replace = __webpack_require__(388);
var babel = __webpack_require__(389);
var continuation = __webpack_require__(390);
var _ = function _(root_path, cb) {
gulp.task('a', function () {
return gulp.src([root_path + '/**' + '/*.es6', '!*' + '*/expected/**', '!**' + '/node_modules/**', '!**' + '/*_data/**' + '/*']).pipe(insert.prepend('const word_wrap = require(\'word-wrap\');\n')).pipe(insert.prepend('const ERR = require(\'async-stacktrace\');\n')).pipe(replace(/\[project\_name\]/g, 'lambda_pattern')).pipe(replace(/cont\(.*err.*\).*;/g, '$&\n if (ERR(err, cb)) {\n return;}\n ')).pipe(replace(/const cb = \(err.*\) \=> \{/g, '$&\n if (err) {\n console.log(word_wrap(err.stack.replace(/\\\\/g, \'\\\\ \'), {\n trim: true,\n width: 80})\n .split(\'\\n\').forEach((stack_line) => {\n console.log(stack_line\n .replace(/\\\\ /g, \'\\\\\')\n .replace(/ at/g, \'\\nat\')\n .replace(/Error:/g, \'\\nError:\'));}));\n t.fail();\n return t.end();}\n ')).pipe(gulp.dest(root_path)).on('end', cb).on('error', cb);
});
gulp.start('a');
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 386 */
/***/ function(module, exports) {
module.exports = require("gulp-debug");
/***/ },
/* 387 */
/***/ function(module, exports) {
module.exports = require("gulp-insert");
/***/ },
/* 388 */
/***/ function(module, exports) {
module.exports = require("gulp-replace");
/***/ },
/* 389 */
/***/ function(module, exports) {
module.exports = require("gulp-babel");
/***/ },
/* 390 */
/***/ function(module, exports) {
module.exports = require("gulp-continuation");
/***/ },
/* 391 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var ERR = __webpack_require__(1);
var word_wrap = __webpack_require__(2);
var gulp = __webpack_require__(63);
var debug = __webpack_require__(386);
var insert = __webpack_require__(387);
var replace = __webpack_require__(388);
var babel = __webpack_require__(389);
var continuation = __webpack_require__(390);
var _ = function _(root_path, cb) {
gulp.task('_', function () {
return gulp.src([root_path + '/**/*.es6', '!**/expected/**', '!**/node_modules/**', '!**/*_data/**/*']).pipe(babel({ presets: ['es2015'] })).pipe(continuation()).pipe(gulp.dest(root_path)).on('end', cb).on('error', cb);
});
gulp.start('_');
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 392 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var ERR = __webpack_require__(1);
var word_wrap = __webpack_require__(2);
var gulp = __webpack_require__(63);
var node_externals = __webpack_require__(393);
var debug = __webpack_require__(386);
var insert = __webpack_require__(387);
var replace = __webpack_require__(388);
var babel = __webpack_require__(389);
var continuation = __webpack_require__(390);
var webpack = __webpack_require__(394);
var _ = function _(root_path, cb) {
gulp.task('_', function () {
process.chdir(root_path);
return gulp.src(root_path + '/_.js').pipe(webpack({
context: root_path,
externals: [node_externals()],
module: {
loaders: [{
test: /\.jsx?$/,
exclude: /node_modules/,
loader: 'shebang' }] },
node: {
__filename: false,
__dirname: false },
output: { filename: '__built.js' },
target: 'node' })).pipe(insert.prepend('#!/usr/bin/env node\n\n')).pipe(gulp.dest(root_path)).on('end', cb).on('error', cb);
});
gulp.start('_');
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 393 */
/***/ function(module, exports) {
module.exports = require("webpack-node-externals");
/***/ },
/* 394 */
/***/ function(module, exports) {
module.exports = require("webpack-stream");
/***/ },
/* 395 */
/***/ function(module, exports, __webpack_require__) {
var ERR, word_wrap, lambda_state_history, yaml, get_info, update_history, move_tools_scripts, _;
'use strict';
ERR = __webpack_require__(1);
word_wrap = __webpack_require__(2);
lambda_state_history = __webpack_require__(396);
yaml = __webpack_require__(64);
get_info = __webpack_require__(397);
update_history = __webpack_require__(398);
move_tools_scripts = __webpack_require__(399);
_ = function _(root_path, cb) {
var err, updatables_version, history;
get_info(root_path, function (arguments, _$param0, _$param1, _$param2) {
err = _$param0;
updatables_version = _$param1;
history = _$param2;
if (ERR(err, cb)) {
return;
}
move_tools_scripts(root_path, history['current_state_version'], function (arguments, _$param3) {
err = _$param3;
if (ERR(err, cb)) {
return;
}
update_history(root_path, history, updatables_version, function (arguments, _$param4, _$param5) {
err = _$param4;
history = _$param5;
if (ERR(err, cb)) {
return;
}
cb();
}.bind(this, arguments));
}.bind(this, arguments));
}.bind(this, arguments));
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 396 */
/***/ function(module, exports, __webpack_require__) {
'use strict';
var ERR = __webpack_require__(1);
var word_wrap = __webpack_require__(2);
var fs = __webpack_require__(6);
var yaml = __webpack_require__(64);
var add_new = function add_new(project_path, cb) {
cb();
};
module.exports = { add_new: add_new };
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 397 */
/***/ function(module, exports, __webpack_require__) {
var ERR, word_wrap, fs, yaml, _;
'use strict';
ERR = __webpack_require__(1);
word_wrap = __webpack_require__(2);
fs = __webpack_require__(6);
yaml = __webpack_require__(64);
_ = function _(root_path, cb) {
var err, updatables_version, history;
fs.readFile(root_path + '/generated_local/lambda_updatables/version', 'utf8', function (arguments, _$param0, _$param1) {
err = _$param0;
updatables_version = _$param1;
if (ERR(err, cb)) {
return;
}
fs.readFile(root_path + '/generated/lambda_state_history.yaml', 'utf8', function (arguments, _$param2, _$param3) {
err = _$param2;
history = _$param3;
if (ERR(err, cb)) {
return;
}
history = yaml.safeLoad(history);
cb(null, updatables_version, history);
}.bind(this, arguments));
}.bind(this, arguments));
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 398 */
/***/ function(module, exports, __webpack_require__) {
var ERR, word_wrap, fs, yaml, _;
'use strict';
ERR = __webpack_require__(1);
word_wrap = __webpack_require__(2);
fs = __webpack_require__(6);
yaml = __webpack_require__(64);
_ = function _(root_path, history, updatables_version, cb) {
var state_version, err;
state_version = history['newest_state_version'] + 1;
history['current_state_version'] = state_version;
history['newest_state_version'] = state_version;
history['state_version_order'].push(state_version);
history['states'][state_version] = {
name: 'state',
state_version: updatables_version.replace(/\n/g, ''),
dev_built: false,
dev_tests_passed: false,
release_built: false,
release_tests_passed: false
};
fs.writeFile(root_path + '/generated/lambda_state_history.yaml', yaml.safeDump(history), 'utf8', function (arguments, _$param0) {
err = _$param0;
if (ERR(err, cb)) {
return;
}
cb(null, history);
}.bind(this, arguments));
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ },
/* 399 */
/***/ function(module, exports, __webpack_require__) {
var ERR, word_wrap, fs, move_if_exists, ensure_dir, _;
'use strict';
ERR = __webpack_require__(1);
word_wrap = __webpack_require__(2);
fs = __webpack_require__(6);
move_if_exists = __webpack_require__(384);
ensure_dir = fs.mkdirp;
_ = function _(root_path, updatables_version, cb) {
var err;
ensure_dir(root_path + '/generated/tools/stored', function (arguments, _$param0) {
err = _$param0;
if (ERR(err, cb)) {
return;
}
move_if_exists(root_path + '/generated/tools/_.js', root_path + '/generated/tools/stored/' + updatables_version + '.js', function (arguments, _$param1) {
err = _$param1;
if (ERR(err, cb)) {
return;
}
fs.move(root_path + '/generated_local/tools/__built.js', root_path + '/generated/tools/_.js', cb);
}.bind(this, arguments));
}.bind(this, arguments));
};
module.exports = _;
/* Generated by Continuation.js v0.1.7 */
/***/ }
/******/ ]);