diff --git a/README.md b/README.md index bd269a29..cfaca53b 100644 --- a/README.md +++ b/README.md @@ -240,6 +240,8 @@ BSD 3 Clause - Included in sources. - Added `native` which includes all the static methods that live on `Object` though flipped and curried. +- Added 'fjl-mutable' as part of source. All methods of 'fjl-mutable' now +live directly on 'fjl' and are defined in 'fjl/objects/defineProp' (or more directly in src at './src/objects/defineProp'). #### Development changes. - Updated 'dev-deps' to use latest babel. diff --git a/dist/amd/object/defineProp.js b/dist/amd/object/defineProp.js new file mode 100644 index 00000000..ef0fa915 --- /dev/null +++ b/dist/amd/object/defineProp.js @@ -0,0 +1,202 @@ +define(["exports", "../function/curry", "../jsPlatform/function", "../errorThrowing", "./is"], function (_exports, _curry, _function, _errorThrowing, _is) { + "use strict"; + + Object.defineProperty(_exports, "__esModule", { + value: true + }); + _exports.defineProps = _exports.defineEnumProps = _exports.defineEnumProp = _exports.defineProp = _exports.toTargetDescriptorTuple = _exports.toEnumerableDescriptor = _exports.createTypedDescriptor = void 0; + + function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); } + + function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } + + function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + + function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + + /** + * Creates `defineProps` and `defineEnumProps` methods based on `{enumerable}` param. + * @param {{enumerable: Boolean}} + * @returns {function(*, *)|PropsDefinerCall} + * @private + */ + function createDefinePropsMethod(_ref) { + var enumerable = _ref.enumerable; + var operation = enumerable ? defineEnumProp : defineProp; + return function (argTuples, target) { + argTuples.forEach(function (argTuple) { + var _argTuple = _slicedToArray(argTuple, 3), + TypeRef = _argTuple[0], + propName = _argTuple[1], + defaultValue = _argTuple[2]; + + (0, _function.apply)(operation, [TypeRef, target, propName, defaultValue]); + }); + return target; + }; + } + + var + /** + * Creates a descriptor for a property which is settable but throws + * errors when the `Type` is disobeyed. + * @function module:object.createTypedDescriptor + * @param Type {TypeRef} - {String|Function} + * @param target {*} + * @param propName {String} + * @returns {Descriptor} - Property descriptor with just getter and setter. + */ + createTypedDescriptor = function createTypedDescriptor(Type, target, propName) { + var _value; + + return { + get: function get() { + return _value; + }, + set: function set(value) { + _value = (0, _errorThrowing.errorIfNotType)(Type, propName, target, value); + } + }; + }, + + /** + * Returns a target-descriptor tuple whose 'descriptor' will be set to + * enumerable (`enumerable: true`). + * @function module:object.toEnumerableDescriptor + * @param {TargetDescriptorTuple} - [target, descriptor] tuple. + * @returns {TargetDescriptorTuple} - Array of target and descriptor. + */ + toEnumerableDescriptor = function toEnumerableDescriptor(_ref2) { + var _ref3 = _slicedToArray(_ref2, 2), + target = _ref3[0], + descriptor = _ref3[1]; + + descriptor.enumerable = true; + return [target, descriptor]; + }, + + /** + * Returns an target and descriptor tuple from given. + * @function module:object.toTargetDescriptorTuple + * @param targetOrTargetDescriptorTuple {(*|Array<*, *>)} - Target object or tuple of target and descriptor. + * @returns {(Array<*>|Array<*,*>)} + */ + toTargetDescriptorTuple = function toTargetDescriptorTuple(targetOrTargetDescriptorTuple) { + return (0, _is.isType)('Array', targetOrTargetDescriptorTuple) ? // Strict type check for array + targetOrTargetDescriptorTuple : [targetOrTargetDescriptorTuple]; + }, + + /** + * Allows you to define a "typed" property on given `target`. + * @function module:object.defineProp + * @param Type {TypeRef} - {String|Function} + * @param target {TargetDescriptorTuple} - Target or array of target and descriptor ([target, descriptor]). + * @param propName {String} + * @param [defaultValue=undefined] {*} + * @returns {TargetDescriptorTuple} + */ + defineProp = function defineProp(Type, target, propName) { + var defaultValue = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined; + + var _toTargetDescriptorTu = toTargetDescriptorTuple(target), + _toTargetDescriptorTu2 = _slicedToArray(_toTargetDescriptorTu, 2), + _target = _toTargetDescriptorTu2[0], + _descriptor = _toTargetDescriptorTu2[1], + descriptor = _descriptor || createTypedDescriptor(Type, _target, propName); + + Object.defineProperty(_target, propName, descriptor); + + if (!(0, _is.isUndefined)(defaultValue)) { + _target[propName] = defaultValue; + } + + return [_target, descriptor]; + }, + + /** + * Allows you to define a "typed", enumerated property on `target`. + * @function module:object.defineEnumProp + * @param Type {TypeRef} - {String|Function} + * @param target {TargetDescriptorTuple} - Target or array of target and descriptor ([target, descriptor]). + * @param propName {String} + * @param [defaultValue=undefined] {*} + * @returns {TargetDescriptorTuple} + */ + defineEnumProp = function defineEnumProp(Type, target, propName) { + var defaultValue = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined; + + var _toTargetDescriptorTu3 = toTargetDescriptorTuple(target), + _toTargetDescriptorTu4 = _slicedToArray(_toTargetDescriptorTu3, 2), + _target = _toTargetDescriptorTu4[0], + _descriptor = _toTargetDescriptorTu4[1], + descriptor = _descriptor || createTypedDescriptor(Type, _target, propName); + + return defineProp(Type, toEnumerableDescriptor([_target, descriptor]), propName, defaultValue); + }, + + /** + * Allows you to define multiple enum props at once on target. + * @function module:object.defineEnumProps + * @param argsTuple {Array.} - Array of argArrays for `defineEnumProp`. + * @param [target = undefined] {Target} - Target to use in internal calls if one is not provided but encountered 'argArray'. + * @returns {Array.} - Results of each call to `defineEnumProp`. + */ + defineEnumProps = (0, _curry.curry)(createDefinePropsMethod({ + enumerable: true + })), + + /** + * Allows you to define multiple props at once on target. + * @function module:object.defineProps + * @param argsTuple {Array.} - Array of argArrays for `defineProp`. + * @param [target = undefined] {Target} - Target to use in internal calls if one is not provided but encountered 'argArray'. + * @returns {Array.} - Results of each call to `defineProp`. + * @curried + */ + defineProps = (0, _curry.curry)(createDefinePropsMethod({ + enumerable: false + })); + /** ============================================================= */ + + /** Type definitions: */ + + /** ============================================================= */ + + /** + * @typedef {*} Target + */ + + /** + * @typedef {Object} Descriptor + */ + + /** + * @typedef {Array} TargetDescriptorTuple + */ + + /** + * @typedef {Array.} DefinePropArgsTuple + * @description Arguments list for `defineProp` and/or `defineEnumProp` (note: some + * parts of array/tuple are options (namely the last two args)); E.g., + * ``` + * [String, [someTarget], 'somePropName', 'someDefaultValue] // ... + * ``` + */ + + /** + * @typedef {Function} PropsDefinerCall + * @description Same type as `defineProp` and `defineEnumProp` + * @param argsTuple {DefinePropArgsTuple} + * @param target {Target} + * @returns {Array.} + */ + + + _exports.defineProps = defineProps; + _exports.defineEnumProps = defineEnumProps; + _exports.defineEnumProp = defineEnumProp; + _exports.defineProp = defineProp; + _exports.toTargetDescriptorTuple = toTargetDescriptorTuple; + _exports.toEnumerableDescriptor = toEnumerableDescriptor; + _exports.createTypedDescriptor = createTypedDescriptor; +}); \ No newline at end of file diff --git a/dist/cjs/object/defineProp.js b/dist/cjs/object/defineProp.js new file mode 100644 index 00000000..df3a9410 --- /dev/null +++ b/dist/cjs/object/defineProp.js @@ -0,0 +1,208 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.defineProps = exports.defineEnumProps = exports.defineEnumProp = exports.defineProp = exports.toTargetDescriptorTuple = exports.toEnumerableDescriptor = exports.createTypedDescriptor = void 0; + +var _curry = require("../function/curry"); + +var _function = require("../jsPlatform/function"); + +var _errorThrowing = require("../errorThrowing"); + +var _is = require("./is"); + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } + +function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +/** + * Creates `defineProps` and `defineEnumProps` methods based on `{enumerable}` param. + * @param {{enumerable: Boolean}} + * @returns {function(*, *)|PropsDefinerCall} + * @private + */ +function createDefinePropsMethod(_ref) { + var enumerable = _ref.enumerable; + var operation = enumerable ? defineEnumProp : defineProp; + return function (argTuples, target) { + argTuples.forEach(function (argTuple) { + var _argTuple = _slicedToArray(argTuple, 3), + TypeRef = _argTuple[0], + propName = _argTuple[1], + defaultValue = _argTuple[2]; + + (0, _function.apply)(operation, [TypeRef, target, propName, defaultValue]); + }); + return target; + }; +} + +var +/** + * Creates a descriptor for a property which is settable but throws + * errors when the `Type` is disobeyed. + * @function module:object.createTypedDescriptor + * @param Type {TypeRef} - {String|Function} + * @param target {*} + * @param propName {String} + * @returns {Descriptor} - Property descriptor with just getter and setter. + */ +createTypedDescriptor = function createTypedDescriptor(Type, target, propName) { + var _value; + + return { + get: function get() { + return _value; + }, + set: function set(value) { + _value = (0, _errorThrowing.errorIfNotType)(Type, propName, target, value); + } + }; +}, + +/** + * Returns a target-descriptor tuple whose 'descriptor' will be set to + * enumerable (`enumerable: true`). + * @function module:object.toEnumerableDescriptor + * @param {TargetDescriptorTuple} - [target, descriptor] tuple. + * @returns {TargetDescriptorTuple} - Array of target and descriptor. + */ +toEnumerableDescriptor = function toEnumerableDescriptor(_ref2) { + var _ref3 = _slicedToArray(_ref2, 2), + target = _ref3[0], + descriptor = _ref3[1]; + + descriptor.enumerable = true; + return [target, descriptor]; +}, + +/** + * Returns an target and descriptor tuple from given. + * @function module:object.toTargetDescriptorTuple + * @param targetOrTargetDescriptorTuple {(*|Array<*, *>)} - Target object or tuple of target and descriptor. + * @returns {(Array<*>|Array<*,*>)} + */ +toTargetDescriptorTuple = function toTargetDescriptorTuple(targetOrTargetDescriptorTuple) { + return (0, _is.isType)('Array', targetOrTargetDescriptorTuple) ? // Strict type check for array + targetOrTargetDescriptorTuple : [targetOrTargetDescriptorTuple]; +}, + +/** + * Allows you to define a "typed" property on given `target`. + * @function module:object.defineProp + * @param Type {TypeRef} - {String|Function} + * @param target {TargetDescriptorTuple} - Target or array of target and descriptor ([target, descriptor]). + * @param propName {String} + * @param [defaultValue=undefined] {*} + * @returns {TargetDescriptorTuple} + */ +defineProp = function defineProp(Type, target, propName) { + var defaultValue = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined; + + var _toTargetDescriptorTu = toTargetDescriptorTuple(target), + _toTargetDescriptorTu2 = _slicedToArray(_toTargetDescriptorTu, 2), + _target = _toTargetDescriptorTu2[0], + _descriptor = _toTargetDescriptorTu2[1], + descriptor = _descriptor || createTypedDescriptor(Type, _target, propName); + + Object.defineProperty(_target, propName, descriptor); + + if (!(0, _is.isUndefined)(defaultValue)) { + _target[propName] = defaultValue; + } + + return [_target, descriptor]; +}, + +/** + * Allows you to define a "typed", enumerated property on `target`. + * @function module:object.defineEnumProp + * @param Type {TypeRef} - {String|Function} + * @param target {TargetDescriptorTuple} - Target or array of target and descriptor ([target, descriptor]). + * @param propName {String} + * @param [defaultValue=undefined] {*} + * @returns {TargetDescriptorTuple} + */ +defineEnumProp = function defineEnumProp(Type, target, propName) { + var defaultValue = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined; + + var _toTargetDescriptorTu3 = toTargetDescriptorTuple(target), + _toTargetDescriptorTu4 = _slicedToArray(_toTargetDescriptorTu3, 2), + _target = _toTargetDescriptorTu4[0], + _descriptor = _toTargetDescriptorTu4[1], + descriptor = _descriptor || createTypedDescriptor(Type, _target, propName); + + return defineProp(Type, toEnumerableDescriptor([_target, descriptor]), propName, defaultValue); +}, + +/** + * Allows you to define multiple enum props at once on target. + * @function module:object.defineEnumProps + * @param argsTuple {Array.} - Array of argArrays for `defineEnumProp`. + * @param [target = undefined] {Target} - Target to use in internal calls if one is not provided but encountered 'argArray'. + * @returns {Array.} - Results of each call to `defineEnumProp`. + */ +defineEnumProps = (0, _curry.curry)(createDefinePropsMethod({ + enumerable: true +})), + +/** + * Allows you to define multiple props at once on target. + * @function module:object.defineProps + * @param argsTuple {Array.} - Array of argArrays for `defineProp`. + * @param [target = undefined] {Target} - Target to use in internal calls if one is not provided but encountered 'argArray'. + * @returns {Array.} - Results of each call to `defineProp`. + * @curried + */ +defineProps = (0, _curry.curry)(createDefinePropsMethod({ + enumerable: false +})); +/** ============================================================= */ + +/** Type definitions: */ + +/** ============================================================= */ + +/** + * @typedef {*} Target + */ + +/** + * @typedef {Object} Descriptor + */ + +/** + * @typedef {Array} TargetDescriptorTuple + */ + +/** + * @typedef {Array.} DefinePropArgsTuple + * @description Arguments list for `defineProp` and/or `defineEnumProp` (note: some + * parts of array/tuple are options (namely the last two args)); E.g., + * ``` + * [String, [someTarget], 'somePropName', 'someDefaultValue] // ... + * ``` + */ + +/** + * @typedef {Function} PropsDefinerCall + * @description Same type as `defineProp` and `defineEnumProp` + * @param argsTuple {DefinePropArgsTuple} + * @param target {Target} + * @returns {Array.} + */ + + +exports.defineProps = defineProps; +exports.defineEnumProps = defineEnumProps; +exports.defineEnumProp = defineEnumProp; +exports.defineProp = defineProp; +exports.toTargetDescriptorTuple = toTargetDescriptorTuple; +exports.toEnumerableDescriptor = toEnumerableDescriptor; +exports.createTypedDescriptor = createTypedDescriptor; \ No newline at end of file diff --git a/dist/es6-module/fjl.js b/dist/es6-module/fjl.js index ca6a47e8..9152c4cf 100644 --- a/dist/es6-module/fjl.js +++ b/dist/es6-module/fjl.js @@ -1676,5 +1676,11 @@ const classCase = compose(ucaseFirst, camelCase); * @see http://hackage.haskell.org/package/base-4.10.0.0/docs/Data-List.html */ +/** + * @typedef {String|Function|ArrayBufferConstructor|ArrayConstructor|BooleanConstructor|MapConstructor|NumberConstructor|SetConstructor|WeakMapConstructor|WeakSetConstructor} TypeRef + * @description Type reference. Either actual type or type's name; E.g., `Type.name` + * Also note: Class cased names are use for values that do not have `name` properties; Namely: 'Null', 'NaN' and 'Undefined' (for their respective values respectively). + */ + export { instanceOf, hasOwnProperty, length, native, keys, assign, lookup, typeOf, copy, toTypeRef, toTypeRefs, toTypeRefName, toTypeRefNames, isFunction, isType, isOfType, isClass, isCallable, isArray, isObject, isBoolean, isNumber, isString, isMap, isSet, isWeakMap, isWeakSet, isUndefined, isNull, isSymbol, isUsableImmutablePrimitive, isEmptyList, isEmptyObject, isEmptyCollection, isEmpty, isset, isOneOf, isFunctor, of, searchObj, assignDeep, objUnion, objIntersect, objDifference, objComplement, log, error, peek, jsonClone, toArray, toAssocList, toAssocListDeep, fromAssocList, fromAssocListDeep, isTruthy, isFalsy, alwaysTrue, alwaysFalse, equal, equalAll, apply, call, compose, curryN, curry, curry2, curry3, curry4, curry5, flipN, flip, flip3, flip4, flip5, id, negateF, negateF2, negateF3, negateFN, until, fnOrError, noop, map$1 as map, append, head, last, tail, init, uncons, unconsr, concat$1 as concat, concatMap, reverse$1 as reverse, intersperse, intercalate, transpose, subsequences, swapped, permutations, foldl, foldr, foldl1, foldr1, mapAccumL, mapAccumR, iterate, repeat, replicate, cycle, unfoldr, findIndex, findIndices, elemIndex, elemIndices, take, drop, splitAt, takeWhile, dropWhile, dropWhileEnd, span, breakOnList, at, find, forEach$1 as forEach, filter$1 as filter, partition, elem, notElem, isPrefixOf, isSuffixOf, isInfixOf, isSubsequenceOf, group, groupBy, inits, tails, stripPrefix, zip, zipN, zip3, zip4, zip5, zipWith, zipWithN, zipWith3, zipWith4, zipWith5, unzip, unzipN, any, all, and, or, not, sum, product, maximum, minimum, scanl, scanl1, scanr, scanr1, nub, remove, sort, sortOn, sortBy, insert, insertBy, nubBy, removeBy, removeFirstsBy, unionBy, union, intersect, intersectBy, difference, complement, slice, includes, indexOf, lastIndexOf, push, range, sliceFrom, sliceTo, sliceCopy, genericAscOrdering, lengths, toShortest, reduceUntil, reduceUntilRight, reduce$1 as reduce, reduceRight$1 as reduceRight, lastIndex, findIndexWhere, findIndexWhereRight, findIndicesWhere, findWhere, aggregateArray, split, lines, words, unwords, unlines, lcaseFirst, ucaseFirst, camelCase, classCase, fPureTakesOne, fPureTakes2, fPureTakes3, fPureTakes4, fPureTakes5, fPureTakesOneOrMore, typeRefsToStringOrError, defaultErrorMessageCall, _getErrorIfNotTypeThrower, _getErrorIfNotTypesThrower, _errorIfNotType, _errorIfNotTypes, getErrorIfNotTypeThrower, getErrorIfNotTypesThrower, errorIfNotType, errorIfNotTypes }; //# sourceMappingURL=fjl.js.map diff --git a/dist/es6-module/fjl.js.map b/dist/es6-module/fjl.js.map index 7fa774cb..e691b536 100644 --- a/dist/es6-module/fjl.js.map +++ b/dist/es6-module/fjl.js.map @@ -1 +1 @@ -{"version":3,"file":"fjl.js","sources":["../../src/function/curry.js","../../src/utils.js","../../src/jsPlatform/array.js","../../src/jsPlatform/function.js","../../src/function/flip.js","../../src/jsPlatform/object.js","../../src/object/typeOf.js","../../src/object/is.js","../../src/object/lookup.js","../../src/object/of.js","../../src/object/copy.js","../../src/object/searchObj.js","../../src/object/assignDeep.js","../../src/jsPlatform/list.js","../../src/boolean.js","../../src/list/map.js","../../src/list/aggregation.js","../../src/list/utils.js","../../src/object/setTheory.js","../../src/object/console.js","../../src/object/jsonClone.js","../../src/object/assocList.js","../../src/object/toArray.js","../../src/object.js","../../src/function/compose.js","../../src/function/id.js","../../src/function/negate.js","../../src/function/until.js","../../src/function/fnOrError.js","../../src/function/noop.js","../../src/function.js","../../src/list/range.js","../../src/jsPlatform/string.js","../../src/jsPlatform.js","../../src/list.js","../../src/errorThrowing.js","../../src/string.js","../../src/fjl.js"],"sourcesContent":["/**\r\n * @author elydelacruz\r\n * @created 12/6/2016.\r\n * @memberOf function\r\n * @description \"Curry strict\" and \"curry arbitrarily\" functions (`curry`, `curryN`).\r\n */\r\n\r\n/**\r\n * @private\r\n * @type {string}\r\n */\r\nconst\r\n\r\n /**\r\n * Returns curried function.\r\n * @private\r\n * @param executeArity {Number}\r\n * @param unmetArityNum {Number}\r\n * @param fn {Function}\r\n * @param argsToCurry {...*}\r\n * @returns {Function} - Curried function.\r\n */\r\n returnCurried = (executeArity, unmetArityNum, fn, argsToCurry) => {\r\n switch (unmetArityNum) {\r\n case 1:\r\n /* eslint-disable */\r\n return function func(x) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 2:\r\n /* eslint-disable */\r\n return function func(a, b) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 3:\r\n /* eslint-disable */\r\n return function func(a, b, c) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 4:\r\n /* eslint-disable */\r\n return function func(a, b, c, d) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 5:\r\n /* eslint-disable */\r\n return function func(a, b, c, d, e) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n default:\r\n return (...args) => executeAsCurriedFunc(fn, executeArity, unmetArityNum, args, argsToCurry);\r\n }\r\n },\r\n\r\n /**\r\n * Returns curried function if unmetArity is not met else returns result of executing\r\n * final function.\r\n * @private\r\n * @param fn {Function}\r\n * @param executeArity {Number}\r\n * @param unmetArity {Number}\r\n * @param args {Array<*>}\r\n * @param argsToCurry {Array<*>}\r\n * @returns {Function|*} - Curried function or result of 'finally' executed function.\r\n */\r\n executeAsCurriedFunc = (fn, executeArity, unmetArity, args, argsToCurry) => {\r\n let concatedArgs = argsToCurry.concat(args),\r\n canBeCalled = (concatedArgs.length >= executeArity) || !executeArity,\r\n newExpectedArity = executeArity - concatedArgs.length;\r\n return !canBeCalled ?\r\n returnCurried(executeArity, newExpectedArity, fn, concatedArgs) :\r\n fn(...concatedArgs);\r\n }\r\n;\r\n\r\nexport const\r\n\r\n /**\r\n * Curries a function up to a given arity.\r\n * @function module:function.curryN\r\n * @param executeArity {Number}\r\n * @param fn {Function}\r\n * @param argsToCurry {...*}\r\n * @returns {Function}\r\n * @throws {Error} - When `fn` is not a function.\r\n */\r\n curryN = (executeArity, fn, ...argsToCurry) => {\r\n if (!fn || !(fn instanceof Function)) {\r\n throw new Error(`\\`curry*\\` functions expect first parameter to be of type \\`Function\\` though received ${fn}?`);\r\n }\r\n return returnCurried(executeArity, executeArity - argsToCurry.length, fn, argsToCurry);\r\n },\r\n\r\n /**\r\n * Curries a function based on it's defined arity (note: rest args param (`...rest`) are not counted in arity).\r\n * @function module:function.curry\r\n * @param fn {Function}\r\n * @param argsToCurry {...*}\r\n * @returns {Function}\r\n */\r\n curry = (fn, ...argsToCurry) => curryN((fn || {}).length, fn, ...argsToCurry),\r\n\r\n /**\r\n * Curries a function up to an arity of 2 (won't call function until 2 or more args).\r\n * @function module:function.curry2\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry2 = fn => curryN(2, fn),\r\n\r\n /**\r\n * Curries a function up to an arity of 3 (won't call function until 3 or more args).\r\n * @function module:function.curry3\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry3 = fn => curryN(3, fn),\r\n\r\n /**\r\n * Curries a function up to an arity of 4 (won't call function until 4 or more args).\r\n * @function module:function.curry4\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry4 = fn => curryN(4, fn),\r\n\r\n /**\r\n * Curries a function up to an arity of 5 (won't call function until 5 or more args).\r\n * @function module:function.curry5\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry5 = fn => curryN(5, fn);\r\n","/**\r\n * @module utils\r\n */\r\nimport {curry, curry2} from './function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a function that takes an argument and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakesOne\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakesOne = name => curry((arg, f) => f[name](arg)),\r\n\r\n /**\r\n * Returns a function that takes 2 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes2\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes2 = name => curry((arg1, arg2, f) => f[name](arg1, arg2)),\r\n\r\n /**\r\n * Returns a function that takes 3 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes3\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes3 = name => curry((arg1, arg2, arg3, f) => f[name](arg1, arg2, arg3)),\r\n\r\n /**\r\n * Returns a function that takes 4 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes4\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes4 = name => curry((arg1, arg2, arg3, arg4, f) => f[name](arg1, arg2, arg3, arg4)),\r\n\r\n /**\r\n * Returns a function that takes 5 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes5\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes5 = name => curry((arg1, arg2, arg3, arg4, arg5, f) => f[name](arg1, arg2, arg3, arg4, arg5)),\r\n\r\n /**\r\n * Returns a function that takes an object and one or more arguments on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakesOneOrMore\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakesOneOrMore = name => curry2((f, ...args) => f[name](...args))\r\n\r\n;\r\n","/**\r\n * Created by elyde on 7/20/2017.\r\n * Functional versions of common array methods (`map`, `filter`, etc.) (un-curried);\r\n * @module _jsPlatform_arrayOps\r\n * @private\r\n */\r\n\r\nimport {fPureTakesOne, fPureTakes2, fPureTakesOneOrMore} from '../utils';\r\n\r\nexport const\r\n\r\n /**\r\n * Array.prototype.reverse generator (generates a function that calls the prototype version or a\r\n * shimmed version if it doesn't exist).\r\n * @returns {Function}\r\n */\r\n defineReverse = () =>\r\n Array.prototype.reverse ? x => x.reverse() :\r\n x => x.reduceRight((agg, item) => {\r\n agg.push(item);\r\n return agg;\r\n }, []),\r\n\r\n /**\r\n * Maps a function to functor (list etc.).\r\n * @function module:_jsPlatform_array.map\r\n * @param fn {Function}\r\n * @param functor {Array|{map: {Function}}}\r\n * @returns {Array|{map: {Function}}}\r\n */\r\n map = fPureTakesOne('map'),\r\n\r\n /**\r\n * Filters a functor (list etc.) with passed in function.\r\n * @function module:_jsPlatform_array.filter\r\n * @param fn {Function}\r\n * @param functor {Array|{filter: {Function}}}\r\n * @returns {Array|{filter: {Function}}}\r\n */\r\n filter = fPureTakesOne('filter'),\r\n\r\n /**\r\n * Reduces a foldable (list etc.) with passed in function.\r\n * @function module:_jsPlatform_array.reduce\r\n * @param fn {Function}\r\n * @param functor {Array|{reduce: {Function}}}\r\n * @returns {Array|{reduce: {Function}}}\r\n */\r\n reduce = fPureTakes2('reduce'),\r\n\r\n /**\r\n * Reduces a foldable (list etc.) from the right with passed in function.\r\n * @function module:_jsPlatform_array.reduceRight\r\n * @param fn {Function}\r\n * @param functor {Array|{reduceRight: {Function}}}\r\n * @returns {Array|{reduceRight: {Function}}}\r\n */\r\n reduceRight = fPureTakes2('reduceRight'),\r\n\r\n /**\r\n * For each on functor (Array|Object|etc.).\r\n * @param fn {Function}\r\n * @param functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type of object you pass in unless it doesn't have a `forEach` method.\r\n * @throws {Error} - When passed in functor doesn't have a `forEach` method.\r\n */\r\n forEach = fPureTakesOne('forEach'),\r\n\r\n /**\r\n * Returns `true` if `fn` (predicate) returns true for at least one item\r\n * in functor else returns `false`.\r\n * @param fn {Function} - Predicate.\r\n * @param functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type passed.\r\n * @throws {Error} - When passed in object doesn't have a `some` method.\r\n */\r\n some = fPureTakesOne('some'),\r\n\r\n /**\r\n * Returns `true` if `fn` (predicate) returns true for all items in functor else returns `false`.\r\n * @param fn {Function} - Predicate.\r\n * @param functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type passed.\r\n * @throws {Error} - When passed in object doesn't have an `every` method.\r\n */\r\n every = fPureTakesOne('every'),\r\n\r\n /**\r\n * Array.prototype.join\r\n * @function module:listPrelude.join\r\n * @param separator {String|RegExp}\r\n * @param arr {Array}\r\n * @returns {String}\r\n */\r\n join = fPureTakesOne('join'),\r\n\r\n /**\r\n * Same as Array.prototype.push\r\n * @param item {*}\r\n * @param arr {Array}\r\n * @returns {Number}\r\n */\r\n push = fPureTakesOneOrMore('push'),\r\n\r\n /**\r\n * Reverses an list (shimmed if not exists).\r\n * @function module:listPrelude.reverse\r\n * @return {Array}\r\n */\r\n reverse = defineReverse();\r\n","import {curry, curry2} from '../function/curry';\r\n\r\n/**\r\n * Created by elydelacruz on 9/7/2017.\r\n * @memberOf function\r\n */\r\nexport const\r\n\r\n /**\r\n * Functional `apply` function (takes no context).\r\n * @function module:function.apply\r\n * @param fn {Function}\r\n * @param args {Array|*}\r\n * @returns {*}\r\n */\r\n apply = curry((fn, args) => fn.apply(null, args)),\r\n\r\n /**\r\n * Functional `call` function (takes no context).\r\n * @function module:function.call\r\n * @param fn {Function}\r\n * @param args {...*}\r\n * @returns {*}\r\n */\r\n call = curry2((fn, ...args) => fn.call(null, ...args));\r\n","import {reverse} from '../jsPlatform/array';\r\nimport {apply, call} from '../jsPlatform/function';\r\nimport {curry, curry2} from './curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a curried function requiring given functions arguments in reverse\r\n * (returned function expects 2 or more variables (curried at 2 or more args)).\r\n * @function module:function.flipN\r\n * @param fn {Function}\r\n * @returns {Function}\r\n * @curried\r\n */\r\n flipN = fn => curry2((...args) => apply(fn, reverse(args))),\r\n\r\n /**\r\n * Flips a function's first and second arguments and and returns a new function requiring said arguments in reverse.\r\n * @function module:function.flip\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip = fn => curry((b, a) => call(fn, a, b)),\r\n\r\n /**\r\n * Same as `flip` except returns a flipped function of arity 3.\r\n * @function module:function.flip3\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip3 = fn => curry((c, b, a) => call(fn, a, b, c)),\r\n\r\n /**\r\n * Same as `flip` except returns a flipped function of arity 4.\r\n * @function module:function.flip4\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip4 = fn => curry((d, c, b, a) => call(fn, a, b, c, d)),\r\n\r\n /**\r\n * Same as `flip` except returns a flipped function of arity 5.\r\n * @function module:function.flip5\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip5 = fn => curry((e, d, c, b, a) => call(fn, a, b, c, d, e));\r\n","/**\r\n * @memberOf object\r\n * @description Defines some of the platform methods for objects (the ones used within `fjl`).\r\n */\r\n\r\nimport {fPureTakesOne} from '../utils';\r\nimport {curry, curry2} from '../function/curry';\r\nimport {flip, flip3, flip4, flip5} from '../function/flip';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns whether constructor has derived object.\r\n * @function module:object.instanceOf\r\n * @param instanceConstructor {Function} - Constructor.\r\n * @param instance {*}\r\n * @instance {*}\r\n * @returns {Boolean}\r\n */\r\n instanceOf = curry((instanceConstructor, instance) =>\r\n instance instanceof instanceConstructor),\r\n\r\n /**\r\n * @function module:object.hasOwnProperty\r\n * @param propName {*}\r\n * @param typeInstance {*}\r\n * @returns {Boolean}\r\n * @deprecated - Use property directly instead.\r\n */\r\n hasOwnProperty = fPureTakesOne('hasOwnProperty'),\r\n\r\n /**\r\n * @function module:object.length\r\n * @param x {*}\r\n * @returns {Number}\r\n * @throws {Error} - Throws an error if value doesn't have a `length` property (\r\n * `null`, `undefined`, {Boolean}, Symbol, et. al.).\r\n */\r\n length = x => x.length,\r\n\r\n /**\r\n * Contains all the static functions from `Object` but curried and flipped;\r\n * @example\r\n * // E.g., `Object.defineProperties(obj, descriptor)` can now be used like\r\n * import {defineProperties} from 'fjl'\r\n * defineProperties(descriptor, someObj),\r\n * // Et. al.\r\n * @memberOf module:object\r\n * @type {{...Object}}\r\n */\r\n native = Object.getOwnPropertyNames(Object).reduce((agg, key) => {\r\n if (typeof Object[key] !== 'function') {\r\n return agg;\r\n }\r\n const operation = Object[key];\r\n switch (operation.length) {\r\n case 2:\r\n agg[key] = flip(operation);\r\n break;\r\n case 3:\r\n agg[key] = flip3(operation);\r\n break;\r\n case 4:\r\n agg[key] = flip4(operation);\r\n break;\r\n case 5:\r\n agg[key] = flip5(operation);\r\n break;\r\n default:\r\n agg[key] = Object[key];\r\n break;\r\n }\r\n return agg;\r\n }, {}),\r\n\r\n /**\r\n * Gets passed in object's own enumerable keys (same as `Object.keys`).\r\n * @function module:object.keys\r\n * @param obj {*}\r\n * @returns {Array}\r\n */\r\n {keys} = native,\r\n\r\n /**\r\n * Defined as `Object.assign` else is the same thing but shimmed.\r\n * @function module:object.assign\r\n * @param obj0 {Object}\r\n * @param objs {...{Object}}\r\n * @returns {Object}\r\n */\r\n assign = (() => Object.assign ?\r\n (obj0, ...objs) => Object.assign(obj0, ...objs) :\r\n curry2((obj0, ...objs) => objs.reduce((topAgg, obj) => {\r\n return Object.keys(obj).reduce((agg, key) => {\r\n agg[key] = obj[key];\r\n return agg;\r\n }, topAgg);\r\n }, obj0))\r\n )();\r\n","/**\r\n * Created by elyde on 12/18/2016.\r\n * @memberOf object\r\n */\r\nconst _Number = Number.name,\r\n _NaN = 'NaN',\r\n _Null = 'Null',\r\n _Undefined = 'Undefined';\r\n\r\n/**\r\n * Returns the constructor/class/type name of a value.\r\n * @note Returns 'NaN' if value is of type `Number` and value is `isNaN`.\r\n * @note Returns 'Undefined' if value is `undefined`\r\n * @note Returns 'Null' if value is `null`\r\n * For values that have no concrete constructors and/or casters\r\n * (null, NaN, and undefined) we returned normalized names for them ('Null', 'NaN', 'Number')\r\n * @function module:object.typeOf\r\n * @param value {*}\r\n * @returns {string} - Constructor's name or derived name (in the case of `null`, `undefined`, or `NaN` (whose\r\n * normalized names are 'Null', 'Undefined', 'NaN' respectively).\r\n */\r\nexport function typeOf (value) {\r\n let retVal;\r\n if (value === undefined) {\r\n retVal = _Undefined;\r\n }\r\n else if (value === null) {\r\n retVal = _Null;\r\n }\r\n else {\r\n let constructorName = (value).constructor.name;\r\n retVal = constructorName === _Number && isNaN(value) ?\r\n _NaN : constructorName;\r\n }\r\n return retVal;\r\n}\r\n","/**\r\n * Created by elyde on 12/18/2016.\r\n * @memberOf object\r\n */\r\n\r\nimport {typeOf} from './typeOf';\r\nimport {instanceOf, length, keys} from '../jsPlatform/object';\r\nimport {curry} from '../function/curry';\r\n\r\nlet _String = String.name,\r\n _Number = Number.name,\r\n _Object = Object.name,\r\n _Boolean = Boolean.name,\r\n _Function = Function.name,\r\n _Array = Array.name,\r\n _Symbol = 'Symbol',\r\n _Map = 'Map',\r\n _Set = 'Set',\r\n _WeakMap = 'WeakMap',\r\n _WeakSet = 'WeakSet',\r\n _Null = 'Null',\r\n _Undefined = 'Undefined',\r\n _NaN = 'NaN';\r\n\r\nexport const\r\n\r\n /**\r\n * Resolves/normalizes a type name from either a string or a constructor.\r\n * @function module:object.toTypeRef\r\n * @param type {Function|String} - String or function representing a type.\r\n * @returns {String}\r\n * @todo write tests for this function.\r\n */\r\n toTypeRef = type => {\r\n if (!type) {\r\n return typeOf(type);\r\n }\r\n else if (type.constructor === String || (type instanceof Function)) {\r\n return type;\r\n }\r\n return typeOf(type);\r\n },\r\n\r\n /**\r\n * Returns an array of type refs from possible type refs (converts null, undefined, NaN, and other values into\r\n * type refs (either constructor name or constructor name based on whether value(s) is a string, a constructor, or not).\r\n * @function module:object.toTypeRefs\r\n * @param types {...(TypeRef|*)}\r\n * @returns {Array}\r\n * @todo Ensure tests are written for this function.\r\n */\r\n toTypeRefs = (...types) => types.map(toTypeRef),\r\n\r\n /**\r\n * Returns possible Type's TypeRef name.\r\n * @function module:object.toTypeRefName\r\n * @param Type {(TypeRef|*)}\r\n * @returns {String}\r\n * @todo Ensure tests are written for this function.\r\n */\r\n toTypeRefName = Type => {\r\n const ref = toTypeRef(Type);\r\n return ref instanceof Function ? ref.name : ref;\r\n },\r\n\r\n /**\r\n * Returns possible Types' TypeRef names.\r\n * @function module:object.toTypeRefNames\r\n * @param types {...(TypeRef|*)}\r\n * @returns {String[]}\r\n * @todo Ensure tests are written for this function.\r\n */\r\n toTypeRefNames = (...types) => types.map(toTypeRefName),\r\n\r\n /**\r\n * Returns whether a value is a function or not.\r\n * @function module:object.isFunction\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isFunction = instanceOf(Function),\r\n\r\n /**\r\n * Strict type checker. Checks if given value is a direct instance of given type; E.g.,\r\n * @example\r\n * isType(String, 'abcdefg') === true // true\r\n * isType(String.name, 'abcdefg') === true\r\n * isType(Number, NaN) === false\r\n * isType(Number, 99) === true\r\n * isType('Null', 99) === false // though, for `null` and `undefined` checks\r\n * // @see `isset`, in this module, instead\r\n * isType('Undefined', undefined) === true // true\r\n *\r\n * @note Useful where absolute types, or some semblance thereof, are required.\r\n * @function module:object.isType\r\n * @param type {Function|ObjectConstructor|String} - Constructor or constructor name\r\n * @param obj {*}\r\n * @return {Boolean}\r\n */\r\n isType = curry((type, obj) => typeOf(obj) === toTypeRefName(type)),\r\n\r\n /**\r\n * Loose type checker; E.g., If `type` is not a constructor, but a constructor name, does a type check on\r\n * constructor names, else if first check fails and `type` is a constructor, performs an `instanceof` check\r\n * on value with constructor.\r\n * @note Use care when checking for `Array` and/or `Object` since the both are considered objects by `instanceof` checker.\r\n * @note For `null` and `undefined` their class cased names can be used for type checks\r\n * `isOfType('Null', null) === true (passes strict type check)` (or better yet `isset` can be used).\r\n * @throwsafe - Doesn't throw on `null` or `undefined` `obj` values.\r\n * @example\r\n * isOfType(Number, 99) === true // true (passes strict type check (numbers are not instances of `Number`\r\n * // constructor)\r\n * isOfType('Number', 99) === true // true (passes strict type check)\r\n * isOfType(Number, NaN) === true // true. (passes instance of check)\r\n * // If you want \"true\" strict type checking use `isType`\r\n * isOfType(Object, []) === true // true (passes instance of check)\r\n * isOfType(Array, []) === true // true (passes instance of check)\r\n * isOfType(Object, {}) === true // true (passes instance of check)\r\n * isOfType(Object.name, {}) === true // true (Passes strict type check)\r\n * class Abc extends String {}\r\n * isOfType(String, new Abc('abcd')) // true (passes instanceof check)\r\n *\r\n * @function module:object.isOfType\r\n * @param type {Function|String} - Type reference (constructor or `constructor.name`).\r\n * @param x {*} - Value to check.\r\n * @returns {Boolean}\r\n */\r\n isOfType = curry((type, x) => isType(type, x) || instanceOf(type, x)),\r\n\r\n /**\r\n * Checks if `value` is an es2015 `class`.\r\n * @function module:object.isClass\r\n * @param x {*}\r\n * @returns {boolean}\r\n */\r\n isClass = x => x && /^\\s{0,3}class\\s{1,3}/.test((x + '').substr(0, 10)),\r\n\r\n /**\r\n * Returns a boolean depicting whether a value is callable or not.\r\n * @function module:object.isCallable\r\n * @tentative\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isCallable = x => isFunction(x) && !isClass(x),\r\n\r\n /**\r\n * Checks if value is an array (same as `Array.isArray`).\r\n * @function module:object.isArray\r\n * @param value {*}\r\n * @returns {boolean}\r\n */\r\n {isArray} = Array,\r\n\r\n /**\r\n * Checks whether value is an object or not.\r\n * @function module:object.isObject\r\n * @param value\r\n * @returns {Boolean}\r\n */\r\n isObject = isType(_Object),\r\n\r\n /**\r\n * Checks if value is a boolean.\r\n * @function module:object.isBoolean\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isBoolean = isType(_Boolean),\r\n\r\n /**\r\n * Checks if value is a valid number (also checks if isNaN so that you don't have to).\r\n * @function module:object.isNumber\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isNumber = isType(_Number),\r\n\r\n /**\r\n * Checks whether value is a string or not.\r\n * @function module:object.isString\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isString = isType(_String),\r\n\r\n /**\r\n * Checks whether value is of `Map` or not.\r\n * @function module:object.isMap\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isMap = isType(_Map),\r\n\r\n /**\r\n * Checks whether value is of `Set` or not.\r\n * @function module:object.isSet\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isSet = isType(_Set),\r\n\r\n /**\r\n * Checks whether value is of `WeakMap` or not.\r\n * @function module:object.isWeakMap\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isWeakMap =isType(_WeakMap),\r\n\r\n /**\r\n * Checks whether value is of `WeakSet` or not.\r\n * @function module:object.isWeakSet\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isWeakSet = isType(_WeakSet),\r\n\r\n /**\r\n * Checks if value is undefined.\r\n * @function module:object.isUndefined\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isUndefined = isType(_Undefined),\r\n\r\n /**\r\n * Checks if value is null.\r\n * @function module:object.isNull\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isNull = isType(_Null),\r\n\r\n /**\r\n * Checks if value is a `Symbol`.\r\n * @function module:object.isSymbol\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isSymbol = isType(_Symbol),\r\n\r\n /**\r\n * Checks if given `x` is set and of one of\r\n * [String, Boolean, Number, Symbol] (null and undefined are immutable\r\n * but are not \"usable\" (usually not what we want to operate on).\r\n * @function module:object.isUsableImmutablePrimitive\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isUsableImmutablePrimitive = x => {\r\n const typeOfX = typeOf(x);\r\n return isset(x) &&\r\n [_String, _Number, _Boolean, _Symbol]\r\n .some(Type => Type === typeOfX);\r\n },\r\n\r\n /**\r\n * Checks if !length.\r\n * @function module:object.isEmptyList\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isEmptyList = x => !length(x),\r\n\r\n /**\r\n * Checks if object has own properties/enumerable-props or not.\r\n * @function module:object.isEmptyObject\r\n * @param obj {*}\r\n * @returns {Boolean}\r\n */\r\n isEmptyObject = obj => isEmptyList(keys(obj)),\r\n\r\n /**\r\n * Checks if collection is empty or not (Map, WeakMap, WeakSet, Set etc.).\r\n * @function module:object.isEmptyCollection\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isEmptyCollection = x => x.size === 0,\r\n\r\n /**\r\n * Checks to see if passed in value is empty; I.e.,\r\n * check for one of '', 0, `null`, `undefined`, `false`, empty array, empty object, empty function (zero arity),\r\n * or empty collection (es6 Map, Set, WeakMap, or WeakSet etc. (`!value.size`);\r\n * @function module:object.isEmpty\r\n * @param value {*} - Value to check.\r\n * @returns {Boolean}\r\n */\r\n isEmpty = value => {\r\n if (!value) { // if '', 0, `null`, `undefined`, or `false` then is empty\r\n return true;\r\n }\r\n switch (typeOf(value)) {\r\n case _Array:\r\n case _Function:\r\n return !value.length;\r\n case _Number: // zero and NaN checks happened above so `if number` then it's 'not-an-empty-number' (lol)\r\n return false;\r\n case _Object:\r\n return !keys(value).length;\r\n case _Map:\r\n case _Set:\r\n case _WeakSet:\r\n case _WeakMap:\r\n return !value.size;\r\n case _NaN:\r\n return true;\r\n default:\r\n return !value;\r\n }\r\n },\r\n\r\n /**\r\n * Returns whether passed in values is defined and not null or not.\r\n * @function module:object.isset\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isset = x => x !== null && x !== undefined,\r\n\r\n /**\r\n * Checks to see if `x` is of one of the given type refs.\r\n * @function object.isOneOf\r\n * @param x {*}\r\n * @param types {...(TypeRef|*)}\r\n * @returns {boolean}\r\n * @todo write tests for this function.\r\n */\r\n isOneOf = (x, ...types) => {\r\n const typeName = typeOf(x);\r\n return toTypeRefNames(types).some(name => typeName === name);\r\n },\r\n\r\n isFunctor = x => x && x.map && instanceOf(Function, x.map)\r\n\r\n;\r\n","/**\r\n * @memberOf object\r\n */\r\n\r\nimport {isset} from './is';\r\nimport {curry} from '../function/curry';\r\n\r\n/**\r\n * Looks up property and returns it's value; Else `undefined`.\r\n * Method is null safe (will not throw on `null` or `undefined`).\r\n * @function module:object.lookup\r\n * @param key {String} - Key to search on `obj`\r\n * @param obj {Object} - Object to search `name` on.\r\n * @returns {*}\r\n */\r\nexport const lookup = curry((key, obj) => isset(obj) ? obj[key] : undefined);\r\n","import {isFunction, isset, isUsableImmutablePrimitive} from './is';\r\nimport {apply} from '../jsPlatform/function';\r\n\r\n/**\r\n * Creates a value `of` given type; Checks for one of the following construction strategies (in order listed):\r\n * @example\r\n * // - If exists `(value).constructor.of` uses this.\r\n * // - If value is of one String, Boolean, Symbol, or Number types calls it's\r\n * // constructor as a function (in cast form; E.g., `constructor(...args)` )\r\n * // - Else if constructor is a function, thus far, then calls constructor using\r\n * // the `new` keyword (with any passed in args).\r\n\r\n * @function module:object.of\r\n * @param x {*} - Value to derive returned value's type from.\r\n * @param [args] {...*} - Any args to pass in to matched construction strategy.\r\n * @returns {*|undefined} - New value of given value's type else `undefined`.\r\n */\r\nexport const of = (x, ...args) => {\r\n if (!isset(x)) { return undefined; }\r\n const constructor = x.constructor;\r\n if (constructor.hasOwnProperty('of')) {\r\n return apply(constructor.of, args);\r\n }\r\n else if (isUsableImmutablePrimitive(x)) {\r\n return apply(constructor, args);\r\n }\r\n else if (isFunction(constructor)) {\r\n return new constructor(...args);\r\n }\r\n return undefined;\r\n};\r\n","import {typeOf} from './typeOf';\r\nimport {of} from './of';\r\n\r\nexport const\r\n\r\n /**\r\n * Make a copy of a value or optionally copy incoming value onto an outgoing value (second parameter).\r\n * @note If incoming thing is an immmutable primitive (string, number, symbol, null, undefined, boolean)\r\n * it is returned as is.\r\n * @function module:object.copy\r\n * @param x {*} - Thing to copy.\r\n * @param [out = undefined] {*} - Optional value to copy on to. Not required.\r\n * @returns {*} - Copied thing or optionally outgoing value copied onto.\r\n */\r\n copy = (x, out) => {\r\n // if `null`, `undefined`, `''`, `0`, `false` return\r\n if (!x) { return x; }\r\n switch (typeOf(x)) {\r\n case Array.name:\r\n return !out ? x.slice(0) : Object.assign(out, x);\r\n\r\n // If immutable primitive, return it\r\n case Symbol.name:\r\n case Boolean.name:\r\n case String.name:\r\n case Number.name:\r\n case Promise.name:\r\n case Function.name:\r\n case 'NaN':\r\n case 'Null':\r\n case 'Undefined':\r\n return x;\r\n\r\n case 'Map':\r\n case 'Set':\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n return new x.constructor(Array.from(x));\r\n\r\n // Else make copy\r\n default:\r\n return Object.assign(!out ? of(x) : out, x);\r\n }\r\n }\r\n;\r\n\r\nexport default copy;\r\n","import {isset} from './is';\r\nimport {curry} from '../function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Gives you value at key/namespace-key within `obj`; E.g.,\r\n * searchObj('all.your.base', {all: {your: {base: 99}}}) === 99 // `true`\r\n * @note If key is unreachable (undefined) returns `undefined`.\r\n * Useful in cases where we do not want to check each key along the way before getting/checking value; E.g.,\r\n * @example\r\n * ```\r\n * if (obj && obj.all && obj.all.your && obj.all.your.base) {\r\n * // Thing we want to do\r\n * }\r\n *\r\n * // So with our function becomes\r\n * if (searchObj('all.your.base', obj)) {\r\n * // Thing we want to do\r\n * }\r\n * ```\r\n * @function module:object.searchObj\r\n * @param nsString {String}\r\n * @param obj {*}\r\n * @returns {*}\r\n */\r\n searchObj = curry((nsString, obj) => {\r\n if (!obj) { return obj; }\r\n if (nsString.indexOf('.') === -1) {\r\n return obj[nsString];\r\n }\r\n const parts = nsString.split('.'),\r\n limit = parts.length;\r\n let ind = 0,\r\n parent = obj;\r\n for (; ind < limit; ind += 1) {\r\n const node = parent[parts[ind]];\r\n if (!isset(node)) {\r\n return node;\r\n }\r\n parent = node;\r\n }\r\n return parent;\r\n })\r\n;\r\n","\r\nimport {isObject} from './is';\r\nimport {keys} from '../jsPlatform/object';\r\nimport {curry2} from '../function/curry';\r\n\r\nexport const\r\n /**\r\n * Merges all objects down into one (takes two or more args).\r\n * @function module:object.assignDeep\r\n * @param obj0 {Object}\r\n * @param [objs] {...{Object}} - One or more objects to merge onto `obj0`.\r\n * @returns {Object}\r\n */\r\n assignDeep = curry2((obj0, ...objs) =>\r\n !obj0 ? obj0 : objs.reduce((topAgg, obj) =>\r\n !obj ? topAgg : keys(obj).reduce((agg, key) => {\r\n let propDescription = Object.getOwnPropertyDescriptor(agg, key);\r\n // If property is not writable move to next item in collection\r\n if (agg.hasOwnProperty(key) && propDescription &&\r\n !(propDescription.get && propDescription.set) &&\r\n !propDescription.writable) {\r\n return agg;\r\n }\r\n if (isObject(agg[key]) && isObject(obj[key])) {\r\n assignDeep(agg[key], obj[key]);\r\n }\r\n else { agg[key] = obj[key]; }\r\n return agg;\r\n }, topAgg)\r\n , obj0));\r\n","/**\r\n * List operations that overlap (apart from globally overlapping props and functions like `length`)\r\n * on both strings and arrays.\r\n * @memberOf list\r\n */\r\n\r\nimport {fPureTakesOne, fPureTakes2, fPureTakesOneOrMore} from '../utils';\r\n\r\nexport const\r\n\r\n /**\r\n * Concats/appends all functors onto the end of first functor.\r\n * Note: functors passed in after the first one must be of the same type.\r\n * @function module:list.concat\r\n * @param functor {Array|Object|*}\r\n * @param ...functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type passed.\r\n * @throws {Error} - When passed in object doesn't have an `every` method.\r\n */\r\n concat = fPureTakesOneOrMore('concat'),\r\n\r\n /**\r\n * Same as Array.prototype.slice\r\n * @function module:list.slice\r\n * @param separator {String|RegExp}\r\n * @param arr{Array}\r\n * @returns {Array}\r\n */\r\n slice = fPureTakes2('slice'),\r\n\r\n /**\r\n * `Array.prototype.includes` or shim.\r\n * @function module:list.includes\r\n * @param value {*}\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n includes = (() => 'includes' in Array.prototype ?\r\n fPureTakesOne('includes') :\r\n (value, xs) => xs.indexOf(value) > -1)(),\r\n\r\n /**\r\n * Searches list/list-like for given element `x`.\r\n * @function module:list.indexOf\r\n * @param x {*} - Element to search for.\r\n * @param xs {Array|String|*} - list or list like to look in.\r\n * @returns {Number} - `-1` if element not found else index at which it is found.\r\n */\r\n indexOf = fPureTakesOne('indexOf'),\r\n\r\n /**\r\n * Last index of (`Array.prototype.lastIndexOf`).\r\n * @function module:list.lastIndexOf\r\n * @param x {*} - Element to search for.\r\n * @param xs {Array|String|*} - list or list like to look in.\r\n * @returns {Number} - `-1` if element not found else index at which it is found.\r\n */\r\n lastIndexOf = fPureTakesOne('lastIndexOf')\r\n\r\n;\r\n","/**\r\n * @module boolean\r\n * @description Contains functional version of 'always-true', 'always-false', 'is-truthy', and 'is-falsy'.\r\n */\r\nimport {curry, curry2} from './function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns whether `value` is 'truthy' or not\r\n * @function module:boolean.isTruthy\r\n * @param value\r\n * @returns {Boolean}\r\n */\r\n isTruthy = value => !!value,\r\n\r\n /**\r\n * Returns whether `value` is 'falsy' or not\r\n * @function module:boolean.isFalsy\r\n * @param value\r\n * @returns {Boolean}\r\n */\r\n isFalsy = value => !value,\r\n\r\n /**\r\n * Returns `true`.\r\n * @function module:boolean.alwaysTrue\r\n * @returns {Boolean}\r\n */\r\n alwaysTrue = () => true,\r\n\r\n /**\r\n * Returns `false`.\r\n * @function module:boolean.alwaysFalse\r\n * @returns {Boolean}\r\n */\r\n alwaysFalse = () => false,\r\n\r\n /**\r\n * Equality operator.\r\n * @function module:boolean.equal\r\n * @param a {*}\r\n * @param b {*}\r\n * @returns {boolean}\r\n */\r\n equal = curry((a, b) => a === b),\r\n\r\n /**\r\n * Equality operator for all.\r\n * @function module:boolean.equalAll\r\n * @param a {*} - Item `0`.\r\n * @param args {...*} - Others\r\n * @returns {boolean}\r\n */\r\n equalAll = curry2((a, ...args) => args.every(b => equal(a, b)))\r\n\r\n;\r\n","import {length} from '../jsPlatform/object';\r\nimport {curry} from '../function/curry';\r\nimport {typeOf} from '../object/typeOf';\r\nimport {of} from '../object/of';\r\nimport {isFunctor, isset} from '../object/is';\r\n\r\n/**\r\n * Maps a function onto a List (string or array) or a functor (value containing a map method).\r\n * @function module:list.map\r\n * @param fn {Function} - Function to map on given value.\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\nconst map = curry((fn, xs) => {\r\n if (!isset(xs)) { return xs; }\r\n let out = of(xs),\r\n limit,\r\n i = 0;\r\n switch (typeOf(xs)) {\r\n case 'Array':\r\n limit = length(xs);\r\n if (!limit) { return out; }\r\n for (; i < limit; i += 1) {\r\n out.push(fn(xs[i], i, xs));\r\n }\r\n return out;\r\n case 'String':\r\n limit = length(xs);\r\n if (!xs) { return out; }\r\n for (; i < limit; i += 1) {\r\n out += fn(xs[i], i, xs);\r\n }\r\n return out;\r\n default:\r\n if (isFunctor(xs)) { return xs.map(fn); }\r\n\r\n // Other objects\r\n return Object.keys(xs).reduce((agg, key) => {\r\n out[key] = fn(xs[key], key, xs);\r\n return out;\r\n }, out);\r\n }\r\n});\r\n\r\nexport default map;\r\n","\r\nexport const\r\n\r\n /**\r\n * Pushes incoming `item` onto given array and returns said array.\r\n * @private\r\n * @param agg {Array}\r\n * @param item {*}\r\n * @returns {Array}\r\n */\r\n aggregateArray = (agg, item) => {\r\n agg.push(item);\r\n return agg;\r\n }\r\n\r\n;\r\n","/**\r\n * List operator utils module.\r\n * @module listUtils\r\n */\r\nimport {apply} from '../jsPlatform/function'; // un-curried version\r\nimport {slice} from '../jsPlatform/list'; // un-curried version good for both strings and arrays\r\nimport {length} from '../jsPlatform/object';\r\nimport {alwaysFalse} from '../boolean';\r\nimport map from './map';\r\nimport {curry, curry2} from '../function/curry';\r\n\r\nexport * from './aggregation';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a slice of the given list from `startInd` to the end of the list.\r\n * @function module:listUtils.sliceFrom\r\n * @param startInd {Number}\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sliceFrom = curry((startInd, xs) => slice(startInd, undefined, xs)),\r\n\r\n /**\r\n * Slices from index `0` to given index.\r\n * @function module:listUtils.sliceTo\r\n * @param toInd {Number}\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sliceTo = curry((toInd, xs) => slice(0, toInd, xs)),\r\n\r\n /**\r\n * Slices a copy of list.\r\n * @function listUtils.sliceCopy\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sliceCopy = sliceFrom(0),\r\n\r\n /**\r\n * Generic 'ascending order' ordering function (use by the likes of `list.sort` etc.)\r\n * @function module:listUtils.genericAscOrdering\r\n * @param a {*}\r\n * @param b {*}\r\n * @returns {number}\r\n */\r\n genericAscOrdering = curry((a, b) => {\r\n if (a > b) { return 1; }\r\n else if (a < b) { return -1; }\r\n return 0;\r\n }),\r\n\r\n /**\r\n * Returns length of all passed lists in list.\r\n * @function module:listUtils.lengths\r\n * @param lists ...{Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n lengths = curry2((...lists) => map(length, lists)),\r\n\r\n /**\r\n * Returns a list of lists trimmed to the shortest length in given list of lists. @background This method is used by the `zip*` functions to achieve their\r\n * 'slice to smallest' functionality.\r\n * @function module:listUtils.toShortest\r\n * @param lists {...(Array|String|*)}\r\n * @returns {Array|String|*}\r\n */\r\n toShortest = curry2((...lists) => {\r\n const listLengths = apply(lengths, lists),\r\n smallLen = Math.min.apply(Math, listLengths);\r\n return map((list, ind) => listLengths[ind] > smallLen ?\r\n sliceTo(smallLen, list) : sliceCopy(list), lists);\r\n }),\r\n\r\n /**\r\n * Reduces until predicate.\r\n * @function module:listUtils.reduceUntil\r\n * @param pred {Function} - `(item, index, list) => Boolean(...)`\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduceUntil = curry((pred, op, agg, xs) => {\r\n const limit = length(xs);\r\n if (!limit) { return agg; }\r\n let ind = 0,\r\n result = agg;\r\n for (; ind < limit; ind++) {\r\n if (pred(xs[ind], ind, xs)) { break; }\r\n result = op(result, xs[ind], ind, xs);\r\n }\r\n return result;\r\n }),\r\n\r\n /**\r\n * Reduces until predicate (from right to left).\r\n * @function module:listUtils.reduceUntilRight\r\n * @param pred {Function} - `(item, index, list) => Boolean(...)`\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduceUntilRight = curry((pred, op, agg, arr) => {\r\n const limit = length(arr);\r\n if (!limit) { return agg; }\r\n let ind = limit - 1,\r\n result = agg;\r\n for (; ind >= 0; ind--) {\r\n if (pred(arr[ind], ind, arr)) { break; }\r\n result = op(result, arr[ind], ind, arr);\r\n }\r\n return result;\r\n }),\r\n\r\n /**\r\n * Reduces a list with given operation (`op`) function.\r\n * @function module:listUtils.reduce\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduce = reduceUntil(alwaysFalse),\r\n\r\n /**\r\n * Reduces a list with given operation (`op`) function (from right-to-left).\r\n * @function module:listUtils.reduceRight\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduceRight = reduceUntilRight(alwaysFalse),\r\n\r\n /**\r\n * Gets last index of a list/list-like (Array|String|Function etc.).\r\n * @function module:listUtils.lastIndex\r\n * @param x {Array|String|*} - list like or list.\r\n * @returns {Number} - `-1` if no element found.\r\n */\r\n lastIndex = x => { const len = length(x); return len ? len - 1 : 0; },\r\n\r\n /**\r\n * Finds index in string or list.\r\n * @function module:listUtils.findIndexWhere\r\n * @param pred {Function} - Predicate.\r\n * @param arr {Array|String}\r\n * @returns {Number} - `-1` if predicate not matched else `index` found\r\n */\r\n findIndexWhere = curry((pred, arr) => {\r\n let ind = 0;\r\n const limit = length(arr);\r\n for (; ind < limit; ind += 1) {\r\n const predicateFulfilled = !!pred(arr[ind], ind, arr);\r\n if (predicateFulfilled) {\r\n return ind;\r\n }\r\n }\r\n return -1;\r\n }),\r\n\r\n /**\r\n * Finds index in list from right to left.\r\n * @function module:listUtils.findIndexWhereRight\r\n * @param pred {Function} - Predicate.\r\n * @param arr {Array|String}\r\n * @returns {Number} - `-1` if predicate not matched else `index` found\r\n */\r\n findIndexWhereRight = curry((pred, arr) => {\r\n let ind = length(arr) - 1;\r\n for (; ind >= 0; ind -= 1) {\r\n const predicateFulfilled = !!pred(arr[ind], ind, arr);\r\n if (predicateFulfilled) {\r\n return ind;\r\n }\r\n }\r\n return -1;\r\n }),\r\n\r\n /**\r\n * @function module:listUtils.findIndicesWhere\r\n * @param pred {Function}\r\n * @param xs {Array|String|*} - list or list like.\r\n * @returns {Array|undefined}\r\n */\r\n findIndicesWhere = curry((pred, xs) => {\r\n const limit = length(xs);\r\n let ind = 0,\r\n out = [];\r\n for (; ind < limit; ind++) {\r\n if (pred(xs[ind], ind, xs)) { out.push(ind); }\r\n }\r\n return out.length ? out : undefined;\r\n }),\r\n\r\n /**\r\n * @function module:listUtils.findWhere\r\n * @param pred {Function}\r\n * @param xs {Array|String|*} - list or list like.\r\n * @returns {*}\r\n */\r\n findWhere = curry((pred, xs) => {\r\n let ind = 0,\r\n limit = length(xs);\r\n if (!limit) { return; }\r\n for (; ind < limit; ind++) {\r\n let elm = xs[ind];\r\n if (pred(elm, ind, xs)) { return elm; }\r\n }\r\n })\r\n\r\n;\r\n","import {assignDeep} from './assignDeep';\r\nimport {keys} from '../jsPlatform/object';\r\nimport {reduce} from '../list/utils';\r\nimport {curry, curry2} from '../function/curry';\r\n\r\nexport const\r\n\r\n objUnion = curry((obj1, obj2) => assignDeep(obj1, obj2)),\r\n\r\n objIntersect = curry((obj1, obj2) => reduce((agg, key) => {\r\n if (obj2.hasOwnProperty(key)) {\r\n agg[key] = obj2[key];\r\n }\r\n return agg;\r\n }, {}, keys(obj1))),\r\n\r\n objDifference = curry((obj1, obj2) => reduce((agg, key) => {\r\n if (!obj2.hasOwnProperty(key)) {\r\n agg[key] = obj1[key];\r\n }\r\n return agg;\r\n }, {}, keys(obj1))),\r\n\r\n objComplement = curry2((obj0, ...objs) => reduce((agg, obj) =>\r\n assignDeep(agg, objDifference(obj, obj0)), {}, objs));\r\n","/**\r\n * @module console\r\n * @description Console exports.\r\n */\r\nexport const\r\n\r\n /**\r\n * `Console.log` method.\r\n * @function module:console.log\r\n * @params args {...*}\r\n * @returns {void}\r\n */\r\n log = console.log.bind(console),\r\n\r\n /**\r\n * `Console.error` method.\r\n * @function module:console.error\r\n * @params args {...*}\r\n * @returns {void}\r\n */\r\n error = console.error.bind(console),\r\n\r\n /**\r\n * Peeks (console.log) at incoming value(s) and returns the last value.\r\n * @function module:console.peek\r\n * @param args {...*}\r\n * @returns {*} Last given value (if one or more values) else first value.\r\n */\r\n peek = (...args) => (log(...args), args.pop())\r\n\r\n;\r\n","export const\r\n\r\n /**\r\n * Clones and object or array using `JSON.parse(JSON.stringify(...))` pattern.\r\n * @function module:object.jsonClone\r\n * @param x {*}\r\n * @returns {*}\r\n */\r\n jsonClone = x => JSON.parse(JSON.stringify(x))\r\n\r\n;\r\n","import {isArray, isType} from './is';\r\nimport {keys} from '../jsPlatform/object';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns an associated list from given object.\r\n * @note Useful for working with plain javascript objects.\r\n * @function module:object.toAssocList\r\n * @param obj {(Object|Array|*)}\r\n * @returns {Array.<*, *>}\r\n */\r\n toAssocList = obj => keys(obj).map(key => [key, obj[key]]),\r\n\r\n /**\r\n * Returns an associated list from given object (deeply (on incoming object's type)).\r\n * @note Does deep conversion on all values of passed in type's type.\r\n * @function module:object.toAssocListDeep\r\n * @param obj {*}\r\n * @param [TypeConstraint = Object] {(Constructor|Function)} - Type constraint to convert on.\r\n * @returns {*}\r\n */\r\n toAssocListDeep = (obj, TypeConstraint = Object) => keys(obj).map(key =>\r\n TypeConstraint && isType(TypeConstraint, obj[key]) ?\r\n [key, toAssocListDeep(obj[key], TypeConstraint)] :\r\n [key, obj[key]]\r\n ),\r\n\r\n /**\r\n * From associated list to object.\r\n * @function module:object.fromAssocList\r\n * @param xs {Array.} - Associated list.\r\n * @param [OutType = Object] {Constructor|Function} - Output type. Default `Object`.\r\n * @returns {*} - Default is `Object`\r\n */\r\n fromAssocList = (xs, OutType = Object) => xs.reduce((agg, [key, value]) => {\r\n agg[key] = value;\r\n return agg;\r\n }, new OutType()),\r\n\r\n /**\r\n * From associated list to object (deep conversion on associative lists (array of 2 value arrays)).\r\n * @note Considers array of arrays associated lists.\r\n * @function module:object.fromAssocListDeep\r\n * @param xs {Array.} - Associated list.\r\n * @param [OutType = Object] {Constructor|Function} - Output type. Default `Object`.\r\n * @returns {*} - Default is `Object`\r\n */\r\n fromAssocListDeep = (xs, OutType = Object) => xs.reduce((agg, [key, value]) => {\r\n if (isArray(value) && isArray(value[0]) && value[0].length === 2) {\r\n agg[key] = fromAssocListDeep(value, OutType);\r\n return agg;\r\n }\r\n agg[key] = value;\r\n return agg;\r\n }, new OutType())\r\n;\r\n","import {typeOf} from './typeOf';\r\nimport {toAssocList} from './assocList';\r\n\r\nexport const\r\n\r\n /**\r\n * Converts incoming value to an array.\r\n * @note For `WeakMap`, `WeakSet`, `Map` and `Set` result is the same as calling `Array.from` on such.\r\n * @note For `null`, `undefined`, `NaN`, `Number{}`, `Symbol{}`, `Boolean{}` returns an empty array.\r\n * @note Method does a shallow conversion;\r\n * @function module:object.toArray\r\n * @param x {*} - Thing to convert from.\r\n * @returns {Array}\r\n */\r\n toArray = x => {\r\n switch (typeOf(x)) {\r\n case 'Null':\r\n case 'Undefined':\r\n return [];\r\n case String.name:\r\n case Array.name:\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n case 'Map':\r\n case 'Set':\r\n return Array.from(x);\r\n case Object.name:\r\n default:\r\n return toAssocList(x);\r\n }\r\n }\r\n\r\n;\r\n","/**\r\n * @module object\r\n * @description Object operations/combinators.\r\n */\r\n\r\nexport * from './jsPlatform/object';\r\nexport * from './object/lookup';\r\nexport * from './object/typeOf';\r\nexport * from './object/copy';\r\nexport * from './object/is';\r\nexport * from './object/of';\r\nexport * from './object/searchObj';\r\nexport * from './object/assignDeep';\r\nexport * from './object/setTheory';\r\nexport * from './object/console';\r\nexport * from './object/jsonClone';\r\nexport * from './object/toArray';\r\nexport * from './object/assocList';\r\n","import {reduceRight} from '../jsPlatform/array';\r\n\r\n/**\r\n * Composes all functions passed in from right to left passing each functions return value to\r\n * the function on the left of itself.\r\n * @function module:function.compose\r\n * @type {Function}\r\n * @param args {...{Function}}\r\n * @returns {Function}\r\n */\r\nexport const compose = (...args) =>\r\n arg0 => reduceRight((value, fn) => fn(value), arg0, args);\r\n","/**\r\n * @memberOf function\r\n */\r\n\r\n/**\r\n * Returns passed in parameter.\r\n * @haskellType `id :: a -> a`\r\n * @function module:function.id\r\n * @param x {*}\r\n * @returns {*}\r\n */\r\nexport const id = x => x;\r\n","/**\r\n * @memberOf function\r\n */\r\n\r\nimport {apply} from '../jsPlatform/function';\r\nimport {curry, curry2} from './curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Negates a function that takes one/no argument.\r\n * @function module:function.negateF\r\n * @param fn {Function}\r\n * @returns {function(*=): boolean}\r\n */\r\n negateF = fn => x => !fn(x),\r\n\r\n /**\r\n * Takes a function that takes two parameters and returns a negated version of given\r\n * function.\r\n * @function module:_negate.negateF2\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n negateF2 = fn => curry((a, b) => !fn(a, b)),\r\n\r\n /**\r\n * Takes a function that takes three parameters and returns a\r\n * negated version of given function.\r\n * @function module:_negate.negateF3\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n negateF3 = fn => curry((a, b, c) => !fn(a, b, c)),\r\n\r\n /**\r\n * Returns a negated version of given function.\r\n * Returned function is variadiac (takes one or more arguments).\r\n * @note function returned is uncurried.\r\n * @uncurried\r\n * @function module:function.negateFN\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n negateFN = fn => curry2((...args) => !apply(fn, args));\r\n","import {curry} from './curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Run `operation` until predicate returns `true` (like a functional\r\n * version of a while loop).\r\n * @function module:function.until\r\n * @param predicate {Function} :: a -> Boolean\r\n * @param operation {Function} :: a -> a\r\n * @param typeInstance {*} :: * - A monoidal zero or some starting point.\r\n * @returns {*} - What ever type `typeInstance` is\r\n */\r\n until = curry((predicate, operation, typeInstance) => {\r\n let result = typeInstance;\r\n while (!predicate(result)) {\r\n result = operation(result);\r\n }\r\n return result;\r\n });\r\n","import {typeOf} from '../object/typeOf';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a function or throws an error if given `f` is not a function.\r\n * @function module:function.fnOrError\r\n * @param symbolName {String} - Error message prefix.\r\n * @param f {Function|*} - Expected function.\r\n * @returns {Function}\r\n * @throws {Error} - Error if `f` is not of `function`\r\n */\r\n fnOrError = (symbolName, f) => {\r\n if (!f || !(f instanceof Function)) {\r\n throw new Error(`${symbolName} should be a function. ` +\r\n `Type received: ${typeOf(f)}; Value received: ${f}.`);\r\n }\r\n return f;\r\n }\r\n\r\n;\r\n","/**\r\n * No-op ('op' as in 'operation') - Performs no operation 'always' (good for places where\r\n * a value should always be a function etc.).\r\n * @function module:function.noop\r\n * @returns {undefined}\r\n */\r\nexport const noop = () => undefined;\r\n","/**\r\n * @module function\r\n */\r\nexport * from './jsPlatform/function';\r\nexport * from './function/compose';\r\nexport * from './function/curry';\r\nexport * from './function/flip';\r\nexport * from './function/id';\r\nexport * from './function/negate';\r\nexport * from './function/until';\r\nexport * from './function/fnOrError';\r\nexport * from './function/noop';\r\n","/**\r\n * @module object\r\n */\r\nimport {curry} from '../function/curry';\r\n\r\n/**\r\n * Normalizes step for `from` and `to` combination.\r\n * @function module:list.normalizeStep\r\n * @param from {Number}\r\n * @param to {Number}\r\n * @param [step = 1] {Number}\r\n * @returns {Number}\r\n * @private\r\n */\r\nconst normalizeStep = (from, to, step) => {\r\n if (from > to) {\r\n return step > 0 ? -step : step; // make step negative\r\n }\r\n return step < 0 ? -1 * step : step; // make step positive\r\n};\r\n\r\nexport const\r\n\r\n /**\r\n * Range function - gives you an array contain numbers in given range.\r\n * @note normalizes `step` to be valid if range numbers given are invalid\r\n * (forces `step` to be negative if range required is in the negative direction\r\n * and forces `step` to be positive if range required is in the other direction).\r\n * @function module:list.range\r\n * @param from {Number}\r\n * @param to {Number}\r\n * @param [step = 1] {Number}\r\n * @returns {Array.}\r\n */\r\n range = curry((from, to, step = 1) => {\r\n let i = from;\r\n const out = [];\r\n step = normalizeStep(from, to, step);\r\n if (step === 0 || from === to) { return [from]; }\r\n for (; (to - i) * step >= 0; i += step) { out.push(i); }\r\n return out;\r\n })\r\n;\r\n","/**\r\n * Created by elydelacruz on 9/6/2017.\r\n */\r\n\r\nimport {fPureTakesOne} from '../utils';\r\n\r\n/**\r\n * Functional version of `String.prototype.split`.\r\n * @function module:_string.split\r\n * @param separator {String|RegExp}\r\n * @param str {String}\r\n * @returns {Array}\r\n */\r\nexport const split = fPureTakesOne('split');\r\n","/**\r\n * @module jsPlatform_\r\n * @private\r\n */\r\nexport * from './jsPlatform/object';\r\nexport * from './jsPlatform/array';\r\nexport * from './jsPlatform/list';\r\nexport * from './jsPlatform/string';\r\nexport * from './jsPlatform/function';\r\n","/**\r\n * List operations module.\r\n * @module list\r\n */\r\nimport {concat as listAppend, indexOf, slice, includes} from './jsPlatform/list';\r\nimport {apply} from './jsPlatform/function';\r\nimport {length} from './jsPlatform/object';\r\nimport {negateF3, negateF2} from './function/negate';\r\nimport {curry, curry2, curry3} from './function/curry';\r\nimport {isTruthy, isFalsy} from './boolean';\r\nimport {lookup} from './object/lookup';\r\nimport {of} from './object/of';\r\nimport {isset, isString} from './object/is';\r\nimport {typeOf} from './object/typeOf';\r\nimport map from './list/map';\r\n\r\nimport {\r\n sliceFrom, sliceTo, lengths,\r\n toShortest, aggregateArray,\r\n reduceUntil, reduce, reduceRight, lastIndex,\r\n findIndexWhere, findIndexWhereRight, findIndicesWhere,\r\n findWhere, sliceCopy, genericAscOrdering\r\n}\r\n from './list/utils';\r\n\r\nexport * from './list/range';\r\n\r\nexport * from './list/utils';\r\n\r\nexport {map};\r\n\r\nexport {slice, includes, indexOf, lastIndexOf, push} from './jsPlatform';\r\n\r\nexport const\r\n\r\n /**\r\n * Append two, or more, lists, i.e.,\r\n * @example\r\n * expectEqual(append(take(13, alphabetString), drop(13, alphabetString)), alphabetString); // true\r\n *\r\n * // Another example\r\n * const result = append(\r\n * alphabetStr.split(''),\r\n * alphabetStr.split('')\r\n * ),\r\n * expected = repeat(2, alphabetStr).split('');\r\n *\r\n * shallowEquals(result, expected) === true // `true`\r\n *\r\n * @function module:list.append\r\n * @param [args] {...(Array|String|*)} - One or more lists or list likes (strings etc.).\r\n * @returns {(Array|String|*)} - Same type as list like passed in.\r\n */\r\n append = curry2((...args) => apply(listAppend, args)),\r\n\r\n /**\r\n * Returns head of list (first item of list).\r\n * @haskellType `head :: [a] -> a`\r\n * @function module:list.head\r\n * @param x {Array|String}\r\n * @returns {*} - First item from list\r\n */\r\n head = x => x[0],\r\n\r\n /**\r\n * Returns last item of list.\r\n * @haskellType `last :: [a] -> a`\r\n * @function module:list.last\r\n * @param xs {Array|String}\r\n * @returns {*}\r\n */\r\n last = xs => xs[lastIndex(xs)],\r\n\r\n /**\r\n * Returns tail part of list (everything after the first item as new list).\r\n * @haskelType `tail :: [a] -> [a]`\r\n * @function module:list.tail\r\n * @param xs {Array|String}\r\n * @returns {Array|String}\r\n */\r\n tail = xs => sliceFrom(1, xs),\r\n\r\n /**\r\n * Returns everything except last item of list as new list.\r\n * @haskellType `init :: [a] -> [a]`\r\n * @function module:list.init\r\n * @param xs {Array|String}\r\n * @returns {Array|String}\r\n */\r\n init = xs => sliceTo(lastIndex(xs), xs),\r\n\r\n /**\r\n * Returns `head` and `tail` of passed in list/string in a tuple.\r\n * @haskellType `uncons :: [a] -> Maybe (a, [a])`\r\n * @function module:list.uncons\r\n * @param xs {Array|String}\r\n * @returns {Array|undefined}\r\n */\r\n uncons = xs => !xs || length(xs) === 0 ? undefined : [head(xs), tail(xs)],\r\n\r\n /**\r\n * Returns `tail` and `head` of passed in list/string in a tuple.\r\n * @haskellType `unconsr :: [a] -> Maybe ([a], a)`\r\n * @function module:list.unconsr\r\n * @param xs {Array|String}\r\n * @returns {Array|String|*|undefined}\r\n */\r\n unconsr = xs => !xs || length(xs) === 0 ? undefined : [init(xs), last(xs)],\r\n\r\n /**\r\n * Concatenates all the elements of a container of lists.\r\n * @haskellType `concat :: Foldable t => t [a] -> [a]`\r\n * @function module:list.concat\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n concat = xs => {\r\n switch (length(xs)) {\r\n case undefined:\r\n case 0:\r\n return [];\r\n case 1:\r\n const item0 = xs[0];\r\n return item0 && item0.slice ? sliceCopy(item0) : item0;\r\n case 2:\r\n default:\r\n return apply(append, xs);\r\n }\r\n },\r\n\r\n /**\r\n * Map a function over all the elements of a container and concatenate the resulting lists.\r\n * @haskellType `concatMap :: Foldable t => (a -> [b]) -> t a -> [b]`\r\n * @function module:list.concatMap\r\n * @param fn {Function}\r\n * @param foldableOfA {Array}\r\n * @returns {Array}\r\n */\r\n concatMap = curry((fn, foldableOfA) => concat(map(fn, foldableOfA))),\r\n\r\n /**\r\n * Returns a copy of the passed in list reverses.\r\n * @haskellType `reverse :: [a] -> [a]`\r\n * @function module:list.reverse\r\n * @param xs {Array|String}\r\n * @returns {Array|String}\r\n */\r\n reverse = xs => {\r\n if (!isset(xs) || !xs.length) {\r\n return xs;\r\n }\r\n let out = of(xs),\r\n i = xs.length - 1;\r\n switch (typeOf(xs)) {\r\n case 'String':\r\n for (; i >= 0; i -= 1) {\r\n out += xs[i];\r\n }\r\n return out;\r\n default:\r\n for (; i >= 0; i -= 1) {\r\n out.push(xs[i]);\r\n }\r\n return out;\r\n }\r\n },\r\n\r\n /**\r\n * Takes an element and a list and `intersperses' that element between the\r\n * elements of the list.\r\n * @function module:list.intersperse\r\n * @note In our version of the function javascript is loosely typed so,\r\n * so is our function (to much overhead to make it typed) so `between` can be any value.\r\n * @param between {*} - Should be of the same type of elements contained in list.\r\n * @param arr {Array|String} - List.\r\n * @returns {Array|String}\r\n */\r\n intersperse = curry((between, xs) => {\r\n if (!xs || !xs.length) {\r\n return xs;\r\n }\r\n const limit = xs.length,\r\n lastInd = limit - 1;\r\n let out = of(xs),\r\n i = 0;\r\n if (isString(xs)) {\r\n for (; i < limit; i += 1) {\r\n out += i === lastInd ?\r\n xs[i] : xs[i] + between;\r\n }\r\n return out;\r\n }\r\n for (; i < limit; i += 1) {\r\n if (i === lastInd) {\r\n out.push(xs[i]);\r\n } else {\r\n out.push(xs[i], between);\r\n }\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * `intercalate xs xss` is equivalent to (concat (intersperse xs xss)). It inserts the list xs in between the lists in xss and concatenates the result.\r\n * @haskellType `intercalate :: [a] -> [[a]] -> [a]`\r\n * @function module:list.intercalate\r\n * @param xs {Array|String}\r\n * @param xss {Array|String}\r\n * @returns {Array|String}\r\n */\r\n intercalate = curry((xs, xss) => {\r\n if (isString(xss)) {\r\n return intersperse(xs, xss);\r\n }\r\n return concat(intersperse(xs, xss));\r\n }),\r\n\r\n /**\r\n * Transposes rows and columns into lists by index; E.g.,\r\n * Haskell example:\r\n * ```\r\n * transpose [[1,2,3],[4,5,6]] == [[1,4],[2,5],[3,6]]\r\n *\r\n * -- Notice the shorter arrays are ignored after their last index is copied over:\r\n * transpose [[10,11],[20],[],[30,31,32]] == [[10,20,30],[11,31],[32]]\r\n * ```\r\n * @note from columns to rows.\r\n * @note Empty lists are ignored.\r\n * @haskellType `transpose :: [[a]] -> [[a]]`\r\n * @function module:list.transpose\r\n * @param xss {Array}\r\n * @returns {Array}\r\n */\r\n transpose = xss => {\r\n let numLists = length(xss),\r\n ind = 0, ind2;\r\n if (!numLists) {\r\n return [];\r\n }\r\n const listLengths = apply(lengths, xss),\r\n longestListLen = maximum(listLengths),\r\n outLists = [];\r\n for (; ind < longestListLen; ind += 1) {\r\n const outList = [];\r\n for (ind2 = 0; ind2 < numLists; ind2 += 1) {\r\n if (listLengths[ind2] < ind + 1) {\r\n continue;\r\n }\r\n outList.push(xss[ind2][ind]);\r\n }\r\n outLists.push(outList);\r\n }\r\n return filter(x => length(x) > 0, outLists);\r\n },\r\n\r\n /**\r\n * Generates 2^n sub-sequences for passed in sequence (string/list) (`n` is\r\n * the length of the passed in sequence so: 2^length(xs)).\r\n * Note: The return value doubles per index/character passed in so use with caution!\r\n * Also note that for 2^16 (or for a sequence of 16 characters) this algorithm\r\n * will generate 65536 sub-sequences! So caution should be taken to not\r\n * use this with sequences above a certain length on certain platform (the browser thread in specific).\r\n * @function module:list.subsequences\r\n * @jsperftest https://jsperf.com/subsequences\r\n * @param xs {Array|String}\r\n * @returns {Array.}\r\n */\r\n subsequences = xs => {\r\n const listLen = length(xs),\r\n len = Math.pow(2, listLen),\r\n out = [];\r\n for (let i = 0; i < len; i += 1) {\r\n let entry = [];\r\n for (let j = 0; j < listLen; j += 1) {\r\n if (i & (1 << j)) {\r\n entry.push(xs[j]);\r\n }\r\n }\r\n out.push(entry);\r\n }\r\n return out;\r\n },\r\n\r\n /**\r\n * Returns an array with the given indices swapped.\r\n * @function module:list.swapped\r\n * @param ind1 {Number}\r\n * @param ind2 {Number}\r\n * @param list {Array}\r\n * @returns {Array} - Copy of incoming with swapped values at indices.\r\n */\r\n swapped = curry((ind1, ind2, list) => {\r\n const out = sliceCopy(list),\r\n tmp = out[ind1];\r\n out[ind1] = out[ind2];\r\n out[ind2] = tmp;\r\n return out;\r\n }),\r\n\r\n /**\r\n * Returns a list of permutations for passed in list.\r\n * Use caution with lists above a length of 15 (will take long due to nature of\r\n * algorithm).\r\n * @function module:list.permutations\r\n * @param xs {Array} - List.\r\n * @returns {Array} - Array of permutations.\r\n */\r\n permutations = xs => {\r\n const limit = length(xs);\r\n\r\n if (!limit || limit === 1) {\r\n return [xs];\r\n }\r\n\r\n let list = sliceCopy(xs),\r\n c = repeat(limit, 0),\r\n i = 0;\r\n\r\n const out = [list];\r\n\r\n for (; i < limit; i++) {\r\n if (c[i] < i) {\r\n list = swapped(i % 2 === 0 ? 0 : c[i], i, list);\r\n out.push(list);\r\n c[i] += 1;\r\n i = 0;\r\n continue;\r\n }\r\n c[i] = 0;\r\n }\r\n\r\n return out;\r\n },\r\n\r\n /**\r\n * Left associative fold. Reduces a container of elements down by the given operation (same as [].reduce).\r\n * @function module:list.foldl\r\n * @param fn {Function}\r\n * @param zero {*} - Aggregator.\r\n * @param functor {Array}\r\n * @returns {*} - Whatever type is lastly returned from `fn`.\r\n */\r\n foldl = reduce,\r\n\r\n /**\r\n * Right associative fold. Reduces a container of elements down by the given operation (same as [].reduceRight).\r\n * @function module:list.foldr\r\n * @param fn {Function}\r\n * @param zero {*} - Aggregator.\r\n * @param functor {Array}\r\n * @returns {*} - Whatever type is lastly returned from `fn`.\r\n */\r\n foldr = reduceRight,\r\n\r\n /**\r\n * A variant of `foldl` except that this one doesn't require the starting point. The starting point/value will be pulled\r\n * out from a copy of the container.\r\n * @function module:list.foldl1\r\n * @param op {Function}\r\n * @param xs {Array}\r\n * @returns {*} - Whatever type is lastly returned from `op`.\r\n */\r\n foldl1 = curry((op, xs) => {\r\n const parts = uncons(xs);\r\n return !parts ? [] : reduce(op, parts[0], parts[1]);\r\n }),\r\n\r\n /**\r\n * A variant of `foldr` except that this one doesn't require the starting point/value. The starting point/value will be pulled\r\n * out from a copy of the container.\r\n * @function module:list.foldr1\r\n * @param op {Function}\r\n * @param xs {Array}\r\n * @returns {*} - Whatever type is lastly returned from `op`.\r\n */\r\n foldr1 = curry((op, xs) => {\r\n const parts = unconsr(xs);\r\n return !parts ? [] : reduceRight(op, parts[1], parts[0]);\r\n }),\r\n\r\n /**\r\n * Performs a map then a reduce all in one (from left-to-right). Returns a tuple\r\n * containing the aggregated value and the result of mapping the passed in function on passed in list.\r\n * @function module:list.mapAccumL\r\n * @param op {Function} - Function : [aggregated, mapResult]\r\n * @param zero {*} - An instance of the passed in list type used to aggregateArray on.\r\n * @param xs {Array} - list type.\r\n * @return {Array} - [aggregated, list]\r\n */\r\n mapAccumL = curry((op, zero, xs) => {\r\n const list = sliceCopy(xs),\r\n limit = length(xs);\r\n if (!limit) {\r\n return [zero, list];\r\n }\r\n let ind = 0,\r\n agg = zero,\r\n mapped = [],\r\n tuple;\r\n for (; ind < limit; ind++) {\r\n tuple = op(agg, list[ind], ind);\r\n agg = tuple[0];\r\n mapped = tuple[1];\r\n }\r\n return [agg, mapped];\r\n }),\r\n\r\n /**\r\n * Performs a map and a reduce all in one (from right-to-left). Returns a tuple\r\n * containing the aggregated value and the result of mapping the passed in function on passed in list.\r\n * @function module:list.mapAccumR\r\n * @param op {Function} - Function : [aggregated, mapResult]\r\n * @param zero {*} - An instance of the passed in list type used to aggregateArray on.\r\n * @param xs {Array} - list type.\r\n * @return {Array} - [aggregated, list]\r\n */\r\n mapAccumR = curry((op, zero, xs) => {\r\n const list = sliceCopy(xs),\r\n limit = length(xs);\r\n if (!limit) {\r\n return [zero, list];\r\n }\r\n let ind = limit - 1,\r\n agg = zero,\r\n mapped = [],\r\n tuple;\r\n for (; ind >= 0; ind--) {\r\n tuple = op(agg, list[ind], ind);\r\n agg = tuple[0];\r\n mapped = tuple[1];\r\n }\r\n return [agg, mapped];\r\n }),\r\n\r\n /**\r\n * iterate f x returns an infinite list of repeated applications of f to x.\r\n * @function module:list.iterate\r\n * @example `iterate(5, f, x) == [x, f(x), f(f(x)), ...]`\r\n * @param limit {Number}\r\n * @param op {Function} - Operation.\r\n * @param x {*} - Starting point.\r\n * @returns {*}\r\n */\r\n iterate = curry((limit, op, x) => {\r\n let ind = 0,\r\n out = [],\r\n lastX = x;\r\n for (; ind < limit; ind += 1) {\r\n out.push(lastX);\r\n lastX = op(lastX, ind);\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Repeats `x` `limit` number of times.\r\n * @function module:list.repeat\r\n * @param limit {Number}\r\n * @param x {*}\r\n * @return {Array}\r\n */\r\n repeat = curry((limit, x) => iterate(limit, a => a, x)),\r\n\r\n /**\r\n * Same as `repeat` due to the nature of javascript (see haskell version for usage).\r\n * @function module:list.replicate\r\n * @param limit {Number}\r\n * @param x {*}\r\n * @return {Array}\r\n */\r\n replicate = repeat,\r\n\r\n /**\r\n * Replicates a list `limit` number of times and appends the results (concat)\r\n * @function module:list.cycle\r\n * @param limit {Number}\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n cycle = curry((limit, xs) => concat(replicate(limit, xs))),\r\n\r\n /**\r\n * Unfolds a value into a list of somethings.\r\n * @haskellType `unfoldr :: (b -> Maybe (a, b)) -> b -> [a]`\r\n * @function module:list.unfoldr\r\n * @param op {Function} - Operation to perform (should return a two component tuple (item to aggregateArray and item to unfold in next iteration).\r\n * @param x {*} - Starting parameter to unfold from.\r\n * @returns {Array} - An array of whatever you return from `op` yielded.\r\n */\r\n unfoldr = curry((op, x) => {\r\n let ind = 0,\r\n out = [],\r\n resultTuple = op(x, ind, out);\r\n while (resultTuple) {\r\n out.push(resultTuple[0]);\r\n resultTuple = op(resultTuple[1], ++ind, out);\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Finds index in string or list (alias for `findIndex`).\r\n * @function module:list.findIndex\r\n * @param pred {Function} - Predicate.\r\n * @param arr {Array|String}\r\n * @returns {Number} - `-1` if predicate not matched else `index` found\r\n */\r\n findIndex = findIndexWhere,\r\n\r\n /**\r\n * @function module:list.findIndices\r\n * @param pred {Function}\r\n * @param xs {Array} - list or list like.\r\n * @returns {Array|undefined}\r\n */\r\n findIndices = findIndicesWhere,\r\n\r\n /**\r\n * @function module:list.elemIndex\r\n * @param x {*} - Element to search for.\r\n * @param xs {Array} - list or list like.\r\n * @returns {*}\r\n */\r\n elemIndex = curry((x, xs) => {\r\n const foundInd = indexOf(x, xs);\r\n return foundInd !== -1 ? foundInd : undefined;\r\n }),\r\n\r\n /**\r\n * @function module:list.elemIndices\r\n * @param value {*} - Element to search for.\r\n * @param xs {Array} - list or list like.\r\n * @returns {*}\r\n */\r\n elemIndices = curry((value, xs) => findIndices(x => x === value, xs)),\r\n\r\n /**\r\n * Takes `n` items from start of list to `limit` (exclusive).\r\n * @function module:list.take\r\n * @param list {Array|String}\r\n * @param limit {Number}\r\n * @returns {String|Array} - Passed in type's type\r\n */\r\n take = sliceTo,\r\n\r\n /**\r\n * Drops `n` items from start of list to `count` (exclusive).\r\n * @function module:list.drop\r\n * @param list {Array|String}\r\n * @param count {Number}\r\n * @returns {String|Array} - Passed in type's type\r\n */\r\n drop = sliceFrom,\r\n\r\n /**\r\n * Splits `x` in two at given `index` (exclusive (includes element/character at\r\n * given index in second part of returned list)).\r\n * @function module:list.splitAt\r\n * @param ind {Number} - Index to split at.\r\n * @param list {Array|String} - functor (list or string) to split.\r\n * @returns {Array|String} - List like type passed\r\n */\r\n splitAt = (ind, list) => [sliceTo(ind, list), sliceFrom(ind, list)],\r\n\r\n /**\r\n * Gives an list with passed elements while predicate was true.\r\n * @function module:list.takeWhile\r\n * @param pred {Function} - Predicate<*, index, list|string>\r\n * @param list {Array|String}\r\n * @returns {Array}\r\n */\r\n takeWhile = curry((pred, list) =>\r\n reduceUntil(\r\n negateF3(pred), // predicate\r\n isString(list) ?\r\n (agg, x) => agg + x :\r\n aggregateArray, // operation\r\n of(list), // aggregate\r\n list\r\n )),\r\n\r\n /**\r\n * Returns an list without elements that match predicate.\r\n * @function module:list.dropWhile\r\n * @param pred {Function} - Predicate<*, index, list|string>\r\n * @param list {Array|String}\r\n * @refactor\r\n * @returns {Array|String}\r\n */\r\n dropWhile = curry((pred, list) => {\r\n const limit = length(list),\r\n splitPoint =\r\n findIndexWhere(\r\n (x, i, xs) => !pred(x, i, xs),\r\n list\r\n );\r\n\r\n return splitPoint === -1 ?\r\n sliceFrom(limit, list) :\r\n slice(splitPoint, limit, list);\r\n }),\r\n\r\n /**\r\n * @function module:list.dropWhileEnd\r\n * @param pred {Function} - Predicate<*, index, list|string>\r\n * @param list {Array|String}\r\n * @refactor\r\n * @returns {Array|String}\r\n */\r\n dropWhileEnd = curry((pred, list) => {\r\n const splitPoint =\r\n findIndexWhereRight(\r\n (x, i, xs) => !pred(x, i, xs),\r\n list\r\n );\r\n if (splitPoint === -1) {\r\n return of(list);\r\n }\r\n return sliceTo(splitPoint + 1, list);\r\n }),\r\n\r\n /**\r\n * Gives you the `span` of items matching predicate\r\n * and items not matching predicate; E.g., Gives an\r\n * array of arrays; E.g., [[matching-items], [non-matching-items]]\r\n * @function list.span\r\n * @param pred {Function} - List predicate (`(x, i, list) => bool`)\r\n * @param list {Array|String}\r\n * @returns {(Array>|Array)}\r\n * @type {Function}\r\n */\r\n span = curry((pred, list) => {\r\n const splitPoint = findIndexWhere(negateF3(pred), list);\r\n return splitPoint === -1 ?\r\n [sliceFrom(0, list), of(list)] :\r\n splitAt(splitPoint, list);\r\n }),\r\n\r\n /**\r\n * breakOnList, applied to a predicate p and a list xs, returns a tuple\r\n * where first element is longest prefix (possibly empty) of xs of elements\r\n * that do not satisfy p and second element is the remainder of the list:\r\n * @haskellExample\r\n * Replace `break` with `breakOnList` for our version.\r\n * ```\r\n * breakOnList (> 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4])\r\n * breakOnList (< 9) [1,2,3] == ([],[1,2,3])\r\n * breakOnList (> 9) [1,2,3] == ([1,2,3],[])\r\n * ```\r\n * @function module:list.breakOnList\r\n * @param pred {Function}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n breakOnList = curry((pred, list) => {\r\n const splitPoint = findIndexWhere(negateF3(pred), list);\r\n return splitPoint === -1 ?\r\n [of(list), sliceFrom(0, list)] : reverse(splitAt(splitPoint, list));\r\n }),\r\n\r\n /**\r\n * Gets item at index.\r\n * @function module:list.at\r\n * @param ind {Number} - Index.\r\n * @param xs {Array} - list or list like.\r\n * @returns {*|undefined} - Item or `undefined`.\r\n */\r\n at = lookup,\r\n\r\n /**\r\n * Find an item in structure of elements based on given predicate (`pred`).\r\n * @function module:list.find\r\n * @param pred {Function}\r\n * @param xs {Array} - list or list like.\r\n * @returns {*} - Found item.\r\n */\r\n find = findWhere,\r\n\r\n /**\r\n * For each function (same as `[].forEach` except in functional format).\r\n * @function module:list.forEach\r\n * @param fn {Function} - Operation (`(element, index, list) => {...}`, etc.)\r\n * @param xs {(Array|String)}\r\n * @returns {void}\r\n */\r\n forEach = curry((fn, list) => {\r\n const limit = length(list);\r\n if (!limit) {\r\n return;\r\n }\r\n let ind = 0;\r\n for (; ind < limit; ind += 1) {\r\n fn(list[ind], ind, list);\r\n }\r\n }),\r\n\r\n /**\r\n * Filters a structure of elements using given predicate (`pred`) (same as `[].filter`).\r\n * @function module:list.filter\r\n * @param pred {Function}\r\n * @param xs {Array} - list or list like.\r\n * @returns {Array} - Structure of filtered elements.\r\n */\r\n filter = curry((pred, xs) => {\r\n let ind = 0,\r\n limit = length(xs),\r\n out = [];\r\n if (!limit) {\r\n return out;\r\n }\r\n for (; ind < limit; ind++) {\r\n if (pred(xs[ind], ind, xs)) {\r\n out.push(xs[ind]);\r\n }\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Partitions a list on a predicate; Items that match predicate are in first list in tuple; Items that\r\n * do not match the tuple are in second list in the returned tuple.\r\n * Essentially `[filter(p, xs), filter(negateF3(p), xs)]`.\r\n * @function module:list.partition\r\n * @param pred {Function} - Predicate\r\n * @param list {Array}\r\n * @returns {Array|String} - Tuple of arrays or strings (depends on incoming list (of type list or string)).\r\n */\r\n partition = curry((pred, list) =>\r\n !length(list) ?\r\n [[], []] :\r\n [filter(pred, list), filter(negateF3(pred), list)]),\r\n\r\n /**\r\n * Returns a boolean indicating whether an element exists in given structure of elements.\r\n * @function module:list.elem\r\n * @param element {*}\r\n * @param xs {Array}\r\n * @returns {Boolean}\r\n */\r\n elem = includes,\r\n\r\n /**\r\n * The opposite of `elem` - Returns a boolean indicating whether an element exists in given list.\r\n * @function module:list.notElem\r\n * @param element {*}\r\n * @param xs {Array}\r\n * @returns {Boolean}\r\n */\r\n notElem = negateF2(includes),\r\n\r\n /**\r\n * Checks if list `xs1` is a prefix of list `xs2`\r\n * @function module:list.isPrefixOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isPrefixOf = curry((xs1, xs2) => {\r\n const limit1 = length(xs1),\r\n limit2 = length(xs2);\r\n if (limit2 < limit1 || !limit1 || !limit2 || indexOf(xs1[0], xs2) === -1) {\r\n return false;\r\n }\r\n let ind = 0;\r\n for (; ind < limit1; ind++) {\r\n if (xs1[ind] !== xs2[ind]) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }),\r\n\r\n /**\r\n * Checks if list `xs1` is a suffix of list `xs2`\r\n * @function module:list.isSuffixOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isSuffixOf = curry((xs1, xs2) => {\r\n const limit1 = length(xs1),\r\n limit2 = length(xs2);\r\n if (limit2 < limit1 || !limit1 || !limit2 || indexOf(xs1[0], xs2) === -1) {\r\n return false;\r\n }\r\n let ind1 = limit1 - 1,\r\n ind2 = limit2 - 1;\r\n for (; ind1 >= 0; ind1--) {\r\n if (xs1[ind1] !== xs2[ind2]) {\r\n return false;\r\n }\r\n ind2 -= 1;\r\n }\r\n return true;\r\n }),\r\n\r\n /**\r\n * Checks if list `xs1` is an infix of list `xs2`\r\n * @function module:list.isInfixOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isInfixOf = curry((xs1, xs2) => {\r\n const limit1 = length(xs1),\r\n limit2 = length(xs2);\r\n if (limit2 < limit1 || !limit1 || !limit2) {\r\n return false;\r\n }\r\n let ind1,\r\n foundLen,\r\n ind = 0;\r\n for (; ind < limit2; ind += 1) {\r\n foundLen = 0;\r\n for (ind1 = 0; ind1 < limit1; ind1 += 1) {\r\n if (xs2[ind1 + ind] === xs1[ind1]) {\r\n foundLen += 1;\r\n }\r\n if (foundLen === limit1) {\r\n return true;\r\n }\r\n }\r\n }\r\n return false;\r\n }),\r\n\r\n /**\r\n * Checks if list `xs1` is a sub-sequence of list `xs2`\r\n * @function module:list.isSubsequenceOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isSubsequenceOf = curry((xs1, xs2) => {\r\n const len = Math.pow(2, length(xs2)),\r\n lenXs1 = length(xs1);\r\n let foundLen,\r\n i;\r\n for (i = 0; i < len; i += 1) {\r\n foundLen = 0;\r\n for (let j = 0; j < len; j += 1) {\r\n if (i & (1 << j) && indexOf(xs2[j], xs1) > -1) {\r\n foundLen += 1;\r\n }\r\n if (foundLen === lenXs1) {\r\n return true;\r\n }\r\n }\r\n }\r\n return false;\r\n }),\r\n\r\n /**\r\n * The group function takes a list and returns a list of lists such that\r\n * the concatenation of the result is equal to the argument. Moreover, each\r\n * sublist in the result contains only equal elements. For example,\r\n * `group \"Mississippi\" = [\"M\",\"i\",\"ss\",\"i\",\"ss\",\"i\",\"pp\",\"i\"]`\r\n * It is a special case of groupBy, which allows the programmer to supply\r\n * their own equality test.\r\n * @haskellType `group :: Eq a => [a] -> [[a]]`\r\n * @function module:list.group\r\n * @param xs {Array|String}\r\n * @returns {Array|*}\r\n */\r\n group = xs => groupBy((a, b) => a === b, xs),\r\n\r\n /**\r\n * Allows you to group items in a list based on your supplied equality check.\r\n * @note Sames `group` but allows you to specify equality operation.\r\n * @haskellType `groupBy :: (a -> a -> Bool) -> [a] -> [[a]]`\r\n * @function module:list.groupBy\r\n * @param equalityOp {Function}\r\n * @param xs {Array}\r\n * @returns {*}\r\n */\r\n groupBy = curry((equalityOp, xs) => {\r\n const limit = length(xs);\r\n if (!limit) {\r\n return sliceCopy(xs);\r\n }\r\n let ind = 0,\r\n prevItem,\r\n item,\r\n predOp = x => {\r\n if (equalityOp(x, prevItem)) {\r\n ind++;\r\n }\r\n if (equalityOp(x, item)) {\r\n prevItem = x;\r\n return true;\r\n }\r\n return false;\r\n },\r\n agg = [];\r\n for (; ind < limit; ind += 1) {\r\n item = xs[ind];\r\n agg.push(takeWhile(predOp, slice(ind, limit, xs)));\r\n }\r\n return agg;\r\n }),\r\n\r\n /**\r\n * The inits function returns all initial segments of the argument, shortest first. For example,\r\n * ```\r\n * shallowEquals(inits('abc'), ['','a','ab','abc'])\r\n * ```\r\n * @function module:list.inits\r\n * @haskellType `inits :: [a] -> [[a]]`\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n inits = xs => {\r\n let limit = length(xs),\r\n ind = 0,\r\n agg = [];\r\n if (!limit) {\r\n return [];\r\n }\r\n for (; ind <= limit; ind += 1) {\r\n agg.push(sliceTo(ind, xs));\r\n }\r\n return agg;\r\n }, //map(list => init(list), xs),\r\n\r\n /**\r\n * The inits function returns all initial segments of the argument, shortest first. For example,\r\n * ```\r\n * shallowEquals(tails('abc'), ['abc', 'bc', 'c',''])\r\n * ```\r\n * @function module:list.tails\r\n * @haskellType `tails :: [a] -> [[a]]`\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n tails = xs => {\r\n let limit = length(xs),\r\n ind = 0,\r\n agg = [];\r\n if (!limit) {\r\n return [];\r\n }\r\n for (; ind <= limit; ind += 1) {\r\n agg.push(slice(ind, limit, xs));\r\n }\r\n return agg;\r\n }, //map(list => tail(list), xs),\r\n\r\n /**\r\n * Strips prefix list from given list\r\n * @function module:list.stripPrefix\r\n * @param prefix {Array|String|*}\r\n * @param list {Array|string|*}\r\n * @returns {Array|*}\r\n */\r\n stripPrefix = curry((prefix, list) =>\r\n isPrefixOf(prefix, list) ?\r\n splitAt(length(prefix), list)[1] :\r\n sliceCopy(list)),\r\n\r\n /**\r\n * zip takes two lists and returns a list of corresponding pairs.\r\n * If one input list is short, excess elements of the longer list are discarded.\r\n * @haskellType `zip :: [a] -> [b] -> [(a, b)]`\r\n * @function module:list.zip\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array>}\r\n */\r\n zip = curry((arr1, arr2) => {\r\n if (!length(arr1) || !length(arr2)) {\r\n return [];\r\n }\r\n const [a1, a2] = toShortest(arr1, arr2);\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, [item, a2[ind]]),\r\n [], a1);\r\n }),\r\n\r\n /**\r\n * zipN takes one or more lists and returns a list containing lists of all indices\r\n * at a given index, index by index.\r\n * If one input list is short, excess elements of the longer list are discarded.\r\n * @function module:list.zipN\r\n * @param lists {Array|String} - One ore more lists of the same type.\r\n * @returns {Array}\r\n */\r\n zipN = curry2((...lists) => {\r\n const trimmedLists = apply(toShortest, lists);\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, map(xs => xs[ind], trimmedLists)),\r\n [], trimmedLists[0]);\r\n }),\r\n\r\n /**\r\n * @haskellType `zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]`\r\n * @function module:list.zip3\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @param arr3 {Array}\r\n * @returns {Array>}\r\n */\r\n zip3 = curry((arr1, arr2, arr3) => zipN(arr1, arr2, arr3)),\r\n\r\n /**\r\n * @haskellType `zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]`\r\n * @function module:list.zip4\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @param arr3 {Array}\r\n * @param arr4 {Array}\r\n * @returns {Array>}\r\n */\r\n zip4 = curry((arr1, arr2, arr3, arr4) => zipN(arr1, arr2, arr3, arr4)),\r\n\r\n /**\r\n * @haskellType `zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]`\r\n * @function module:list.zip5\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @param arr3 {Array}\r\n * @param arr4 {Array}\r\n * @param arr5 {Array}\r\n * @returns {Array>}\r\n */\r\n zip5 = curry((arr1, arr2, arr3, arr4, arr5) => zipN(arr1, arr2, arr3, arr4, arr5)),\r\n\r\n /**\r\n * zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]\r\n * zipWith generalises zip by zipping with the function given as the\r\n * first argument, instead of a function tupling function (function that returns a tuple). For example,\r\n * zipWith (+) is applied to two lists to produce the list of corresponding sums.\r\n * @note `_|_` means bottom or perpetual (@see\r\n * - https://wiki.haskell.org/Bottom\r\n * - https://stackoverflow.com/questions/19794681/what-does-this-syntax-mean-in-haskell-or\r\n * )\r\n * @example\r\n * ```\r\n * zipWith f [] _|_ = []\r\n * ```\r\n * @haskellType `zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]`\r\n * @function module:list.zipWith\r\n * @param op {Function} - Takes two parts of a tuple and returns a tuple.\r\n * E.g., ` op :: a -> b -> (a, b)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith = curry((op, xs1, xs2) => {\r\n if (!length(xs1) || !length(xs2)) {\r\n return [];\r\n }\r\n const [a1, a2] = toShortest(xs1, xs2);\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, op(item, a2[ind])),\r\n [], a1);\r\n }),\r\n\r\n /**\r\n * Zips all given lists with tupling function. Note: Haskell types do not have\r\n * a way (that I know of) to show one or more for params in a function so `@haskellType` below\r\n * is left there for general purpose not for exactness as is told by aforementioned.\r\n * @haskellType `zipWithN :: (a -> b -> c) -> [a] -> [b] -> [c]` - Where `N` is the number\r\n * of lists to zip.\r\n * @function module:list.zipWithN\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> (a, b, c)`\r\n * @param lists ...{Array}\r\n * @returns {Array>}\r\n */\r\n zipWithN = curry3((op, ...lists) => {\r\n const trimmedLists = apply(toShortest, lists),\r\n lenOfTrimmed = length(trimmedLists);\r\n if (!lenOfTrimmed) {\r\n return [];\r\n }\r\n else if (lenOfTrimmed === 1) {\r\n return sliceTo(length(trimmedLists[0]), trimmedLists[0]);\r\n }\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, apply(op, map(xs => xs[ind], trimmedLists))),\r\n [], trimmedLists[0]);\r\n }),\r\n\r\n /**\r\n * Zips 3 lists with tupling function.\r\n * @haskellType `zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]`\r\n * @function module:list.zipWith3\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> (a, b, c)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @param xs3 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith3 = curry((op, xs1, xs2, xs3) => zipWithN(op, xs1, xs2, xs3)),\r\n\r\n /**\r\n * Zips 4 lists with tupling function.\r\n * @haskellType `zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]`\r\n * @function module:list.zipWith4\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> d -> (a, b, c, d)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @param xs3 {Array}\r\n * @param xs4 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith4 = curry((op, xs1, xs2, xs3, xs4) => zipWithN(op, xs1, xs2, xs3, xs4)),\r\n\r\n /**\r\n * Zips 5 lists.\r\n * @haskellType `zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]`\r\n * @function module:list.zipWith5\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> d -> e -> (a, b, c, d, e)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @param xs3 {Array}\r\n * @param xs4 {Array}\r\n * @param xs5 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith5 = curry((op, xs1, xs2, xs3, xs4, xs5) => zipWithN(op, xs1, xs2, xs3, xs4, xs5)),\r\n\r\n /**\r\n * unzip transforms a list of pairs into a list of first components and a list of second components.\r\n * @haskellType `unzip :: [(a, b)] -> ([a], [b])`\r\n * @function module:list.unzip\r\n * @param arr {Array|*}\r\n * @returns {Array|*}\r\n */\r\n unzip = foldl((agg, item) => {\r\n agg[0].push(item[0]);\r\n agg[1].push(item[1]);\r\n return agg;\r\n }, [[], []]),\r\n\r\n /**\r\n * unzip transforms a list of pairs into a list of first components and a list of second components.\r\n * @sudoHaskellType `unzipN :: [(a, b, ...x)] -> ([a], [b], ...[x])`\r\n * @function module:list.unzipN\r\n * @param list {Array|*} - List of tuples (lists).\r\n * @returns {Array|*}\r\n */\r\n unzipN = list => {\r\n if (!length(list)) {\r\n return [];\r\n }\r\n const lenItem0 = length(list[0]);\r\n let zero = lenItem0 ?\r\n unfoldr(numLists => numLists-- ? [[], numLists] : undefined, lenItem0) :\r\n [];\r\n return foldl((agg, item) => {\r\n agg.forEach((outList, ind) => outList.push(item[ind]));\r\n return agg;\r\n }, zero, list);\r\n },\r\n\r\n /**\r\n * Returns true if any item in container passes predicate `p`.\r\n * @function module:list.any\r\n * @param p {Function} - Predicate.\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n any = curry((p, xs) => {\r\n let ind = 0,\r\n limit = length(xs);\r\n if (!limit) {\r\n return false;\r\n }\r\n for (; ind < limit; ind += 1) {\r\n if (p(xs[ind])) {\r\n return true;\r\n }\r\n }\r\n return false;\r\n }),\r\n\r\n /**\r\n * Returns true if all items in container pass predicate `p`.\r\n * @function module:list.all\r\n * @param p {Function} - Predicate.\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n all = curry((p, xs) => {\r\n const limit = length(xs);\r\n let ind = 0;\r\n if (!limit) {\r\n return false;\r\n }\r\n for (; ind < limit; ind++) {\r\n if (!p(xs[ind], ind, xs)) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }),\r\n\r\n /**\r\n * Conjuction of container of bools (or truthy and/or falsy values); Returns\r\n * `true` if all in container are 'truthy' else returns `false`\r\n * @function module:list.and\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n and = xs => all(isTruthy, xs),\r\n\r\n /**\r\n * Returns a boolean indicating whether any item in container is 'truthy' or not.\r\n * **Note** The haskell type for this function only takes two items, but here\r\n * we allow the passing of more than one item (may change later to adhere to the haskell type).\r\n * @function module:list.or\r\n * @haskellType `or :: Bool -> Bool -> Bool`\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n or = xs => any(isTruthy, xs),\r\n\r\n /**\r\n * Returns a boolean indicating whether all items in container are 'falsy' or not.\r\n * **Note** The haskell type for this function only takes two items, but here\r\n * we allow the passing of more than one item (may change later to adhere to the haskell type).\r\n * @function module:list.not\r\n * @haskellType `not :: Bool -> Bool`\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n not = xs => all(isFalsy, xs),\r\n\r\n /**\r\n * Computes the sum of the numbers of a structure.\r\n * @function module:list.sum\r\n * @haskellType `sum :: (List t, Num a) => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {Number}\r\n */\r\n sum = list => foldl((agg, x) => agg + x, 0, list),\r\n\r\n /**\r\n * Computes the product of the numbers of a structure.\r\n * @function module:list.product\r\n * @haskellType `product :: (List t, Num a) => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {Number}\r\n */\r\n product = list => foldl((agg, x) => agg * x, 1, list),\r\n\r\n /**\r\n * Returns the largest element in a non-empty structure of elements.\r\n * @function module:list.maximum\r\n * @haskellType `maximum :: forall a . Ord a => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {*} - Whatever type the array is made of (if any).\r\n */\r\n maximum = list => last(sortBy(genericAscOrdering, list)),\r\n\r\n /**\r\n * Returns the smallest element in a non-empty structure of elements.\r\n * @function module:list.minimum\r\n * @haskellType `minimum :: forall a . Ord a => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {*} - Whatever type the array is made of (if any).\r\n */\r\n minimum = list => head(sortBy(genericAscOrdering, list)),\r\n\r\n /**\r\n * scanl is similar to foldl, but returns a list of successive reduced values from the left:\r\n * ```\r\n * scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]\r\n * ```\r\n * Also note that:\r\n * ```\r\n * last (scanl f z xs) == foldl f z xs.\r\n * ```\r\n * @function module:list.scanl\r\n * @param fn {Function}\r\n * @param zero {*}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanl = curry((fn, zero, xs) => {\r\n if (!xs || !length(xs)) {\r\n return [];\r\n }\r\n const limit = length(xs);\r\n let ind = 0,\r\n result = zero,\r\n out = [];\r\n while (ind < limit) {\r\n result = fn(result, xs[ind], ind, xs);\r\n out.push(result);\r\n ind++;\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * `scanl1` is a variant of `scanl` that has no starting value argument:\r\n * `shallowCompare(scanl1(fn, [x1, x2, ...]), [x1, fn(x1, x2), ...]) // true`\r\n * @function module:list.scanl1\r\n * @param fn {Function}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanl1 = curry((fn, xs) => {\r\n if (!xs || !xs.length) {\r\n return [];\r\n }\r\n return scanl(fn, head(xs), tail(xs));\r\n }),\r\n\r\n /**\r\n * Same as `scanl` but from the right (similiar to `foldr`'s relationship to 'foldl').\r\n * Note also `scanr`'s relationship ot `foldr`:\r\n * `head (scanr(fn, z, xs)) === foldr(fn, z, xs).\r\n * @function module:list.scanr\r\n * @param fn {Function}\r\n * @param zero {*}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanr = curry((fn, zero, xs) => {\r\n if (!xs || !length(xs)) {\r\n return [];\r\n }\r\n const limit = length(xs);\r\n let ind = limit - 1,\r\n result = xs[0],\r\n out = [];\r\n while (ind > -1) {\r\n result = fn(result, xs[ind], ind, xs);\r\n out.push(result);\r\n ind--;\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Same as `scanr` but takes no zero/accumulator value.\r\n * @function module:list.scanr1\r\n * @param fn {Function}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanr1 = curry((fn, xs) => {\r\n if (!xs || !xs.length) {\r\n return [];\r\n }\r\n return scanr(fn, last(xs), init(xs));\r\n }),\r\n\r\n /**\r\n * The nub function removes duplicate elements from a list.\r\n * In particular, it keeps only the first occurrence of each element.\r\n * (The name nub means `essence'.) It is a special case of nubBy, which\r\n * allows the programmer to supply their own equality test.\r\n * ```shallowCompare( nub ([1,2,3,4,3,2,1,2,4,3,5]), [1,2,3,4,5] )```\r\n * @function module:list.nub\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n nub = list => nubBy((a, b) => a === b, list),\r\n\r\n /**\r\n * `remove(x, xs)` removes the first occurrence of `x` from `xs`.\r\n * For example, `remove('a', 'banana') === 'bnana';`\r\n * @function module:list.remove\r\n * @param x {*}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n remove = curry((x, list) => removeBy((a, b) => a === b, x, list)),\r\n\r\n /**\r\n * The sort function implements a stable sorting algorithm.\r\n * It is a special case of sortBy, which allows the programmer\r\n * to supply their own comparison function.\r\n * ```shallowCompare(sort ([1,6,4,3,2,5]), [1,2,3,4,5,6]) // true```\r\n * @function module:list.sort\r\n * @param xs {Array|String|*}\r\n * @returns {Array}\r\n */\r\n sort = xs => sortBy(genericAscOrdering, xs),\r\n\r\n /**\r\n * Sort a list by comparing the results of a key function applied to each\r\n * element. sortOn f is equivalent to sortBy (comparing f), but has the\r\n * performance advantage of only evaluating f once for each element in the\r\n * input list. This is called the decorate-sort-undecorate paradigm, or\r\n * Schwartzian transform.\r\n *\r\n * Elements are arranged from from lowest to highest, keeping duplicates\r\n * in the order they appeared in the input.\r\n *\r\n * Ex:\r\n * ```\r\n * shallowEquals(\r\n * sortOn (head, [[2, \"world\"], [4, \"!\"], [1, \"Hello\"]]),\r\n * [[1,\"Hello\"],[2,\"world\"],[4,\"!\"]]\r\n * ) // true\r\n * ```\r\n * @function module:list.sortOn\r\n * @param valueFn {Function}\r\n * @param xs {Array|String|*}\r\n * @returns {Array}\r\n */\r\n sortOn = curry((valueFn, xs) =>\r\n\r\n // Un-decorate\r\n map(decorated => decorated[1],\r\n\r\n // Decorate and sort\r\n sortBy(\r\n // Ordering\r\n ([a0], [b0]) => genericAscOrdering(a0, b0),\r\n\r\n // Decorate\r\n map(item => [valueFn(item), item], xs)\r\n )\r\n )\r\n ),\r\n\r\n /**\r\n * The sortBy function is the non-overloaded (in haskell terms) version of sort.\r\n * @haskellExample ```\r\n * >>> sortBy (\\(a,_) (b,_) -> compare a b) [(2, \"world\"), (4, \"!\"), (1, \"Hello\")]\r\n * [(1,\"Hello\"),(2,\"world\"),(4,\"!\")]\r\n * ```\r\n * @function module:list.sortBy\r\n * @param orderingFn {Function}\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sortBy = curry((orderingFn, xs) => sliceCopy(xs).sort(orderingFn || genericAscOrdering)),\r\n\r\n /**\r\n * The insert function takes an element and a list and inserts the element\r\n * into the list at the first position where it is less than or equal to the\r\n * next element. In particular, if the list is sorted before the call, the\r\n * result will also be sorted. It is a special case of insertBy, which allows\r\n * the programmer to supply their own comparison function.\r\n * @function module:list.insert\r\n * @param x {*}\r\n * @param xs {Array|*}\r\n * @returns {Array}\r\n */\r\n insert = curry((x, xs) => {\r\n if (!xs.length) {\r\n return of(xs, x);\r\n }\r\n const foundIndex = findIndex(item => x <= item, xs);\r\n return foundIndex === -1 ? concat([xs, of(xs, x)]) :\r\n concat(intersperse(of(xs, x), splitAt(foundIndex, xs)));\r\n }),\r\n\r\n /**\r\n * A version of `insert` that allows you to specify the ordering of the inserted\r\n * item; Before/at, or after\r\n * @function module:list.insertBy\r\n * @haskellType `insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]`\r\n * @note `Ordering` means 'something that is order-able'\r\n * operated on by this functions logic.\r\n * @param orderingFn {Function} - A function that returns `-1`, `0`, or 1`.\r\n * @param x {*} - Value to insert.\r\n * @param xs {Array} - List to insert into (note new list is returned)\r\n * @returns {Array} - New list.\r\n */\r\n insertBy = curry((orderingFn, x, xs) => {\r\n const limit = length(xs);\r\n if (!limit) {\r\n return [x];\r\n }\r\n let ind = 0;\r\n for (; ind < limit; ind += 1) {\r\n if (orderingFn(x, xs[ind]) <= 0) {\r\n const parts = splitAt(ind, xs);\r\n return concat([parts[0], [x], parts[1]]);\r\n }\r\n }\r\n return aggregateArray(sliceCopy(xs), x);\r\n }),\r\n\r\n /**\r\n * The nubBy function behaves just like nub, except it uses a user-supplied equality predicate.\r\n * @function module:list.nubBy\r\n * @param pred {Function}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n nubBy = curry((pred, list) => {\r\n if (!length(list)) {\r\n return [];\r\n }\r\n const limit = length(list);\r\n let ind = 0,\r\n currItem,\r\n out = [],\r\n anyOp = storedItem => pred(currItem, storedItem);\r\n for (; ind < limit; ind += 1) {\r\n currItem = list[ind];\r\n if (any(anyOp, out)) {\r\n continue;\r\n }\r\n out.push(currItem);\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Behaves the same as `remove`, but takes a user-supplied equality predicate.\r\n * @function module:list.removeBy\r\n * @param pred {Function} - Equality predicate `(a, b) => bool`\r\n * @param x {*}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n removeBy = curry((pred, x, list) => {\r\n const foundIndex = findIndex(item => pred(x, item), list);\r\n if (foundIndex > -1) {\r\n const parts = splitAt(foundIndex, list);\r\n return append(parts[0], tail(parts[1]));\r\n }\r\n return sliceCopy(list);\r\n }),\r\n\r\n /**\r\n * The `removeFirstsBy` function takes a predicate and two lists and returns the first list with the first\r\n * occurrence of each element of the second list removed.\r\n * @function module:list.removeFirstBy\r\n * @param pred {Function}\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {Array}\r\n */\r\n removeFirstsBy = curry((pred, xs1, xs2) =>\r\n foldl((agg, x) => removeBy(pred, x, agg), xs1, xs2)),\r\n\r\n /**\r\n * Returns the union on elements matching boolean check passed in.\r\n * @function module:list.unionBy\r\n * @param pred {Function} - `pred :: a -> a -> Bool`\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array}\r\n */\r\n unionBy = curry((pred, arr1, arr2) =>\r\n foldl((agg, b) => {\r\n const alreadyAdded = any(a => pred(a, b), agg);\r\n return !alreadyAdded ? (agg.push(b), agg) : agg;\r\n }, sliceCopy(arr1), arr2\r\n )),\r\n\r\n /**\r\n * Creates a union on matching elements from array1.\r\n * @function module:list.union\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array}\r\n */\r\n union = curry((arr1, arr2) =>\r\n append(arr1,\r\n filter(elm => !includes(elm, arr1), arr2))),\r\n\r\n /**\r\n * Performs an intersection on list 1 with elements from list 2.\r\n * @function module:list.intersect\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array}\r\n */\r\n intersect = curry((arr1, arr2) =>\r\n !arr1 || !arr2 || (!arr1 && !arr2) ? [] :\r\n filter(elm => includes(elm, arr2), arr1)),\r\n\r\n /**\r\n * Returns an intersection by predicate.\r\n * @function module:list.intersectBy\r\n * @param pred {Function} - `pred :: a -> b -> Bool`\r\n * @param list1 {Array}\r\n * @param list2 {Array}\r\n * @return {Array}\r\n */\r\n intersectBy = curry((pred, list1, list2) =>\r\n foldl((agg, a) =>\r\n any(b => pred(a, b), list2) ? (agg.push(a), agg) : agg\r\n , [], list1)),\r\n\r\n /**\r\n * Returns the difference of list 1 from list 2.\r\n * @note The `difference` operation here is non-associative; E.g., `a - b` is not equal to `b - a`;\r\n * @function module:list.difference\r\n * @param array1 {Array}\r\n * @param array2 {Array}\r\n * @returns {Array}\r\n */\r\n difference = curry((array1, array2) => { // augment this with max length and min length ordering on op\r\n if (array1 && !array2) {\r\n return sliceCopy(array1);\r\n }\r\n else if (!array1 && array2 || (!array1 && !array2)) {\r\n return [];\r\n }\r\n return reduce((agg, elm) =>\r\n !includes(elm, array2) ? (agg.push(elm), agg) : agg\r\n , [], array1);\r\n }),\r\n\r\n /**\r\n * Returns the complement of list 0 and the reset of the passed in arrays.\r\n * @function module:list.complement\r\n * @param arr0 {Array}\r\n * @param arrays {...Array}\r\n * @returns {Array}\r\n */\r\n complement = curry2((arr0, ...arrays) =>\r\n reduce((agg, arr) => append(agg, difference(arr, arr0)), [], arrays));\r\n","/**\r\n * @module errorThrowing\r\n * @description Contains error throwing facilities for when a value doesn't match a type.\r\n */\r\nimport {typeOf} from './object/typeOf';\r\nimport {isArray, toTypeRef, toTypeRefName, isOfType} from './object/is';\r\nimport {curry} from './function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Pretty prints an array of types/type-strings for use by error messages;\r\n * Outputs \"`SomeTypeName`, ...\" from [SomeType, 'SomeTypeName', etc...]\r\n * @function module:errorThrowing.typeRefsToStringOrError\r\n * @param types {Array|TypesArray}\r\n * @return {String}\r\n * @private\r\n */\r\n typeRefsToStringOrError = types => types.length ?\r\n types.map(type => `\\`${toTypeRefName(type)}\\``).join(', ') : '',\r\n\r\n /**\r\n * Prints a message from an object. Object signature:\r\n * {contextName, valueName, value, expectedTypeName, foundTypeName, messageSuffix}\r\n * @function module:errorThrowing.defaultErrorMessageCall\r\n * @param tmplContext {Object|TemplateContext} - Object to use in error template.\r\n * @returns {string}\r\n * @private\r\n */\r\n defaultErrorMessageCall = tmplContext => {\r\n const {\r\n contextName, valueName, value, expectedTypeName,\r\n foundTypeName, messageSuffix\r\n } = tmplContext,\r\n isMultiTypeNames = isArray(expectedTypeName),\r\n typesCopy = isMultiTypeNames ? 'of type' : 'of one of the types',\r\n typesToMatchCopy = isMultiTypeNames ? typeRefsToStringOrError(expectedTypeName) : expectedTypeName;\r\n return (contextName ? `\\`${contextName}.` : '`') +\r\n `${valueName}\\` is not ${typesCopy}: ${typesToMatchCopy}. ` +\r\n `Type received: ${foundTypeName}. Value: ${value};` +\r\n `${messageSuffix ? ' ' + messageSuffix + ';' : ''}`;\r\n },\r\n\r\n /**\r\n * Gets the error message thrower seeded with passed in errorMessage template call.\r\n * @function module:errorThrowing.getErrorIfNotTypeThrower$\r\n * @param errorMessageCall {Function|ErrorMessageCall}\r\n * @param typeChecker {Function|TypeChecker} - Function:Boolean\r\n * @returns {Function|ErrorIfNotType}\r\n * @private\r\n */\r\n _getErrorIfNotTypeThrower = (errorMessageCall, typeChecker = isOfType) =>\r\n (ValueType, contextName, valueName, value, messageSuffix = null) => {\r\n const expectedTypeName = toTypeRef(ValueType),\r\n foundTypeName = typeOf(value);\r\n if (typeChecker(ValueType, value)) { return value; } // Value matches type\r\n throw new Error(errorMessageCall(\r\n {contextName, valueName, value, expectedTypeName, foundTypeName, messageSuffix}\r\n ));\r\n },\r\n\r\n /**\r\n * Gets the error message thrower seeded with passed in errorMessage template call.\r\n * @function module:errorThrowing.getErrorIfNotTypesThrower$\r\n * @param errorMessageCall {Function|ErrorMessageCall}\r\n * @param typeChecker {Function|TypeChecker} - Function:Boolean\r\n * @returns {Function|ErrorIfNotTypes}\r\n * @private\r\n */\r\n _getErrorIfNotTypesThrower = (errorMessageCall, typeChecker = isOfType) =>\r\n (valueTypes, contextName, valueName, value, messageSuffix = null) => {\r\n const expectedTypeNames = valueTypes.map(toTypeRef),\r\n matchFound = valueTypes.some(ValueType => typeChecker(ValueType, value)),\r\n foundTypeName = typeOf(value);\r\n if (matchFound) { return value; }\r\n throw new Error(\r\n errorMessageCall({\r\n contextName, valueName, value,\r\n expectedTypeName: expectedTypeNames, foundTypeName,\r\n messageSuffix\r\n })\r\n );\r\n },\r\n\r\n /**\r\n * Checks that passed in `value` is of given `type`. Throws an error if value\r\n * is not of given `type`. This is the un-curried version. For the curried version\r\n * see `module:errorThrowing.errorIfNotType`.\r\n * @function module:errorThrowing.errorIfNotType$\r\n * @param type {String|Function} - Type's name or type itself.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @param [messageSuffix=null] {String} - Optional.\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @private\r\n */\r\n _errorIfNotType = _getErrorIfNotTypeThrower(defaultErrorMessageCall),\r\n\r\n /**\r\n * Checks that passed in `value` is of one of the given `types`. Throws an error if value\r\n * is not of one of the given `types`. This is the un-curried version. For the curried version\r\n * see `module:errorThrowing.errorIfNotTypes`.\r\n * @type {Function|module:errorThrowing.errorIfNotTypes}\r\n * @function module:errorThrowing.errorIfNotTypes$\r\n * @param types {Array} - Array of one or more types or type names themselves.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @private\r\n */\r\n _errorIfNotTypes = _getErrorIfNotTypesThrower(defaultErrorMessageCall),\r\n\r\n /**\r\n * Returns a function that can be used to ensure that values are of a given type.\r\n * Also throws informative error messages containing the value types, names, expected type names,\r\n * etc.\r\n * @function module:errorThrowing.getErrorIfNotTypeThrower\r\n * @param errorMessageCall {Function|ErrorMessageCall} - Template function (takes an info-object and returns a printed string).\r\n * @returns {Function|ErrorIfNotType} - Returns a function with the same signature as `errorIfNotType` though curried.\r\n */\r\n getErrorIfNotTypeThrower = errorMessageCall => curry(_getErrorIfNotTypeThrower(errorMessageCall)),\r\n\r\n /**\r\n * Returns a function that can be used to ensure that a value is of one or more given types.\r\n * The returned function is used in cases where informative error messages\r\n * containing the value types, names, expected type names, are-required/should-be-used etc.\r\n * @function module:errorThrowing.getErrorIfNotTypesThrower\r\n * @param errorMessageCall {Function|ErrorMessageCall} - Template function (takes an info-object and returns a printed string).\r\n * @returns {Function|ErrorIfNotTypes} - Returns a function with the same signature as `errorIfNotTypes` though curried.\r\n */\r\n getErrorIfNotTypesThrower = errorMessageCall => curry(_getErrorIfNotTypesThrower(errorMessageCall)),\r\n\r\n /**\r\n * Checks that passed in `value` is of given `type`. Throws an error if value\r\n * is not of given `type`. Curried.\r\n * @function module:errorThrowing.errorIfNotType\r\n * @param type {String|Function} - Type's name or type itself.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @param [messageSuffix=null] {String} - Optional.\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @curried\r\n */\r\n errorIfNotType = curry(_errorIfNotType),\r\n\r\n /**\r\n * Checks that passed in `value` is of one of the given `types`. Throws an error if value\r\n * is not of one of the given `types`. Curried.\r\n * @function module:errorThrowing.errorIfNotTypes\r\n * @param types {Array} - Array of one or more types or type names themselves.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @curried\r\n */\r\n errorIfNotTypes = curry(_errorIfNotTypes)\r\n;\r\n\r\n/**\r\n * @typedef {*} Any - Synonym for 'any value'.\r\n */\r\n\r\n/**\r\n * @typedef {String|Function} TypeRef\r\n * @description Type reference. Type itself or Type's name; E.g., `Type.name`;\r\n */\r\n\r\n/**\r\n * @typedef {Object} TemplateContext\r\n * @description Template context used for error message renderers (functions that take a context obj and return a string).\r\n * @property value {*}\r\n * @property valueName {String}\r\n * @property expectedTypeName {String} - Expected name of constructor of `value`; E.g., usually `SomeConstructor.name`;\r\n * @property foundTypeName {String} - Found types name; E.g., `FoundConstructor.name`;\r\n * @property [messageSuffix=null] {*} - Message suffix (sometimes an extra hint or instructions for\r\n * directing user to fix where his/her error has occurred). Optional.\r\n */\r\n\r\n/**\r\n * @typedef {Array<(String|Function)>} TypesArray\r\n */\r\n\r\n/**\r\n * @typedef {Function} TypeChecker\r\n * @description Checks whether a value is of given type.\r\n * @param Type {TypeRef} - a Type or it's name; E.g., `Type.name`.\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n\r\n/**\r\n * @typedef {Function} ErrorMessageCall\r\n * @description Error message template function.\r\n * @param tmplContext {TemplateContext}\r\n * @returns {String}\r\n */\r\n\r\n/**\r\n * @typedef {Function} ErrorIfNotType\r\n * @description Used to ensure value matches passed in type.\r\n * @param type {TypeRef} - Constructor name or constructor.\r\n * @param contextName {String}\r\n * @param valueName {String}\r\n * @param value {*}\r\n * @throws {Error} - If value doesn't match type.\r\n * @returns {*} - What ever value is.\r\n */\r\n\r\n/**\r\n * @typedef {Function} ErrorIfNotTypes\r\n * @description Used to ensure a value matches one of one or more types passed in.\r\n * @param valueTypes {TypesArray} - Array of constructor names or constructors.\r\n * @param contextName {String}\r\n * @param valueName {String}\r\n * @param value {*}\r\n * @throws {Error} - If value doesn't match type.\r\n * @returns {*} - Whatever value is.\r\n */\r\n","/**\r\n * @module string\r\n * @description Contains functions for strings.\r\n */\r\nimport {intercalate, map, filter} from './list';\r\nimport {split} from './jsPlatform/string';\r\nimport {compose} from './function/compose';\r\nimport {join} from './jsPlatform/array';\r\nimport {_errorIfNotType} from './errorThrowing';\r\n\r\nexport {split};\r\n\r\nexport const\r\n\r\n /**\r\n * Splits a string on all '\\n', '\\r', '\\n\\r', or '\\r\\n' characters.\r\n * @function module:string.lines\r\n * @param str {String}\r\n * @returns {Array}\r\n */\r\n lines = split(/[\\n\\r]/gm),\r\n\r\n /**\r\n * Splits a string on all '\\s' and/or all '\\t' characters.\r\n * @function module:string.words\r\n * @param str{String}\r\n * @returns {Array}\r\n */\r\n words = split(/[\\s\\t]/gm),\r\n\r\n /**\r\n * Intersperse an array of strings with '\\s' and then concats them.\r\n * @function module:string.unwords\r\n * @param arr {String}\r\n * @returns {Array}\r\n */\r\n unwords = intercalate(' '),\r\n\r\n /**\r\n * Intersperses a '\\n' character into a list of strings and then concats it.\r\n * @function module:string.unlines\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n unlines = intercalate('\\n'),\r\n\r\n /**\r\n * Lower cases first character of a non-empty string.\r\n * @function module:string.lcaseFirst\r\n * @param xs {String}\r\n * @returns {string}\r\n * @throws {Error} - Throws error if receiving anything that is not a string.\r\n */\r\n lcaseFirst = xs => {\r\n _errorIfNotType(String, 'lcaseFirst', 'xs', xs);\r\n return xs[0].toLowerCase() + xs.substring(1);\r\n },\r\n\r\n /**\r\n * Upper cases first character of a non-empty string.\r\n * @function module:string.ucaseFirst\r\n * @param xs {String}\r\n * @returns {string}\r\n * @throws {Error} - Throws error if receiving anything that is not a string.\r\n */\r\n ucaseFirst = xs => {\r\n _errorIfNotType(String, 'ucaseFirst', 'xs', xs);\r\n return xs[0].toUpperCase() + xs.substring(1);\r\n },\r\n\r\n /**\r\n * Camel cases (class case) a string.\r\n * @function module:string.camelCase\r\n * @param xs {String}\r\n * @param [pattern=/[^a-z\\d/i]/] {RegExp} - Pattern to split on. Optional.\r\n * @throws {Error} - Throws error if param `xs` is not a string.\r\n * @returns {string}\r\n * @curried\r\n */\r\n camelCase = (xs, pattern = /[^a-z\\d]/i) => compose(\r\n join(''),\r\n map(str => ucaseFirst(str.toLowerCase())),\r\n filter(x => !!x),\r\n split(pattern)\r\n )(_errorIfNotType(String, 'camelCase', 'xs', xs)),\r\n\r\n /**\r\n * Class cases a string. Uses pattern /[^a-z\\d/i]/ to split on.\r\n * If you require a different pattern use `string.camelCase(str, pattern)`\r\n * and then upper case first character (`ucaseFirst`).\r\n * @function module:string.classCase\r\n * @param xs {String}\r\n * @returns {string}\r\n * @throws {Error} - Throws error if `xs` is not a string (via `camelCase` call).\r\n */\r\n classCase = compose(ucaseFirst, camelCase)\r\n\r\n;\r\n\r\n/**\r\n * Functional version of `String.prototype.split`.\r\n * @function module:string.split\r\n * @param separator {String|RegExp}\r\n * @param str {String}\r\n * @returns {Array}\r\n */\r\n","/**\r\n * @module fjl\r\n * @description Exports all module methods (object, list, string modules etc.).\r\n * @goal to include everything from haskell's Prelude where it makes sense in order to create\r\n * a subset of functions which can make the javascript developer more efficient and make his/her\r\n * code more concise (and functional).\r\n * @motivation preludejs, lodash/fp, RamdaJs, Haskell.\r\n * @see http://hackage.haskell.org/package/base-4.10.0.0/docs/Prelude.html\r\n * @see http://hackage.haskell.org/package/base-4.10.0.0/docs/Data-List.html\r\n */\r\nexport * from './object';\r\nexport * from './boolean';\r\nexport * from './function';\r\nexport * from './list';\r\nexport * from './string';\r\nexport * from './utils';\r\nexport * from './errorThrowing';\r\n"],"names":["returnCurried","executeArity","unmetArityNum","fn","argsToCurry","func","x","executeAsCurriedFunc","Array","from","arguments","a","b","c","d","e","args","unmetArity","concatedArgs","concat","canBeCalled","length","newExpectedArity","curryN","Function","Error","curry","curry2","curry3","curry4","curry5","fPureTakesOne","name","arg","f","fPureTakes2","arg1","arg2","fPureTakes3","arg3","fPureTakes4","arg4","fPureTakes5","arg5","fPureTakesOneOrMore","defineReverse","prototype","reverse","reduceRight","agg","item","push","map","filter","reduce","forEach","some","every","join","apply","call","flipN","flip","flip3","flip4","flip5","instanceOf","instanceConstructor","instance","hasOwnProperty","native","Object","getOwnPropertyNames","key","operation","keys","assign","obj0","objs","topAgg","obj","_Number","Number","_NaN","_Null","_Undefined","typeOf","value","retVal","undefined","constructorName","constructor","isNaN","_String","String","_Object","_Boolean","Boolean","_Function","_Array","_Symbol","_Map","_Set","_WeakMap","_WeakSet","toTypeRef","type","toTypeRefs","types","toTypeRefName","Type","ref","toTypeRefNames","isFunction","isType","isOfType","isClass","test","substr","isCallable","isArray","isObject","isBoolean","isNumber","isString","isMap","isSet","isWeakMap","isWeakSet","isUndefined","isNull","isSymbol","isUsableImmutablePrimitive","typeOfX","isset","isEmptyList","isEmptyObject","isEmptyCollection","size","isEmpty","isOneOf","typeName","isFunctor","lookup","of","copy","out","slice","Symbol","Promise","searchObj","nsString","indexOf","parts","split","limit","ind","parent","node","assignDeep","propDescription","getOwnPropertyDescriptor","get","set","writable","includes","xs","lastIndexOf","isTruthy","isFalsy","alwaysTrue","alwaysFalse","equal","equalAll","i","aggregateArray","sliceFrom","startInd","sliceTo","toInd","sliceCopy","genericAscOrdering","lengths","lists","toShortest","listLengths","smallLen","Math","min","list","reduceUntil","pred","op","result","reduceUntilRight","arr","lastIndex","len","findIndexWhere","predicateFulfilled","findIndexWhereRight","findIndicesWhere","findWhere","elm","objUnion","obj1","obj2","objIntersect","objDifference","objComplement","log","console","bind","error","peek","pop","jsonClone","JSON","parse","stringify","toAssocList","toAssocListDeep","TypeConstraint","fromAssocList","OutType","fromAssocListDeep","toArray","compose","arg0","id","negateF","negateF2","negateF3","negateFN","until","predicate","typeInstance","fnOrError","symbolName","noop","normalizeStep","to","step","range","append","listAppend","head","last","tail","init","uncons","unconsr","item0","concatMap","foldableOfA","intersperse","between","lastInd","intercalate","xss","transpose","numLists","ind2","longestListLen","maximum","outLists","outList","subsequences","listLen","pow","entry","j","swapped","ind1","tmp","permutations","repeat","foldl","foldr","foldl1","foldr1","mapAccumL","zero","mapped","tuple","mapAccumR","iterate","lastX","replicate","cycle","unfoldr","resultTuple","findIndex","findIndices","elemIndex","foundInd","elemIndices","take","drop","splitAt","takeWhile","dropWhile","splitPoint","dropWhileEnd","span","breakOnList","at","find","partition","elem","notElem","isPrefixOf","xs1","xs2","limit1","limit2","isSuffixOf","isInfixOf","foundLen","isSubsequenceOf","lenXs1","group","groupBy","equalityOp","prevItem","predOp","inits","tails","stripPrefix","prefix","zip","arr1","arr2","a1","a2","zipN","trimmedLists","zip3","arr3","zip4","arr4","zip5","arr5","zipWith","zipWithN","lenOfTrimmed","zipWith3","xs3","zipWith4","xs4","zipWith5","xs5","unzip","unzipN","lenItem0","any","p","all","and","or","not","sum","product","sortBy","minimum","scanl","scanl1","scanr","scanr1","nub","nubBy","remove","removeBy","sort","sortOn","valueFn","decorated","a0","b0","orderingFn","insert","foundIndex","insertBy","currItem","anyOp","storedItem","removeFirstsBy","unionBy","alreadyAdded","union","intersect","intersectBy","list1","list2","difference","array1","array2","complement","arr0","arrays","typeRefsToStringOrError","defaultErrorMessageCall","tmplContext","contextName","valueName","expectedTypeName","foundTypeName","messageSuffix","isMultiTypeNames","typesCopy","typesToMatchCopy","_getErrorIfNotTypeThrower","errorMessageCall","typeChecker","ValueType","_getErrorIfNotTypesThrower","valueTypes","expectedTypeNames","matchFound","_errorIfNotType","_errorIfNotTypes","getErrorIfNotTypeThrower","getErrorIfNotTypesThrower","errorIfNotType","errorIfNotTypes","lines","words","unwords","unlines","lcaseFirst","toLowerCase","substring","ucaseFirst","toUpperCase","camelCase","pattern","str","classCase"],"mappings":"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"} \ No newline at end of file +{"version":3,"file":"fjl.js","sources":["../../src/function/curry.js","../../src/utils.js","../../src/jsPlatform/array.js","../../src/jsPlatform/function.js","../../src/function/flip.js","../../src/jsPlatform/object.js","../../src/object/typeOf.js","../../src/object/is.js","../../src/object/lookup.js","../../src/object/of.js","../../src/object/copy.js","../../src/object/searchObj.js","../../src/object/assignDeep.js","../../src/jsPlatform/list.js","../../src/boolean.js","../../src/list/map.js","../../src/list/aggregation.js","../../src/list/utils.js","../../src/object/setTheory.js","../../src/object/console.js","../../src/object/jsonClone.js","../../src/object/assocList.js","../../src/object/toArray.js","../../src/object.js","../../src/function/compose.js","../../src/function/id.js","../../src/function/negate.js","../../src/function/until.js","../../src/function/fnOrError.js","../../src/function/noop.js","../../src/function.js","../../src/list/range.js","../../src/jsPlatform/string.js","../../src/jsPlatform.js","../../src/list.js","../../src/errorThrowing.js","../../src/string.js","../../src/fjl.js"],"sourcesContent":["/**\r\n * @author elydelacruz\r\n * @created 12/6/2016.\r\n * @memberOf function\r\n * @description \"Curry strict\" and \"curry arbitrarily\" functions (`curry`, `curryN`).\r\n */\r\n\r\n/**\r\n * @private\r\n * @type {string}\r\n */\r\nconst\r\n\r\n /**\r\n * Returns curried function.\r\n * @private\r\n * @param executeArity {Number}\r\n * @param unmetArityNum {Number}\r\n * @param fn {Function}\r\n * @param argsToCurry {...*}\r\n * @returns {Function} - Curried function.\r\n */\r\n returnCurried = (executeArity, unmetArityNum, fn, argsToCurry) => {\r\n switch (unmetArityNum) {\r\n case 1:\r\n /* eslint-disable */\r\n return function func(x) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 2:\r\n /* eslint-disable */\r\n return function func(a, b) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 3:\r\n /* eslint-disable */\r\n return function func(a, b, c) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 4:\r\n /* eslint-disable */\r\n return function func(a, b, c, d) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 5:\r\n /* eslint-disable */\r\n return function func(a, b, c, d, e) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n default:\r\n return (...args) => executeAsCurriedFunc(fn, executeArity, unmetArityNum, args, argsToCurry);\r\n }\r\n },\r\n\r\n /**\r\n * Returns curried function if unmetArity is not met else returns result of executing\r\n * final function.\r\n * @private\r\n * @param fn {Function}\r\n * @param executeArity {Number}\r\n * @param unmetArity {Number}\r\n * @param args {Array<*>}\r\n * @param argsToCurry {Array<*>}\r\n * @returns {Function|*} - Curried function or result of 'finally' executed function.\r\n */\r\n executeAsCurriedFunc = (fn, executeArity, unmetArity, args, argsToCurry) => {\r\n let concatedArgs = argsToCurry.concat(args),\r\n canBeCalled = (concatedArgs.length >= executeArity) || !executeArity,\r\n newExpectedArity = executeArity - concatedArgs.length;\r\n return !canBeCalled ?\r\n returnCurried(executeArity, newExpectedArity, fn, concatedArgs) :\r\n fn(...concatedArgs);\r\n }\r\n;\r\n\r\nexport const\r\n\r\n /**\r\n * Curries a function up to a given arity.\r\n * @function module:function.curryN\r\n * @param executeArity {Number}\r\n * @param fn {Function}\r\n * @param argsToCurry {...*}\r\n * @returns {Function}\r\n * @throws {Error} - When `fn` is not a function.\r\n */\r\n curryN = (executeArity, fn, ...argsToCurry) => {\r\n if (!fn || !(fn instanceof Function)) {\r\n throw new Error(`\\`curry*\\` functions expect first parameter to be of type \\`Function\\` though received ${fn}?`);\r\n }\r\n return returnCurried(executeArity, executeArity - argsToCurry.length, fn, argsToCurry);\r\n },\r\n\r\n /**\r\n * Curries a function based on it's defined arity (note: rest args param (`...rest`) are not counted in arity).\r\n * @function module:function.curry\r\n * @param fn {Function}\r\n * @param argsToCurry {...*}\r\n * @returns {Function}\r\n */\r\n curry = (fn, ...argsToCurry) => curryN((fn || {}).length, fn, ...argsToCurry),\r\n\r\n /**\r\n * Curries a function up to an arity of 2 (won't call function until 2 or more args).\r\n * @function module:function.curry2\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry2 = fn => curryN(2, fn),\r\n\r\n /**\r\n * Curries a function up to an arity of 3 (won't call function until 3 or more args).\r\n * @function module:function.curry3\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry3 = fn => curryN(3, fn),\r\n\r\n /**\r\n * Curries a function up to an arity of 4 (won't call function until 4 or more args).\r\n * @function module:function.curry4\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry4 = fn => curryN(4, fn),\r\n\r\n /**\r\n * Curries a function up to an arity of 5 (won't call function until 5 or more args).\r\n * @function module:function.curry5\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry5 = fn => curryN(5, fn);\r\n","/**\r\n * @module utils\r\n */\r\nimport {curry, curry2} from './function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a function that takes an argument and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakesOne\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakesOne = name => curry((arg, f) => f[name](arg)),\r\n\r\n /**\r\n * Returns a function that takes 2 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes2\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes2 = name => curry((arg1, arg2, f) => f[name](arg1, arg2)),\r\n\r\n /**\r\n * Returns a function that takes 3 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes3\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes3 = name => curry((arg1, arg2, arg3, f) => f[name](arg1, arg2, arg3)),\r\n\r\n /**\r\n * Returns a function that takes 4 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes4\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes4 = name => curry((arg1, arg2, arg3, arg4, f) => f[name](arg1, arg2, arg3, arg4)),\r\n\r\n /**\r\n * Returns a function that takes 5 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes5\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes5 = name => curry((arg1, arg2, arg3, arg4, arg5, f) => f[name](arg1, arg2, arg3, arg4, arg5)),\r\n\r\n /**\r\n * Returns a function that takes an object and one or more arguments on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakesOneOrMore\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakesOneOrMore = name => curry2((f, ...args) => f[name](...args))\r\n\r\n;\r\n","/**\r\n * Created by elyde on 7/20/2017.\r\n * Functional versions of common array methods (`map`, `filter`, etc.) (un-curried);\r\n * @module _jsPlatform_arrayOps\r\n * @private\r\n */\r\n\r\nimport {fPureTakesOne, fPureTakes2, fPureTakesOneOrMore} from '../utils';\r\n\r\nexport const\r\n\r\n /**\r\n * Array.prototype.reverse generator (generates a function that calls the prototype version or a\r\n * shimmed version if it doesn't exist).\r\n * @returns {Function}\r\n */\r\n defineReverse = () =>\r\n Array.prototype.reverse ? x => x.reverse() :\r\n x => x.reduceRight((agg, item) => {\r\n agg.push(item);\r\n return agg;\r\n }, []),\r\n\r\n /**\r\n * Maps a function to functor (list etc.).\r\n * @function module:_jsPlatform_array.map\r\n * @param fn {Function}\r\n * @param functor {Array|{map: {Function}}}\r\n * @returns {Array|{map: {Function}}}\r\n */\r\n map = fPureTakesOne('map'),\r\n\r\n /**\r\n * Filters a functor (list etc.) with passed in function.\r\n * @function module:_jsPlatform_array.filter\r\n * @param fn {Function}\r\n * @param functor {Array|{filter: {Function}}}\r\n * @returns {Array|{filter: {Function}}}\r\n */\r\n filter = fPureTakesOne('filter'),\r\n\r\n /**\r\n * Reduces a foldable (list etc.) with passed in function.\r\n * @function module:_jsPlatform_array.reduce\r\n * @param fn {Function}\r\n * @param functor {Array|{reduce: {Function}}}\r\n * @returns {Array|{reduce: {Function}}}\r\n */\r\n reduce = fPureTakes2('reduce'),\r\n\r\n /**\r\n * Reduces a foldable (list etc.) from the right with passed in function.\r\n * @function module:_jsPlatform_array.reduceRight\r\n * @param fn {Function}\r\n * @param functor {Array|{reduceRight: {Function}}}\r\n * @returns {Array|{reduceRight: {Function}}}\r\n */\r\n reduceRight = fPureTakes2('reduceRight'),\r\n\r\n /**\r\n * For each on functor (Array|Object|etc.).\r\n * @param fn {Function}\r\n * @param functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type of object you pass in unless it doesn't have a `forEach` method.\r\n * @throws {Error} - When passed in functor doesn't have a `forEach` method.\r\n */\r\n forEach = fPureTakesOne('forEach'),\r\n\r\n /**\r\n * Returns `true` if `fn` (predicate) returns true for at least one item\r\n * in functor else returns `false`.\r\n * @param fn {Function} - Predicate.\r\n * @param functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type passed.\r\n * @throws {Error} - When passed in object doesn't have a `some` method.\r\n */\r\n some = fPureTakesOne('some'),\r\n\r\n /**\r\n * Returns `true` if `fn` (predicate) returns true for all items in functor else returns `false`.\r\n * @param fn {Function} - Predicate.\r\n * @param functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type passed.\r\n * @throws {Error} - When passed in object doesn't have an `every` method.\r\n */\r\n every = fPureTakesOne('every'),\r\n\r\n /**\r\n * Array.prototype.join\r\n * @function module:listPrelude.join\r\n * @param separator {String|RegExp}\r\n * @param arr {Array}\r\n * @returns {String}\r\n */\r\n join = fPureTakesOne('join'),\r\n\r\n /**\r\n * Same as Array.prototype.push\r\n * @param item {*}\r\n * @param arr {Array}\r\n * @returns {Number}\r\n */\r\n push = fPureTakesOneOrMore('push'),\r\n\r\n /**\r\n * Reverses an list (shimmed if not exists).\r\n * @function module:listPrelude.reverse\r\n * @return {Array}\r\n */\r\n reverse = defineReverse();\r\n","import {curry, curry2} from '../function/curry';\r\n\r\n/**\r\n * Created by elydelacruz on 9/7/2017.\r\n * @memberOf function\r\n */\r\nexport const\r\n\r\n /**\r\n * Functional `apply` function (takes no context).\r\n * @function module:function.apply\r\n * @param fn {Function}\r\n * @param args {Array|*}\r\n * @returns {*}\r\n */\r\n apply = curry((fn, args) => fn.apply(null, args)),\r\n\r\n /**\r\n * Functional `call` function (takes no context).\r\n * @function module:function.call\r\n * @param fn {Function}\r\n * @param args {...*}\r\n * @returns {*}\r\n */\r\n call = curry2((fn, ...args) => fn.call(null, ...args));\r\n","import {reverse} from '../jsPlatform/array';\r\nimport {apply, call} from '../jsPlatform/function';\r\nimport {curry, curry2} from './curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a curried function requiring given functions arguments in reverse\r\n * (returned function expects 2 or more variables (curried at 2 or more args)).\r\n * @function module:function.flipN\r\n * @param fn {Function}\r\n * @returns {Function}\r\n * @curried\r\n */\r\n flipN = fn => curry2((...args) => apply(fn, reverse(args))),\r\n\r\n /**\r\n * Flips a function's first and second arguments and and returns a new function requiring said arguments in reverse.\r\n * @function module:function.flip\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip = fn => curry((b, a) => call(fn, a, b)),\r\n\r\n /**\r\n * Same as `flip` except returns a flipped function of arity 3.\r\n * @function module:function.flip3\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip3 = fn => curry((c, b, a) => call(fn, a, b, c)),\r\n\r\n /**\r\n * Same as `flip` except returns a flipped function of arity 4.\r\n * @function module:function.flip4\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip4 = fn => curry((d, c, b, a) => call(fn, a, b, c, d)),\r\n\r\n /**\r\n * Same as `flip` except returns a flipped function of arity 5.\r\n * @function module:function.flip5\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip5 = fn => curry((e, d, c, b, a) => call(fn, a, b, c, d, e));\r\n","/**\r\n * @memberOf object\r\n * @description Defines some of the platform methods for objects (the ones used within `fjl`).\r\n */\r\n\r\nimport {fPureTakesOne} from '../utils';\r\nimport {curry, curry2} from '../function/curry';\r\nimport {flip, flip3, flip4, flip5} from '../function/flip';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns whether constructor has derived object.\r\n * @function module:object.instanceOf\r\n * @param instanceConstructor {Function} - Constructor.\r\n * @param instance {*}\r\n * @instance {*}\r\n * @returns {Boolean}\r\n */\r\n instanceOf = curry((instanceConstructor, instance) =>\r\n instance instanceof instanceConstructor),\r\n\r\n /**\r\n * @function module:object.hasOwnProperty\r\n * @param propName {*}\r\n * @param typeInstance {*}\r\n * @returns {Boolean}\r\n * @deprecated - Use property directly instead.\r\n */\r\n hasOwnProperty = fPureTakesOne('hasOwnProperty'),\r\n\r\n /**\r\n * @function module:object.length\r\n * @param x {*}\r\n * @returns {Number}\r\n * @throws {Error} - Throws an error if value doesn't have a `length` property (\r\n * `null`, `undefined`, {Boolean}, Symbol, et. al.).\r\n */\r\n length = x => x.length,\r\n\r\n /**\r\n * Contains all the static functions from `Object` but curried and flipped;\r\n * @example\r\n * // E.g., `Object.defineProperties(obj, descriptor)` can now be used like\r\n * import {defineProperties} from 'fjl'\r\n * defineProperties(descriptor, someObj),\r\n * // Et. al.\r\n * @memberOf module:object\r\n * @type {{...Object}}\r\n */\r\n native = Object.getOwnPropertyNames(Object).reduce((agg, key) => {\r\n if (typeof Object[key] !== 'function') {\r\n return agg;\r\n }\r\n const operation = Object[key];\r\n switch (operation.length) {\r\n case 2:\r\n agg[key] = flip(operation);\r\n break;\r\n case 3:\r\n agg[key] = flip3(operation);\r\n break;\r\n case 4:\r\n agg[key] = flip4(operation);\r\n break;\r\n case 5:\r\n agg[key] = flip5(operation);\r\n break;\r\n default:\r\n agg[key] = Object[key];\r\n break;\r\n }\r\n return agg;\r\n }, {}),\r\n\r\n /**\r\n * Gets passed in object's own enumerable keys (same as `Object.keys`).\r\n * @function module:object.keys\r\n * @param obj {*}\r\n * @returns {Array}\r\n */\r\n {keys} = native,\r\n\r\n /**\r\n * Defined as `Object.assign` else is the same thing but shimmed.\r\n * @function module:object.assign\r\n * @param obj0 {Object}\r\n * @param objs {...{Object}}\r\n * @returns {Object}\r\n */\r\n assign = (() => Object.assign ?\r\n (obj0, ...objs) => Object.assign(obj0, ...objs) :\r\n curry2((obj0, ...objs) => objs.reduce((topAgg, obj) => {\r\n return Object.keys(obj).reduce((agg, key) => {\r\n agg[key] = obj[key];\r\n return agg;\r\n }, topAgg);\r\n }, obj0))\r\n )();\r\n","/**\r\n * Created by elyde on 12/18/2016.\r\n * @memberOf object\r\n */\r\nconst _Number = Number.name,\r\n _NaN = 'NaN',\r\n _Null = 'Null',\r\n _Undefined = 'Undefined';\r\n\r\n/**\r\n * Returns the constructor/class/type name of a value.\r\n * @note Returns 'NaN' if value is of type `Number` and value is `isNaN`.\r\n * @note Returns 'Undefined' if value is `undefined`\r\n * @note Returns 'Null' if value is `null`\r\n * For values that have no concrete constructors and/or casters\r\n * (null, NaN, and undefined) we returned normalized names for them ('Null', 'NaN', 'Number')\r\n * @function module:object.typeOf\r\n * @param value {*}\r\n * @returns {string} - Constructor's name or derived name (in the case of `null`, `undefined`, or `NaN` (whose\r\n * normalized names are 'Null', 'Undefined', 'NaN' respectively).\r\n */\r\nexport function typeOf (value) {\r\n let retVal;\r\n if (value === undefined) {\r\n retVal = _Undefined;\r\n }\r\n else if (value === null) {\r\n retVal = _Null;\r\n }\r\n else {\r\n let constructorName = (value).constructor.name;\r\n retVal = constructorName === _Number && isNaN(value) ?\r\n _NaN : constructorName;\r\n }\r\n return retVal;\r\n}\r\n","/**\r\n * Created by elyde on 12/18/2016.\r\n * @memberOf object\r\n */\r\n\r\nimport {typeOf} from './typeOf';\r\nimport {instanceOf, length, keys} from '../jsPlatform/object';\r\nimport {curry} from '../function/curry';\r\n\r\nlet _String = String.name,\r\n _Number = Number.name,\r\n _Object = Object.name,\r\n _Boolean = Boolean.name,\r\n _Function = Function.name,\r\n _Array = Array.name,\r\n _Symbol = 'Symbol',\r\n _Map = 'Map',\r\n _Set = 'Set',\r\n _WeakMap = 'WeakMap',\r\n _WeakSet = 'WeakSet',\r\n _Null = 'Null',\r\n _Undefined = 'Undefined',\r\n _NaN = 'NaN';\r\n\r\nexport const\r\n\r\n /**\r\n * Resolves/normalizes a type name from either a string or a constructor.\r\n * @function module:object.toTypeRef\r\n * @param type {Function|String} - String or function representing a type.\r\n * @returns {String}\r\n * @todo write tests for this function.\r\n */\r\n toTypeRef = type => {\r\n if (!type) {\r\n return typeOf(type);\r\n }\r\n else if (type.constructor === String || (type instanceof Function)) {\r\n return type;\r\n }\r\n return typeOf(type);\r\n },\r\n\r\n /**\r\n * Returns an array of type refs from possible type refs (converts null, undefined, NaN, and other values into\r\n * type refs (either constructor name or constructor name based on whether value(s) is a string, a constructor, or not).\r\n * @function module:object.toTypeRefs\r\n * @param types {...(TypeRef|*)}\r\n * @returns {Array}\r\n * @todo Ensure tests are written for this function.\r\n */\r\n toTypeRefs = (...types) => types.map(toTypeRef),\r\n\r\n /**\r\n * Returns possible Type's TypeRef name.\r\n * @function module:object.toTypeRefName\r\n * @param Type {(TypeRef|*)}\r\n * @returns {String}\r\n * @todo Ensure tests are written for this function.\r\n */\r\n toTypeRefName = Type => {\r\n const ref = toTypeRef(Type);\r\n return ref instanceof Function ? ref.name : ref;\r\n },\r\n\r\n /**\r\n * Returns possible Types' TypeRef names.\r\n * @function module:object.toTypeRefNames\r\n * @param types {...(TypeRef|*)}\r\n * @returns {String[]}\r\n * @todo Ensure tests are written for this function.\r\n */\r\n toTypeRefNames = (...types) => types.map(toTypeRefName),\r\n\r\n /**\r\n * Returns whether a value is a function or not.\r\n * @function module:object.isFunction\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isFunction = instanceOf(Function),\r\n\r\n /**\r\n * Strict type checker. Checks if given value is a direct instance of given type; E.g.,\r\n * @example\r\n * isType(String, 'abcdefg') === true // true\r\n * isType(String.name, 'abcdefg') === true\r\n * isType(Number, NaN) === false\r\n * isType(Number, 99) === true\r\n * isType('Null', 99) === false // though, for `null` and `undefined` checks\r\n * // @see `isset`, in this module, instead\r\n * isType('Undefined', undefined) === true // true\r\n *\r\n * @note Useful where absolute types, or some semblance thereof, are required.\r\n * @function module:object.isType\r\n * @param type {Function|ObjectConstructor|String} - Constructor or constructor name\r\n * @param obj {*}\r\n * @return {Boolean}\r\n */\r\n isType = curry((type, obj) => typeOf(obj) === toTypeRefName(type)),\r\n\r\n /**\r\n * Loose type checker; E.g., If `type` is not a constructor, but a constructor name, does a type check on\r\n * constructor names, else if first check fails and `type` is a constructor, performs an `instanceof` check\r\n * on value with constructor.\r\n * @note Use care when checking for `Array` and/or `Object` since the both are considered objects by `instanceof` checker.\r\n * @note For `null` and `undefined` their class cased names can be used for type checks\r\n * `isOfType('Null', null) === true (passes strict type check)` (or better yet `isset` can be used).\r\n * @throwsafe - Doesn't throw on `null` or `undefined` `obj` values.\r\n * @example\r\n * isOfType(Number, 99) === true // true (passes strict type check (numbers are not instances of `Number`\r\n * // constructor)\r\n * isOfType('Number', 99) === true // true (passes strict type check)\r\n * isOfType(Number, NaN) === true // true. (passes instance of check)\r\n * // If you want \"true\" strict type checking use `isType`\r\n * isOfType(Object, []) === true // true (passes instance of check)\r\n * isOfType(Array, []) === true // true (passes instance of check)\r\n * isOfType(Object, {}) === true // true (passes instance of check)\r\n * isOfType(Object.name, {}) === true // true (Passes strict type check)\r\n * class Abc extends String {}\r\n * isOfType(String, new Abc('abcd')) // true (passes instanceof check)\r\n *\r\n * @function module:object.isOfType\r\n * @param type {Function|String} - Type reference (constructor or `constructor.name`).\r\n * @param x {*} - Value to check.\r\n * @returns {Boolean}\r\n */\r\n isOfType = curry((type, x) => isType(type, x) || instanceOf(type, x)),\r\n\r\n /**\r\n * Checks if `value` is an es2015 `class`.\r\n * @function module:object.isClass\r\n * @param x {*}\r\n * @returns {boolean}\r\n */\r\n isClass = x => x && /^\\s{0,3}class\\s{1,3}/.test((x + '').substr(0, 10)),\r\n\r\n /**\r\n * Returns a boolean depicting whether a value is callable or not.\r\n * @function module:object.isCallable\r\n * @tentative\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isCallable = x => isFunction(x) && !isClass(x),\r\n\r\n /**\r\n * Checks if value is an array (same as `Array.isArray`).\r\n * @function module:object.isArray\r\n * @param value {*}\r\n * @returns {boolean}\r\n */\r\n {isArray} = Array,\r\n\r\n /**\r\n * Checks whether value is an object or not.\r\n * @function module:object.isObject\r\n * @param value\r\n * @returns {Boolean}\r\n */\r\n isObject = isType(_Object),\r\n\r\n /**\r\n * Checks if value is a boolean.\r\n * @function module:object.isBoolean\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isBoolean = isType(_Boolean),\r\n\r\n /**\r\n * Checks if value is a valid number (also checks if isNaN so that you don't have to).\r\n * @function module:object.isNumber\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isNumber = isType(_Number),\r\n\r\n /**\r\n * Checks whether value is a string or not.\r\n * @function module:object.isString\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isString = isType(_String),\r\n\r\n /**\r\n * Checks whether value is of `Map` or not.\r\n * @function module:object.isMap\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isMap = isType(_Map),\r\n\r\n /**\r\n * Checks whether value is of `Set` or not.\r\n * @function module:object.isSet\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isSet = isType(_Set),\r\n\r\n /**\r\n * Checks whether value is of `WeakMap` or not.\r\n * @function module:object.isWeakMap\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isWeakMap =isType(_WeakMap),\r\n\r\n /**\r\n * Checks whether value is of `WeakSet` or not.\r\n * @function module:object.isWeakSet\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isWeakSet = isType(_WeakSet),\r\n\r\n /**\r\n * Checks if value is undefined.\r\n * @function module:object.isUndefined\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isUndefined = isType(_Undefined),\r\n\r\n /**\r\n * Checks if value is null.\r\n * @function module:object.isNull\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isNull = isType(_Null),\r\n\r\n /**\r\n * Checks if value is a `Symbol`.\r\n * @function module:object.isSymbol\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isSymbol = isType(_Symbol),\r\n\r\n /**\r\n * Checks if given `x` is set and of one of\r\n * [String, Boolean, Number, Symbol] (null and undefined are immutable\r\n * but are not \"usable\" (usually not what we want to operate on).\r\n * @function module:object.isUsableImmutablePrimitive\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isUsableImmutablePrimitive = x => {\r\n const typeOfX = typeOf(x);\r\n return isset(x) &&\r\n [_String, _Number, _Boolean, _Symbol]\r\n .some(Type => Type === typeOfX);\r\n },\r\n\r\n /**\r\n * Checks if !length.\r\n * @function module:object.isEmptyList\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isEmptyList = x => !length(x),\r\n\r\n /**\r\n * Checks if object has own properties/enumerable-props or not.\r\n * @function module:object.isEmptyObject\r\n * @param obj {*}\r\n * @returns {Boolean}\r\n */\r\n isEmptyObject = obj => isEmptyList(keys(obj)),\r\n\r\n /**\r\n * Checks if collection is empty or not (Map, WeakMap, WeakSet, Set etc.).\r\n * @function module:object.isEmptyCollection\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isEmptyCollection = x => x.size === 0,\r\n\r\n /**\r\n * Checks to see if passed in value is empty; I.e.,\r\n * check for one of '', 0, `null`, `undefined`, `false`, empty array, empty object, empty function (zero arity),\r\n * or empty collection (es6 Map, Set, WeakMap, or WeakSet etc. (`!value.size`);\r\n * @function module:object.isEmpty\r\n * @param value {*} - Value to check.\r\n * @returns {Boolean}\r\n */\r\n isEmpty = value => {\r\n if (!value) { // if '', 0, `null`, `undefined`, or `false` then is empty\r\n return true;\r\n }\r\n switch (typeOf(value)) {\r\n case _Array:\r\n case _Function:\r\n return !value.length;\r\n case _Number: // zero and NaN checks happened above so `if number` then it's 'not-an-empty-number' (lol)\r\n return false;\r\n case _Object:\r\n return !keys(value).length;\r\n case _Map:\r\n case _Set:\r\n case _WeakSet:\r\n case _WeakMap:\r\n return !value.size;\r\n case _NaN:\r\n return true;\r\n default:\r\n return !value;\r\n }\r\n },\r\n\r\n /**\r\n * Returns whether passed in values is defined and not null or not.\r\n * @function module:object.isset\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isset = x => x !== null && x !== undefined,\r\n\r\n /**\r\n * Checks to see if `x` is of one of the given type refs.\r\n * @function object.isOneOf\r\n * @param x {*}\r\n * @param types {...(TypeRef|*)}\r\n * @returns {boolean}\r\n * @todo write tests for this function.\r\n */\r\n isOneOf = (x, ...types) => {\r\n const typeName = typeOf(x);\r\n return toTypeRefNames(types).some(name => typeName === name);\r\n },\r\n\r\n isFunctor = x => x && x.map && instanceOf(Function, x.map)\r\n\r\n;\r\n","/**\r\n * @memberOf object\r\n */\r\n\r\nimport {isset} from './is';\r\nimport {curry} from '../function/curry';\r\n\r\n/**\r\n * Looks up property and returns it's value; Else `undefined`.\r\n * Method is null safe (will not throw on `null` or `undefined`).\r\n * @function module:object.lookup\r\n * @param key {String} - Key to search on `obj`\r\n * @param obj {Object} - Object to search `name` on.\r\n * @returns {*}\r\n */\r\nexport const lookup = curry((key, obj) => isset(obj) ? obj[key] : undefined);\r\n","import {isFunction, isset, isUsableImmutablePrimitive} from './is';\r\nimport {apply} from '../jsPlatform/function';\r\n\r\n/**\r\n * Creates a value `of` given type; Checks for one of the following construction strategies (in order listed):\r\n * @example\r\n * // - If exists `(value).constructor.of` uses this.\r\n * // - If value is of one String, Boolean, Symbol, or Number types calls it's\r\n * // constructor as a function (in cast form; E.g., `constructor(...args)` )\r\n * // - Else if constructor is a function, thus far, then calls constructor using\r\n * // the `new` keyword (with any passed in args).\r\n\r\n * @function module:object.of\r\n * @param x {*} - Value to derive returned value's type from.\r\n * @param [args] {...*} - Any args to pass in to matched construction strategy.\r\n * @returns {*|undefined} - New value of given value's type else `undefined`.\r\n */\r\nexport const of = (x, ...args) => {\r\n if (!isset(x)) { return undefined; }\r\n const constructor = x.constructor;\r\n if (constructor.hasOwnProperty('of')) {\r\n return apply(constructor.of, args);\r\n }\r\n else if (isUsableImmutablePrimitive(x)) {\r\n return apply(constructor, args);\r\n }\r\n else if (isFunction(constructor)) {\r\n return new constructor(...args);\r\n }\r\n return undefined;\r\n};\r\n","import {typeOf} from './typeOf';\r\nimport {of} from './of';\r\n\r\nexport const\r\n\r\n /**\r\n * Make a copy of a value or optionally copy incoming value onto an outgoing value (second parameter).\r\n * @note If incoming thing is an immmutable primitive (string, number, symbol, null, undefined, boolean)\r\n * it is returned as is.\r\n * @function module:object.copy\r\n * @param x {*} - Thing to copy.\r\n * @param [out = undefined] {*} - Optional value to copy on to. Not required.\r\n * @returns {*} - Copied thing or optionally outgoing value copied onto.\r\n */\r\n copy = (x, out) => {\r\n // if `null`, `undefined`, `''`, `0`, `false` return\r\n if (!x) { return x; }\r\n switch (typeOf(x)) {\r\n case Array.name:\r\n return !out ? x.slice(0) : Object.assign(out, x);\r\n\r\n // If immutable primitive, return it\r\n case Symbol.name:\r\n case Boolean.name:\r\n case String.name:\r\n case Number.name:\r\n case Promise.name:\r\n case Function.name:\r\n case 'NaN':\r\n case 'Null':\r\n case 'Undefined':\r\n return x;\r\n\r\n case 'Map':\r\n case 'Set':\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n return new x.constructor(Array.from(x));\r\n\r\n // Else make copy\r\n default:\r\n return Object.assign(!out ? of(x) : out, x);\r\n }\r\n }\r\n;\r\n\r\nexport default copy;\r\n","import {isset} from './is';\r\nimport {curry} from '../function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Gives you value at key/namespace-key within `obj`; E.g.,\r\n * searchObj('all.your.base', {all: {your: {base: 99}}}) === 99 // `true`\r\n * @note If key is unreachable (undefined) returns `undefined`.\r\n * Useful in cases where we do not want to check each key along the way before getting/checking value; E.g.,\r\n * @example\r\n * ```\r\n * if (obj && obj.all && obj.all.your && obj.all.your.base) {\r\n * // Thing we want to do\r\n * }\r\n *\r\n * // So with our function becomes\r\n * if (searchObj('all.your.base', obj)) {\r\n * // Thing we want to do\r\n * }\r\n * ```\r\n * @function module:object.searchObj\r\n * @param nsString {String}\r\n * @param obj {*}\r\n * @returns {*}\r\n */\r\n searchObj = curry((nsString, obj) => {\r\n if (!obj) { return obj; }\r\n if (nsString.indexOf('.') === -1) {\r\n return obj[nsString];\r\n }\r\n const parts = nsString.split('.'),\r\n limit = parts.length;\r\n let ind = 0,\r\n parent = obj;\r\n for (; ind < limit; ind += 1) {\r\n const node = parent[parts[ind]];\r\n if (!isset(node)) {\r\n return node;\r\n }\r\n parent = node;\r\n }\r\n return parent;\r\n })\r\n;\r\n","\r\nimport {isObject} from './is';\r\nimport {keys} from '../jsPlatform/object';\r\nimport {curry2} from '../function/curry';\r\n\r\nexport const\r\n /**\r\n * Merges all objects down into one (takes two or more args).\r\n * @function module:object.assignDeep\r\n * @param obj0 {Object}\r\n * @param [objs] {...{Object}} - One or more objects to merge onto `obj0`.\r\n * @returns {Object}\r\n */\r\n assignDeep = curry2((obj0, ...objs) =>\r\n !obj0 ? obj0 : objs.reduce((topAgg, obj) =>\r\n !obj ? topAgg : keys(obj).reduce((agg, key) => {\r\n let propDescription = Object.getOwnPropertyDescriptor(agg, key);\r\n // If property is not writable move to next item in collection\r\n if (agg.hasOwnProperty(key) && propDescription &&\r\n !(propDescription.get && propDescription.set) &&\r\n !propDescription.writable) {\r\n return agg;\r\n }\r\n if (isObject(agg[key]) && isObject(obj[key])) {\r\n assignDeep(agg[key], obj[key]);\r\n }\r\n else { agg[key] = obj[key]; }\r\n return agg;\r\n }, topAgg)\r\n , obj0));\r\n","/**\r\n * List operations that overlap (apart from globally overlapping props and functions like `length`)\r\n * on both strings and arrays.\r\n * @memberOf list\r\n */\r\n\r\nimport {fPureTakesOne, fPureTakes2, fPureTakesOneOrMore} from '../utils';\r\n\r\nexport const\r\n\r\n /**\r\n * Concats/appends all functors onto the end of first functor.\r\n * Note: functors passed in after the first one must be of the same type.\r\n * @function module:list.concat\r\n * @param functor {Array|Object|*}\r\n * @param ...functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type passed.\r\n * @throws {Error} - When passed in object doesn't have an `every` method.\r\n */\r\n concat = fPureTakesOneOrMore('concat'),\r\n\r\n /**\r\n * Same as Array.prototype.slice\r\n * @function module:list.slice\r\n * @param separator {String|RegExp}\r\n * @param arr{Array}\r\n * @returns {Array}\r\n */\r\n slice = fPureTakes2('slice'),\r\n\r\n /**\r\n * `Array.prototype.includes` or shim.\r\n * @function module:list.includes\r\n * @param value {*}\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n includes = (() => 'includes' in Array.prototype ?\r\n fPureTakesOne('includes') :\r\n (value, xs) => xs.indexOf(value) > -1)(),\r\n\r\n /**\r\n * Searches list/list-like for given element `x`.\r\n * @function module:list.indexOf\r\n * @param x {*} - Element to search for.\r\n * @param xs {Array|String|*} - list or list like to look in.\r\n * @returns {Number} - `-1` if element not found else index at which it is found.\r\n */\r\n indexOf = fPureTakesOne('indexOf'),\r\n\r\n /**\r\n * Last index of (`Array.prototype.lastIndexOf`).\r\n * @function module:list.lastIndexOf\r\n * @param x {*} - Element to search for.\r\n * @param xs {Array|String|*} - list or list like to look in.\r\n * @returns {Number} - `-1` if element not found else index at which it is found.\r\n */\r\n lastIndexOf = fPureTakesOne('lastIndexOf')\r\n\r\n;\r\n","/**\r\n * @module boolean\r\n * @description Contains functional version of 'always-true', 'always-false', 'is-truthy', and 'is-falsy'.\r\n */\r\nimport {curry, curry2} from './function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns whether `value` is 'truthy' or not\r\n * @function module:boolean.isTruthy\r\n * @param value\r\n * @returns {Boolean}\r\n */\r\n isTruthy = value => !!value,\r\n\r\n /**\r\n * Returns whether `value` is 'falsy' or not\r\n * @function module:boolean.isFalsy\r\n * @param value\r\n * @returns {Boolean}\r\n */\r\n isFalsy = value => !value,\r\n\r\n /**\r\n * Returns `true`.\r\n * @function module:boolean.alwaysTrue\r\n * @returns {Boolean}\r\n */\r\n alwaysTrue = () => true,\r\n\r\n /**\r\n * Returns `false`.\r\n * @function module:boolean.alwaysFalse\r\n * @returns {Boolean}\r\n */\r\n alwaysFalse = () => false,\r\n\r\n /**\r\n * Equality operator.\r\n * @function module:boolean.equal\r\n * @param a {*}\r\n * @param b {*}\r\n * @returns {boolean}\r\n */\r\n equal = curry((a, b) => a === b),\r\n\r\n /**\r\n * Equality operator for all.\r\n * @function module:boolean.equalAll\r\n * @param a {*} - Item `0`.\r\n * @param args {...*} - Others\r\n * @returns {boolean}\r\n */\r\n equalAll = curry2((a, ...args) => args.every(b => equal(a, b)))\r\n\r\n;\r\n","import {length} from '../jsPlatform/object';\r\nimport {curry} from '../function/curry';\r\nimport {typeOf} from '../object/typeOf';\r\nimport {of} from '../object/of';\r\nimport {isFunctor, isset} from '../object/is';\r\n\r\n/**\r\n * Maps a function onto a List (string or array) or a functor (value containing a map method).\r\n * @function module:list.map\r\n * @param fn {Function} - Function to map on given value.\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\nconst map = curry((fn, xs) => {\r\n if (!isset(xs)) { return xs; }\r\n let out = of(xs),\r\n limit,\r\n i = 0;\r\n switch (typeOf(xs)) {\r\n case 'Array':\r\n limit = length(xs);\r\n if (!limit) { return out; }\r\n for (; i < limit; i += 1) {\r\n out.push(fn(xs[i], i, xs));\r\n }\r\n return out;\r\n case 'String':\r\n limit = length(xs);\r\n if (!xs) { return out; }\r\n for (; i < limit; i += 1) {\r\n out += fn(xs[i], i, xs);\r\n }\r\n return out;\r\n default:\r\n if (isFunctor(xs)) { return xs.map(fn); }\r\n\r\n // Other objects\r\n return Object.keys(xs).reduce((agg, key) => {\r\n out[key] = fn(xs[key], key, xs);\r\n return out;\r\n }, out);\r\n }\r\n});\r\n\r\nexport default map;\r\n","\r\nexport const\r\n\r\n /**\r\n * Pushes incoming `item` onto given array and returns said array.\r\n * @private\r\n * @param agg {Array}\r\n * @param item {*}\r\n * @returns {Array}\r\n */\r\n aggregateArray = (agg, item) => {\r\n agg.push(item);\r\n return agg;\r\n }\r\n\r\n;\r\n","/**\r\n * List operator utils module.\r\n * @module listUtils\r\n */\r\nimport {apply} from '../jsPlatform/function'; // un-curried version\r\nimport {slice} from '../jsPlatform/list'; // un-curried version good for both strings and arrays\r\nimport {length} from '../jsPlatform/object';\r\nimport {alwaysFalse} from '../boolean';\r\nimport map from './map';\r\nimport {curry, curry2} from '../function/curry';\r\n\r\nexport * from './aggregation';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a slice of the given list from `startInd` to the end of the list.\r\n * @function module:listUtils.sliceFrom\r\n * @param startInd {Number}\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sliceFrom = curry((startInd, xs) => slice(startInd, undefined, xs)),\r\n\r\n /**\r\n * Slices from index `0` to given index.\r\n * @function module:listUtils.sliceTo\r\n * @param toInd {Number}\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sliceTo = curry((toInd, xs) => slice(0, toInd, xs)),\r\n\r\n /**\r\n * Slices a copy of list.\r\n * @function listUtils.sliceCopy\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sliceCopy = sliceFrom(0),\r\n\r\n /**\r\n * Generic 'ascending order' ordering function (use by the likes of `list.sort` etc.)\r\n * @function module:listUtils.genericAscOrdering\r\n * @param a {*}\r\n * @param b {*}\r\n * @returns {number}\r\n */\r\n genericAscOrdering = curry((a, b) => {\r\n if (a > b) { return 1; }\r\n else if (a < b) { return -1; }\r\n return 0;\r\n }),\r\n\r\n /**\r\n * Returns length of all passed lists in list.\r\n * @function module:listUtils.lengths\r\n * @param lists ...{Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n lengths = curry2((...lists) => map(length, lists)),\r\n\r\n /**\r\n * Returns a list of lists trimmed to the shortest length in given list of lists. @background This method is used by the `zip*` functions to achieve their\r\n * 'slice to smallest' functionality.\r\n * @function module:listUtils.toShortest\r\n * @param lists {...(Array|String|*)}\r\n * @returns {Array|String|*}\r\n */\r\n toShortest = curry2((...lists) => {\r\n const listLengths = apply(lengths, lists),\r\n smallLen = Math.min.apply(Math, listLengths);\r\n return map((list, ind) => listLengths[ind] > smallLen ?\r\n sliceTo(smallLen, list) : sliceCopy(list), lists);\r\n }),\r\n\r\n /**\r\n * Reduces until predicate.\r\n * @function module:listUtils.reduceUntil\r\n * @param pred {Function} - `(item, index, list) => Boolean(...)`\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduceUntil = curry((pred, op, agg, xs) => {\r\n const limit = length(xs);\r\n if (!limit) { return agg; }\r\n let ind = 0,\r\n result = agg;\r\n for (; ind < limit; ind++) {\r\n if (pred(xs[ind], ind, xs)) { break; }\r\n result = op(result, xs[ind], ind, xs);\r\n }\r\n return result;\r\n }),\r\n\r\n /**\r\n * Reduces until predicate (from right to left).\r\n * @function module:listUtils.reduceUntilRight\r\n * @param pred {Function} - `(item, index, list) => Boolean(...)`\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduceUntilRight = curry((pred, op, agg, arr) => {\r\n const limit = length(arr);\r\n if (!limit) { return agg; }\r\n let ind = limit - 1,\r\n result = agg;\r\n for (; ind >= 0; ind--) {\r\n if (pred(arr[ind], ind, arr)) { break; }\r\n result = op(result, arr[ind], ind, arr);\r\n }\r\n return result;\r\n }),\r\n\r\n /**\r\n * Reduces a list with given operation (`op`) function.\r\n * @function module:listUtils.reduce\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduce = reduceUntil(alwaysFalse),\r\n\r\n /**\r\n * Reduces a list with given operation (`op`) function (from right-to-left).\r\n * @function module:listUtils.reduceRight\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduceRight = reduceUntilRight(alwaysFalse),\r\n\r\n /**\r\n * Gets last index of a list/list-like (Array|String|Function etc.).\r\n * @function module:listUtils.lastIndex\r\n * @param x {Array|String|*} - list like or list.\r\n * @returns {Number} - `-1` if no element found.\r\n */\r\n lastIndex = x => { const len = length(x); return len ? len - 1 : 0; },\r\n\r\n /**\r\n * Finds index in string or list.\r\n * @function module:listUtils.findIndexWhere\r\n * @param pred {Function} - Predicate.\r\n * @param arr {Array|String}\r\n * @returns {Number} - `-1` if predicate not matched else `index` found\r\n */\r\n findIndexWhere = curry((pred, arr) => {\r\n let ind = 0;\r\n const limit = length(arr);\r\n for (; ind < limit; ind += 1) {\r\n const predicateFulfilled = !!pred(arr[ind], ind, arr);\r\n if (predicateFulfilled) {\r\n return ind;\r\n }\r\n }\r\n return -1;\r\n }),\r\n\r\n /**\r\n * Finds index in list from right to left.\r\n * @function module:listUtils.findIndexWhereRight\r\n * @param pred {Function} - Predicate.\r\n * @param arr {Array|String}\r\n * @returns {Number} - `-1` if predicate not matched else `index` found\r\n */\r\n findIndexWhereRight = curry((pred, arr) => {\r\n let ind = length(arr) - 1;\r\n for (; ind >= 0; ind -= 1) {\r\n const predicateFulfilled = !!pred(arr[ind], ind, arr);\r\n if (predicateFulfilled) {\r\n return ind;\r\n }\r\n }\r\n return -1;\r\n }),\r\n\r\n /**\r\n * @function module:listUtils.findIndicesWhere\r\n * @param pred {Function}\r\n * @param xs {Array|String|*} - list or list like.\r\n * @returns {Array|undefined}\r\n */\r\n findIndicesWhere = curry((pred, xs) => {\r\n const limit = length(xs);\r\n let ind = 0,\r\n out = [];\r\n for (; ind < limit; ind++) {\r\n if (pred(xs[ind], ind, xs)) { out.push(ind); }\r\n }\r\n return out.length ? out : undefined;\r\n }),\r\n\r\n /**\r\n * @function module:listUtils.findWhere\r\n * @param pred {Function}\r\n * @param xs {Array|String|*} - list or list like.\r\n * @returns {*}\r\n */\r\n findWhere = curry((pred, xs) => {\r\n let ind = 0,\r\n limit = length(xs);\r\n if (!limit) { return; }\r\n for (; ind < limit; ind++) {\r\n let elm = xs[ind];\r\n if (pred(elm, ind, xs)) { return elm; }\r\n }\r\n })\r\n\r\n;\r\n","import {assignDeep} from './assignDeep';\r\nimport {keys} from '../jsPlatform/object';\r\nimport {reduce} from '../list/utils';\r\nimport {curry, curry2} from '../function/curry';\r\n\r\nexport const\r\n\r\n objUnion = curry((obj1, obj2) => assignDeep(obj1, obj2)),\r\n\r\n objIntersect = curry((obj1, obj2) => reduce((agg, key) => {\r\n if (obj2.hasOwnProperty(key)) {\r\n agg[key] = obj2[key];\r\n }\r\n return agg;\r\n }, {}, keys(obj1))),\r\n\r\n objDifference = curry((obj1, obj2) => reduce((agg, key) => {\r\n if (!obj2.hasOwnProperty(key)) {\r\n agg[key] = obj1[key];\r\n }\r\n return agg;\r\n }, {}, keys(obj1))),\r\n\r\n objComplement = curry2((obj0, ...objs) => reduce((agg, obj) =>\r\n assignDeep(agg, objDifference(obj, obj0)), {}, objs));\r\n","/**\r\n * @module console\r\n * @description Console exports.\r\n */\r\nexport const\r\n\r\n /**\r\n * `Console.log` method.\r\n * @function module:console.log\r\n * @params args {...*}\r\n * @returns {void}\r\n */\r\n log = console.log.bind(console),\r\n\r\n /**\r\n * `Console.error` method.\r\n * @function module:console.error\r\n * @params args {...*}\r\n * @returns {void}\r\n */\r\n error = console.error.bind(console),\r\n\r\n /**\r\n * Peeks (console.log) at incoming value(s) and returns the last value.\r\n * @function module:console.peek\r\n * @param args {...*}\r\n * @returns {*} Last given value (if one or more values) else first value.\r\n */\r\n peek = (...args) => (log(...args), args.pop())\r\n\r\n;\r\n","export const\r\n\r\n /**\r\n * Clones and object or array using `JSON.parse(JSON.stringify(...))` pattern.\r\n * @function module:object.jsonClone\r\n * @param x {*}\r\n * @returns {*}\r\n */\r\n jsonClone = x => JSON.parse(JSON.stringify(x))\r\n\r\n;\r\n","import {isArray, isType} from './is';\r\nimport {keys} from '../jsPlatform/object';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns an associated list from given object.\r\n * @note Useful for working with plain javascript objects.\r\n * @function module:object.toAssocList\r\n * @param obj {(Object|Array|*)}\r\n * @returns {Array.<*, *>}\r\n */\r\n toAssocList = obj => keys(obj).map(key => [key, obj[key]]),\r\n\r\n /**\r\n * Returns an associated list from given object (deeply (on incoming object's type)).\r\n * @note Does deep conversion on all values of passed in type's type.\r\n * @function module:object.toAssocListDeep\r\n * @param obj {*}\r\n * @param [TypeConstraint = Object] {(Constructor|Function)} - Type constraint to convert on.\r\n * @returns {*}\r\n */\r\n toAssocListDeep = (obj, TypeConstraint = Object) => keys(obj).map(key =>\r\n TypeConstraint && isType(TypeConstraint, obj[key]) ?\r\n [key, toAssocListDeep(obj[key], TypeConstraint)] :\r\n [key, obj[key]]\r\n ),\r\n\r\n /**\r\n * From associated list to object.\r\n * @function module:object.fromAssocList\r\n * @param xs {Array.} - Associated list.\r\n * @param [OutType = Object] {Constructor|Function} - Output type. Default `Object`.\r\n * @returns {*} - Default is `Object`\r\n */\r\n fromAssocList = (xs, OutType = Object) => xs.reduce((agg, [key, value]) => {\r\n agg[key] = value;\r\n return agg;\r\n }, new OutType()),\r\n\r\n /**\r\n * From associated list to object (deep conversion on associative lists (array of 2 value arrays)).\r\n * @note Considers array of arrays associated lists.\r\n * @function module:object.fromAssocListDeep\r\n * @param xs {Array.} - Associated list.\r\n * @param [OutType = Object] {Constructor|Function} - Output type. Default `Object`.\r\n * @returns {*} - Default is `Object`\r\n */\r\n fromAssocListDeep = (xs, OutType = Object) => xs.reduce((agg, [key, value]) => {\r\n if (isArray(value) && isArray(value[0]) && value[0].length === 2) {\r\n agg[key] = fromAssocListDeep(value, OutType);\r\n return agg;\r\n }\r\n agg[key] = value;\r\n return agg;\r\n }, new OutType())\r\n;\r\n","import {typeOf} from './typeOf';\r\nimport {toAssocList} from './assocList';\r\n\r\nexport const\r\n\r\n /**\r\n * Converts incoming value to an array.\r\n * @note For `WeakMap`, `WeakSet`, `Map` and `Set` result is the same as calling `Array.from` on such.\r\n * @note For `null`, `undefined`, `NaN`, `Number{}`, `Symbol{}`, `Boolean{}` returns an empty array.\r\n * @note Method does a shallow conversion;\r\n * @function module:object.toArray\r\n * @param x {*} - Thing to convert from.\r\n * @returns {Array}\r\n */\r\n toArray = x => {\r\n switch (typeOf(x)) {\r\n case 'Null':\r\n case 'Undefined':\r\n return [];\r\n case String.name:\r\n case Array.name:\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n case 'Map':\r\n case 'Set':\r\n return Array.from(x);\r\n case Object.name:\r\n default:\r\n return toAssocList(x);\r\n }\r\n }\r\n\r\n;\r\n","/**\r\n * @module object\r\n * @description Object operations/combinators.\r\n */\r\n\r\nexport * from './jsPlatform/object';\r\nexport * from './object/lookup';\r\nexport * from './object/typeOf';\r\nexport * from './object/copy';\r\nexport * from './object/is';\r\nexport * from './object/of';\r\nexport * from './object/searchObj';\r\nexport * from './object/assignDeep';\r\nexport * from './object/setTheory';\r\nexport * from './object/console';\r\nexport * from './object/jsonClone';\r\nexport * from './object/toArray';\r\nexport * from './object/assocList';\r\n","import {reduceRight} from '../jsPlatform/array';\r\n\r\n/**\r\n * Composes all functions passed in from right to left passing each functions return value to\r\n * the function on the left of itself.\r\n * @function module:function.compose\r\n * @type {Function}\r\n * @param args {...{Function}}\r\n * @returns {Function}\r\n */\r\nexport const compose = (...args) =>\r\n arg0 => reduceRight((value, fn) => fn(value), arg0, args);\r\n","/**\r\n * @memberOf function\r\n */\r\n\r\n/**\r\n * Returns passed in parameter.\r\n * @haskellType `id :: a -> a`\r\n * @function module:function.id\r\n * @param x {*}\r\n * @returns {*}\r\n */\r\nexport const id = x => x;\r\n","/**\r\n * @memberOf function\r\n */\r\n\r\nimport {apply} from '../jsPlatform/function';\r\nimport {curry, curry2} from './curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Negates a function that takes one/no argument.\r\n * @function module:function.negateF\r\n * @param fn {Function}\r\n * @returns {function(*=): boolean}\r\n */\r\n negateF = fn => x => !fn(x),\r\n\r\n /**\r\n * Takes a function that takes two parameters and returns a negated version of given\r\n * function.\r\n * @function module:_negate.negateF2\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n negateF2 = fn => curry((a, b) => !fn(a, b)),\r\n\r\n /**\r\n * Takes a function that takes three parameters and returns a\r\n * negated version of given function.\r\n * @function module:_negate.negateF3\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n negateF3 = fn => curry((a, b, c) => !fn(a, b, c)),\r\n\r\n /**\r\n * Returns a negated version of given function.\r\n * Returned function is variadiac (takes one or more arguments).\r\n * @note function returned is uncurried.\r\n * @uncurried\r\n * @function module:function.negateFN\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n negateFN = fn => curry2((...args) => !apply(fn, args));\r\n","import {curry} from './curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Run `operation` until predicate returns `true` (like a functional\r\n * version of a while loop).\r\n * @function module:function.until\r\n * @param predicate {Function} :: a -> Boolean\r\n * @param operation {Function} :: a -> a\r\n * @param typeInstance {*} :: * - A monoidal zero or some starting point.\r\n * @returns {*} - What ever type `typeInstance` is\r\n */\r\n until = curry((predicate, operation, typeInstance) => {\r\n let result = typeInstance;\r\n while (!predicate(result)) {\r\n result = operation(result);\r\n }\r\n return result;\r\n });\r\n","import {typeOf} from '../object/typeOf';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a function or throws an error if given `f` is not a function.\r\n * @function module:function.fnOrError\r\n * @param symbolName {String} - Error message prefix.\r\n * @param f {Function|*} - Expected function.\r\n * @returns {Function}\r\n * @throws {Error} - Error if `f` is not of `function`\r\n */\r\n fnOrError = (symbolName, f) => {\r\n if (!f || !(f instanceof Function)) {\r\n throw new Error(`${symbolName} should be a function. ` +\r\n `Type received: ${typeOf(f)}; Value received: ${f}.`);\r\n }\r\n return f;\r\n }\r\n\r\n;\r\n","/**\r\n * No-op ('op' as in 'operation') - Performs no operation 'always' (good for places where\r\n * a value should always be a function etc.).\r\n * @function module:function.noop\r\n * @returns {undefined}\r\n */\r\nexport const noop = () => undefined;\r\n","/**\r\n * @module function\r\n */\r\nexport * from './jsPlatform/function';\r\nexport * from './function/compose';\r\nexport * from './function/curry';\r\nexport * from './function/flip';\r\nexport * from './function/id';\r\nexport * from './function/negate';\r\nexport * from './function/until';\r\nexport * from './function/fnOrError';\r\nexport * from './function/noop';\r\n","/**\r\n * @module object\r\n */\r\nimport {curry} from '../function/curry';\r\n\r\n/**\r\n * Normalizes step for `from` and `to` combination.\r\n * @function module:list.normalizeStep\r\n * @param from {Number}\r\n * @param to {Number}\r\n * @param [step = 1] {Number}\r\n * @returns {Number}\r\n * @private\r\n */\r\nconst normalizeStep = (from, to, step) => {\r\n if (from > to) {\r\n return step > 0 ? -step : step; // make step negative\r\n }\r\n return step < 0 ? -1 * step : step; // make step positive\r\n};\r\n\r\nexport const\r\n\r\n /**\r\n * Range function - gives you an array contain numbers in given range.\r\n * @note normalizes `step` to be valid if range numbers given are invalid\r\n * (forces `step` to be negative if range required is in the negative direction\r\n * and forces `step` to be positive if range required is in the other direction).\r\n * @function module:list.range\r\n * @param from {Number}\r\n * @param to {Number}\r\n * @param [step = 1] {Number}\r\n * @returns {Array.}\r\n */\r\n range = curry((from, to, step = 1) => {\r\n let i = from;\r\n const out = [];\r\n step = normalizeStep(from, to, step);\r\n if (step === 0 || from === to) { return [from]; }\r\n for (; (to - i) * step >= 0; i += step) { out.push(i); }\r\n return out;\r\n })\r\n;\r\n","/**\r\n * Created by elydelacruz on 9/6/2017.\r\n */\r\n\r\nimport {fPureTakesOne} from '../utils';\r\n\r\n/**\r\n * Functional version of `String.prototype.split`.\r\n * @function module:_string.split\r\n * @param separator {String|RegExp}\r\n * @param str {String}\r\n * @returns {Array}\r\n */\r\nexport const split = fPureTakesOne('split');\r\n","/**\r\n * @module jsPlatform_\r\n * @private\r\n */\r\nexport * from './jsPlatform/object';\r\nexport * from './jsPlatform/array';\r\nexport * from './jsPlatform/list';\r\nexport * from './jsPlatform/string';\r\nexport * from './jsPlatform/function';\r\n","/**\r\n * List operations module.\r\n * @module list\r\n */\r\nimport {concat as listAppend, indexOf, slice, includes} from './jsPlatform/list';\r\nimport {apply} from './jsPlatform/function';\r\nimport {length} from './jsPlatform/object';\r\nimport {negateF3, negateF2} from './function/negate';\r\nimport {curry, curry2, curry3} from './function/curry';\r\nimport {isTruthy, isFalsy} from './boolean';\r\nimport {lookup} from './object/lookup';\r\nimport {of} from './object/of';\r\nimport {isset, isString} from './object/is';\r\nimport {typeOf} from './object/typeOf';\r\nimport map from './list/map';\r\n\r\nimport {\r\n sliceFrom, sliceTo, lengths,\r\n toShortest, aggregateArray,\r\n reduceUntil, reduce, reduceRight, lastIndex,\r\n findIndexWhere, findIndexWhereRight, findIndicesWhere,\r\n findWhere, sliceCopy, genericAscOrdering\r\n}\r\n from './list/utils';\r\n\r\nexport * from './list/range';\r\n\r\nexport * from './list/utils';\r\n\r\nexport {map};\r\n\r\nexport {slice, includes, indexOf, lastIndexOf, push} from './jsPlatform';\r\n\r\nexport const\r\n\r\n /**\r\n * Append two, or more, lists, i.e.,\r\n * @example\r\n * expectEqual(append(take(13, alphabetString), drop(13, alphabetString)), alphabetString); // true\r\n *\r\n * // Another example\r\n * const result = append(\r\n * alphabetStr.split(''),\r\n * alphabetStr.split('')\r\n * ),\r\n * expected = repeat(2, alphabetStr).split('');\r\n *\r\n * shallowEquals(result, expected) === true // `true`\r\n *\r\n * @function module:list.append\r\n * @param [args] {...(Array|String|*)} - One or more lists or list likes (strings etc.).\r\n * @returns {(Array|String|*)} - Same type as list like passed in.\r\n */\r\n append = curry2((...args) => apply(listAppend, args)),\r\n\r\n /**\r\n * Returns head of list (first item of list).\r\n * @haskellType `head :: [a] -> a`\r\n * @function module:list.head\r\n * @param x {Array|String}\r\n * @returns {*} - First item from list\r\n */\r\n head = x => x[0],\r\n\r\n /**\r\n * Returns last item of list.\r\n * @haskellType `last :: [a] -> a`\r\n * @function module:list.last\r\n * @param xs {Array|String}\r\n * @returns {*}\r\n */\r\n last = xs => xs[lastIndex(xs)],\r\n\r\n /**\r\n * Returns tail part of list (everything after the first item as new list).\r\n * @haskelType `tail :: [a] -> [a]`\r\n * @function module:list.tail\r\n * @param xs {Array|String}\r\n * @returns {Array|String}\r\n */\r\n tail = xs => sliceFrom(1, xs),\r\n\r\n /**\r\n * Returns everything except last item of list as new list.\r\n * @haskellType `init :: [a] -> [a]`\r\n * @function module:list.init\r\n * @param xs {Array|String}\r\n * @returns {Array|String}\r\n */\r\n init = xs => sliceTo(lastIndex(xs), xs),\r\n\r\n /**\r\n * Returns `head` and `tail` of passed in list/string in a tuple.\r\n * @haskellType `uncons :: [a] -> Maybe (a, [a])`\r\n * @function module:list.uncons\r\n * @param xs {Array|String}\r\n * @returns {Array|undefined}\r\n */\r\n uncons = xs => !xs || length(xs) === 0 ? undefined : [head(xs), tail(xs)],\r\n\r\n /**\r\n * Returns `tail` and `head` of passed in list/string in a tuple.\r\n * @haskellType `unconsr :: [a] -> Maybe ([a], a)`\r\n * @function module:list.unconsr\r\n * @param xs {Array|String}\r\n * @returns {Array|String|*|undefined}\r\n */\r\n unconsr = xs => !xs || length(xs) === 0 ? undefined : [init(xs), last(xs)],\r\n\r\n /**\r\n * Concatenates all the elements of a container of lists.\r\n * @haskellType `concat :: Foldable t => t [a] -> [a]`\r\n * @function module:list.concat\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n concat = xs => {\r\n switch (length(xs)) {\r\n case undefined:\r\n case 0:\r\n return [];\r\n case 1:\r\n const item0 = xs[0];\r\n return item0 && item0.slice ? sliceCopy(item0) : item0;\r\n case 2:\r\n default:\r\n return apply(append, xs);\r\n }\r\n },\r\n\r\n /**\r\n * Map a function over all the elements of a container and concatenate the resulting lists.\r\n * @haskellType `concatMap :: Foldable t => (a -> [b]) -> t a -> [b]`\r\n * @function module:list.concatMap\r\n * @param fn {Function}\r\n * @param foldableOfA {Array}\r\n * @returns {Array}\r\n */\r\n concatMap = curry((fn, foldableOfA) => concat(map(fn, foldableOfA))),\r\n\r\n /**\r\n * Returns a copy of the passed in list reverses.\r\n * @haskellType `reverse :: [a] -> [a]`\r\n * @function module:list.reverse\r\n * @param xs {Array|String}\r\n * @returns {Array|String}\r\n */\r\n reverse = xs => {\r\n if (!isset(xs) || !xs.length) {\r\n return xs;\r\n }\r\n let out = of(xs),\r\n i = xs.length - 1;\r\n switch (typeOf(xs)) {\r\n case 'String':\r\n for (; i >= 0; i -= 1) {\r\n out += xs[i];\r\n }\r\n return out;\r\n default:\r\n for (; i >= 0; i -= 1) {\r\n out.push(xs[i]);\r\n }\r\n return out;\r\n }\r\n },\r\n\r\n /**\r\n * Takes an element and a list and `intersperses' that element between the\r\n * elements of the list.\r\n * @function module:list.intersperse\r\n * @note In our version of the function javascript is loosely typed so,\r\n * so is our function (to much overhead to make it typed) so `between` can be any value.\r\n * @param between {*} - Should be of the same type of elements contained in list.\r\n * @param arr {Array|String} - List.\r\n * @returns {Array|String}\r\n */\r\n intersperse = curry((between, xs) => {\r\n if (!xs || !xs.length) {\r\n return xs;\r\n }\r\n const limit = xs.length,\r\n lastInd = limit - 1;\r\n let out = of(xs),\r\n i = 0;\r\n if (isString(xs)) {\r\n for (; i < limit; i += 1) {\r\n out += i === lastInd ?\r\n xs[i] : xs[i] + between;\r\n }\r\n return out;\r\n }\r\n for (; i < limit; i += 1) {\r\n if (i === lastInd) {\r\n out.push(xs[i]);\r\n } else {\r\n out.push(xs[i], between);\r\n }\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * `intercalate xs xss` is equivalent to (concat (intersperse xs xss)). It inserts the list xs in between the lists in xss and concatenates the result.\r\n * @haskellType `intercalate :: [a] -> [[a]] -> [a]`\r\n * @function module:list.intercalate\r\n * @param xs {Array|String}\r\n * @param xss {Array|String}\r\n * @returns {Array|String}\r\n */\r\n intercalate = curry((xs, xss) => {\r\n if (isString(xss)) {\r\n return intersperse(xs, xss);\r\n }\r\n return concat(intersperse(xs, xss));\r\n }),\r\n\r\n /**\r\n * Transposes rows and columns into lists by index; E.g.,\r\n * Haskell example:\r\n * ```\r\n * transpose [[1,2,3],[4,5,6]] == [[1,4],[2,5],[3,6]]\r\n *\r\n * -- Notice the shorter arrays are ignored after their last index is copied over:\r\n * transpose [[10,11],[20],[],[30,31,32]] == [[10,20,30],[11,31],[32]]\r\n * ```\r\n * @note from columns to rows.\r\n * @note Empty lists are ignored.\r\n * @haskellType `transpose :: [[a]] -> [[a]]`\r\n * @function module:list.transpose\r\n * @param xss {Array}\r\n * @returns {Array}\r\n */\r\n transpose = xss => {\r\n let numLists = length(xss),\r\n ind = 0, ind2;\r\n if (!numLists) {\r\n return [];\r\n }\r\n const listLengths = apply(lengths, xss),\r\n longestListLen = maximum(listLengths),\r\n outLists = [];\r\n for (; ind < longestListLen; ind += 1) {\r\n const outList = [];\r\n for (ind2 = 0; ind2 < numLists; ind2 += 1) {\r\n if (listLengths[ind2] < ind + 1) {\r\n continue;\r\n }\r\n outList.push(xss[ind2][ind]);\r\n }\r\n outLists.push(outList);\r\n }\r\n return filter(x => length(x) > 0, outLists);\r\n },\r\n\r\n /**\r\n * Generates 2^n sub-sequences for passed in sequence (string/list) (`n` is\r\n * the length of the passed in sequence so: 2^length(xs)).\r\n * Note: The return value doubles per index/character passed in so use with caution!\r\n * Also note that for 2^16 (or for a sequence of 16 characters) this algorithm\r\n * will generate 65536 sub-sequences! So caution should be taken to not\r\n * use this with sequences above a certain length on certain platform (the browser thread in specific).\r\n * @function module:list.subsequences\r\n * @jsperftest https://jsperf.com/subsequences\r\n * @param xs {Array|String}\r\n * @returns {Array.}\r\n */\r\n subsequences = xs => {\r\n const listLen = length(xs),\r\n len = Math.pow(2, listLen),\r\n out = [];\r\n for (let i = 0; i < len; i += 1) {\r\n let entry = [];\r\n for (let j = 0; j < listLen; j += 1) {\r\n if (i & (1 << j)) {\r\n entry.push(xs[j]);\r\n }\r\n }\r\n out.push(entry);\r\n }\r\n return out;\r\n },\r\n\r\n /**\r\n * Returns an array with the given indices swapped.\r\n * @function module:list.swapped\r\n * @param ind1 {Number}\r\n * @param ind2 {Number}\r\n * @param list {Array}\r\n * @returns {Array} - Copy of incoming with swapped values at indices.\r\n */\r\n swapped = curry((ind1, ind2, list) => {\r\n const out = sliceCopy(list),\r\n tmp = out[ind1];\r\n out[ind1] = out[ind2];\r\n out[ind2] = tmp;\r\n return out;\r\n }),\r\n\r\n /**\r\n * Returns a list of permutations for passed in list.\r\n * Use caution with lists above a length of 15 (will take long due to nature of\r\n * algorithm).\r\n * @function module:list.permutations\r\n * @param xs {Array} - List.\r\n * @returns {Array} - Array of permutations.\r\n */\r\n permutations = xs => {\r\n const limit = length(xs);\r\n\r\n if (!limit || limit === 1) {\r\n return [xs];\r\n }\r\n\r\n let list = sliceCopy(xs),\r\n c = repeat(limit, 0),\r\n i = 0;\r\n\r\n const out = [list];\r\n\r\n for (; i < limit; i++) {\r\n if (c[i] < i) {\r\n list = swapped(i % 2 === 0 ? 0 : c[i], i, list);\r\n out.push(list);\r\n c[i] += 1;\r\n i = 0;\r\n continue;\r\n }\r\n c[i] = 0;\r\n }\r\n\r\n return out;\r\n },\r\n\r\n /**\r\n * Left associative fold. Reduces a container of elements down by the given operation (same as [].reduce).\r\n * @function module:list.foldl\r\n * @param fn {Function}\r\n * @param zero {*} - Aggregator.\r\n * @param functor {Array}\r\n * @returns {*} - Whatever type is lastly returned from `fn`.\r\n */\r\n foldl = reduce,\r\n\r\n /**\r\n * Right associative fold. Reduces a container of elements down by the given operation (same as [].reduceRight).\r\n * @function module:list.foldr\r\n * @param fn {Function}\r\n * @param zero {*} - Aggregator.\r\n * @param functor {Array}\r\n * @returns {*} - Whatever type is lastly returned from `fn`.\r\n */\r\n foldr = reduceRight,\r\n\r\n /**\r\n * A variant of `foldl` except that this one doesn't require the starting point. The starting point/value will be pulled\r\n * out from a copy of the container.\r\n * @function module:list.foldl1\r\n * @param op {Function}\r\n * @param xs {Array}\r\n * @returns {*} - Whatever type is lastly returned from `op`.\r\n */\r\n foldl1 = curry((op, xs) => {\r\n const parts = uncons(xs);\r\n return !parts ? [] : reduce(op, parts[0], parts[1]);\r\n }),\r\n\r\n /**\r\n * A variant of `foldr` except that this one doesn't require the starting point/value. The starting point/value will be pulled\r\n * out from a copy of the container.\r\n * @function module:list.foldr1\r\n * @param op {Function}\r\n * @param xs {Array}\r\n * @returns {*} - Whatever type is lastly returned from `op`.\r\n */\r\n foldr1 = curry((op, xs) => {\r\n const parts = unconsr(xs);\r\n return !parts ? [] : reduceRight(op, parts[1], parts[0]);\r\n }),\r\n\r\n /**\r\n * Performs a map then a reduce all in one (from left-to-right). Returns a tuple\r\n * containing the aggregated value and the result of mapping the passed in function on passed in list.\r\n * @function module:list.mapAccumL\r\n * @param op {Function} - Function : [aggregated, mapResult]\r\n * @param zero {*} - An instance of the passed in list type used to aggregateArray on.\r\n * @param xs {Array} - list type.\r\n * @return {Array} - [aggregated, list]\r\n */\r\n mapAccumL = curry((op, zero, xs) => {\r\n const list = sliceCopy(xs),\r\n limit = length(xs);\r\n if (!limit) {\r\n return [zero, list];\r\n }\r\n let ind = 0,\r\n agg = zero,\r\n mapped = [],\r\n tuple;\r\n for (; ind < limit; ind++) {\r\n tuple = op(agg, list[ind], ind);\r\n agg = tuple[0];\r\n mapped = tuple[1];\r\n }\r\n return [agg, mapped];\r\n }),\r\n\r\n /**\r\n * Performs a map and a reduce all in one (from right-to-left). Returns a tuple\r\n * containing the aggregated value and the result of mapping the passed in function on passed in list.\r\n * @function module:list.mapAccumR\r\n * @param op {Function} - Function : [aggregated, mapResult]\r\n * @param zero {*} - An instance of the passed in list type used to aggregateArray on.\r\n * @param xs {Array} - list type.\r\n * @return {Array} - [aggregated, list]\r\n */\r\n mapAccumR = curry((op, zero, xs) => {\r\n const list = sliceCopy(xs),\r\n limit = length(xs);\r\n if (!limit) {\r\n return [zero, list];\r\n }\r\n let ind = limit - 1,\r\n agg = zero,\r\n mapped = [],\r\n tuple;\r\n for (; ind >= 0; ind--) {\r\n tuple = op(agg, list[ind], ind);\r\n agg = tuple[0];\r\n mapped = tuple[1];\r\n }\r\n return [agg, mapped];\r\n }),\r\n\r\n /**\r\n * iterate f x returns an infinite list of repeated applications of f to x.\r\n * @function module:list.iterate\r\n * @example `iterate(5, f, x) == [x, f(x), f(f(x)), ...]`\r\n * @param limit {Number}\r\n * @param op {Function} - Operation.\r\n * @param x {*} - Starting point.\r\n * @returns {*}\r\n */\r\n iterate = curry((limit, op, x) => {\r\n let ind = 0,\r\n out = [],\r\n lastX = x;\r\n for (; ind < limit; ind += 1) {\r\n out.push(lastX);\r\n lastX = op(lastX, ind);\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Repeats `x` `limit` number of times.\r\n * @function module:list.repeat\r\n * @param limit {Number}\r\n * @param x {*}\r\n * @return {Array}\r\n */\r\n repeat = curry((limit, x) => iterate(limit, a => a, x)),\r\n\r\n /**\r\n * Same as `repeat` due to the nature of javascript (see haskell version for usage).\r\n * @function module:list.replicate\r\n * @param limit {Number}\r\n * @param x {*}\r\n * @return {Array}\r\n */\r\n replicate = repeat,\r\n\r\n /**\r\n * Replicates a list `limit` number of times and appends the results (concat)\r\n * @function module:list.cycle\r\n * @param limit {Number}\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n cycle = curry((limit, xs) => concat(replicate(limit, xs))),\r\n\r\n /**\r\n * Unfolds a value into a list of somethings.\r\n * @haskellType `unfoldr :: (b -> Maybe (a, b)) -> b -> [a]`\r\n * @function module:list.unfoldr\r\n * @param op {Function} - Operation to perform (should return a two component tuple (item to aggregateArray and item to unfold in next iteration).\r\n * @param x {*} - Starting parameter to unfold from.\r\n * @returns {Array} - An array of whatever you return from `op` yielded.\r\n */\r\n unfoldr = curry((op, x) => {\r\n let ind = 0,\r\n out = [],\r\n resultTuple = op(x, ind, out);\r\n while (resultTuple) {\r\n out.push(resultTuple[0]);\r\n resultTuple = op(resultTuple[1], ++ind, out);\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Finds index in string or list (alias for `findIndex`).\r\n * @function module:list.findIndex\r\n * @param pred {Function} - Predicate.\r\n * @param arr {Array|String}\r\n * @returns {Number} - `-1` if predicate not matched else `index` found\r\n */\r\n findIndex = findIndexWhere,\r\n\r\n /**\r\n * @function module:list.findIndices\r\n * @param pred {Function}\r\n * @param xs {Array} - list or list like.\r\n * @returns {Array|undefined}\r\n */\r\n findIndices = findIndicesWhere,\r\n\r\n /**\r\n * @function module:list.elemIndex\r\n * @param x {*} - Element to search for.\r\n * @param xs {Array} - list or list like.\r\n * @returns {*}\r\n */\r\n elemIndex = curry((x, xs) => {\r\n const foundInd = indexOf(x, xs);\r\n return foundInd !== -1 ? foundInd : undefined;\r\n }),\r\n\r\n /**\r\n * @function module:list.elemIndices\r\n * @param value {*} - Element to search for.\r\n * @param xs {Array} - list or list like.\r\n * @returns {*}\r\n */\r\n elemIndices = curry((value, xs) => findIndices(x => x === value, xs)),\r\n\r\n /**\r\n * Takes `n` items from start of list to `limit` (exclusive).\r\n * @function module:list.take\r\n * @param list {Array|String}\r\n * @param limit {Number}\r\n * @returns {String|Array} - Passed in type's type\r\n */\r\n take = sliceTo,\r\n\r\n /**\r\n * Drops `n` items from start of list to `count` (exclusive).\r\n * @function module:list.drop\r\n * @param list {Array|String}\r\n * @param count {Number}\r\n * @returns {String|Array} - Passed in type's type\r\n */\r\n drop = sliceFrom,\r\n\r\n /**\r\n * Splits `x` in two at given `index` (exclusive (includes element/character at\r\n * given index in second part of returned list)).\r\n * @function module:list.splitAt\r\n * @param ind {Number} - Index to split at.\r\n * @param list {Array|String} - functor (list or string) to split.\r\n * @returns {Array|String} - List like type passed\r\n */\r\n splitAt = (ind, list) => [sliceTo(ind, list), sliceFrom(ind, list)],\r\n\r\n /**\r\n * Gives an list with passed elements while predicate was true.\r\n * @function module:list.takeWhile\r\n * @param pred {Function} - Predicate<*, index, list|string>\r\n * @param list {Array|String}\r\n * @returns {Array}\r\n */\r\n takeWhile = curry((pred, list) =>\r\n reduceUntil(\r\n negateF3(pred), // predicate\r\n isString(list) ?\r\n (agg, x) => agg + x :\r\n aggregateArray, // operation\r\n of(list), // aggregate\r\n list\r\n )),\r\n\r\n /**\r\n * Returns an list without elements that match predicate.\r\n * @function module:list.dropWhile\r\n * @param pred {Function} - Predicate<*, index, list|string>\r\n * @param list {Array|String}\r\n * @refactor\r\n * @returns {Array|String}\r\n */\r\n dropWhile = curry((pred, list) => {\r\n const limit = length(list),\r\n splitPoint =\r\n findIndexWhere(\r\n (x, i, xs) => !pred(x, i, xs),\r\n list\r\n );\r\n\r\n return splitPoint === -1 ?\r\n sliceFrom(limit, list) :\r\n slice(splitPoint, limit, list);\r\n }),\r\n\r\n /**\r\n * @function module:list.dropWhileEnd\r\n * @param pred {Function} - Predicate<*, index, list|string>\r\n * @param list {Array|String}\r\n * @refactor\r\n * @returns {Array|String}\r\n */\r\n dropWhileEnd = curry((pred, list) => {\r\n const splitPoint =\r\n findIndexWhereRight(\r\n (x, i, xs) => !pred(x, i, xs),\r\n list\r\n );\r\n if (splitPoint === -1) {\r\n return of(list);\r\n }\r\n return sliceTo(splitPoint + 1, list);\r\n }),\r\n\r\n /**\r\n * Gives you the `span` of items matching predicate\r\n * and items not matching predicate; E.g., Gives an\r\n * array of arrays; E.g., [[matching-items], [non-matching-items]]\r\n * @function list.span\r\n * @param pred {Function} - List predicate (`(x, i, list) => bool`)\r\n * @param list {Array|String}\r\n * @returns {(Array>|Array)}\r\n * @type {Function}\r\n */\r\n span = curry((pred, list) => {\r\n const splitPoint = findIndexWhere(negateF3(pred), list);\r\n return splitPoint === -1 ?\r\n [sliceFrom(0, list), of(list)] :\r\n splitAt(splitPoint, list);\r\n }),\r\n\r\n /**\r\n * breakOnList, applied to a predicate p and a list xs, returns a tuple\r\n * where first element is longest prefix (possibly empty) of xs of elements\r\n * that do not satisfy p and second element is the remainder of the list:\r\n * @haskellExample\r\n * Replace `break` with `breakOnList` for our version.\r\n * ```\r\n * breakOnList (> 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4])\r\n * breakOnList (< 9) [1,2,3] == ([],[1,2,3])\r\n * breakOnList (> 9) [1,2,3] == ([1,2,3],[])\r\n * ```\r\n * @function module:list.breakOnList\r\n * @param pred {Function}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n breakOnList = curry((pred, list) => {\r\n const splitPoint = findIndexWhere(negateF3(pred), list);\r\n return splitPoint === -1 ?\r\n [of(list), sliceFrom(0, list)] : reverse(splitAt(splitPoint, list));\r\n }),\r\n\r\n /**\r\n * Gets item at index.\r\n * @function module:list.at\r\n * @param ind {Number} - Index.\r\n * @param xs {Array} - list or list like.\r\n * @returns {*|undefined} - Item or `undefined`.\r\n */\r\n at = lookup,\r\n\r\n /**\r\n * Find an item in structure of elements based on given predicate (`pred`).\r\n * @function module:list.find\r\n * @param pred {Function}\r\n * @param xs {Array} - list or list like.\r\n * @returns {*} - Found item.\r\n */\r\n find = findWhere,\r\n\r\n /**\r\n * For each function (same as `[].forEach` except in functional format).\r\n * @function module:list.forEach\r\n * @param fn {Function} - Operation (`(element, index, list) => {...}`, etc.)\r\n * @param xs {(Array|String)}\r\n * @returns {void}\r\n */\r\n forEach = curry((fn, list) => {\r\n const limit = length(list);\r\n if (!limit) {\r\n return;\r\n }\r\n let ind = 0;\r\n for (; ind < limit; ind += 1) {\r\n fn(list[ind], ind, list);\r\n }\r\n }),\r\n\r\n /**\r\n * Filters a structure of elements using given predicate (`pred`) (same as `[].filter`).\r\n * @function module:list.filter\r\n * @param pred {Function}\r\n * @param xs {Array} - list or list like.\r\n * @returns {Array} - Structure of filtered elements.\r\n */\r\n filter = curry((pred, xs) => {\r\n let ind = 0,\r\n limit = length(xs),\r\n out = [];\r\n if (!limit) {\r\n return out;\r\n }\r\n for (; ind < limit; ind++) {\r\n if (pred(xs[ind], ind, xs)) {\r\n out.push(xs[ind]);\r\n }\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Partitions a list on a predicate; Items that match predicate are in first list in tuple; Items that\r\n * do not match the tuple are in second list in the returned tuple.\r\n * Essentially `[filter(p, xs), filter(negateF3(p), xs)]`.\r\n * @function module:list.partition\r\n * @param pred {Function} - Predicate\r\n * @param list {Array}\r\n * @returns {Array|String} - Tuple of arrays or strings (depends on incoming list (of type list or string)).\r\n */\r\n partition = curry((pred, list) =>\r\n !length(list) ?\r\n [[], []] :\r\n [filter(pred, list), filter(negateF3(pred), list)]),\r\n\r\n /**\r\n * Returns a boolean indicating whether an element exists in given structure of elements.\r\n * @function module:list.elem\r\n * @param element {*}\r\n * @param xs {Array}\r\n * @returns {Boolean}\r\n */\r\n elem = includes,\r\n\r\n /**\r\n * The opposite of `elem` - Returns a boolean indicating whether an element exists in given list.\r\n * @function module:list.notElem\r\n * @param element {*}\r\n * @param xs {Array}\r\n * @returns {Boolean}\r\n */\r\n notElem = negateF2(includes),\r\n\r\n /**\r\n * Checks if list `xs1` is a prefix of list `xs2`\r\n * @function module:list.isPrefixOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isPrefixOf = curry((xs1, xs2) => {\r\n const limit1 = length(xs1),\r\n limit2 = length(xs2);\r\n if (limit2 < limit1 || !limit1 || !limit2 || indexOf(xs1[0], xs2) === -1) {\r\n return false;\r\n }\r\n let ind = 0;\r\n for (; ind < limit1; ind++) {\r\n if (xs1[ind] !== xs2[ind]) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }),\r\n\r\n /**\r\n * Checks if list `xs1` is a suffix of list `xs2`\r\n * @function module:list.isSuffixOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isSuffixOf = curry((xs1, xs2) => {\r\n const limit1 = length(xs1),\r\n limit2 = length(xs2);\r\n if (limit2 < limit1 || !limit1 || !limit2 || indexOf(xs1[0], xs2) === -1) {\r\n return false;\r\n }\r\n let ind1 = limit1 - 1,\r\n ind2 = limit2 - 1;\r\n for (; ind1 >= 0; ind1--) {\r\n if (xs1[ind1] !== xs2[ind2]) {\r\n return false;\r\n }\r\n ind2 -= 1;\r\n }\r\n return true;\r\n }),\r\n\r\n /**\r\n * Checks if list `xs1` is an infix of list `xs2`\r\n * @function module:list.isInfixOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isInfixOf = curry((xs1, xs2) => {\r\n const limit1 = length(xs1),\r\n limit2 = length(xs2);\r\n if (limit2 < limit1 || !limit1 || !limit2) {\r\n return false;\r\n }\r\n let ind1,\r\n foundLen,\r\n ind = 0;\r\n for (; ind < limit2; ind += 1) {\r\n foundLen = 0;\r\n for (ind1 = 0; ind1 < limit1; ind1 += 1) {\r\n if (xs2[ind1 + ind] === xs1[ind1]) {\r\n foundLen += 1;\r\n }\r\n if (foundLen === limit1) {\r\n return true;\r\n }\r\n }\r\n }\r\n return false;\r\n }),\r\n\r\n /**\r\n * Checks if list `xs1` is a sub-sequence of list `xs2`\r\n * @function module:list.isSubsequenceOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isSubsequenceOf = curry((xs1, xs2) => {\r\n const len = Math.pow(2, length(xs2)),\r\n lenXs1 = length(xs1);\r\n let foundLen,\r\n i;\r\n for (i = 0; i < len; i += 1) {\r\n foundLen = 0;\r\n for (let j = 0; j < len; j += 1) {\r\n if (i & (1 << j) && indexOf(xs2[j], xs1) > -1) {\r\n foundLen += 1;\r\n }\r\n if (foundLen === lenXs1) {\r\n return true;\r\n }\r\n }\r\n }\r\n return false;\r\n }),\r\n\r\n /**\r\n * The group function takes a list and returns a list of lists such that\r\n * the concatenation of the result is equal to the argument. Moreover, each\r\n * sublist in the result contains only equal elements. For example,\r\n * `group \"Mississippi\" = [\"M\",\"i\",\"ss\",\"i\",\"ss\",\"i\",\"pp\",\"i\"]`\r\n * It is a special case of groupBy, which allows the programmer to supply\r\n * their own equality test.\r\n * @haskellType `group :: Eq a => [a] -> [[a]]`\r\n * @function module:list.group\r\n * @param xs {Array|String}\r\n * @returns {Array|*}\r\n */\r\n group = xs => groupBy((a, b) => a === b, xs),\r\n\r\n /**\r\n * Allows you to group items in a list based on your supplied equality check.\r\n * @note Sames `group` but allows you to specify equality operation.\r\n * @haskellType `groupBy :: (a -> a -> Bool) -> [a] -> [[a]]`\r\n * @function module:list.groupBy\r\n * @param equalityOp {Function}\r\n * @param xs {Array}\r\n * @returns {*}\r\n */\r\n groupBy = curry((equalityOp, xs) => {\r\n const limit = length(xs);\r\n if (!limit) {\r\n return sliceCopy(xs);\r\n }\r\n let ind = 0,\r\n prevItem,\r\n item,\r\n predOp = x => {\r\n if (equalityOp(x, prevItem)) {\r\n ind++;\r\n }\r\n if (equalityOp(x, item)) {\r\n prevItem = x;\r\n return true;\r\n }\r\n return false;\r\n },\r\n agg = [];\r\n for (; ind < limit; ind += 1) {\r\n item = xs[ind];\r\n agg.push(takeWhile(predOp, slice(ind, limit, xs)));\r\n }\r\n return agg;\r\n }),\r\n\r\n /**\r\n * The inits function returns all initial segments of the argument, shortest first. For example,\r\n * ```\r\n * shallowEquals(inits('abc'), ['','a','ab','abc'])\r\n * ```\r\n * @function module:list.inits\r\n * @haskellType `inits :: [a] -> [[a]]`\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n inits = xs => {\r\n let limit = length(xs),\r\n ind = 0,\r\n agg = [];\r\n if (!limit) {\r\n return [];\r\n }\r\n for (; ind <= limit; ind += 1) {\r\n agg.push(sliceTo(ind, xs));\r\n }\r\n return agg;\r\n }, //map(list => init(list), xs),\r\n\r\n /**\r\n * The inits function returns all initial segments of the argument, shortest first. For example,\r\n * ```\r\n * shallowEquals(tails('abc'), ['abc', 'bc', 'c',''])\r\n * ```\r\n * @function module:list.tails\r\n * @haskellType `tails :: [a] -> [[a]]`\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n tails = xs => {\r\n let limit = length(xs),\r\n ind = 0,\r\n agg = [];\r\n if (!limit) {\r\n return [];\r\n }\r\n for (; ind <= limit; ind += 1) {\r\n agg.push(slice(ind, limit, xs));\r\n }\r\n return agg;\r\n }, //map(list => tail(list), xs),\r\n\r\n /**\r\n * Strips prefix list from given list\r\n * @function module:list.stripPrefix\r\n * @param prefix {Array|String|*}\r\n * @param list {Array|string|*}\r\n * @returns {Array|*}\r\n */\r\n stripPrefix = curry((prefix, list) =>\r\n isPrefixOf(prefix, list) ?\r\n splitAt(length(prefix), list)[1] :\r\n sliceCopy(list)),\r\n\r\n /**\r\n * zip takes two lists and returns a list of corresponding pairs.\r\n * If one input list is short, excess elements of the longer list are discarded.\r\n * @haskellType `zip :: [a] -> [b] -> [(a, b)]`\r\n * @function module:list.zip\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array>}\r\n */\r\n zip = curry((arr1, arr2) => {\r\n if (!length(arr1) || !length(arr2)) {\r\n return [];\r\n }\r\n const [a1, a2] = toShortest(arr1, arr2);\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, [item, a2[ind]]),\r\n [], a1);\r\n }),\r\n\r\n /**\r\n * zipN takes one or more lists and returns a list containing lists of all indices\r\n * at a given index, index by index.\r\n * If one input list is short, excess elements of the longer list are discarded.\r\n * @function module:list.zipN\r\n * @param lists {Array|String} - One ore more lists of the same type.\r\n * @returns {Array}\r\n */\r\n zipN = curry2((...lists) => {\r\n const trimmedLists = apply(toShortest, lists);\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, map(xs => xs[ind], trimmedLists)),\r\n [], trimmedLists[0]);\r\n }),\r\n\r\n /**\r\n * @haskellType `zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]`\r\n * @function module:list.zip3\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @param arr3 {Array}\r\n * @returns {Array>}\r\n */\r\n zip3 = curry((arr1, arr2, arr3) => zipN(arr1, arr2, arr3)),\r\n\r\n /**\r\n * @haskellType `zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]`\r\n * @function module:list.zip4\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @param arr3 {Array}\r\n * @param arr4 {Array}\r\n * @returns {Array>}\r\n */\r\n zip4 = curry((arr1, arr2, arr3, arr4) => zipN(arr1, arr2, arr3, arr4)),\r\n\r\n /**\r\n * @haskellType `zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]`\r\n * @function module:list.zip5\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @param arr3 {Array}\r\n * @param arr4 {Array}\r\n * @param arr5 {Array}\r\n * @returns {Array>}\r\n */\r\n zip5 = curry((arr1, arr2, arr3, arr4, arr5) => zipN(arr1, arr2, arr3, arr4, arr5)),\r\n\r\n /**\r\n * zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]\r\n * zipWith generalises zip by zipping with the function given as the\r\n * first argument, instead of a function tupling function (function that returns a tuple). For example,\r\n * zipWith (+) is applied to two lists to produce the list of corresponding sums.\r\n * @note `_|_` means bottom or perpetual (@see\r\n * - https://wiki.haskell.org/Bottom\r\n * - https://stackoverflow.com/questions/19794681/what-does-this-syntax-mean-in-haskell-or\r\n * )\r\n * @example\r\n * ```\r\n * zipWith f [] _|_ = []\r\n * ```\r\n * @haskellType `zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]`\r\n * @function module:list.zipWith\r\n * @param op {Function} - Takes two parts of a tuple and returns a tuple.\r\n * E.g., ` op :: a -> b -> (a, b)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith = curry((op, xs1, xs2) => {\r\n if (!length(xs1) || !length(xs2)) {\r\n return [];\r\n }\r\n const [a1, a2] = toShortest(xs1, xs2);\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, op(item, a2[ind])),\r\n [], a1);\r\n }),\r\n\r\n /**\r\n * Zips all given lists with tupling function. Note: Haskell types do not have\r\n * a way (that I know of) to show one or more for params in a function so `@haskellType` below\r\n * is left there for general purpose not for exactness as is told by aforementioned.\r\n * @haskellType `zipWithN :: (a -> b -> c) -> [a] -> [b] -> [c]` - Where `N` is the number\r\n * of lists to zip.\r\n * @function module:list.zipWithN\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> (a, b, c)`\r\n * @param lists ...{Array}\r\n * @returns {Array>}\r\n */\r\n zipWithN = curry3((op, ...lists) => {\r\n const trimmedLists = apply(toShortest, lists),\r\n lenOfTrimmed = length(trimmedLists);\r\n if (!lenOfTrimmed) {\r\n return [];\r\n }\r\n else if (lenOfTrimmed === 1) {\r\n return sliceTo(length(trimmedLists[0]), trimmedLists[0]);\r\n }\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, apply(op, map(xs => xs[ind], trimmedLists))),\r\n [], trimmedLists[0]);\r\n }),\r\n\r\n /**\r\n * Zips 3 lists with tupling function.\r\n * @haskellType `zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]`\r\n * @function module:list.zipWith3\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> (a, b, c)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @param xs3 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith3 = curry((op, xs1, xs2, xs3) => zipWithN(op, xs1, xs2, xs3)),\r\n\r\n /**\r\n * Zips 4 lists with tupling function.\r\n * @haskellType `zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]`\r\n * @function module:list.zipWith4\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> d -> (a, b, c, d)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @param xs3 {Array}\r\n * @param xs4 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith4 = curry((op, xs1, xs2, xs3, xs4) => zipWithN(op, xs1, xs2, xs3, xs4)),\r\n\r\n /**\r\n * Zips 5 lists.\r\n * @haskellType `zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]`\r\n * @function module:list.zipWith5\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> d -> e -> (a, b, c, d, e)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @param xs3 {Array}\r\n * @param xs4 {Array}\r\n * @param xs5 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith5 = curry((op, xs1, xs2, xs3, xs4, xs5) => zipWithN(op, xs1, xs2, xs3, xs4, xs5)),\r\n\r\n /**\r\n * unzip transforms a list of pairs into a list of first components and a list of second components.\r\n * @haskellType `unzip :: [(a, b)] -> ([a], [b])`\r\n * @function module:list.unzip\r\n * @param arr {Array|*}\r\n * @returns {Array|*}\r\n */\r\n unzip = foldl((agg, item) => {\r\n agg[0].push(item[0]);\r\n agg[1].push(item[1]);\r\n return agg;\r\n }, [[], []]),\r\n\r\n /**\r\n * unzip transforms a list of pairs into a list of first components and a list of second components.\r\n * @sudoHaskellType `unzipN :: [(a, b, ...x)] -> ([a], [b], ...[x])`\r\n * @function module:list.unzipN\r\n * @param list {Array|*} - List of tuples (lists).\r\n * @returns {Array|*}\r\n */\r\n unzipN = list => {\r\n if (!length(list)) {\r\n return [];\r\n }\r\n const lenItem0 = length(list[0]);\r\n let zero = lenItem0 ?\r\n unfoldr(numLists => numLists-- ? [[], numLists] : undefined, lenItem0) :\r\n [];\r\n return foldl((agg, item) => {\r\n agg.forEach((outList, ind) => outList.push(item[ind]));\r\n return agg;\r\n }, zero, list);\r\n },\r\n\r\n /**\r\n * Returns true if any item in container passes predicate `p`.\r\n * @function module:list.any\r\n * @param p {Function} - Predicate.\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n any = curry((p, xs) => {\r\n let ind = 0,\r\n limit = length(xs);\r\n if (!limit) {\r\n return false;\r\n }\r\n for (; ind < limit; ind += 1) {\r\n if (p(xs[ind])) {\r\n return true;\r\n }\r\n }\r\n return false;\r\n }),\r\n\r\n /**\r\n * Returns true if all items in container pass predicate `p`.\r\n * @function module:list.all\r\n * @param p {Function} - Predicate.\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n all = curry((p, xs) => {\r\n const limit = length(xs);\r\n let ind = 0;\r\n if (!limit) {\r\n return false;\r\n }\r\n for (; ind < limit; ind++) {\r\n if (!p(xs[ind], ind, xs)) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }),\r\n\r\n /**\r\n * Conjuction of container of bools (or truthy and/or falsy values); Returns\r\n * `true` if all in container are 'truthy' else returns `false`\r\n * @function module:list.and\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n and = xs => all(isTruthy, xs),\r\n\r\n /**\r\n * Returns a boolean indicating whether any item in container is 'truthy' or not.\r\n * **Note** The haskell type for this function only takes two items, but here\r\n * we allow the passing of more than one item (may change later to adhere to the haskell type).\r\n * @function module:list.or\r\n * @haskellType `or :: Bool -> Bool -> Bool`\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n or = xs => any(isTruthy, xs),\r\n\r\n /**\r\n * Returns a boolean indicating whether all items in container are 'falsy' or not.\r\n * **Note** The haskell type for this function only takes two items, but here\r\n * we allow the passing of more than one item (may change later to adhere to the haskell type).\r\n * @function module:list.not\r\n * @haskellType `not :: Bool -> Bool`\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n not = xs => all(isFalsy, xs),\r\n\r\n /**\r\n * Computes the sum of the numbers of a structure.\r\n * @function module:list.sum\r\n * @haskellType `sum :: (List t, Num a) => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {Number}\r\n */\r\n sum = list => foldl((agg, x) => agg + x, 0, list),\r\n\r\n /**\r\n * Computes the product of the numbers of a structure.\r\n * @function module:list.product\r\n * @haskellType `product :: (List t, Num a) => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {Number}\r\n */\r\n product = list => foldl((agg, x) => agg * x, 1, list),\r\n\r\n /**\r\n * Returns the largest element in a non-empty structure of elements.\r\n * @function module:list.maximum\r\n * @haskellType `maximum :: forall a . Ord a => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {*} - Whatever type the array is made of (if any).\r\n */\r\n maximum = list => last(sortBy(genericAscOrdering, list)),\r\n\r\n /**\r\n * Returns the smallest element in a non-empty structure of elements.\r\n * @function module:list.minimum\r\n * @haskellType `minimum :: forall a . Ord a => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {*} - Whatever type the array is made of (if any).\r\n */\r\n minimum = list => head(sortBy(genericAscOrdering, list)),\r\n\r\n /**\r\n * scanl is similar to foldl, but returns a list of successive reduced values from the left:\r\n * ```\r\n * scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]\r\n * ```\r\n * Also note that:\r\n * ```\r\n * last (scanl f z xs) == foldl f z xs.\r\n * ```\r\n * @function module:list.scanl\r\n * @param fn {Function}\r\n * @param zero {*}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanl = curry((fn, zero, xs) => {\r\n if (!xs || !length(xs)) {\r\n return [];\r\n }\r\n const limit = length(xs);\r\n let ind = 0,\r\n result = zero,\r\n out = [];\r\n while (ind < limit) {\r\n result = fn(result, xs[ind], ind, xs);\r\n out.push(result);\r\n ind++;\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * `scanl1` is a variant of `scanl` that has no starting value argument:\r\n * `shallowCompare(scanl1(fn, [x1, x2, ...]), [x1, fn(x1, x2), ...]) // true`\r\n * @function module:list.scanl1\r\n * @param fn {Function}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanl1 = curry((fn, xs) => {\r\n if (!xs || !xs.length) {\r\n return [];\r\n }\r\n return scanl(fn, head(xs), tail(xs));\r\n }),\r\n\r\n /**\r\n * Same as `scanl` but from the right (similiar to `foldr`'s relationship to 'foldl').\r\n * Note also `scanr`'s relationship ot `foldr`:\r\n * `head (scanr(fn, z, xs)) === foldr(fn, z, xs).\r\n * @function module:list.scanr\r\n * @param fn {Function}\r\n * @param zero {*}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanr = curry((fn, zero, xs) => {\r\n if (!xs || !length(xs)) {\r\n return [];\r\n }\r\n const limit = length(xs);\r\n let ind = limit - 1,\r\n result = xs[0],\r\n out = [];\r\n while (ind > -1) {\r\n result = fn(result, xs[ind], ind, xs);\r\n out.push(result);\r\n ind--;\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Same as `scanr` but takes no zero/accumulator value.\r\n * @function module:list.scanr1\r\n * @param fn {Function}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanr1 = curry((fn, xs) => {\r\n if (!xs || !xs.length) {\r\n return [];\r\n }\r\n return scanr(fn, last(xs), init(xs));\r\n }),\r\n\r\n /**\r\n * The nub function removes duplicate elements from a list.\r\n * In particular, it keeps only the first occurrence of each element.\r\n * (The name nub means `essence'.) It is a special case of nubBy, which\r\n * allows the programmer to supply their own equality test.\r\n * ```shallowCompare( nub ([1,2,3,4,3,2,1,2,4,3,5]), [1,2,3,4,5] )```\r\n * @function module:list.nub\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n nub = list => nubBy((a, b) => a === b, list),\r\n\r\n /**\r\n * `remove(x, xs)` removes the first occurrence of `x` from `xs`.\r\n * For example, `remove('a', 'banana') === 'bnana';`\r\n * @function module:list.remove\r\n * @param x {*}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n remove = curry((x, list) => removeBy((a, b) => a === b, x, list)),\r\n\r\n /**\r\n * The sort function implements a stable sorting algorithm.\r\n * It is a special case of sortBy, which allows the programmer\r\n * to supply their own comparison function.\r\n * ```shallowCompare(sort ([1,6,4,3,2,5]), [1,2,3,4,5,6]) // true```\r\n * @function module:list.sort\r\n * @param xs {Array|String|*}\r\n * @returns {Array}\r\n */\r\n sort = xs => sortBy(genericAscOrdering, xs),\r\n\r\n /**\r\n * Sort a list by comparing the results of a key function applied to each\r\n * element. sortOn f is equivalent to sortBy (comparing f), but has the\r\n * performance advantage of only evaluating f once for each element in the\r\n * input list. This is called the decorate-sort-undecorate paradigm, or\r\n * Schwartzian transform.\r\n *\r\n * Elements are arranged from from lowest to highest, keeping duplicates\r\n * in the order they appeared in the input.\r\n *\r\n * Ex:\r\n * ```\r\n * shallowEquals(\r\n * sortOn (head, [[2, \"world\"], [4, \"!\"], [1, \"Hello\"]]),\r\n * [[1,\"Hello\"],[2,\"world\"],[4,\"!\"]]\r\n * ) // true\r\n * ```\r\n * @function module:list.sortOn\r\n * @param valueFn {Function}\r\n * @param xs {Array|String|*}\r\n * @returns {Array}\r\n */\r\n sortOn = curry((valueFn, xs) =>\r\n\r\n // Un-decorate\r\n map(decorated => decorated[1],\r\n\r\n // Decorate and sort\r\n sortBy(\r\n // Ordering\r\n ([a0], [b0]) => genericAscOrdering(a0, b0),\r\n\r\n // Decorate\r\n map(item => [valueFn(item), item], xs)\r\n )\r\n )\r\n ),\r\n\r\n /**\r\n * The sortBy function is the non-overloaded (in haskell terms) version of sort.\r\n * @haskellExample ```\r\n * >>> sortBy (\\(a,_) (b,_) -> compare a b) [(2, \"world\"), (4, \"!\"), (1, \"Hello\")]\r\n * [(1,\"Hello\"),(2,\"world\"),(4,\"!\")]\r\n * ```\r\n * @function module:list.sortBy\r\n * @param orderingFn {Function}\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sortBy = curry((orderingFn, xs) => sliceCopy(xs).sort(orderingFn || genericAscOrdering)),\r\n\r\n /**\r\n * The insert function takes an element and a list and inserts the element\r\n * into the list at the first position where it is less than or equal to the\r\n * next element. In particular, if the list is sorted before the call, the\r\n * result will also be sorted. It is a special case of insertBy, which allows\r\n * the programmer to supply their own comparison function.\r\n * @function module:list.insert\r\n * @param x {*}\r\n * @param xs {Array|*}\r\n * @returns {Array}\r\n */\r\n insert = curry((x, xs) => {\r\n if (!xs.length) {\r\n return of(xs, x);\r\n }\r\n const foundIndex = findIndex(item => x <= item, xs);\r\n return foundIndex === -1 ? concat([xs, of(xs, x)]) :\r\n concat(intersperse(of(xs, x), splitAt(foundIndex, xs)));\r\n }),\r\n\r\n /**\r\n * A version of `insert` that allows you to specify the ordering of the inserted\r\n * item; Before/at, or after\r\n * @function module:list.insertBy\r\n * @haskellType `insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]`\r\n * @note `Ordering` means 'something that is order-able'\r\n * operated on by this functions logic.\r\n * @param orderingFn {Function} - A function that returns `-1`, `0`, or 1`.\r\n * @param x {*} - Value to insert.\r\n * @param xs {Array} - List to insert into (note new list is returned)\r\n * @returns {Array} - New list.\r\n */\r\n insertBy = curry((orderingFn, x, xs) => {\r\n const limit = length(xs);\r\n if (!limit) {\r\n return [x];\r\n }\r\n let ind = 0;\r\n for (; ind < limit; ind += 1) {\r\n if (orderingFn(x, xs[ind]) <= 0) {\r\n const parts = splitAt(ind, xs);\r\n return concat([parts[0], [x], parts[1]]);\r\n }\r\n }\r\n return aggregateArray(sliceCopy(xs), x);\r\n }),\r\n\r\n /**\r\n * The nubBy function behaves just like nub, except it uses a user-supplied equality predicate.\r\n * @function module:list.nubBy\r\n * @param pred {Function}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n nubBy = curry((pred, list) => {\r\n if (!length(list)) {\r\n return [];\r\n }\r\n const limit = length(list);\r\n let ind = 0,\r\n currItem,\r\n out = [],\r\n anyOp = storedItem => pred(currItem, storedItem);\r\n for (; ind < limit; ind += 1) {\r\n currItem = list[ind];\r\n if (any(anyOp, out)) {\r\n continue;\r\n }\r\n out.push(currItem);\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Behaves the same as `remove`, but takes a user-supplied equality predicate.\r\n * @function module:list.removeBy\r\n * @param pred {Function} - Equality predicate `(a, b) => bool`\r\n * @param x {*}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n removeBy = curry((pred, x, list) => {\r\n const foundIndex = findIndex(item => pred(x, item), list);\r\n if (foundIndex > -1) {\r\n const parts = splitAt(foundIndex, list);\r\n return append(parts[0], tail(parts[1]));\r\n }\r\n return sliceCopy(list);\r\n }),\r\n\r\n /**\r\n * The `removeFirstsBy` function takes a predicate and two lists and returns the first list with the first\r\n * occurrence of each element of the second list removed.\r\n * @function module:list.removeFirstBy\r\n * @param pred {Function}\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {Array}\r\n */\r\n removeFirstsBy = curry((pred, xs1, xs2) =>\r\n foldl((agg, x) => removeBy(pred, x, agg), xs1, xs2)),\r\n\r\n /**\r\n * Returns the union on elements matching boolean check passed in.\r\n * @function module:list.unionBy\r\n * @param pred {Function} - `pred :: a -> a -> Bool`\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array}\r\n */\r\n unionBy = curry((pred, arr1, arr2) =>\r\n foldl((agg, b) => {\r\n const alreadyAdded = any(a => pred(a, b), agg);\r\n return !alreadyAdded ? (agg.push(b), agg) : agg;\r\n }, sliceCopy(arr1), arr2\r\n )),\r\n\r\n /**\r\n * Creates a union on matching elements from array1.\r\n * @function module:list.union\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array}\r\n */\r\n union = curry((arr1, arr2) =>\r\n append(arr1,\r\n filter(elm => !includes(elm, arr1), arr2))),\r\n\r\n /**\r\n * Performs an intersection on list 1 with elements from list 2.\r\n * @function module:list.intersect\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array}\r\n */\r\n intersect = curry((arr1, arr2) =>\r\n !arr1 || !arr2 || (!arr1 && !arr2) ? [] :\r\n filter(elm => includes(elm, arr2), arr1)),\r\n\r\n /**\r\n * Returns an intersection by predicate.\r\n * @function module:list.intersectBy\r\n * @param pred {Function} - `pred :: a -> b -> Bool`\r\n * @param list1 {Array}\r\n * @param list2 {Array}\r\n * @return {Array}\r\n */\r\n intersectBy = curry((pred, list1, list2) =>\r\n foldl((agg, a) =>\r\n any(b => pred(a, b), list2) ? (agg.push(a), agg) : agg\r\n , [], list1)),\r\n\r\n /**\r\n * Returns the difference of list 1 from list 2.\r\n * @note The `difference` operation here is non-associative; E.g., `a - b` is not equal to `b - a`;\r\n * @function module:list.difference\r\n * @param array1 {Array}\r\n * @param array2 {Array}\r\n * @returns {Array}\r\n */\r\n difference = curry((array1, array2) => { // augment this with max length and min length ordering on op\r\n if (array1 && !array2) {\r\n return sliceCopy(array1);\r\n }\r\n else if (!array1 && array2 || (!array1 && !array2)) {\r\n return [];\r\n }\r\n return reduce((agg, elm) =>\r\n !includes(elm, array2) ? (agg.push(elm), agg) : agg\r\n , [], array1);\r\n }),\r\n\r\n /**\r\n * Returns the complement of list 0 and the reset of the passed in arrays.\r\n * @function module:list.complement\r\n * @param arr0 {Array}\r\n * @param arrays {...Array}\r\n * @returns {Array}\r\n */\r\n complement = curry2((arr0, ...arrays) =>\r\n reduce((agg, arr) => append(agg, difference(arr, arr0)), [], arrays));\r\n","/**\r\n * @module errorThrowing\r\n * @description Contains error throwing facilities for when a value doesn't match a type.\r\n */\r\nimport {typeOf} from './object/typeOf';\r\nimport {isArray, toTypeRef, toTypeRefName, isOfType} from './object/is';\r\nimport {curry} from './function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Pretty prints an array of types/type-strings for use by error messages;\r\n * Outputs \"`SomeTypeName`, ...\" from [SomeType, 'SomeTypeName', etc...]\r\n * @function module:errorThrowing.typeRefsToStringOrError\r\n * @param types {Array|TypesArray}\r\n * @return {String}\r\n * @private\r\n */\r\n typeRefsToStringOrError = types => types.length ?\r\n types.map(type => `\\`${toTypeRefName(type)}\\``).join(', ') : '',\r\n\r\n /**\r\n * Prints a message from an object. Object signature:\r\n * {contextName, valueName, value, expectedTypeName, foundTypeName, messageSuffix}\r\n * @function module:errorThrowing.defaultErrorMessageCall\r\n * @param tmplContext {Object|TemplateContext} - Object to use in error template.\r\n * @returns {string}\r\n * @private\r\n */\r\n defaultErrorMessageCall = tmplContext => {\r\n const {\r\n contextName, valueName, value, expectedTypeName,\r\n foundTypeName, messageSuffix\r\n } = tmplContext,\r\n isMultiTypeNames = isArray(expectedTypeName),\r\n typesCopy = isMultiTypeNames ? 'of type' : 'of one of the types',\r\n typesToMatchCopy = isMultiTypeNames ? typeRefsToStringOrError(expectedTypeName) : expectedTypeName;\r\n return (contextName ? `\\`${contextName}.` : '`') +\r\n `${valueName}\\` is not ${typesCopy}: ${typesToMatchCopy}. ` +\r\n `Type received: ${foundTypeName}. Value: ${value};` +\r\n `${messageSuffix ? ' ' + messageSuffix + ';' : ''}`;\r\n },\r\n\r\n /**\r\n * Gets the error message thrower seeded with passed in errorMessage template call.\r\n * @function module:errorThrowing.getErrorIfNotTypeThrower$\r\n * @param errorMessageCall {Function|ErrorMessageCall}\r\n * @param typeChecker {Function|TypeChecker} - Function:Boolean\r\n * @returns {Function|ErrorIfNotType}\r\n * @private\r\n */\r\n _getErrorIfNotTypeThrower = (errorMessageCall, typeChecker = isOfType) =>\r\n (ValueType, contextName, valueName, value, messageSuffix = null) => {\r\n const expectedTypeName = toTypeRef(ValueType),\r\n foundTypeName = typeOf(value);\r\n if (typeChecker(ValueType, value)) { return value; } // Value matches type\r\n throw new Error(errorMessageCall(\r\n {contextName, valueName, value, expectedTypeName, foundTypeName, messageSuffix}\r\n ));\r\n },\r\n\r\n /**\r\n * Gets the error message thrower seeded with passed in errorMessage template call.\r\n * @function module:errorThrowing.getErrorIfNotTypesThrower$\r\n * @param errorMessageCall {Function|ErrorMessageCall}\r\n * @param typeChecker {Function|TypeChecker} - Function:Boolean\r\n * @returns {Function|ErrorIfNotTypes}\r\n * @private\r\n */\r\n _getErrorIfNotTypesThrower = (errorMessageCall, typeChecker = isOfType) =>\r\n (valueTypes, contextName, valueName, value, messageSuffix = null) => {\r\n const expectedTypeNames = valueTypes.map(toTypeRef),\r\n matchFound = valueTypes.some(ValueType => typeChecker(ValueType, value)),\r\n foundTypeName = typeOf(value);\r\n if (matchFound) { return value; }\r\n throw new Error(\r\n errorMessageCall({\r\n contextName, valueName, value,\r\n expectedTypeName: expectedTypeNames, foundTypeName,\r\n messageSuffix\r\n })\r\n );\r\n },\r\n\r\n /**\r\n * Checks that passed in `value` is of given `type`. Throws an error if value\r\n * is not of given `type`. This is the un-curried version. For the curried version\r\n * see `module:errorThrowing.errorIfNotType`.\r\n * @function module:errorThrowing.errorIfNotType$\r\n * @param type {String|Function} - Type's name or type itself.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @param [messageSuffix=null] {String} - Optional.\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @private\r\n */\r\n _errorIfNotType = _getErrorIfNotTypeThrower(defaultErrorMessageCall),\r\n\r\n /**\r\n * Checks that passed in `value` is of one of the given `types`. Throws an error if value\r\n * is not of one of the given `types`. This is the un-curried version. For the curried version\r\n * see `module:errorThrowing.errorIfNotTypes`.\r\n * @type {Function|module:errorThrowing.errorIfNotTypes}\r\n * @function module:errorThrowing.errorIfNotTypes$\r\n * @param types {Array} - Array of one or more types or type names themselves.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @private\r\n */\r\n _errorIfNotTypes = _getErrorIfNotTypesThrower(defaultErrorMessageCall),\r\n\r\n /**\r\n * Returns a function that can be used to ensure that values are of a given type.\r\n * Also throws informative error messages containing the value types, names, expected type names,\r\n * etc.\r\n * @function module:errorThrowing.getErrorIfNotTypeThrower\r\n * @param errorMessageCall {Function|ErrorMessageCall} - Template function (takes an info-object and returns a printed string).\r\n * @returns {Function|ErrorIfNotType} - Returns a function with the same signature as `errorIfNotType` though curried.\r\n */\r\n getErrorIfNotTypeThrower = errorMessageCall => curry(_getErrorIfNotTypeThrower(errorMessageCall)),\r\n\r\n /**\r\n * Returns a function that can be used to ensure that a value is of one or more given types.\r\n * The returned function is used in cases where informative error messages\r\n * containing the value types, names, expected type names, are-required/should-be-used etc.\r\n * @function module:errorThrowing.getErrorIfNotTypesThrower\r\n * @param errorMessageCall {Function|ErrorMessageCall} - Template function (takes an info-object and returns a printed string).\r\n * @returns {Function|ErrorIfNotTypes} - Returns a function with the same signature as `errorIfNotTypes` though curried.\r\n */\r\n getErrorIfNotTypesThrower = errorMessageCall => curry(_getErrorIfNotTypesThrower(errorMessageCall)),\r\n\r\n /**\r\n * Checks that passed in `value` is of given `type`. Throws an error if value\r\n * is not of given `type`. Curried.\r\n * @function module:errorThrowing.errorIfNotType\r\n * @param type {String|Function} - Type's name or type itself.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @param [messageSuffix=null] {String} - Optional.\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @curried\r\n */\r\n errorIfNotType = curry(_errorIfNotType),\r\n\r\n /**\r\n * Checks that passed in `value` is of one of the given `types`. Throws an error if value\r\n * is not of one of the given `types`. Curried.\r\n * @function module:errorThrowing.errorIfNotTypes\r\n * @param types {Array} - Array of one or more types or type names themselves.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @curried\r\n */\r\n errorIfNotTypes = curry(_errorIfNotTypes)\r\n;\r\n\r\n/**\r\n * @typedef {*} Any - Synonym for 'any value'.\r\n */\r\n\r\n/**\r\n * @typedef {String|Function} TypeRef\r\n * @description Type reference. Type itself or Type's name; E.g., `Type.name`;\r\n */\r\n\r\n/**\r\n * @typedef {Object} TemplateContext\r\n * @description Template context used for error message renderers (functions that take a context obj and return a string).\r\n * @property value {*}\r\n * @property valueName {String}\r\n * @property expectedTypeName {String} - Expected name of constructor of `value`; E.g., usually `SomeConstructor.name`;\r\n * @property foundTypeName {String} - Found types name; E.g., `FoundConstructor.name`;\r\n * @property [messageSuffix=null] {*} - Message suffix (sometimes an extra hint or instructions for\r\n * directing user to fix where his/her error has occurred). Optional.\r\n */\r\n\r\n/**\r\n * @typedef {Array<(String|Function)>} TypesArray\r\n */\r\n\r\n/**\r\n * @typedef {Function} TypeChecker\r\n * @description Checks whether a value is of given type.\r\n * @param Type {TypeRef} - a Type or it's name; E.g., `Type.name`.\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n\r\n/**\r\n * @typedef {Function} ErrorMessageCall\r\n * @description Error message template function.\r\n * @param tmplContext {TemplateContext}\r\n * @returns {String}\r\n */\r\n\r\n/**\r\n * @typedef {Function} ErrorIfNotType\r\n * @description Used to ensure value matches passed in type.\r\n * @param type {TypeRef} - Constructor name or constructor.\r\n * @param contextName {String}\r\n * @param valueName {String}\r\n * @param value {*}\r\n * @throws {Error} - If value doesn't match type.\r\n * @returns {*} - What ever value is.\r\n */\r\n\r\n/**\r\n * @typedef {Function} ErrorIfNotTypes\r\n * @description Used to ensure a value matches one of one or more types passed in.\r\n * @param valueTypes {TypesArray} - Array of constructor names or constructors.\r\n * @param contextName {String}\r\n * @param valueName {String}\r\n * @param value {*}\r\n * @throws {Error} - If value doesn't match type.\r\n * @returns {*} - Whatever value is.\r\n */\r\n","/**\r\n * @module string\r\n * @description Contains functions for strings.\r\n */\r\nimport {intercalate, map, filter} from './list';\r\nimport {split} from './jsPlatform/string';\r\nimport {compose} from './function/compose';\r\nimport {join} from './jsPlatform/array';\r\nimport {_errorIfNotType} from './errorThrowing';\r\n\r\nexport {split};\r\n\r\nexport const\r\n\r\n /**\r\n * Splits a string on all '\\n', '\\r', '\\n\\r', or '\\r\\n' characters.\r\n * @function module:string.lines\r\n * @param str {String}\r\n * @returns {Array}\r\n */\r\n lines = split(/[\\n\\r]/gm),\r\n\r\n /**\r\n * Splits a string on all '\\s' and/or all '\\t' characters.\r\n * @function module:string.words\r\n * @param str{String}\r\n * @returns {Array}\r\n */\r\n words = split(/[\\s\\t]/gm),\r\n\r\n /**\r\n * Intersperse an array of strings with '\\s' and then concats them.\r\n * @function module:string.unwords\r\n * @param arr {String}\r\n * @returns {Array}\r\n */\r\n unwords = intercalate(' '),\r\n\r\n /**\r\n * Intersperses a '\\n' character into a list of strings and then concats it.\r\n * @function module:string.unlines\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n unlines = intercalate('\\n'),\r\n\r\n /**\r\n * Lower cases first character of a non-empty string.\r\n * @function module:string.lcaseFirst\r\n * @param xs {String}\r\n * @returns {string}\r\n * @throws {Error} - Throws error if receiving anything that is not a string.\r\n */\r\n lcaseFirst = xs => {\r\n _errorIfNotType(String, 'lcaseFirst', 'xs', xs);\r\n return xs[0].toLowerCase() + xs.substring(1);\r\n },\r\n\r\n /**\r\n * Upper cases first character of a non-empty string.\r\n * @function module:string.ucaseFirst\r\n * @param xs {String}\r\n * @returns {string}\r\n * @throws {Error} - Throws error if receiving anything that is not a string.\r\n */\r\n ucaseFirst = xs => {\r\n _errorIfNotType(String, 'ucaseFirst', 'xs', xs);\r\n return xs[0].toUpperCase() + xs.substring(1);\r\n },\r\n\r\n /**\r\n * Camel cases (class case) a string.\r\n * @function module:string.camelCase\r\n * @param xs {String}\r\n * @param [pattern=/[^a-z\\d/i]/] {RegExp} - Pattern to split on. Optional.\r\n * @throws {Error} - Throws error if param `xs` is not a string.\r\n * @returns {string}\r\n * @curried\r\n */\r\n camelCase = (xs, pattern = /[^a-z\\d]/i) => compose(\r\n join(''),\r\n map(str => ucaseFirst(str.toLowerCase())),\r\n filter(x => !!x),\r\n split(pattern)\r\n )(_errorIfNotType(String, 'camelCase', 'xs', xs)),\r\n\r\n /**\r\n * Class cases a string. Uses pattern /[^a-z\\d/i]/ to split on.\r\n * If you require a different pattern use `string.camelCase(str, pattern)`\r\n * and then upper case first character (`ucaseFirst`).\r\n * @function module:string.classCase\r\n * @param xs {String}\r\n * @returns {string}\r\n * @throws {Error} - Throws error if `xs` is not a string (via `camelCase` call).\r\n */\r\n classCase = compose(ucaseFirst, camelCase)\r\n\r\n;\r\n\r\n/**\r\n * Functional version of `String.prototype.split`.\r\n * @function module:string.split\r\n * @param separator {String|RegExp}\r\n * @param str {String}\r\n * @returns {Array}\r\n */\r\n","/**\r\n * @module fjl\r\n * @description Exports all module methods (object, list, string modules etc.).\r\n * @goal to include everything from haskell's Prelude where it makes sense in order to create\r\n * a subset of functions which can make the javascript developer more efficient and make his/her\r\n * code more concise (and functional).\r\n * @motivation preludejs, lodash/fp, RamdaJs, Haskell.\r\n * @see http://hackage.haskell.org/package/base-4.10.0.0/docs/Prelude.html\r\n * @see http://hackage.haskell.org/package/base-4.10.0.0/docs/Data-List.html\r\n */\r\nexport * from './object';\r\nexport * from './boolean';\r\nexport * from './function';\r\nexport * from './list';\r\nexport * from './string';\r\nexport * from './utils';\r\nexport * from './errorThrowing';\r\n\r\n/**\r\n * @typedef {String|Function|ArrayBufferConstructor|ArrayConstructor|BooleanConstructor|MapConstructor|NumberConstructor|SetConstructor|WeakMapConstructor|WeakSetConstructor} TypeRef\r\n * @description Type reference. Either actual type or type's name; E.g., `Type.name`\r\n * Also note: Class cased names are use for values that do not have `name` properties; Namely: 'Null', 'NaN' and 'Undefined' (for their respective values respectively).\r\n */\r\n"],"names":["returnCurried","executeArity","unmetArityNum","fn","argsToCurry","func","x","executeAsCurriedFunc","Array","from","arguments","a","b","c","d","e","args","unmetArity","concatedArgs","concat","canBeCalled","length","newExpectedArity","curryN","Function","Error","curry","curry2","curry3","curry4","curry5","fPureTakesOne","name","arg","f","fPureTakes2","arg1","arg2","fPureTakes3","arg3","fPureTakes4","arg4","fPureTakes5","arg5","fPureTakesOneOrMore","defineReverse","prototype","reverse","reduceRight","agg","item","push","map","filter","reduce","forEach","some","every","join","apply","call","flipN","flip","flip3","flip4","flip5","instanceOf","instanceConstructor","instance","hasOwnProperty","native","Object","getOwnPropertyNames","key","operation","keys","assign","obj0","objs","topAgg","obj","_Number","Number","_NaN","_Null","_Undefined","typeOf","value","retVal","undefined","constructorName","constructor","isNaN","_String","String","_Object","_Boolean","Boolean","_Function","_Array","_Symbol","_Map","_Set","_WeakMap","_WeakSet","toTypeRef","type","toTypeRefs","types","toTypeRefName","Type","ref","toTypeRefNames","isFunction","isType","isOfType","isClass","test","substr","isCallable","isArray","isObject","isBoolean","isNumber","isString","isMap","isSet","isWeakMap","isWeakSet","isUndefined","isNull","isSymbol","isUsableImmutablePrimitive","typeOfX","isset","isEmptyList","isEmptyObject","isEmptyCollection","size","isEmpty","isOneOf","typeName","isFunctor","lookup","of","copy","out","slice","Symbol","Promise","searchObj","nsString","indexOf","parts","split","limit","ind","parent","node","assignDeep","propDescription","getOwnPropertyDescriptor","get","set","writable","includes","xs","lastIndexOf","isTruthy","isFalsy","alwaysTrue","alwaysFalse","equal","equalAll","i","aggregateArray","sliceFrom","startInd","sliceTo","toInd","sliceCopy","genericAscOrdering","lengths","lists","toShortest","listLengths","smallLen","Math","min","list","reduceUntil","pred","op","result","reduceUntilRight","arr","lastIndex","len","findIndexWhere","predicateFulfilled","findIndexWhereRight","findIndicesWhere","findWhere","elm","objUnion","obj1","obj2","objIntersect","objDifference","objComplement","log","console","bind","error","peek","pop","jsonClone","JSON","parse","stringify","toAssocList","toAssocListDeep","TypeConstraint","fromAssocList","OutType","fromAssocListDeep","toArray","compose","arg0","id","negateF","negateF2","negateF3","negateFN","until","predicate","typeInstance","fnOrError","symbolName","noop","normalizeStep","to","step","range","append","listAppend","head","last","tail","init","uncons","unconsr","item0","concatMap","foldableOfA","intersperse","between","lastInd","intercalate","xss","transpose","numLists","ind2","longestListLen","maximum","outLists","outList","subsequences","listLen","pow","entry","j","swapped","ind1","tmp","permutations","repeat","foldl","foldr","foldl1","foldr1","mapAccumL","zero","mapped","tuple","mapAccumR","iterate","lastX","replicate","cycle","unfoldr","resultTuple","findIndex","findIndices","elemIndex","foundInd","elemIndices","take","drop","splitAt","takeWhile","dropWhile","splitPoint","dropWhileEnd","span","breakOnList","at","find","partition","elem","notElem","isPrefixOf","xs1","xs2","limit1","limit2","isSuffixOf","isInfixOf","foundLen","isSubsequenceOf","lenXs1","group","groupBy","equalityOp","prevItem","predOp","inits","tails","stripPrefix","prefix","zip","arr1","arr2","a1","a2","zipN","trimmedLists","zip3","arr3","zip4","arr4","zip5","arr5","zipWith","zipWithN","lenOfTrimmed","zipWith3","xs3","zipWith4","xs4","zipWith5","xs5","unzip","unzipN","lenItem0","any","p","all","and","or","not","sum","product","sortBy","minimum","scanl","scanl1","scanr","scanr1","nub","nubBy","remove","removeBy","sort","sortOn","valueFn","decorated","a0","b0","orderingFn","insert","foundIndex","insertBy","currItem","anyOp","storedItem","removeFirstsBy","unionBy","alreadyAdded","union","intersect","intersectBy","list1","list2","difference","array1","array2","complement","arr0","arrays","typeRefsToStringOrError","defaultErrorMessageCall","tmplContext","contextName","valueName","expectedTypeName","foundTypeName","messageSuffix","isMultiTypeNames","typesCopy","typesToMatchCopy","_getErrorIfNotTypeThrower","errorMessageCall","typeChecker","ValueType","_getErrorIfNotTypesThrower","valueTypes","expectedTypeNames","matchFound","_errorIfNotType","_errorIfNotTypes","getErrorIfNotTypeThrower","getErrorIfNotTypesThrower","errorIfNotType","errorIfNotTypes","lines","words","unwords","unlines","lcaseFirst","toLowerCase","substring","ucaseFirst","toUpperCase","camelCase","pattern","str","classCase"],"mappings":"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"} \ No newline at end of file diff --git a/dist/es6-module/fjl.mjs b/dist/es6-module/fjl.mjs index a8033217..814d58e3 100644 --- a/dist/es6-module/fjl.mjs +++ b/dist/es6-module/fjl.mjs @@ -1676,5 +1676,11 @@ const classCase = compose(ucaseFirst, camelCase); * @see http://hackage.haskell.org/package/base-4.10.0.0/docs/Data-List.html */ +/** + * @typedef {String|Function|ArrayBufferConstructor|ArrayConstructor|BooleanConstructor|MapConstructor|NumberConstructor|SetConstructor|WeakMapConstructor|WeakSetConstructor} TypeRef + * @description Type reference. Either actual type or type's name; E.g., `Type.name` + * Also note: Class cased names are use for values that do not have `name` properties; Namely: 'Null', 'NaN' and 'Undefined' (for their respective values respectively). + */ + export { instanceOf, hasOwnProperty, length, native, keys, assign, lookup, typeOf, copy, toTypeRef, toTypeRefs, toTypeRefName, toTypeRefNames, isFunction, isType, isOfType, isClass, isCallable, isArray, isObject, isBoolean, isNumber, isString, isMap, isSet, isWeakMap, isWeakSet, isUndefined, isNull, isSymbol, isUsableImmutablePrimitive, isEmptyList, isEmptyObject, isEmptyCollection, isEmpty, isset, isOneOf, isFunctor, of, searchObj, assignDeep, objUnion, objIntersect, objDifference, objComplement, log, error, peek, jsonClone, toArray, toAssocList, toAssocListDeep, fromAssocList, fromAssocListDeep, isTruthy, isFalsy, alwaysTrue, alwaysFalse, equal, equalAll, apply, call, compose, curryN, curry, curry2, curry3, curry4, curry5, flipN, flip, flip3, flip4, flip5, id, negateF, negateF2, negateF3, negateFN, until, fnOrError, noop, map$1 as map, append, head, last, tail, init, uncons, unconsr, concat$1 as concat, concatMap, reverse$1 as reverse, intersperse, intercalate, transpose, subsequences, swapped, permutations, foldl, foldr, foldl1, foldr1, mapAccumL, mapAccumR, iterate, repeat, replicate, cycle, unfoldr, findIndex, findIndices, elemIndex, elemIndices, take, drop, splitAt, takeWhile, dropWhile, dropWhileEnd, span, breakOnList, at, find, forEach$1 as forEach, filter$1 as filter, partition, elem, notElem, isPrefixOf, isSuffixOf, isInfixOf, isSubsequenceOf, group, groupBy, inits, tails, stripPrefix, zip, zipN, zip3, zip4, zip5, zipWith, zipWithN, zipWith3, zipWith4, zipWith5, unzip, unzipN, any, all, and, or, not, sum, product, maximum, minimum, scanl, scanl1, scanr, scanr1, nub, remove, sort, sortOn, sortBy, insert, insertBy, nubBy, removeBy, removeFirstsBy, unionBy, union, intersect, intersectBy, difference, complement, slice, includes, indexOf, lastIndexOf, push, range, sliceFrom, sliceTo, sliceCopy, genericAscOrdering, lengths, toShortest, reduceUntil, reduceUntilRight, reduce$1 as reduce, reduceRight$1 as reduceRight, lastIndex, findIndexWhere, findIndexWhereRight, findIndicesWhere, findWhere, aggregateArray, split, lines, words, unwords, unlines, lcaseFirst, ucaseFirst, camelCase, classCase, fPureTakesOne, fPureTakes2, fPureTakes3, fPureTakes4, fPureTakes5, fPureTakesOneOrMore, typeRefsToStringOrError, defaultErrorMessageCall, _getErrorIfNotTypeThrower, _getErrorIfNotTypesThrower, _errorIfNotType, _errorIfNotTypes, getErrorIfNotTypeThrower, getErrorIfNotTypesThrower, errorIfNotType, errorIfNotTypes }; //# sourceMappingURL=fjl.mjs.map diff --git a/dist/es6-module/fjl.mjs.map b/dist/es6-module/fjl.mjs.map index d4256b31..36b2eb32 100644 --- a/dist/es6-module/fjl.mjs.map +++ b/dist/es6-module/fjl.mjs.map @@ -1 +1 @@ -{"version":3,"file":"fjl.mjs","sources":["../../src/function/curry.js","../../src/utils.js","../../src/jsPlatform/array.js","../../src/jsPlatform/function.js","../../src/function/flip.js","../../src/jsPlatform/object.js","../../src/object/typeOf.js","../../src/object/is.js","../../src/object/lookup.js","../../src/object/of.js","../../src/object/copy.js","../../src/object/searchObj.js","../../src/object/assignDeep.js","../../src/jsPlatform/list.js","../../src/boolean.js","../../src/list/map.js","../../src/list/aggregation.js","../../src/list/utils.js","../../src/object/setTheory.js","../../src/object/console.js","../../src/object/jsonClone.js","../../src/object/assocList.js","../../src/object/toArray.js","../../src/object.js","../../src/function/compose.js","../../src/function/id.js","../../src/function/negate.js","../../src/function/until.js","../../src/function/fnOrError.js","../../src/function/noop.js","../../src/function.js","../../src/list/range.js","../../src/jsPlatform/string.js","../../src/jsPlatform.js","../../src/list.js","../../src/errorThrowing.js","../../src/string.js","../../src/fjl.js"],"sourcesContent":["/**\r\n * @author elydelacruz\r\n * @created 12/6/2016.\r\n * @memberOf function\r\n * @description \"Curry strict\" and \"curry arbitrarily\" functions (`curry`, `curryN`).\r\n */\r\n\r\n/**\r\n * @private\r\n * @type {string}\r\n */\r\nconst\r\n\r\n /**\r\n * Returns curried function.\r\n * @private\r\n * @param executeArity {Number}\r\n * @param unmetArityNum {Number}\r\n * @param fn {Function}\r\n * @param argsToCurry {...*}\r\n * @returns {Function} - Curried function.\r\n */\r\n returnCurried = (executeArity, unmetArityNum, fn, argsToCurry) => {\r\n switch (unmetArityNum) {\r\n case 1:\r\n /* eslint-disable */\r\n return function func(x) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 2:\r\n /* eslint-disable */\r\n return function func(a, b) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 3:\r\n /* eslint-disable */\r\n return function func(a, b, c) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 4:\r\n /* eslint-disable */\r\n return function func(a, b, c, d) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 5:\r\n /* eslint-disable */\r\n return function func(a, b, c, d, e) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n default:\r\n return (...args) => executeAsCurriedFunc(fn, executeArity, unmetArityNum, args, argsToCurry);\r\n }\r\n },\r\n\r\n /**\r\n * Returns curried function if unmetArity is not met else returns result of executing\r\n * final function.\r\n * @private\r\n * @param fn {Function}\r\n * @param executeArity {Number}\r\n * @param unmetArity {Number}\r\n * @param args {Array<*>}\r\n * @param argsToCurry {Array<*>}\r\n * @returns {Function|*} - Curried function or result of 'finally' executed function.\r\n */\r\n executeAsCurriedFunc = (fn, executeArity, unmetArity, args, argsToCurry) => {\r\n let concatedArgs = argsToCurry.concat(args),\r\n canBeCalled = (concatedArgs.length >= executeArity) || !executeArity,\r\n newExpectedArity = executeArity - concatedArgs.length;\r\n return !canBeCalled ?\r\n returnCurried(executeArity, newExpectedArity, fn, concatedArgs) :\r\n fn(...concatedArgs);\r\n }\r\n;\r\n\r\nexport const\r\n\r\n /**\r\n * Curries a function up to a given arity.\r\n * @function module:function.curryN\r\n * @param executeArity {Number}\r\n * @param fn {Function}\r\n * @param argsToCurry {...*}\r\n * @returns {Function}\r\n * @throws {Error} - When `fn` is not a function.\r\n */\r\n curryN = (executeArity, fn, ...argsToCurry) => {\r\n if (!fn || !(fn instanceof Function)) {\r\n throw new Error(`\\`curry*\\` functions expect first parameter to be of type \\`Function\\` though received ${fn}?`);\r\n }\r\n return returnCurried(executeArity, executeArity - argsToCurry.length, fn, argsToCurry);\r\n },\r\n\r\n /**\r\n * Curries a function based on it's defined arity (note: rest args param (`...rest`) are not counted in arity).\r\n * @function module:function.curry\r\n * @param fn {Function}\r\n * @param argsToCurry {...*}\r\n * @returns {Function}\r\n */\r\n curry = (fn, ...argsToCurry) => curryN((fn || {}).length, fn, ...argsToCurry),\r\n\r\n /**\r\n * Curries a function up to an arity of 2 (won't call function until 2 or more args).\r\n * @function module:function.curry2\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry2 = fn => curryN(2, fn),\r\n\r\n /**\r\n * Curries a function up to an arity of 3 (won't call function until 3 or more args).\r\n * @function module:function.curry3\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry3 = fn => curryN(3, fn),\r\n\r\n /**\r\n * Curries a function up to an arity of 4 (won't call function until 4 or more args).\r\n * @function module:function.curry4\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry4 = fn => curryN(4, fn),\r\n\r\n /**\r\n * Curries a function up to an arity of 5 (won't call function until 5 or more args).\r\n * @function module:function.curry5\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry5 = fn => curryN(5, fn);\r\n","/**\r\n * @module utils\r\n */\r\nimport {curry, curry2} from './function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a function that takes an argument and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakesOne\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakesOne = name => curry((arg, f) => f[name](arg)),\r\n\r\n /**\r\n * Returns a function that takes 2 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes2\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes2 = name => curry((arg1, arg2, f) => f[name](arg1, arg2)),\r\n\r\n /**\r\n * Returns a function that takes 3 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes3\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes3 = name => curry((arg1, arg2, arg3, f) => f[name](arg1, arg2, arg3)),\r\n\r\n /**\r\n * Returns a function that takes 4 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes4\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes4 = name => curry((arg1, arg2, arg3, arg4, f) => f[name](arg1, arg2, arg3, arg4)),\r\n\r\n /**\r\n * Returns a function that takes 5 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes5\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes5 = name => curry((arg1, arg2, arg3, arg4, arg5, f) => f[name](arg1, arg2, arg3, arg4, arg5)),\r\n\r\n /**\r\n * Returns a function that takes an object and one or more arguments on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakesOneOrMore\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakesOneOrMore = name => curry2((f, ...args) => f[name](...args))\r\n\r\n;\r\n","/**\r\n * Created by elyde on 7/20/2017.\r\n * Functional versions of common array methods (`map`, `filter`, etc.) (un-curried);\r\n * @module _jsPlatform_arrayOps\r\n * @private\r\n */\r\n\r\nimport {fPureTakesOne, fPureTakes2, fPureTakesOneOrMore} from '../utils';\r\n\r\nexport const\r\n\r\n /**\r\n * Array.prototype.reverse generator (generates a function that calls the prototype version or a\r\n * shimmed version if it doesn't exist).\r\n * @returns {Function}\r\n */\r\n defineReverse = () =>\r\n Array.prototype.reverse ? x => x.reverse() :\r\n x => x.reduceRight((agg, item) => {\r\n agg.push(item);\r\n return agg;\r\n }, []),\r\n\r\n /**\r\n * Maps a function to functor (list etc.).\r\n * @function module:_jsPlatform_array.map\r\n * @param fn {Function}\r\n * @param functor {Array|{map: {Function}}}\r\n * @returns {Array|{map: {Function}}}\r\n */\r\n map = fPureTakesOne('map'),\r\n\r\n /**\r\n * Filters a functor (list etc.) with passed in function.\r\n * @function module:_jsPlatform_array.filter\r\n * @param fn {Function}\r\n * @param functor {Array|{filter: {Function}}}\r\n * @returns {Array|{filter: {Function}}}\r\n */\r\n filter = fPureTakesOne('filter'),\r\n\r\n /**\r\n * Reduces a foldable (list etc.) with passed in function.\r\n * @function module:_jsPlatform_array.reduce\r\n * @param fn {Function}\r\n * @param functor {Array|{reduce: {Function}}}\r\n * @returns {Array|{reduce: {Function}}}\r\n */\r\n reduce = fPureTakes2('reduce'),\r\n\r\n /**\r\n * Reduces a foldable (list etc.) from the right with passed in function.\r\n * @function module:_jsPlatform_array.reduceRight\r\n * @param fn {Function}\r\n * @param functor {Array|{reduceRight: {Function}}}\r\n * @returns {Array|{reduceRight: {Function}}}\r\n */\r\n reduceRight = fPureTakes2('reduceRight'),\r\n\r\n /**\r\n * For each on functor (Array|Object|etc.).\r\n * @param fn {Function}\r\n * @param functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type of object you pass in unless it doesn't have a `forEach` method.\r\n * @throws {Error} - When passed in functor doesn't have a `forEach` method.\r\n */\r\n forEach = fPureTakesOne('forEach'),\r\n\r\n /**\r\n * Returns `true` if `fn` (predicate) returns true for at least one item\r\n * in functor else returns `false`.\r\n * @param fn {Function} - Predicate.\r\n * @param functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type passed.\r\n * @throws {Error} - When passed in object doesn't have a `some` method.\r\n */\r\n some = fPureTakesOne('some'),\r\n\r\n /**\r\n * Returns `true` if `fn` (predicate) returns true for all items in functor else returns `false`.\r\n * @param fn {Function} - Predicate.\r\n * @param functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type passed.\r\n * @throws {Error} - When passed in object doesn't have an `every` method.\r\n */\r\n every = fPureTakesOne('every'),\r\n\r\n /**\r\n * Array.prototype.join\r\n * @function module:listPrelude.join\r\n * @param separator {String|RegExp}\r\n * @param arr {Array}\r\n * @returns {String}\r\n */\r\n join = fPureTakesOne('join'),\r\n\r\n /**\r\n * Same as Array.prototype.push\r\n * @param item {*}\r\n * @param arr {Array}\r\n * @returns {Number}\r\n */\r\n push = fPureTakesOneOrMore('push'),\r\n\r\n /**\r\n * Reverses an list (shimmed if not exists).\r\n * @function module:listPrelude.reverse\r\n * @return {Array}\r\n */\r\n reverse = defineReverse();\r\n","import {curry, curry2} from '../function/curry';\r\n\r\n/**\r\n * Created by elydelacruz on 9/7/2017.\r\n * @memberOf function\r\n */\r\nexport const\r\n\r\n /**\r\n * Functional `apply` function (takes no context).\r\n * @function module:function.apply\r\n * @param fn {Function}\r\n * @param args {Array|*}\r\n * @returns {*}\r\n */\r\n apply = curry((fn, args) => fn.apply(null, args)),\r\n\r\n /**\r\n * Functional `call` function (takes no context).\r\n * @function module:function.call\r\n * @param fn {Function}\r\n * @param args {...*}\r\n * @returns {*}\r\n */\r\n call = curry2((fn, ...args) => fn.call(null, ...args));\r\n","import {reverse} from '../jsPlatform/array';\r\nimport {apply, call} from '../jsPlatform/function';\r\nimport {curry, curry2} from './curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a curried function requiring given functions arguments in reverse\r\n * (returned function expects 2 or more variables (curried at 2 or more args)).\r\n * @function module:function.flipN\r\n * @param fn {Function}\r\n * @returns {Function}\r\n * @curried\r\n */\r\n flipN = fn => curry2((...args) => apply(fn, reverse(args))),\r\n\r\n /**\r\n * Flips a function's first and second arguments and and returns a new function requiring said arguments in reverse.\r\n * @function module:function.flip\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip = fn => curry((b, a) => call(fn, a, b)),\r\n\r\n /**\r\n * Same as `flip` except returns a flipped function of arity 3.\r\n * @function module:function.flip3\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip3 = fn => curry((c, b, a) => call(fn, a, b, c)),\r\n\r\n /**\r\n * Same as `flip` except returns a flipped function of arity 4.\r\n * @function module:function.flip4\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip4 = fn => curry((d, c, b, a) => call(fn, a, b, c, d)),\r\n\r\n /**\r\n * Same as `flip` except returns a flipped function of arity 5.\r\n * @function module:function.flip5\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip5 = fn => curry((e, d, c, b, a) => call(fn, a, b, c, d, e));\r\n","/**\r\n * @memberOf object\r\n * @description Defines some of the platform methods for objects (the ones used within `fjl`).\r\n */\r\n\r\nimport {fPureTakesOne} from '../utils';\r\nimport {curry, curry2} from '../function/curry';\r\nimport {flip, flip3, flip4, flip5} from '../function/flip';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns whether constructor has derived object.\r\n * @function module:object.instanceOf\r\n * @param instanceConstructor {Function} - Constructor.\r\n * @param instance {*}\r\n * @instance {*}\r\n * @returns {Boolean}\r\n */\r\n instanceOf = curry((instanceConstructor, instance) =>\r\n instance instanceof instanceConstructor),\r\n\r\n /**\r\n * @function module:object.hasOwnProperty\r\n * @param propName {*}\r\n * @param typeInstance {*}\r\n * @returns {Boolean}\r\n * @deprecated - Use property directly instead.\r\n */\r\n hasOwnProperty = fPureTakesOne('hasOwnProperty'),\r\n\r\n /**\r\n * @function module:object.length\r\n * @param x {*}\r\n * @returns {Number}\r\n * @throws {Error} - Throws an error if value doesn't have a `length` property (\r\n * `null`, `undefined`, {Boolean}, Symbol, et. al.).\r\n */\r\n length = x => x.length,\r\n\r\n /**\r\n * Contains all the static functions from `Object` but curried and flipped;\r\n * @example\r\n * // E.g., `Object.defineProperties(obj, descriptor)` can now be used like\r\n * import {defineProperties} from 'fjl'\r\n * defineProperties(descriptor, someObj),\r\n * // Et. al.\r\n * @memberOf module:object\r\n * @type {{...Object}}\r\n */\r\n native = Object.getOwnPropertyNames(Object).reduce((agg, key) => {\r\n if (typeof Object[key] !== 'function') {\r\n return agg;\r\n }\r\n const operation = Object[key];\r\n switch (operation.length) {\r\n case 2:\r\n agg[key] = flip(operation);\r\n break;\r\n case 3:\r\n agg[key] = flip3(operation);\r\n break;\r\n case 4:\r\n agg[key] = flip4(operation);\r\n break;\r\n case 5:\r\n agg[key] = flip5(operation);\r\n break;\r\n default:\r\n agg[key] = Object[key];\r\n break;\r\n }\r\n return agg;\r\n }, {}),\r\n\r\n /**\r\n * Gets passed in object's own enumerable keys (same as `Object.keys`).\r\n * @function module:object.keys\r\n * @param obj {*}\r\n * @returns {Array}\r\n */\r\n {keys} = native,\r\n\r\n /**\r\n * Defined as `Object.assign` else is the same thing but shimmed.\r\n * @function module:object.assign\r\n * @param obj0 {Object}\r\n * @param objs {...{Object}}\r\n * @returns {Object}\r\n */\r\n assign = (() => Object.assign ?\r\n (obj0, ...objs) => Object.assign(obj0, ...objs) :\r\n curry2((obj0, ...objs) => objs.reduce((topAgg, obj) => {\r\n return Object.keys(obj).reduce((agg, key) => {\r\n agg[key] = obj[key];\r\n return agg;\r\n }, topAgg);\r\n }, obj0))\r\n )();\r\n","/**\r\n * Created by elyde on 12/18/2016.\r\n * @memberOf object\r\n */\r\nconst _Number = Number.name,\r\n _NaN = 'NaN',\r\n _Null = 'Null',\r\n _Undefined = 'Undefined';\r\n\r\n/**\r\n * Returns the constructor/class/type name of a value.\r\n * @note Returns 'NaN' if value is of type `Number` and value is `isNaN`.\r\n * @note Returns 'Undefined' if value is `undefined`\r\n * @note Returns 'Null' if value is `null`\r\n * For values that have no concrete constructors and/or casters\r\n * (null, NaN, and undefined) we returned normalized names for them ('Null', 'NaN', 'Number')\r\n * @function module:object.typeOf\r\n * @param value {*}\r\n * @returns {string} - Constructor's name or derived name (in the case of `null`, `undefined`, or `NaN` (whose\r\n * normalized names are 'Null', 'Undefined', 'NaN' respectively).\r\n */\r\nexport function typeOf (value) {\r\n let retVal;\r\n if (value === undefined) {\r\n retVal = _Undefined;\r\n }\r\n else if (value === null) {\r\n retVal = _Null;\r\n }\r\n else {\r\n let constructorName = (value).constructor.name;\r\n retVal = constructorName === _Number && isNaN(value) ?\r\n _NaN : constructorName;\r\n }\r\n return retVal;\r\n}\r\n","/**\r\n * Created by elyde on 12/18/2016.\r\n * @memberOf object\r\n */\r\n\r\nimport {typeOf} from './typeOf';\r\nimport {instanceOf, length, keys} from '../jsPlatform/object';\r\nimport {curry} from '../function/curry';\r\n\r\nlet _String = String.name,\r\n _Number = Number.name,\r\n _Object = Object.name,\r\n _Boolean = Boolean.name,\r\n _Function = Function.name,\r\n _Array = Array.name,\r\n _Symbol = 'Symbol',\r\n _Map = 'Map',\r\n _Set = 'Set',\r\n _WeakMap = 'WeakMap',\r\n _WeakSet = 'WeakSet',\r\n _Null = 'Null',\r\n _Undefined = 'Undefined',\r\n _NaN = 'NaN';\r\n\r\nexport const\r\n\r\n /**\r\n * Resolves/normalizes a type name from either a string or a constructor.\r\n * @function module:object.toTypeRef\r\n * @param type {Function|String} - String or function representing a type.\r\n * @returns {String}\r\n * @todo write tests for this function.\r\n */\r\n toTypeRef = type => {\r\n if (!type) {\r\n return typeOf(type);\r\n }\r\n else if (type.constructor === String || (type instanceof Function)) {\r\n return type;\r\n }\r\n return typeOf(type);\r\n },\r\n\r\n /**\r\n * Returns an array of type refs from possible type refs (converts null, undefined, NaN, and other values into\r\n * type refs (either constructor name or constructor name based on whether value(s) is a string, a constructor, or not).\r\n * @function module:object.toTypeRefs\r\n * @param types {...(TypeRef|*)}\r\n * @returns {Array}\r\n * @todo Ensure tests are written for this function.\r\n */\r\n toTypeRefs = (...types) => types.map(toTypeRef),\r\n\r\n /**\r\n * Returns possible Type's TypeRef name.\r\n * @function module:object.toTypeRefName\r\n * @param Type {(TypeRef|*)}\r\n * @returns {String}\r\n * @todo Ensure tests are written for this function.\r\n */\r\n toTypeRefName = Type => {\r\n const ref = toTypeRef(Type);\r\n return ref instanceof Function ? ref.name : ref;\r\n },\r\n\r\n /**\r\n * Returns possible Types' TypeRef names.\r\n * @function module:object.toTypeRefNames\r\n * @param types {...(TypeRef|*)}\r\n * @returns {String[]}\r\n * @todo Ensure tests are written for this function.\r\n */\r\n toTypeRefNames = (...types) => types.map(toTypeRefName),\r\n\r\n /**\r\n * Returns whether a value is a function or not.\r\n * @function module:object.isFunction\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isFunction = instanceOf(Function),\r\n\r\n /**\r\n * Strict type checker. Checks if given value is a direct instance of given type; E.g.,\r\n * @example\r\n * isType(String, 'abcdefg') === true // true\r\n * isType(String.name, 'abcdefg') === true\r\n * isType(Number, NaN) === false\r\n * isType(Number, 99) === true\r\n * isType('Null', 99) === false // though, for `null` and `undefined` checks\r\n * // @see `isset`, in this module, instead\r\n * isType('Undefined', undefined) === true // true\r\n *\r\n * @note Useful where absolute types, or some semblance thereof, are required.\r\n * @function module:object.isType\r\n * @param type {Function|ObjectConstructor|String} - Constructor or constructor name\r\n * @param obj {*}\r\n * @return {Boolean}\r\n */\r\n isType = curry((type, obj) => typeOf(obj) === toTypeRefName(type)),\r\n\r\n /**\r\n * Loose type checker; E.g., If `type` is not a constructor, but a constructor name, does a type check on\r\n * constructor names, else if first check fails and `type` is a constructor, performs an `instanceof` check\r\n * on value with constructor.\r\n * @note Use care when checking for `Array` and/or `Object` since the both are considered objects by `instanceof` checker.\r\n * @note For `null` and `undefined` their class cased names can be used for type checks\r\n * `isOfType('Null', null) === true (passes strict type check)` (or better yet `isset` can be used).\r\n * @throwsafe - Doesn't throw on `null` or `undefined` `obj` values.\r\n * @example\r\n * isOfType(Number, 99) === true // true (passes strict type check (numbers are not instances of `Number`\r\n * // constructor)\r\n * isOfType('Number', 99) === true // true (passes strict type check)\r\n * isOfType(Number, NaN) === true // true. (passes instance of check)\r\n * // If you want \"true\" strict type checking use `isType`\r\n * isOfType(Object, []) === true // true (passes instance of check)\r\n * isOfType(Array, []) === true // true (passes instance of check)\r\n * isOfType(Object, {}) === true // true (passes instance of check)\r\n * isOfType(Object.name, {}) === true // true (Passes strict type check)\r\n * class Abc extends String {}\r\n * isOfType(String, new Abc('abcd')) // true (passes instanceof check)\r\n *\r\n * @function module:object.isOfType\r\n * @param type {Function|String} - Type reference (constructor or `constructor.name`).\r\n * @param x {*} - Value to check.\r\n * @returns {Boolean}\r\n */\r\n isOfType = curry((type, x) => isType(type, x) || instanceOf(type, x)),\r\n\r\n /**\r\n * Checks if `value` is an es2015 `class`.\r\n * @function module:object.isClass\r\n * @param x {*}\r\n * @returns {boolean}\r\n */\r\n isClass = x => x && /^\\s{0,3}class\\s{1,3}/.test((x + '').substr(0, 10)),\r\n\r\n /**\r\n * Returns a boolean depicting whether a value is callable or not.\r\n * @function module:object.isCallable\r\n * @tentative\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isCallable = x => isFunction(x) && !isClass(x),\r\n\r\n /**\r\n * Checks if value is an array (same as `Array.isArray`).\r\n * @function module:object.isArray\r\n * @param value {*}\r\n * @returns {boolean}\r\n */\r\n {isArray} = Array,\r\n\r\n /**\r\n * Checks whether value is an object or not.\r\n * @function module:object.isObject\r\n * @param value\r\n * @returns {Boolean}\r\n */\r\n isObject = isType(_Object),\r\n\r\n /**\r\n * Checks if value is a boolean.\r\n * @function module:object.isBoolean\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isBoolean = isType(_Boolean),\r\n\r\n /**\r\n * Checks if value is a valid number (also checks if isNaN so that you don't have to).\r\n * @function module:object.isNumber\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isNumber = isType(_Number),\r\n\r\n /**\r\n * Checks whether value is a string or not.\r\n * @function module:object.isString\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isString = isType(_String),\r\n\r\n /**\r\n * Checks whether value is of `Map` or not.\r\n * @function module:object.isMap\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isMap = isType(_Map),\r\n\r\n /**\r\n * Checks whether value is of `Set` or not.\r\n * @function module:object.isSet\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isSet = isType(_Set),\r\n\r\n /**\r\n * Checks whether value is of `WeakMap` or not.\r\n * @function module:object.isWeakMap\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isWeakMap =isType(_WeakMap),\r\n\r\n /**\r\n * Checks whether value is of `WeakSet` or not.\r\n * @function module:object.isWeakSet\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isWeakSet = isType(_WeakSet),\r\n\r\n /**\r\n * Checks if value is undefined.\r\n * @function module:object.isUndefined\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isUndefined = isType(_Undefined),\r\n\r\n /**\r\n * Checks if value is null.\r\n * @function module:object.isNull\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isNull = isType(_Null),\r\n\r\n /**\r\n * Checks if value is a `Symbol`.\r\n * @function module:object.isSymbol\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isSymbol = isType(_Symbol),\r\n\r\n /**\r\n * Checks if given `x` is set and of one of\r\n * [String, Boolean, Number, Symbol] (null and undefined are immutable\r\n * but are not \"usable\" (usually not what we want to operate on).\r\n * @function module:object.isUsableImmutablePrimitive\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isUsableImmutablePrimitive = x => {\r\n const typeOfX = typeOf(x);\r\n return isset(x) &&\r\n [_String, _Number, _Boolean, _Symbol]\r\n .some(Type => Type === typeOfX);\r\n },\r\n\r\n /**\r\n * Checks if !length.\r\n * @function module:object.isEmptyList\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isEmptyList = x => !length(x),\r\n\r\n /**\r\n * Checks if object has own properties/enumerable-props or not.\r\n * @function module:object.isEmptyObject\r\n * @param obj {*}\r\n * @returns {Boolean}\r\n */\r\n isEmptyObject = obj => isEmptyList(keys(obj)),\r\n\r\n /**\r\n * Checks if collection is empty or not (Map, WeakMap, WeakSet, Set etc.).\r\n * @function module:object.isEmptyCollection\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isEmptyCollection = x => x.size === 0,\r\n\r\n /**\r\n * Checks to see if passed in value is empty; I.e.,\r\n * check for one of '', 0, `null`, `undefined`, `false`, empty array, empty object, empty function (zero arity),\r\n * or empty collection (es6 Map, Set, WeakMap, or WeakSet etc. (`!value.size`);\r\n * @function module:object.isEmpty\r\n * @param value {*} - Value to check.\r\n * @returns {Boolean}\r\n */\r\n isEmpty = value => {\r\n if (!value) { // if '', 0, `null`, `undefined`, or `false` then is empty\r\n return true;\r\n }\r\n switch (typeOf(value)) {\r\n case _Array:\r\n case _Function:\r\n return !value.length;\r\n case _Number: // zero and NaN checks happened above so `if number` then it's 'not-an-empty-number' (lol)\r\n return false;\r\n case _Object:\r\n return !keys(value).length;\r\n case _Map:\r\n case _Set:\r\n case _WeakSet:\r\n case _WeakMap:\r\n return !value.size;\r\n case _NaN:\r\n return true;\r\n default:\r\n return !value;\r\n }\r\n },\r\n\r\n /**\r\n * Returns whether passed in values is defined and not null or not.\r\n * @function module:object.isset\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isset = x => x !== null && x !== undefined,\r\n\r\n /**\r\n * Checks to see if `x` is of one of the given type refs.\r\n * @function object.isOneOf\r\n * @param x {*}\r\n * @param types {...(TypeRef|*)}\r\n * @returns {boolean}\r\n * @todo write tests for this function.\r\n */\r\n isOneOf = (x, ...types) => {\r\n const typeName = typeOf(x);\r\n return toTypeRefNames(types).some(name => typeName === name);\r\n },\r\n\r\n isFunctor = x => x && x.map && instanceOf(Function, x.map)\r\n\r\n;\r\n","/**\r\n * @memberOf object\r\n */\r\n\r\nimport {isset} from './is';\r\nimport {curry} from '../function/curry';\r\n\r\n/**\r\n * Looks up property and returns it's value; Else `undefined`.\r\n * Method is null safe (will not throw on `null` or `undefined`).\r\n * @function module:object.lookup\r\n * @param key {String} - Key to search on `obj`\r\n * @param obj {Object} - Object to search `name` on.\r\n * @returns {*}\r\n */\r\nexport const lookup = curry((key, obj) => isset(obj) ? obj[key] : undefined);\r\n","import {isFunction, isset, isUsableImmutablePrimitive} from './is';\r\nimport {apply} from '../jsPlatform/function';\r\n\r\n/**\r\n * Creates a value `of` given type; Checks for one of the following construction strategies (in order listed):\r\n * @example\r\n * // - If exists `(value).constructor.of` uses this.\r\n * // - If value is of one String, Boolean, Symbol, or Number types calls it's\r\n * // constructor as a function (in cast form; E.g., `constructor(...args)` )\r\n * // - Else if constructor is a function, thus far, then calls constructor using\r\n * // the `new` keyword (with any passed in args).\r\n\r\n * @function module:object.of\r\n * @param x {*} - Value to derive returned value's type from.\r\n * @param [args] {...*} - Any args to pass in to matched construction strategy.\r\n * @returns {*|undefined} - New value of given value's type else `undefined`.\r\n */\r\nexport const of = (x, ...args) => {\r\n if (!isset(x)) { return undefined; }\r\n const constructor = x.constructor;\r\n if (constructor.hasOwnProperty('of')) {\r\n return apply(constructor.of, args);\r\n }\r\n else if (isUsableImmutablePrimitive(x)) {\r\n return apply(constructor, args);\r\n }\r\n else if (isFunction(constructor)) {\r\n return new constructor(...args);\r\n }\r\n return undefined;\r\n};\r\n","import {typeOf} from './typeOf';\r\nimport {of} from './of';\r\n\r\nexport const\r\n\r\n /**\r\n * Make a copy of a value or optionally copy incoming value onto an outgoing value (second parameter).\r\n * @note If incoming thing is an immmutable primitive (string, number, symbol, null, undefined, boolean)\r\n * it is returned as is.\r\n * @function module:object.copy\r\n * @param x {*} - Thing to copy.\r\n * @param [out = undefined] {*} - Optional value to copy on to. Not required.\r\n * @returns {*} - Copied thing or optionally outgoing value copied onto.\r\n */\r\n copy = (x, out) => {\r\n // if `null`, `undefined`, `''`, `0`, `false` return\r\n if (!x) { return x; }\r\n switch (typeOf(x)) {\r\n case Array.name:\r\n return !out ? x.slice(0) : Object.assign(out, x);\r\n\r\n // If immutable primitive, return it\r\n case Symbol.name:\r\n case Boolean.name:\r\n case String.name:\r\n case Number.name:\r\n case Promise.name:\r\n case Function.name:\r\n case 'NaN':\r\n case 'Null':\r\n case 'Undefined':\r\n return x;\r\n\r\n case 'Map':\r\n case 'Set':\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n return new x.constructor(Array.from(x));\r\n\r\n // Else make copy\r\n default:\r\n return Object.assign(!out ? of(x) : out, x);\r\n }\r\n }\r\n;\r\n\r\nexport default copy;\r\n","import {isset} from './is';\r\nimport {curry} from '../function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Gives you value at key/namespace-key within `obj`; E.g.,\r\n * searchObj('all.your.base', {all: {your: {base: 99}}}) === 99 // `true`\r\n * @note If key is unreachable (undefined) returns `undefined`.\r\n * Useful in cases where we do not want to check each key along the way before getting/checking value; E.g.,\r\n * @example\r\n * ```\r\n * if (obj && obj.all && obj.all.your && obj.all.your.base) {\r\n * // Thing we want to do\r\n * }\r\n *\r\n * // So with our function becomes\r\n * if (searchObj('all.your.base', obj)) {\r\n * // Thing we want to do\r\n * }\r\n * ```\r\n * @function module:object.searchObj\r\n * @param nsString {String}\r\n * @param obj {*}\r\n * @returns {*}\r\n */\r\n searchObj = curry((nsString, obj) => {\r\n if (!obj) { return obj; }\r\n if (nsString.indexOf('.') === -1) {\r\n return obj[nsString];\r\n }\r\n const parts = nsString.split('.'),\r\n limit = parts.length;\r\n let ind = 0,\r\n parent = obj;\r\n for (; ind < limit; ind += 1) {\r\n const node = parent[parts[ind]];\r\n if (!isset(node)) {\r\n return node;\r\n }\r\n parent = node;\r\n }\r\n return parent;\r\n })\r\n;\r\n","\r\nimport {isObject} from './is';\r\nimport {keys} from '../jsPlatform/object';\r\nimport {curry2} from '../function/curry';\r\n\r\nexport const\r\n /**\r\n * Merges all objects down into one (takes two or more args).\r\n * @function module:object.assignDeep\r\n * @param obj0 {Object}\r\n * @param [objs] {...{Object}} - One or more objects to merge onto `obj0`.\r\n * @returns {Object}\r\n */\r\n assignDeep = curry2((obj0, ...objs) =>\r\n !obj0 ? obj0 : objs.reduce((topAgg, obj) =>\r\n !obj ? topAgg : keys(obj).reduce((agg, key) => {\r\n let propDescription = Object.getOwnPropertyDescriptor(agg, key);\r\n // If property is not writable move to next item in collection\r\n if (agg.hasOwnProperty(key) && propDescription &&\r\n !(propDescription.get && propDescription.set) &&\r\n !propDescription.writable) {\r\n return agg;\r\n }\r\n if (isObject(agg[key]) && isObject(obj[key])) {\r\n assignDeep(agg[key], obj[key]);\r\n }\r\n else { agg[key] = obj[key]; }\r\n return agg;\r\n }, topAgg)\r\n , obj0));\r\n","/**\r\n * List operations that overlap (apart from globally overlapping props and functions like `length`)\r\n * on both strings and arrays.\r\n * @memberOf list\r\n */\r\n\r\nimport {fPureTakesOne, fPureTakes2, fPureTakesOneOrMore} from '../utils';\r\n\r\nexport const\r\n\r\n /**\r\n * Concats/appends all functors onto the end of first functor.\r\n * Note: functors passed in after the first one must be of the same type.\r\n * @function module:list.concat\r\n * @param functor {Array|Object|*}\r\n * @param ...functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type passed.\r\n * @throws {Error} - When passed in object doesn't have an `every` method.\r\n */\r\n concat = fPureTakesOneOrMore('concat'),\r\n\r\n /**\r\n * Same as Array.prototype.slice\r\n * @function module:list.slice\r\n * @param separator {String|RegExp}\r\n * @param arr{Array}\r\n * @returns {Array}\r\n */\r\n slice = fPureTakes2('slice'),\r\n\r\n /**\r\n * `Array.prototype.includes` or shim.\r\n * @function module:list.includes\r\n * @param value {*}\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n includes = (() => 'includes' in Array.prototype ?\r\n fPureTakesOne('includes') :\r\n (value, xs) => xs.indexOf(value) > -1)(),\r\n\r\n /**\r\n * Searches list/list-like for given element `x`.\r\n * @function module:list.indexOf\r\n * @param x {*} - Element to search for.\r\n * @param xs {Array|String|*} - list or list like to look in.\r\n * @returns {Number} - `-1` if element not found else index at which it is found.\r\n */\r\n indexOf = fPureTakesOne('indexOf'),\r\n\r\n /**\r\n * Last index of (`Array.prototype.lastIndexOf`).\r\n * @function module:list.lastIndexOf\r\n * @param x {*} - Element to search for.\r\n * @param xs {Array|String|*} - list or list like to look in.\r\n * @returns {Number} - `-1` if element not found else index at which it is found.\r\n */\r\n lastIndexOf = fPureTakesOne('lastIndexOf')\r\n\r\n;\r\n","/**\r\n * @module boolean\r\n * @description Contains functional version of 'always-true', 'always-false', 'is-truthy', and 'is-falsy'.\r\n */\r\nimport {curry, curry2} from './function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns whether `value` is 'truthy' or not\r\n * @function module:boolean.isTruthy\r\n * @param value\r\n * @returns {Boolean}\r\n */\r\n isTruthy = value => !!value,\r\n\r\n /**\r\n * Returns whether `value` is 'falsy' or not\r\n * @function module:boolean.isFalsy\r\n * @param value\r\n * @returns {Boolean}\r\n */\r\n isFalsy = value => !value,\r\n\r\n /**\r\n * Returns `true`.\r\n * @function module:boolean.alwaysTrue\r\n * @returns {Boolean}\r\n */\r\n alwaysTrue = () => true,\r\n\r\n /**\r\n * Returns `false`.\r\n * @function module:boolean.alwaysFalse\r\n * @returns {Boolean}\r\n */\r\n alwaysFalse = () => false,\r\n\r\n /**\r\n * Equality operator.\r\n * @function module:boolean.equal\r\n * @param a {*}\r\n * @param b {*}\r\n * @returns {boolean}\r\n */\r\n equal = curry((a, b) => a === b),\r\n\r\n /**\r\n * Equality operator for all.\r\n * @function module:boolean.equalAll\r\n * @param a {*} - Item `0`.\r\n * @param args {...*} - Others\r\n * @returns {boolean}\r\n */\r\n equalAll = curry2((a, ...args) => args.every(b => equal(a, b)))\r\n\r\n;\r\n","import {length} from '../jsPlatform/object';\r\nimport {curry} from '../function/curry';\r\nimport {typeOf} from '../object/typeOf';\r\nimport {of} from '../object/of';\r\nimport {isFunctor, isset} from '../object/is';\r\n\r\n/**\r\n * Maps a function onto a List (string or array) or a functor (value containing a map method).\r\n * @function module:list.map\r\n * @param fn {Function} - Function to map on given value.\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\nconst map = curry((fn, xs) => {\r\n if (!isset(xs)) { return xs; }\r\n let out = of(xs),\r\n limit,\r\n i = 0;\r\n switch (typeOf(xs)) {\r\n case 'Array':\r\n limit = length(xs);\r\n if (!limit) { return out; }\r\n for (; i < limit; i += 1) {\r\n out.push(fn(xs[i], i, xs));\r\n }\r\n return out;\r\n case 'String':\r\n limit = length(xs);\r\n if (!xs) { return out; }\r\n for (; i < limit; i += 1) {\r\n out += fn(xs[i], i, xs);\r\n }\r\n return out;\r\n default:\r\n if (isFunctor(xs)) { return xs.map(fn); }\r\n\r\n // Other objects\r\n return Object.keys(xs).reduce((agg, key) => {\r\n out[key] = fn(xs[key], key, xs);\r\n return out;\r\n }, out);\r\n }\r\n});\r\n\r\nexport default map;\r\n","\r\nexport const\r\n\r\n /**\r\n * Pushes incoming `item` onto given array and returns said array.\r\n * @private\r\n * @param agg {Array}\r\n * @param item {*}\r\n * @returns {Array}\r\n */\r\n aggregateArray = (agg, item) => {\r\n agg.push(item);\r\n return agg;\r\n }\r\n\r\n;\r\n","/**\r\n * List operator utils module.\r\n * @module listUtils\r\n */\r\nimport {apply} from '../jsPlatform/function'; // un-curried version\r\nimport {slice} from '../jsPlatform/list'; // un-curried version good for both strings and arrays\r\nimport {length} from '../jsPlatform/object';\r\nimport {alwaysFalse} from '../boolean';\r\nimport map from './map';\r\nimport {curry, curry2} from '../function/curry';\r\n\r\nexport * from './aggregation';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a slice of the given list from `startInd` to the end of the list.\r\n * @function module:listUtils.sliceFrom\r\n * @param startInd {Number}\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sliceFrom = curry((startInd, xs) => slice(startInd, undefined, xs)),\r\n\r\n /**\r\n * Slices from index `0` to given index.\r\n * @function module:listUtils.sliceTo\r\n * @param toInd {Number}\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sliceTo = curry((toInd, xs) => slice(0, toInd, xs)),\r\n\r\n /**\r\n * Slices a copy of list.\r\n * @function listUtils.sliceCopy\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sliceCopy = sliceFrom(0),\r\n\r\n /**\r\n * Generic 'ascending order' ordering function (use by the likes of `list.sort` etc.)\r\n * @function module:listUtils.genericAscOrdering\r\n * @param a {*}\r\n * @param b {*}\r\n * @returns {number}\r\n */\r\n genericAscOrdering = curry((a, b) => {\r\n if (a > b) { return 1; }\r\n else if (a < b) { return -1; }\r\n return 0;\r\n }),\r\n\r\n /**\r\n * Returns length of all passed lists in list.\r\n * @function module:listUtils.lengths\r\n * @param lists ...{Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n lengths = curry2((...lists) => map(length, lists)),\r\n\r\n /**\r\n * Returns a list of lists trimmed to the shortest length in given list of lists. @background This method is used by the `zip*` functions to achieve their\r\n * 'slice to smallest' functionality.\r\n * @function module:listUtils.toShortest\r\n * @param lists {...(Array|String|*)}\r\n * @returns {Array|String|*}\r\n */\r\n toShortest = curry2((...lists) => {\r\n const listLengths = apply(lengths, lists),\r\n smallLen = Math.min.apply(Math, listLengths);\r\n return map((list, ind) => listLengths[ind] > smallLen ?\r\n sliceTo(smallLen, list) : sliceCopy(list), lists);\r\n }),\r\n\r\n /**\r\n * Reduces until predicate.\r\n * @function module:listUtils.reduceUntil\r\n * @param pred {Function} - `(item, index, list) => Boolean(...)`\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduceUntil = curry((pred, op, agg, xs) => {\r\n const limit = length(xs);\r\n if (!limit) { return agg; }\r\n let ind = 0,\r\n result = agg;\r\n for (; ind < limit; ind++) {\r\n if (pred(xs[ind], ind, xs)) { break; }\r\n result = op(result, xs[ind], ind, xs);\r\n }\r\n return result;\r\n }),\r\n\r\n /**\r\n * Reduces until predicate (from right to left).\r\n * @function module:listUtils.reduceUntilRight\r\n * @param pred {Function} - `(item, index, list) => Boolean(...)`\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduceUntilRight = curry((pred, op, agg, arr) => {\r\n const limit = length(arr);\r\n if (!limit) { return agg; }\r\n let ind = limit - 1,\r\n result = agg;\r\n for (; ind >= 0; ind--) {\r\n if (pred(arr[ind], ind, arr)) { break; }\r\n result = op(result, arr[ind], ind, arr);\r\n }\r\n return result;\r\n }),\r\n\r\n /**\r\n * Reduces a list with given operation (`op`) function.\r\n * @function module:listUtils.reduce\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduce = reduceUntil(alwaysFalse),\r\n\r\n /**\r\n * Reduces a list with given operation (`op`) function (from right-to-left).\r\n * @function module:listUtils.reduceRight\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduceRight = reduceUntilRight(alwaysFalse),\r\n\r\n /**\r\n * Gets last index of a list/list-like (Array|String|Function etc.).\r\n * @function module:listUtils.lastIndex\r\n * @param x {Array|String|*} - list like or list.\r\n * @returns {Number} - `-1` if no element found.\r\n */\r\n lastIndex = x => { const len = length(x); return len ? len - 1 : 0; },\r\n\r\n /**\r\n * Finds index in string or list.\r\n * @function module:listUtils.findIndexWhere\r\n * @param pred {Function} - Predicate.\r\n * @param arr {Array|String}\r\n * @returns {Number} - `-1` if predicate not matched else `index` found\r\n */\r\n findIndexWhere = curry((pred, arr) => {\r\n let ind = 0;\r\n const limit = length(arr);\r\n for (; ind < limit; ind += 1) {\r\n const predicateFulfilled = !!pred(arr[ind], ind, arr);\r\n if (predicateFulfilled) {\r\n return ind;\r\n }\r\n }\r\n return -1;\r\n }),\r\n\r\n /**\r\n * Finds index in list from right to left.\r\n * @function module:listUtils.findIndexWhereRight\r\n * @param pred {Function} - Predicate.\r\n * @param arr {Array|String}\r\n * @returns {Number} - `-1` if predicate not matched else `index` found\r\n */\r\n findIndexWhereRight = curry((pred, arr) => {\r\n let ind = length(arr) - 1;\r\n for (; ind >= 0; ind -= 1) {\r\n const predicateFulfilled = !!pred(arr[ind], ind, arr);\r\n if (predicateFulfilled) {\r\n return ind;\r\n }\r\n }\r\n return -1;\r\n }),\r\n\r\n /**\r\n * @function module:listUtils.findIndicesWhere\r\n * @param pred {Function}\r\n * @param xs {Array|String|*} - list or list like.\r\n * @returns {Array|undefined}\r\n */\r\n findIndicesWhere = curry((pred, xs) => {\r\n const limit = length(xs);\r\n let ind = 0,\r\n out = [];\r\n for (; ind < limit; ind++) {\r\n if (pred(xs[ind], ind, xs)) { out.push(ind); }\r\n }\r\n return out.length ? out : undefined;\r\n }),\r\n\r\n /**\r\n * @function module:listUtils.findWhere\r\n * @param pred {Function}\r\n * @param xs {Array|String|*} - list or list like.\r\n * @returns {*}\r\n */\r\n findWhere = curry((pred, xs) => {\r\n let ind = 0,\r\n limit = length(xs);\r\n if (!limit) { return; }\r\n for (; ind < limit; ind++) {\r\n let elm = xs[ind];\r\n if (pred(elm, ind, xs)) { return elm; }\r\n }\r\n })\r\n\r\n;\r\n","import {assignDeep} from './assignDeep';\r\nimport {keys} from '../jsPlatform/object';\r\nimport {reduce} from '../list/utils';\r\nimport {curry, curry2} from '../function/curry';\r\n\r\nexport const\r\n\r\n objUnion = curry((obj1, obj2) => assignDeep(obj1, obj2)),\r\n\r\n objIntersect = curry((obj1, obj2) => reduce((agg, key) => {\r\n if (obj2.hasOwnProperty(key)) {\r\n agg[key] = obj2[key];\r\n }\r\n return agg;\r\n }, {}, keys(obj1))),\r\n\r\n objDifference = curry((obj1, obj2) => reduce((agg, key) => {\r\n if (!obj2.hasOwnProperty(key)) {\r\n agg[key] = obj1[key];\r\n }\r\n return agg;\r\n }, {}, keys(obj1))),\r\n\r\n objComplement = curry2((obj0, ...objs) => reduce((agg, obj) =>\r\n assignDeep(agg, objDifference(obj, obj0)), {}, objs));\r\n","/**\r\n * @module console\r\n * @description Console exports.\r\n */\r\nexport const\r\n\r\n /**\r\n * `Console.log` method.\r\n * @function module:console.log\r\n * @params args {...*}\r\n * @returns {void}\r\n */\r\n log = console.log.bind(console),\r\n\r\n /**\r\n * `Console.error` method.\r\n * @function module:console.error\r\n * @params args {...*}\r\n * @returns {void}\r\n */\r\n error = console.error.bind(console),\r\n\r\n /**\r\n * Peeks (console.log) at incoming value(s) and returns the last value.\r\n * @function module:console.peek\r\n * @param args {...*}\r\n * @returns {*} Last given value (if one or more values) else first value.\r\n */\r\n peek = (...args) => (log(...args), args.pop())\r\n\r\n;\r\n","export const\r\n\r\n /**\r\n * Clones and object or array using `JSON.parse(JSON.stringify(...))` pattern.\r\n * @function module:object.jsonClone\r\n * @param x {*}\r\n * @returns {*}\r\n */\r\n jsonClone = x => JSON.parse(JSON.stringify(x))\r\n\r\n;\r\n","import {isArray, isType} from './is';\r\nimport {keys} from '../jsPlatform/object';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns an associated list from given object.\r\n * @note Useful for working with plain javascript objects.\r\n * @function module:object.toAssocList\r\n * @param obj {(Object|Array|*)}\r\n * @returns {Array.<*, *>}\r\n */\r\n toAssocList = obj => keys(obj).map(key => [key, obj[key]]),\r\n\r\n /**\r\n * Returns an associated list from given object (deeply (on incoming object's type)).\r\n * @note Does deep conversion on all values of passed in type's type.\r\n * @function module:object.toAssocListDeep\r\n * @param obj {*}\r\n * @param [TypeConstraint = Object] {(Constructor|Function)} - Type constraint to convert on.\r\n * @returns {*}\r\n */\r\n toAssocListDeep = (obj, TypeConstraint = Object) => keys(obj).map(key =>\r\n TypeConstraint && isType(TypeConstraint, obj[key]) ?\r\n [key, toAssocListDeep(obj[key], TypeConstraint)] :\r\n [key, obj[key]]\r\n ),\r\n\r\n /**\r\n * From associated list to object.\r\n * @function module:object.fromAssocList\r\n * @param xs {Array.} - Associated list.\r\n * @param [OutType = Object] {Constructor|Function} - Output type. Default `Object`.\r\n * @returns {*} - Default is `Object`\r\n */\r\n fromAssocList = (xs, OutType = Object) => xs.reduce((agg, [key, value]) => {\r\n agg[key] = value;\r\n return agg;\r\n }, new OutType()),\r\n\r\n /**\r\n * From associated list to object (deep conversion on associative lists (array of 2 value arrays)).\r\n * @note Considers array of arrays associated lists.\r\n * @function module:object.fromAssocListDeep\r\n * @param xs {Array.} - Associated list.\r\n * @param [OutType = Object] {Constructor|Function} - Output type. Default `Object`.\r\n * @returns {*} - Default is `Object`\r\n */\r\n fromAssocListDeep = (xs, OutType = Object) => xs.reduce((agg, [key, value]) => {\r\n if (isArray(value) && isArray(value[0]) && value[0].length === 2) {\r\n agg[key] = fromAssocListDeep(value, OutType);\r\n return agg;\r\n }\r\n agg[key] = value;\r\n return agg;\r\n }, new OutType())\r\n;\r\n","import {typeOf} from './typeOf';\r\nimport {toAssocList} from './assocList';\r\n\r\nexport const\r\n\r\n /**\r\n * Converts incoming value to an array.\r\n * @note For `WeakMap`, `WeakSet`, `Map` and `Set` result is the same as calling `Array.from` on such.\r\n * @note For `null`, `undefined`, `NaN`, `Number{}`, `Symbol{}`, `Boolean{}` returns an empty array.\r\n * @note Method does a shallow conversion;\r\n * @function module:object.toArray\r\n * @param x {*} - Thing to convert from.\r\n * @returns {Array}\r\n */\r\n toArray = x => {\r\n switch (typeOf(x)) {\r\n case 'Null':\r\n case 'Undefined':\r\n return [];\r\n case String.name:\r\n case Array.name:\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n case 'Map':\r\n case 'Set':\r\n return Array.from(x);\r\n case Object.name:\r\n default:\r\n return toAssocList(x);\r\n }\r\n }\r\n\r\n;\r\n","/**\r\n * @module object\r\n * @description Object operations/combinators.\r\n */\r\n\r\nexport * from './jsPlatform/object';\r\nexport * from './object/lookup';\r\nexport * from './object/typeOf';\r\nexport * from './object/copy';\r\nexport * from './object/is';\r\nexport * from './object/of';\r\nexport * from './object/searchObj';\r\nexport * from './object/assignDeep';\r\nexport * from './object/setTheory';\r\nexport * from './object/console';\r\nexport * from './object/jsonClone';\r\nexport * from './object/toArray';\r\nexport * from './object/assocList';\r\n","import {reduceRight} from '../jsPlatform/array';\r\n\r\n/**\r\n * Composes all functions passed in from right to left passing each functions return value to\r\n * the function on the left of itself.\r\n * @function module:function.compose\r\n * @type {Function}\r\n * @param args {...{Function}}\r\n * @returns {Function}\r\n */\r\nexport const compose = (...args) =>\r\n arg0 => reduceRight((value, fn) => fn(value), arg0, args);\r\n","/**\r\n * @memberOf function\r\n */\r\n\r\n/**\r\n * Returns passed in parameter.\r\n * @haskellType `id :: a -> a`\r\n * @function module:function.id\r\n * @param x {*}\r\n * @returns {*}\r\n */\r\nexport const id = x => x;\r\n","/**\r\n * @memberOf function\r\n */\r\n\r\nimport {apply} from '../jsPlatform/function';\r\nimport {curry, curry2} from './curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Negates a function that takes one/no argument.\r\n * @function module:function.negateF\r\n * @param fn {Function}\r\n * @returns {function(*=): boolean}\r\n */\r\n negateF = fn => x => !fn(x),\r\n\r\n /**\r\n * Takes a function that takes two parameters and returns a negated version of given\r\n * function.\r\n * @function module:_negate.negateF2\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n negateF2 = fn => curry((a, b) => !fn(a, b)),\r\n\r\n /**\r\n * Takes a function that takes three parameters and returns a\r\n * negated version of given function.\r\n * @function module:_negate.negateF3\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n negateF3 = fn => curry((a, b, c) => !fn(a, b, c)),\r\n\r\n /**\r\n * Returns a negated version of given function.\r\n * Returned function is variadiac (takes one or more arguments).\r\n * @note function returned is uncurried.\r\n * @uncurried\r\n * @function module:function.negateFN\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n negateFN = fn => curry2((...args) => !apply(fn, args));\r\n","import {curry} from './curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Run `operation` until predicate returns `true` (like a functional\r\n * version of a while loop).\r\n * @function module:function.until\r\n * @param predicate {Function} :: a -> Boolean\r\n * @param operation {Function} :: a -> a\r\n * @param typeInstance {*} :: * - A monoidal zero or some starting point.\r\n * @returns {*} - What ever type `typeInstance` is\r\n */\r\n until = curry((predicate, operation, typeInstance) => {\r\n let result = typeInstance;\r\n while (!predicate(result)) {\r\n result = operation(result);\r\n }\r\n return result;\r\n });\r\n","import {typeOf} from '../object/typeOf';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a function or throws an error if given `f` is not a function.\r\n * @function module:function.fnOrError\r\n * @param symbolName {String} - Error message prefix.\r\n * @param f {Function|*} - Expected function.\r\n * @returns {Function}\r\n * @throws {Error} - Error if `f` is not of `function`\r\n */\r\n fnOrError = (symbolName, f) => {\r\n if (!f || !(f instanceof Function)) {\r\n throw new Error(`${symbolName} should be a function. ` +\r\n `Type received: ${typeOf(f)}; Value received: ${f}.`);\r\n }\r\n return f;\r\n }\r\n\r\n;\r\n","/**\r\n * No-op ('op' as in 'operation') - Performs no operation 'always' (good for places where\r\n * a value should always be a function etc.).\r\n * @function module:function.noop\r\n * @returns {undefined}\r\n */\r\nexport const noop = () => undefined;\r\n","/**\r\n * @module function\r\n */\r\nexport * from './jsPlatform/function';\r\nexport * from './function/compose';\r\nexport * from './function/curry';\r\nexport * from './function/flip';\r\nexport * from './function/id';\r\nexport * from './function/negate';\r\nexport * from './function/until';\r\nexport * from './function/fnOrError';\r\nexport * from './function/noop';\r\n","/**\r\n * @module object\r\n */\r\nimport {curry} from '../function/curry';\r\n\r\n/**\r\n * Normalizes step for `from` and `to` combination.\r\n * @function module:list.normalizeStep\r\n * @param from {Number}\r\n * @param to {Number}\r\n * @param [step = 1] {Number}\r\n * @returns {Number}\r\n * @private\r\n */\r\nconst normalizeStep = (from, to, step) => {\r\n if (from > to) {\r\n return step > 0 ? -step : step; // make step negative\r\n }\r\n return step < 0 ? -1 * step : step; // make step positive\r\n};\r\n\r\nexport const\r\n\r\n /**\r\n * Range function - gives you an array contain numbers in given range.\r\n * @note normalizes `step` to be valid if range numbers given are invalid\r\n * (forces `step` to be negative if range required is in the negative direction\r\n * and forces `step` to be positive if range required is in the other direction).\r\n * @function module:list.range\r\n * @param from {Number}\r\n * @param to {Number}\r\n * @param [step = 1] {Number}\r\n * @returns {Array.}\r\n */\r\n range = curry((from, to, step = 1) => {\r\n let i = from;\r\n const out = [];\r\n step = normalizeStep(from, to, step);\r\n if (step === 0 || from === to) { return [from]; }\r\n for (; (to - i) * step >= 0; i += step) { out.push(i); }\r\n return out;\r\n })\r\n;\r\n","/**\r\n * Created by elydelacruz on 9/6/2017.\r\n */\r\n\r\nimport {fPureTakesOne} from '../utils';\r\n\r\n/**\r\n * Functional version of `String.prototype.split`.\r\n * @function module:_string.split\r\n * @param separator {String|RegExp}\r\n * @param str {String}\r\n * @returns {Array}\r\n */\r\nexport const split = fPureTakesOne('split');\r\n","/**\r\n * @module jsPlatform_\r\n * @private\r\n */\r\nexport * from './jsPlatform/object';\r\nexport * from './jsPlatform/array';\r\nexport * from './jsPlatform/list';\r\nexport * from './jsPlatform/string';\r\nexport * from './jsPlatform/function';\r\n","/**\r\n * List operations module.\r\n * @module list\r\n */\r\nimport {concat as listAppend, indexOf, slice, includes} from './jsPlatform/list';\r\nimport {apply} from './jsPlatform/function';\r\nimport {length} from './jsPlatform/object';\r\nimport {negateF3, negateF2} from './function/negate';\r\nimport {curry, curry2, curry3} from './function/curry';\r\nimport {isTruthy, isFalsy} from './boolean';\r\nimport {lookup} from './object/lookup';\r\nimport {of} from './object/of';\r\nimport {isset, isString} from './object/is';\r\nimport {typeOf} from './object/typeOf';\r\nimport map from './list/map';\r\n\r\nimport {\r\n sliceFrom, sliceTo, lengths,\r\n toShortest, aggregateArray,\r\n reduceUntil, reduce, reduceRight, lastIndex,\r\n findIndexWhere, findIndexWhereRight, findIndicesWhere,\r\n findWhere, sliceCopy, genericAscOrdering\r\n}\r\n from './list/utils';\r\n\r\nexport * from './list/range';\r\n\r\nexport * from './list/utils';\r\n\r\nexport {map};\r\n\r\nexport {slice, includes, indexOf, lastIndexOf, push} from './jsPlatform';\r\n\r\nexport const\r\n\r\n /**\r\n * Append two, or more, lists, i.e.,\r\n * @example\r\n * expectEqual(append(take(13, alphabetString), drop(13, alphabetString)), alphabetString); // true\r\n *\r\n * // Another example\r\n * const result = append(\r\n * alphabetStr.split(''),\r\n * alphabetStr.split('')\r\n * ),\r\n * expected = repeat(2, alphabetStr).split('');\r\n *\r\n * shallowEquals(result, expected) === true // `true`\r\n *\r\n * @function module:list.append\r\n * @param [args] {...(Array|String|*)} - One or more lists or list likes (strings etc.).\r\n * @returns {(Array|String|*)} - Same type as list like passed in.\r\n */\r\n append = curry2((...args) => apply(listAppend, args)),\r\n\r\n /**\r\n * Returns head of list (first item of list).\r\n * @haskellType `head :: [a] -> a`\r\n * @function module:list.head\r\n * @param x {Array|String}\r\n * @returns {*} - First item from list\r\n */\r\n head = x => x[0],\r\n\r\n /**\r\n * Returns last item of list.\r\n * @haskellType `last :: [a] -> a`\r\n * @function module:list.last\r\n * @param xs {Array|String}\r\n * @returns {*}\r\n */\r\n last = xs => xs[lastIndex(xs)],\r\n\r\n /**\r\n * Returns tail part of list (everything after the first item as new list).\r\n * @haskelType `tail :: [a] -> [a]`\r\n * @function module:list.tail\r\n * @param xs {Array|String}\r\n * @returns {Array|String}\r\n */\r\n tail = xs => sliceFrom(1, xs),\r\n\r\n /**\r\n * Returns everything except last item of list as new list.\r\n * @haskellType `init :: [a] -> [a]`\r\n * @function module:list.init\r\n * @param xs {Array|String}\r\n * @returns {Array|String}\r\n */\r\n init = xs => sliceTo(lastIndex(xs), xs),\r\n\r\n /**\r\n * Returns `head` and `tail` of passed in list/string in a tuple.\r\n * @haskellType `uncons :: [a] -> Maybe (a, [a])`\r\n * @function module:list.uncons\r\n * @param xs {Array|String}\r\n * @returns {Array|undefined}\r\n */\r\n uncons = xs => !xs || length(xs) === 0 ? undefined : [head(xs), tail(xs)],\r\n\r\n /**\r\n * Returns `tail` and `head` of passed in list/string in a tuple.\r\n * @haskellType `unconsr :: [a] -> Maybe ([a], a)`\r\n * @function module:list.unconsr\r\n * @param xs {Array|String}\r\n * @returns {Array|String|*|undefined}\r\n */\r\n unconsr = xs => !xs || length(xs) === 0 ? undefined : [init(xs), last(xs)],\r\n\r\n /**\r\n * Concatenates all the elements of a container of lists.\r\n * @haskellType `concat :: Foldable t => t [a] -> [a]`\r\n * @function module:list.concat\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n concat = xs => {\r\n switch (length(xs)) {\r\n case undefined:\r\n case 0:\r\n return [];\r\n case 1:\r\n const item0 = xs[0];\r\n return item0 && item0.slice ? sliceCopy(item0) : item0;\r\n case 2:\r\n default:\r\n return apply(append, xs);\r\n }\r\n },\r\n\r\n /**\r\n * Map a function over all the elements of a container and concatenate the resulting lists.\r\n * @haskellType `concatMap :: Foldable t => (a -> [b]) -> t a -> [b]`\r\n * @function module:list.concatMap\r\n * @param fn {Function}\r\n * @param foldableOfA {Array}\r\n * @returns {Array}\r\n */\r\n concatMap = curry((fn, foldableOfA) => concat(map(fn, foldableOfA))),\r\n\r\n /**\r\n * Returns a copy of the passed in list reverses.\r\n * @haskellType `reverse :: [a] -> [a]`\r\n * @function module:list.reverse\r\n * @param xs {Array|String}\r\n * @returns {Array|String}\r\n */\r\n reverse = xs => {\r\n if (!isset(xs) || !xs.length) {\r\n return xs;\r\n }\r\n let out = of(xs),\r\n i = xs.length - 1;\r\n switch (typeOf(xs)) {\r\n case 'String':\r\n for (; i >= 0; i -= 1) {\r\n out += xs[i];\r\n }\r\n return out;\r\n default:\r\n for (; i >= 0; i -= 1) {\r\n out.push(xs[i]);\r\n }\r\n return out;\r\n }\r\n },\r\n\r\n /**\r\n * Takes an element and a list and `intersperses' that element between the\r\n * elements of the list.\r\n * @function module:list.intersperse\r\n * @note In our version of the function javascript is loosely typed so,\r\n * so is our function (to much overhead to make it typed) so `between` can be any value.\r\n * @param between {*} - Should be of the same type of elements contained in list.\r\n * @param arr {Array|String} - List.\r\n * @returns {Array|String}\r\n */\r\n intersperse = curry((between, xs) => {\r\n if (!xs || !xs.length) {\r\n return xs;\r\n }\r\n const limit = xs.length,\r\n lastInd = limit - 1;\r\n let out = of(xs),\r\n i = 0;\r\n if (isString(xs)) {\r\n for (; i < limit; i += 1) {\r\n out += i === lastInd ?\r\n xs[i] : xs[i] + between;\r\n }\r\n return out;\r\n }\r\n for (; i < limit; i += 1) {\r\n if (i === lastInd) {\r\n out.push(xs[i]);\r\n } else {\r\n out.push(xs[i], between);\r\n }\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * `intercalate xs xss` is equivalent to (concat (intersperse xs xss)). It inserts the list xs in between the lists in xss and concatenates the result.\r\n * @haskellType `intercalate :: [a] -> [[a]] -> [a]`\r\n * @function module:list.intercalate\r\n * @param xs {Array|String}\r\n * @param xss {Array|String}\r\n * @returns {Array|String}\r\n */\r\n intercalate = curry((xs, xss) => {\r\n if (isString(xss)) {\r\n return intersperse(xs, xss);\r\n }\r\n return concat(intersperse(xs, xss));\r\n }),\r\n\r\n /**\r\n * Transposes rows and columns into lists by index; E.g.,\r\n * Haskell example:\r\n * ```\r\n * transpose [[1,2,3],[4,5,6]] == [[1,4],[2,5],[3,6]]\r\n *\r\n * -- Notice the shorter arrays are ignored after their last index is copied over:\r\n * transpose [[10,11],[20],[],[30,31,32]] == [[10,20,30],[11,31],[32]]\r\n * ```\r\n * @note from columns to rows.\r\n * @note Empty lists are ignored.\r\n * @haskellType `transpose :: [[a]] -> [[a]]`\r\n * @function module:list.transpose\r\n * @param xss {Array}\r\n * @returns {Array}\r\n */\r\n transpose = xss => {\r\n let numLists = length(xss),\r\n ind = 0, ind2;\r\n if (!numLists) {\r\n return [];\r\n }\r\n const listLengths = apply(lengths, xss),\r\n longestListLen = maximum(listLengths),\r\n outLists = [];\r\n for (; ind < longestListLen; ind += 1) {\r\n const outList = [];\r\n for (ind2 = 0; ind2 < numLists; ind2 += 1) {\r\n if (listLengths[ind2] < ind + 1) {\r\n continue;\r\n }\r\n outList.push(xss[ind2][ind]);\r\n }\r\n outLists.push(outList);\r\n }\r\n return filter(x => length(x) > 0, outLists);\r\n },\r\n\r\n /**\r\n * Generates 2^n sub-sequences for passed in sequence (string/list) (`n` is\r\n * the length of the passed in sequence so: 2^length(xs)).\r\n * Note: The return value doubles per index/character passed in so use with caution!\r\n * Also note that for 2^16 (or for a sequence of 16 characters) this algorithm\r\n * will generate 65536 sub-sequences! So caution should be taken to not\r\n * use this with sequences above a certain length on certain platform (the browser thread in specific).\r\n * @function module:list.subsequences\r\n * @jsperftest https://jsperf.com/subsequences\r\n * @param xs {Array|String}\r\n * @returns {Array.}\r\n */\r\n subsequences = xs => {\r\n const listLen = length(xs),\r\n len = Math.pow(2, listLen),\r\n out = [];\r\n for (let i = 0; i < len; i += 1) {\r\n let entry = [];\r\n for (let j = 0; j < listLen; j += 1) {\r\n if (i & (1 << j)) {\r\n entry.push(xs[j]);\r\n }\r\n }\r\n out.push(entry);\r\n }\r\n return out;\r\n },\r\n\r\n /**\r\n * Returns an array with the given indices swapped.\r\n * @function module:list.swapped\r\n * @param ind1 {Number}\r\n * @param ind2 {Number}\r\n * @param list {Array}\r\n * @returns {Array} - Copy of incoming with swapped values at indices.\r\n */\r\n swapped = curry((ind1, ind2, list) => {\r\n const out = sliceCopy(list),\r\n tmp = out[ind1];\r\n out[ind1] = out[ind2];\r\n out[ind2] = tmp;\r\n return out;\r\n }),\r\n\r\n /**\r\n * Returns a list of permutations for passed in list.\r\n * Use caution with lists above a length of 15 (will take long due to nature of\r\n * algorithm).\r\n * @function module:list.permutations\r\n * @param xs {Array} - List.\r\n * @returns {Array} - Array of permutations.\r\n */\r\n permutations = xs => {\r\n const limit = length(xs);\r\n\r\n if (!limit || limit === 1) {\r\n return [xs];\r\n }\r\n\r\n let list = sliceCopy(xs),\r\n c = repeat(limit, 0),\r\n i = 0;\r\n\r\n const out = [list];\r\n\r\n for (; i < limit; i++) {\r\n if (c[i] < i) {\r\n list = swapped(i % 2 === 0 ? 0 : c[i], i, list);\r\n out.push(list);\r\n c[i] += 1;\r\n i = 0;\r\n continue;\r\n }\r\n c[i] = 0;\r\n }\r\n\r\n return out;\r\n },\r\n\r\n /**\r\n * Left associative fold. Reduces a container of elements down by the given operation (same as [].reduce).\r\n * @function module:list.foldl\r\n * @param fn {Function}\r\n * @param zero {*} - Aggregator.\r\n * @param functor {Array}\r\n * @returns {*} - Whatever type is lastly returned from `fn`.\r\n */\r\n foldl = reduce,\r\n\r\n /**\r\n * Right associative fold. Reduces a container of elements down by the given operation (same as [].reduceRight).\r\n * @function module:list.foldr\r\n * @param fn {Function}\r\n * @param zero {*} - Aggregator.\r\n * @param functor {Array}\r\n * @returns {*} - Whatever type is lastly returned from `fn`.\r\n */\r\n foldr = reduceRight,\r\n\r\n /**\r\n * A variant of `foldl` except that this one doesn't require the starting point. The starting point/value will be pulled\r\n * out from a copy of the container.\r\n * @function module:list.foldl1\r\n * @param op {Function}\r\n * @param xs {Array}\r\n * @returns {*} - Whatever type is lastly returned from `op`.\r\n */\r\n foldl1 = curry((op, xs) => {\r\n const parts = uncons(xs);\r\n return !parts ? [] : reduce(op, parts[0], parts[1]);\r\n }),\r\n\r\n /**\r\n * A variant of `foldr` except that this one doesn't require the starting point/value. The starting point/value will be pulled\r\n * out from a copy of the container.\r\n * @function module:list.foldr1\r\n * @param op {Function}\r\n * @param xs {Array}\r\n * @returns {*} - Whatever type is lastly returned from `op`.\r\n */\r\n foldr1 = curry((op, xs) => {\r\n const parts = unconsr(xs);\r\n return !parts ? [] : reduceRight(op, parts[1], parts[0]);\r\n }),\r\n\r\n /**\r\n * Performs a map then a reduce all in one (from left-to-right). Returns a tuple\r\n * containing the aggregated value and the result of mapping the passed in function on passed in list.\r\n * @function module:list.mapAccumL\r\n * @param op {Function} - Function : [aggregated, mapResult]\r\n * @param zero {*} - An instance of the passed in list type used to aggregateArray on.\r\n * @param xs {Array} - list type.\r\n * @return {Array} - [aggregated, list]\r\n */\r\n mapAccumL = curry((op, zero, xs) => {\r\n const list = sliceCopy(xs),\r\n limit = length(xs);\r\n if (!limit) {\r\n return [zero, list];\r\n }\r\n let ind = 0,\r\n agg = zero,\r\n mapped = [],\r\n tuple;\r\n for (; ind < limit; ind++) {\r\n tuple = op(agg, list[ind], ind);\r\n agg = tuple[0];\r\n mapped = tuple[1];\r\n }\r\n return [agg, mapped];\r\n }),\r\n\r\n /**\r\n * Performs a map and a reduce all in one (from right-to-left). Returns a tuple\r\n * containing the aggregated value and the result of mapping the passed in function on passed in list.\r\n * @function module:list.mapAccumR\r\n * @param op {Function} - Function : [aggregated, mapResult]\r\n * @param zero {*} - An instance of the passed in list type used to aggregateArray on.\r\n * @param xs {Array} - list type.\r\n * @return {Array} - [aggregated, list]\r\n */\r\n mapAccumR = curry((op, zero, xs) => {\r\n const list = sliceCopy(xs),\r\n limit = length(xs);\r\n if (!limit) {\r\n return [zero, list];\r\n }\r\n let ind = limit - 1,\r\n agg = zero,\r\n mapped = [],\r\n tuple;\r\n for (; ind >= 0; ind--) {\r\n tuple = op(agg, list[ind], ind);\r\n agg = tuple[0];\r\n mapped = tuple[1];\r\n }\r\n return [agg, mapped];\r\n }),\r\n\r\n /**\r\n * iterate f x returns an infinite list of repeated applications of f to x.\r\n * @function module:list.iterate\r\n * @example `iterate(5, f, x) == [x, f(x), f(f(x)), ...]`\r\n * @param limit {Number}\r\n * @param op {Function} - Operation.\r\n * @param x {*} - Starting point.\r\n * @returns {*}\r\n */\r\n iterate = curry((limit, op, x) => {\r\n let ind = 0,\r\n out = [],\r\n lastX = x;\r\n for (; ind < limit; ind += 1) {\r\n out.push(lastX);\r\n lastX = op(lastX, ind);\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Repeats `x` `limit` number of times.\r\n * @function module:list.repeat\r\n * @param limit {Number}\r\n * @param x {*}\r\n * @return {Array}\r\n */\r\n repeat = curry((limit, x) => iterate(limit, a => a, x)),\r\n\r\n /**\r\n * Same as `repeat` due to the nature of javascript (see haskell version for usage).\r\n * @function module:list.replicate\r\n * @param limit {Number}\r\n * @param x {*}\r\n * @return {Array}\r\n */\r\n replicate = repeat,\r\n\r\n /**\r\n * Replicates a list `limit` number of times and appends the results (concat)\r\n * @function module:list.cycle\r\n * @param limit {Number}\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n cycle = curry((limit, xs) => concat(replicate(limit, xs))),\r\n\r\n /**\r\n * Unfolds a value into a list of somethings.\r\n * @haskellType `unfoldr :: (b -> Maybe (a, b)) -> b -> [a]`\r\n * @function module:list.unfoldr\r\n * @param op {Function} - Operation to perform (should return a two component tuple (item to aggregateArray and item to unfold in next iteration).\r\n * @param x {*} - Starting parameter to unfold from.\r\n * @returns {Array} - An array of whatever you return from `op` yielded.\r\n */\r\n unfoldr = curry((op, x) => {\r\n let ind = 0,\r\n out = [],\r\n resultTuple = op(x, ind, out);\r\n while (resultTuple) {\r\n out.push(resultTuple[0]);\r\n resultTuple = op(resultTuple[1], ++ind, out);\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Finds index in string or list (alias for `findIndex`).\r\n * @function module:list.findIndex\r\n * @param pred {Function} - Predicate.\r\n * @param arr {Array|String}\r\n * @returns {Number} - `-1` if predicate not matched else `index` found\r\n */\r\n findIndex = findIndexWhere,\r\n\r\n /**\r\n * @function module:list.findIndices\r\n * @param pred {Function}\r\n * @param xs {Array} - list or list like.\r\n * @returns {Array|undefined}\r\n */\r\n findIndices = findIndicesWhere,\r\n\r\n /**\r\n * @function module:list.elemIndex\r\n * @param x {*} - Element to search for.\r\n * @param xs {Array} - list or list like.\r\n * @returns {*}\r\n */\r\n elemIndex = curry((x, xs) => {\r\n const foundInd = indexOf(x, xs);\r\n return foundInd !== -1 ? foundInd : undefined;\r\n }),\r\n\r\n /**\r\n * @function module:list.elemIndices\r\n * @param value {*} - Element to search for.\r\n * @param xs {Array} - list or list like.\r\n * @returns {*}\r\n */\r\n elemIndices = curry((value, xs) => findIndices(x => x === value, xs)),\r\n\r\n /**\r\n * Takes `n` items from start of list to `limit` (exclusive).\r\n * @function module:list.take\r\n * @param list {Array|String}\r\n * @param limit {Number}\r\n * @returns {String|Array} - Passed in type's type\r\n */\r\n take = sliceTo,\r\n\r\n /**\r\n * Drops `n` items from start of list to `count` (exclusive).\r\n * @function module:list.drop\r\n * @param list {Array|String}\r\n * @param count {Number}\r\n * @returns {String|Array} - Passed in type's type\r\n */\r\n drop = sliceFrom,\r\n\r\n /**\r\n * Splits `x` in two at given `index` (exclusive (includes element/character at\r\n * given index in second part of returned list)).\r\n * @function module:list.splitAt\r\n * @param ind {Number} - Index to split at.\r\n * @param list {Array|String} - functor (list or string) to split.\r\n * @returns {Array|String} - List like type passed\r\n */\r\n splitAt = (ind, list) => [sliceTo(ind, list), sliceFrom(ind, list)],\r\n\r\n /**\r\n * Gives an list with passed elements while predicate was true.\r\n * @function module:list.takeWhile\r\n * @param pred {Function} - Predicate<*, index, list|string>\r\n * @param list {Array|String}\r\n * @returns {Array}\r\n */\r\n takeWhile = curry((pred, list) =>\r\n reduceUntil(\r\n negateF3(pred), // predicate\r\n isString(list) ?\r\n (agg, x) => agg + x :\r\n aggregateArray, // operation\r\n of(list), // aggregate\r\n list\r\n )),\r\n\r\n /**\r\n * Returns an list without elements that match predicate.\r\n * @function module:list.dropWhile\r\n * @param pred {Function} - Predicate<*, index, list|string>\r\n * @param list {Array|String}\r\n * @refactor\r\n * @returns {Array|String}\r\n */\r\n dropWhile = curry((pred, list) => {\r\n const limit = length(list),\r\n splitPoint =\r\n findIndexWhere(\r\n (x, i, xs) => !pred(x, i, xs),\r\n list\r\n );\r\n\r\n return splitPoint === -1 ?\r\n sliceFrom(limit, list) :\r\n slice(splitPoint, limit, list);\r\n }),\r\n\r\n /**\r\n * @function module:list.dropWhileEnd\r\n * @param pred {Function} - Predicate<*, index, list|string>\r\n * @param list {Array|String}\r\n * @refactor\r\n * @returns {Array|String}\r\n */\r\n dropWhileEnd = curry((pred, list) => {\r\n const splitPoint =\r\n findIndexWhereRight(\r\n (x, i, xs) => !pred(x, i, xs),\r\n list\r\n );\r\n if (splitPoint === -1) {\r\n return of(list);\r\n }\r\n return sliceTo(splitPoint + 1, list);\r\n }),\r\n\r\n /**\r\n * Gives you the `span` of items matching predicate\r\n * and items not matching predicate; E.g., Gives an\r\n * array of arrays; E.g., [[matching-items], [non-matching-items]]\r\n * @function list.span\r\n * @param pred {Function} - List predicate (`(x, i, list) => bool`)\r\n * @param list {Array|String}\r\n * @returns {(Array>|Array)}\r\n * @type {Function}\r\n */\r\n span = curry((pred, list) => {\r\n const splitPoint = findIndexWhere(negateF3(pred), list);\r\n return splitPoint === -1 ?\r\n [sliceFrom(0, list), of(list)] :\r\n splitAt(splitPoint, list);\r\n }),\r\n\r\n /**\r\n * breakOnList, applied to a predicate p and a list xs, returns a tuple\r\n * where first element is longest prefix (possibly empty) of xs of elements\r\n * that do not satisfy p and second element is the remainder of the list:\r\n * @haskellExample\r\n * Replace `break` with `breakOnList` for our version.\r\n * ```\r\n * breakOnList (> 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4])\r\n * breakOnList (< 9) [1,2,3] == ([],[1,2,3])\r\n * breakOnList (> 9) [1,2,3] == ([1,2,3],[])\r\n * ```\r\n * @function module:list.breakOnList\r\n * @param pred {Function}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n breakOnList = curry((pred, list) => {\r\n const splitPoint = findIndexWhere(negateF3(pred), list);\r\n return splitPoint === -1 ?\r\n [of(list), sliceFrom(0, list)] : reverse(splitAt(splitPoint, list));\r\n }),\r\n\r\n /**\r\n * Gets item at index.\r\n * @function module:list.at\r\n * @param ind {Number} - Index.\r\n * @param xs {Array} - list or list like.\r\n * @returns {*|undefined} - Item or `undefined`.\r\n */\r\n at = lookup,\r\n\r\n /**\r\n * Find an item in structure of elements based on given predicate (`pred`).\r\n * @function module:list.find\r\n * @param pred {Function}\r\n * @param xs {Array} - list or list like.\r\n * @returns {*} - Found item.\r\n */\r\n find = findWhere,\r\n\r\n /**\r\n * For each function (same as `[].forEach` except in functional format).\r\n * @function module:list.forEach\r\n * @param fn {Function} - Operation (`(element, index, list) => {...}`, etc.)\r\n * @param xs {(Array|String)}\r\n * @returns {void}\r\n */\r\n forEach = curry((fn, list) => {\r\n const limit = length(list);\r\n if (!limit) {\r\n return;\r\n }\r\n let ind = 0;\r\n for (; ind < limit; ind += 1) {\r\n fn(list[ind], ind, list);\r\n }\r\n }),\r\n\r\n /**\r\n * Filters a structure of elements using given predicate (`pred`) (same as `[].filter`).\r\n * @function module:list.filter\r\n * @param pred {Function}\r\n * @param xs {Array} - list or list like.\r\n * @returns {Array} - Structure of filtered elements.\r\n */\r\n filter = curry((pred, xs) => {\r\n let ind = 0,\r\n limit = length(xs),\r\n out = [];\r\n if (!limit) {\r\n return out;\r\n }\r\n for (; ind < limit; ind++) {\r\n if (pred(xs[ind], ind, xs)) {\r\n out.push(xs[ind]);\r\n }\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Partitions a list on a predicate; Items that match predicate are in first list in tuple; Items that\r\n * do not match the tuple are in second list in the returned tuple.\r\n * Essentially `[filter(p, xs), filter(negateF3(p), xs)]`.\r\n * @function module:list.partition\r\n * @param pred {Function} - Predicate\r\n * @param list {Array}\r\n * @returns {Array|String} - Tuple of arrays or strings (depends on incoming list (of type list or string)).\r\n */\r\n partition = curry((pred, list) =>\r\n !length(list) ?\r\n [[], []] :\r\n [filter(pred, list), filter(negateF3(pred), list)]),\r\n\r\n /**\r\n * Returns a boolean indicating whether an element exists in given structure of elements.\r\n * @function module:list.elem\r\n * @param element {*}\r\n * @param xs {Array}\r\n * @returns {Boolean}\r\n */\r\n elem = includes,\r\n\r\n /**\r\n * The opposite of `elem` - Returns a boolean indicating whether an element exists in given list.\r\n * @function module:list.notElem\r\n * @param element {*}\r\n * @param xs {Array}\r\n * @returns {Boolean}\r\n */\r\n notElem = negateF2(includes),\r\n\r\n /**\r\n * Checks if list `xs1` is a prefix of list `xs2`\r\n * @function module:list.isPrefixOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isPrefixOf = curry((xs1, xs2) => {\r\n const limit1 = length(xs1),\r\n limit2 = length(xs2);\r\n if (limit2 < limit1 || !limit1 || !limit2 || indexOf(xs1[0], xs2) === -1) {\r\n return false;\r\n }\r\n let ind = 0;\r\n for (; ind < limit1; ind++) {\r\n if (xs1[ind] !== xs2[ind]) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }),\r\n\r\n /**\r\n * Checks if list `xs1` is a suffix of list `xs2`\r\n * @function module:list.isSuffixOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isSuffixOf = curry((xs1, xs2) => {\r\n const limit1 = length(xs1),\r\n limit2 = length(xs2);\r\n if (limit2 < limit1 || !limit1 || !limit2 || indexOf(xs1[0], xs2) === -1) {\r\n return false;\r\n }\r\n let ind1 = limit1 - 1,\r\n ind2 = limit2 - 1;\r\n for (; ind1 >= 0; ind1--) {\r\n if (xs1[ind1] !== xs2[ind2]) {\r\n return false;\r\n }\r\n ind2 -= 1;\r\n }\r\n return true;\r\n }),\r\n\r\n /**\r\n * Checks if list `xs1` is an infix of list `xs2`\r\n * @function module:list.isInfixOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isInfixOf = curry((xs1, xs2) => {\r\n const limit1 = length(xs1),\r\n limit2 = length(xs2);\r\n if (limit2 < limit1 || !limit1 || !limit2) {\r\n return false;\r\n }\r\n let ind1,\r\n foundLen,\r\n ind = 0;\r\n for (; ind < limit2; ind += 1) {\r\n foundLen = 0;\r\n for (ind1 = 0; ind1 < limit1; ind1 += 1) {\r\n if (xs2[ind1 + ind] === xs1[ind1]) {\r\n foundLen += 1;\r\n }\r\n if (foundLen === limit1) {\r\n return true;\r\n }\r\n }\r\n }\r\n return false;\r\n }),\r\n\r\n /**\r\n * Checks if list `xs1` is a sub-sequence of list `xs2`\r\n * @function module:list.isSubsequenceOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isSubsequenceOf = curry((xs1, xs2) => {\r\n const len = Math.pow(2, length(xs2)),\r\n lenXs1 = length(xs1);\r\n let foundLen,\r\n i;\r\n for (i = 0; i < len; i += 1) {\r\n foundLen = 0;\r\n for (let j = 0; j < len; j += 1) {\r\n if (i & (1 << j) && indexOf(xs2[j], xs1) > -1) {\r\n foundLen += 1;\r\n }\r\n if (foundLen === lenXs1) {\r\n return true;\r\n }\r\n }\r\n }\r\n return false;\r\n }),\r\n\r\n /**\r\n * The group function takes a list and returns a list of lists such that\r\n * the concatenation of the result is equal to the argument. Moreover, each\r\n * sublist in the result contains only equal elements. For example,\r\n * `group \"Mississippi\" = [\"M\",\"i\",\"ss\",\"i\",\"ss\",\"i\",\"pp\",\"i\"]`\r\n * It is a special case of groupBy, which allows the programmer to supply\r\n * their own equality test.\r\n * @haskellType `group :: Eq a => [a] -> [[a]]`\r\n * @function module:list.group\r\n * @param xs {Array|String}\r\n * @returns {Array|*}\r\n */\r\n group = xs => groupBy((a, b) => a === b, xs),\r\n\r\n /**\r\n * Allows you to group items in a list based on your supplied equality check.\r\n * @note Sames `group` but allows you to specify equality operation.\r\n * @haskellType `groupBy :: (a -> a -> Bool) -> [a] -> [[a]]`\r\n * @function module:list.groupBy\r\n * @param equalityOp {Function}\r\n * @param xs {Array}\r\n * @returns {*}\r\n */\r\n groupBy = curry((equalityOp, xs) => {\r\n const limit = length(xs);\r\n if (!limit) {\r\n return sliceCopy(xs);\r\n }\r\n let ind = 0,\r\n prevItem,\r\n item,\r\n predOp = x => {\r\n if (equalityOp(x, prevItem)) {\r\n ind++;\r\n }\r\n if (equalityOp(x, item)) {\r\n prevItem = x;\r\n return true;\r\n }\r\n return false;\r\n },\r\n agg = [];\r\n for (; ind < limit; ind += 1) {\r\n item = xs[ind];\r\n agg.push(takeWhile(predOp, slice(ind, limit, xs)));\r\n }\r\n return agg;\r\n }),\r\n\r\n /**\r\n * The inits function returns all initial segments of the argument, shortest first. For example,\r\n * ```\r\n * shallowEquals(inits('abc'), ['','a','ab','abc'])\r\n * ```\r\n * @function module:list.inits\r\n * @haskellType `inits :: [a] -> [[a]]`\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n inits = xs => {\r\n let limit = length(xs),\r\n ind = 0,\r\n agg = [];\r\n if (!limit) {\r\n return [];\r\n }\r\n for (; ind <= limit; ind += 1) {\r\n agg.push(sliceTo(ind, xs));\r\n }\r\n return agg;\r\n }, //map(list => init(list), xs),\r\n\r\n /**\r\n * The inits function returns all initial segments of the argument, shortest first. For example,\r\n * ```\r\n * shallowEquals(tails('abc'), ['abc', 'bc', 'c',''])\r\n * ```\r\n * @function module:list.tails\r\n * @haskellType `tails :: [a] -> [[a]]`\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n tails = xs => {\r\n let limit = length(xs),\r\n ind = 0,\r\n agg = [];\r\n if (!limit) {\r\n return [];\r\n }\r\n for (; ind <= limit; ind += 1) {\r\n agg.push(slice(ind, limit, xs));\r\n }\r\n return agg;\r\n }, //map(list => tail(list), xs),\r\n\r\n /**\r\n * Strips prefix list from given list\r\n * @function module:list.stripPrefix\r\n * @param prefix {Array|String|*}\r\n * @param list {Array|string|*}\r\n * @returns {Array|*}\r\n */\r\n stripPrefix = curry((prefix, list) =>\r\n isPrefixOf(prefix, list) ?\r\n splitAt(length(prefix), list)[1] :\r\n sliceCopy(list)),\r\n\r\n /**\r\n * zip takes two lists and returns a list of corresponding pairs.\r\n * If one input list is short, excess elements of the longer list are discarded.\r\n * @haskellType `zip :: [a] -> [b] -> [(a, b)]`\r\n * @function module:list.zip\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array>}\r\n */\r\n zip = curry((arr1, arr2) => {\r\n if (!length(arr1) || !length(arr2)) {\r\n return [];\r\n }\r\n const [a1, a2] = toShortest(arr1, arr2);\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, [item, a2[ind]]),\r\n [], a1);\r\n }),\r\n\r\n /**\r\n * zipN takes one or more lists and returns a list containing lists of all indices\r\n * at a given index, index by index.\r\n * If one input list is short, excess elements of the longer list are discarded.\r\n * @function module:list.zipN\r\n * @param lists {Array|String} - One ore more lists of the same type.\r\n * @returns {Array}\r\n */\r\n zipN = curry2((...lists) => {\r\n const trimmedLists = apply(toShortest, lists);\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, map(xs => xs[ind], trimmedLists)),\r\n [], trimmedLists[0]);\r\n }),\r\n\r\n /**\r\n * @haskellType `zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]`\r\n * @function module:list.zip3\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @param arr3 {Array}\r\n * @returns {Array>}\r\n */\r\n zip3 = curry((arr1, arr2, arr3) => zipN(arr1, arr2, arr3)),\r\n\r\n /**\r\n * @haskellType `zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]`\r\n * @function module:list.zip4\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @param arr3 {Array}\r\n * @param arr4 {Array}\r\n * @returns {Array>}\r\n */\r\n zip4 = curry((arr1, arr2, arr3, arr4) => zipN(arr1, arr2, arr3, arr4)),\r\n\r\n /**\r\n * @haskellType `zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]`\r\n * @function module:list.zip5\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @param arr3 {Array}\r\n * @param arr4 {Array}\r\n * @param arr5 {Array}\r\n * @returns {Array>}\r\n */\r\n zip5 = curry((arr1, arr2, arr3, arr4, arr5) => zipN(arr1, arr2, arr3, arr4, arr5)),\r\n\r\n /**\r\n * zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]\r\n * zipWith generalises zip by zipping with the function given as the\r\n * first argument, instead of a function tupling function (function that returns a tuple). For example,\r\n * zipWith (+) is applied to two lists to produce the list of corresponding sums.\r\n * @note `_|_` means bottom or perpetual (@see\r\n * - https://wiki.haskell.org/Bottom\r\n * - https://stackoverflow.com/questions/19794681/what-does-this-syntax-mean-in-haskell-or\r\n * )\r\n * @example\r\n * ```\r\n * zipWith f [] _|_ = []\r\n * ```\r\n * @haskellType `zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]`\r\n * @function module:list.zipWith\r\n * @param op {Function} - Takes two parts of a tuple and returns a tuple.\r\n * E.g., ` op :: a -> b -> (a, b)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith = curry((op, xs1, xs2) => {\r\n if (!length(xs1) || !length(xs2)) {\r\n return [];\r\n }\r\n const [a1, a2] = toShortest(xs1, xs2);\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, op(item, a2[ind])),\r\n [], a1);\r\n }),\r\n\r\n /**\r\n * Zips all given lists with tupling function. Note: Haskell types do not have\r\n * a way (that I know of) to show one or more for params in a function so `@haskellType` below\r\n * is left there for general purpose not for exactness as is told by aforementioned.\r\n * @haskellType `zipWithN :: (a -> b -> c) -> [a] -> [b] -> [c]` - Where `N` is the number\r\n * of lists to zip.\r\n * @function module:list.zipWithN\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> (a, b, c)`\r\n * @param lists ...{Array}\r\n * @returns {Array>}\r\n */\r\n zipWithN = curry3((op, ...lists) => {\r\n const trimmedLists = apply(toShortest, lists),\r\n lenOfTrimmed = length(trimmedLists);\r\n if (!lenOfTrimmed) {\r\n return [];\r\n }\r\n else if (lenOfTrimmed === 1) {\r\n return sliceTo(length(trimmedLists[0]), trimmedLists[0]);\r\n }\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, apply(op, map(xs => xs[ind], trimmedLists))),\r\n [], trimmedLists[0]);\r\n }),\r\n\r\n /**\r\n * Zips 3 lists with tupling function.\r\n * @haskellType `zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]`\r\n * @function module:list.zipWith3\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> (a, b, c)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @param xs3 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith3 = curry((op, xs1, xs2, xs3) => zipWithN(op, xs1, xs2, xs3)),\r\n\r\n /**\r\n * Zips 4 lists with tupling function.\r\n * @haskellType `zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]`\r\n * @function module:list.zipWith4\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> d -> (a, b, c, d)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @param xs3 {Array}\r\n * @param xs4 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith4 = curry((op, xs1, xs2, xs3, xs4) => zipWithN(op, xs1, xs2, xs3, xs4)),\r\n\r\n /**\r\n * Zips 5 lists.\r\n * @haskellType `zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]`\r\n * @function module:list.zipWith5\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> d -> e -> (a, b, c, d, e)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @param xs3 {Array}\r\n * @param xs4 {Array}\r\n * @param xs5 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith5 = curry((op, xs1, xs2, xs3, xs4, xs5) => zipWithN(op, xs1, xs2, xs3, xs4, xs5)),\r\n\r\n /**\r\n * unzip transforms a list of pairs into a list of first components and a list of second components.\r\n * @haskellType `unzip :: [(a, b)] -> ([a], [b])`\r\n * @function module:list.unzip\r\n * @param arr {Array|*}\r\n * @returns {Array|*}\r\n */\r\n unzip = foldl((agg, item) => {\r\n agg[0].push(item[0]);\r\n agg[1].push(item[1]);\r\n return agg;\r\n }, [[], []]),\r\n\r\n /**\r\n * unzip transforms a list of pairs into a list of first components and a list of second components.\r\n * @sudoHaskellType `unzipN :: [(a, b, ...x)] -> ([a], [b], ...[x])`\r\n * @function module:list.unzipN\r\n * @param list {Array|*} - List of tuples (lists).\r\n * @returns {Array|*}\r\n */\r\n unzipN = list => {\r\n if (!length(list)) {\r\n return [];\r\n }\r\n const lenItem0 = length(list[0]);\r\n let zero = lenItem0 ?\r\n unfoldr(numLists => numLists-- ? [[], numLists] : undefined, lenItem0) :\r\n [];\r\n return foldl((agg, item) => {\r\n agg.forEach((outList, ind) => outList.push(item[ind]));\r\n return agg;\r\n }, zero, list);\r\n },\r\n\r\n /**\r\n * Returns true if any item in container passes predicate `p`.\r\n * @function module:list.any\r\n * @param p {Function} - Predicate.\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n any = curry((p, xs) => {\r\n let ind = 0,\r\n limit = length(xs);\r\n if (!limit) {\r\n return false;\r\n }\r\n for (; ind < limit; ind += 1) {\r\n if (p(xs[ind])) {\r\n return true;\r\n }\r\n }\r\n return false;\r\n }),\r\n\r\n /**\r\n * Returns true if all items in container pass predicate `p`.\r\n * @function module:list.all\r\n * @param p {Function} - Predicate.\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n all = curry((p, xs) => {\r\n const limit = length(xs);\r\n let ind = 0;\r\n if (!limit) {\r\n return false;\r\n }\r\n for (; ind < limit; ind++) {\r\n if (!p(xs[ind], ind, xs)) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }),\r\n\r\n /**\r\n * Conjuction of container of bools (or truthy and/or falsy values); Returns\r\n * `true` if all in container are 'truthy' else returns `false`\r\n * @function module:list.and\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n and = xs => all(isTruthy, xs),\r\n\r\n /**\r\n * Returns a boolean indicating whether any item in container is 'truthy' or not.\r\n * **Note** The haskell type for this function only takes two items, but here\r\n * we allow the passing of more than one item (may change later to adhere to the haskell type).\r\n * @function module:list.or\r\n * @haskellType `or :: Bool -> Bool -> Bool`\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n or = xs => any(isTruthy, xs),\r\n\r\n /**\r\n * Returns a boolean indicating whether all items in container are 'falsy' or not.\r\n * **Note** The haskell type for this function only takes two items, but here\r\n * we allow the passing of more than one item (may change later to adhere to the haskell type).\r\n * @function module:list.not\r\n * @haskellType `not :: Bool -> Bool`\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n not = xs => all(isFalsy, xs),\r\n\r\n /**\r\n * Computes the sum of the numbers of a structure.\r\n * @function module:list.sum\r\n * @haskellType `sum :: (List t, Num a) => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {Number}\r\n */\r\n sum = list => foldl((agg, x) => agg + x, 0, list),\r\n\r\n /**\r\n * Computes the product of the numbers of a structure.\r\n * @function module:list.product\r\n * @haskellType `product :: (List t, Num a) => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {Number}\r\n */\r\n product = list => foldl((agg, x) => agg * x, 1, list),\r\n\r\n /**\r\n * Returns the largest element in a non-empty structure of elements.\r\n * @function module:list.maximum\r\n * @haskellType `maximum :: forall a . Ord a => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {*} - Whatever type the array is made of (if any).\r\n */\r\n maximum = list => last(sortBy(genericAscOrdering, list)),\r\n\r\n /**\r\n * Returns the smallest element in a non-empty structure of elements.\r\n * @function module:list.minimum\r\n * @haskellType `minimum :: forall a . Ord a => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {*} - Whatever type the array is made of (if any).\r\n */\r\n minimum = list => head(sortBy(genericAscOrdering, list)),\r\n\r\n /**\r\n * scanl is similar to foldl, but returns a list of successive reduced values from the left:\r\n * ```\r\n * scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]\r\n * ```\r\n * Also note that:\r\n * ```\r\n * last (scanl f z xs) == foldl f z xs.\r\n * ```\r\n * @function module:list.scanl\r\n * @param fn {Function}\r\n * @param zero {*}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanl = curry((fn, zero, xs) => {\r\n if (!xs || !length(xs)) {\r\n return [];\r\n }\r\n const limit = length(xs);\r\n let ind = 0,\r\n result = zero,\r\n out = [];\r\n while (ind < limit) {\r\n result = fn(result, xs[ind], ind, xs);\r\n out.push(result);\r\n ind++;\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * `scanl1` is a variant of `scanl` that has no starting value argument:\r\n * `shallowCompare(scanl1(fn, [x1, x2, ...]), [x1, fn(x1, x2), ...]) // true`\r\n * @function module:list.scanl1\r\n * @param fn {Function}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanl1 = curry((fn, xs) => {\r\n if (!xs || !xs.length) {\r\n return [];\r\n }\r\n return scanl(fn, head(xs), tail(xs));\r\n }),\r\n\r\n /**\r\n * Same as `scanl` but from the right (similiar to `foldr`'s relationship to 'foldl').\r\n * Note also `scanr`'s relationship ot `foldr`:\r\n * `head (scanr(fn, z, xs)) === foldr(fn, z, xs).\r\n * @function module:list.scanr\r\n * @param fn {Function}\r\n * @param zero {*}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanr = curry((fn, zero, xs) => {\r\n if (!xs || !length(xs)) {\r\n return [];\r\n }\r\n const limit = length(xs);\r\n let ind = limit - 1,\r\n result = xs[0],\r\n out = [];\r\n while (ind > -1) {\r\n result = fn(result, xs[ind], ind, xs);\r\n out.push(result);\r\n ind--;\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Same as `scanr` but takes no zero/accumulator value.\r\n * @function module:list.scanr1\r\n * @param fn {Function}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanr1 = curry((fn, xs) => {\r\n if (!xs || !xs.length) {\r\n return [];\r\n }\r\n return scanr(fn, last(xs), init(xs));\r\n }),\r\n\r\n /**\r\n * The nub function removes duplicate elements from a list.\r\n * In particular, it keeps only the first occurrence of each element.\r\n * (The name nub means `essence'.) It is a special case of nubBy, which\r\n * allows the programmer to supply their own equality test.\r\n * ```shallowCompare( nub ([1,2,3,4,3,2,1,2,4,3,5]), [1,2,3,4,5] )```\r\n * @function module:list.nub\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n nub = list => nubBy((a, b) => a === b, list),\r\n\r\n /**\r\n * `remove(x, xs)` removes the first occurrence of `x` from `xs`.\r\n * For example, `remove('a', 'banana') === 'bnana';`\r\n * @function module:list.remove\r\n * @param x {*}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n remove = curry((x, list) => removeBy((a, b) => a === b, x, list)),\r\n\r\n /**\r\n * The sort function implements a stable sorting algorithm.\r\n * It is a special case of sortBy, which allows the programmer\r\n * to supply their own comparison function.\r\n * ```shallowCompare(sort ([1,6,4,3,2,5]), [1,2,3,4,5,6]) // true```\r\n * @function module:list.sort\r\n * @param xs {Array|String|*}\r\n * @returns {Array}\r\n */\r\n sort = xs => sortBy(genericAscOrdering, xs),\r\n\r\n /**\r\n * Sort a list by comparing the results of a key function applied to each\r\n * element. sortOn f is equivalent to sortBy (comparing f), but has the\r\n * performance advantage of only evaluating f once for each element in the\r\n * input list. This is called the decorate-sort-undecorate paradigm, or\r\n * Schwartzian transform.\r\n *\r\n * Elements are arranged from from lowest to highest, keeping duplicates\r\n * in the order they appeared in the input.\r\n *\r\n * Ex:\r\n * ```\r\n * shallowEquals(\r\n * sortOn (head, [[2, \"world\"], [4, \"!\"], [1, \"Hello\"]]),\r\n * [[1,\"Hello\"],[2,\"world\"],[4,\"!\"]]\r\n * ) // true\r\n * ```\r\n * @function module:list.sortOn\r\n * @param valueFn {Function}\r\n * @param xs {Array|String|*}\r\n * @returns {Array}\r\n */\r\n sortOn = curry((valueFn, xs) =>\r\n\r\n // Un-decorate\r\n map(decorated => decorated[1],\r\n\r\n // Decorate and sort\r\n sortBy(\r\n // Ordering\r\n ([a0], [b0]) => genericAscOrdering(a0, b0),\r\n\r\n // Decorate\r\n map(item => [valueFn(item), item], xs)\r\n )\r\n )\r\n ),\r\n\r\n /**\r\n * The sortBy function is the non-overloaded (in haskell terms) version of sort.\r\n * @haskellExample ```\r\n * >>> sortBy (\\(a,_) (b,_) -> compare a b) [(2, \"world\"), (4, \"!\"), (1, \"Hello\")]\r\n * [(1,\"Hello\"),(2,\"world\"),(4,\"!\")]\r\n * ```\r\n * @function module:list.sortBy\r\n * @param orderingFn {Function}\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sortBy = curry((orderingFn, xs) => sliceCopy(xs).sort(orderingFn || genericAscOrdering)),\r\n\r\n /**\r\n * The insert function takes an element and a list and inserts the element\r\n * into the list at the first position where it is less than or equal to the\r\n * next element. In particular, if the list is sorted before the call, the\r\n * result will also be sorted. It is a special case of insertBy, which allows\r\n * the programmer to supply their own comparison function.\r\n * @function module:list.insert\r\n * @param x {*}\r\n * @param xs {Array|*}\r\n * @returns {Array}\r\n */\r\n insert = curry((x, xs) => {\r\n if (!xs.length) {\r\n return of(xs, x);\r\n }\r\n const foundIndex = findIndex(item => x <= item, xs);\r\n return foundIndex === -1 ? concat([xs, of(xs, x)]) :\r\n concat(intersperse(of(xs, x), splitAt(foundIndex, xs)));\r\n }),\r\n\r\n /**\r\n * A version of `insert` that allows you to specify the ordering of the inserted\r\n * item; Before/at, or after\r\n * @function module:list.insertBy\r\n * @haskellType `insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]`\r\n * @note `Ordering` means 'something that is order-able'\r\n * operated on by this functions logic.\r\n * @param orderingFn {Function} - A function that returns `-1`, `0`, or 1`.\r\n * @param x {*} - Value to insert.\r\n * @param xs {Array} - List to insert into (note new list is returned)\r\n * @returns {Array} - New list.\r\n */\r\n insertBy = curry((orderingFn, x, xs) => {\r\n const limit = length(xs);\r\n if (!limit) {\r\n return [x];\r\n }\r\n let ind = 0;\r\n for (; ind < limit; ind += 1) {\r\n if (orderingFn(x, xs[ind]) <= 0) {\r\n const parts = splitAt(ind, xs);\r\n return concat([parts[0], [x], parts[1]]);\r\n }\r\n }\r\n return aggregateArray(sliceCopy(xs), x);\r\n }),\r\n\r\n /**\r\n * The nubBy function behaves just like nub, except it uses a user-supplied equality predicate.\r\n * @function module:list.nubBy\r\n * @param pred {Function}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n nubBy = curry((pred, list) => {\r\n if (!length(list)) {\r\n return [];\r\n }\r\n const limit = length(list);\r\n let ind = 0,\r\n currItem,\r\n out = [],\r\n anyOp = storedItem => pred(currItem, storedItem);\r\n for (; ind < limit; ind += 1) {\r\n currItem = list[ind];\r\n if (any(anyOp, out)) {\r\n continue;\r\n }\r\n out.push(currItem);\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Behaves the same as `remove`, but takes a user-supplied equality predicate.\r\n * @function module:list.removeBy\r\n * @param pred {Function} - Equality predicate `(a, b) => bool`\r\n * @param x {*}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n removeBy = curry((pred, x, list) => {\r\n const foundIndex = findIndex(item => pred(x, item), list);\r\n if (foundIndex > -1) {\r\n const parts = splitAt(foundIndex, list);\r\n return append(parts[0], tail(parts[1]));\r\n }\r\n return sliceCopy(list);\r\n }),\r\n\r\n /**\r\n * The `removeFirstsBy` function takes a predicate and two lists and returns the first list with the first\r\n * occurrence of each element of the second list removed.\r\n * @function module:list.removeFirstBy\r\n * @param pred {Function}\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {Array}\r\n */\r\n removeFirstsBy = curry((pred, xs1, xs2) =>\r\n foldl((agg, x) => removeBy(pred, x, agg), xs1, xs2)),\r\n\r\n /**\r\n * Returns the union on elements matching boolean check passed in.\r\n * @function module:list.unionBy\r\n * @param pred {Function} - `pred :: a -> a -> Bool`\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array}\r\n */\r\n unionBy = curry((pred, arr1, arr2) =>\r\n foldl((agg, b) => {\r\n const alreadyAdded = any(a => pred(a, b), agg);\r\n return !alreadyAdded ? (agg.push(b), agg) : agg;\r\n }, sliceCopy(arr1), arr2\r\n )),\r\n\r\n /**\r\n * Creates a union on matching elements from array1.\r\n * @function module:list.union\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array}\r\n */\r\n union = curry((arr1, arr2) =>\r\n append(arr1,\r\n filter(elm => !includes(elm, arr1), arr2))),\r\n\r\n /**\r\n * Performs an intersection on list 1 with elements from list 2.\r\n * @function module:list.intersect\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array}\r\n */\r\n intersect = curry((arr1, arr2) =>\r\n !arr1 || !arr2 || (!arr1 && !arr2) ? [] :\r\n filter(elm => includes(elm, arr2), arr1)),\r\n\r\n /**\r\n * Returns an intersection by predicate.\r\n * @function module:list.intersectBy\r\n * @param pred {Function} - `pred :: a -> b -> Bool`\r\n * @param list1 {Array}\r\n * @param list2 {Array}\r\n * @return {Array}\r\n */\r\n intersectBy = curry((pred, list1, list2) =>\r\n foldl((agg, a) =>\r\n any(b => pred(a, b), list2) ? (agg.push(a), agg) : agg\r\n , [], list1)),\r\n\r\n /**\r\n * Returns the difference of list 1 from list 2.\r\n * @note The `difference` operation here is non-associative; E.g., `a - b` is not equal to `b - a`;\r\n * @function module:list.difference\r\n * @param array1 {Array}\r\n * @param array2 {Array}\r\n * @returns {Array}\r\n */\r\n difference = curry((array1, array2) => { // augment this with max length and min length ordering on op\r\n if (array1 && !array2) {\r\n return sliceCopy(array1);\r\n }\r\n else if (!array1 && array2 || (!array1 && !array2)) {\r\n return [];\r\n }\r\n return reduce((agg, elm) =>\r\n !includes(elm, array2) ? (agg.push(elm), agg) : agg\r\n , [], array1);\r\n }),\r\n\r\n /**\r\n * Returns the complement of list 0 and the reset of the passed in arrays.\r\n * @function module:list.complement\r\n * @param arr0 {Array}\r\n * @param arrays {...Array}\r\n * @returns {Array}\r\n */\r\n complement = curry2((arr0, ...arrays) =>\r\n reduce((agg, arr) => append(agg, difference(arr, arr0)), [], arrays));\r\n","/**\r\n * @module errorThrowing\r\n * @description Contains error throwing facilities for when a value doesn't match a type.\r\n */\r\nimport {typeOf} from './object/typeOf';\r\nimport {isArray, toTypeRef, toTypeRefName, isOfType} from './object/is';\r\nimport {curry} from './function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Pretty prints an array of types/type-strings for use by error messages;\r\n * Outputs \"`SomeTypeName`, ...\" from [SomeType, 'SomeTypeName', etc...]\r\n * @function module:errorThrowing.typeRefsToStringOrError\r\n * @param types {Array|TypesArray}\r\n * @return {String}\r\n * @private\r\n */\r\n typeRefsToStringOrError = types => types.length ?\r\n types.map(type => `\\`${toTypeRefName(type)}\\``).join(', ') : '',\r\n\r\n /**\r\n * Prints a message from an object. Object signature:\r\n * {contextName, valueName, value, expectedTypeName, foundTypeName, messageSuffix}\r\n * @function module:errorThrowing.defaultErrorMessageCall\r\n * @param tmplContext {Object|TemplateContext} - Object to use in error template.\r\n * @returns {string}\r\n * @private\r\n */\r\n defaultErrorMessageCall = tmplContext => {\r\n const {\r\n contextName, valueName, value, expectedTypeName,\r\n foundTypeName, messageSuffix\r\n } = tmplContext,\r\n isMultiTypeNames = isArray(expectedTypeName),\r\n typesCopy = isMultiTypeNames ? 'of type' : 'of one of the types',\r\n typesToMatchCopy = isMultiTypeNames ? typeRefsToStringOrError(expectedTypeName) : expectedTypeName;\r\n return (contextName ? `\\`${contextName}.` : '`') +\r\n `${valueName}\\` is not ${typesCopy}: ${typesToMatchCopy}. ` +\r\n `Type received: ${foundTypeName}. Value: ${value};` +\r\n `${messageSuffix ? ' ' + messageSuffix + ';' : ''}`;\r\n },\r\n\r\n /**\r\n * Gets the error message thrower seeded with passed in errorMessage template call.\r\n * @function module:errorThrowing.getErrorIfNotTypeThrower$\r\n * @param errorMessageCall {Function|ErrorMessageCall}\r\n * @param typeChecker {Function|TypeChecker} - Function:Boolean\r\n * @returns {Function|ErrorIfNotType}\r\n * @private\r\n */\r\n _getErrorIfNotTypeThrower = (errorMessageCall, typeChecker = isOfType) =>\r\n (ValueType, contextName, valueName, value, messageSuffix = null) => {\r\n const expectedTypeName = toTypeRef(ValueType),\r\n foundTypeName = typeOf(value);\r\n if (typeChecker(ValueType, value)) { return value; } // Value matches type\r\n throw new Error(errorMessageCall(\r\n {contextName, valueName, value, expectedTypeName, foundTypeName, messageSuffix}\r\n ));\r\n },\r\n\r\n /**\r\n * Gets the error message thrower seeded with passed in errorMessage template call.\r\n * @function module:errorThrowing.getErrorIfNotTypesThrower$\r\n * @param errorMessageCall {Function|ErrorMessageCall}\r\n * @param typeChecker {Function|TypeChecker} - Function:Boolean\r\n * @returns {Function|ErrorIfNotTypes}\r\n * @private\r\n */\r\n _getErrorIfNotTypesThrower = (errorMessageCall, typeChecker = isOfType) =>\r\n (valueTypes, contextName, valueName, value, messageSuffix = null) => {\r\n const expectedTypeNames = valueTypes.map(toTypeRef),\r\n matchFound = valueTypes.some(ValueType => typeChecker(ValueType, value)),\r\n foundTypeName = typeOf(value);\r\n if (matchFound) { return value; }\r\n throw new Error(\r\n errorMessageCall({\r\n contextName, valueName, value,\r\n expectedTypeName: expectedTypeNames, foundTypeName,\r\n messageSuffix\r\n })\r\n );\r\n },\r\n\r\n /**\r\n * Checks that passed in `value` is of given `type`. Throws an error if value\r\n * is not of given `type`. This is the un-curried version. For the curried version\r\n * see `module:errorThrowing.errorIfNotType`.\r\n * @function module:errorThrowing.errorIfNotType$\r\n * @param type {String|Function} - Type's name or type itself.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @param [messageSuffix=null] {String} - Optional.\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @private\r\n */\r\n _errorIfNotType = _getErrorIfNotTypeThrower(defaultErrorMessageCall),\r\n\r\n /**\r\n * Checks that passed in `value` is of one of the given `types`. Throws an error if value\r\n * is not of one of the given `types`. This is the un-curried version. For the curried version\r\n * see `module:errorThrowing.errorIfNotTypes`.\r\n * @type {Function|module:errorThrowing.errorIfNotTypes}\r\n * @function module:errorThrowing.errorIfNotTypes$\r\n * @param types {Array} - Array of one or more types or type names themselves.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @private\r\n */\r\n _errorIfNotTypes = _getErrorIfNotTypesThrower(defaultErrorMessageCall),\r\n\r\n /**\r\n * Returns a function that can be used to ensure that values are of a given type.\r\n * Also throws informative error messages containing the value types, names, expected type names,\r\n * etc.\r\n * @function module:errorThrowing.getErrorIfNotTypeThrower\r\n * @param errorMessageCall {Function|ErrorMessageCall} - Template function (takes an info-object and returns a printed string).\r\n * @returns {Function|ErrorIfNotType} - Returns a function with the same signature as `errorIfNotType` though curried.\r\n */\r\n getErrorIfNotTypeThrower = errorMessageCall => curry(_getErrorIfNotTypeThrower(errorMessageCall)),\r\n\r\n /**\r\n * Returns a function that can be used to ensure that a value is of one or more given types.\r\n * The returned function is used in cases where informative error messages\r\n * containing the value types, names, expected type names, are-required/should-be-used etc.\r\n * @function module:errorThrowing.getErrorIfNotTypesThrower\r\n * @param errorMessageCall {Function|ErrorMessageCall} - Template function (takes an info-object and returns a printed string).\r\n * @returns {Function|ErrorIfNotTypes} - Returns a function with the same signature as `errorIfNotTypes` though curried.\r\n */\r\n getErrorIfNotTypesThrower = errorMessageCall => curry(_getErrorIfNotTypesThrower(errorMessageCall)),\r\n\r\n /**\r\n * Checks that passed in `value` is of given `type`. Throws an error if value\r\n * is not of given `type`. Curried.\r\n * @function module:errorThrowing.errorIfNotType\r\n * @param type {String|Function} - Type's name or type itself.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @param [messageSuffix=null] {String} - Optional.\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @curried\r\n */\r\n errorIfNotType = curry(_errorIfNotType),\r\n\r\n /**\r\n * Checks that passed in `value` is of one of the given `types`. Throws an error if value\r\n * is not of one of the given `types`. Curried.\r\n * @function module:errorThrowing.errorIfNotTypes\r\n * @param types {Array} - Array of one or more types or type names themselves.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @curried\r\n */\r\n errorIfNotTypes = curry(_errorIfNotTypes)\r\n;\r\n\r\n/**\r\n * @typedef {*} Any - Synonym for 'any value'.\r\n */\r\n\r\n/**\r\n * @typedef {String|Function} TypeRef\r\n * @description Type reference. Type itself or Type's name; E.g., `Type.name`;\r\n */\r\n\r\n/**\r\n * @typedef {Object} TemplateContext\r\n * @description Template context used for error message renderers (functions that take a context obj and return a string).\r\n * @property value {*}\r\n * @property valueName {String}\r\n * @property expectedTypeName {String} - Expected name of constructor of `value`; E.g., usually `SomeConstructor.name`;\r\n * @property foundTypeName {String} - Found types name; E.g., `FoundConstructor.name`;\r\n * @property [messageSuffix=null] {*} - Message suffix (sometimes an extra hint or instructions for\r\n * directing user to fix where his/her error has occurred). Optional.\r\n */\r\n\r\n/**\r\n * @typedef {Array<(String|Function)>} TypesArray\r\n */\r\n\r\n/**\r\n * @typedef {Function} TypeChecker\r\n * @description Checks whether a value is of given type.\r\n * @param Type {TypeRef} - a Type or it's name; E.g., `Type.name`.\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n\r\n/**\r\n * @typedef {Function} ErrorMessageCall\r\n * @description Error message template function.\r\n * @param tmplContext {TemplateContext}\r\n * @returns {String}\r\n */\r\n\r\n/**\r\n * @typedef {Function} ErrorIfNotType\r\n * @description Used to ensure value matches passed in type.\r\n * @param type {TypeRef} - Constructor name or constructor.\r\n * @param contextName {String}\r\n * @param valueName {String}\r\n * @param value {*}\r\n * @throws {Error} - If value doesn't match type.\r\n * @returns {*} - What ever value is.\r\n */\r\n\r\n/**\r\n * @typedef {Function} ErrorIfNotTypes\r\n * @description Used to ensure a value matches one of one or more types passed in.\r\n * @param valueTypes {TypesArray} - Array of constructor names or constructors.\r\n * @param contextName {String}\r\n * @param valueName {String}\r\n * @param value {*}\r\n * @throws {Error} - If value doesn't match type.\r\n * @returns {*} - Whatever value is.\r\n */\r\n","/**\r\n * @module string\r\n * @description Contains functions for strings.\r\n */\r\nimport {intercalate, map, filter} from './list';\r\nimport {split} from './jsPlatform/string';\r\nimport {compose} from './function/compose';\r\nimport {join} from './jsPlatform/array';\r\nimport {_errorIfNotType} from './errorThrowing';\r\n\r\nexport {split};\r\n\r\nexport const\r\n\r\n /**\r\n * Splits a string on all '\\n', '\\r', '\\n\\r', or '\\r\\n' characters.\r\n * @function module:string.lines\r\n * @param str {String}\r\n * @returns {Array}\r\n */\r\n lines = split(/[\\n\\r]/gm),\r\n\r\n /**\r\n * Splits a string on all '\\s' and/or all '\\t' characters.\r\n * @function module:string.words\r\n * @param str{String}\r\n * @returns {Array}\r\n */\r\n words = split(/[\\s\\t]/gm),\r\n\r\n /**\r\n * Intersperse an array of strings with '\\s' and then concats them.\r\n * @function module:string.unwords\r\n * @param arr {String}\r\n * @returns {Array}\r\n */\r\n unwords = intercalate(' '),\r\n\r\n /**\r\n * Intersperses a '\\n' character into a list of strings and then concats it.\r\n * @function module:string.unlines\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n unlines = intercalate('\\n'),\r\n\r\n /**\r\n * Lower cases first character of a non-empty string.\r\n * @function module:string.lcaseFirst\r\n * @param xs {String}\r\n * @returns {string}\r\n * @throws {Error} - Throws error if receiving anything that is not a string.\r\n */\r\n lcaseFirst = xs => {\r\n _errorIfNotType(String, 'lcaseFirst', 'xs', xs);\r\n return xs[0].toLowerCase() + xs.substring(1);\r\n },\r\n\r\n /**\r\n * Upper cases first character of a non-empty string.\r\n * @function module:string.ucaseFirst\r\n * @param xs {String}\r\n * @returns {string}\r\n * @throws {Error} - Throws error if receiving anything that is not a string.\r\n */\r\n ucaseFirst = xs => {\r\n _errorIfNotType(String, 'ucaseFirst', 'xs', xs);\r\n return xs[0].toUpperCase() + xs.substring(1);\r\n },\r\n\r\n /**\r\n * Camel cases (class case) a string.\r\n * @function module:string.camelCase\r\n * @param xs {String}\r\n * @param [pattern=/[^a-z\\d/i]/] {RegExp} - Pattern to split on. Optional.\r\n * @throws {Error} - Throws error if param `xs` is not a string.\r\n * @returns {string}\r\n * @curried\r\n */\r\n camelCase = (xs, pattern = /[^a-z\\d]/i) => compose(\r\n join(''),\r\n map(str => ucaseFirst(str.toLowerCase())),\r\n filter(x => !!x),\r\n split(pattern)\r\n )(_errorIfNotType(String, 'camelCase', 'xs', xs)),\r\n\r\n /**\r\n * Class cases a string. Uses pattern /[^a-z\\d/i]/ to split on.\r\n * If you require a different pattern use `string.camelCase(str, pattern)`\r\n * and then upper case first character (`ucaseFirst`).\r\n * @function module:string.classCase\r\n * @param xs {String}\r\n * @returns {string}\r\n * @throws {Error} - Throws error if `xs` is not a string (via `camelCase` call).\r\n */\r\n classCase = compose(ucaseFirst, camelCase)\r\n\r\n;\r\n\r\n/**\r\n * Functional version of `String.prototype.split`.\r\n * @function module:string.split\r\n * @param separator {String|RegExp}\r\n * @param str {String}\r\n * @returns {Array}\r\n */\r\n","/**\r\n * @module fjl\r\n * @description Exports all module methods (object, list, string modules etc.).\r\n * @goal to include everything from haskell's Prelude where it makes sense in order to create\r\n * a subset of functions which can make the javascript developer more efficient and make his/her\r\n * code more concise (and functional).\r\n * @motivation preludejs, lodash/fp, RamdaJs, Haskell.\r\n * @see http://hackage.haskell.org/package/base-4.10.0.0/docs/Prelude.html\r\n * @see http://hackage.haskell.org/package/base-4.10.0.0/docs/Data-List.html\r\n */\r\nexport * from './object';\r\nexport * from './boolean';\r\nexport * from './function';\r\nexport * from './list';\r\nexport * from './string';\r\nexport * from './utils';\r\nexport * from './errorThrowing';\r\n"],"names":["returnCurried","executeArity","unmetArityNum","fn","argsToCurry","func","x","executeAsCurriedFunc","Array","from","arguments","a","b","c","d","e","args","unmetArity","concatedArgs","concat","canBeCalled","length","newExpectedArity","curryN","Function","Error","curry","curry2","curry3","curry4","curry5","fPureTakesOne","name","arg","f","fPureTakes2","arg1","arg2","fPureTakes3","arg3","fPureTakes4","arg4","fPureTakes5","arg5","fPureTakesOneOrMore","defineReverse","prototype","reverse","reduceRight","agg","item","push","map","filter","reduce","forEach","some","every","join","apply","call","flipN","flip","flip3","flip4","flip5","instanceOf","instanceConstructor","instance","hasOwnProperty","native","Object","getOwnPropertyNames","key","operation","keys","assign","obj0","objs","topAgg","obj","_Number","Number","_NaN","_Null","_Undefined","typeOf","value","retVal","undefined","constructorName","constructor","isNaN","_String","String","_Object","_Boolean","Boolean","_Function","_Array","_Symbol","_Map","_Set","_WeakMap","_WeakSet","toTypeRef","type","toTypeRefs","types","toTypeRefName","Type","ref","toTypeRefNames","isFunction","isType","isOfType","isClass","test","substr","isCallable","isArray","isObject","isBoolean","isNumber","isString","isMap","isSet","isWeakMap","isWeakSet","isUndefined","isNull","isSymbol","isUsableImmutablePrimitive","typeOfX","isset","isEmptyList","isEmptyObject","isEmptyCollection","size","isEmpty","isOneOf","typeName","isFunctor","lookup","of","copy","out","slice","Symbol","Promise","searchObj","nsString","indexOf","parts","split","limit","ind","parent","node","assignDeep","propDescription","getOwnPropertyDescriptor","get","set","writable","includes","xs","lastIndexOf","isTruthy","isFalsy","alwaysTrue","alwaysFalse","equal","equalAll","i","aggregateArray","sliceFrom","startInd","sliceTo","toInd","sliceCopy","genericAscOrdering","lengths","lists","toShortest","listLengths","smallLen","Math","min","list","reduceUntil","pred","op","result","reduceUntilRight","arr","lastIndex","len","findIndexWhere","predicateFulfilled","findIndexWhereRight","findIndicesWhere","findWhere","elm","objUnion","obj1","obj2","objIntersect","objDifference","objComplement","log","console","bind","error","peek","pop","jsonClone","JSON","parse","stringify","toAssocList","toAssocListDeep","TypeConstraint","fromAssocList","OutType","fromAssocListDeep","toArray","compose","arg0","id","negateF","negateF2","negateF3","negateFN","until","predicate","typeInstance","fnOrError","symbolName","noop","normalizeStep","to","step","range","append","listAppend","head","last","tail","init","uncons","unconsr","item0","concatMap","foldableOfA","intersperse","between","lastInd","intercalate","xss","transpose","numLists","ind2","longestListLen","maximum","outLists","outList","subsequences","listLen","pow","entry","j","swapped","ind1","tmp","permutations","repeat","foldl","foldr","foldl1","foldr1","mapAccumL","zero","mapped","tuple","mapAccumR","iterate","lastX","replicate","cycle","unfoldr","resultTuple","findIndex","findIndices","elemIndex","foundInd","elemIndices","take","drop","splitAt","takeWhile","dropWhile","splitPoint","dropWhileEnd","span","breakOnList","at","find","partition","elem","notElem","isPrefixOf","xs1","xs2","limit1","limit2","isSuffixOf","isInfixOf","foundLen","isSubsequenceOf","lenXs1","group","groupBy","equalityOp","prevItem","predOp","inits","tails","stripPrefix","prefix","zip","arr1","arr2","a1","a2","zipN","trimmedLists","zip3","arr3","zip4","arr4","zip5","arr5","zipWith","zipWithN","lenOfTrimmed","zipWith3","xs3","zipWith4","xs4","zipWith5","xs5","unzip","unzipN","lenItem0","any","p","all","and","or","not","sum","product","sortBy","minimum","scanl","scanl1","scanr","scanr1","nub","nubBy","remove","removeBy","sort","sortOn","valueFn","decorated","a0","b0","orderingFn","insert","foundIndex","insertBy","currItem","anyOp","storedItem","removeFirstsBy","unionBy","alreadyAdded","union","intersect","intersectBy","list1","list2","difference","array1","array2","complement","arr0","arrays","typeRefsToStringOrError","defaultErrorMessageCall","tmplContext","contextName","valueName","expectedTypeName","foundTypeName","messageSuffix","isMultiTypeNames","typesCopy","typesToMatchCopy","_getErrorIfNotTypeThrower","errorMessageCall","typeChecker","ValueType","_getErrorIfNotTypesThrower","valueTypes","expectedTypeNames","matchFound","_errorIfNotType","_errorIfNotTypes","getErrorIfNotTypeThrower","getErrorIfNotTypesThrower","errorIfNotType","errorIfNotTypes","lines","words","unwords","unlines","lcaseFirst","toLowerCase","substring","ucaseFirst","toUpperCase","camelCase","pattern","str","classCase"],"mappings":"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"} \ No newline at end of file +{"version":3,"file":"fjl.mjs","sources":["../../src/function/curry.js","../../src/utils.js","../../src/jsPlatform/array.js","../../src/jsPlatform/function.js","../../src/function/flip.js","../../src/jsPlatform/object.js","../../src/object/typeOf.js","../../src/object/is.js","../../src/object/lookup.js","../../src/object/of.js","../../src/object/copy.js","../../src/object/searchObj.js","../../src/object/assignDeep.js","../../src/jsPlatform/list.js","../../src/boolean.js","../../src/list/map.js","../../src/list/aggregation.js","../../src/list/utils.js","../../src/object/setTheory.js","../../src/object/console.js","../../src/object/jsonClone.js","../../src/object/assocList.js","../../src/object/toArray.js","../../src/object.js","../../src/function/compose.js","../../src/function/id.js","../../src/function/negate.js","../../src/function/until.js","../../src/function/fnOrError.js","../../src/function/noop.js","../../src/function.js","../../src/list/range.js","../../src/jsPlatform/string.js","../../src/jsPlatform.js","../../src/list.js","../../src/errorThrowing.js","../../src/string.js","../../src/fjl.js"],"sourcesContent":["/**\r\n * @author elydelacruz\r\n * @created 12/6/2016.\r\n * @memberOf function\r\n * @description \"Curry strict\" and \"curry arbitrarily\" functions (`curry`, `curryN`).\r\n */\r\n\r\n/**\r\n * @private\r\n * @type {string}\r\n */\r\nconst\r\n\r\n /**\r\n * Returns curried function.\r\n * @private\r\n * @param executeArity {Number}\r\n * @param unmetArityNum {Number}\r\n * @param fn {Function}\r\n * @param argsToCurry {...*}\r\n * @returns {Function} - Curried function.\r\n */\r\n returnCurried = (executeArity, unmetArityNum, fn, argsToCurry) => {\r\n switch (unmetArityNum) {\r\n case 1:\r\n /* eslint-disable */\r\n return function func(x) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 2:\r\n /* eslint-disable */\r\n return function func(a, b) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 3:\r\n /* eslint-disable */\r\n return function func(a, b, c) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 4:\r\n /* eslint-disable */\r\n return function func(a, b, c, d) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 5:\r\n /* eslint-disable */\r\n return function func(a, b, c, d, e) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n default:\r\n return (...args) => executeAsCurriedFunc(fn, executeArity, unmetArityNum, args, argsToCurry);\r\n }\r\n },\r\n\r\n /**\r\n * Returns curried function if unmetArity is not met else returns result of executing\r\n * final function.\r\n * @private\r\n * @param fn {Function}\r\n * @param executeArity {Number}\r\n * @param unmetArity {Number}\r\n * @param args {Array<*>}\r\n * @param argsToCurry {Array<*>}\r\n * @returns {Function|*} - Curried function or result of 'finally' executed function.\r\n */\r\n executeAsCurriedFunc = (fn, executeArity, unmetArity, args, argsToCurry) => {\r\n let concatedArgs = argsToCurry.concat(args),\r\n canBeCalled = (concatedArgs.length >= executeArity) || !executeArity,\r\n newExpectedArity = executeArity - concatedArgs.length;\r\n return !canBeCalled ?\r\n returnCurried(executeArity, newExpectedArity, fn, concatedArgs) :\r\n fn(...concatedArgs);\r\n }\r\n;\r\n\r\nexport const\r\n\r\n /**\r\n * Curries a function up to a given arity.\r\n * @function module:function.curryN\r\n * @param executeArity {Number}\r\n * @param fn {Function}\r\n * @param argsToCurry {...*}\r\n * @returns {Function}\r\n * @throws {Error} - When `fn` is not a function.\r\n */\r\n curryN = (executeArity, fn, ...argsToCurry) => {\r\n if (!fn || !(fn instanceof Function)) {\r\n throw new Error(`\\`curry*\\` functions expect first parameter to be of type \\`Function\\` though received ${fn}?`);\r\n }\r\n return returnCurried(executeArity, executeArity - argsToCurry.length, fn, argsToCurry);\r\n },\r\n\r\n /**\r\n * Curries a function based on it's defined arity (note: rest args param (`...rest`) are not counted in arity).\r\n * @function module:function.curry\r\n * @param fn {Function}\r\n * @param argsToCurry {...*}\r\n * @returns {Function}\r\n */\r\n curry = (fn, ...argsToCurry) => curryN((fn || {}).length, fn, ...argsToCurry),\r\n\r\n /**\r\n * Curries a function up to an arity of 2 (won't call function until 2 or more args).\r\n * @function module:function.curry2\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry2 = fn => curryN(2, fn),\r\n\r\n /**\r\n * Curries a function up to an arity of 3 (won't call function until 3 or more args).\r\n * @function module:function.curry3\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry3 = fn => curryN(3, fn),\r\n\r\n /**\r\n * Curries a function up to an arity of 4 (won't call function until 4 or more args).\r\n * @function module:function.curry4\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry4 = fn => curryN(4, fn),\r\n\r\n /**\r\n * Curries a function up to an arity of 5 (won't call function until 5 or more args).\r\n * @function module:function.curry5\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry5 = fn => curryN(5, fn);\r\n","/**\r\n * @module utils\r\n */\r\nimport {curry, curry2} from './function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a function that takes an argument and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakesOne\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakesOne = name => curry((arg, f) => f[name](arg)),\r\n\r\n /**\r\n * Returns a function that takes 2 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes2\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes2 = name => curry((arg1, arg2, f) => f[name](arg1, arg2)),\r\n\r\n /**\r\n * Returns a function that takes 3 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes3\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes3 = name => curry((arg1, arg2, arg3, f) => f[name](arg1, arg2, arg3)),\r\n\r\n /**\r\n * Returns a function that takes 4 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes4\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes4 = name => curry((arg1, arg2, arg3, arg4, f) => f[name](arg1, arg2, arg3, arg4)),\r\n\r\n /**\r\n * Returns a function that takes 5 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes5\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes5 = name => curry((arg1, arg2, arg3, arg4, arg5, f) => f[name](arg1, arg2, arg3, arg4, arg5)),\r\n\r\n /**\r\n * Returns a function that takes an object and one or more arguments on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakesOneOrMore\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakesOneOrMore = name => curry2((f, ...args) => f[name](...args))\r\n\r\n;\r\n","/**\r\n * Created by elyde on 7/20/2017.\r\n * Functional versions of common array methods (`map`, `filter`, etc.) (un-curried);\r\n * @module _jsPlatform_arrayOps\r\n * @private\r\n */\r\n\r\nimport {fPureTakesOne, fPureTakes2, fPureTakesOneOrMore} from '../utils';\r\n\r\nexport const\r\n\r\n /**\r\n * Array.prototype.reverse generator (generates a function that calls the prototype version or a\r\n * shimmed version if it doesn't exist).\r\n * @returns {Function}\r\n */\r\n defineReverse = () =>\r\n Array.prototype.reverse ? x => x.reverse() :\r\n x => x.reduceRight((agg, item) => {\r\n agg.push(item);\r\n return agg;\r\n }, []),\r\n\r\n /**\r\n * Maps a function to functor (list etc.).\r\n * @function module:_jsPlatform_array.map\r\n * @param fn {Function}\r\n * @param functor {Array|{map: {Function}}}\r\n * @returns {Array|{map: {Function}}}\r\n */\r\n map = fPureTakesOne('map'),\r\n\r\n /**\r\n * Filters a functor (list etc.) with passed in function.\r\n * @function module:_jsPlatform_array.filter\r\n * @param fn {Function}\r\n * @param functor {Array|{filter: {Function}}}\r\n * @returns {Array|{filter: {Function}}}\r\n */\r\n filter = fPureTakesOne('filter'),\r\n\r\n /**\r\n * Reduces a foldable (list etc.) with passed in function.\r\n * @function module:_jsPlatform_array.reduce\r\n * @param fn {Function}\r\n * @param functor {Array|{reduce: {Function}}}\r\n * @returns {Array|{reduce: {Function}}}\r\n */\r\n reduce = fPureTakes2('reduce'),\r\n\r\n /**\r\n * Reduces a foldable (list etc.) from the right with passed in function.\r\n * @function module:_jsPlatform_array.reduceRight\r\n * @param fn {Function}\r\n * @param functor {Array|{reduceRight: {Function}}}\r\n * @returns {Array|{reduceRight: {Function}}}\r\n */\r\n reduceRight = fPureTakes2('reduceRight'),\r\n\r\n /**\r\n * For each on functor (Array|Object|etc.).\r\n * @param fn {Function}\r\n * @param functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type of object you pass in unless it doesn't have a `forEach` method.\r\n * @throws {Error} - When passed in functor doesn't have a `forEach` method.\r\n */\r\n forEach = fPureTakesOne('forEach'),\r\n\r\n /**\r\n * Returns `true` if `fn` (predicate) returns true for at least one item\r\n * in functor else returns `false`.\r\n * @param fn {Function} - Predicate.\r\n * @param functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type passed.\r\n * @throws {Error} - When passed in object doesn't have a `some` method.\r\n */\r\n some = fPureTakesOne('some'),\r\n\r\n /**\r\n * Returns `true` if `fn` (predicate) returns true for all items in functor else returns `false`.\r\n * @param fn {Function} - Predicate.\r\n * @param functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type passed.\r\n * @throws {Error} - When passed in object doesn't have an `every` method.\r\n */\r\n every = fPureTakesOne('every'),\r\n\r\n /**\r\n * Array.prototype.join\r\n * @function module:listPrelude.join\r\n * @param separator {String|RegExp}\r\n * @param arr {Array}\r\n * @returns {String}\r\n */\r\n join = fPureTakesOne('join'),\r\n\r\n /**\r\n * Same as Array.prototype.push\r\n * @param item {*}\r\n * @param arr {Array}\r\n * @returns {Number}\r\n */\r\n push = fPureTakesOneOrMore('push'),\r\n\r\n /**\r\n * Reverses an list (shimmed if not exists).\r\n * @function module:listPrelude.reverse\r\n * @return {Array}\r\n */\r\n reverse = defineReverse();\r\n","import {curry, curry2} from '../function/curry';\r\n\r\n/**\r\n * Created by elydelacruz on 9/7/2017.\r\n * @memberOf function\r\n */\r\nexport const\r\n\r\n /**\r\n * Functional `apply` function (takes no context).\r\n * @function module:function.apply\r\n * @param fn {Function}\r\n * @param args {Array|*}\r\n * @returns {*}\r\n */\r\n apply = curry((fn, args) => fn.apply(null, args)),\r\n\r\n /**\r\n * Functional `call` function (takes no context).\r\n * @function module:function.call\r\n * @param fn {Function}\r\n * @param args {...*}\r\n * @returns {*}\r\n */\r\n call = curry2((fn, ...args) => fn.call(null, ...args));\r\n","import {reverse} from '../jsPlatform/array';\r\nimport {apply, call} from '../jsPlatform/function';\r\nimport {curry, curry2} from './curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a curried function requiring given functions arguments in reverse\r\n * (returned function expects 2 or more variables (curried at 2 or more args)).\r\n * @function module:function.flipN\r\n * @param fn {Function}\r\n * @returns {Function}\r\n * @curried\r\n */\r\n flipN = fn => curry2((...args) => apply(fn, reverse(args))),\r\n\r\n /**\r\n * Flips a function's first and second arguments and and returns a new function requiring said arguments in reverse.\r\n * @function module:function.flip\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip = fn => curry((b, a) => call(fn, a, b)),\r\n\r\n /**\r\n * Same as `flip` except returns a flipped function of arity 3.\r\n * @function module:function.flip3\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip3 = fn => curry((c, b, a) => call(fn, a, b, c)),\r\n\r\n /**\r\n * Same as `flip` except returns a flipped function of arity 4.\r\n * @function module:function.flip4\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip4 = fn => curry((d, c, b, a) => call(fn, a, b, c, d)),\r\n\r\n /**\r\n * Same as `flip` except returns a flipped function of arity 5.\r\n * @function module:function.flip5\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip5 = fn => curry((e, d, c, b, a) => call(fn, a, b, c, d, e));\r\n","/**\r\n * @memberOf object\r\n * @description Defines some of the platform methods for objects (the ones used within `fjl`).\r\n */\r\n\r\nimport {fPureTakesOne} from '../utils';\r\nimport {curry, curry2} from '../function/curry';\r\nimport {flip, flip3, flip4, flip5} from '../function/flip';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns whether constructor has derived object.\r\n * @function module:object.instanceOf\r\n * @param instanceConstructor {Function} - Constructor.\r\n * @param instance {*}\r\n * @instance {*}\r\n * @returns {Boolean}\r\n */\r\n instanceOf = curry((instanceConstructor, instance) =>\r\n instance instanceof instanceConstructor),\r\n\r\n /**\r\n * @function module:object.hasOwnProperty\r\n * @param propName {*}\r\n * @param typeInstance {*}\r\n * @returns {Boolean}\r\n * @deprecated - Use property directly instead.\r\n */\r\n hasOwnProperty = fPureTakesOne('hasOwnProperty'),\r\n\r\n /**\r\n * @function module:object.length\r\n * @param x {*}\r\n * @returns {Number}\r\n * @throws {Error} - Throws an error if value doesn't have a `length` property (\r\n * `null`, `undefined`, {Boolean}, Symbol, et. al.).\r\n */\r\n length = x => x.length,\r\n\r\n /**\r\n * Contains all the static functions from `Object` but curried and flipped;\r\n * @example\r\n * // E.g., `Object.defineProperties(obj, descriptor)` can now be used like\r\n * import {defineProperties} from 'fjl'\r\n * defineProperties(descriptor, someObj),\r\n * // Et. al.\r\n * @memberOf module:object\r\n * @type {{...Object}}\r\n */\r\n native = Object.getOwnPropertyNames(Object).reduce((agg, key) => {\r\n if (typeof Object[key] !== 'function') {\r\n return agg;\r\n }\r\n const operation = Object[key];\r\n switch (operation.length) {\r\n case 2:\r\n agg[key] = flip(operation);\r\n break;\r\n case 3:\r\n agg[key] = flip3(operation);\r\n break;\r\n case 4:\r\n agg[key] = flip4(operation);\r\n break;\r\n case 5:\r\n agg[key] = flip5(operation);\r\n break;\r\n default:\r\n agg[key] = Object[key];\r\n break;\r\n }\r\n return agg;\r\n }, {}),\r\n\r\n /**\r\n * Gets passed in object's own enumerable keys (same as `Object.keys`).\r\n * @function module:object.keys\r\n * @param obj {*}\r\n * @returns {Array}\r\n */\r\n {keys} = native,\r\n\r\n /**\r\n * Defined as `Object.assign` else is the same thing but shimmed.\r\n * @function module:object.assign\r\n * @param obj0 {Object}\r\n * @param objs {...{Object}}\r\n * @returns {Object}\r\n */\r\n assign = (() => Object.assign ?\r\n (obj0, ...objs) => Object.assign(obj0, ...objs) :\r\n curry2((obj0, ...objs) => objs.reduce((topAgg, obj) => {\r\n return Object.keys(obj).reduce((agg, key) => {\r\n agg[key] = obj[key];\r\n return agg;\r\n }, topAgg);\r\n }, obj0))\r\n )();\r\n","/**\r\n * Created by elyde on 12/18/2016.\r\n * @memberOf object\r\n */\r\nconst _Number = Number.name,\r\n _NaN = 'NaN',\r\n _Null = 'Null',\r\n _Undefined = 'Undefined';\r\n\r\n/**\r\n * Returns the constructor/class/type name of a value.\r\n * @note Returns 'NaN' if value is of type `Number` and value is `isNaN`.\r\n * @note Returns 'Undefined' if value is `undefined`\r\n * @note Returns 'Null' if value is `null`\r\n * For values that have no concrete constructors and/or casters\r\n * (null, NaN, and undefined) we returned normalized names for them ('Null', 'NaN', 'Number')\r\n * @function module:object.typeOf\r\n * @param value {*}\r\n * @returns {string} - Constructor's name or derived name (in the case of `null`, `undefined`, or `NaN` (whose\r\n * normalized names are 'Null', 'Undefined', 'NaN' respectively).\r\n */\r\nexport function typeOf (value) {\r\n let retVal;\r\n if (value === undefined) {\r\n retVal = _Undefined;\r\n }\r\n else if (value === null) {\r\n retVal = _Null;\r\n }\r\n else {\r\n let constructorName = (value).constructor.name;\r\n retVal = constructorName === _Number && isNaN(value) ?\r\n _NaN : constructorName;\r\n }\r\n return retVal;\r\n}\r\n","/**\r\n * Created by elyde on 12/18/2016.\r\n * @memberOf object\r\n */\r\n\r\nimport {typeOf} from './typeOf';\r\nimport {instanceOf, length, keys} from '../jsPlatform/object';\r\nimport {curry} from '../function/curry';\r\n\r\nlet _String = String.name,\r\n _Number = Number.name,\r\n _Object = Object.name,\r\n _Boolean = Boolean.name,\r\n _Function = Function.name,\r\n _Array = Array.name,\r\n _Symbol = 'Symbol',\r\n _Map = 'Map',\r\n _Set = 'Set',\r\n _WeakMap = 'WeakMap',\r\n _WeakSet = 'WeakSet',\r\n _Null = 'Null',\r\n _Undefined = 'Undefined',\r\n _NaN = 'NaN';\r\n\r\nexport const\r\n\r\n /**\r\n * Resolves/normalizes a type name from either a string or a constructor.\r\n * @function module:object.toTypeRef\r\n * @param type {Function|String} - String or function representing a type.\r\n * @returns {String}\r\n * @todo write tests for this function.\r\n */\r\n toTypeRef = type => {\r\n if (!type) {\r\n return typeOf(type);\r\n }\r\n else if (type.constructor === String || (type instanceof Function)) {\r\n return type;\r\n }\r\n return typeOf(type);\r\n },\r\n\r\n /**\r\n * Returns an array of type refs from possible type refs (converts null, undefined, NaN, and other values into\r\n * type refs (either constructor name or constructor name based on whether value(s) is a string, a constructor, or not).\r\n * @function module:object.toTypeRefs\r\n * @param types {...(TypeRef|*)}\r\n * @returns {Array}\r\n * @todo Ensure tests are written for this function.\r\n */\r\n toTypeRefs = (...types) => types.map(toTypeRef),\r\n\r\n /**\r\n * Returns possible Type's TypeRef name.\r\n * @function module:object.toTypeRefName\r\n * @param Type {(TypeRef|*)}\r\n * @returns {String}\r\n * @todo Ensure tests are written for this function.\r\n */\r\n toTypeRefName = Type => {\r\n const ref = toTypeRef(Type);\r\n return ref instanceof Function ? ref.name : ref;\r\n },\r\n\r\n /**\r\n * Returns possible Types' TypeRef names.\r\n * @function module:object.toTypeRefNames\r\n * @param types {...(TypeRef|*)}\r\n * @returns {String[]}\r\n * @todo Ensure tests are written for this function.\r\n */\r\n toTypeRefNames = (...types) => types.map(toTypeRefName),\r\n\r\n /**\r\n * Returns whether a value is a function or not.\r\n * @function module:object.isFunction\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isFunction = instanceOf(Function),\r\n\r\n /**\r\n * Strict type checker. Checks if given value is a direct instance of given type; E.g.,\r\n * @example\r\n * isType(String, 'abcdefg') === true // true\r\n * isType(String.name, 'abcdefg') === true\r\n * isType(Number, NaN) === false\r\n * isType(Number, 99) === true\r\n * isType('Null', 99) === false // though, for `null` and `undefined` checks\r\n * // @see `isset`, in this module, instead\r\n * isType('Undefined', undefined) === true // true\r\n *\r\n * @note Useful where absolute types, or some semblance thereof, are required.\r\n * @function module:object.isType\r\n * @param type {Function|ObjectConstructor|String} - Constructor or constructor name\r\n * @param obj {*}\r\n * @return {Boolean}\r\n */\r\n isType = curry((type, obj) => typeOf(obj) === toTypeRefName(type)),\r\n\r\n /**\r\n * Loose type checker; E.g., If `type` is not a constructor, but a constructor name, does a type check on\r\n * constructor names, else if first check fails and `type` is a constructor, performs an `instanceof` check\r\n * on value with constructor.\r\n * @note Use care when checking for `Array` and/or `Object` since the both are considered objects by `instanceof` checker.\r\n * @note For `null` and `undefined` their class cased names can be used for type checks\r\n * `isOfType('Null', null) === true (passes strict type check)` (or better yet `isset` can be used).\r\n * @throwsafe - Doesn't throw on `null` or `undefined` `obj` values.\r\n * @example\r\n * isOfType(Number, 99) === true // true (passes strict type check (numbers are not instances of `Number`\r\n * // constructor)\r\n * isOfType('Number', 99) === true // true (passes strict type check)\r\n * isOfType(Number, NaN) === true // true. (passes instance of check)\r\n * // If you want \"true\" strict type checking use `isType`\r\n * isOfType(Object, []) === true // true (passes instance of check)\r\n * isOfType(Array, []) === true // true (passes instance of check)\r\n * isOfType(Object, {}) === true // true (passes instance of check)\r\n * isOfType(Object.name, {}) === true // true (Passes strict type check)\r\n * class Abc extends String {}\r\n * isOfType(String, new Abc('abcd')) // true (passes instanceof check)\r\n *\r\n * @function module:object.isOfType\r\n * @param type {Function|String} - Type reference (constructor or `constructor.name`).\r\n * @param x {*} - Value to check.\r\n * @returns {Boolean}\r\n */\r\n isOfType = curry((type, x) => isType(type, x) || instanceOf(type, x)),\r\n\r\n /**\r\n * Checks if `value` is an es2015 `class`.\r\n * @function module:object.isClass\r\n * @param x {*}\r\n * @returns {boolean}\r\n */\r\n isClass = x => x && /^\\s{0,3}class\\s{1,3}/.test((x + '').substr(0, 10)),\r\n\r\n /**\r\n * Returns a boolean depicting whether a value is callable or not.\r\n * @function module:object.isCallable\r\n * @tentative\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isCallable = x => isFunction(x) && !isClass(x),\r\n\r\n /**\r\n * Checks if value is an array (same as `Array.isArray`).\r\n * @function module:object.isArray\r\n * @param value {*}\r\n * @returns {boolean}\r\n */\r\n {isArray} = Array,\r\n\r\n /**\r\n * Checks whether value is an object or not.\r\n * @function module:object.isObject\r\n * @param value\r\n * @returns {Boolean}\r\n */\r\n isObject = isType(_Object),\r\n\r\n /**\r\n * Checks if value is a boolean.\r\n * @function module:object.isBoolean\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isBoolean = isType(_Boolean),\r\n\r\n /**\r\n * Checks if value is a valid number (also checks if isNaN so that you don't have to).\r\n * @function module:object.isNumber\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isNumber = isType(_Number),\r\n\r\n /**\r\n * Checks whether value is a string or not.\r\n * @function module:object.isString\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isString = isType(_String),\r\n\r\n /**\r\n * Checks whether value is of `Map` or not.\r\n * @function module:object.isMap\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isMap = isType(_Map),\r\n\r\n /**\r\n * Checks whether value is of `Set` or not.\r\n * @function module:object.isSet\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isSet = isType(_Set),\r\n\r\n /**\r\n * Checks whether value is of `WeakMap` or not.\r\n * @function module:object.isWeakMap\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isWeakMap =isType(_WeakMap),\r\n\r\n /**\r\n * Checks whether value is of `WeakSet` or not.\r\n * @function module:object.isWeakSet\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isWeakSet = isType(_WeakSet),\r\n\r\n /**\r\n * Checks if value is undefined.\r\n * @function module:object.isUndefined\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isUndefined = isType(_Undefined),\r\n\r\n /**\r\n * Checks if value is null.\r\n * @function module:object.isNull\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isNull = isType(_Null),\r\n\r\n /**\r\n * Checks if value is a `Symbol`.\r\n * @function module:object.isSymbol\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isSymbol = isType(_Symbol),\r\n\r\n /**\r\n * Checks if given `x` is set and of one of\r\n * [String, Boolean, Number, Symbol] (null and undefined are immutable\r\n * but are not \"usable\" (usually not what we want to operate on).\r\n * @function module:object.isUsableImmutablePrimitive\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isUsableImmutablePrimitive = x => {\r\n const typeOfX = typeOf(x);\r\n return isset(x) &&\r\n [_String, _Number, _Boolean, _Symbol]\r\n .some(Type => Type === typeOfX);\r\n },\r\n\r\n /**\r\n * Checks if !length.\r\n * @function module:object.isEmptyList\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isEmptyList = x => !length(x),\r\n\r\n /**\r\n * Checks if object has own properties/enumerable-props or not.\r\n * @function module:object.isEmptyObject\r\n * @param obj {*}\r\n * @returns {Boolean}\r\n */\r\n isEmptyObject = obj => isEmptyList(keys(obj)),\r\n\r\n /**\r\n * Checks if collection is empty or not (Map, WeakMap, WeakSet, Set etc.).\r\n * @function module:object.isEmptyCollection\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isEmptyCollection = x => x.size === 0,\r\n\r\n /**\r\n * Checks to see if passed in value is empty; I.e.,\r\n * check for one of '', 0, `null`, `undefined`, `false`, empty array, empty object, empty function (zero arity),\r\n * or empty collection (es6 Map, Set, WeakMap, or WeakSet etc. (`!value.size`);\r\n * @function module:object.isEmpty\r\n * @param value {*} - Value to check.\r\n * @returns {Boolean}\r\n */\r\n isEmpty = value => {\r\n if (!value) { // if '', 0, `null`, `undefined`, or `false` then is empty\r\n return true;\r\n }\r\n switch (typeOf(value)) {\r\n case _Array:\r\n case _Function:\r\n return !value.length;\r\n case _Number: // zero and NaN checks happened above so `if number` then it's 'not-an-empty-number' (lol)\r\n return false;\r\n case _Object:\r\n return !keys(value).length;\r\n case _Map:\r\n case _Set:\r\n case _WeakSet:\r\n case _WeakMap:\r\n return !value.size;\r\n case _NaN:\r\n return true;\r\n default:\r\n return !value;\r\n }\r\n },\r\n\r\n /**\r\n * Returns whether passed in values is defined and not null or not.\r\n * @function module:object.isset\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isset = x => x !== null && x !== undefined,\r\n\r\n /**\r\n * Checks to see if `x` is of one of the given type refs.\r\n * @function object.isOneOf\r\n * @param x {*}\r\n * @param types {...(TypeRef|*)}\r\n * @returns {boolean}\r\n * @todo write tests for this function.\r\n */\r\n isOneOf = (x, ...types) => {\r\n const typeName = typeOf(x);\r\n return toTypeRefNames(types).some(name => typeName === name);\r\n },\r\n\r\n isFunctor = x => x && x.map && instanceOf(Function, x.map)\r\n\r\n;\r\n","/**\r\n * @memberOf object\r\n */\r\n\r\nimport {isset} from './is';\r\nimport {curry} from '../function/curry';\r\n\r\n/**\r\n * Looks up property and returns it's value; Else `undefined`.\r\n * Method is null safe (will not throw on `null` or `undefined`).\r\n * @function module:object.lookup\r\n * @param key {String} - Key to search on `obj`\r\n * @param obj {Object} - Object to search `name` on.\r\n * @returns {*}\r\n */\r\nexport const lookup = curry((key, obj) => isset(obj) ? obj[key] : undefined);\r\n","import {isFunction, isset, isUsableImmutablePrimitive} from './is';\r\nimport {apply} from '../jsPlatform/function';\r\n\r\n/**\r\n * Creates a value `of` given type; Checks for one of the following construction strategies (in order listed):\r\n * @example\r\n * // - If exists `(value).constructor.of` uses this.\r\n * // - If value is of one String, Boolean, Symbol, or Number types calls it's\r\n * // constructor as a function (in cast form; E.g., `constructor(...args)` )\r\n * // - Else if constructor is a function, thus far, then calls constructor using\r\n * // the `new` keyword (with any passed in args).\r\n\r\n * @function module:object.of\r\n * @param x {*} - Value to derive returned value's type from.\r\n * @param [args] {...*} - Any args to pass in to matched construction strategy.\r\n * @returns {*|undefined} - New value of given value's type else `undefined`.\r\n */\r\nexport const of = (x, ...args) => {\r\n if (!isset(x)) { return undefined; }\r\n const constructor = x.constructor;\r\n if (constructor.hasOwnProperty('of')) {\r\n return apply(constructor.of, args);\r\n }\r\n else if (isUsableImmutablePrimitive(x)) {\r\n return apply(constructor, args);\r\n }\r\n else if (isFunction(constructor)) {\r\n return new constructor(...args);\r\n }\r\n return undefined;\r\n};\r\n","import {typeOf} from './typeOf';\r\nimport {of} from './of';\r\n\r\nexport const\r\n\r\n /**\r\n * Make a copy of a value or optionally copy incoming value onto an outgoing value (second parameter).\r\n * @note If incoming thing is an immmutable primitive (string, number, symbol, null, undefined, boolean)\r\n * it is returned as is.\r\n * @function module:object.copy\r\n * @param x {*} - Thing to copy.\r\n * @param [out = undefined] {*} - Optional value to copy on to. Not required.\r\n * @returns {*} - Copied thing or optionally outgoing value copied onto.\r\n */\r\n copy = (x, out) => {\r\n // if `null`, `undefined`, `''`, `0`, `false` return\r\n if (!x) { return x; }\r\n switch (typeOf(x)) {\r\n case Array.name:\r\n return !out ? x.slice(0) : Object.assign(out, x);\r\n\r\n // If immutable primitive, return it\r\n case Symbol.name:\r\n case Boolean.name:\r\n case String.name:\r\n case Number.name:\r\n case Promise.name:\r\n case Function.name:\r\n case 'NaN':\r\n case 'Null':\r\n case 'Undefined':\r\n return x;\r\n\r\n case 'Map':\r\n case 'Set':\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n return new x.constructor(Array.from(x));\r\n\r\n // Else make copy\r\n default:\r\n return Object.assign(!out ? of(x) : out, x);\r\n }\r\n }\r\n;\r\n\r\nexport default copy;\r\n","import {isset} from './is';\r\nimport {curry} from '../function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Gives you value at key/namespace-key within `obj`; E.g.,\r\n * searchObj('all.your.base', {all: {your: {base: 99}}}) === 99 // `true`\r\n * @note If key is unreachable (undefined) returns `undefined`.\r\n * Useful in cases where we do not want to check each key along the way before getting/checking value; E.g.,\r\n * @example\r\n * ```\r\n * if (obj && obj.all && obj.all.your && obj.all.your.base) {\r\n * // Thing we want to do\r\n * }\r\n *\r\n * // So with our function becomes\r\n * if (searchObj('all.your.base', obj)) {\r\n * // Thing we want to do\r\n * }\r\n * ```\r\n * @function module:object.searchObj\r\n * @param nsString {String}\r\n * @param obj {*}\r\n * @returns {*}\r\n */\r\n searchObj = curry((nsString, obj) => {\r\n if (!obj) { return obj; }\r\n if (nsString.indexOf('.') === -1) {\r\n return obj[nsString];\r\n }\r\n const parts = nsString.split('.'),\r\n limit = parts.length;\r\n let ind = 0,\r\n parent = obj;\r\n for (; ind < limit; ind += 1) {\r\n const node = parent[parts[ind]];\r\n if (!isset(node)) {\r\n return node;\r\n }\r\n parent = node;\r\n }\r\n return parent;\r\n })\r\n;\r\n","\r\nimport {isObject} from './is';\r\nimport {keys} from '../jsPlatform/object';\r\nimport {curry2} from '../function/curry';\r\n\r\nexport const\r\n /**\r\n * Merges all objects down into one (takes two or more args).\r\n * @function module:object.assignDeep\r\n * @param obj0 {Object}\r\n * @param [objs] {...{Object}} - One or more objects to merge onto `obj0`.\r\n * @returns {Object}\r\n */\r\n assignDeep = curry2((obj0, ...objs) =>\r\n !obj0 ? obj0 : objs.reduce((topAgg, obj) =>\r\n !obj ? topAgg : keys(obj).reduce((agg, key) => {\r\n let propDescription = Object.getOwnPropertyDescriptor(agg, key);\r\n // If property is not writable move to next item in collection\r\n if (agg.hasOwnProperty(key) && propDescription &&\r\n !(propDescription.get && propDescription.set) &&\r\n !propDescription.writable) {\r\n return agg;\r\n }\r\n if (isObject(agg[key]) && isObject(obj[key])) {\r\n assignDeep(agg[key], obj[key]);\r\n }\r\n else { agg[key] = obj[key]; }\r\n return agg;\r\n }, topAgg)\r\n , obj0));\r\n","/**\r\n * List operations that overlap (apart from globally overlapping props and functions like `length`)\r\n * on both strings and arrays.\r\n * @memberOf list\r\n */\r\n\r\nimport {fPureTakesOne, fPureTakes2, fPureTakesOneOrMore} from '../utils';\r\n\r\nexport const\r\n\r\n /**\r\n * Concats/appends all functors onto the end of first functor.\r\n * Note: functors passed in after the first one must be of the same type.\r\n * @function module:list.concat\r\n * @param functor {Array|Object|*}\r\n * @param ...functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type passed.\r\n * @throws {Error} - When passed in object doesn't have an `every` method.\r\n */\r\n concat = fPureTakesOneOrMore('concat'),\r\n\r\n /**\r\n * Same as Array.prototype.slice\r\n * @function module:list.slice\r\n * @param separator {String|RegExp}\r\n * @param arr{Array}\r\n * @returns {Array}\r\n */\r\n slice = fPureTakes2('slice'),\r\n\r\n /**\r\n * `Array.prototype.includes` or shim.\r\n * @function module:list.includes\r\n * @param value {*}\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n includes = (() => 'includes' in Array.prototype ?\r\n fPureTakesOne('includes') :\r\n (value, xs) => xs.indexOf(value) > -1)(),\r\n\r\n /**\r\n * Searches list/list-like for given element `x`.\r\n * @function module:list.indexOf\r\n * @param x {*} - Element to search for.\r\n * @param xs {Array|String|*} - list or list like to look in.\r\n * @returns {Number} - `-1` if element not found else index at which it is found.\r\n */\r\n indexOf = fPureTakesOne('indexOf'),\r\n\r\n /**\r\n * Last index of (`Array.prototype.lastIndexOf`).\r\n * @function module:list.lastIndexOf\r\n * @param x {*} - Element to search for.\r\n * @param xs {Array|String|*} - list or list like to look in.\r\n * @returns {Number} - `-1` if element not found else index at which it is found.\r\n */\r\n lastIndexOf = fPureTakesOne('lastIndexOf')\r\n\r\n;\r\n","/**\r\n * @module boolean\r\n * @description Contains functional version of 'always-true', 'always-false', 'is-truthy', and 'is-falsy'.\r\n */\r\nimport {curry, curry2} from './function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns whether `value` is 'truthy' or not\r\n * @function module:boolean.isTruthy\r\n * @param value\r\n * @returns {Boolean}\r\n */\r\n isTruthy = value => !!value,\r\n\r\n /**\r\n * Returns whether `value` is 'falsy' or not\r\n * @function module:boolean.isFalsy\r\n * @param value\r\n * @returns {Boolean}\r\n */\r\n isFalsy = value => !value,\r\n\r\n /**\r\n * Returns `true`.\r\n * @function module:boolean.alwaysTrue\r\n * @returns {Boolean}\r\n */\r\n alwaysTrue = () => true,\r\n\r\n /**\r\n * Returns `false`.\r\n * @function module:boolean.alwaysFalse\r\n * @returns {Boolean}\r\n */\r\n alwaysFalse = () => false,\r\n\r\n /**\r\n * Equality operator.\r\n * @function module:boolean.equal\r\n * @param a {*}\r\n * @param b {*}\r\n * @returns {boolean}\r\n */\r\n equal = curry((a, b) => a === b),\r\n\r\n /**\r\n * Equality operator for all.\r\n * @function module:boolean.equalAll\r\n * @param a {*} - Item `0`.\r\n * @param args {...*} - Others\r\n * @returns {boolean}\r\n */\r\n equalAll = curry2((a, ...args) => args.every(b => equal(a, b)))\r\n\r\n;\r\n","import {length} from '../jsPlatform/object';\r\nimport {curry} from '../function/curry';\r\nimport {typeOf} from '../object/typeOf';\r\nimport {of} from '../object/of';\r\nimport {isFunctor, isset} from '../object/is';\r\n\r\n/**\r\n * Maps a function onto a List (string or array) or a functor (value containing a map method).\r\n * @function module:list.map\r\n * @param fn {Function} - Function to map on given value.\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\nconst map = curry((fn, xs) => {\r\n if (!isset(xs)) { return xs; }\r\n let out = of(xs),\r\n limit,\r\n i = 0;\r\n switch (typeOf(xs)) {\r\n case 'Array':\r\n limit = length(xs);\r\n if (!limit) { return out; }\r\n for (; i < limit; i += 1) {\r\n out.push(fn(xs[i], i, xs));\r\n }\r\n return out;\r\n case 'String':\r\n limit = length(xs);\r\n if (!xs) { return out; }\r\n for (; i < limit; i += 1) {\r\n out += fn(xs[i], i, xs);\r\n }\r\n return out;\r\n default:\r\n if (isFunctor(xs)) { return xs.map(fn); }\r\n\r\n // Other objects\r\n return Object.keys(xs).reduce((agg, key) => {\r\n out[key] = fn(xs[key], key, xs);\r\n return out;\r\n }, out);\r\n }\r\n});\r\n\r\nexport default map;\r\n","\r\nexport const\r\n\r\n /**\r\n * Pushes incoming `item` onto given array and returns said array.\r\n * @private\r\n * @param agg {Array}\r\n * @param item {*}\r\n * @returns {Array}\r\n */\r\n aggregateArray = (agg, item) => {\r\n agg.push(item);\r\n return agg;\r\n }\r\n\r\n;\r\n","/**\r\n * List operator utils module.\r\n * @module listUtils\r\n */\r\nimport {apply} from '../jsPlatform/function'; // un-curried version\r\nimport {slice} from '../jsPlatform/list'; // un-curried version good for both strings and arrays\r\nimport {length} from '../jsPlatform/object';\r\nimport {alwaysFalse} from '../boolean';\r\nimport map from './map';\r\nimport {curry, curry2} from '../function/curry';\r\n\r\nexport * from './aggregation';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a slice of the given list from `startInd` to the end of the list.\r\n * @function module:listUtils.sliceFrom\r\n * @param startInd {Number}\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sliceFrom = curry((startInd, xs) => slice(startInd, undefined, xs)),\r\n\r\n /**\r\n * Slices from index `0` to given index.\r\n * @function module:listUtils.sliceTo\r\n * @param toInd {Number}\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sliceTo = curry((toInd, xs) => slice(0, toInd, xs)),\r\n\r\n /**\r\n * Slices a copy of list.\r\n * @function listUtils.sliceCopy\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sliceCopy = sliceFrom(0),\r\n\r\n /**\r\n * Generic 'ascending order' ordering function (use by the likes of `list.sort` etc.)\r\n * @function module:listUtils.genericAscOrdering\r\n * @param a {*}\r\n * @param b {*}\r\n * @returns {number}\r\n */\r\n genericAscOrdering = curry((a, b) => {\r\n if (a > b) { return 1; }\r\n else if (a < b) { return -1; }\r\n return 0;\r\n }),\r\n\r\n /**\r\n * Returns length of all passed lists in list.\r\n * @function module:listUtils.lengths\r\n * @param lists ...{Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n lengths = curry2((...lists) => map(length, lists)),\r\n\r\n /**\r\n * Returns a list of lists trimmed to the shortest length in given list of lists. @background This method is used by the `zip*` functions to achieve their\r\n * 'slice to smallest' functionality.\r\n * @function module:listUtils.toShortest\r\n * @param lists {...(Array|String|*)}\r\n * @returns {Array|String|*}\r\n */\r\n toShortest = curry2((...lists) => {\r\n const listLengths = apply(lengths, lists),\r\n smallLen = Math.min.apply(Math, listLengths);\r\n return map((list, ind) => listLengths[ind] > smallLen ?\r\n sliceTo(smallLen, list) : sliceCopy(list), lists);\r\n }),\r\n\r\n /**\r\n * Reduces until predicate.\r\n * @function module:listUtils.reduceUntil\r\n * @param pred {Function} - `(item, index, list) => Boolean(...)`\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduceUntil = curry((pred, op, agg, xs) => {\r\n const limit = length(xs);\r\n if (!limit) { return agg; }\r\n let ind = 0,\r\n result = agg;\r\n for (; ind < limit; ind++) {\r\n if (pred(xs[ind], ind, xs)) { break; }\r\n result = op(result, xs[ind], ind, xs);\r\n }\r\n return result;\r\n }),\r\n\r\n /**\r\n * Reduces until predicate (from right to left).\r\n * @function module:listUtils.reduceUntilRight\r\n * @param pred {Function} - `(item, index, list) => Boolean(...)`\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduceUntilRight = curry((pred, op, agg, arr) => {\r\n const limit = length(arr);\r\n if (!limit) { return agg; }\r\n let ind = limit - 1,\r\n result = agg;\r\n for (; ind >= 0; ind--) {\r\n if (pred(arr[ind], ind, arr)) { break; }\r\n result = op(result, arr[ind], ind, arr);\r\n }\r\n return result;\r\n }),\r\n\r\n /**\r\n * Reduces a list with given operation (`op`) function.\r\n * @function module:listUtils.reduce\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduce = reduceUntil(alwaysFalse),\r\n\r\n /**\r\n * Reduces a list with given operation (`op`) function (from right-to-left).\r\n * @function module:listUtils.reduceRight\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduceRight = reduceUntilRight(alwaysFalse),\r\n\r\n /**\r\n * Gets last index of a list/list-like (Array|String|Function etc.).\r\n * @function module:listUtils.lastIndex\r\n * @param x {Array|String|*} - list like or list.\r\n * @returns {Number} - `-1` if no element found.\r\n */\r\n lastIndex = x => { const len = length(x); return len ? len - 1 : 0; },\r\n\r\n /**\r\n * Finds index in string or list.\r\n * @function module:listUtils.findIndexWhere\r\n * @param pred {Function} - Predicate.\r\n * @param arr {Array|String}\r\n * @returns {Number} - `-1` if predicate not matched else `index` found\r\n */\r\n findIndexWhere = curry((pred, arr) => {\r\n let ind = 0;\r\n const limit = length(arr);\r\n for (; ind < limit; ind += 1) {\r\n const predicateFulfilled = !!pred(arr[ind], ind, arr);\r\n if (predicateFulfilled) {\r\n return ind;\r\n }\r\n }\r\n return -1;\r\n }),\r\n\r\n /**\r\n * Finds index in list from right to left.\r\n * @function module:listUtils.findIndexWhereRight\r\n * @param pred {Function} - Predicate.\r\n * @param arr {Array|String}\r\n * @returns {Number} - `-1` if predicate not matched else `index` found\r\n */\r\n findIndexWhereRight = curry((pred, arr) => {\r\n let ind = length(arr) - 1;\r\n for (; ind >= 0; ind -= 1) {\r\n const predicateFulfilled = !!pred(arr[ind], ind, arr);\r\n if (predicateFulfilled) {\r\n return ind;\r\n }\r\n }\r\n return -1;\r\n }),\r\n\r\n /**\r\n * @function module:listUtils.findIndicesWhere\r\n * @param pred {Function}\r\n * @param xs {Array|String|*} - list or list like.\r\n * @returns {Array|undefined}\r\n */\r\n findIndicesWhere = curry((pred, xs) => {\r\n const limit = length(xs);\r\n let ind = 0,\r\n out = [];\r\n for (; ind < limit; ind++) {\r\n if (pred(xs[ind], ind, xs)) { out.push(ind); }\r\n }\r\n return out.length ? out : undefined;\r\n }),\r\n\r\n /**\r\n * @function module:listUtils.findWhere\r\n * @param pred {Function}\r\n * @param xs {Array|String|*} - list or list like.\r\n * @returns {*}\r\n */\r\n findWhere = curry((pred, xs) => {\r\n let ind = 0,\r\n limit = length(xs);\r\n if (!limit) { return; }\r\n for (; ind < limit; ind++) {\r\n let elm = xs[ind];\r\n if (pred(elm, ind, xs)) { return elm; }\r\n }\r\n })\r\n\r\n;\r\n","import {assignDeep} from './assignDeep';\r\nimport {keys} from '../jsPlatform/object';\r\nimport {reduce} from '../list/utils';\r\nimport {curry, curry2} from '../function/curry';\r\n\r\nexport const\r\n\r\n objUnion = curry((obj1, obj2) => assignDeep(obj1, obj2)),\r\n\r\n objIntersect = curry((obj1, obj2) => reduce((agg, key) => {\r\n if (obj2.hasOwnProperty(key)) {\r\n agg[key] = obj2[key];\r\n }\r\n return agg;\r\n }, {}, keys(obj1))),\r\n\r\n objDifference = curry((obj1, obj2) => reduce((agg, key) => {\r\n if (!obj2.hasOwnProperty(key)) {\r\n agg[key] = obj1[key];\r\n }\r\n return agg;\r\n }, {}, keys(obj1))),\r\n\r\n objComplement = curry2((obj0, ...objs) => reduce((agg, obj) =>\r\n assignDeep(agg, objDifference(obj, obj0)), {}, objs));\r\n","/**\r\n * @module console\r\n * @description Console exports.\r\n */\r\nexport const\r\n\r\n /**\r\n * `Console.log` method.\r\n * @function module:console.log\r\n * @params args {...*}\r\n * @returns {void}\r\n */\r\n log = console.log.bind(console),\r\n\r\n /**\r\n * `Console.error` method.\r\n * @function module:console.error\r\n * @params args {...*}\r\n * @returns {void}\r\n */\r\n error = console.error.bind(console),\r\n\r\n /**\r\n * Peeks (console.log) at incoming value(s) and returns the last value.\r\n * @function module:console.peek\r\n * @param args {...*}\r\n * @returns {*} Last given value (if one or more values) else first value.\r\n */\r\n peek = (...args) => (log(...args), args.pop())\r\n\r\n;\r\n","export const\r\n\r\n /**\r\n * Clones and object or array using `JSON.parse(JSON.stringify(...))` pattern.\r\n * @function module:object.jsonClone\r\n * @param x {*}\r\n * @returns {*}\r\n */\r\n jsonClone = x => JSON.parse(JSON.stringify(x))\r\n\r\n;\r\n","import {isArray, isType} from './is';\r\nimport {keys} from '../jsPlatform/object';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns an associated list from given object.\r\n * @note Useful for working with plain javascript objects.\r\n * @function module:object.toAssocList\r\n * @param obj {(Object|Array|*)}\r\n * @returns {Array.<*, *>}\r\n */\r\n toAssocList = obj => keys(obj).map(key => [key, obj[key]]),\r\n\r\n /**\r\n * Returns an associated list from given object (deeply (on incoming object's type)).\r\n * @note Does deep conversion on all values of passed in type's type.\r\n * @function module:object.toAssocListDeep\r\n * @param obj {*}\r\n * @param [TypeConstraint = Object] {(Constructor|Function)} - Type constraint to convert on.\r\n * @returns {*}\r\n */\r\n toAssocListDeep = (obj, TypeConstraint = Object) => keys(obj).map(key =>\r\n TypeConstraint && isType(TypeConstraint, obj[key]) ?\r\n [key, toAssocListDeep(obj[key], TypeConstraint)] :\r\n [key, obj[key]]\r\n ),\r\n\r\n /**\r\n * From associated list to object.\r\n * @function module:object.fromAssocList\r\n * @param xs {Array.} - Associated list.\r\n * @param [OutType = Object] {Constructor|Function} - Output type. Default `Object`.\r\n * @returns {*} - Default is `Object`\r\n */\r\n fromAssocList = (xs, OutType = Object) => xs.reduce((agg, [key, value]) => {\r\n agg[key] = value;\r\n return agg;\r\n }, new OutType()),\r\n\r\n /**\r\n * From associated list to object (deep conversion on associative lists (array of 2 value arrays)).\r\n * @note Considers array of arrays associated lists.\r\n * @function module:object.fromAssocListDeep\r\n * @param xs {Array.} - Associated list.\r\n * @param [OutType = Object] {Constructor|Function} - Output type. Default `Object`.\r\n * @returns {*} - Default is `Object`\r\n */\r\n fromAssocListDeep = (xs, OutType = Object) => xs.reduce((agg, [key, value]) => {\r\n if (isArray(value) && isArray(value[0]) && value[0].length === 2) {\r\n agg[key] = fromAssocListDeep(value, OutType);\r\n return agg;\r\n }\r\n agg[key] = value;\r\n return agg;\r\n }, new OutType())\r\n;\r\n","import {typeOf} from './typeOf';\r\nimport {toAssocList} from './assocList';\r\n\r\nexport const\r\n\r\n /**\r\n * Converts incoming value to an array.\r\n * @note For `WeakMap`, `WeakSet`, `Map` and `Set` result is the same as calling `Array.from` on such.\r\n * @note For `null`, `undefined`, `NaN`, `Number{}`, `Symbol{}`, `Boolean{}` returns an empty array.\r\n * @note Method does a shallow conversion;\r\n * @function module:object.toArray\r\n * @param x {*} - Thing to convert from.\r\n * @returns {Array}\r\n */\r\n toArray = x => {\r\n switch (typeOf(x)) {\r\n case 'Null':\r\n case 'Undefined':\r\n return [];\r\n case String.name:\r\n case Array.name:\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n case 'Map':\r\n case 'Set':\r\n return Array.from(x);\r\n case Object.name:\r\n default:\r\n return toAssocList(x);\r\n }\r\n }\r\n\r\n;\r\n","/**\r\n * @module object\r\n * @description Object operations/combinators.\r\n */\r\n\r\nexport * from './jsPlatform/object';\r\nexport * from './object/lookup';\r\nexport * from './object/typeOf';\r\nexport * from './object/copy';\r\nexport * from './object/is';\r\nexport * from './object/of';\r\nexport * from './object/searchObj';\r\nexport * from './object/assignDeep';\r\nexport * from './object/setTheory';\r\nexport * from './object/console';\r\nexport * from './object/jsonClone';\r\nexport * from './object/toArray';\r\nexport * from './object/assocList';\r\n","import {reduceRight} from '../jsPlatform/array';\r\n\r\n/**\r\n * Composes all functions passed in from right to left passing each functions return value to\r\n * the function on the left of itself.\r\n * @function module:function.compose\r\n * @type {Function}\r\n * @param args {...{Function}}\r\n * @returns {Function}\r\n */\r\nexport const compose = (...args) =>\r\n arg0 => reduceRight((value, fn) => fn(value), arg0, args);\r\n","/**\r\n * @memberOf function\r\n */\r\n\r\n/**\r\n * Returns passed in parameter.\r\n * @haskellType `id :: a -> a`\r\n * @function module:function.id\r\n * @param x {*}\r\n * @returns {*}\r\n */\r\nexport const id = x => x;\r\n","/**\r\n * @memberOf function\r\n */\r\n\r\nimport {apply} from '../jsPlatform/function';\r\nimport {curry, curry2} from './curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Negates a function that takes one/no argument.\r\n * @function module:function.negateF\r\n * @param fn {Function}\r\n * @returns {function(*=): boolean}\r\n */\r\n negateF = fn => x => !fn(x),\r\n\r\n /**\r\n * Takes a function that takes two parameters and returns a negated version of given\r\n * function.\r\n * @function module:_negate.negateF2\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n negateF2 = fn => curry((a, b) => !fn(a, b)),\r\n\r\n /**\r\n * Takes a function that takes three parameters and returns a\r\n * negated version of given function.\r\n * @function module:_negate.negateF3\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n negateF3 = fn => curry((a, b, c) => !fn(a, b, c)),\r\n\r\n /**\r\n * Returns a negated version of given function.\r\n * Returned function is variadiac (takes one or more arguments).\r\n * @note function returned is uncurried.\r\n * @uncurried\r\n * @function module:function.negateFN\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n negateFN = fn => curry2((...args) => !apply(fn, args));\r\n","import {curry} from './curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Run `operation` until predicate returns `true` (like a functional\r\n * version of a while loop).\r\n * @function module:function.until\r\n * @param predicate {Function} :: a -> Boolean\r\n * @param operation {Function} :: a -> a\r\n * @param typeInstance {*} :: * - A monoidal zero or some starting point.\r\n * @returns {*} - What ever type `typeInstance` is\r\n */\r\n until = curry((predicate, operation, typeInstance) => {\r\n let result = typeInstance;\r\n while (!predicate(result)) {\r\n result = operation(result);\r\n }\r\n return result;\r\n });\r\n","import {typeOf} from '../object/typeOf';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a function or throws an error if given `f` is not a function.\r\n * @function module:function.fnOrError\r\n * @param symbolName {String} - Error message prefix.\r\n * @param f {Function|*} - Expected function.\r\n * @returns {Function}\r\n * @throws {Error} - Error if `f` is not of `function`\r\n */\r\n fnOrError = (symbolName, f) => {\r\n if (!f || !(f instanceof Function)) {\r\n throw new Error(`${symbolName} should be a function. ` +\r\n `Type received: ${typeOf(f)}; Value received: ${f}.`);\r\n }\r\n return f;\r\n }\r\n\r\n;\r\n","/**\r\n * No-op ('op' as in 'operation') - Performs no operation 'always' (good for places where\r\n * a value should always be a function etc.).\r\n * @function module:function.noop\r\n * @returns {undefined}\r\n */\r\nexport const noop = () => undefined;\r\n","/**\r\n * @module function\r\n */\r\nexport * from './jsPlatform/function';\r\nexport * from './function/compose';\r\nexport * from './function/curry';\r\nexport * from './function/flip';\r\nexport * from './function/id';\r\nexport * from './function/negate';\r\nexport * from './function/until';\r\nexport * from './function/fnOrError';\r\nexport * from './function/noop';\r\n","/**\r\n * @module object\r\n */\r\nimport {curry} from '../function/curry';\r\n\r\n/**\r\n * Normalizes step for `from` and `to` combination.\r\n * @function module:list.normalizeStep\r\n * @param from {Number}\r\n * @param to {Number}\r\n * @param [step = 1] {Number}\r\n * @returns {Number}\r\n * @private\r\n */\r\nconst normalizeStep = (from, to, step) => {\r\n if (from > to) {\r\n return step > 0 ? -step : step; // make step negative\r\n }\r\n return step < 0 ? -1 * step : step; // make step positive\r\n};\r\n\r\nexport const\r\n\r\n /**\r\n * Range function - gives you an array contain numbers in given range.\r\n * @note normalizes `step` to be valid if range numbers given are invalid\r\n * (forces `step` to be negative if range required is in the negative direction\r\n * and forces `step` to be positive if range required is in the other direction).\r\n * @function module:list.range\r\n * @param from {Number}\r\n * @param to {Number}\r\n * @param [step = 1] {Number}\r\n * @returns {Array.}\r\n */\r\n range = curry((from, to, step = 1) => {\r\n let i = from;\r\n const out = [];\r\n step = normalizeStep(from, to, step);\r\n if (step === 0 || from === to) { return [from]; }\r\n for (; (to - i) * step >= 0; i += step) { out.push(i); }\r\n return out;\r\n })\r\n;\r\n","/**\r\n * Created by elydelacruz on 9/6/2017.\r\n */\r\n\r\nimport {fPureTakesOne} from '../utils';\r\n\r\n/**\r\n * Functional version of `String.prototype.split`.\r\n * @function module:_string.split\r\n * @param separator {String|RegExp}\r\n * @param str {String}\r\n * @returns {Array}\r\n */\r\nexport const split = fPureTakesOne('split');\r\n","/**\r\n * @module jsPlatform_\r\n * @private\r\n */\r\nexport * from './jsPlatform/object';\r\nexport * from './jsPlatform/array';\r\nexport * from './jsPlatform/list';\r\nexport * from './jsPlatform/string';\r\nexport * from './jsPlatform/function';\r\n","/**\r\n * List operations module.\r\n * @module list\r\n */\r\nimport {concat as listAppend, indexOf, slice, includes} from './jsPlatform/list';\r\nimport {apply} from './jsPlatform/function';\r\nimport {length} from './jsPlatform/object';\r\nimport {negateF3, negateF2} from './function/negate';\r\nimport {curry, curry2, curry3} from './function/curry';\r\nimport {isTruthy, isFalsy} from './boolean';\r\nimport {lookup} from './object/lookup';\r\nimport {of} from './object/of';\r\nimport {isset, isString} from './object/is';\r\nimport {typeOf} from './object/typeOf';\r\nimport map from './list/map';\r\n\r\nimport {\r\n sliceFrom, sliceTo, lengths,\r\n toShortest, aggregateArray,\r\n reduceUntil, reduce, reduceRight, lastIndex,\r\n findIndexWhere, findIndexWhereRight, findIndicesWhere,\r\n findWhere, sliceCopy, genericAscOrdering\r\n}\r\n from './list/utils';\r\n\r\nexport * from './list/range';\r\n\r\nexport * from './list/utils';\r\n\r\nexport {map};\r\n\r\nexport {slice, includes, indexOf, lastIndexOf, push} from './jsPlatform';\r\n\r\nexport const\r\n\r\n /**\r\n * Append two, or more, lists, i.e.,\r\n * @example\r\n * expectEqual(append(take(13, alphabetString), drop(13, alphabetString)), alphabetString); // true\r\n *\r\n * // Another example\r\n * const result = append(\r\n * alphabetStr.split(''),\r\n * alphabetStr.split('')\r\n * ),\r\n * expected = repeat(2, alphabetStr).split('');\r\n *\r\n * shallowEquals(result, expected) === true // `true`\r\n *\r\n * @function module:list.append\r\n * @param [args] {...(Array|String|*)} - One or more lists or list likes (strings etc.).\r\n * @returns {(Array|String|*)} - Same type as list like passed in.\r\n */\r\n append = curry2((...args) => apply(listAppend, args)),\r\n\r\n /**\r\n * Returns head of list (first item of list).\r\n * @haskellType `head :: [a] -> a`\r\n * @function module:list.head\r\n * @param x {Array|String}\r\n * @returns {*} - First item from list\r\n */\r\n head = x => x[0],\r\n\r\n /**\r\n * Returns last item of list.\r\n * @haskellType `last :: [a] -> a`\r\n * @function module:list.last\r\n * @param xs {Array|String}\r\n * @returns {*}\r\n */\r\n last = xs => xs[lastIndex(xs)],\r\n\r\n /**\r\n * Returns tail part of list (everything after the first item as new list).\r\n * @haskelType `tail :: [a] -> [a]`\r\n * @function module:list.tail\r\n * @param xs {Array|String}\r\n * @returns {Array|String}\r\n */\r\n tail = xs => sliceFrom(1, xs),\r\n\r\n /**\r\n * Returns everything except last item of list as new list.\r\n * @haskellType `init :: [a] -> [a]`\r\n * @function module:list.init\r\n * @param xs {Array|String}\r\n * @returns {Array|String}\r\n */\r\n init = xs => sliceTo(lastIndex(xs), xs),\r\n\r\n /**\r\n * Returns `head` and `tail` of passed in list/string in a tuple.\r\n * @haskellType `uncons :: [a] -> Maybe (a, [a])`\r\n * @function module:list.uncons\r\n * @param xs {Array|String}\r\n * @returns {Array|undefined}\r\n */\r\n uncons = xs => !xs || length(xs) === 0 ? undefined : [head(xs), tail(xs)],\r\n\r\n /**\r\n * Returns `tail` and `head` of passed in list/string in a tuple.\r\n * @haskellType `unconsr :: [a] -> Maybe ([a], a)`\r\n * @function module:list.unconsr\r\n * @param xs {Array|String}\r\n * @returns {Array|String|*|undefined}\r\n */\r\n unconsr = xs => !xs || length(xs) === 0 ? undefined : [init(xs), last(xs)],\r\n\r\n /**\r\n * Concatenates all the elements of a container of lists.\r\n * @haskellType `concat :: Foldable t => t [a] -> [a]`\r\n * @function module:list.concat\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n concat = xs => {\r\n switch (length(xs)) {\r\n case undefined:\r\n case 0:\r\n return [];\r\n case 1:\r\n const item0 = xs[0];\r\n return item0 && item0.slice ? sliceCopy(item0) : item0;\r\n case 2:\r\n default:\r\n return apply(append, xs);\r\n }\r\n },\r\n\r\n /**\r\n * Map a function over all the elements of a container and concatenate the resulting lists.\r\n * @haskellType `concatMap :: Foldable t => (a -> [b]) -> t a -> [b]`\r\n * @function module:list.concatMap\r\n * @param fn {Function}\r\n * @param foldableOfA {Array}\r\n * @returns {Array}\r\n */\r\n concatMap = curry((fn, foldableOfA) => concat(map(fn, foldableOfA))),\r\n\r\n /**\r\n * Returns a copy of the passed in list reverses.\r\n * @haskellType `reverse :: [a] -> [a]`\r\n * @function module:list.reverse\r\n * @param xs {Array|String}\r\n * @returns {Array|String}\r\n */\r\n reverse = xs => {\r\n if (!isset(xs) || !xs.length) {\r\n return xs;\r\n }\r\n let out = of(xs),\r\n i = xs.length - 1;\r\n switch (typeOf(xs)) {\r\n case 'String':\r\n for (; i >= 0; i -= 1) {\r\n out += xs[i];\r\n }\r\n return out;\r\n default:\r\n for (; i >= 0; i -= 1) {\r\n out.push(xs[i]);\r\n }\r\n return out;\r\n }\r\n },\r\n\r\n /**\r\n * Takes an element and a list and `intersperses' that element between the\r\n * elements of the list.\r\n * @function module:list.intersperse\r\n * @note In our version of the function javascript is loosely typed so,\r\n * so is our function (to much overhead to make it typed) so `between` can be any value.\r\n * @param between {*} - Should be of the same type of elements contained in list.\r\n * @param arr {Array|String} - List.\r\n * @returns {Array|String}\r\n */\r\n intersperse = curry((between, xs) => {\r\n if (!xs || !xs.length) {\r\n return xs;\r\n }\r\n const limit = xs.length,\r\n lastInd = limit - 1;\r\n let out = of(xs),\r\n i = 0;\r\n if (isString(xs)) {\r\n for (; i < limit; i += 1) {\r\n out += i === lastInd ?\r\n xs[i] : xs[i] + between;\r\n }\r\n return out;\r\n }\r\n for (; i < limit; i += 1) {\r\n if (i === lastInd) {\r\n out.push(xs[i]);\r\n } else {\r\n out.push(xs[i], between);\r\n }\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * `intercalate xs xss` is equivalent to (concat (intersperse xs xss)). It inserts the list xs in between the lists in xss and concatenates the result.\r\n * @haskellType `intercalate :: [a] -> [[a]] -> [a]`\r\n * @function module:list.intercalate\r\n * @param xs {Array|String}\r\n * @param xss {Array|String}\r\n * @returns {Array|String}\r\n */\r\n intercalate = curry((xs, xss) => {\r\n if (isString(xss)) {\r\n return intersperse(xs, xss);\r\n }\r\n return concat(intersperse(xs, xss));\r\n }),\r\n\r\n /**\r\n * Transposes rows and columns into lists by index; E.g.,\r\n * Haskell example:\r\n * ```\r\n * transpose [[1,2,3],[4,5,6]] == [[1,4],[2,5],[3,6]]\r\n *\r\n * -- Notice the shorter arrays are ignored after their last index is copied over:\r\n * transpose [[10,11],[20],[],[30,31,32]] == [[10,20,30],[11,31],[32]]\r\n * ```\r\n * @note from columns to rows.\r\n * @note Empty lists are ignored.\r\n * @haskellType `transpose :: [[a]] -> [[a]]`\r\n * @function module:list.transpose\r\n * @param xss {Array}\r\n * @returns {Array}\r\n */\r\n transpose = xss => {\r\n let numLists = length(xss),\r\n ind = 0, ind2;\r\n if (!numLists) {\r\n return [];\r\n }\r\n const listLengths = apply(lengths, xss),\r\n longestListLen = maximum(listLengths),\r\n outLists = [];\r\n for (; ind < longestListLen; ind += 1) {\r\n const outList = [];\r\n for (ind2 = 0; ind2 < numLists; ind2 += 1) {\r\n if (listLengths[ind2] < ind + 1) {\r\n continue;\r\n }\r\n outList.push(xss[ind2][ind]);\r\n }\r\n outLists.push(outList);\r\n }\r\n return filter(x => length(x) > 0, outLists);\r\n },\r\n\r\n /**\r\n * Generates 2^n sub-sequences for passed in sequence (string/list) (`n` is\r\n * the length of the passed in sequence so: 2^length(xs)).\r\n * Note: The return value doubles per index/character passed in so use with caution!\r\n * Also note that for 2^16 (or for a sequence of 16 characters) this algorithm\r\n * will generate 65536 sub-sequences! So caution should be taken to not\r\n * use this with sequences above a certain length on certain platform (the browser thread in specific).\r\n * @function module:list.subsequences\r\n * @jsperftest https://jsperf.com/subsequences\r\n * @param xs {Array|String}\r\n * @returns {Array.}\r\n */\r\n subsequences = xs => {\r\n const listLen = length(xs),\r\n len = Math.pow(2, listLen),\r\n out = [];\r\n for (let i = 0; i < len; i += 1) {\r\n let entry = [];\r\n for (let j = 0; j < listLen; j += 1) {\r\n if (i & (1 << j)) {\r\n entry.push(xs[j]);\r\n }\r\n }\r\n out.push(entry);\r\n }\r\n return out;\r\n },\r\n\r\n /**\r\n * Returns an array with the given indices swapped.\r\n * @function module:list.swapped\r\n * @param ind1 {Number}\r\n * @param ind2 {Number}\r\n * @param list {Array}\r\n * @returns {Array} - Copy of incoming with swapped values at indices.\r\n */\r\n swapped = curry((ind1, ind2, list) => {\r\n const out = sliceCopy(list),\r\n tmp = out[ind1];\r\n out[ind1] = out[ind2];\r\n out[ind2] = tmp;\r\n return out;\r\n }),\r\n\r\n /**\r\n * Returns a list of permutations for passed in list.\r\n * Use caution with lists above a length of 15 (will take long due to nature of\r\n * algorithm).\r\n * @function module:list.permutations\r\n * @param xs {Array} - List.\r\n * @returns {Array} - Array of permutations.\r\n */\r\n permutations = xs => {\r\n const limit = length(xs);\r\n\r\n if (!limit || limit === 1) {\r\n return [xs];\r\n }\r\n\r\n let list = sliceCopy(xs),\r\n c = repeat(limit, 0),\r\n i = 0;\r\n\r\n const out = [list];\r\n\r\n for (; i < limit; i++) {\r\n if (c[i] < i) {\r\n list = swapped(i % 2 === 0 ? 0 : c[i], i, list);\r\n out.push(list);\r\n c[i] += 1;\r\n i = 0;\r\n continue;\r\n }\r\n c[i] = 0;\r\n }\r\n\r\n return out;\r\n },\r\n\r\n /**\r\n * Left associative fold. Reduces a container of elements down by the given operation (same as [].reduce).\r\n * @function module:list.foldl\r\n * @param fn {Function}\r\n * @param zero {*} - Aggregator.\r\n * @param functor {Array}\r\n * @returns {*} - Whatever type is lastly returned from `fn`.\r\n */\r\n foldl = reduce,\r\n\r\n /**\r\n * Right associative fold. Reduces a container of elements down by the given operation (same as [].reduceRight).\r\n * @function module:list.foldr\r\n * @param fn {Function}\r\n * @param zero {*} - Aggregator.\r\n * @param functor {Array}\r\n * @returns {*} - Whatever type is lastly returned from `fn`.\r\n */\r\n foldr = reduceRight,\r\n\r\n /**\r\n * A variant of `foldl` except that this one doesn't require the starting point. The starting point/value will be pulled\r\n * out from a copy of the container.\r\n * @function module:list.foldl1\r\n * @param op {Function}\r\n * @param xs {Array}\r\n * @returns {*} - Whatever type is lastly returned from `op`.\r\n */\r\n foldl1 = curry((op, xs) => {\r\n const parts = uncons(xs);\r\n return !parts ? [] : reduce(op, parts[0], parts[1]);\r\n }),\r\n\r\n /**\r\n * A variant of `foldr` except that this one doesn't require the starting point/value. The starting point/value will be pulled\r\n * out from a copy of the container.\r\n * @function module:list.foldr1\r\n * @param op {Function}\r\n * @param xs {Array}\r\n * @returns {*} - Whatever type is lastly returned from `op`.\r\n */\r\n foldr1 = curry((op, xs) => {\r\n const parts = unconsr(xs);\r\n return !parts ? [] : reduceRight(op, parts[1], parts[0]);\r\n }),\r\n\r\n /**\r\n * Performs a map then a reduce all in one (from left-to-right). Returns a tuple\r\n * containing the aggregated value and the result of mapping the passed in function on passed in list.\r\n * @function module:list.mapAccumL\r\n * @param op {Function} - Function : [aggregated, mapResult]\r\n * @param zero {*} - An instance of the passed in list type used to aggregateArray on.\r\n * @param xs {Array} - list type.\r\n * @return {Array} - [aggregated, list]\r\n */\r\n mapAccumL = curry((op, zero, xs) => {\r\n const list = sliceCopy(xs),\r\n limit = length(xs);\r\n if (!limit) {\r\n return [zero, list];\r\n }\r\n let ind = 0,\r\n agg = zero,\r\n mapped = [],\r\n tuple;\r\n for (; ind < limit; ind++) {\r\n tuple = op(agg, list[ind], ind);\r\n agg = tuple[0];\r\n mapped = tuple[1];\r\n }\r\n return [agg, mapped];\r\n }),\r\n\r\n /**\r\n * Performs a map and a reduce all in one (from right-to-left). Returns a tuple\r\n * containing the aggregated value and the result of mapping the passed in function on passed in list.\r\n * @function module:list.mapAccumR\r\n * @param op {Function} - Function : [aggregated, mapResult]\r\n * @param zero {*} - An instance of the passed in list type used to aggregateArray on.\r\n * @param xs {Array} - list type.\r\n * @return {Array} - [aggregated, list]\r\n */\r\n mapAccumR = curry((op, zero, xs) => {\r\n const list = sliceCopy(xs),\r\n limit = length(xs);\r\n if (!limit) {\r\n return [zero, list];\r\n }\r\n let ind = limit - 1,\r\n agg = zero,\r\n mapped = [],\r\n tuple;\r\n for (; ind >= 0; ind--) {\r\n tuple = op(agg, list[ind], ind);\r\n agg = tuple[0];\r\n mapped = tuple[1];\r\n }\r\n return [agg, mapped];\r\n }),\r\n\r\n /**\r\n * iterate f x returns an infinite list of repeated applications of f to x.\r\n * @function module:list.iterate\r\n * @example `iterate(5, f, x) == [x, f(x), f(f(x)), ...]`\r\n * @param limit {Number}\r\n * @param op {Function} - Operation.\r\n * @param x {*} - Starting point.\r\n * @returns {*}\r\n */\r\n iterate = curry((limit, op, x) => {\r\n let ind = 0,\r\n out = [],\r\n lastX = x;\r\n for (; ind < limit; ind += 1) {\r\n out.push(lastX);\r\n lastX = op(lastX, ind);\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Repeats `x` `limit` number of times.\r\n * @function module:list.repeat\r\n * @param limit {Number}\r\n * @param x {*}\r\n * @return {Array}\r\n */\r\n repeat = curry((limit, x) => iterate(limit, a => a, x)),\r\n\r\n /**\r\n * Same as `repeat` due to the nature of javascript (see haskell version for usage).\r\n * @function module:list.replicate\r\n * @param limit {Number}\r\n * @param x {*}\r\n * @return {Array}\r\n */\r\n replicate = repeat,\r\n\r\n /**\r\n * Replicates a list `limit` number of times and appends the results (concat)\r\n * @function module:list.cycle\r\n * @param limit {Number}\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n cycle = curry((limit, xs) => concat(replicate(limit, xs))),\r\n\r\n /**\r\n * Unfolds a value into a list of somethings.\r\n * @haskellType `unfoldr :: (b -> Maybe (a, b)) -> b -> [a]`\r\n * @function module:list.unfoldr\r\n * @param op {Function} - Operation to perform (should return a two component tuple (item to aggregateArray and item to unfold in next iteration).\r\n * @param x {*} - Starting parameter to unfold from.\r\n * @returns {Array} - An array of whatever you return from `op` yielded.\r\n */\r\n unfoldr = curry((op, x) => {\r\n let ind = 0,\r\n out = [],\r\n resultTuple = op(x, ind, out);\r\n while (resultTuple) {\r\n out.push(resultTuple[0]);\r\n resultTuple = op(resultTuple[1], ++ind, out);\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Finds index in string or list (alias for `findIndex`).\r\n * @function module:list.findIndex\r\n * @param pred {Function} - Predicate.\r\n * @param arr {Array|String}\r\n * @returns {Number} - `-1` if predicate not matched else `index` found\r\n */\r\n findIndex = findIndexWhere,\r\n\r\n /**\r\n * @function module:list.findIndices\r\n * @param pred {Function}\r\n * @param xs {Array} - list or list like.\r\n * @returns {Array|undefined}\r\n */\r\n findIndices = findIndicesWhere,\r\n\r\n /**\r\n * @function module:list.elemIndex\r\n * @param x {*} - Element to search for.\r\n * @param xs {Array} - list or list like.\r\n * @returns {*}\r\n */\r\n elemIndex = curry((x, xs) => {\r\n const foundInd = indexOf(x, xs);\r\n return foundInd !== -1 ? foundInd : undefined;\r\n }),\r\n\r\n /**\r\n * @function module:list.elemIndices\r\n * @param value {*} - Element to search for.\r\n * @param xs {Array} - list or list like.\r\n * @returns {*}\r\n */\r\n elemIndices = curry((value, xs) => findIndices(x => x === value, xs)),\r\n\r\n /**\r\n * Takes `n` items from start of list to `limit` (exclusive).\r\n * @function module:list.take\r\n * @param list {Array|String}\r\n * @param limit {Number}\r\n * @returns {String|Array} - Passed in type's type\r\n */\r\n take = sliceTo,\r\n\r\n /**\r\n * Drops `n` items from start of list to `count` (exclusive).\r\n * @function module:list.drop\r\n * @param list {Array|String}\r\n * @param count {Number}\r\n * @returns {String|Array} - Passed in type's type\r\n */\r\n drop = sliceFrom,\r\n\r\n /**\r\n * Splits `x` in two at given `index` (exclusive (includes element/character at\r\n * given index in second part of returned list)).\r\n * @function module:list.splitAt\r\n * @param ind {Number} - Index to split at.\r\n * @param list {Array|String} - functor (list or string) to split.\r\n * @returns {Array|String} - List like type passed\r\n */\r\n splitAt = (ind, list) => [sliceTo(ind, list), sliceFrom(ind, list)],\r\n\r\n /**\r\n * Gives an list with passed elements while predicate was true.\r\n * @function module:list.takeWhile\r\n * @param pred {Function} - Predicate<*, index, list|string>\r\n * @param list {Array|String}\r\n * @returns {Array}\r\n */\r\n takeWhile = curry((pred, list) =>\r\n reduceUntil(\r\n negateF3(pred), // predicate\r\n isString(list) ?\r\n (agg, x) => agg + x :\r\n aggregateArray, // operation\r\n of(list), // aggregate\r\n list\r\n )),\r\n\r\n /**\r\n * Returns an list without elements that match predicate.\r\n * @function module:list.dropWhile\r\n * @param pred {Function} - Predicate<*, index, list|string>\r\n * @param list {Array|String}\r\n * @refactor\r\n * @returns {Array|String}\r\n */\r\n dropWhile = curry((pred, list) => {\r\n const limit = length(list),\r\n splitPoint =\r\n findIndexWhere(\r\n (x, i, xs) => !pred(x, i, xs),\r\n list\r\n );\r\n\r\n return splitPoint === -1 ?\r\n sliceFrom(limit, list) :\r\n slice(splitPoint, limit, list);\r\n }),\r\n\r\n /**\r\n * @function module:list.dropWhileEnd\r\n * @param pred {Function} - Predicate<*, index, list|string>\r\n * @param list {Array|String}\r\n * @refactor\r\n * @returns {Array|String}\r\n */\r\n dropWhileEnd = curry((pred, list) => {\r\n const splitPoint =\r\n findIndexWhereRight(\r\n (x, i, xs) => !pred(x, i, xs),\r\n list\r\n );\r\n if (splitPoint === -1) {\r\n return of(list);\r\n }\r\n return sliceTo(splitPoint + 1, list);\r\n }),\r\n\r\n /**\r\n * Gives you the `span` of items matching predicate\r\n * and items not matching predicate; E.g., Gives an\r\n * array of arrays; E.g., [[matching-items], [non-matching-items]]\r\n * @function list.span\r\n * @param pred {Function} - List predicate (`(x, i, list) => bool`)\r\n * @param list {Array|String}\r\n * @returns {(Array>|Array)}\r\n * @type {Function}\r\n */\r\n span = curry((pred, list) => {\r\n const splitPoint = findIndexWhere(negateF3(pred), list);\r\n return splitPoint === -1 ?\r\n [sliceFrom(0, list), of(list)] :\r\n splitAt(splitPoint, list);\r\n }),\r\n\r\n /**\r\n * breakOnList, applied to a predicate p and a list xs, returns a tuple\r\n * where first element is longest prefix (possibly empty) of xs of elements\r\n * that do not satisfy p and second element is the remainder of the list:\r\n * @haskellExample\r\n * Replace `break` with `breakOnList` for our version.\r\n * ```\r\n * breakOnList (> 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4])\r\n * breakOnList (< 9) [1,2,3] == ([],[1,2,3])\r\n * breakOnList (> 9) [1,2,3] == ([1,2,3],[])\r\n * ```\r\n * @function module:list.breakOnList\r\n * @param pred {Function}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n breakOnList = curry((pred, list) => {\r\n const splitPoint = findIndexWhere(negateF3(pred), list);\r\n return splitPoint === -1 ?\r\n [of(list), sliceFrom(0, list)] : reverse(splitAt(splitPoint, list));\r\n }),\r\n\r\n /**\r\n * Gets item at index.\r\n * @function module:list.at\r\n * @param ind {Number} - Index.\r\n * @param xs {Array} - list or list like.\r\n * @returns {*|undefined} - Item or `undefined`.\r\n */\r\n at = lookup,\r\n\r\n /**\r\n * Find an item in structure of elements based on given predicate (`pred`).\r\n * @function module:list.find\r\n * @param pred {Function}\r\n * @param xs {Array} - list or list like.\r\n * @returns {*} - Found item.\r\n */\r\n find = findWhere,\r\n\r\n /**\r\n * For each function (same as `[].forEach` except in functional format).\r\n * @function module:list.forEach\r\n * @param fn {Function} - Operation (`(element, index, list) => {...}`, etc.)\r\n * @param xs {(Array|String)}\r\n * @returns {void}\r\n */\r\n forEach = curry((fn, list) => {\r\n const limit = length(list);\r\n if (!limit) {\r\n return;\r\n }\r\n let ind = 0;\r\n for (; ind < limit; ind += 1) {\r\n fn(list[ind], ind, list);\r\n }\r\n }),\r\n\r\n /**\r\n * Filters a structure of elements using given predicate (`pred`) (same as `[].filter`).\r\n * @function module:list.filter\r\n * @param pred {Function}\r\n * @param xs {Array} - list or list like.\r\n * @returns {Array} - Structure of filtered elements.\r\n */\r\n filter = curry((pred, xs) => {\r\n let ind = 0,\r\n limit = length(xs),\r\n out = [];\r\n if (!limit) {\r\n return out;\r\n }\r\n for (; ind < limit; ind++) {\r\n if (pred(xs[ind], ind, xs)) {\r\n out.push(xs[ind]);\r\n }\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Partitions a list on a predicate; Items that match predicate are in first list in tuple; Items that\r\n * do not match the tuple are in second list in the returned tuple.\r\n * Essentially `[filter(p, xs), filter(negateF3(p), xs)]`.\r\n * @function module:list.partition\r\n * @param pred {Function} - Predicate\r\n * @param list {Array}\r\n * @returns {Array|String} - Tuple of arrays or strings (depends on incoming list (of type list or string)).\r\n */\r\n partition = curry((pred, list) =>\r\n !length(list) ?\r\n [[], []] :\r\n [filter(pred, list), filter(negateF3(pred), list)]),\r\n\r\n /**\r\n * Returns a boolean indicating whether an element exists in given structure of elements.\r\n * @function module:list.elem\r\n * @param element {*}\r\n * @param xs {Array}\r\n * @returns {Boolean}\r\n */\r\n elem = includes,\r\n\r\n /**\r\n * The opposite of `elem` - Returns a boolean indicating whether an element exists in given list.\r\n * @function module:list.notElem\r\n * @param element {*}\r\n * @param xs {Array}\r\n * @returns {Boolean}\r\n */\r\n notElem = negateF2(includes),\r\n\r\n /**\r\n * Checks if list `xs1` is a prefix of list `xs2`\r\n * @function module:list.isPrefixOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isPrefixOf = curry((xs1, xs2) => {\r\n const limit1 = length(xs1),\r\n limit2 = length(xs2);\r\n if (limit2 < limit1 || !limit1 || !limit2 || indexOf(xs1[0], xs2) === -1) {\r\n return false;\r\n }\r\n let ind = 0;\r\n for (; ind < limit1; ind++) {\r\n if (xs1[ind] !== xs2[ind]) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }),\r\n\r\n /**\r\n * Checks if list `xs1` is a suffix of list `xs2`\r\n * @function module:list.isSuffixOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isSuffixOf = curry((xs1, xs2) => {\r\n const limit1 = length(xs1),\r\n limit2 = length(xs2);\r\n if (limit2 < limit1 || !limit1 || !limit2 || indexOf(xs1[0], xs2) === -1) {\r\n return false;\r\n }\r\n let ind1 = limit1 - 1,\r\n ind2 = limit2 - 1;\r\n for (; ind1 >= 0; ind1--) {\r\n if (xs1[ind1] !== xs2[ind2]) {\r\n return false;\r\n }\r\n ind2 -= 1;\r\n }\r\n return true;\r\n }),\r\n\r\n /**\r\n * Checks if list `xs1` is an infix of list `xs2`\r\n * @function module:list.isInfixOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isInfixOf = curry((xs1, xs2) => {\r\n const limit1 = length(xs1),\r\n limit2 = length(xs2);\r\n if (limit2 < limit1 || !limit1 || !limit2) {\r\n return false;\r\n }\r\n let ind1,\r\n foundLen,\r\n ind = 0;\r\n for (; ind < limit2; ind += 1) {\r\n foundLen = 0;\r\n for (ind1 = 0; ind1 < limit1; ind1 += 1) {\r\n if (xs2[ind1 + ind] === xs1[ind1]) {\r\n foundLen += 1;\r\n }\r\n if (foundLen === limit1) {\r\n return true;\r\n }\r\n }\r\n }\r\n return false;\r\n }),\r\n\r\n /**\r\n * Checks if list `xs1` is a sub-sequence of list `xs2`\r\n * @function module:list.isSubsequenceOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isSubsequenceOf = curry((xs1, xs2) => {\r\n const len = Math.pow(2, length(xs2)),\r\n lenXs1 = length(xs1);\r\n let foundLen,\r\n i;\r\n for (i = 0; i < len; i += 1) {\r\n foundLen = 0;\r\n for (let j = 0; j < len; j += 1) {\r\n if (i & (1 << j) && indexOf(xs2[j], xs1) > -1) {\r\n foundLen += 1;\r\n }\r\n if (foundLen === lenXs1) {\r\n return true;\r\n }\r\n }\r\n }\r\n return false;\r\n }),\r\n\r\n /**\r\n * The group function takes a list and returns a list of lists such that\r\n * the concatenation of the result is equal to the argument. Moreover, each\r\n * sublist in the result contains only equal elements. For example,\r\n * `group \"Mississippi\" = [\"M\",\"i\",\"ss\",\"i\",\"ss\",\"i\",\"pp\",\"i\"]`\r\n * It is a special case of groupBy, which allows the programmer to supply\r\n * their own equality test.\r\n * @haskellType `group :: Eq a => [a] -> [[a]]`\r\n * @function module:list.group\r\n * @param xs {Array|String}\r\n * @returns {Array|*}\r\n */\r\n group = xs => groupBy((a, b) => a === b, xs),\r\n\r\n /**\r\n * Allows you to group items in a list based on your supplied equality check.\r\n * @note Sames `group` but allows you to specify equality operation.\r\n * @haskellType `groupBy :: (a -> a -> Bool) -> [a] -> [[a]]`\r\n * @function module:list.groupBy\r\n * @param equalityOp {Function}\r\n * @param xs {Array}\r\n * @returns {*}\r\n */\r\n groupBy = curry((equalityOp, xs) => {\r\n const limit = length(xs);\r\n if (!limit) {\r\n return sliceCopy(xs);\r\n }\r\n let ind = 0,\r\n prevItem,\r\n item,\r\n predOp = x => {\r\n if (equalityOp(x, prevItem)) {\r\n ind++;\r\n }\r\n if (equalityOp(x, item)) {\r\n prevItem = x;\r\n return true;\r\n }\r\n return false;\r\n },\r\n agg = [];\r\n for (; ind < limit; ind += 1) {\r\n item = xs[ind];\r\n agg.push(takeWhile(predOp, slice(ind, limit, xs)));\r\n }\r\n return agg;\r\n }),\r\n\r\n /**\r\n * The inits function returns all initial segments of the argument, shortest first. For example,\r\n * ```\r\n * shallowEquals(inits('abc'), ['','a','ab','abc'])\r\n * ```\r\n * @function module:list.inits\r\n * @haskellType `inits :: [a] -> [[a]]`\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n inits = xs => {\r\n let limit = length(xs),\r\n ind = 0,\r\n agg = [];\r\n if (!limit) {\r\n return [];\r\n }\r\n for (; ind <= limit; ind += 1) {\r\n agg.push(sliceTo(ind, xs));\r\n }\r\n return agg;\r\n }, //map(list => init(list), xs),\r\n\r\n /**\r\n * The inits function returns all initial segments of the argument, shortest first. For example,\r\n * ```\r\n * shallowEquals(tails('abc'), ['abc', 'bc', 'c',''])\r\n * ```\r\n * @function module:list.tails\r\n * @haskellType `tails :: [a] -> [[a]]`\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n tails = xs => {\r\n let limit = length(xs),\r\n ind = 0,\r\n agg = [];\r\n if (!limit) {\r\n return [];\r\n }\r\n for (; ind <= limit; ind += 1) {\r\n agg.push(slice(ind, limit, xs));\r\n }\r\n return agg;\r\n }, //map(list => tail(list), xs),\r\n\r\n /**\r\n * Strips prefix list from given list\r\n * @function module:list.stripPrefix\r\n * @param prefix {Array|String|*}\r\n * @param list {Array|string|*}\r\n * @returns {Array|*}\r\n */\r\n stripPrefix = curry((prefix, list) =>\r\n isPrefixOf(prefix, list) ?\r\n splitAt(length(prefix), list)[1] :\r\n sliceCopy(list)),\r\n\r\n /**\r\n * zip takes two lists and returns a list of corresponding pairs.\r\n * If one input list is short, excess elements of the longer list are discarded.\r\n * @haskellType `zip :: [a] -> [b] -> [(a, b)]`\r\n * @function module:list.zip\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array>}\r\n */\r\n zip = curry((arr1, arr2) => {\r\n if (!length(arr1) || !length(arr2)) {\r\n return [];\r\n }\r\n const [a1, a2] = toShortest(arr1, arr2);\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, [item, a2[ind]]),\r\n [], a1);\r\n }),\r\n\r\n /**\r\n * zipN takes one or more lists and returns a list containing lists of all indices\r\n * at a given index, index by index.\r\n * If one input list is short, excess elements of the longer list are discarded.\r\n * @function module:list.zipN\r\n * @param lists {Array|String} - One ore more lists of the same type.\r\n * @returns {Array}\r\n */\r\n zipN = curry2((...lists) => {\r\n const trimmedLists = apply(toShortest, lists);\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, map(xs => xs[ind], trimmedLists)),\r\n [], trimmedLists[0]);\r\n }),\r\n\r\n /**\r\n * @haskellType `zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]`\r\n * @function module:list.zip3\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @param arr3 {Array}\r\n * @returns {Array>}\r\n */\r\n zip3 = curry((arr1, arr2, arr3) => zipN(arr1, arr2, arr3)),\r\n\r\n /**\r\n * @haskellType `zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]`\r\n * @function module:list.zip4\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @param arr3 {Array}\r\n * @param arr4 {Array}\r\n * @returns {Array>}\r\n */\r\n zip4 = curry((arr1, arr2, arr3, arr4) => zipN(arr1, arr2, arr3, arr4)),\r\n\r\n /**\r\n * @haskellType `zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]`\r\n * @function module:list.zip5\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @param arr3 {Array}\r\n * @param arr4 {Array}\r\n * @param arr5 {Array}\r\n * @returns {Array>}\r\n */\r\n zip5 = curry((arr1, arr2, arr3, arr4, arr5) => zipN(arr1, arr2, arr3, arr4, arr5)),\r\n\r\n /**\r\n * zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]\r\n * zipWith generalises zip by zipping with the function given as the\r\n * first argument, instead of a function tupling function (function that returns a tuple). For example,\r\n * zipWith (+) is applied to two lists to produce the list of corresponding sums.\r\n * @note `_|_` means bottom or perpetual (@see\r\n * - https://wiki.haskell.org/Bottom\r\n * - https://stackoverflow.com/questions/19794681/what-does-this-syntax-mean-in-haskell-or\r\n * )\r\n * @example\r\n * ```\r\n * zipWith f [] _|_ = []\r\n * ```\r\n * @haskellType `zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]`\r\n * @function module:list.zipWith\r\n * @param op {Function} - Takes two parts of a tuple and returns a tuple.\r\n * E.g., ` op :: a -> b -> (a, b)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith = curry((op, xs1, xs2) => {\r\n if (!length(xs1) || !length(xs2)) {\r\n return [];\r\n }\r\n const [a1, a2] = toShortest(xs1, xs2);\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, op(item, a2[ind])),\r\n [], a1);\r\n }),\r\n\r\n /**\r\n * Zips all given lists with tupling function. Note: Haskell types do not have\r\n * a way (that I know of) to show one or more for params in a function so `@haskellType` below\r\n * is left there for general purpose not for exactness as is told by aforementioned.\r\n * @haskellType `zipWithN :: (a -> b -> c) -> [a] -> [b] -> [c]` - Where `N` is the number\r\n * of lists to zip.\r\n * @function module:list.zipWithN\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> (a, b, c)`\r\n * @param lists ...{Array}\r\n * @returns {Array>}\r\n */\r\n zipWithN = curry3((op, ...lists) => {\r\n const trimmedLists = apply(toShortest, lists),\r\n lenOfTrimmed = length(trimmedLists);\r\n if (!lenOfTrimmed) {\r\n return [];\r\n }\r\n else if (lenOfTrimmed === 1) {\r\n return sliceTo(length(trimmedLists[0]), trimmedLists[0]);\r\n }\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, apply(op, map(xs => xs[ind], trimmedLists))),\r\n [], trimmedLists[0]);\r\n }),\r\n\r\n /**\r\n * Zips 3 lists with tupling function.\r\n * @haskellType `zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]`\r\n * @function module:list.zipWith3\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> (a, b, c)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @param xs3 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith3 = curry((op, xs1, xs2, xs3) => zipWithN(op, xs1, xs2, xs3)),\r\n\r\n /**\r\n * Zips 4 lists with tupling function.\r\n * @haskellType `zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]`\r\n * @function module:list.zipWith4\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> d -> (a, b, c, d)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @param xs3 {Array}\r\n * @param xs4 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith4 = curry((op, xs1, xs2, xs3, xs4) => zipWithN(op, xs1, xs2, xs3, xs4)),\r\n\r\n /**\r\n * Zips 5 lists.\r\n * @haskellType `zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]`\r\n * @function module:list.zipWith5\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> d -> e -> (a, b, c, d, e)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @param xs3 {Array}\r\n * @param xs4 {Array}\r\n * @param xs5 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith5 = curry((op, xs1, xs2, xs3, xs4, xs5) => zipWithN(op, xs1, xs2, xs3, xs4, xs5)),\r\n\r\n /**\r\n * unzip transforms a list of pairs into a list of first components and a list of second components.\r\n * @haskellType `unzip :: [(a, b)] -> ([a], [b])`\r\n * @function module:list.unzip\r\n * @param arr {Array|*}\r\n * @returns {Array|*}\r\n */\r\n unzip = foldl((agg, item) => {\r\n agg[0].push(item[0]);\r\n agg[1].push(item[1]);\r\n return agg;\r\n }, [[], []]),\r\n\r\n /**\r\n * unzip transforms a list of pairs into a list of first components and a list of second components.\r\n * @sudoHaskellType `unzipN :: [(a, b, ...x)] -> ([a], [b], ...[x])`\r\n * @function module:list.unzipN\r\n * @param list {Array|*} - List of tuples (lists).\r\n * @returns {Array|*}\r\n */\r\n unzipN = list => {\r\n if (!length(list)) {\r\n return [];\r\n }\r\n const lenItem0 = length(list[0]);\r\n let zero = lenItem0 ?\r\n unfoldr(numLists => numLists-- ? [[], numLists] : undefined, lenItem0) :\r\n [];\r\n return foldl((agg, item) => {\r\n agg.forEach((outList, ind) => outList.push(item[ind]));\r\n return agg;\r\n }, zero, list);\r\n },\r\n\r\n /**\r\n * Returns true if any item in container passes predicate `p`.\r\n * @function module:list.any\r\n * @param p {Function} - Predicate.\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n any = curry((p, xs) => {\r\n let ind = 0,\r\n limit = length(xs);\r\n if (!limit) {\r\n return false;\r\n }\r\n for (; ind < limit; ind += 1) {\r\n if (p(xs[ind])) {\r\n return true;\r\n }\r\n }\r\n return false;\r\n }),\r\n\r\n /**\r\n * Returns true if all items in container pass predicate `p`.\r\n * @function module:list.all\r\n * @param p {Function} - Predicate.\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n all = curry((p, xs) => {\r\n const limit = length(xs);\r\n let ind = 0;\r\n if (!limit) {\r\n return false;\r\n }\r\n for (; ind < limit; ind++) {\r\n if (!p(xs[ind], ind, xs)) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }),\r\n\r\n /**\r\n * Conjuction of container of bools (or truthy and/or falsy values); Returns\r\n * `true` if all in container are 'truthy' else returns `false`\r\n * @function module:list.and\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n and = xs => all(isTruthy, xs),\r\n\r\n /**\r\n * Returns a boolean indicating whether any item in container is 'truthy' or not.\r\n * **Note** The haskell type for this function only takes two items, but here\r\n * we allow the passing of more than one item (may change later to adhere to the haskell type).\r\n * @function module:list.or\r\n * @haskellType `or :: Bool -> Bool -> Bool`\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n or = xs => any(isTruthy, xs),\r\n\r\n /**\r\n * Returns a boolean indicating whether all items in container are 'falsy' or not.\r\n * **Note** The haskell type for this function only takes two items, but here\r\n * we allow the passing of more than one item (may change later to adhere to the haskell type).\r\n * @function module:list.not\r\n * @haskellType `not :: Bool -> Bool`\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n not = xs => all(isFalsy, xs),\r\n\r\n /**\r\n * Computes the sum of the numbers of a structure.\r\n * @function module:list.sum\r\n * @haskellType `sum :: (List t, Num a) => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {Number}\r\n */\r\n sum = list => foldl((agg, x) => agg + x, 0, list),\r\n\r\n /**\r\n * Computes the product of the numbers of a structure.\r\n * @function module:list.product\r\n * @haskellType `product :: (List t, Num a) => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {Number}\r\n */\r\n product = list => foldl((agg, x) => agg * x, 1, list),\r\n\r\n /**\r\n * Returns the largest element in a non-empty structure of elements.\r\n * @function module:list.maximum\r\n * @haskellType `maximum :: forall a . Ord a => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {*} - Whatever type the array is made of (if any).\r\n */\r\n maximum = list => last(sortBy(genericAscOrdering, list)),\r\n\r\n /**\r\n * Returns the smallest element in a non-empty structure of elements.\r\n * @function module:list.minimum\r\n * @haskellType `minimum :: forall a . Ord a => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {*} - Whatever type the array is made of (if any).\r\n */\r\n minimum = list => head(sortBy(genericAscOrdering, list)),\r\n\r\n /**\r\n * scanl is similar to foldl, but returns a list of successive reduced values from the left:\r\n * ```\r\n * scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]\r\n * ```\r\n * Also note that:\r\n * ```\r\n * last (scanl f z xs) == foldl f z xs.\r\n * ```\r\n * @function module:list.scanl\r\n * @param fn {Function}\r\n * @param zero {*}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanl = curry((fn, zero, xs) => {\r\n if (!xs || !length(xs)) {\r\n return [];\r\n }\r\n const limit = length(xs);\r\n let ind = 0,\r\n result = zero,\r\n out = [];\r\n while (ind < limit) {\r\n result = fn(result, xs[ind], ind, xs);\r\n out.push(result);\r\n ind++;\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * `scanl1` is a variant of `scanl` that has no starting value argument:\r\n * `shallowCompare(scanl1(fn, [x1, x2, ...]), [x1, fn(x1, x2), ...]) // true`\r\n * @function module:list.scanl1\r\n * @param fn {Function}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanl1 = curry((fn, xs) => {\r\n if (!xs || !xs.length) {\r\n return [];\r\n }\r\n return scanl(fn, head(xs), tail(xs));\r\n }),\r\n\r\n /**\r\n * Same as `scanl` but from the right (similiar to `foldr`'s relationship to 'foldl').\r\n * Note also `scanr`'s relationship ot `foldr`:\r\n * `head (scanr(fn, z, xs)) === foldr(fn, z, xs).\r\n * @function module:list.scanr\r\n * @param fn {Function}\r\n * @param zero {*}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanr = curry((fn, zero, xs) => {\r\n if (!xs || !length(xs)) {\r\n return [];\r\n }\r\n const limit = length(xs);\r\n let ind = limit - 1,\r\n result = xs[0],\r\n out = [];\r\n while (ind > -1) {\r\n result = fn(result, xs[ind], ind, xs);\r\n out.push(result);\r\n ind--;\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Same as `scanr` but takes no zero/accumulator value.\r\n * @function module:list.scanr1\r\n * @param fn {Function}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanr1 = curry((fn, xs) => {\r\n if (!xs || !xs.length) {\r\n return [];\r\n }\r\n return scanr(fn, last(xs), init(xs));\r\n }),\r\n\r\n /**\r\n * The nub function removes duplicate elements from a list.\r\n * In particular, it keeps only the first occurrence of each element.\r\n * (The name nub means `essence'.) It is a special case of nubBy, which\r\n * allows the programmer to supply their own equality test.\r\n * ```shallowCompare( nub ([1,2,3,4,3,2,1,2,4,3,5]), [1,2,3,4,5] )```\r\n * @function module:list.nub\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n nub = list => nubBy((a, b) => a === b, list),\r\n\r\n /**\r\n * `remove(x, xs)` removes the first occurrence of `x` from `xs`.\r\n * For example, `remove('a', 'banana') === 'bnana';`\r\n * @function module:list.remove\r\n * @param x {*}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n remove = curry((x, list) => removeBy((a, b) => a === b, x, list)),\r\n\r\n /**\r\n * The sort function implements a stable sorting algorithm.\r\n * It is a special case of sortBy, which allows the programmer\r\n * to supply their own comparison function.\r\n * ```shallowCompare(sort ([1,6,4,3,2,5]), [1,2,3,4,5,6]) // true```\r\n * @function module:list.sort\r\n * @param xs {Array|String|*}\r\n * @returns {Array}\r\n */\r\n sort = xs => sortBy(genericAscOrdering, xs),\r\n\r\n /**\r\n * Sort a list by comparing the results of a key function applied to each\r\n * element. sortOn f is equivalent to sortBy (comparing f), but has the\r\n * performance advantage of only evaluating f once for each element in the\r\n * input list. This is called the decorate-sort-undecorate paradigm, or\r\n * Schwartzian transform.\r\n *\r\n * Elements are arranged from from lowest to highest, keeping duplicates\r\n * in the order they appeared in the input.\r\n *\r\n * Ex:\r\n * ```\r\n * shallowEquals(\r\n * sortOn (head, [[2, \"world\"], [4, \"!\"], [1, \"Hello\"]]),\r\n * [[1,\"Hello\"],[2,\"world\"],[4,\"!\"]]\r\n * ) // true\r\n * ```\r\n * @function module:list.sortOn\r\n * @param valueFn {Function}\r\n * @param xs {Array|String|*}\r\n * @returns {Array}\r\n */\r\n sortOn = curry((valueFn, xs) =>\r\n\r\n // Un-decorate\r\n map(decorated => decorated[1],\r\n\r\n // Decorate and sort\r\n sortBy(\r\n // Ordering\r\n ([a0], [b0]) => genericAscOrdering(a0, b0),\r\n\r\n // Decorate\r\n map(item => [valueFn(item), item], xs)\r\n )\r\n )\r\n ),\r\n\r\n /**\r\n * The sortBy function is the non-overloaded (in haskell terms) version of sort.\r\n * @haskellExample ```\r\n * >>> sortBy (\\(a,_) (b,_) -> compare a b) [(2, \"world\"), (4, \"!\"), (1, \"Hello\")]\r\n * [(1,\"Hello\"),(2,\"world\"),(4,\"!\")]\r\n * ```\r\n * @function module:list.sortBy\r\n * @param orderingFn {Function}\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sortBy = curry((orderingFn, xs) => sliceCopy(xs).sort(orderingFn || genericAscOrdering)),\r\n\r\n /**\r\n * The insert function takes an element and a list and inserts the element\r\n * into the list at the first position where it is less than or equal to the\r\n * next element. In particular, if the list is sorted before the call, the\r\n * result will also be sorted. It is a special case of insertBy, which allows\r\n * the programmer to supply their own comparison function.\r\n * @function module:list.insert\r\n * @param x {*}\r\n * @param xs {Array|*}\r\n * @returns {Array}\r\n */\r\n insert = curry((x, xs) => {\r\n if (!xs.length) {\r\n return of(xs, x);\r\n }\r\n const foundIndex = findIndex(item => x <= item, xs);\r\n return foundIndex === -1 ? concat([xs, of(xs, x)]) :\r\n concat(intersperse(of(xs, x), splitAt(foundIndex, xs)));\r\n }),\r\n\r\n /**\r\n * A version of `insert` that allows you to specify the ordering of the inserted\r\n * item; Before/at, or after\r\n * @function module:list.insertBy\r\n * @haskellType `insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]`\r\n * @note `Ordering` means 'something that is order-able'\r\n * operated on by this functions logic.\r\n * @param orderingFn {Function} - A function that returns `-1`, `0`, or 1`.\r\n * @param x {*} - Value to insert.\r\n * @param xs {Array} - List to insert into (note new list is returned)\r\n * @returns {Array} - New list.\r\n */\r\n insertBy = curry((orderingFn, x, xs) => {\r\n const limit = length(xs);\r\n if (!limit) {\r\n return [x];\r\n }\r\n let ind = 0;\r\n for (; ind < limit; ind += 1) {\r\n if (orderingFn(x, xs[ind]) <= 0) {\r\n const parts = splitAt(ind, xs);\r\n return concat([parts[0], [x], parts[1]]);\r\n }\r\n }\r\n return aggregateArray(sliceCopy(xs), x);\r\n }),\r\n\r\n /**\r\n * The nubBy function behaves just like nub, except it uses a user-supplied equality predicate.\r\n * @function module:list.nubBy\r\n * @param pred {Function}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n nubBy = curry((pred, list) => {\r\n if (!length(list)) {\r\n return [];\r\n }\r\n const limit = length(list);\r\n let ind = 0,\r\n currItem,\r\n out = [],\r\n anyOp = storedItem => pred(currItem, storedItem);\r\n for (; ind < limit; ind += 1) {\r\n currItem = list[ind];\r\n if (any(anyOp, out)) {\r\n continue;\r\n }\r\n out.push(currItem);\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Behaves the same as `remove`, but takes a user-supplied equality predicate.\r\n * @function module:list.removeBy\r\n * @param pred {Function} - Equality predicate `(a, b) => bool`\r\n * @param x {*}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n removeBy = curry((pred, x, list) => {\r\n const foundIndex = findIndex(item => pred(x, item), list);\r\n if (foundIndex > -1) {\r\n const parts = splitAt(foundIndex, list);\r\n return append(parts[0], tail(parts[1]));\r\n }\r\n return sliceCopy(list);\r\n }),\r\n\r\n /**\r\n * The `removeFirstsBy` function takes a predicate and two lists and returns the first list with the first\r\n * occurrence of each element of the second list removed.\r\n * @function module:list.removeFirstBy\r\n * @param pred {Function}\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {Array}\r\n */\r\n removeFirstsBy = curry((pred, xs1, xs2) =>\r\n foldl((agg, x) => removeBy(pred, x, agg), xs1, xs2)),\r\n\r\n /**\r\n * Returns the union on elements matching boolean check passed in.\r\n * @function module:list.unionBy\r\n * @param pred {Function} - `pred :: a -> a -> Bool`\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array}\r\n */\r\n unionBy = curry((pred, arr1, arr2) =>\r\n foldl((agg, b) => {\r\n const alreadyAdded = any(a => pred(a, b), agg);\r\n return !alreadyAdded ? (agg.push(b), agg) : agg;\r\n }, sliceCopy(arr1), arr2\r\n )),\r\n\r\n /**\r\n * Creates a union on matching elements from array1.\r\n * @function module:list.union\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array}\r\n */\r\n union = curry((arr1, arr2) =>\r\n append(arr1,\r\n filter(elm => !includes(elm, arr1), arr2))),\r\n\r\n /**\r\n * Performs an intersection on list 1 with elements from list 2.\r\n * @function module:list.intersect\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array}\r\n */\r\n intersect = curry((arr1, arr2) =>\r\n !arr1 || !arr2 || (!arr1 && !arr2) ? [] :\r\n filter(elm => includes(elm, arr2), arr1)),\r\n\r\n /**\r\n * Returns an intersection by predicate.\r\n * @function module:list.intersectBy\r\n * @param pred {Function} - `pred :: a -> b -> Bool`\r\n * @param list1 {Array}\r\n * @param list2 {Array}\r\n * @return {Array}\r\n */\r\n intersectBy = curry((pred, list1, list2) =>\r\n foldl((agg, a) =>\r\n any(b => pred(a, b), list2) ? (agg.push(a), agg) : agg\r\n , [], list1)),\r\n\r\n /**\r\n * Returns the difference of list 1 from list 2.\r\n * @note The `difference` operation here is non-associative; E.g., `a - b` is not equal to `b - a`;\r\n * @function module:list.difference\r\n * @param array1 {Array}\r\n * @param array2 {Array}\r\n * @returns {Array}\r\n */\r\n difference = curry((array1, array2) => { // augment this with max length and min length ordering on op\r\n if (array1 && !array2) {\r\n return sliceCopy(array1);\r\n }\r\n else if (!array1 && array2 || (!array1 && !array2)) {\r\n return [];\r\n }\r\n return reduce((agg, elm) =>\r\n !includes(elm, array2) ? (agg.push(elm), agg) : agg\r\n , [], array1);\r\n }),\r\n\r\n /**\r\n * Returns the complement of list 0 and the reset of the passed in arrays.\r\n * @function module:list.complement\r\n * @param arr0 {Array}\r\n * @param arrays {...Array}\r\n * @returns {Array}\r\n */\r\n complement = curry2((arr0, ...arrays) =>\r\n reduce((agg, arr) => append(agg, difference(arr, arr0)), [], arrays));\r\n","/**\r\n * @module errorThrowing\r\n * @description Contains error throwing facilities for when a value doesn't match a type.\r\n */\r\nimport {typeOf} from './object/typeOf';\r\nimport {isArray, toTypeRef, toTypeRefName, isOfType} from './object/is';\r\nimport {curry} from './function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Pretty prints an array of types/type-strings for use by error messages;\r\n * Outputs \"`SomeTypeName`, ...\" from [SomeType, 'SomeTypeName', etc...]\r\n * @function module:errorThrowing.typeRefsToStringOrError\r\n * @param types {Array|TypesArray}\r\n * @return {String}\r\n * @private\r\n */\r\n typeRefsToStringOrError = types => types.length ?\r\n types.map(type => `\\`${toTypeRefName(type)}\\``).join(', ') : '',\r\n\r\n /**\r\n * Prints a message from an object. Object signature:\r\n * {contextName, valueName, value, expectedTypeName, foundTypeName, messageSuffix}\r\n * @function module:errorThrowing.defaultErrorMessageCall\r\n * @param tmplContext {Object|TemplateContext} - Object to use in error template.\r\n * @returns {string}\r\n * @private\r\n */\r\n defaultErrorMessageCall = tmplContext => {\r\n const {\r\n contextName, valueName, value, expectedTypeName,\r\n foundTypeName, messageSuffix\r\n } = tmplContext,\r\n isMultiTypeNames = isArray(expectedTypeName),\r\n typesCopy = isMultiTypeNames ? 'of type' : 'of one of the types',\r\n typesToMatchCopy = isMultiTypeNames ? typeRefsToStringOrError(expectedTypeName) : expectedTypeName;\r\n return (contextName ? `\\`${contextName}.` : '`') +\r\n `${valueName}\\` is not ${typesCopy}: ${typesToMatchCopy}. ` +\r\n `Type received: ${foundTypeName}. Value: ${value};` +\r\n `${messageSuffix ? ' ' + messageSuffix + ';' : ''}`;\r\n },\r\n\r\n /**\r\n * Gets the error message thrower seeded with passed in errorMessage template call.\r\n * @function module:errorThrowing.getErrorIfNotTypeThrower$\r\n * @param errorMessageCall {Function|ErrorMessageCall}\r\n * @param typeChecker {Function|TypeChecker} - Function:Boolean\r\n * @returns {Function|ErrorIfNotType}\r\n * @private\r\n */\r\n _getErrorIfNotTypeThrower = (errorMessageCall, typeChecker = isOfType) =>\r\n (ValueType, contextName, valueName, value, messageSuffix = null) => {\r\n const expectedTypeName = toTypeRef(ValueType),\r\n foundTypeName = typeOf(value);\r\n if (typeChecker(ValueType, value)) { return value; } // Value matches type\r\n throw new Error(errorMessageCall(\r\n {contextName, valueName, value, expectedTypeName, foundTypeName, messageSuffix}\r\n ));\r\n },\r\n\r\n /**\r\n * Gets the error message thrower seeded with passed in errorMessage template call.\r\n * @function module:errorThrowing.getErrorIfNotTypesThrower$\r\n * @param errorMessageCall {Function|ErrorMessageCall}\r\n * @param typeChecker {Function|TypeChecker} - Function:Boolean\r\n * @returns {Function|ErrorIfNotTypes}\r\n * @private\r\n */\r\n _getErrorIfNotTypesThrower = (errorMessageCall, typeChecker = isOfType) =>\r\n (valueTypes, contextName, valueName, value, messageSuffix = null) => {\r\n const expectedTypeNames = valueTypes.map(toTypeRef),\r\n matchFound = valueTypes.some(ValueType => typeChecker(ValueType, value)),\r\n foundTypeName = typeOf(value);\r\n if (matchFound) { return value; }\r\n throw new Error(\r\n errorMessageCall({\r\n contextName, valueName, value,\r\n expectedTypeName: expectedTypeNames, foundTypeName,\r\n messageSuffix\r\n })\r\n );\r\n },\r\n\r\n /**\r\n * Checks that passed in `value` is of given `type`. Throws an error if value\r\n * is not of given `type`. This is the un-curried version. For the curried version\r\n * see `module:errorThrowing.errorIfNotType`.\r\n * @function module:errorThrowing.errorIfNotType$\r\n * @param type {String|Function} - Type's name or type itself.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @param [messageSuffix=null] {String} - Optional.\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @private\r\n */\r\n _errorIfNotType = _getErrorIfNotTypeThrower(defaultErrorMessageCall),\r\n\r\n /**\r\n * Checks that passed in `value` is of one of the given `types`. Throws an error if value\r\n * is not of one of the given `types`. This is the un-curried version. For the curried version\r\n * see `module:errorThrowing.errorIfNotTypes`.\r\n * @type {Function|module:errorThrowing.errorIfNotTypes}\r\n * @function module:errorThrowing.errorIfNotTypes$\r\n * @param types {Array} - Array of one or more types or type names themselves.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @private\r\n */\r\n _errorIfNotTypes = _getErrorIfNotTypesThrower(defaultErrorMessageCall),\r\n\r\n /**\r\n * Returns a function that can be used to ensure that values are of a given type.\r\n * Also throws informative error messages containing the value types, names, expected type names,\r\n * etc.\r\n * @function module:errorThrowing.getErrorIfNotTypeThrower\r\n * @param errorMessageCall {Function|ErrorMessageCall} - Template function (takes an info-object and returns a printed string).\r\n * @returns {Function|ErrorIfNotType} - Returns a function with the same signature as `errorIfNotType` though curried.\r\n */\r\n getErrorIfNotTypeThrower = errorMessageCall => curry(_getErrorIfNotTypeThrower(errorMessageCall)),\r\n\r\n /**\r\n * Returns a function that can be used to ensure that a value is of one or more given types.\r\n * The returned function is used in cases where informative error messages\r\n * containing the value types, names, expected type names, are-required/should-be-used etc.\r\n * @function module:errorThrowing.getErrorIfNotTypesThrower\r\n * @param errorMessageCall {Function|ErrorMessageCall} - Template function (takes an info-object and returns a printed string).\r\n * @returns {Function|ErrorIfNotTypes} - Returns a function with the same signature as `errorIfNotTypes` though curried.\r\n */\r\n getErrorIfNotTypesThrower = errorMessageCall => curry(_getErrorIfNotTypesThrower(errorMessageCall)),\r\n\r\n /**\r\n * Checks that passed in `value` is of given `type`. Throws an error if value\r\n * is not of given `type`. Curried.\r\n * @function module:errorThrowing.errorIfNotType\r\n * @param type {String|Function} - Type's name or type itself.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @param [messageSuffix=null] {String} - Optional.\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @curried\r\n */\r\n errorIfNotType = curry(_errorIfNotType),\r\n\r\n /**\r\n * Checks that passed in `value` is of one of the given `types`. Throws an error if value\r\n * is not of one of the given `types`. Curried.\r\n * @function module:errorThrowing.errorIfNotTypes\r\n * @param types {Array} - Array of one or more types or type names themselves.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @curried\r\n */\r\n errorIfNotTypes = curry(_errorIfNotTypes)\r\n;\r\n\r\n/**\r\n * @typedef {*} Any - Synonym for 'any value'.\r\n */\r\n\r\n/**\r\n * @typedef {String|Function} TypeRef\r\n * @description Type reference. Type itself or Type's name; E.g., `Type.name`;\r\n */\r\n\r\n/**\r\n * @typedef {Object} TemplateContext\r\n * @description Template context used for error message renderers (functions that take a context obj and return a string).\r\n * @property value {*}\r\n * @property valueName {String}\r\n * @property expectedTypeName {String} - Expected name of constructor of `value`; E.g., usually `SomeConstructor.name`;\r\n * @property foundTypeName {String} - Found types name; E.g., `FoundConstructor.name`;\r\n * @property [messageSuffix=null] {*} - Message suffix (sometimes an extra hint or instructions for\r\n * directing user to fix where his/her error has occurred). Optional.\r\n */\r\n\r\n/**\r\n * @typedef {Array<(String|Function)>} TypesArray\r\n */\r\n\r\n/**\r\n * @typedef {Function} TypeChecker\r\n * @description Checks whether a value is of given type.\r\n * @param Type {TypeRef} - a Type or it's name; E.g., `Type.name`.\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n\r\n/**\r\n * @typedef {Function} ErrorMessageCall\r\n * @description Error message template function.\r\n * @param tmplContext {TemplateContext}\r\n * @returns {String}\r\n */\r\n\r\n/**\r\n * @typedef {Function} ErrorIfNotType\r\n * @description Used to ensure value matches passed in type.\r\n * @param type {TypeRef} - Constructor name or constructor.\r\n * @param contextName {String}\r\n * @param valueName {String}\r\n * @param value {*}\r\n * @throws {Error} - If value doesn't match type.\r\n * @returns {*} - What ever value is.\r\n */\r\n\r\n/**\r\n * @typedef {Function} ErrorIfNotTypes\r\n * @description Used to ensure a value matches one of one or more types passed in.\r\n * @param valueTypes {TypesArray} - Array of constructor names or constructors.\r\n * @param contextName {String}\r\n * @param valueName {String}\r\n * @param value {*}\r\n * @throws {Error} - If value doesn't match type.\r\n * @returns {*} - Whatever value is.\r\n */\r\n","/**\r\n * @module string\r\n * @description Contains functions for strings.\r\n */\r\nimport {intercalate, map, filter} from './list';\r\nimport {split} from './jsPlatform/string';\r\nimport {compose} from './function/compose';\r\nimport {join} from './jsPlatform/array';\r\nimport {_errorIfNotType} from './errorThrowing';\r\n\r\nexport {split};\r\n\r\nexport const\r\n\r\n /**\r\n * Splits a string on all '\\n', '\\r', '\\n\\r', or '\\r\\n' characters.\r\n * @function module:string.lines\r\n * @param str {String}\r\n * @returns {Array}\r\n */\r\n lines = split(/[\\n\\r]/gm),\r\n\r\n /**\r\n * Splits a string on all '\\s' and/or all '\\t' characters.\r\n * @function module:string.words\r\n * @param str{String}\r\n * @returns {Array}\r\n */\r\n words = split(/[\\s\\t]/gm),\r\n\r\n /**\r\n * Intersperse an array of strings with '\\s' and then concats them.\r\n * @function module:string.unwords\r\n * @param arr {String}\r\n * @returns {Array}\r\n */\r\n unwords = intercalate(' '),\r\n\r\n /**\r\n * Intersperses a '\\n' character into a list of strings and then concats it.\r\n * @function module:string.unlines\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n unlines = intercalate('\\n'),\r\n\r\n /**\r\n * Lower cases first character of a non-empty string.\r\n * @function module:string.lcaseFirst\r\n * @param xs {String}\r\n * @returns {string}\r\n * @throws {Error} - Throws error if receiving anything that is not a string.\r\n */\r\n lcaseFirst = xs => {\r\n _errorIfNotType(String, 'lcaseFirst', 'xs', xs);\r\n return xs[0].toLowerCase() + xs.substring(1);\r\n },\r\n\r\n /**\r\n * Upper cases first character of a non-empty string.\r\n * @function module:string.ucaseFirst\r\n * @param xs {String}\r\n * @returns {string}\r\n * @throws {Error} - Throws error if receiving anything that is not a string.\r\n */\r\n ucaseFirst = xs => {\r\n _errorIfNotType(String, 'ucaseFirst', 'xs', xs);\r\n return xs[0].toUpperCase() + xs.substring(1);\r\n },\r\n\r\n /**\r\n * Camel cases (class case) a string.\r\n * @function module:string.camelCase\r\n * @param xs {String}\r\n * @param [pattern=/[^a-z\\d/i]/] {RegExp} - Pattern to split on. Optional.\r\n * @throws {Error} - Throws error if param `xs` is not a string.\r\n * @returns {string}\r\n * @curried\r\n */\r\n camelCase = (xs, pattern = /[^a-z\\d]/i) => compose(\r\n join(''),\r\n map(str => ucaseFirst(str.toLowerCase())),\r\n filter(x => !!x),\r\n split(pattern)\r\n )(_errorIfNotType(String, 'camelCase', 'xs', xs)),\r\n\r\n /**\r\n * Class cases a string. Uses pattern /[^a-z\\d/i]/ to split on.\r\n * If you require a different pattern use `string.camelCase(str, pattern)`\r\n * and then upper case first character (`ucaseFirst`).\r\n * @function module:string.classCase\r\n * @param xs {String}\r\n * @returns {string}\r\n * @throws {Error} - Throws error if `xs` is not a string (via `camelCase` call).\r\n */\r\n classCase = compose(ucaseFirst, camelCase)\r\n\r\n;\r\n\r\n/**\r\n * Functional version of `String.prototype.split`.\r\n * @function module:string.split\r\n * @param separator {String|RegExp}\r\n * @param str {String}\r\n * @returns {Array}\r\n */\r\n","/**\r\n * @module fjl\r\n * @description Exports all module methods (object, list, string modules etc.).\r\n * @goal to include everything from haskell's Prelude where it makes sense in order to create\r\n * a subset of functions which can make the javascript developer more efficient and make his/her\r\n * code more concise (and functional).\r\n * @motivation preludejs, lodash/fp, RamdaJs, Haskell.\r\n * @see http://hackage.haskell.org/package/base-4.10.0.0/docs/Prelude.html\r\n * @see http://hackage.haskell.org/package/base-4.10.0.0/docs/Data-List.html\r\n */\r\nexport * from './object';\r\nexport * from './boolean';\r\nexport * from './function';\r\nexport * from './list';\r\nexport * from './string';\r\nexport * from './utils';\r\nexport * from './errorThrowing';\r\n\r\n/**\r\n * @typedef {String|Function|ArrayBufferConstructor|ArrayConstructor|BooleanConstructor|MapConstructor|NumberConstructor|SetConstructor|WeakMapConstructor|WeakSetConstructor} TypeRef\r\n * @description Type reference. Either actual type or type's name; E.g., `Type.name`\r\n * Also note: Class cased names are use for values that do not have `name` properties; Namely: 'Null', 'NaN' and 'Undefined' (for their respective values respectively).\r\n */\r\n"],"names":["returnCurried","executeArity","unmetArityNum","fn","argsToCurry","func","x","executeAsCurriedFunc","Array","from","arguments","a","b","c","d","e","args","unmetArity","concatedArgs","concat","canBeCalled","length","newExpectedArity","curryN","Function","Error","curry","curry2","curry3","curry4","curry5","fPureTakesOne","name","arg","f","fPureTakes2","arg1","arg2","fPureTakes3","arg3","fPureTakes4","arg4","fPureTakes5","arg5","fPureTakesOneOrMore","defineReverse","prototype","reverse","reduceRight","agg","item","push","map","filter","reduce","forEach","some","every","join","apply","call","flipN","flip","flip3","flip4","flip5","instanceOf","instanceConstructor","instance","hasOwnProperty","native","Object","getOwnPropertyNames","key","operation","keys","assign","obj0","objs","topAgg","obj","_Number","Number","_NaN","_Null","_Undefined","typeOf","value","retVal","undefined","constructorName","constructor","isNaN","_String","String","_Object","_Boolean","Boolean","_Function","_Array","_Symbol","_Map","_Set","_WeakMap","_WeakSet","toTypeRef","type","toTypeRefs","types","toTypeRefName","Type","ref","toTypeRefNames","isFunction","isType","isOfType","isClass","test","substr","isCallable","isArray","isObject","isBoolean","isNumber","isString","isMap","isSet","isWeakMap","isWeakSet","isUndefined","isNull","isSymbol","isUsableImmutablePrimitive","typeOfX","isset","isEmptyList","isEmptyObject","isEmptyCollection","size","isEmpty","isOneOf","typeName","isFunctor","lookup","of","copy","out","slice","Symbol","Promise","searchObj","nsString","indexOf","parts","split","limit","ind","parent","node","assignDeep","propDescription","getOwnPropertyDescriptor","get","set","writable","includes","xs","lastIndexOf","isTruthy","isFalsy","alwaysTrue","alwaysFalse","equal","equalAll","i","aggregateArray","sliceFrom","startInd","sliceTo","toInd","sliceCopy","genericAscOrdering","lengths","lists","toShortest","listLengths","smallLen","Math","min","list","reduceUntil","pred","op","result","reduceUntilRight","arr","lastIndex","len","findIndexWhere","predicateFulfilled","findIndexWhereRight","findIndicesWhere","findWhere","elm","objUnion","obj1","obj2","objIntersect","objDifference","objComplement","log","console","bind","error","peek","pop","jsonClone","JSON","parse","stringify","toAssocList","toAssocListDeep","TypeConstraint","fromAssocList","OutType","fromAssocListDeep","toArray","compose","arg0","id","negateF","negateF2","negateF3","negateFN","until","predicate","typeInstance","fnOrError","symbolName","noop","normalizeStep","to","step","range","append","listAppend","head","last","tail","init","uncons","unconsr","item0","concatMap","foldableOfA","intersperse","between","lastInd","intercalate","xss","transpose","numLists","ind2","longestListLen","maximum","outLists","outList","subsequences","listLen","pow","entry","j","swapped","ind1","tmp","permutations","repeat","foldl","foldr","foldl1","foldr1","mapAccumL","zero","mapped","tuple","mapAccumR","iterate","lastX","replicate","cycle","unfoldr","resultTuple","findIndex","findIndices","elemIndex","foundInd","elemIndices","take","drop","splitAt","takeWhile","dropWhile","splitPoint","dropWhileEnd","span","breakOnList","at","find","partition","elem","notElem","isPrefixOf","xs1","xs2","limit1","limit2","isSuffixOf","isInfixOf","foundLen","isSubsequenceOf","lenXs1","group","groupBy","equalityOp","prevItem","predOp","inits","tails","stripPrefix","prefix","zip","arr1","arr2","a1","a2","zipN","trimmedLists","zip3","arr3","zip4","arr4","zip5","arr5","zipWith","zipWithN","lenOfTrimmed","zipWith3","xs3","zipWith4","xs4","zipWith5","xs5","unzip","unzipN","lenItem0","any","p","all","and","or","not","sum","product","sortBy","minimum","scanl","scanl1","scanr","scanr1","nub","nubBy","remove","removeBy","sort","sortOn","valueFn","decorated","a0","b0","orderingFn","insert","foundIndex","insertBy","currItem","anyOp","storedItem","removeFirstsBy","unionBy","alreadyAdded","union","intersect","intersectBy","list1","list2","difference","array1","array2","complement","arr0","arrays","typeRefsToStringOrError","defaultErrorMessageCall","tmplContext","contextName","valueName","expectedTypeName","foundTypeName","messageSuffix","isMultiTypeNames","typesCopy","typesToMatchCopy","_getErrorIfNotTypeThrower","errorMessageCall","typeChecker","ValueType","_getErrorIfNotTypesThrower","valueTypes","expectedTypeNames","matchFound","_errorIfNotType","_errorIfNotTypes","getErrorIfNotTypeThrower","getErrorIfNotTypesThrower","errorIfNotType","errorIfNotTypes","lines","words","unwords","unlines","lcaseFirst","toLowerCase","substring","ucaseFirst","toUpperCase","camelCase","pattern","str","classCase"],"mappings":"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"} \ No newline at end of file diff --git a/dist/iife/fjl.js b/dist/iife/fjl.js index d2ea35e2..900fad8c 100644 --- a/dist/iife/fjl.js +++ b/dist/iife/fjl.js @@ -2368,6 +2368,12 @@ var classCase = compose(ucaseFirst, camelCase); * @see http://hackage.haskell.org/package/base-4.10.0.0/docs/Data-List.html */ +/** + * @typedef {String|Function|ArrayBufferConstructor|ArrayConstructor|BooleanConstructor|MapConstructor|NumberConstructor|SetConstructor|WeakMapConstructor|WeakSetConstructor} TypeRef + * @description Type reference. Either actual type or type's name; E.g., `Type.name` + * Also note: Class cased names are use for values that do not have `name` properties; Namely: 'Null', 'NaN' and 'Undefined' (for their respective values respectively). + */ + exports.instanceOf = instanceOf; exports.hasOwnProperty = hasOwnProperty; exports.length = length; diff --git a/dist/iife/fjl.js.map b/dist/iife/fjl.js.map index 0acad8dc..7980fec7 100644 --- a/dist/iife/fjl.js.map +++ b/dist/iife/fjl.js.map @@ -1 +1 @@ -{"version":3,"file":"fjl.js","sources":["../../src/function/curry.js","../../src/utils.js","../../src/jsPlatform/array.js","../../src/jsPlatform/function.js","../../src/function/flip.js","../../src/jsPlatform/object.js","../../src/object/typeOf.js","../../src/object/is.js","../../src/object/lookup.js","../../src/object/of.js","../../src/object/copy.js","../../src/object/searchObj.js","../../src/object/assignDeep.js","../../src/jsPlatform/list.js","../../src/boolean.js","../../src/list/map.js","../../src/list/aggregation.js","../../src/list/utils.js","../../src/object/setTheory.js","../../src/object/console.js","../../src/object/jsonClone.js","../../src/object/assocList.js","../../src/object/toArray.js","../../src/object.js","../../src/function/compose.js","../../src/function/id.js","../../src/function/negate.js","../../src/function/until.js","../../src/function/fnOrError.js","../../src/function/noop.js","../../src/function.js","../../src/list/range.js","../../src/jsPlatform/string.js","../../src/jsPlatform.js","../../src/list.js","../../src/errorThrowing.js","../../src/string.js","../../src/fjl.js"],"sourcesContent":["/**\r\n * @author elydelacruz\r\n * @created 12/6/2016.\r\n * @memberOf function\r\n * @description \"Curry strict\" and \"curry arbitrarily\" functions (`curry`, `curryN`).\r\n */\r\n\r\n/**\r\n * @private\r\n * @type {string}\r\n */\r\nconst\r\n\r\n /**\r\n * Returns curried function.\r\n * @private\r\n * @param executeArity {Number}\r\n * @param unmetArityNum {Number}\r\n * @param fn {Function}\r\n * @param argsToCurry {...*}\r\n * @returns {Function} - Curried function.\r\n */\r\n returnCurried = (executeArity, unmetArityNum, fn, argsToCurry) => {\r\n switch (unmetArityNum) {\r\n case 1:\r\n /* eslint-disable */\r\n return function func(x) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 2:\r\n /* eslint-disable */\r\n return function func(a, b) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 3:\r\n /* eslint-disable */\r\n return function func(a, b, c) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 4:\r\n /* eslint-disable */\r\n return function func(a, b, c, d) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 5:\r\n /* eslint-disable */\r\n return function func(a, b, c, d, e) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n default:\r\n return (...args) => executeAsCurriedFunc(fn, executeArity, unmetArityNum, args, argsToCurry);\r\n }\r\n },\r\n\r\n /**\r\n * Returns curried function if unmetArity is not met else returns result of executing\r\n * final function.\r\n * @private\r\n * @param fn {Function}\r\n * @param executeArity {Number}\r\n * @param unmetArity {Number}\r\n * @param args {Array<*>}\r\n * @param argsToCurry {Array<*>}\r\n * @returns {Function|*} - Curried function or result of 'finally' executed function.\r\n */\r\n executeAsCurriedFunc = (fn, executeArity, unmetArity, args, argsToCurry) => {\r\n let concatedArgs = argsToCurry.concat(args),\r\n canBeCalled = (concatedArgs.length >= executeArity) || !executeArity,\r\n newExpectedArity = executeArity - concatedArgs.length;\r\n return !canBeCalled ?\r\n returnCurried(executeArity, newExpectedArity, fn, concatedArgs) :\r\n fn(...concatedArgs);\r\n }\r\n;\r\n\r\nexport const\r\n\r\n /**\r\n * Curries a function up to a given arity.\r\n * @function module:function.curryN\r\n * @param executeArity {Number}\r\n * @param fn {Function}\r\n * @param argsToCurry {...*}\r\n * @returns {Function}\r\n * @throws {Error} - When `fn` is not a function.\r\n */\r\n curryN = (executeArity, fn, ...argsToCurry) => {\r\n if (!fn || !(fn instanceof Function)) {\r\n throw new Error(`\\`curry*\\` functions expect first parameter to be of type \\`Function\\` though received ${fn}?`);\r\n }\r\n return returnCurried(executeArity, executeArity - argsToCurry.length, fn, argsToCurry);\r\n },\r\n\r\n /**\r\n * Curries a function based on it's defined arity (note: rest args param (`...rest`) are not counted in arity).\r\n * @function module:function.curry\r\n * @param fn {Function}\r\n * @param argsToCurry {...*}\r\n * @returns {Function}\r\n */\r\n curry = (fn, ...argsToCurry) => curryN((fn || {}).length, fn, ...argsToCurry),\r\n\r\n /**\r\n * Curries a function up to an arity of 2 (won't call function until 2 or more args).\r\n * @function module:function.curry2\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry2 = fn => curryN(2, fn),\r\n\r\n /**\r\n * Curries a function up to an arity of 3 (won't call function until 3 or more args).\r\n * @function module:function.curry3\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry3 = fn => curryN(3, fn),\r\n\r\n /**\r\n * Curries a function up to an arity of 4 (won't call function until 4 or more args).\r\n * @function module:function.curry4\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry4 = fn => curryN(4, fn),\r\n\r\n /**\r\n * Curries a function up to an arity of 5 (won't call function until 5 or more args).\r\n * @function module:function.curry5\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry5 = fn => curryN(5, fn);\r\n","/**\r\n * @module utils\r\n */\r\nimport {curry, curry2} from './function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a function that takes an argument and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakesOne\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakesOne = name => curry((arg, f) => f[name](arg)),\r\n\r\n /**\r\n * Returns a function that takes 2 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes2\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes2 = name => curry((arg1, arg2, f) => f[name](arg1, arg2)),\r\n\r\n /**\r\n * Returns a function that takes 3 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes3\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes3 = name => curry((arg1, arg2, arg3, f) => f[name](arg1, arg2, arg3)),\r\n\r\n /**\r\n * Returns a function that takes 4 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes4\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes4 = name => curry((arg1, arg2, arg3, arg4, f) => f[name](arg1, arg2, arg3, arg4)),\r\n\r\n /**\r\n * Returns a function that takes 5 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes5\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes5 = name => curry((arg1, arg2, arg3, arg4, arg5, f) => f[name](arg1, arg2, arg3, arg4, arg5)),\r\n\r\n /**\r\n * Returns a function that takes an object and one or more arguments on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakesOneOrMore\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakesOneOrMore = name => curry2((f, ...args) => f[name](...args))\r\n\r\n;\r\n","/**\r\n * Created by elyde on 7/20/2017.\r\n * Functional versions of common array methods (`map`, `filter`, etc.) (un-curried);\r\n * @module _jsPlatform_arrayOps\r\n * @private\r\n */\r\n\r\nimport {fPureTakesOne, fPureTakes2, fPureTakesOneOrMore} from '../utils';\r\n\r\nexport const\r\n\r\n /**\r\n * Array.prototype.reverse generator (generates a function that calls the prototype version or a\r\n * shimmed version if it doesn't exist).\r\n * @returns {Function}\r\n */\r\n defineReverse = () =>\r\n Array.prototype.reverse ? x => x.reverse() :\r\n x => x.reduceRight((agg, item) => {\r\n agg.push(item);\r\n return agg;\r\n }, []),\r\n\r\n /**\r\n * Maps a function to functor (list etc.).\r\n * @function module:_jsPlatform_array.map\r\n * @param fn {Function}\r\n * @param functor {Array|{map: {Function}}}\r\n * @returns {Array|{map: {Function}}}\r\n */\r\n map = fPureTakesOne('map'),\r\n\r\n /**\r\n * Filters a functor (list etc.) with passed in function.\r\n * @function module:_jsPlatform_array.filter\r\n * @param fn {Function}\r\n * @param functor {Array|{filter: {Function}}}\r\n * @returns {Array|{filter: {Function}}}\r\n */\r\n filter = fPureTakesOne('filter'),\r\n\r\n /**\r\n * Reduces a foldable (list etc.) with passed in function.\r\n * @function module:_jsPlatform_array.reduce\r\n * @param fn {Function}\r\n * @param functor {Array|{reduce: {Function}}}\r\n * @returns {Array|{reduce: {Function}}}\r\n */\r\n reduce = fPureTakes2('reduce'),\r\n\r\n /**\r\n * Reduces a foldable (list etc.) from the right with passed in function.\r\n * @function module:_jsPlatform_array.reduceRight\r\n * @param fn {Function}\r\n * @param functor {Array|{reduceRight: {Function}}}\r\n * @returns {Array|{reduceRight: {Function}}}\r\n */\r\n reduceRight = fPureTakes2('reduceRight'),\r\n\r\n /**\r\n * For each on functor (Array|Object|etc.).\r\n * @param fn {Function}\r\n * @param functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type of object you pass in unless it doesn't have a `forEach` method.\r\n * @throws {Error} - When passed in functor doesn't have a `forEach` method.\r\n */\r\n forEach = fPureTakesOne('forEach'),\r\n\r\n /**\r\n * Returns `true` if `fn` (predicate) returns true for at least one item\r\n * in functor else returns `false`.\r\n * @param fn {Function} - Predicate.\r\n * @param functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type passed.\r\n * @throws {Error} - When passed in object doesn't have a `some` method.\r\n */\r\n some = fPureTakesOne('some'),\r\n\r\n /**\r\n * Returns `true` if `fn` (predicate) returns true for all items in functor else returns `false`.\r\n * @param fn {Function} - Predicate.\r\n * @param functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type passed.\r\n * @throws {Error} - When passed in object doesn't have an `every` method.\r\n */\r\n every = fPureTakesOne('every'),\r\n\r\n /**\r\n * Array.prototype.join\r\n * @function module:listPrelude.join\r\n * @param separator {String|RegExp}\r\n * @param arr {Array}\r\n * @returns {String}\r\n */\r\n join = fPureTakesOne('join'),\r\n\r\n /**\r\n * Same as Array.prototype.push\r\n * @param item {*}\r\n * @param arr {Array}\r\n * @returns {Number}\r\n */\r\n push = fPureTakesOneOrMore('push'),\r\n\r\n /**\r\n * Reverses an list (shimmed if not exists).\r\n * @function module:listPrelude.reverse\r\n * @return {Array}\r\n */\r\n reverse = defineReverse();\r\n","import {curry, curry2} from '../function/curry';\r\n\r\n/**\r\n * Created by elydelacruz on 9/7/2017.\r\n * @memberOf function\r\n */\r\nexport const\r\n\r\n /**\r\n * Functional `apply` function (takes no context).\r\n * @function module:function.apply\r\n * @param fn {Function}\r\n * @param args {Array|*}\r\n * @returns {*}\r\n */\r\n apply = curry((fn, args) => fn.apply(null, args)),\r\n\r\n /**\r\n * Functional `call` function (takes no context).\r\n * @function module:function.call\r\n * @param fn {Function}\r\n * @param args {...*}\r\n * @returns {*}\r\n */\r\n call = curry2((fn, ...args) => fn.call(null, ...args));\r\n","import {reverse} from '../jsPlatform/array';\r\nimport {apply, call} from '../jsPlatform/function';\r\nimport {curry, curry2} from './curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a curried function requiring given functions arguments in reverse\r\n * (returned function expects 2 or more variables (curried at 2 or more args)).\r\n * @function module:function.flipN\r\n * @param fn {Function}\r\n * @returns {Function}\r\n * @curried\r\n */\r\n flipN = fn => curry2((...args) => apply(fn, reverse(args))),\r\n\r\n /**\r\n * Flips a function's first and second arguments and and returns a new function requiring said arguments in reverse.\r\n * @function module:function.flip\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip = fn => curry((b, a) => call(fn, a, b)),\r\n\r\n /**\r\n * Same as `flip` except returns a flipped function of arity 3.\r\n * @function module:function.flip3\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip3 = fn => curry((c, b, a) => call(fn, a, b, c)),\r\n\r\n /**\r\n * Same as `flip` except returns a flipped function of arity 4.\r\n * @function module:function.flip4\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip4 = fn => curry((d, c, b, a) => call(fn, a, b, c, d)),\r\n\r\n /**\r\n * Same as `flip` except returns a flipped function of arity 5.\r\n * @function module:function.flip5\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip5 = fn => curry((e, d, c, b, a) => call(fn, a, b, c, d, e));\r\n","/**\r\n * @memberOf object\r\n * @description Defines some of the platform methods for objects (the ones used within `fjl`).\r\n */\r\n\r\nimport {fPureTakesOne} from '../utils';\r\nimport {curry, curry2} from '../function/curry';\r\nimport {flip, flip3, flip4, flip5} from '../function/flip';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns whether constructor has derived object.\r\n * @function module:object.instanceOf\r\n * @param instanceConstructor {Function} - Constructor.\r\n * @param instance {*}\r\n * @instance {*}\r\n * @returns {Boolean}\r\n */\r\n instanceOf = curry((instanceConstructor, instance) =>\r\n instance instanceof instanceConstructor),\r\n\r\n /**\r\n * @function module:object.hasOwnProperty\r\n * @param propName {*}\r\n * @param typeInstance {*}\r\n * @returns {Boolean}\r\n * @deprecated - Use property directly instead.\r\n */\r\n hasOwnProperty = fPureTakesOne('hasOwnProperty'),\r\n\r\n /**\r\n * @function module:object.length\r\n * @param x {*}\r\n * @returns {Number}\r\n * @throws {Error} - Throws an error if value doesn't have a `length` property (\r\n * `null`, `undefined`, {Boolean}, Symbol, et. al.).\r\n */\r\n length = x => x.length,\r\n\r\n /**\r\n * Contains all the static functions from `Object` but curried and flipped;\r\n * @example\r\n * // E.g., `Object.defineProperties(obj, descriptor)` can now be used like\r\n * import {defineProperties} from 'fjl'\r\n * defineProperties(descriptor, someObj),\r\n * // Et. al.\r\n * @memberOf module:object\r\n * @type {{...Object}}\r\n */\r\n native = Object.getOwnPropertyNames(Object).reduce((agg, key) => {\r\n if (typeof Object[key] !== 'function') {\r\n return agg;\r\n }\r\n const operation = Object[key];\r\n switch (operation.length) {\r\n case 2:\r\n agg[key] = flip(operation);\r\n break;\r\n case 3:\r\n agg[key] = flip3(operation);\r\n break;\r\n case 4:\r\n agg[key] = flip4(operation);\r\n break;\r\n case 5:\r\n agg[key] = flip5(operation);\r\n break;\r\n default:\r\n agg[key] = Object[key];\r\n break;\r\n }\r\n return agg;\r\n }, {}),\r\n\r\n /**\r\n * Gets passed in object's own enumerable keys (same as `Object.keys`).\r\n * @function module:object.keys\r\n * @param obj {*}\r\n * @returns {Array}\r\n */\r\n {keys} = native,\r\n\r\n /**\r\n * Defined as `Object.assign` else is the same thing but shimmed.\r\n * @function module:object.assign\r\n * @param obj0 {Object}\r\n * @param objs {...{Object}}\r\n * @returns {Object}\r\n */\r\n assign = (() => Object.assign ?\r\n (obj0, ...objs) => Object.assign(obj0, ...objs) :\r\n curry2((obj0, ...objs) => objs.reduce((topAgg, obj) => {\r\n return Object.keys(obj).reduce((agg, key) => {\r\n agg[key] = obj[key];\r\n return agg;\r\n }, topAgg);\r\n }, obj0))\r\n )();\r\n","/**\r\n * Created by elyde on 12/18/2016.\r\n * @memberOf object\r\n */\r\nconst _Number = Number.name,\r\n _NaN = 'NaN',\r\n _Null = 'Null',\r\n _Undefined = 'Undefined';\r\n\r\n/**\r\n * Returns the constructor/class/type name of a value.\r\n * @note Returns 'NaN' if value is of type `Number` and value is `isNaN`.\r\n * @note Returns 'Undefined' if value is `undefined`\r\n * @note Returns 'Null' if value is `null`\r\n * For values that have no concrete constructors and/or casters\r\n * (null, NaN, and undefined) we returned normalized names for them ('Null', 'NaN', 'Number')\r\n * @function module:object.typeOf\r\n * @param value {*}\r\n * @returns {string} - Constructor's name or derived name (in the case of `null`, `undefined`, or `NaN` (whose\r\n * normalized names are 'Null', 'Undefined', 'NaN' respectively).\r\n */\r\nexport function typeOf (value) {\r\n let retVal;\r\n if (value === undefined) {\r\n retVal = _Undefined;\r\n }\r\n else if (value === null) {\r\n retVal = _Null;\r\n }\r\n else {\r\n let constructorName = (value).constructor.name;\r\n retVal = constructorName === _Number && isNaN(value) ?\r\n _NaN : constructorName;\r\n }\r\n return retVal;\r\n}\r\n","/**\r\n * Created by elyde on 12/18/2016.\r\n * @memberOf object\r\n */\r\n\r\nimport {typeOf} from './typeOf';\r\nimport {instanceOf, length, keys} from '../jsPlatform/object';\r\nimport {curry} from '../function/curry';\r\n\r\nlet _String = String.name,\r\n _Number = Number.name,\r\n _Object = Object.name,\r\n _Boolean = Boolean.name,\r\n _Function = Function.name,\r\n _Array = Array.name,\r\n _Symbol = 'Symbol',\r\n _Map = 'Map',\r\n _Set = 'Set',\r\n _WeakMap = 'WeakMap',\r\n _WeakSet = 'WeakSet',\r\n _Null = 'Null',\r\n _Undefined = 'Undefined',\r\n _NaN = 'NaN';\r\n\r\nexport const\r\n\r\n /**\r\n * Resolves/normalizes a type name from either a string or a constructor.\r\n * @function module:object.toTypeRef\r\n * @param type {Function|String} - String or function representing a type.\r\n * @returns {String}\r\n * @todo write tests for this function.\r\n */\r\n toTypeRef = type => {\r\n if (!type) {\r\n return typeOf(type);\r\n }\r\n else if (type.constructor === String || (type instanceof Function)) {\r\n return type;\r\n }\r\n return typeOf(type);\r\n },\r\n\r\n /**\r\n * Returns an array of type refs from possible type refs (converts null, undefined, NaN, and other values into\r\n * type refs (either constructor name or constructor name based on whether value(s) is a string, a constructor, or not).\r\n * @function module:object.toTypeRefs\r\n * @param types {...(TypeRef|*)}\r\n * @returns {Array}\r\n * @todo Ensure tests are written for this function.\r\n */\r\n toTypeRefs = (...types) => types.map(toTypeRef),\r\n\r\n /**\r\n * Returns possible Type's TypeRef name.\r\n * @function module:object.toTypeRefName\r\n * @param Type {(TypeRef|*)}\r\n * @returns {String}\r\n * @todo Ensure tests are written for this function.\r\n */\r\n toTypeRefName = Type => {\r\n const ref = toTypeRef(Type);\r\n return ref instanceof Function ? ref.name : ref;\r\n },\r\n\r\n /**\r\n * Returns possible Types' TypeRef names.\r\n * @function module:object.toTypeRefNames\r\n * @param types {...(TypeRef|*)}\r\n * @returns {String[]}\r\n * @todo Ensure tests are written for this function.\r\n */\r\n toTypeRefNames = (...types) => types.map(toTypeRefName),\r\n\r\n /**\r\n * Returns whether a value is a function or not.\r\n * @function module:object.isFunction\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isFunction = instanceOf(Function),\r\n\r\n /**\r\n * Strict type checker. Checks if given value is a direct instance of given type; E.g.,\r\n * @example\r\n * isType(String, 'abcdefg') === true // true\r\n * isType(String.name, 'abcdefg') === true\r\n * isType(Number, NaN) === false\r\n * isType(Number, 99) === true\r\n * isType('Null', 99) === false // though, for `null` and `undefined` checks\r\n * // @see `isset`, in this module, instead\r\n * isType('Undefined', undefined) === true // true\r\n *\r\n * @note Useful where absolute types, or some semblance thereof, are required.\r\n * @function module:object.isType\r\n * @param type {Function|ObjectConstructor|String} - Constructor or constructor name\r\n * @param obj {*}\r\n * @return {Boolean}\r\n */\r\n isType = curry((type, obj) => typeOf(obj) === toTypeRefName(type)),\r\n\r\n /**\r\n * Loose type checker; E.g., If `type` is not a constructor, but a constructor name, does a type check on\r\n * constructor names, else if first check fails and `type` is a constructor, performs an `instanceof` check\r\n * on value with constructor.\r\n * @note Use care when checking for `Array` and/or `Object` since the both are considered objects by `instanceof` checker.\r\n * @note For `null` and `undefined` their class cased names can be used for type checks\r\n * `isOfType('Null', null) === true (passes strict type check)` (or better yet `isset` can be used).\r\n * @throwsafe - Doesn't throw on `null` or `undefined` `obj` values.\r\n * @example\r\n * isOfType(Number, 99) === true // true (passes strict type check (numbers are not instances of `Number`\r\n * // constructor)\r\n * isOfType('Number', 99) === true // true (passes strict type check)\r\n * isOfType(Number, NaN) === true // true. (passes instance of check)\r\n * // If you want \"true\" strict type checking use `isType`\r\n * isOfType(Object, []) === true // true (passes instance of check)\r\n * isOfType(Array, []) === true // true (passes instance of check)\r\n * isOfType(Object, {}) === true // true (passes instance of check)\r\n * isOfType(Object.name, {}) === true // true (Passes strict type check)\r\n * class Abc extends String {}\r\n * isOfType(String, new Abc('abcd')) // true (passes instanceof check)\r\n *\r\n * @function module:object.isOfType\r\n * @param type {Function|String} - Type reference (constructor or `constructor.name`).\r\n * @param x {*} - Value to check.\r\n * @returns {Boolean}\r\n */\r\n isOfType = curry((type, x) => isType(type, x) || instanceOf(type, x)),\r\n\r\n /**\r\n * Checks if `value` is an es2015 `class`.\r\n * @function module:object.isClass\r\n * @param x {*}\r\n * @returns {boolean}\r\n */\r\n isClass = x => x && /^\\s{0,3}class\\s{1,3}/.test((x + '').substr(0, 10)),\r\n\r\n /**\r\n * Returns a boolean depicting whether a value is callable or not.\r\n * @function module:object.isCallable\r\n * @tentative\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isCallable = x => isFunction(x) && !isClass(x),\r\n\r\n /**\r\n * Checks if value is an array (same as `Array.isArray`).\r\n * @function module:object.isArray\r\n * @param value {*}\r\n * @returns {boolean}\r\n */\r\n {isArray} = Array,\r\n\r\n /**\r\n * Checks whether value is an object or not.\r\n * @function module:object.isObject\r\n * @param value\r\n * @returns {Boolean}\r\n */\r\n isObject = isType(_Object),\r\n\r\n /**\r\n * Checks if value is a boolean.\r\n * @function module:object.isBoolean\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isBoolean = isType(_Boolean),\r\n\r\n /**\r\n * Checks if value is a valid number (also checks if isNaN so that you don't have to).\r\n * @function module:object.isNumber\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isNumber = isType(_Number),\r\n\r\n /**\r\n * Checks whether value is a string or not.\r\n * @function module:object.isString\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isString = isType(_String),\r\n\r\n /**\r\n * Checks whether value is of `Map` or not.\r\n * @function module:object.isMap\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isMap = isType(_Map),\r\n\r\n /**\r\n * Checks whether value is of `Set` or not.\r\n * @function module:object.isSet\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isSet = isType(_Set),\r\n\r\n /**\r\n * Checks whether value is of `WeakMap` or not.\r\n * @function module:object.isWeakMap\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isWeakMap =isType(_WeakMap),\r\n\r\n /**\r\n * Checks whether value is of `WeakSet` or not.\r\n * @function module:object.isWeakSet\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isWeakSet = isType(_WeakSet),\r\n\r\n /**\r\n * Checks if value is undefined.\r\n * @function module:object.isUndefined\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isUndefined = isType(_Undefined),\r\n\r\n /**\r\n * Checks if value is null.\r\n * @function module:object.isNull\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isNull = isType(_Null),\r\n\r\n /**\r\n * Checks if value is a `Symbol`.\r\n * @function module:object.isSymbol\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isSymbol = isType(_Symbol),\r\n\r\n /**\r\n * Checks if given `x` is set and of one of\r\n * [String, Boolean, Number, Symbol] (null and undefined are immutable\r\n * but are not \"usable\" (usually not what we want to operate on).\r\n * @function module:object.isUsableImmutablePrimitive\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isUsableImmutablePrimitive = x => {\r\n const typeOfX = typeOf(x);\r\n return isset(x) &&\r\n [_String, _Number, _Boolean, _Symbol]\r\n .some(Type => Type === typeOfX);\r\n },\r\n\r\n /**\r\n * Checks if !length.\r\n * @function module:object.isEmptyList\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isEmptyList = x => !length(x),\r\n\r\n /**\r\n * Checks if object has own properties/enumerable-props or not.\r\n * @function module:object.isEmptyObject\r\n * @param obj {*}\r\n * @returns {Boolean}\r\n */\r\n isEmptyObject = obj => isEmptyList(keys(obj)),\r\n\r\n /**\r\n * Checks if collection is empty or not (Map, WeakMap, WeakSet, Set etc.).\r\n * @function module:object.isEmptyCollection\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isEmptyCollection = x => x.size === 0,\r\n\r\n /**\r\n * Checks to see if passed in value is empty; I.e.,\r\n * check for one of '', 0, `null`, `undefined`, `false`, empty array, empty object, empty function (zero arity),\r\n * or empty collection (es6 Map, Set, WeakMap, or WeakSet etc. (`!value.size`);\r\n * @function module:object.isEmpty\r\n * @param value {*} - Value to check.\r\n * @returns {Boolean}\r\n */\r\n isEmpty = value => {\r\n if (!value) { // if '', 0, `null`, `undefined`, or `false` then is empty\r\n return true;\r\n }\r\n switch (typeOf(value)) {\r\n case _Array:\r\n case _Function:\r\n return !value.length;\r\n case _Number: // zero and NaN checks happened above so `if number` then it's 'not-an-empty-number' (lol)\r\n return false;\r\n case _Object:\r\n return !keys(value).length;\r\n case _Map:\r\n case _Set:\r\n case _WeakSet:\r\n case _WeakMap:\r\n return !value.size;\r\n case _NaN:\r\n return true;\r\n default:\r\n return !value;\r\n }\r\n },\r\n\r\n /**\r\n * Returns whether passed in values is defined and not null or not.\r\n * @function module:object.isset\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isset = x => x !== null && x !== undefined,\r\n\r\n /**\r\n * Checks to see if `x` is of one of the given type refs.\r\n * @function object.isOneOf\r\n * @param x {*}\r\n * @param types {...(TypeRef|*)}\r\n * @returns {boolean}\r\n * @todo write tests for this function.\r\n */\r\n isOneOf = (x, ...types) => {\r\n const typeName = typeOf(x);\r\n return toTypeRefNames(types).some(name => typeName === name);\r\n },\r\n\r\n isFunctor = x => x && x.map && instanceOf(Function, x.map)\r\n\r\n;\r\n","/**\r\n * @memberOf object\r\n */\r\n\r\nimport {isset} from './is';\r\nimport {curry} from '../function/curry';\r\n\r\n/**\r\n * Looks up property and returns it's value; Else `undefined`.\r\n * Method is null safe (will not throw on `null` or `undefined`).\r\n * @function module:object.lookup\r\n * @param key {String} - Key to search on `obj`\r\n * @param obj {Object} - Object to search `name` on.\r\n * @returns {*}\r\n */\r\nexport const lookup = curry((key, obj) => isset(obj) ? obj[key] : undefined);\r\n","import {isFunction, isset, isUsableImmutablePrimitive} from './is';\r\nimport {apply} from '../jsPlatform/function';\r\n\r\n/**\r\n * Creates a value `of` given type; Checks for one of the following construction strategies (in order listed):\r\n * @example\r\n * // - If exists `(value).constructor.of` uses this.\r\n * // - If value is of one String, Boolean, Symbol, or Number types calls it's\r\n * // constructor as a function (in cast form; E.g., `constructor(...args)` )\r\n * // - Else if constructor is a function, thus far, then calls constructor using\r\n * // the `new` keyword (with any passed in args).\r\n\r\n * @function module:object.of\r\n * @param x {*} - Value to derive returned value's type from.\r\n * @param [args] {...*} - Any args to pass in to matched construction strategy.\r\n * @returns {*|undefined} - New value of given value's type else `undefined`.\r\n */\r\nexport const of = (x, ...args) => {\r\n if (!isset(x)) { return undefined; }\r\n const constructor = x.constructor;\r\n if (constructor.hasOwnProperty('of')) {\r\n return apply(constructor.of, args);\r\n }\r\n else if (isUsableImmutablePrimitive(x)) {\r\n return apply(constructor, args);\r\n }\r\n else if (isFunction(constructor)) {\r\n return new constructor(...args);\r\n }\r\n return undefined;\r\n};\r\n","import {typeOf} from './typeOf';\r\nimport {of} from './of';\r\n\r\nexport const\r\n\r\n /**\r\n * Make a copy of a value or optionally copy incoming value onto an outgoing value (second parameter).\r\n * @note If incoming thing is an immmutable primitive (string, number, symbol, null, undefined, boolean)\r\n * it is returned as is.\r\n * @function module:object.copy\r\n * @param x {*} - Thing to copy.\r\n * @param [out = undefined] {*} - Optional value to copy on to. Not required.\r\n * @returns {*} - Copied thing or optionally outgoing value copied onto.\r\n */\r\n copy = (x, out) => {\r\n // if `null`, `undefined`, `''`, `0`, `false` return\r\n if (!x) { return x; }\r\n switch (typeOf(x)) {\r\n case Array.name:\r\n return !out ? x.slice(0) : Object.assign(out, x);\r\n\r\n // If immutable primitive, return it\r\n case Symbol.name:\r\n case Boolean.name:\r\n case String.name:\r\n case Number.name:\r\n case Promise.name:\r\n case Function.name:\r\n case 'NaN':\r\n case 'Null':\r\n case 'Undefined':\r\n return x;\r\n\r\n case 'Map':\r\n case 'Set':\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n return new x.constructor(Array.from(x));\r\n\r\n // Else make copy\r\n default:\r\n return Object.assign(!out ? of(x) : out, x);\r\n }\r\n }\r\n;\r\n\r\nexport default copy;\r\n","import {isset} from './is';\r\nimport {curry} from '../function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Gives you value at key/namespace-key within `obj`; E.g.,\r\n * searchObj('all.your.base', {all: {your: {base: 99}}}) === 99 // `true`\r\n * @note If key is unreachable (undefined) returns `undefined`.\r\n * Useful in cases where we do not want to check each key along the way before getting/checking value; E.g.,\r\n * @example\r\n * ```\r\n * if (obj && obj.all && obj.all.your && obj.all.your.base) {\r\n * // Thing we want to do\r\n * }\r\n *\r\n * // So with our function becomes\r\n * if (searchObj('all.your.base', obj)) {\r\n * // Thing we want to do\r\n * }\r\n * ```\r\n * @function module:object.searchObj\r\n * @param nsString {String}\r\n * @param obj {*}\r\n * @returns {*}\r\n */\r\n searchObj = curry((nsString, obj) => {\r\n if (!obj) { return obj; }\r\n if (nsString.indexOf('.') === -1) {\r\n return obj[nsString];\r\n }\r\n const parts = nsString.split('.'),\r\n limit = parts.length;\r\n let ind = 0,\r\n parent = obj;\r\n for (; ind < limit; ind += 1) {\r\n const node = parent[parts[ind]];\r\n if (!isset(node)) {\r\n return node;\r\n }\r\n parent = node;\r\n }\r\n return parent;\r\n })\r\n;\r\n","\r\nimport {isObject} from './is';\r\nimport {keys} from '../jsPlatform/object';\r\nimport {curry2} from '../function/curry';\r\n\r\nexport const\r\n /**\r\n * Merges all objects down into one (takes two or more args).\r\n * @function module:object.assignDeep\r\n * @param obj0 {Object}\r\n * @param [objs] {...{Object}} - One or more objects to merge onto `obj0`.\r\n * @returns {Object}\r\n */\r\n assignDeep = curry2((obj0, ...objs) =>\r\n !obj0 ? obj0 : objs.reduce((topAgg, obj) =>\r\n !obj ? topAgg : keys(obj).reduce((agg, key) => {\r\n let propDescription = Object.getOwnPropertyDescriptor(agg, key);\r\n // If property is not writable move to next item in collection\r\n if (agg.hasOwnProperty(key) && propDescription &&\r\n !(propDescription.get && propDescription.set) &&\r\n !propDescription.writable) {\r\n return agg;\r\n }\r\n if (isObject(agg[key]) && isObject(obj[key])) {\r\n assignDeep(agg[key], obj[key]);\r\n }\r\n else { agg[key] = obj[key]; }\r\n return agg;\r\n }, topAgg)\r\n , obj0));\r\n","/**\r\n * List operations that overlap (apart from globally overlapping props and functions like `length`)\r\n * on both strings and arrays.\r\n * @memberOf list\r\n */\r\n\r\nimport {fPureTakesOne, fPureTakes2, fPureTakesOneOrMore} from '../utils';\r\n\r\nexport const\r\n\r\n /**\r\n * Concats/appends all functors onto the end of first functor.\r\n * Note: functors passed in after the first one must be of the same type.\r\n * @function module:list.concat\r\n * @param functor {Array|Object|*}\r\n * @param ...functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type passed.\r\n * @throws {Error} - When passed in object doesn't have an `every` method.\r\n */\r\n concat = fPureTakesOneOrMore('concat'),\r\n\r\n /**\r\n * Same as Array.prototype.slice\r\n * @function module:list.slice\r\n * @param separator {String|RegExp}\r\n * @param arr{Array}\r\n * @returns {Array}\r\n */\r\n slice = fPureTakes2('slice'),\r\n\r\n /**\r\n * `Array.prototype.includes` or shim.\r\n * @function module:list.includes\r\n * @param value {*}\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n includes = (() => 'includes' in Array.prototype ?\r\n fPureTakesOne('includes') :\r\n (value, xs) => xs.indexOf(value) > -1)(),\r\n\r\n /**\r\n * Searches list/list-like for given element `x`.\r\n * @function module:list.indexOf\r\n * @param x {*} - Element to search for.\r\n * @param xs {Array|String|*} - list or list like to look in.\r\n * @returns {Number} - `-1` if element not found else index at which it is found.\r\n */\r\n indexOf = fPureTakesOne('indexOf'),\r\n\r\n /**\r\n * Last index of (`Array.prototype.lastIndexOf`).\r\n * @function module:list.lastIndexOf\r\n * @param x {*} - Element to search for.\r\n * @param xs {Array|String|*} - list or list like to look in.\r\n * @returns {Number} - `-1` if element not found else index at which it is found.\r\n */\r\n lastIndexOf = fPureTakesOne('lastIndexOf')\r\n\r\n;\r\n","/**\r\n * @module boolean\r\n * @description Contains functional version of 'always-true', 'always-false', 'is-truthy', and 'is-falsy'.\r\n */\r\nimport {curry, curry2} from './function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns whether `value` is 'truthy' or not\r\n * @function module:boolean.isTruthy\r\n * @param value\r\n * @returns {Boolean}\r\n */\r\n isTruthy = value => !!value,\r\n\r\n /**\r\n * Returns whether `value` is 'falsy' or not\r\n * @function module:boolean.isFalsy\r\n * @param value\r\n * @returns {Boolean}\r\n */\r\n isFalsy = value => !value,\r\n\r\n /**\r\n * Returns `true`.\r\n * @function module:boolean.alwaysTrue\r\n * @returns {Boolean}\r\n */\r\n alwaysTrue = () => true,\r\n\r\n /**\r\n * Returns `false`.\r\n * @function module:boolean.alwaysFalse\r\n * @returns {Boolean}\r\n */\r\n alwaysFalse = () => false,\r\n\r\n /**\r\n * Equality operator.\r\n * @function module:boolean.equal\r\n * @param a {*}\r\n * @param b {*}\r\n * @returns {boolean}\r\n */\r\n equal = curry((a, b) => a === b),\r\n\r\n /**\r\n * Equality operator for all.\r\n * @function module:boolean.equalAll\r\n * @param a {*} - Item `0`.\r\n * @param args {...*} - Others\r\n * @returns {boolean}\r\n */\r\n equalAll = curry2((a, ...args) => args.every(b => equal(a, b)))\r\n\r\n;\r\n","import {length} from '../jsPlatform/object';\r\nimport {curry} from '../function/curry';\r\nimport {typeOf} from '../object/typeOf';\r\nimport {of} from '../object/of';\r\nimport {isFunctor, isset} from '../object/is';\r\n\r\n/**\r\n * Maps a function onto a List (string or array) or a functor (value containing a map method).\r\n * @function module:list.map\r\n * @param fn {Function} - Function to map on given value.\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\nconst map = curry((fn, xs) => {\r\n if (!isset(xs)) { return xs; }\r\n let out = of(xs),\r\n limit,\r\n i = 0;\r\n switch (typeOf(xs)) {\r\n case 'Array':\r\n limit = length(xs);\r\n if (!limit) { return out; }\r\n for (; i < limit; i += 1) {\r\n out.push(fn(xs[i], i, xs));\r\n }\r\n return out;\r\n case 'String':\r\n limit = length(xs);\r\n if (!xs) { return out; }\r\n for (; i < limit; i += 1) {\r\n out += fn(xs[i], i, xs);\r\n }\r\n return out;\r\n default:\r\n if (isFunctor(xs)) { return xs.map(fn); }\r\n\r\n // Other objects\r\n return Object.keys(xs).reduce((agg, key) => {\r\n out[key] = fn(xs[key], key, xs);\r\n return out;\r\n }, out);\r\n }\r\n});\r\n\r\nexport default map;\r\n","\r\nexport const\r\n\r\n /**\r\n * Pushes incoming `item` onto given array and returns said array.\r\n * @private\r\n * @param agg {Array}\r\n * @param item {*}\r\n * @returns {Array}\r\n */\r\n aggregateArray = (agg, item) => {\r\n agg.push(item);\r\n return agg;\r\n }\r\n\r\n;\r\n","/**\r\n * List operator utils module.\r\n * @module listUtils\r\n */\r\nimport {apply} from '../jsPlatform/function'; // un-curried version\r\nimport {slice} from '../jsPlatform/list'; // un-curried version good for both strings and arrays\r\nimport {length} from '../jsPlatform/object';\r\nimport {alwaysFalse} from '../boolean';\r\nimport map from './map';\r\nimport {curry, curry2} from '../function/curry';\r\n\r\nexport * from './aggregation';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a slice of the given list from `startInd` to the end of the list.\r\n * @function module:listUtils.sliceFrom\r\n * @param startInd {Number}\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sliceFrom = curry((startInd, xs) => slice(startInd, undefined, xs)),\r\n\r\n /**\r\n * Slices from index `0` to given index.\r\n * @function module:listUtils.sliceTo\r\n * @param toInd {Number}\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sliceTo = curry((toInd, xs) => slice(0, toInd, xs)),\r\n\r\n /**\r\n * Slices a copy of list.\r\n * @function listUtils.sliceCopy\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sliceCopy = sliceFrom(0),\r\n\r\n /**\r\n * Generic 'ascending order' ordering function (use by the likes of `list.sort` etc.)\r\n * @function module:listUtils.genericAscOrdering\r\n * @param a {*}\r\n * @param b {*}\r\n * @returns {number}\r\n */\r\n genericAscOrdering = curry((a, b) => {\r\n if (a > b) { return 1; }\r\n else if (a < b) { return -1; }\r\n return 0;\r\n }),\r\n\r\n /**\r\n * Returns length of all passed lists in list.\r\n * @function module:listUtils.lengths\r\n * @param lists ...{Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n lengths = curry2((...lists) => map(length, lists)),\r\n\r\n /**\r\n * Returns a list of lists trimmed to the shortest length in given list of lists. @background This method is used by the `zip*` functions to achieve their\r\n * 'slice to smallest' functionality.\r\n * @function module:listUtils.toShortest\r\n * @param lists {...(Array|String|*)}\r\n * @returns {Array|String|*}\r\n */\r\n toShortest = curry2((...lists) => {\r\n const listLengths = apply(lengths, lists),\r\n smallLen = Math.min.apply(Math, listLengths);\r\n return map((list, ind) => listLengths[ind] > smallLen ?\r\n sliceTo(smallLen, list) : sliceCopy(list), lists);\r\n }),\r\n\r\n /**\r\n * Reduces until predicate.\r\n * @function module:listUtils.reduceUntil\r\n * @param pred {Function} - `(item, index, list) => Boolean(...)`\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduceUntil = curry((pred, op, agg, xs) => {\r\n const limit = length(xs);\r\n if (!limit) { return agg; }\r\n let ind = 0,\r\n result = agg;\r\n for (; ind < limit; ind++) {\r\n if (pred(xs[ind], ind, xs)) { break; }\r\n result = op(result, xs[ind], ind, xs);\r\n }\r\n return result;\r\n }),\r\n\r\n /**\r\n * Reduces until predicate (from right to left).\r\n * @function module:listUtils.reduceUntilRight\r\n * @param pred {Function} - `(item, index, list) => Boolean(...)`\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduceUntilRight = curry((pred, op, agg, arr) => {\r\n const limit = length(arr);\r\n if (!limit) { return agg; }\r\n let ind = limit - 1,\r\n result = agg;\r\n for (; ind >= 0; ind--) {\r\n if (pred(arr[ind], ind, arr)) { break; }\r\n result = op(result, arr[ind], ind, arr);\r\n }\r\n return result;\r\n }),\r\n\r\n /**\r\n * Reduces a list with given operation (`op`) function.\r\n * @function module:listUtils.reduce\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduce = reduceUntil(alwaysFalse),\r\n\r\n /**\r\n * Reduces a list with given operation (`op`) function (from right-to-left).\r\n * @function module:listUtils.reduceRight\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduceRight = reduceUntilRight(alwaysFalse),\r\n\r\n /**\r\n * Gets last index of a list/list-like (Array|String|Function etc.).\r\n * @function module:listUtils.lastIndex\r\n * @param x {Array|String|*} - list like or list.\r\n * @returns {Number} - `-1` if no element found.\r\n */\r\n lastIndex = x => { const len = length(x); return len ? len - 1 : 0; },\r\n\r\n /**\r\n * Finds index in string or list.\r\n * @function module:listUtils.findIndexWhere\r\n * @param pred {Function} - Predicate.\r\n * @param arr {Array|String}\r\n * @returns {Number} - `-1` if predicate not matched else `index` found\r\n */\r\n findIndexWhere = curry((pred, arr) => {\r\n let ind = 0;\r\n const limit = length(arr);\r\n for (; ind < limit; ind += 1) {\r\n const predicateFulfilled = !!pred(arr[ind], ind, arr);\r\n if (predicateFulfilled) {\r\n return ind;\r\n }\r\n }\r\n return -1;\r\n }),\r\n\r\n /**\r\n * Finds index in list from right to left.\r\n * @function module:listUtils.findIndexWhereRight\r\n * @param pred {Function} - Predicate.\r\n * @param arr {Array|String}\r\n * @returns {Number} - `-1` if predicate not matched else `index` found\r\n */\r\n findIndexWhereRight = curry((pred, arr) => {\r\n let ind = length(arr) - 1;\r\n for (; ind >= 0; ind -= 1) {\r\n const predicateFulfilled = !!pred(arr[ind], ind, arr);\r\n if (predicateFulfilled) {\r\n return ind;\r\n }\r\n }\r\n return -1;\r\n }),\r\n\r\n /**\r\n * @function module:listUtils.findIndicesWhere\r\n * @param pred {Function}\r\n * @param xs {Array|String|*} - list or list like.\r\n * @returns {Array|undefined}\r\n */\r\n findIndicesWhere = curry((pred, xs) => {\r\n const limit = length(xs);\r\n let ind = 0,\r\n out = [];\r\n for (; ind < limit; ind++) {\r\n if (pred(xs[ind], ind, xs)) { out.push(ind); }\r\n }\r\n return out.length ? out : undefined;\r\n }),\r\n\r\n /**\r\n * @function module:listUtils.findWhere\r\n * @param pred {Function}\r\n * @param xs {Array|String|*} - list or list like.\r\n * @returns {*}\r\n */\r\n findWhere = curry((pred, xs) => {\r\n let ind = 0,\r\n limit = length(xs);\r\n if (!limit) { return; }\r\n for (; ind < limit; ind++) {\r\n let elm = xs[ind];\r\n if (pred(elm, ind, xs)) { return elm; }\r\n }\r\n })\r\n\r\n;\r\n","import {assignDeep} from './assignDeep';\r\nimport {keys} from '../jsPlatform/object';\r\nimport {reduce} from '../list/utils';\r\nimport {curry, curry2} from '../function/curry';\r\n\r\nexport const\r\n\r\n objUnion = curry((obj1, obj2) => assignDeep(obj1, obj2)),\r\n\r\n objIntersect = curry((obj1, obj2) => reduce((agg, key) => {\r\n if (obj2.hasOwnProperty(key)) {\r\n agg[key] = obj2[key];\r\n }\r\n return agg;\r\n }, {}, keys(obj1))),\r\n\r\n objDifference = curry((obj1, obj2) => reduce((agg, key) => {\r\n if (!obj2.hasOwnProperty(key)) {\r\n agg[key] = obj1[key];\r\n }\r\n return agg;\r\n }, {}, keys(obj1))),\r\n\r\n objComplement = curry2((obj0, ...objs) => reduce((agg, obj) =>\r\n assignDeep(agg, objDifference(obj, obj0)), {}, objs));\r\n","/**\r\n * @module console\r\n * @description Console exports.\r\n */\r\nexport const\r\n\r\n /**\r\n * `Console.log` method.\r\n * @function module:console.log\r\n * @params args {...*}\r\n * @returns {void}\r\n */\r\n log = console.log.bind(console),\r\n\r\n /**\r\n * `Console.error` method.\r\n * @function module:console.error\r\n * @params args {...*}\r\n * @returns {void}\r\n */\r\n error = console.error.bind(console),\r\n\r\n /**\r\n * Peeks (console.log) at incoming value(s) and returns the last value.\r\n * @function module:console.peek\r\n * @param args {...*}\r\n * @returns {*} Last given value (if one or more values) else first value.\r\n */\r\n peek = (...args) => (log(...args), args.pop())\r\n\r\n;\r\n","export const\r\n\r\n /**\r\n * Clones and object or array using `JSON.parse(JSON.stringify(...))` pattern.\r\n * @function module:object.jsonClone\r\n * @param x {*}\r\n * @returns {*}\r\n */\r\n jsonClone = x => JSON.parse(JSON.stringify(x))\r\n\r\n;\r\n","import {isArray, isType} from './is';\r\nimport {keys} from '../jsPlatform/object';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns an associated list from given object.\r\n * @note Useful for working with plain javascript objects.\r\n * @function module:object.toAssocList\r\n * @param obj {(Object|Array|*)}\r\n * @returns {Array.<*, *>}\r\n */\r\n toAssocList = obj => keys(obj).map(key => [key, obj[key]]),\r\n\r\n /**\r\n * Returns an associated list from given object (deeply (on incoming object's type)).\r\n * @note Does deep conversion on all values of passed in type's type.\r\n * @function module:object.toAssocListDeep\r\n * @param obj {*}\r\n * @param [TypeConstraint = Object] {(Constructor|Function)} - Type constraint to convert on.\r\n * @returns {*}\r\n */\r\n toAssocListDeep = (obj, TypeConstraint = Object) => keys(obj).map(key =>\r\n TypeConstraint && isType(TypeConstraint, obj[key]) ?\r\n [key, toAssocListDeep(obj[key], TypeConstraint)] :\r\n [key, obj[key]]\r\n ),\r\n\r\n /**\r\n * From associated list to object.\r\n * @function module:object.fromAssocList\r\n * @param xs {Array.} - Associated list.\r\n * @param [OutType = Object] {Constructor|Function} - Output type. Default `Object`.\r\n * @returns {*} - Default is `Object`\r\n */\r\n fromAssocList = (xs, OutType = Object) => xs.reduce((agg, [key, value]) => {\r\n agg[key] = value;\r\n return agg;\r\n }, new OutType()),\r\n\r\n /**\r\n * From associated list to object (deep conversion on associative lists (array of 2 value arrays)).\r\n * @note Considers array of arrays associated lists.\r\n * @function module:object.fromAssocListDeep\r\n * @param xs {Array.} - Associated list.\r\n * @param [OutType = Object] {Constructor|Function} - Output type. Default `Object`.\r\n * @returns {*} - Default is `Object`\r\n */\r\n fromAssocListDeep = (xs, OutType = Object) => xs.reduce((agg, [key, value]) => {\r\n if (isArray(value) && isArray(value[0]) && value[0].length === 2) {\r\n agg[key] = fromAssocListDeep(value, OutType);\r\n return agg;\r\n }\r\n agg[key] = value;\r\n return agg;\r\n }, new OutType())\r\n;\r\n","import {typeOf} from './typeOf';\r\nimport {toAssocList} from './assocList';\r\n\r\nexport const\r\n\r\n /**\r\n * Converts incoming value to an array.\r\n * @note For `WeakMap`, `WeakSet`, `Map` and `Set` result is the same as calling `Array.from` on such.\r\n * @note For `null`, `undefined`, `NaN`, `Number{}`, `Symbol{}`, `Boolean{}` returns an empty array.\r\n * @note Method does a shallow conversion;\r\n * @function module:object.toArray\r\n * @param x {*} - Thing to convert from.\r\n * @returns {Array}\r\n */\r\n toArray = x => {\r\n switch (typeOf(x)) {\r\n case 'Null':\r\n case 'Undefined':\r\n return [];\r\n case String.name:\r\n case Array.name:\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n case 'Map':\r\n case 'Set':\r\n return Array.from(x);\r\n case Object.name:\r\n default:\r\n return toAssocList(x);\r\n }\r\n }\r\n\r\n;\r\n","/**\r\n * @module object\r\n * @description Object operations/combinators.\r\n */\r\n\r\nexport * from './jsPlatform/object';\r\nexport * from './object/lookup';\r\nexport * from './object/typeOf';\r\nexport * from './object/copy';\r\nexport * from './object/is';\r\nexport * from './object/of';\r\nexport * from './object/searchObj';\r\nexport * from './object/assignDeep';\r\nexport * from './object/setTheory';\r\nexport * from './object/console';\r\nexport * from './object/jsonClone';\r\nexport * from './object/toArray';\r\nexport * from './object/assocList';\r\n","import {reduceRight} from '../jsPlatform/array';\r\n\r\n/**\r\n * Composes all functions passed in from right to left passing each functions return value to\r\n * the function on the left of itself.\r\n * @function module:function.compose\r\n * @type {Function}\r\n * @param args {...{Function}}\r\n * @returns {Function}\r\n */\r\nexport const compose = (...args) =>\r\n arg0 => reduceRight((value, fn) => fn(value), arg0, args);\r\n","/**\r\n * @memberOf function\r\n */\r\n\r\n/**\r\n * Returns passed in parameter.\r\n * @haskellType `id :: a -> a`\r\n * @function module:function.id\r\n * @param x {*}\r\n * @returns {*}\r\n */\r\nexport const id = x => x;\r\n","/**\r\n * @memberOf function\r\n */\r\n\r\nimport {apply} from '../jsPlatform/function';\r\nimport {curry, curry2} from './curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Negates a function that takes one/no argument.\r\n * @function module:function.negateF\r\n * @param fn {Function}\r\n * @returns {function(*=): boolean}\r\n */\r\n negateF = fn => x => !fn(x),\r\n\r\n /**\r\n * Takes a function that takes two parameters and returns a negated version of given\r\n * function.\r\n * @function module:_negate.negateF2\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n negateF2 = fn => curry((a, b) => !fn(a, b)),\r\n\r\n /**\r\n * Takes a function that takes three parameters and returns a\r\n * negated version of given function.\r\n * @function module:_negate.negateF3\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n negateF3 = fn => curry((a, b, c) => !fn(a, b, c)),\r\n\r\n /**\r\n * Returns a negated version of given function.\r\n * Returned function is variadiac (takes one or more arguments).\r\n * @note function returned is uncurried.\r\n * @uncurried\r\n * @function module:function.negateFN\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n negateFN = fn => curry2((...args) => !apply(fn, args));\r\n","import {curry} from './curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Run `operation` until predicate returns `true` (like a functional\r\n * version of a while loop).\r\n * @function module:function.until\r\n * @param predicate {Function} :: a -> Boolean\r\n * @param operation {Function} :: a -> a\r\n * @param typeInstance {*} :: * - A monoidal zero or some starting point.\r\n * @returns {*} - What ever type `typeInstance` is\r\n */\r\n until = curry((predicate, operation, typeInstance) => {\r\n let result = typeInstance;\r\n while (!predicate(result)) {\r\n result = operation(result);\r\n }\r\n return result;\r\n });\r\n","import {typeOf} from '../object/typeOf';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a function or throws an error if given `f` is not a function.\r\n * @function module:function.fnOrError\r\n * @param symbolName {String} - Error message prefix.\r\n * @param f {Function|*} - Expected function.\r\n * @returns {Function}\r\n * @throws {Error} - Error if `f` is not of `function`\r\n */\r\n fnOrError = (symbolName, f) => {\r\n if (!f || !(f instanceof Function)) {\r\n throw new Error(`${symbolName} should be a function. ` +\r\n `Type received: ${typeOf(f)}; Value received: ${f}.`);\r\n }\r\n return f;\r\n }\r\n\r\n;\r\n","/**\r\n * No-op ('op' as in 'operation') - Performs no operation 'always' (good for places where\r\n * a value should always be a function etc.).\r\n * @function module:function.noop\r\n * @returns {undefined}\r\n */\r\nexport const noop = () => undefined;\r\n","/**\r\n * @module function\r\n */\r\nexport * from './jsPlatform/function';\r\nexport * from './function/compose';\r\nexport * from './function/curry';\r\nexport * from './function/flip';\r\nexport * from './function/id';\r\nexport * from './function/negate';\r\nexport * from './function/until';\r\nexport * from './function/fnOrError';\r\nexport * from './function/noop';\r\n","/**\r\n * @module object\r\n */\r\nimport {curry} from '../function/curry';\r\n\r\n/**\r\n * Normalizes step for `from` and `to` combination.\r\n * @function module:list.normalizeStep\r\n * @param from {Number}\r\n * @param to {Number}\r\n * @param [step = 1] {Number}\r\n * @returns {Number}\r\n * @private\r\n */\r\nconst normalizeStep = (from, to, step) => {\r\n if (from > to) {\r\n return step > 0 ? -step : step; // make step negative\r\n }\r\n return step < 0 ? -1 * step : step; // make step positive\r\n};\r\n\r\nexport const\r\n\r\n /**\r\n * Range function - gives you an array contain numbers in given range.\r\n * @note normalizes `step` to be valid if range numbers given are invalid\r\n * (forces `step` to be negative if range required is in the negative direction\r\n * and forces `step` to be positive if range required is in the other direction).\r\n * @function module:list.range\r\n * @param from {Number}\r\n * @param to {Number}\r\n * @param [step = 1] {Number}\r\n * @returns {Array.}\r\n */\r\n range = curry((from, to, step = 1) => {\r\n let i = from;\r\n const out = [];\r\n step = normalizeStep(from, to, step);\r\n if (step === 0 || from === to) { return [from]; }\r\n for (; (to - i) * step >= 0; i += step) { out.push(i); }\r\n return out;\r\n })\r\n;\r\n","/**\r\n * Created by elydelacruz on 9/6/2017.\r\n */\r\n\r\nimport {fPureTakesOne} from '../utils';\r\n\r\n/**\r\n * Functional version of `String.prototype.split`.\r\n * @function module:_string.split\r\n * @param separator {String|RegExp}\r\n * @param str {String}\r\n * @returns {Array}\r\n */\r\nexport const split = fPureTakesOne('split');\r\n","/**\r\n * @module jsPlatform_\r\n * @private\r\n */\r\nexport * from './jsPlatform/object';\r\nexport * from './jsPlatform/array';\r\nexport * from './jsPlatform/list';\r\nexport * from './jsPlatform/string';\r\nexport * from './jsPlatform/function';\r\n","/**\r\n * List operations module.\r\n * @module list\r\n */\r\nimport {concat as listAppend, indexOf, slice, includes} from './jsPlatform/list';\r\nimport {apply} from './jsPlatform/function';\r\nimport {length} from './jsPlatform/object';\r\nimport {negateF3, negateF2} from './function/negate';\r\nimport {curry, curry2, curry3} from './function/curry';\r\nimport {isTruthy, isFalsy} from './boolean';\r\nimport {lookup} from './object/lookup';\r\nimport {of} from './object/of';\r\nimport {isset, isString} from './object/is';\r\nimport {typeOf} from './object/typeOf';\r\nimport map from './list/map';\r\n\r\nimport {\r\n sliceFrom, sliceTo, lengths,\r\n toShortest, aggregateArray,\r\n reduceUntil, reduce, reduceRight, lastIndex,\r\n findIndexWhere, findIndexWhereRight, findIndicesWhere,\r\n findWhere, sliceCopy, genericAscOrdering\r\n}\r\n from './list/utils';\r\n\r\nexport * from './list/range';\r\n\r\nexport * from './list/utils';\r\n\r\nexport {map};\r\n\r\nexport {slice, includes, indexOf, lastIndexOf, push} from './jsPlatform';\r\n\r\nexport const\r\n\r\n /**\r\n * Append two, or more, lists, i.e.,\r\n * @example\r\n * expectEqual(append(take(13, alphabetString), drop(13, alphabetString)), alphabetString); // true\r\n *\r\n * // Another example\r\n * const result = append(\r\n * alphabetStr.split(''),\r\n * alphabetStr.split('')\r\n * ),\r\n * expected = repeat(2, alphabetStr).split('');\r\n *\r\n * shallowEquals(result, expected) === true // `true`\r\n *\r\n * @function module:list.append\r\n * @param [args] {...(Array|String|*)} - One or more lists or list likes (strings etc.).\r\n * @returns {(Array|String|*)} - Same type as list like passed in.\r\n */\r\n append = curry2((...args) => apply(listAppend, args)),\r\n\r\n /**\r\n * Returns head of list (first item of list).\r\n * @haskellType `head :: [a] -> a`\r\n * @function module:list.head\r\n * @param x {Array|String}\r\n * @returns {*} - First item from list\r\n */\r\n head = x => x[0],\r\n\r\n /**\r\n * Returns last item of list.\r\n * @haskellType `last :: [a] -> a`\r\n * @function module:list.last\r\n * @param xs {Array|String}\r\n * @returns {*}\r\n */\r\n last = xs => xs[lastIndex(xs)],\r\n\r\n /**\r\n * Returns tail part of list (everything after the first item as new list).\r\n * @haskelType `tail :: [a] -> [a]`\r\n * @function module:list.tail\r\n * @param xs {Array|String}\r\n * @returns {Array|String}\r\n */\r\n tail = xs => sliceFrom(1, xs),\r\n\r\n /**\r\n * Returns everything except last item of list as new list.\r\n * @haskellType `init :: [a] -> [a]`\r\n * @function module:list.init\r\n * @param xs {Array|String}\r\n * @returns {Array|String}\r\n */\r\n init = xs => sliceTo(lastIndex(xs), xs),\r\n\r\n /**\r\n * Returns `head` and `tail` of passed in list/string in a tuple.\r\n * @haskellType `uncons :: [a] -> Maybe (a, [a])`\r\n * @function module:list.uncons\r\n * @param xs {Array|String}\r\n * @returns {Array|undefined}\r\n */\r\n uncons = xs => !xs || length(xs) === 0 ? undefined : [head(xs), tail(xs)],\r\n\r\n /**\r\n * Returns `tail` and `head` of passed in list/string in a tuple.\r\n * @haskellType `unconsr :: [a] -> Maybe ([a], a)`\r\n * @function module:list.unconsr\r\n * @param xs {Array|String}\r\n * @returns {Array|String|*|undefined}\r\n */\r\n unconsr = xs => !xs || length(xs) === 0 ? undefined : [init(xs), last(xs)],\r\n\r\n /**\r\n * Concatenates all the elements of a container of lists.\r\n * @haskellType `concat :: Foldable t => t [a] -> [a]`\r\n * @function module:list.concat\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n concat = xs => {\r\n switch (length(xs)) {\r\n case undefined:\r\n case 0:\r\n return [];\r\n case 1:\r\n const item0 = xs[0];\r\n return item0 && item0.slice ? sliceCopy(item0) : item0;\r\n case 2:\r\n default:\r\n return apply(append, xs);\r\n }\r\n },\r\n\r\n /**\r\n * Map a function over all the elements of a container and concatenate the resulting lists.\r\n * @haskellType `concatMap :: Foldable t => (a -> [b]) -> t a -> [b]`\r\n * @function module:list.concatMap\r\n * @param fn {Function}\r\n * @param foldableOfA {Array}\r\n * @returns {Array}\r\n */\r\n concatMap = curry((fn, foldableOfA) => concat(map(fn, foldableOfA))),\r\n\r\n /**\r\n * Returns a copy of the passed in list reverses.\r\n * @haskellType `reverse :: [a] -> [a]`\r\n * @function module:list.reverse\r\n * @param xs {Array|String}\r\n * @returns {Array|String}\r\n */\r\n reverse = xs => {\r\n if (!isset(xs) || !xs.length) {\r\n return xs;\r\n }\r\n let out = of(xs),\r\n i = xs.length - 1;\r\n switch (typeOf(xs)) {\r\n case 'String':\r\n for (; i >= 0; i -= 1) {\r\n out += xs[i];\r\n }\r\n return out;\r\n default:\r\n for (; i >= 0; i -= 1) {\r\n out.push(xs[i]);\r\n }\r\n return out;\r\n }\r\n },\r\n\r\n /**\r\n * Takes an element and a list and `intersperses' that element between the\r\n * elements of the list.\r\n * @function module:list.intersperse\r\n * @note In our version of the function javascript is loosely typed so,\r\n * so is our function (to much overhead to make it typed) so `between` can be any value.\r\n * @param between {*} - Should be of the same type of elements contained in list.\r\n * @param arr {Array|String} - List.\r\n * @returns {Array|String}\r\n */\r\n intersperse = curry((between, xs) => {\r\n if (!xs || !xs.length) {\r\n return xs;\r\n }\r\n const limit = xs.length,\r\n lastInd = limit - 1;\r\n let out = of(xs),\r\n i = 0;\r\n if (isString(xs)) {\r\n for (; i < limit; i += 1) {\r\n out += i === lastInd ?\r\n xs[i] : xs[i] + between;\r\n }\r\n return out;\r\n }\r\n for (; i < limit; i += 1) {\r\n if (i === lastInd) {\r\n out.push(xs[i]);\r\n } else {\r\n out.push(xs[i], between);\r\n }\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * `intercalate xs xss` is equivalent to (concat (intersperse xs xss)). It inserts the list xs in between the lists in xss and concatenates the result.\r\n * @haskellType `intercalate :: [a] -> [[a]] -> [a]`\r\n * @function module:list.intercalate\r\n * @param xs {Array|String}\r\n * @param xss {Array|String}\r\n * @returns {Array|String}\r\n */\r\n intercalate = curry((xs, xss) => {\r\n if (isString(xss)) {\r\n return intersperse(xs, xss);\r\n }\r\n return concat(intersperse(xs, xss));\r\n }),\r\n\r\n /**\r\n * Transposes rows and columns into lists by index; E.g.,\r\n * Haskell example:\r\n * ```\r\n * transpose [[1,2,3],[4,5,6]] == [[1,4],[2,5],[3,6]]\r\n *\r\n * -- Notice the shorter arrays are ignored after their last index is copied over:\r\n * transpose [[10,11],[20],[],[30,31,32]] == [[10,20,30],[11,31],[32]]\r\n * ```\r\n * @note from columns to rows.\r\n * @note Empty lists are ignored.\r\n * @haskellType `transpose :: [[a]] -> [[a]]`\r\n * @function module:list.transpose\r\n * @param xss {Array}\r\n * @returns {Array}\r\n */\r\n transpose = xss => {\r\n let numLists = length(xss),\r\n ind = 0, ind2;\r\n if (!numLists) {\r\n return [];\r\n }\r\n const listLengths = apply(lengths, xss),\r\n longestListLen = maximum(listLengths),\r\n outLists = [];\r\n for (; ind < longestListLen; ind += 1) {\r\n const outList = [];\r\n for (ind2 = 0; ind2 < numLists; ind2 += 1) {\r\n if (listLengths[ind2] < ind + 1) {\r\n continue;\r\n }\r\n outList.push(xss[ind2][ind]);\r\n }\r\n outLists.push(outList);\r\n }\r\n return filter(x => length(x) > 0, outLists);\r\n },\r\n\r\n /**\r\n * Generates 2^n sub-sequences for passed in sequence (string/list) (`n` is\r\n * the length of the passed in sequence so: 2^length(xs)).\r\n * Note: The return value doubles per index/character passed in so use with caution!\r\n * Also note that for 2^16 (or for a sequence of 16 characters) this algorithm\r\n * will generate 65536 sub-sequences! So caution should be taken to not\r\n * use this with sequences above a certain length on certain platform (the browser thread in specific).\r\n * @function module:list.subsequences\r\n * @jsperftest https://jsperf.com/subsequences\r\n * @param xs {Array|String}\r\n * @returns {Array.}\r\n */\r\n subsequences = xs => {\r\n const listLen = length(xs),\r\n len = Math.pow(2, listLen),\r\n out = [];\r\n for (let i = 0; i < len; i += 1) {\r\n let entry = [];\r\n for (let j = 0; j < listLen; j += 1) {\r\n if (i & (1 << j)) {\r\n entry.push(xs[j]);\r\n }\r\n }\r\n out.push(entry);\r\n }\r\n return out;\r\n },\r\n\r\n /**\r\n * Returns an array with the given indices swapped.\r\n * @function module:list.swapped\r\n * @param ind1 {Number}\r\n * @param ind2 {Number}\r\n * @param list {Array}\r\n * @returns {Array} - Copy of incoming with swapped values at indices.\r\n */\r\n swapped = curry((ind1, ind2, list) => {\r\n const out = sliceCopy(list),\r\n tmp = out[ind1];\r\n out[ind1] = out[ind2];\r\n out[ind2] = tmp;\r\n return out;\r\n }),\r\n\r\n /**\r\n * Returns a list of permutations for passed in list.\r\n * Use caution with lists above a length of 15 (will take long due to nature of\r\n * algorithm).\r\n * @function module:list.permutations\r\n * @param xs {Array} - List.\r\n * @returns {Array} - Array of permutations.\r\n */\r\n permutations = xs => {\r\n const limit = length(xs);\r\n\r\n if (!limit || limit === 1) {\r\n return [xs];\r\n }\r\n\r\n let list = sliceCopy(xs),\r\n c = repeat(limit, 0),\r\n i = 0;\r\n\r\n const out = [list];\r\n\r\n for (; i < limit; i++) {\r\n if (c[i] < i) {\r\n list = swapped(i % 2 === 0 ? 0 : c[i], i, list);\r\n out.push(list);\r\n c[i] += 1;\r\n i = 0;\r\n continue;\r\n }\r\n c[i] = 0;\r\n }\r\n\r\n return out;\r\n },\r\n\r\n /**\r\n * Left associative fold. Reduces a container of elements down by the given operation (same as [].reduce).\r\n * @function module:list.foldl\r\n * @param fn {Function}\r\n * @param zero {*} - Aggregator.\r\n * @param functor {Array}\r\n * @returns {*} - Whatever type is lastly returned from `fn`.\r\n */\r\n foldl = reduce,\r\n\r\n /**\r\n * Right associative fold. Reduces a container of elements down by the given operation (same as [].reduceRight).\r\n * @function module:list.foldr\r\n * @param fn {Function}\r\n * @param zero {*} - Aggregator.\r\n * @param functor {Array}\r\n * @returns {*} - Whatever type is lastly returned from `fn`.\r\n */\r\n foldr = reduceRight,\r\n\r\n /**\r\n * A variant of `foldl` except that this one doesn't require the starting point. The starting point/value will be pulled\r\n * out from a copy of the container.\r\n * @function module:list.foldl1\r\n * @param op {Function}\r\n * @param xs {Array}\r\n * @returns {*} - Whatever type is lastly returned from `op`.\r\n */\r\n foldl1 = curry((op, xs) => {\r\n const parts = uncons(xs);\r\n return !parts ? [] : reduce(op, parts[0], parts[1]);\r\n }),\r\n\r\n /**\r\n * A variant of `foldr` except that this one doesn't require the starting point/value. The starting point/value will be pulled\r\n * out from a copy of the container.\r\n * @function module:list.foldr1\r\n * @param op {Function}\r\n * @param xs {Array}\r\n * @returns {*} - Whatever type is lastly returned from `op`.\r\n */\r\n foldr1 = curry((op, xs) => {\r\n const parts = unconsr(xs);\r\n return !parts ? [] : reduceRight(op, parts[1], parts[0]);\r\n }),\r\n\r\n /**\r\n * Performs a map then a reduce all in one (from left-to-right). Returns a tuple\r\n * containing the aggregated value and the result of mapping the passed in function on passed in list.\r\n * @function module:list.mapAccumL\r\n * @param op {Function} - Function : [aggregated, mapResult]\r\n * @param zero {*} - An instance of the passed in list type used to aggregateArray on.\r\n * @param xs {Array} - list type.\r\n * @return {Array} - [aggregated, list]\r\n */\r\n mapAccumL = curry((op, zero, xs) => {\r\n const list = sliceCopy(xs),\r\n limit = length(xs);\r\n if (!limit) {\r\n return [zero, list];\r\n }\r\n let ind = 0,\r\n agg = zero,\r\n mapped = [],\r\n tuple;\r\n for (; ind < limit; ind++) {\r\n tuple = op(agg, list[ind], ind);\r\n agg = tuple[0];\r\n mapped = tuple[1];\r\n }\r\n return [agg, mapped];\r\n }),\r\n\r\n /**\r\n * Performs a map and a reduce all in one (from right-to-left). Returns a tuple\r\n * containing the aggregated value and the result of mapping the passed in function on passed in list.\r\n * @function module:list.mapAccumR\r\n * @param op {Function} - Function : [aggregated, mapResult]\r\n * @param zero {*} - An instance of the passed in list type used to aggregateArray on.\r\n * @param xs {Array} - list type.\r\n * @return {Array} - [aggregated, list]\r\n */\r\n mapAccumR = curry((op, zero, xs) => {\r\n const list = sliceCopy(xs),\r\n limit = length(xs);\r\n if (!limit) {\r\n return [zero, list];\r\n }\r\n let ind = limit - 1,\r\n agg = zero,\r\n mapped = [],\r\n tuple;\r\n for (; ind >= 0; ind--) {\r\n tuple = op(agg, list[ind], ind);\r\n agg = tuple[0];\r\n mapped = tuple[1];\r\n }\r\n return [agg, mapped];\r\n }),\r\n\r\n /**\r\n * iterate f x returns an infinite list of repeated applications of f to x.\r\n * @function module:list.iterate\r\n * @example `iterate(5, f, x) == [x, f(x), f(f(x)), ...]`\r\n * @param limit {Number}\r\n * @param op {Function} - Operation.\r\n * @param x {*} - Starting point.\r\n * @returns {*}\r\n */\r\n iterate = curry((limit, op, x) => {\r\n let ind = 0,\r\n out = [],\r\n lastX = x;\r\n for (; ind < limit; ind += 1) {\r\n out.push(lastX);\r\n lastX = op(lastX, ind);\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Repeats `x` `limit` number of times.\r\n * @function module:list.repeat\r\n * @param limit {Number}\r\n * @param x {*}\r\n * @return {Array}\r\n */\r\n repeat = curry((limit, x) => iterate(limit, a => a, x)),\r\n\r\n /**\r\n * Same as `repeat` due to the nature of javascript (see haskell version for usage).\r\n * @function module:list.replicate\r\n * @param limit {Number}\r\n * @param x {*}\r\n * @return {Array}\r\n */\r\n replicate = repeat,\r\n\r\n /**\r\n * Replicates a list `limit` number of times and appends the results (concat)\r\n * @function module:list.cycle\r\n * @param limit {Number}\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n cycle = curry((limit, xs) => concat(replicate(limit, xs))),\r\n\r\n /**\r\n * Unfolds a value into a list of somethings.\r\n * @haskellType `unfoldr :: (b -> Maybe (a, b)) -> b -> [a]`\r\n * @function module:list.unfoldr\r\n * @param op {Function} - Operation to perform (should return a two component tuple (item to aggregateArray and item to unfold in next iteration).\r\n * @param x {*} - Starting parameter to unfold from.\r\n * @returns {Array} - An array of whatever you return from `op` yielded.\r\n */\r\n unfoldr = curry((op, x) => {\r\n let ind = 0,\r\n out = [],\r\n resultTuple = op(x, ind, out);\r\n while (resultTuple) {\r\n out.push(resultTuple[0]);\r\n resultTuple = op(resultTuple[1], ++ind, out);\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Finds index in string or list (alias for `findIndex`).\r\n * @function module:list.findIndex\r\n * @param pred {Function} - Predicate.\r\n * @param arr {Array|String}\r\n * @returns {Number} - `-1` if predicate not matched else `index` found\r\n */\r\n findIndex = findIndexWhere,\r\n\r\n /**\r\n * @function module:list.findIndices\r\n * @param pred {Function}\r\n * @param xs {Array} - list or list like.\r\n * @returns {Array|undefined}\r\n */\r\n findIndices = findIndicesWhere,\r\n\r\n /**\r\n * @function module:list.elemIndex\r\n * @param x {*} - Element to search for.\r\n * @param xs {Array} - list or list like.\r\n * @returns {*}\r\n */\r\n elemIndex = curry((x, xs) => {\r\n const foundInd = indexOf(x, xs);\r\n return foundInd !== -1 ? foundInd : undefined;\r\n }),\r\n\r\n /**\r\n * @function module:list.elemIndices\r\n * @param value {*} - Element to search for.\r\n * @param xs {Array} - list or list like.\r\n * @returns {*}\r\n */\r\n elemIndices = curry((value, xs) => findIndices(x => x === value, xs)),\r\n\r\n /**\r\n * Takes `n` items from start of list to `limit` (exclusive).\r\n * @function module:list.take\r\n * @param list {Array|String}\r\n * @param limit {Number}\r\n * @returns {String|Array} - Passed in type's type\r\n */\r\n take = sliceTo,\r\n\r\n /**\r\n * Drops `n` items from start of list to `count` (exclusive).\r\n * @function module:list.drop\r\n * @param list {Array|String}\r\n * @param count {Number}\r\n * @returns {String|Array} - Passed in type's type\r\n */\r\n drop = sliceFrom,\r\n\r\n /**\r\n * Splits `x` in two at given `index` (exclusive (includes element/character at\r\n * given index in second part of returned list)).\r\n * @function module:list.splitAt\r\n * @param ind {Number} - Index to split at.\r\n * @param list {Array|String} - functor (list or string) to split.\r\n * @returns {Array|String} - List like type passed\r\n */\r\n splitAt = (ind, list) => [sliceTo(ind, list), sliceFrom(ind, list)],\r\n\r\n /**\r\n * Gives an list with passed elements while predicate was true.\r\n * @function module:list.takeWhile\r\n * @param pred {Function} - Predicate<*, index, list|string>\r\n * @param list {Array|String}\r\n * @returns {Array}\r\n */\r\n takeWhile = curry((pred, list) =>\r\n reduceUntil(\r\n negateF3(pred), // predicate\r\n isString(list) ?\r\n (agg, x) => agg + x :\r\n aggregateArray, // operation\r\n of(list), // aggregate\r\n list\r\n )),\r\n\r\n /**\r\n * Returns an list without elements that match predicate.\r\n * @function module:list.dropWhile\r\n * @param pred {Function} - Predicate<*, index, list|string>\r\n * @param list {Array|String}\r\n * @refactor\r\n * @returns {Array|String}\r\n */\r\n dropWhile = curry((pred, list) => {\r\n const limit = length(list),\r\n splitPoint =\r\n findIndexWhere(\r\n (x, i, xs) => !pred(x, i, xs),\r\n list\r\n );\r\n\r\n return splitPoint === -1 ?\r\n sliceFrom(limit, list) :\r\n slice(splitPoint, limit, list);\r\n }),\r\n\r\n /**\r\n * @function module:list.dropWhileEnd\r\n * @param pred {Function} - Predicate<*, index, list|string>\r\n * @param list {Array|String}\r\n * @refactor\r\n * @returns {Array|String}\r\n */\r\n dropWhileEnd = curry((pred, list) => {\r\n const splitPoint =\r\n findIndexWhereRight(\r\n (x, i, xs) => !pred(x, i, xs),\r\n list\r\n );\r\n if (splitPoint === -1) {\r\n return of(list);\r\n }\r\n return sliceTo(splitPoint + 1, list);\r\n }),\r\n\r\n /**\r\n * Gives you the `span` of items matching predicate\r\n * and items not matching predicate; E.g., Gives an\r\n * array of arrays; E.g., [[matching-items], [non-matching-items]]\r\n * @function list.span\r\n * @param pred {Function} - List predicate (`(x, i, list) => bool`)\r\n * @param list {Array|String}\r\n * @returns {(Array>|Array)}\r\n * @type {Function}\r\n */\r\n span = curry((pred, list) => {\r\n const splitPoint = findIndexWhere(negateF3(pred), list);\r\n return splitPoint === -1 ?\r\n [sliceFrom(0, list), of(list)] :\r\n splitAt(splitPoint, list);\r\n }),\r\n\r\n /**\r\n * breakOnList, applied to a predicate p and a list xs, returns a tuple\r\n * where first element is longest prefix (possibly empty) of xs of elements\r\n * that do not satisfy p and second element is the remainder of the list:\r\n * @haskellExample\r\n * Replace `break` with `breakOnList` for our version.\r\n * ```\r\n * breakOnList (> 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4])\r\n * breakOnList (< 9) [1,2,3] == ([],[1,2,3])\r\n * breakOnList (> 9) [1,2,3] == ([1,2,3],[])\r\n * ```\r\n * @function module:list.breakOnList\r\n * @param pred {Function}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n breakOnList = curry((pred, list) => {\r\n const splitPoint = findIndexWhere(negateF3(pred), list);\r\n return splitPoint === -1 ?\r\n [of(list), sliceFrom(0, list)] : reverse(splitAt(splitPoint, list));\r\n }),\r\n\r\n /**\r\n * Gets item at index.\r\n * @function module:list.at\r\n * @param ind {Number} - Index.\r\n * @param xs {Array} - list or list like.\r\n * @returns {*|undefined} - Item or `undefined`.\r\n */\r\n at = lookup,\r\n\r\n /**\r\n * Find an item in structure of elements based on given predicate (`pred`).\r\n * @function module:list.find\r\n * @param pred {Function}\r\n * @param xs {Array} - list or list like.\r\n * @returns {*} - Found item.\r\n */\r\n find = findWhere,\r\n\r\n /**\r\n * For each function (same as `[].forEach` except in functional format).\r\n * @function module:list.forEach\r\n * @param fn {Function} - Operation (`(element, index, list) => {...}`, etc.)\r\n * @param xs {(Array|String)}\r\n * @returns {void}\r\n */\r\n forEach = curry((fn, list) => {\r\n const limit = length(list);\r\n if (!limit) {\r\n return;\r\n }\r\n let ind = 0;\r\n for (; ind < limit; ind += 1) {\r\n fn(list[ind], ind, list);\r\n }\r\n }),\r\n\r\n /**\r\n * Filters a structure of elements using given predicate (`pred`) (same as `[].filter`).\r\n * @function module:list.filter\r\n * @param pred {Function}\r\n * @param xs {Array} - list or list like.\r\n * @returns {Array} - Structure of filtered elements.\r\n */\r\n filter = curry((pred, xs) => {\r\n let ind = 0,\r\n limit = length(xs),\r\n out = [];\r\n if (!limit) {\r\n return out;\r\n }\r\n for (; ind < limit; ind++) {\r\n if (pred(xs[ind], ind, xs)) {\r\n out.push(xs[ind]);\r\n }\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Partitions a list on a predicate; Items that match predicate are in first list in tuple; Items that\r\n * do not match the tuple are in second list in the returned tuple.\r\n * Essentially `[filter(p, xs), filter(negateF3(p), xs)]`.\r\n * @function module:list.partition\r\n * @param pred {Function} - Predicate\r\n * @param list {Array}\r\n * @returns {Array|String} - Tuple of arrays or strings (depends on incoming list (of type list or string)).\r\n */\r\n partition = curry((pred, list) =>\r\n !length(list) ?\r\n [[], []] :\r\n [filter(pred, list), filter(negateF3(pred), list)]),\r\n\r\n /**\r\n * Returns a boolean indicating whether an element exists in given structure of elements.\r\n * @function module:list.elem\r\n * @param element {*}\r\n * @param xs {Array}\r\n * @returns {Boolean}\r\n */\r\n elem = includes,\r\n\r\n /**\r\n * The opposite of `elem` - Returns a boolean indicating whether an element exists in given list.\r\n * @function module:list.notElem\r\n * @param element {*}\r\n * @param xs {Array}\r\n * @returns {Boolean}\r\n */\r\n notElem = negateF2(includes),\r\n\r\n /**\r\n * Checks if list `xs1` is a prefix of list `xs2`\r\n * @function module:list.isPrefixOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isPrefixOf = curry((xs1, xs2) => {\r\n const limit1 = length(xs1),\r\n limit2 = length(xs2);\r\n if (limit2 < limit1 || !limit1 || !limit2 || indexOf(xs1[0], xs2) === -1) {\r\n return false;\r\n }\r\n let ind = 0;\r\n for (; ind < limit1; ind++) {\r\n if (xs1[ind] !== xs2[ind]) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }),\r\n\r\n /**\r\n * Checks if list `xs1` is a suffix of list `xs2`\r\n * @function module:list.isSuffixOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isSuffixOf = curry((xs1, xs2) => {\r\n const limit1 = length(xs1),\r\n limit2 = length(xs2);\r\n if (limit2 < limit1 || !limit1 || !limit2 || indexOf(xs1[0], xs2) === -1) {\r\n return false;\r\n }\r\n let ind1 = limit1 - 1,\r\n ind2 = limit2 - 1;\r\n for (; ind1 >= 0; ind1--) {\r\n if (xs1[ind1] !== xs2[ind2]) {\r\n return false;\r\n }\r\n ind2 -= 1;\r\n }\r\n return true;\r\n }),\r\n\r\n /**\r\n * Checks if list `xs1` is an infix of list `xs2`\r\n * @function module:list.isInfixOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isInfixOf = curry((xs1, xs2) => {\r\n const limit1 = length(xs1),\r\n limit2 = length(xs2);\r\n if (limit2 < limit1 || !limit1 || !limit2) {\r\n return false;\r\n }\r\n let ind1,\r\n foundLen,\r\n ind = 0;\r\n for (; ind < limit2; ind += 1) {\r\n foundLen = 0;\r\n for (ind1 = 0; ind1 < limit1; ind1 += 1) {\r\n if (xs2[ind1 + ind] === xs1[ind1]) {\r\n foundLen += 1;\r\n }\r\n if (foundLen === limit1) {\r\n return true;\r\n }\r\n }\r\n }\r\n return false;\r\n }),\r\n\r\n /**\r\n * Checks if list `xs1` is a sub-sequence of list `xs2`\r\n * @function module:list.isSubsequenceOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isSubsequenceOf = curry((xs1, xs2) => {\r\n const len = Math.pow(2, length(xs2)),\r\n lenXs1 = length(xs1);\r\n let foundLen,\r\n i;\r\n for (i = 0; i < len; i += 1) {\r\n foundLen = 0;\r\n for (let j = 0; j < len; j += 1) {\r\n if (i & (1 << j) && indexOf(xs2[j], xs1) > -1) {\r\n foundLen += 1;\r\n }\r\n if (foundLen === lenXs1) {\r\n return true;\r\n }\r\n }\r\n }\r\n return false;\r\n }),\r\n\r\n /**\r\n * The group function takes a list and returns a list of lists such that\r\n * the concatenation of the result is equal to the argument. Moreover, each\r\n * sublist in the result contains only equal elements. For example,\r\n * `group \"Mississippi\" = [\"M\",\"i\",\"ss\",\"i\",\"ss\",\"i\",\"pp\",\"i\"]`\r\n * It is a special case of groupBy, which allows the programmer to supply\r\n * their own equality test.\r\n * @haskellType `group :: Eq a => [a] -> [[a]]`\r\n * @function module:list.group\r\n * @param xs {Array|String}\r\n * @returns {Array|*}\r\n */\r\n group = xs => groupBy((a, b) => a === b, xs),\r\n\r\n /**\r\n * Allows you to group items in a list based on your supplied equality check.\r\n * @note Sames `group` but allows you to specify equality operation.\r\n * @haskellType `groupBy :: (a -> a -> Bool) -> [a] -> [[a]]`\r\n * @function module:list.groupBy\r\n * @param equalityOp {Function}\r\n * @param xs {Array}\r\n * @returns {*}\r\n */\r\n groupBy = curry((equalityOp, xs) => {\r\n const limit = length(xs);\r\n if (!limit) {\r\n return sliceCopy(xs);\r\n }\r\n let ind = 0,\r\n prevItem,\r\n item,\r\n predOp = x => {\r\n if (equalityOp(x, prevItem)) {\r\n ind++;\r\n }\r\n if (equalityOp(x, item)) {\r\n prevItem = x;\r\n return true;\r\n }\r\n return false;\r\n },\r\n agg = [];\r\n for (; ind < limit; ind += 1) {\r\n item = xs[ind];\r\n agg.push(takeWhile(predOp, slice(ind, limit, xs)));\r\n }\r\n return agg;\r\n }),\r\n\r\n /**\r\n * The inits function returns all initial segments of the argument, shortest first. For example,\r\n * ```\r\n * shallowEquals(inits('abc'), ['','a','ab','abc'])\r\n * ```\r\n * @function module:list.inits\r\n * @haskellType `inits :: [a] -> [[a]]`\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n inits = xs => {\r\n let limit = length(xs),\r\n ind = 0,\r\n agg = [];\r\n if (!limit) {\r\n return [];\r\n }\r\n for (; ind <= limit; ind += 1) {\r\n agg.push(sliceTo(ind, xs));\r\n }\r\n return agg;\r\n }, //map(list => init(list), xs),\r\n\r\n /**\r\n * The inits function returns all initial segments of the argument, shortest first. For example,\r\n * ```\r\n * shallowEquals(tails('abc'), ['abc', 'bc', 'c',''])\r\n * ```\r\n * @function module:list.tails\r\n * @haskellType `tails :: [a] -> [[a]]`\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n tails = xs => {\r\n let limit = length(xs),\r\n ind = 0,\r\n agg = [];\r\n if (!limit) {\r\n return [];\r\n }\r\n for (; ind <= limit; ind += 1) {\r\n agg.push(slice(ind, limit, xs));\r\n }\r\n return agg;\r\n }, //map(list => tail(list), xs),\r\n\r\n /**\r\n * Strips prefix list from given list\r\n * @function module:list.stripPrefix\r\n * @param prefix {Array|String|*}\r\n * @param list {Array|string|*}\r\n * @returns {Array|*}\r\n */\r\n stripPrefix = curry((prefix, list) =>\r\n isPrefixOf(prefix, list) ?\r\n splitAt(length(prefix), list)[1] :\r\n sliceCopy(list)),\r\n\r\n /**\r\n * zip takes two lists and returns a list of corresponding pairs.\r\n * If one input list is short, excess elements of the longer list are discarded.\r\n * @haskellType `zip :: [a] -> [b] -> [(a, b)]`\r\n * @function module:list.zip\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array>}\r\n */\r\n zip = curry((arr1, arr2) => {\r\n if (!length(arr1) || !length(arr2)) {\r\n return [];\r\n }\r\n const [a1, a2] = toShortest(arr1, arr2);\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, [item, a2[ind]]),\r\n [], a1);\r\n }),\r\n\r\n /**\r\n * zipN takes one or more lists and returns a list containing lists of all indices\r\n * at a given index, index by index.\r\n * If one input list is short, excess elements of the longer list are discarded.\r\n * @function module:list.zipN\r\n * @param lists {Array|String} - One ore more lists of the same type.\r\n * @returns {Array}\r\n */\r\n zipN = curry2((...lists) => {\r\n const trimmedLists = apply(toShortest, lists);\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, map(xs => xs[ind], trimmedLists)),\r\n [], trimmedLists[0]);\r\n }),\r\n\r\n /**\r\n * @haskellType `zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]`\r\n * @function module:list.zip3\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @param arr3 {Array}\r\n * @returns {Array>}\r\n */\r\n zip3 = curry((arr1, arr2, arr3) => zipN(arr1, arr2, arr3)),\r\n\r\n /**\r\n * @haskellType `zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]`\r\n * @function module:list.zip4\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @param arr3 {Array}\r\n * @param arr4 {Array}\r\n * @returns {Array>}\r\n */\r\n zip4 = curry((arr1, arr2, arr3, arr4) => zipN(arr1, arr2, arr3, arr4)),\r\n\r\n /**\r\n * @haskellType `zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]`\r\n * @function module:list.zip5\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @param arr3 {Array}\r\n * @param arr4 {Array}\r\n * @param arr5 {Array}\r\n * @returns {Array>}\r\n */\r\n zip5 = curry((arr1, arr2, arr3, arr4, arr5) => zipN(arr1, arr2, arr3, arr4, arr5)),\r\n\r\n /**\r\n * zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]\r\n * zipWith generalises zip by zipping with the function given as the\r\n * first argument, instead of a function tupling function (function that returns a tuple). For example,\r\n * zipWith (+) is applied to two lists to produce the list of corresponding sums.\r\n * @note `_|_` means bottom or perpetual (@see\r\n * - https://wiki.haskell.org/Bottom\r\n * - https://stackoverflow.com/questions/19794681/what-does-this-syntax-mean-in-haskell-or\r\n * )\r\n * @example\r\n * ```\r\n * zipWith f [] _|_ = []\r\n * ```\r\n * @haskellType `zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]`\r\n * @function module:list.zipWith\r\n * @param op {Function} - Takes two parts of a tuple and returns a tuple.\r\n * E.g., ` op :: a -> b -> (a, b)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith = curry((op, xs1, xs2) => {\r\n if (!length(xs1) || !length(xs2)) {\r\n return [];\r\n }\r\n const [a1, a2] = toShortest(xs1, xs2);\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, op(item, a2[ind])),\r\n [], a1);\r\n }),\r\n\r\n /**\r\n * Zips all given lists with tupling function. Note: Haskell types do not have\r\n * a way (that I know of) to show one or more for params in a function so `@haskellType` below\r\n * is left there for general purpose not for exactness as is told by aforementioned.\r\n * @haskellType `zipWithN :: (a -> b -> c) -> [a] -> [b] -> [c]` - Where `N` is the number\r\n * of lists to zip.\r\n * @function module:list.zipWithN\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> (a, b, c)`\r\n * @param lists ...{Array}\r\n * @returns {Array>}\r\n */\r\n zipWithN = curry3((op, ...lists) => {\r\n const trimmedLists = apply(toShortest, lists),\r\n lenOfTrimmed = length(trimmedLists);\r\n if (!lenOfTrimmed) {\r\n return [];\r\n }\r\n else if (lenOfTrimmed === 1) {\r\n return sliceTo(length(trimmedLists[0]), trimmedLists[0]);\r\n }\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, apply(op, map(xs => xs[ind], trimmedLists))),\r\n [], trimmedLists[0]);\r\n }),\r\n\r\n /**\r\n * Zips 3 lists with tupling function.\r\n * @haskellType `zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]`\r\n * @function module:list.zipWith3\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> (a, b, c)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @param xs3 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith3 = curry((op, xs1, xs2, xs3) => zipWithN(op, xs1, xs2, xs3)),\r\n\r\n /**\r\n * Zips 4 lists with tupling function.\r\n * @haskellType `zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]`\r\n * @function module:list.zipWith4\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> d -> (a, b, c, d)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @param xs3 {Array}\r\n * @param xs4 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith4 = curry((op, xs1, xs2, xs3, xs4) => zipWithN(op, xs1, xs2, xs3, xs4)),\r\n\r\n /**\r\n * Zips 5 lists.\r\n * @haskellType `zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]`\r\n * @function module:list.zipWith5\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> d -> e -> (a, b, c, d, e)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @param xs3 {Array}\r\n * @param xs4 {Array}\r\n * @param xs5 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith5 = curry((op, xs1, xs2, xs3, xs4, xs5) => zipWithN(op, xs1, xs2, xs3, xs4, xs5)),\r\n\r\n /**\r\n * unzip transforms a list of pairs into a list of first components and a list of second components.\r\n * @haskellType `unzip :: [(a, b)] -> ([a], [b])`\r\n * @function module:list.unzip\r\n * @param arr {Array|*}\r\n * @returns {Array|*}\r\n */\r\n unzip = foldl((agg, item) => {\r\n agg[0].push(item[0]);\r\n agg[1].push(item[1]);\r\n return agg;\r\n }, [[], []]),\r\n\r\n /**\r\n * unzip transforms a list of pairs into a list of first components and a list of second components.\r\n * @sudoHaskellType `unzipN :: [(a, b, ...x)] -> ([a], [b], ...[x])`\r\n * @function module:list.unzipN\r\n * @param list {Array|*} - List of tuples (lists).\r\n * @returns {Array|*}\r\n */\r\n unzipN = list => {\r\n if (!length(list)) {\r\n return [];\r\n }\r\n const lenItem0 = length(list[0]);\r\n let zero = lenItem0 ?\r\n unfoldr(numLists => numLists-- ? [[], numLists] : undefined, lenItem0) :\r\n [];\r\n return foldl((agg, item) => {\r\n agg.forEach((outList, ind) => outList.push(item[ind]));\r\n return agg;\r\n }, zero, list);\r\n },\r\n\r\n /**\r\n * Returns true if any item in container passes predicate `p`.\r\n * @function module:list.any\r\n * @param p {Function} - Predicate.\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n any = curry((p, xs) => {\r\n let ind = 0,\r\n limit = length(xs);\r\n if (!limit) {\r\n return false;\r\n }\r\n for (; ind < limit; ind += 1) {\r\n if (p(xs[ind])) {\r\n return true;\r\n }\r\n }\r\n return false;\r\n }),\r\n\r\n /**\r\n * Returns true if all items in container pass predicate `p`.\r\n * @function module:list.all\r\n * @param p {Function} - Predicate.\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n all = curry((p, xs) => {\r\n const limit = length(xs);\r\n let ind = 0;\r\n if (!limit) {\r\n return false;\r\n }\r\n for (; ind < limit; ind++) {\r\n if (!p(xs[ind], ind, xs)) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }),\r\n\r\n /**\r\n * Conjuction of container of bools (or truthy and/or falsy values); Returns\r\n * `true` if all in container are 'truthy' else returns `false`\r\n * @function module:list.and\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n and = xs => all(isTruthy, xs),\r\n\r\n /**\r\n * Returns a boolean indicating whether any item in container is 'truthy' or not.\r\n * **Note** The haskell type for this function only takes two items, but here\r\n * we allow the passing of more than one item (may change later to adhere to the haskell type).\r\n * @function module:list.or\r\n * @haskellType `or :: Bool -> Bool -> Bool`\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n or = xs => any(isTruthy, xs),\r\n\r\n /**\r\n * Returns a boolean indicating whether all items in container are 'falsy' or not.\r\n * **Note** The haskell type for this function only takes two items, but here\r\n * we allow the passing of more than one item (may change later to adhere to the haskell type).\r\n * @function module:list.not\r\n * @haskellType `not :: Bool -> Bool`\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n not = xs => all(isFalsy, xs),\r\n\r\n /**\r\n * Computes the sum of the numbers of a structure.\r\n * @function module:list.sum\r\n * @haskellType `sum :: (List t, Num a) => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {Number}\r\n */\r\n sum = list => foldl((agg, x) => agg + x, 0, list),\r\n\r\n /**\r\n * Computes the product of the numbers of a structure.\r\n * @function module:list.product\r\n * @haskellType `product :: (List t, Num a) => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {Number}\r\n */\r\n product = list => foldl((agg, x) => agg * x, 1, list),\r\n\r\n /**\r\n * Returns the largest element in a non-empty structure of elements.\r\n * @function module:list.maximum\r\n * @haskellType `maximum :: forall a . Ord a => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {*} - Whatever type the array is made of (if any).\r\n */\r\n maximum = list => last(sortBy(genericAscOrdering, list)),\r\n\r\n /**\r\n * Returns the smallest element in a non-empty structure of elements.\r\n * @function module:list.minimum\r\n * @haskellType `minimum :: forall a . Ord a => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {*} - Whatever type the array is made of (if any).\r\n */\r\n minimum = list => head(sortBy(genericAscOrdering, list)),\r\n\r\n /**\r\n * scanl is similar to foldl, but returns a list of successive reduced values from the left:\r\n * ```\r\n * scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]\r\n * ```\r\n * Also note that:\r\n * ```\r\n * last (scanl f z xs) == foldl f z xs.\r\n * ```\r\n * @function module:list.scanl\r\n * @param fn {Function}\r\n * @param zero {*}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanl = curry((fn, zero, xs) => {\r\n if (!xs || !length(xs)) {\r\n return [];\r\n }\r\n const limit = length(xs);\r\n let ind = 0,\r\n result = zero,\r\n out = [];\r\n while (ind < limit) {\r\n result = fn(result, xs[ind], ind, xs);\r\n out.push(result);\r\n ind++;\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * `scanl1` is a variant of `scanl` that has no starting value argument:\r\n * `shallowCompare(scanl1(fn, [x1, x2, ...]), [x1, fn(x1, x2), ...]) // true`\r\n * @function module:list.scanl1\r\n * @param fn {Function}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanl1 = curry((fn, xs) => {\r\n if (!xs || !xs.length) {\r\n return [];\r\n }\r\n return scanl(fn, head(xs), tail(xs));\r\n }),\r\n\r\n /**\r\n * Same as `scanl` but from the right (similiar to `foldr`'s relationship to 'foldl').\r\n * Note also `scanr`'s relationship ot `foldr`:\r\n * `head (scanr(fn, z, xs)) === foldr(fn, z, xs).\r\n * @function module:list.scanr\r\n * @param fn {Function}\r\n * @param zero {*}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanr = curry((fn, zero, xs) => {\r\n if (!xs || !length(xs)) {\r\n return [];\r\n }\r\n const limit = length(xs);\r\n let ind = limit - 1,\r\n result = xs[0],\r\n out = [];\r\n while (ind > -1) {\r\n result = fn(result, xs[ind], ind, xs);\r\n out.push(result);\r\n ind--;\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Same as `scanr` but takes no zero/accumulator value.\r\n * @function module:list.scanr1\r\n * @param fn {Function}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanr1 = curry((fn, xs) => {\r\n if (!xs || !xs.length) {\r\n return [];\r\n }\r\n return scanr(fn, last(xs), init(xs));\r\n }),\r\n\r\n /**\r\n * The nub function removes duplicate elements from a list.\r\n * In particular, it keeps only the first occurrence of each element.\r\n * (The name nub means `essence'.) It is a special case of nubBy, which\r\n * allows the programmer to supply their own equality test.\r\n * ```shallowCompare( nub ([1,2,3,4,3,2,1,2,4,3,5]), [1,2,3,4,5] )```\r\n * @function module:list.nub\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n nub = list => nubBy((a, b) => a === b, list),\r\n\r\n /**\r\n * `remove(x, xs)` removes the first occurrence of `x` from `xs`.\r\n * For example, `remove('a', 'banana') === 'bnana';`\r\n * @function module:list.remove\r\n * @param x {*}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n remove = curry((x, list) => removeBy((a, b) => a === b, x, list)),\r\n\r\n /**\r\n * The sort function implements a stable sorting algorithm.\r\n * It is a special case of sortBy, which allows the programmer\r\n * to supply their own comparison function.\r\n * ```shallowCompare(sort ([1,6,4,3,2,5]), [1,2,3,4,5,6]) // true```\r\n * @function module:list.sort\r\n * @param xs {Array|String|*}\r\n * @returns {Array}\r\n */\r\n sort = xs => sortBy(genericAscOrdering, xs),\r\n\r\n /**\r\n * Sort a list by comparing the results of a key function applied to each\r\n * element. sortOn f is equivalent to sortBy (comparing f), but has the\r\n * performance advantage of only evaluating f once for each element in the\r\n * input list. This is called the decorate-sort-undecorate paradigm, or\r\n * Schwartzian transform.\r\n *\r\n * Elements are arranged from from lowest to highest, keeping duplicates\r\n * in the order they appeared in the input.\r\n *\r\n * Ex:\r\n * ```\r\n * shallowEquals(\r\n * sortOn (head, [[2, \"world\"], [4, \"!\"], [1, \"Hello\"]]),\r\n * [[1,\"Hello\"],[2,\"world\"],[4,\"!\"]]\r\n * ) // true\r\n * ```\r\n * @function module:list.sortOn\r\n * @param valueFn {Function}\r\n * @param xs {Array|String|*}\r\n * @returns {Array}\r\n */\r\n sortOn = curry((valueFn, xs) =>\r\n\r\n // Un-decorate\r\n map(decorated => decorated[1],\r\n\r\n // Decorate and sort\r\n sortBy(\r\n // Ordering\r\n ([a0], [b0]) => genericAscOrdering(a0, b0),\r\n\r\n // Decorate\r\n map(item => [valueFn(item), item], xs)\r\n )\r\n )\r\n ),\r\n\r\n /**\r\n * The sortBy function is the non-overloaded (in haskell terms) version of sort.\r\n * @haskellExample ```\r\n * >>> sortBy (\\(a,_) (b,_) -> compare a b) [(2, \"world\"), (4, \"!\"), (1, \"Hello\")]\r\n * [(1,\"Hello\"),(2,\"world\"),(4,\"!\")]\r\n * ```\r\n * @function module:list.sortBy\r\n * @param orderingFn {Function}\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sortBy = curry((orderingFn, xs) => sliceCopy(xs).sort(orderingFn || genericAscOrdering)),\r\n\r\n /**\r\n * The insert function takes an element and a list and inserts the element\r\n * into the list at the first position where it is less than or equal to the\r\n * next element. In particular, if the list is sorted before the call, the\r\n * result will also be sorted. It is a special case of insertBy, which allows\r\n * the programmer to supply their own comparison function.\r\n * @function module:list.insert\r\n * @param x {*}\r\n * @param xs {Array|*}\r\n * @returns {Array}\r\n */\r\n insert = curry((x, xs) => {\r\n if (!xs.length) {\r\n return of(xs, x);\r\n }\r\n const foundIndex = findIndex(item => x <= item, xs);\r\n return foundIndex === -1 ? concat([xs, of(xs, x)]) :\r\n concat(intersperse(of(xs, x), splitAt(foundIndex, xs)));\r\n }),\r\n\r\n /**\r\n * A version of `insert` that allows you to specify the ordering of the inserted\r\n * item; Before/at, or after\r\n * @function module:list.insertBy\r\n * @haskellType `insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]`\r\n * @note `Ordering` means 'something that is order-able'\r\n * operated on by this functions logic.\r\n * @param orderingFn {Function} - A function that returns `-1`, `0`, or 1`.\r\n * @param x {*} - Value to insert.\r\n * @param xs {Array} - List to insert into (note new list is returned)\r\n * @returns {Array} - New list.\r\n */\r\n insertBy = curry((orderingFn, x, xs) => {\r\n const limit = length(xs);\r\n if (!limit) {\r\n return [x];\r\n }\r\n let ind = 0;\r\n for (; ind < limit; ind += 1) {\r\n if (orderingFn(x, xs[ind]) <= 0) {\r\n const parts = splitAt(ind, xs);\r\n return concat([parts[0], [x], parts[1]]);\r\n }\r\n }\r\n return aggregateArray(sliceCopy(xs), x);\r\n }),\r\n\r\n /**\r\n * The nubBy function behaves just like nub, except it uses a user-supplied equality predicate.\r\n * @function module:list.nubBy\r\n * @param pred {Function}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n nubBy = curry((pred, list) => {\r\n if (!length(list)) {\r\n return [];\r\n }\r\n const limit = length(list);\r\n let ind = 0,\r\n currItem,\r\n out = [],\r\n anyOp = storedItem => pred(currItem, storedItem);\r\n for (; ind < limit; ind += 1) {\r\n currItem = list[ind];\r\n if (any(anyOp, out)) {\r\n continue;\r\n }\r\n out.push(currItem);\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Behaves the same as `remove`, but takes a user-supplied equality predicate.\r\n * @function module:list.removeBy\r\n * @param pred {Function} - Equality predicate `(a, b) => bool`\r\n * @param x {*}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n removeBy = curry((pred, x, list) => {\r\n const foundIndex = findIndex(item => pred(x, item), list);\r\n if (foundIndex > -1) {\r\n const parts = splitAt(foundIndex, list);\r\n return append(parts[0], tail(parts[1]));\r\n }\r\n return sliceCopy(list);\r\n }),\r\n\r\n /**\r\n * The `removeFirstsBy` function takes a predicate and two lists and returns the first list with the first\r\n * occurrence of each element of the second list removed.\r\n * @function module:list.removeFirstBy\r\n * @param pred {Function}\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {Array}\r\n */\r\n removeFirstsBy = curry((pred, xs1, xs2) =>\r\n foldl((agg, x) => removeBy(pred, x, agg), xs1, xs2)),\r\n\r\n /**\r\n * Returns the union on elements matching boolean check passed in.\r\n * @function module:list.unionBy\r\n * @param pred {Function} - `pred :: a -> a -> Bool`\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array}\r\n */\r\n unionBy = curry((pred, arr1, arr2) =>\r\n foldl((agg, b) => {\r\n const alreadyAdded = any(a => pred(a, b), agg);\r\n return !alreadyAdded ? (agg.push(b), agg) : agg;\r\n }, sliceCopy(arr1), arr2\r\n )),\r\n\r\n /**\r\n * Creates a union on matching elements from array1.\r\n * @function module:list.union\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array}\r\n */\r\n union = curry((arr1, arr2) =>\r\n append(arr1,\r\n filter(elm => !includes(elm, arr1), arr2))),\r\n\r\n /**\r\n * Performs an intersection on list 1 with elements from list 2.\r\n * @function module:list.intersect\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array}\r\n */\r\n intersect = curry((arr1, arr2) =>\r\n !arr1 || !arr2 || (!arr1 && !arr2) ? [] :\r\n filter(elm => includes(elm, arr2), arr1)),\r\n\r\n /**\r\n * Returns an intersection by predicate.\r\n * @function module:list.intersectBy\r\n * @param pred {Function} - `pred :: a -> b -> Bool`\r\n * @param list1 {Array}\r\n * @param list2 {Array}\r\n * @return {Array}\r\n */\r\n intersectBy = curry((pred, list1, list2) =>\r\n foldl((agg, a) =>\r\n any(b => pred(a, b), list2) ? (agg.push(a), agg) : agg\r\n , [], list1)),\r\n\r\n /**\r\n * Returns the difference of list 1 from list 2.\r\n * @note The `difference` operation here is non-associative; E.g., `a - b` is not equal to `b - a`;\r\n * @function module:list.difference\r\n * @param array1 {Array}\r\n * @param array2 {Array}\r\n * @returns {Array}\r\n */\r\n difference = curry((array1, array2) => { // augment this with max length and min length ordering on op\r\n if (array1 && !array2) {\r\n return sliceCopy(array1);\r\n }\r\n else if (!array1 && array2 || (!array1 && !array2)) {\r\n return [];\r\n }\r\n return reduce((agg, elm) =>\r\n !includes(elm, array2) ? (agg.push(elm), agg) : agg\r\n , [], array1);\r\n }),\r\n\r\n /**\r\n * Returns the complement of list 0 and the reset of the passed in arrays.\r\n * @function module:list.complement\r\n * @param arr0 {Array}\r\n * @param arrays {...Array}\r\n * @returns {Array}\r\n */\r\n complement = curry2((arr0, ...arrays) =>\r\n reduce((agg, arr) => append(agg, difference(arr, arr0)), [], arrays));\r\n","/**\r\n * @module errorThrowing\r\n * @description Contains error throwing facilities for when a value doesn't match a type.\r\n */\r\nimport {typeOf} from './object/typeOf';\r\nimport {isArray, toTypeRef, toTypeRefName, isOfType} from './object/is';\r\nimport {curry} from './function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Pretty prints an array of types/type-strings for use by error messages;\r\n * Outputs \"`SomeTypeName`, ...\" from [SomeType, 'SomeTypeName', etc...]\r\n * @function module:errorThrowing.typeRefsToStringOrError\r\n * @param types {Array|TypesArray}\r\n * @return {String}\r\n * @private\r\n */\r\n typeRefsToStringOrError = types => types.length ?\r\n types.map(type => `\\`${toTypeRefName(type)}\\``).join(', ') : '',\r\n\r\n /**\r\n * Prints a message from an object. Object signature:\r\n * {contextName, valueName, value, expectedTypeName, foundTypeName, messageSuffix}\r\n * @function module:errorThrowing.defaultErrorMessageCall\r\n * @param tmplContext {Object|TemplateContext} - Object to use in error template.\r\n * @returns {string}\r\n * @private\r\n */\r\n defaultErrorMessageCall = tmplContext => {\r\n const {\r\n contextName, valueName, value, expectedTypeName,\r\n foundTypeName, messageSuffix\r\n } = tmplContext,\r\n isMultiTypeNames = isArray(expectedTypeName),\r\n typesCopy = isMultiTypeNames ? 'of type' : 'of one of the types',\r\n typesToMatchCopy = isMultiTypeNames ? typeRefsToStringOrError(expectedTypeName) : expectedTypeName;\r\n return (contextName ? `\\`${contextName}.` : '`') +\r\n `${valueName}\\` is not ${typesCopy}: ${typesToMatchCopy}. ` +\r\n `Type received: ${foundTypeName}. Value: ${value};` +\r\n `${messageSuffix ? ' ' + messageSuffix + ';' : ''}`;\r\n },\r\n\r\n /**\r\n * Gets the error message thrower seeded with passed in errorMessage template call.\r\n * @function module:errorThrowing.getErrorIfNotTypeThrower$\r\n * @param errorMessageCall {Function|ErrorMessageCall}\r\n * @param typeChecker {Function|TypeChecker} - Function:Boolean\r\n * @returns {Function|ErrorIfNotType}\r\n * @private\r\n */\r\n _getErrorIfNotTypeThrower = (errorMessageCall, typeChecker = isOfType) =>\r\n (ValueType, contextName, valueName, value, messageSuffix = null) => {\r\n const expectedTypeName = toTypeRef(ValueType),\r\n foundTypeName = typeOf(value);\r\n if (typeChecker(ValueType, value)) { return value; } // Value matches type\r\n throw new Error(errorMessageCall(\r\n {contextName, valueName, value, expectedTypeName, foundTypeName, messageSuffix}\r\n ));\r\n },\r\n\r\n /**\r\n * Gets the error message thrower seeded with passed in errorMessage template call.\r\n * @function module:errorThrowing.getErrorIfNotTypesThrower$\r\n * @param errorMessageCall {Function|ErrorMessageCall}\r\n * @param typeChecker {Function|TypeChecker} - Function:Boolean\r\n * @returns {Function|ErrorIfNotTypes}\r\n * @private\r\n */\r\n _getErrorIfNotTypesThrower = (errorMessageCall, typeChecker = isOfType) =>\r\n (valueTypes, contextName, valueName, value, messageSuffix = null) => {\r\n const expectedTypeNames = valueTypes.map(toTypeRef),\r\n matchFound = valueTypes.some(ValueType => typeChecker(ValueType, value)),\r\n foundTypeName = typeOf(value);\r\n if (matchFound) { return value; }\r\n throw new Error(\r\n errorMessageCall({\r\n contextName, valueName, value,\r\n expectedTypeName: expectedTypeNames, foundTypeName,\r\n messageSuffix\r\n })\r\n );\r\n },\r\n\r\n /**\r\n * Checks that passed in `value` is of given `type`. Throws an error if value\r\n * is not of given `type`. This is the un-curried version. For the curried version\r\n * see `module:errorThrowing.errorIfNotType`.\r\n * @function module:errorThrowing.errorIfNotType$\r\n * @param type {String|Function} - Type's name or type itself.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @param [messageSuffix=null] {String} - Optional.\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @private\r\n */\r\n _errorIfNotType = _getErrorIfNotTypeThrower(defaultErrorMessageCall),\r\n\r\n /**\r\n * Checks that passed in `value` is of one of the given `types`. Throws an error if value\r\n * is not of one of the given `types`. This is the un-curried version. For the curried version\r\n * see `module:errorThrowing.errorIfNotTypes`.\r\n * @type {Function|module:errorThrowing.errorIfNotTypes}\r\n * @function module:errorThrowing.errorIfNotTypes$\r\n * @param types {Array} - Array of one or more types or type names themselves.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @private\r\n */\r\n _errorIfNotTypes = _getErrorIfNotTypesThrower(defaultErrorMessageCall),\r\n\r\n /**\r\n * Returns a function that can be used to ensure that values are of a given type.\r\n * Also throws informative error messages containing the value types, names, expected type names,\r\n * etc.\r\n * @function module:errorThrowing.getErrorIfNotTypeThrower\r\n * @param errorMessageCall {Function|ErrorMessageCall} - Template function (takes an info-object and returns a printed string).\r\n * @returns {Function|ErrorIfNotType} - Returns a function with the same signature as `errorIfNotType` though curried.\r\n */\r\n getErrorIfNotTypeThrower = errorMessageCall => curry(_getErrorIfNotTypeThrower(errorMessageCall)),\r\n\r\n /**\r\n * Returns a function that can be used to ensure that a value is of one or more given types.\r\n * The returned function is used in cases where informative error messages\r\n * containing the value types, names, expected type names, are-required/should-be-used etc.\r\n * @function module:errorThrowing.getErrorIfNotTypesThrower\r\n * @param errorMessageCall {Function|ErrorMessageCall} - Template function (takes an info-object and returns a printed string).\r\n * @returns {Function|ErrorIfNotTypes} - Returns a function with the same signature as `errorIfNotTypes` though curried.\r\n */\r\n getErrorIfNotTypesThrower = errorMessageCall => curry(_getErrorIfNotTypesThrower(errorMessageCall)),\r\n\r\n /**\r\n * Checks that passed in `value` is of given `type`. Throws an error if value\r\n * is not of given `type`. Curried.\r\n * @function module:errorThrowing.errorIfNotType\r\n * @param type {String|Function} - Type's name or type itself.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @param [messageSuffix=null] {String} - Optional.\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @curried\r\n */\r\n errorIfNotType = curry(_errorIfNotType),\r\n\r\n /**\r\n * Checks that passed in `value` is of one of the given `types`. Throws an error if value\r\n * is not of one of the given `types`. Curried.\r\n * @function module:errorThrowing.errorIfNotTypes\r\n * @param types {Array} - Array of one or more types or type names themselves.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @curried\r\n */\r\n errorIfNotTypes = curry(_errorIfNotTypes)\r\n;\r\n\r\n/**\r\n * @typedef {*} Any - Synonym for 'any value'.\r\n */\r\n\r\n/**\r\n * @typedef {String|Function} TypeRef\r\n * @description Type reference. Type itself or Type's name; E.g., `Type.name`;\r\n */\r\n\r\n/**\r\n * @typedef {Object} TemplateContext\r\n * @description Template context used for error message renderers (functions that take a context obj and return a string).\r\n * @property value {*}\r\n * @property valueName {String}\r\n * @property expectedTypeName {String} - Expected name of constructor of `value`; E.g., usually `SomeConstructor.name`;\r\n * @property foundTypeName {String} - Found types name; E.g., `FoundConstructor.name`;\r\n * @property [messageSuffix=null] {*} - Message suffix (sometimes an extra hint or instructions for\r\n * directing user to fix where his/her error has occurred). Optional.\r\n */\r\n\r\n/**\r\n * @typedef {Array<(String|Function)>} TypesArray\r\n */\r\n\r\n/**\r\n * @typedef {Function} TypeChecker\r\n * @description Checks whether a value is of given type.\r\n * @param Type {TypeRef} - a Type or it's name; E.g., `Type.name`.\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n\r\n/**\r\n * @typedef {Function} ErrorMessageCall\r\n * @description Error message template function.\r\n * @param tmplContext {TemplateContext}\r\n * @returns {String}\r\n */\r\n\r\n/**\r\n * @typedef {Function} ErrorIfNotType\r\n * @description Used to ensure value matches passed in type.\r\n * @param type {TypeRef} - Constructor name or constructor.\r\n * @param contextName {String}\r\n * @param valueName {String}\r\n * @param value {*}\r\n * @throws {Error} - If value doesn't match type.\r\n * @returns {*} - What ever value is.\r\n */\r\n\r\n/**\r\n * @typedef {Function} ErrorIfNotTypes\r\n * @description Used to ensure a value matches one of one or more types passed in.\r\n * @param valueTypes {TypesArray} - Array of constructor names or constructors.\r\n * @param contextName {String}\r\n * @param valueName {String}\r\n * @param value {*}\r\n * @throws {Error} - If value doesn't match type.\r\n * @returns {*} - Whatever value is.\r\n */\r\n","/**\r\n * @module string\r\n * @description Contains functions for strings.\r\n */\r\nimport {intercalate, map, filter} from './list';\r\nimport {split} from './jsPlatform/string';\r\nimport {compose} from './function/compose';\r\nimport {join} from './jsPlatform/array';\r\nimport {_errorIfNotType} from './errorThrowing';\r\n\r\nexport {split};\r\n\r\nexport const\r\n\r\n /**\r\n * Splits a string on all '\\n', '\\r', '\\n\\r', or '\\r\\n' characters.\r\n * @function module:string.lines\r\n * @param str {String}\r\n * @returns {Array}\r\n */\r\n lines = split(/[\\n\\r]/gm),\r\n\r\n /**\r\n * Splits a string on all '\\s' and/or all '\\t' characters.\r\n * @function module:string.words\r\n * @param str{String}\r\n * @returns {Array}\r\n */\r\n words = split(/[\\s\\t]/gm),\r\n\r\n /**\r\n * Intersperse an array of strings with '\\s' and then concats them.\r\n * @function module:string.unwords\r\n * @param arr {String}\r\n * @returns {Array}\r\n */\r\n unwords = intercalate(' '),\r\n\r\n /**\r\n * Intersperses a '\\n' character into a list of strings and then concats it.\r\n * @function module:string.unlines\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n unlines = intercalate('\\n'),\r\n\r\n /**\r\n * Lower cases first character of a non-empty string.\r\n * @function module:string.lcaseFirst\r\n * @param xs {String}\r\n * @returns {string}\r\n * @throws {Error} - Throws error if receiving anything that is not a string.\r\n */\r\n lcaseFirst = xs => {\r\n _errorIfNotType(String, 'lcaseFirst', 'xs', xs);\r\n return xs[0].toLowerCase() + xs.substring(1);\r\n },\r\n\r\n /**\r\n * Upper cases first character of a non-empty string.\r\n * @function module:string.ucaseFirst\r\n * @param xs {String}\r\n * @returns {string}\r\n * @throws {Error} - Throws error if receiving anything that is not a string.\r\n */\r\n ucaseFirst = xs => {\r\n _errorIfNotType(String, 'ucaseFirst', 'xs', xs);\r\n return xs[0].toUpperCase() + xs.substring(1);\r\n },\r\n\r\n /**\r\n * Camel cases (class case) a string.\r\n * @function module:string.camelCase\r\n * @param xs {String}\r\n * @param [pattern=/[^a-z\\d/i]/] {RegExp} - Pattern to split on. Optional.\r\n * @throws {Error} - Throws error if param `xs` is not a string.\r\n * @returns {string}\r\n * @curried\r\n */\r\n camelCase = (xs, pattern = /[^a-z\\d]/i) => compose(\r\n join(''),\r\n map(str => ucaseFirst(str.toLowerCase())),\r\n filter(x => !!x),\r\n split(pattern)\r\n )(_errorIfNotType(String, 'camelCase', 'xs', xs)),\r\n\r\n /**\r\n * Class cases a string. Uses pattern /[^a-z\\d/i]/ to split on.\r\n * If you require a different pattern use `string.camelCase(str, pattern)`\r\n * and then upper case first character (`ucaseFirst`).\r\n * @function module:string.classCase\r\n * @param xs {String}\r\n * @returns {string}\r\n * @throws {Error} - Throws error if `xs` is not a string (via `camelCase` call).\r\n */\r\n classCase = compose(ucaseFirst, camelCase)\r\n\r\n;\r\n\r\n/**\r\n * Functional version of `String.prototype.split`.\r\n * @function module:string.split\r\n * @param separator {String|RegExp}\r\n * @param str {String}\r\n * @returns {Array}\r\n */\r\n","/**\r\n * @module fjl\r\n * @description Exports all module methods (object, list, string modules etc.).\r\n * @goal to include everything from haskell's Prelude where it makes sense in order to create\r\n * a subset of functions which can make the javascript developer more efficient and make his/her\r\n * code more concise (and functional).\r\n * @motivation preludejs, lodash/fp, RamdaJs, Haskell.\r\n * @see http://hackage.haskell.org/package/base-4.10.0.0/docs/Prelude.html\r\n * @see http://hackage.haskell.org/package/base-4.10.0.0/docs/Data-List.html\r\n */\r\nexport * from './object';\r\nexport * from './boolean';\r\nexport * from './function';\r\nexport * from './list';\r\nexport * from './string';\r\nexport * from './utils';\r\nexport * from './errorThrowing';\r\n"],"names":["returnCurried","executeArity","unmetArityNum","fn","argsToCurry","func","x","executeAsCurriedFunc","Array","from","arguments","a","b","c","d","e","args","unmetArity","concatedArgs","concat","canBeCalled","length","newExpectedArity","curryN","Function","Error","curry","curry2","curry3","curry4","curry5","fPureTakesOne","name","arg","f","fPureTakes2","arg1","arg2","fPureTakes3","arg3","fPureTakes4","arg4","fPureTakes5","arg5","fPureTakesOneOrMore","defineReverse","prototype","reverse","reduceRight","agg","item","push","map","filter","reduce","forEach","some","every","join","apply","call","flipN","flip","flip3","flip4","flip5","instanceOf","instanceConstructor","instance","hasOwnProperty","native","Object","getOwnPropertyNames","key","operation","keys","assign","obj0","objs","topAgg","obj","_Number","Number","_NaN","_Null","_Undefined","typeOf","value","retVal","undefined","constructorName","constructor","isNaN","_String","String","_Object","_Boolean","Boolean","_Function","_Array","_Symbol","_Map","_Set","_WeakMap","_WeakSet","toTypeRef","type","toTypeRefs","types","toTypeRefName","Type","ref","toTypeRefNames","isFunction","isType","isOfType","isClass","test","substr","isCallable","isArray","isObject","isBoolean","isNumber","isString","isMap","isSet","isWeakMap","isWeakSet","isUndefined","isNull","isSymbol","isUsableImmutablePrimitive","typeOfX","isset","isEmptyList","isEmptyObject","isEmptyCollection","size","isEmpty","isOneOf","typeName","isFunctor","lookup","of","copy","out","slice","Symbol","Promise","searchObj","nsString","indexOf","parts","split","limit","ind","parent","node","assignDeep","propDescription","getOwnPropertyDescriptor","get","set","writable","includes","xs","lastIndexOf","isTruthy","isFalsy","alwaysTrue","alwaysFalse","equal","equalAll","i","aggregateArray","sliceFrom","startInd","sliceTo","toInd","sliceCopy","genericAscOrdering","lengths","lists","toShortest","listLengths","smallLen","Math","min","list","reduceUntil","pred","op","result","reduceUntilRight","arr","lastIndex","len","findIndexWhere","predicateFulfilled","findIndexWhereRight","findIndicesWhere","findWhere","elm","objUnion","obj1","obj2","objIntersect","objDifference","objComplement","log","console","bind","error","peek","pop","jsonClone","JSON","parse","stringify","toAssocList","toAssocListDeep","TypeConstraint","fromAssocList","OutType","fromAssocListDeep","toArray","compose","arg0","id","negateF","negateF2","negateF3","negateFN","until","predicate","typeInstance","fnOrError","symbolName","noop","normalizeStep","to","step","range","append","listAppend","head","last","tail","init","uncons","unconsr","item0","concatMap","foldableOfA","intersperse","between","lastInd","intercalate","xss","transpose","numLists","ind2","longestListLen","maximum","outLists","outList","subsequences","listLen","pow","entry","j","swapped","ind1","tmp","permutations","repeat","foldl","foldr","foldl1","foldr1","mapAccumL","zero","mapped","tuple","mapAccumR","iterate","lastX","replicate","cycle","unfoldr","resultTuple","findIndex","findIndices","elemIndex","foundInd","elemIndices","take","drop","splitAt","takeWhile","dropWhile","splitPoint","dropWhileEnd","span","breakOnList","at","find","partition","elem","notElem","isPrefixOf","xs1","xs2","limit1","limit2","isSuffixOf","isInfixOf","foundLen","isSubsequenceOf","lenXs1","group","groupBy","equalityOp","prevItem","predOp","inits","tails","stripPrefix","prefix","zip","arr1","arr2","a1","a2","zipN","trimmedLists","zip3","arr3","zip4","arr4","zip5","arr5","zipWith","zipWithN","lenOfTrimmed","zipWith3","xs3","zipWith4","xs4","zipWith5","xs5","unzip","unzipN","lenItem0","any","p","all","and","or","not","sum","product","sortBy","minimum","scanl","scanl1","scanr","scanr1","nub","nubBy","remove","removeBy","sort","sortOn","valueFn","decorated","a0","b0","orderingFn","insert","foundIndex","insertBy","currItem","anyOp","storedItem","removeFirstsBy","unionBy","alreadyAdded","union","intersect","intersectBy","list1","list2","difference","array1","array2","complement","arr0","arrays","typeRefsToStringOrError","defaultErrorMessageCall","tmplContext","contextName","valueName","expectedTypeName","foundTypeName","messageSuffix","isMultiTypeNames","typesCopy","typesToMatchCopy","_getErrorIfNotTypeThrower","errorMessageCall","typeChecker","ValueType","_getErrorIfNotTypesThrower","valueTypes","expectedTypeNames","matchFound","_errorIfNotType","_errorIfNotTypes","getErrorIfNotTypeThrower","getErrorIfNotTypesThrower","errorIfNotType","errorIfNotTypes","lines","words","unwords","unlines","lcaseFirst","toLowerCase","substring","ucaseFirst","toUpperCase","camelCase","pattern","str","classCase"],"mappings":"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"} \ No newline at end of file +{"version":3,"file":"fjl.js","sources":["../../src/function/curry.js","../../src/utils.js","../../src/jsPlatform/array.js","../../src/jsPlatform/function.js","../../src/function/flip.js","../../src/jsPlatform/object.js","../../src/object/typeOf.js","../../src/object/is.js","../../src/object/lookup.js","../../src/object/of.js","../../src/object/copy.js","../../src/object/searchObj.js","../../src/object/assignDeep.js","../../src/jsPlatform/list.js","../../src/boolean.js","../../src/list/map.js","../../src/list/aggregation.js","../../src/list/utils.js","../../src/object/setTheory.js","../../src/object/console.js","../../src/object/jsonClone.js","../../src/object/assocList.js","../../src/object/toArray.js","../../src/object.js","../../src/function/compose.js","../../src/function/id.js","../../src/function/negate.js","../../src/function/until.js","../../src/function/fnOrError.js","../../src/function/noop.js","../../src/function.js","../../src/list/range.js","../../src/jsPlatform/string.js","../../src/jsPlatform.js","../../src/list.js","../../src/errorThrowing.js","../../src/string.js","../../src/fjl.js"],"sourcesContent":["/**\r\n * @author elydelacruz\r\n * @created 12/6/2016.\r\n * @memberOf function\r\n * @description \"Curry strict\" and \"curry arbitrarily\" functions (`curry`, `curryN`).\r\n */\r\n\r\n/**\r\n * @private\r\n * @type {string}\r\n */\r\nconst\r\n\r\n /**\r\n * Returns curried function.\r\n * @private\r\n * @param executeArity {Number}\r\n * @param unmetArityNum {Number}\r\n * @param fn {Function}\r\n * @param argsToCurry {...*}\r\n * @returns {Function} - Curried function.\r\n */\r\n returnCurried = (executeArity, unmetArityNum, fn, argsToCurry) => {\r\n switch (unmetArityNum) {\r\n case 1:\r\n /* eslint-disable */\r\n return function func(x) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 2:\r\n /* eslint-disable */\r\n return function func(a, b) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 3:\r\n /* eslint-disable */\r\n return function func(a, b, c) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 4:\r\n /* eslint-disable */\r\n return function func(a, b, c, d) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n case 5:\r\n /* eslint-disable */\r\n return function func(a, b, c, d, e) {\r\n /* eslint-enable */\r\n return executeAsCurriedFunc(fn, executeArity, unmetArityNum, Array.from(arguments), argsToCurry);\r\n };\r\n default:\r\n return (...args) => executeAsCurriedFunc(fn, executeArity, unmetArityNum, args, argsToCurry);\r\n }\r\n },\r\n\r\n /**\r\n * Returns curried function if unmetArity is not met else returns result of executing\r\n * final function.\r\n * @private\r\n * @param fn {Function}\r\n * @param executeArity {Number}\r\n * @param unmetArity {Number}\r\n * @param args {Array<*>}\r\n * @param argsToCurry {Array<*>}\r\n * @returns {Function|*} - Curried function or result of 'finally' executed function.\r\n */\r\n executeAsCurriedFunc = (fn, executeArity, unmetArity, args, argsToCurry) => {\r\n let concatedArgs = argsToCurry.concat(args),\r\n canBeCalled = (concatedArgs.length >= executeArity) || !executeArity,\r\n newExpectedArity = executeArity - concatedArgs.length;\r\n return !canBeCalled ?\r\n returnCurried(executeArity, newExpectedArity, fn, concatedArgs) :\r\n fn(...concatedArgs);\r\n }\r\n;\r\n\r\nexport const\r\n\r\n /**\r\n * Curries a function up to a given arity.\r\n * @function module:function.curryN\r\n * @param executeArity {Number}\r\n * @param fn {Function}\r\n * @param argsToCurry {...*}\r\n * @returns {Function}\r\n * @throws {Error} - When `fn` is not a function.\r\n */\r\n curryN = (executeArity, fn, ...argsToCurry) => {\r\n if (!fn || !(fn instanceof Function)) {\r\n throw new Error(`\\`curry*\\` functions expect first parameter to be of type \\`Function\\` though received ${fn}?`);\r\n }\r\n return returnCurried(executeArity, executeArity - argsToCurry.length, fn, argsToCurry);\r\n },\r\n\r\n /**\r\n * Curries a function based on it's defined arity (note: rest args param (`...rest`) are not counted in arity).\r\n * @function module:function.curry\r\n * @param fn {Function}\r\n * @param argsToCurry {...*}\r\n * @returns {Function}\r\n */\r\n curry = (fn, ...argsToCurry) => curryN((fn || {}).length, fn, ...argsToCurry),\r\n\r\n /**\r\n * Curries a function up to an arity of 2 (won't call function until 2 or more args).\r\n * @function module:function.curry2\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry2 = fn => curryN(2, fn),\r\n\r\n /**\r\n * Curries a function up to an arity of 3 (won't call function until 3 or more args).\r\n * @function module:function.curry3\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry3 = fn => curryN(3, fn),\r\n\r\n /**\r\n * Curries a function up to an arity of 4 (won't call function until 4 or more args).\r\n * @function module:function.curry4\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry4 = fn => curryN(4, fn),\r\n\r\n /**\r\n * Curries a function up to an arity of 5 (won't call function until 5 or more args).\r\n * @function module:function.curry5\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n curry5 = fn => curryN(5, fn);\r\n","/**\r\n * @module utils\r\n */\r\nimport {curry, curry2} from './function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a function that takes an argument and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakesOne\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakesOne = name => curry((arg, f) => f[name](arg)),\r\n\r\n /**\r\n * Returns a function that takes 2 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes2\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes2 = name => curry((arg1, arg2, f) => f[name](arg1, arg2)),\r\n\r\n /**\r\n * Returns a function that takes 3 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes3\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes3 = name => curry((arg1, arg2, arg3, f) => f[name](arg1, arg2, arg3)),\r\n\r\n /**\r\n * Returns a function that takes 4 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes4\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes4 = name => curry((arg1, arg2, arg3, arg4, f) => f[name](arg1, arg2, arg3, arg4)),\r\n\r\n /**\r\n * Returns a function that takes 5 arguments and an object on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakes5\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakes5 = name => curry((arg1, arg2, arg3, arg4, arg5, f) => f[name](arg1, arg2, arg3, arg4, arg5)),\r\n\r\n /**\r\n * Returns a function that takes an object and one or more arguments on which to execute 'method name'\r\n * with said parameters.\r\n * @function module:utils.fPureTakesOneOrMore\r\n * @param name {String}\r\n * @returns {Function}\r\n */\r\n fPureTakesOneOrMore = name => curry2((f, ...args) => f[name](...args))\r\n\r\n;\r\n","/**\r\n * Created by elyde on 7/20/2017.\r\n * Functional versions of common array methods (`map`, `filter`, etc.) (un-curried);\r\n * @module _jsPlatform_arrayOps\r\n * @private\r\n */\r\n\r\nimport {fPureTakesOne, fPureTakes2, fPureTakesOneOrMore} from '../utils';\r\n\r\nexport const\r\n\r\n /**\r\n * Array.prototype.reverse generator (generates a function that calls the prototype version or a\r\n * shimmed version if it doesn't exist).\r\n * @returns {Function}\r\n */\r\n defineReverse = () =>\r\n Array.prototype.reverse ? x => x.reverse() :\r\n x => x.reduceRight((agg, item) => {\r\n agg.push(item);\r\n return agg;\r\n }, []),\r\n\r\n /**\r\n * Maps a function to functor (list etc.).\r\n * @function module:_jsPlatform_array.map\r\n * @param fn {Function}\r\n * @param functor {Array|{map: {Function}}}\r\n * @returns {Array|{map: {Function}}}\r\n */\r\n map = fPureTakesOne('map'),\r\n\r\n /**\r\n * Filters a functor (list etc.) with passed in function.\r\n * @function module:_jsPlatform_array.filter\r\n * @param fn {Function}\r\n * @param functor {Array|{filter: {Function}}}\r\n * @returns {Array|{filter: {Function}}}\r\n */\r\n filter = fPureTakesOne('filter'),\r\n\r\n /**\r\n * Reduces a foldable (list etc.) with passed in function.\r\n * @function module:_jsPlatform_array.reduce\r\n * @param fn {Function}\r\n * @param functor {Array|{reduce: {Function}}}\r\n * @returns {Array|{reduce: {Function}}}\r\n */\r\n reduce = fPureTakes2('reduce'),\r\n\r\n /**\r\n * Reduces a foldable (list etc.) from the right with passed in function.\r\n * @function module:_jsPlatform_array.reduceRight\r\n * @param fn {Function}\r\n * @param functor {Array|{reduceRight: {Function}}}\r\n * @returns {Array|{reduceRight: {Function}}}\r\n */\r\n reduceRight = fPureTakes2('reduceRight'),\r\n\r\n /**\r\n * For each on functor (Array|Object|etc.).\r\n * @param fn {Function}\r\n * @param functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type of object you pass in unless it doesn't have a `forEach` method.\r\n * @throws {Error} - When passed in functor doesn't have a `forEach` method.\r\n */\r\n forEach = fPureTakesOne('forEach'),\r\n\r\n /**\r\n * Returns `true` if `fn` (predicate) returns true for at least one item\r\n * in functor else returns `false`.\r\n * @param fn {Function} - Predicate.\r\n * @param functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type passed.\r\n * @throws {Error} - When passed in object doesn't have a `some` method.\r\n */\r\n some = fPureTakesOne('some'),\r\n\r\n /**\r\n * Returns `true` if `fn` (predicate) returns true for all items in functor else returns `false`.\r\n * @param fn {Function} - Predicate.\r\n * @param functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type passed.\r\n * @throws {Error} - When passed in object doesn't have an `every` method.\r\n */\r\n every = fPureTakesOne('every'),\r\n\r\n /**\r\n * Array.prototype.join\r\n * @function module:listPrelude.join\r\n * @param separator {String|RegExp}\r\n * @param arr {Array}\r\n * @returns {String}\r\n */\r\n join = fPureTakesOne('join'),\r\n\r\n /**\r\n * Same as Array.prototype.push\r\n * @param item {*}\r\n * @param arr {Array}\r\n * @returns {Number}\r\n */\r\n push = fPureTakesOneOrMore('push'),\r\n\r\n /**\r\n * Reverses an list (shimmed if not exists).\r\n * @function module:listPrelude.reverse\r\n * @return {Array}\r\n */\r\n reverse = defineReverse();\r\n","import {curry, curry2} from '../function/curry';\r\n\r\n/**\r\n * Created by elydelacruz on 9/7/2017.\r\n * @memberOf function\r\n */\r\nexport const\r\n\r\n /**\r\n * Functional `apply` function (takes no context).\r\n * @function module:function.apply\r\n * @param fn {Function}\r\n * @param args {Array|*}\r\n * @returns {*}\r\n */\r\n apply = curry((fn, args) => fn.apply(null, args)),\r\n\r\n /**\r\n * Functional `call` function (takes no context).\r\n * @function module:function.call\r\n * @param fn {Function}\r\n * @param args {...*}\r\n * @returns {*}\r\n */\r\n call = curry2((fn, ...args) => fn.call(null, ...args));\r\n","import {reverse} from '../jsPlatform/array';\r\nimport {apply, call} from '../jsPlatform/function';\r\nimport {curry, curry2} from './curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a curried function requiring given functions arguments in reverse\r\n * (returned function expects 2 or more variables (curried at 2 or more args)).\r\n * @function module:function.flipN\r\n * @param fn {Function}\r\n * @returns {Function}\r\n * @curried\r\n */\r\n flipN = fn => curry2((...args) => apply(fn, reverse(args))),\r\n\r\n /**\r\n * Flips a function's first and second arguments and and returns a new function requiring said arguments in reverse.\r\n * @function module:function.flip\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip = fn => curry((b, a) => call(fn, a, b)),\r\n\r\n /**\r\n * Same as `flip` except returns a flipped function of arity 3.\r\n * @function module:function.flip3\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip3 = fn => curry((c, b, a) => call(fn, a, b, c)),\r\n\r\n /**\r\n * Same as `flip` except returns a flipped function of arity 4.\r\n * @function module:function.flip4\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip4 = fn => curry((d, c, b, a) => call(fn, a, b, c, d)),\r\n\r\n /**\r\n * Same as `flip` except returns a flipped function of arity 5.\r\n * @function module:function.flip5\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n flip5 = fn => curry((e, d, c, b, a) => call(fn, a, b, c, d, e));\r\n","/**\r\n * @memberOf object\r\n * @description Defines some of the platform methods for objects (the ones used within `fjl`).\r\n */\r\n\r\nimport {fPureTakesOne} from '../utils';\r\nimport {curry, curry2} from '../function/curry';\r\nimport {flip, flip3, flip4, flip5} from '../function/flip';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns whether constructor has derived object.\r\n * @function module:object.instanceOf\r\n * @param instanceConstructor {Function} - Constructor.\r\n * @param instance {*}\r\n * @instance {*}\r\n * @returns {Boolean}\r\n */\r\n instanceOf = curry((instanceConstructor, instance) =>\r\n instance instanceof instanceConstructor),\r\n\r\n /**\r\n * @function module:object.hasOwnProperty\r\n * @param propName {*}\r\n * @param typeInstance {*}\r\n * @returns {Boolean}\r\n * @deprecated - Use property directly instead.\r\n */\r\n hasOwnProperty = fPureTakesOne('hasOwnProperty'),\r\n\r\n /**\r\n * @function module:object.length\r\n * @param x {*}\r\n * @returns {Number}\r\n * @throws {Error} - Throws an error if value doesn't have a `length` property (\r\n * `null`, `undefined`, {Boolean}, Symbol, et. al.).\r\n */\r\n length = x => x.length,\r\n\r\n /**\r\n * Contains all the static functions from `Object` but curried and flipped;\r\n * @example\r\n * // E.g., `Object.defineProperties(obj, descriptor)` can now be used like\r\n * import {defineProperties} from 'fjl'\r\n * defineProperties(descriptor, someObj),\r\n * // Et. al.\r\n * @memberOf module:object\r\n * @type {{...Object}}\r\n */\r\n native = Object.getOwnPropertyNames(Object).reduce((agg, key) => {\r\n if (typeof Object[key] !== 'function') {\r\n return agg;\r\n }\r\n const operation = Object[key];\r\n switch (operation.length) {\r\n case 2:\r\n agg[key] = flip(operation);\r\n break;\r\n case 3:\r\n agg[key] = flip3(operation);\r\n break;\r\n case 4:\r\n agg[key] = flip4(operation);\r\n break;\r\n case 5:\r\n agg[key] = flip5(operation);\r\n break;\r\n default:\r\n agg[key] = Object[key];\r\n break;\r\n }\r\n return agg;\r\n }, {}),\r\n\r\n /**\r\n * Gets passed in object's own enumerable keys (same as `Object.keys`).\r\n * @function module:object.keys\r\n * @param obj {*}\r\n * @returns {Array}\r\n */\r\n {keys} = native,\r\n\r\n /**\r\n * Defined as `Object.assign` else is the same thing but shimmed.\r\n * @function module:object.assign\r\n * @param obj0 {Object}\r\n * @param objs {...{Object}}\r\n * @returns {Object}\r\n */\r\n assign = (() => Object.assign ?\r\n (obj0, ...objs) => Object.assign(obj0, ...objs) :\r\n curry2((obj0, ...objs) => objs.reduce((topAgg, obj) => {\r\n return Object.keys(obj).reduce((agg, key) => {\r\n agg[key] = obj[key];\r\n return agg;\r\n }, topAgg);\r\n }, obj0))\r\n )();\r\n","/**\r\n * Created by elyde on 12/18/2016.\r\n * @memberOf object\r\n */\r\nconst _Number = Number.name,\r\n _NaN = 'NaN',\r\n _Null = 'Null',\r\n _Undefined = 'Undefined';\r\n\r\n/**\r\n * Returns the constructor/class/type name of a value.\r\n * @note Returns 'NaN' if value is of type `Number` and value is `isNaN`.\r\n * @note Returns 'Undefined' if value is `undefined`\r\n * @note Returns 'Null' if value is `null`\r\n * For values that have no concrete constructors and/or casters\r\n * (null, NaN, and undefined) we returned normalized names for them ('Null', 'NaN', 'Number')\r\n * @function module:object.typeOf\r\n * @param value {*}\r\n * @returns {string} - Constructor's name or derived name (in the case of `null`, `undefined`, or `NaN` (whose\r\n * normalized names are 'Null', 'Undefined', 'NaN' respectively).\r\n */\r\nexport function typeOf (value) {\r\n let retVal;\r\n if (value === undefined) {\r\n retVal = _Undefined;\r\n }\r\n else if (value === null) {\r\n retVal = _Null;\r\n }\r\n else {\r\n let constructorName = (value).constructor.name;\r\n retVal = constructorName === _Number && isNaN(value) ?\r\n _NaN : constructorName;\r\n }\r\n return retVal;\r\n}\r\n","/**\r\n * Created by elyde on 12/18/2016.\r\n * @memberOf object\r\n */\r\n\r\nimport {typeOf} from './typeOf';\r\nimport {instanceOf, length, keys} from '../jsPlatform/object';\r\nimport {curry} from '../function/curry';\r\n\r\nlet _String = String.name,\r\n _Number = Number.name,\r\n _Object = Object.name,\r\n _Boolean = Boolean.name,\r\n _Function = Function.name,\r\n _Array = Array.name,\r\n _Symbol = 'Symbol',\r\n _Map = 'Map',\r\n _Set = 'Set',\r\n _WeakMap = 'WeakMap',\r\n _WeakSet = 'WeakSet',\r\n _Null = 'Null',\r\n _Undefined = 'Undefined',\r\n _NaN = 'NaN';\r\n\r\nexport const\r\n\r\n /**\r\n * Resolves/normalizes a type name from either a string or a constructor.\r\n * @function module:object.toTypeRef\r\n * @param type {Function|String} - String or function representing a type.\r\n * @returns {String}\r\n * @todo write tests for this function.\r\n */\r\n toTypeRef = type => {\r\n if (!type) {\r\n return typeOf(type);\r\n }\r\n else if (type.constructor === String || (type instanceof Function)) {\r\n return type;\r\n }\r\n return typeOf(type);\r\n },\r\n\r\n /**\r\n * Returns an array of type refs from possible type refs (converts null, undefined, NaN, and other values into\r\n * type refs (either constructor name or constructor name based on whether value(s) is a string, a constructor, or not).\r\n * @function module:object.toTypeRefs\r\n * @param types {...(TypeRef|*)}\r\n * @returns {Array}\r\n * @todo Ensure tests are written for this function.\r\n */\r\n toTypeRefs = (...types) => types.map(toTypeRef),\r\n\r\n /**\r\n * Returns possible Type's TypeRef name.\r\n * @function module:object.toTypeRefName\r\n * @param Type {(TypeRef|*)}\r\n * @returns {String}\r\n * @todo Ensure tests are written for this function.\r\n */\r\n toTypeRefName = Type => {\r\n const ref = toTypeRef(Type);\r\n return ref instanceof Function ? ref.name : ref;\r\n },\r\n\r\n /**\r\n * Returns possible Types' TypeRef names.\r\n * @function module:object.toTypeRefNames\r\n * @param types {...(TypeRef|*)}\r\n * @returns {String[]}\r\n * @todo Ensure tests are written for this function.\r\n */\r\n toTypeRefNames = (...types) => types.map(toTypeRefName),\r\n\r\n /**\r\n * Returns whether a value is a function or not.\r\n * @function module:object.isFunction\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isFunction = instanceOf(Function),\r\n\r\n /**\r\n * Strict type checker. Checks if given value is a direct instance of given type; E.g.,\r\n * @example\r\n * isType(String, 'abcdefg') === true // true\r\n * isType(String.name, 'abcdefg') === true\r\n * isType(Number, NaN) === false\r\n * isType(Number, 99) === true\r\n * isType('Null', 99) === false // though, for `null` and `undefined` checks\r\n * // @see `isset`, in this module, instead\r\n * isType('Undefined', undefined) === true // true\r\n *\r\n * @note Useful where absolute types, or some semblance thereof, are required.\r\n * @function module:object.isType\r\n * @param type {Function|ObjectConstructor|String} - Constructor or constructor name\r\n * @param obj {*}\r\n * @return {Boolean}\r\n */\r\n isType = curry((type, obj) => typeOf(obj) === toTypeRefName(type)),\r\n\r\n /**\r\n * Loose type checker; E.g., If `type` is not a constructor, but a constructor name, does a type check on\r\n * constructor names, else if first check fails and `type` is a constructor, performs an `instanceof` check\r\n * on value with constructor.\r\n * @note Use care when checking for `Array` and/or `Object` since the both are considered objects by `instanceof` checker.\r\n * @note For `null` and `undefined` their class cased names can be used for type checks\r\n * `isOfType('Null', null) === true (passes strict type check)` (or better yet `isset` can be used).\r\n * @throwsafe - Doesn't throw on `null` or `undefined` `obj` values.\r\n * @example\r\n * isOfType(Number, 99) === true // true (passes strict type check (numbers are not instances of `Number`\r\n * // constructor)\r\n * isOfType('Number', 99) === true // true (passes strict type check)\r\n * isOfType(Number, NaN) === true // true. (passes instance of check)\r\n * // If you want \"true\" strict type checking use `isType`\r\n * isOfType(Object, []) === true // true (passes instance of check)\r\n * isOfType(Array, []) === true // true (passes instance of check)\r\n * isOfType(Object, {}) === true // true (passes instance of check)\r\n * isOfType(Object.name, {}) === true // true (Passes strict type check)\r\n * class Abc extends String {}\r\n * isOfType(String, new Abc('abcd')) // true (passes instanceof check)\r\n *\r\n * @function module:object.isOfType\r\n * @param type {Function|String} - Type reference (constructor or `constructor.name`).\r\n * @param x {*} - Value to check.\r\n * @returns {Boolean}\r\n */\r\n isOfType = curry((type, x) => isType(type, x) || instanceOf(type, x)),\r\n\r\n /**\r\n * Checks if `value` is an es2015 `class`.\r\n * @function module:object.isClass\r\n * @param x {*}\r\n * @returns {boolean}\r\n */\r\n isClass = x => x && /^\\s{0,3}class\\s{1,3}/.test((x + '').substr(0, 10)),\r\n\r\n /**\r\n * Returns a boolean depicting whether a value is callable or not.\r\n * @function module:object.isCallable\r\n * @tentative\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isCallable = x => isFunction(x) && !isClass(x),\r\n\r\n /**\r\n * Checks if value is an array (same as `Array.isArray`).\r\n * @function module:object.isArray\r\n * @param value {*}\r\n * @returns {boolean}\r\n */\r\n {isArray} = Array,\r\n\r\n /**\r\n * Checks whether value is an object or not.\r\n * @function module:object.isObject\r\n * @param value\r\n * @returns {Boolean}\r\n */\r\n isObject = isType(_Object),\r\n\r\n /**\r\n * Checks if value is a boolean.\r\n * @function module:object.isBoolean\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isBoolean = isType(_Boolean),\r\n\r\n /**\r\n * Checks if value is a valid number (also checks if isNaN so that you don't have to).\r\n * @function module:object.isNumber\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isNumber = isType(_Number),\r\n\r\n /**\r\n * Checks whether value is a string or not.\r\n * @function module:object.isString\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isString = isType(_String),\r\n\r\n /**\r\n * Checks whether value is of `Map` or not.\r\n * @function module:object.isMap\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isMap = isType(_Map),\r\n\r\n /**\r\n * Checks whether value is of `Set` or not.\r\n * @function module:object.isSet\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isSet = isType(_Set),\r\n\r\n /**\r\n * Checks whether value is of `WeakMap` or not.\r\n * @function module:object.isWeakMap\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isWeakMap =isType(_WeakMap),\r\n\r\n /**\r\n * Checks whether value is of `WeakSet` or not.\r\n * @function module:object.isWeakSet\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isWeakSet = isType(_WeakSet),\r\n\r\n /**\r\n * Checks if value is undefined.\r\n * @function module:object.isUndefined\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isUndefined = isType(_Undefined),\r\n\r\n /**\r\n * Checks if value is null.\r\n * @function module:object.isNull\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isNull = isType(_Null),\r\n\r\n /**\r\n * Checks if value is a `Symbol`.\r\n * @function module:object.isSymbol\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n isSymbol = isType(_Symbol),\r\n\r\n /**\r\n * Checks if given `x` is set and of one of\r\n * [String, Boolean, Number, Symbol] (null and undefined are immutable\r\n * but are not \"usable\" (usually not what we want to operate on).\r\n * @function module:object.isUsableImmutablePrimitive\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isUsableImmutablePrimitive = x => {\r\n const typeOfX = typeOf(x);\r\n return isset(x) &&\r\n [_String, _Number, _Boolean, _Symbol]\r\n .some(Type => Type === typeOfX);\r\n },\r\n\r\n /**\r\n * Checks if !length.\r\n * @function module:object.isEmptyList\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isEmptyList = x => !length(x),\r\n\r\n /**\r\n * Checks if object has own properties/enumerable-props or not.\r\n * @function module:object.isEmptyObject\r\n * @param obj {*}\r\n * @returns {Boolean}\r\n */\r\n isEmptyObject = obj => isEmptyList(keys(obj)),\r\n\r\n /**\r\n * Checks if collection is empty or not (Map, WeakMap, WeakSet, Set etc.).\r\n * @function module:object.isEmptyCollection\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isEmptyCollection = x => x.size === 0,\r\n\r\n /**\r\n * Checks to see if passed in value is empty; I.e.,\r\n * check for one of '', 0, `null`, `undefined`, `false`, empty array, empty object, empty function (zero arity),\r\n * or empty collection (es6 Map, Set, WeakMap, or WeakSet etc. (`!value.size`);\r\n * @function module:object.isEmpty\r\n * @param value {*} - Value to check.\r\n * @returns {Boolean}\r\n */\r\n isEmpty = value => {\r\n if (!value) { // if '', 0, `null`, `undefined`, or `false` then is empty\r\n return true;\r\n }\r\n switch (typeOf(value)) {\r\n case _Array:\r\n case _Function:\r\n return !value.length;\r\n case _Number: // zero and NaN checks happened above so `if number` then it's 'not-an-empty-number' (lol)\r\n return false;\r\n case _Object:\r\n return !keys(value).length;\r\n case _Map:\r\n case _Set:\r\n case _WeakSet:\r\n case _WeakMap:\r\n return !value.size;\r\n case _NaN:\r\n return true;\r\n default:\r\n return !value;\r\n }\r\n },\r\n\r\n /**\r\n * Returns whether passed in values is defined and not null or not.\r\n * @function module:object.isset\r\n * @param x {*}\r\n * @returns {Boolean}\r\n */\r\n isset = x => x !== null && x !== undefined,\r\n\r\n /**\r\n * Checks to see if `x` is of one of the given type refs.\r\n * @function object.isOneOf\r\n * @param x {*}\r\n * @param types {...(TypeRef|*)}\r\n * @returns {boolean}\r\n * @todo write tests for this function.\r\n */\r\n isOneOf = (x, ...types) => {\r\n const typeName = typeOf(x);\r\n return toTypeRefNames(types).some(name => typeName === name);\r\n },\r\n\r\n isFunctor = x => x && x.map && instanceOf(Function, x.map)\r\n\r\n;\r\n","/**\r\n * @memberOf object\r\n */\r\n\r\nimport {isset} from './is';\r\nimport {curry} from '../function/curry';\r\n\r\n/**\r\n * Looks up property and returns it's value; Else `undefined`.\r\n * Method is null safe (will not throw on `null` or `undefined`).\r\n * @function module:object.lookup\r\n * @param key {String} - Key to search on `obj`\r\n * @param obj {Object} - Object to search `name` on.\r\n * @returns {*}\r\n */\r\nexport const lookup = curry((key, obj) => isset(obj) ? obj[key] : undefined);\r\n","import {isFunction, isset, isUsableImmutablePrimitive} from './is';\r\nimport {apply} from '../jsPlatform/function';\r\n\r\n/**\r\n * Creates a value `of` given type; Checks for one of the following construction strategies (in order listed):\r\n * @example\r\n * // - If exists `(value).constructor.of` uses this.\r\n * // - If value is of one String, Boolean, Symbol, or Number types calls it's\r\n * // constructor as a function (in cast form; E.g., `constructor(...args)` )\r\n * // - Else if constructor is a function, thus far, then calls constructor using\r\n * // the `new` keyword (with any passed in args).\r\n\r\n * @function module:object.of\r\n * @param x {*} - Value to derive returned value's type from.\r\n * @param [args] {...*} - Any args to pass in to matched construction strategy.\r\n * @returns {*|undefined} - New value of given value's type else `undefined`.\r\n */\r\nexport const of = (x, ...args) => {\r\n if (!isset(x)) { return undefined; }\r\n const constructor = x.constructor;\r\n if (constructor.hasOwnProperty('of')) {\r\n return apply(constructor.of, args);\r\n }\r\n else if (isUsableImmutablePrimitive(x)) {\r\n return apply(constructor, args);\r\n }\r\n else if (isFunction(constructor)) {\r\n return new constructor(...args);\r\n }\r\n return undefined;\r\n};\r\n","import {typeOf} from './typeOf';\r\nimport {of} from './of';\r\n\r\nexport const\r\n\r\n /**\r\n * Make a copy of a value or optionally copy incoming value onto an outgoing value (second parameter).\r\n * @note If incoming thing is an immmutable primitive (string, number, symbol, null, undefined, boolean)\r\n * it is returned as is.\r\n * @function module:object.copy\r\n * @param x {*} - Thing to copy.\r\n * @param [out = undefined] {*} - Optional value to copy on to. Not required.\r\n * @returns {*} - Copied thing or optionally outgoing value copied onto.\r\n */\r\n copy = (x, out) => {\r\n // if `null`, `undefined`, `''`, `0`, `false` return\r\n if (!x) { return x; }\r\n switch (typeOf(x)) {\r\n case Array.name:\r\n return !out ? x.slice(0) : Object.assign(out, x);\r\n\r\n // If immutable primitive, return it\r\n case Symbol.name:\r\n case Boolean.name:\r\n case String.name:\r\n case Number.name:\r\n case Promise.name:\r\n case Function.name:\r\n case 'NaN':\r\n case 'Null':\r\n case 'Undefined':\r\n return x;\r\n\r\n case 'Map':\r\n case 'Set':\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n return new x.constructor(Array.from(x));\r\n\r\n // Else make copy\r\n default:\r\n return Object.assign(!out ? of(x) : out, x);\r\n }\r\n }\r\n;\r\n\r\nexport default copy;\r\n","import {isset} from './is';\r\nimport {curry} from '../function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Gives you value at key/namespace-key within `obj`; E.g.,\r\n * searchObj('all.your.base', {all: {your: {base: 99}}}) === 99 // `true`\r\n * @note If key is unreachable (undefined) returns `undefined`.\r\n * Useful in cases where we do not want to check each key along the way before getting/checking value; E.g.,\r\n * @example\r\n * ```\r\n * if (obj && obj.all && obj.all.your && obj.all.your.base) {\r\n * // Thing we want to do\r\n * }\r\n *\r\n * // So with our function becomes\r\n * if (searchObj('all.your.base', obj)) {\r\n * // Thing we want to do\r\n * }\r\n * ```\r\n * @function module:object.searchObj\r\n * @param nsString {String}\r\n * @param obj {*}\r\n * @returns {*}\r\n */\r\n searchObj = curry((nsString, obj) => {\r\n if (!obj) { return obj; }\r\n if (nsString.indexOf('.') === -1) {\r\n return obj[nsString];\r\n }\r\n const parts = nsString.split('.'),\r\n limit = parts.length;\r\n let ind = 0,\r\n parent = obj;\r\n for (; ind < limit; ind += 1) {\r\n const node = parent[parts[ind]];\r\n if (!isset(node)) {\r\n return node;\r\n }\r\n parent = node;\r\n }\r\n return parent;\r\n })\r\n;\r\n","\r\nimport {isObject} from './is';\r\nimport {keys} from '../jsPlatform/object';\r\nimport {curry2} from '../function/curry';\r\n\r\nexport const\r\n /**\r\n * Merges all objects down into one (takes two or more args).\r\n * @function module:object.assignDeep\r\n * @param obj0 {Object}\r\n * @param [objs] {...{Object}} - One or more objects to merge onto `obj0`.\r\n * @returns {Object}\r\n */\r\n assignDeep = curry2((obj0, ...objs) =>\r\n !obj0 ? obj0 : objs.reduce((topAgg, obj) =>\r\n !obj ? topAgg : keys(obj).reduce((agg, key) => {\r\n let propDescription = Object.getOwnPropertyDescriptor(agg, key);\r\n // If property is not writable move to next item in collection\r\n if (agg.hasOwnProperty(key) && propDescription &&\r\n !(propDescription.get && propDescription.set) &&\r\n !propDescription.writable) {\r\n return agg;\r\n }\r\n if (isObject(agg[key]) && isObject(obj[key])) {\r\n assignDeep(agg[key], obj[key]);\r\n }\r\n else { agg[key] = obj[key]; }\r\n return agg;\r\n }, topAgg)\r\n , obj0));\r\n","/**\r\n * List operations that overlap (apart from globally overlapping props and functions like `length`)\r\n * on both strings and arrays.\r\n * @memberOf list\r\n */\r\n\r\nimport {fPureTakesOne, fPureTakes2, fPureTakesOneOrMore} from '../utils';\r\n\r\nexport const\r\n\r\n /**\r\n * Concats/appends all functors onto the end of first functor.\r\n * Note: functors passed in after the first one must be of the same type.\r\n * @function module:list.concat\r\n * @param functor {Array|Object|*}\r\n * @param ...functor {Array|Object|*}\r\n * @return {*|Array|Object} - The type passed.\r\n * @throws {Error} - When passed in object doesn't have an `every` method.\r\n */\r\n concat = fPureTakesOneOrMore('concat'),\r\n\r\n /**\r\n * Same as Array.prototype.slice\r\n * @function module:list.slice\r\n * @param separator {String|RegExp}\r\n * @param arr{Array}\r\n * @returns {Array}\r\n */\r\n slice = fPureTakes2('slice'),\r\n\r\n /**\r\n * `Array.prototype.includes` or shim.\r\n * @function module:list.includes\r\n * @param value {*}\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n includes = (() => 'includes' in Array.prototype ?\r\n fPureTakesOne('includes') :\r\n (value, xs) => xs.indexOf(value) > -1)(),\r\n\r\n /**\r\n * Searches list/list-like for given element `x`.\r\n * @function module:list.indexOf\r\n * @param x {*} - Element to search for.\r\n * @param xs {Array|String|*} - list or list like to look in.\r\n * @returns {Number} - `-1` if element not found else index at which it is found.\r\n */\r\n indexOf = fPureTakesOne('indexOf'),\r\n\r\n /**\r\n * Last index of (`Array.prototype.lastIndexOf`).\r\n * @function module:list.lastIndexOf\r\n * @param x {*} - Element to search for.\r\n * @param xs {Array|String|*} - list or list like to look in.\r\n * @returns {Number} - `-1` if element not found else index at which it is found.\r\n */\r\n lastIndexOf = fPureTakesOne('lastIndexOf')\r\n\r\n;\r\n","/**\r\n * @module boolean\r\n * @description Contains functional version of 'always-true', 'always-false', 'is-truthy', and 'is-falsy'.\r\n */\r\nimport {curry, curry2} from './function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns whether `value` is 'truthy' or not\r\n * @function module:boolean.isTruthy\r\n * @param value\r\n * @returns {Boolean}\r\n */\r\n isTruthy = value => !!value,\r\n\r\n /**\r\n * Returns whether `value` is 'falsy' or not\r\n * @function module:boolean.isFalsy\r\n * @param value\r\n * @returns {Boolean}\r\n */\r\n isFalsy = value => !value,\r\n\r\n /**\r\n * Returns `true`.\r\n * @function module:boolean.alwaysTrue\r\n * @returns {Boolean}\r\n */\r\n alwaysTrue = () => true,\r\n\r\n /**\r\n * Returns `false`.\r\n * @function module:boolean.alwaysFalse\r\n * @returns {Boolean}\r\n */\r\n alwaysFalse = () => false,\r\n\r\n /**\r\n * Equality operator.\r\n * @function module:boolean.equal\r\n * @param a {*}\r\n * @param b {*}\r\n * @returns {boolean}\r\n */\r\n equal = curry((a, b) => a === b),\r\n\r\n /**\r\n * Equality operator for all.\r\n * @function module:boolean.equalAll\r\n * @param a {*} - Item `0`.\r\n * @param args {...*} - Others\r\n * @returns {boolean}\r\n */\r\n equalAll = curry2((a, ...args) => args.every(b => equal(a, b)))\r\n\r\n;\r\n","import {length} from '../jsPlatform/object';\r\nimport {curry} from '../function/curry';\r\nimport {typeOf} from '../object/typeOf';\r\nimport {of} from '../object/of';\r\nimport {isFunctor, isset} from '../object/is';\r\n\r\n/**\r\n * Maps a function onto a List (string or array) or a functor (value containing a map method).\r\n * @function module:list.map\r\n * @param fn {Function} - Function to map on given value.\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\nconst map = curry((fn, xs) => {\r\n if (!isset(xs)) { return xs; }\r\n let out = of(xs),\r\n limit,\r\n i = 0;\r\n switch (typeOf(xs)) {\r\n case 'Array':\r\n limit = length(xs);\r\n if (!limit) { return out; }\r\n for (; i < limit; i += 1) {\r\n out.push(fn(xs[i], i, xs));\r\n }\r\n return out;\r\n case 'String':\r\n limit = length(xs);\r\n if (!xs) { return out; }\r\n for (; i < limit; i += 1) {\r\n out += fn(xs[i], i, xs);\r\n }\r\n return out;\r\n default:\r\n if (isFunctor(xs)) { return xs.map(fn); }\r\n\r\n // Other objects\r\n return Object.keys(xs).reduce((agg, key) => {\r\n out[key] = fn(xs[key], key, xs);\r\n return out;\r\n }, out);\r\n }\r\n});\r\n\r\nexport default map;\r\n","\r\nexport const\r\n\r\n /**\r\n * Pushes incoming `item` onto given array and returns said array.\r\n * @private\r\n * @param agg {Array}\r\n * @param item {*}\r\n * @returns {Array}\r\n */\r\n aggregateArray = (agg, item) => {\r\n agg.push(item);\r\n return agg;\r\n }\r\n\r\n;\r\n","/**\r\n * List operator utils module.\r\n * @module listUtils\r\n */\r\nimport {apply} from '../jsPlatform/function'; // un-curried version\r\nimport {slice} from '../jsPlatform/list'; // un-curried version good for both strings and arrays\r\nimport {length} from '../jsPlatform/object';\r\nimport {alwaysFalse} from '../boolean';\r\nimport map from './map';\r\nimport {curry, curry2} from '../function/curry';\r\n\r\nexport * from './aggregation';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a slice of the given list from `startInd` to the end of the list.\r\n * @function module:listUtils.sliceFrom\r\n * @param startInd {Number}\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sliceFrom = curry((startInd, xs) => slice(startInd, undefined, xs)),\r\n\r\n /**\r\n * Slices from index `0` to given index.\r\n * @function module:listUtils.sliceTo\r\n * @param toInd {Number}\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sliceTo = curry((toInd, xs) => slice(0, toInd, xs)),\r\n\r\n /**\r\n * Slices a copy of list.\r\n * @function listUtils.sliceCopy\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sliceCopy = sliceFrom(0),\r\n\r\n /**\r\n * Generic 'ascending order' ordering function (use by the likes of `list.sort` etc.)\r\n * @function module:listUtils.genericAscOrdering\r\n * @param a {*}\r\n * @param b {*}\r\n * @returns {number}\r\n */\r\n genericAscOrdering = curry((a, b) => {\r\n if (a > b) { return 1; }\r\n else if (a < b) { return -1; }\r\n return 0;\r\n }),\r\n\r\n /**\r\n * Returns length of all passed lists in list.\r\n * @function module:listUtils.lengths\r\n * @param lists ...{Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n lengths = curry2((...lists) => map(length, lists)),\r\n\r\n /**\r\n * Returns a list of lists trimmed to the shortest length in given list of lists. @background This method is used by the `zip*` functions to achieve their\r\n * 'slice to smallest' functionality.\r\n * @function module:listUtils.toShortest\r\n * @param lists {...(Array|String|*)}\r\n * @returns {Array|String|*}\r\n */\r\n toShortest = curry2((...lists) => {\r\n const listLengths = apply(lengths, lists),\r\n smallLen = Math.min.apply(Math, listLengths);\r\n return map((list, ind) => listLengths[ind] > smallLen ?\r\n sliceTo(smallLen, list) : sliceCopy(list), lists);\r\n }),\r\n\r\n /**\r\n * Reduces until predicate.\r\n * @function module:listUtils.reduceUntil\r\n * @param pred {Function} - `(item, index, list) => Boolean(...)`\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduceUntil = curry((pred, op, agg, xs) => {\r\n const limit = length(xs);\r\n if (!limit) { return agg; }\r\n let ind = 0,\r\n result = agg;\r\n for (; ind < limit; ind++) {\r\n if (pred(xs[ind], ind, xs)) { break; }\r\n result = op(result, xs[ind], ind, xs);\r\n }\r\n return result;\r\n }),\r\n\r\n /**\r\n * Reduces until predicate (from right to left).\r\n * @function module:listUtils.reduceUntilRight\r\n * @param pred {Function} - `(item, index, list) => Boolean(...)`\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduceUntilRight = curry((pred, op, agg, arr) => {\r\n const limit = length(arr);\r\n if (!limit) { return agg; }\r\n let ind = limit - 1,\r\n result = agg;\r\n for (; ind >= 0; ind--) {\r\n if (pred(arr[ind], ind, arr)) { break; }\r\n result = op(result, arr[ind], ind, arr);\r\n }\r\n return result;\r\n }),\r\n\r\n /**\r\n * Reduces a list with given operation (`op`) function.\r\n * @function module:listUtils.reduce\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduce = reduceUntil(alwaysFalse),\r\n\r\n /**\r\n * Reduces a list with given operation (`op`) function (from right-to-left).\r\n * @function module:listUtils.reduceRight\r\n * @param op {Function} - Operation - `(agg, item, index, list) => agg`\r\n * @param agg {*} - Zero value.\r\n * @param xs {Array|String|*} - List.\r\n * @returns {*}\r\n */\r\n reduceRight = reduceUntilRight(alwaysFalse),\r\n\r\n /**\r\n * Gets last index of a list/list-like (Array|String|Function etc.).\r\n * @function module:listUtils.lastIndex\r\n * @param x {Array|String|*} - list like or list.\r\n * @returns {Number} - `-1` if no element found.\r\n */\r\n lastIndex = x => { const len = length(x); return len ? len - 1 : 0; },\r\n\r\n /**\r\n * Finds index in string or list.\r\n * @function module:listUtils.findIndexWhere\r\n * @param pred {Function} - Predicate.\r\n * @param arr {Array|String}\r\n * @returns {Number} - `-1` if predicate not matched else `index` found\r\n */\r\n findIndexWhere = curry((pred, arr) => {\r\n let ind = 0;\r\n const limit = length(arr);\r\n for (; ind < limit; ind += 1) {\r\n const predicateFulfilled = !!pred(arr[ind], ind, arr);\r\n if (predicateFulfilled) {\r\n return ind;\r\n }\r\n }\r\n return -1;\r\n }),\r\n\r\n /**\r\n * Finds index in list from right to left.\r\n * @function module:listUtils.findIndexWhereRight\r\n * @param pred {Function} - Predicate.\r\n * @param arr {Array|String}\r\n * @returns {Number} - `-1` if predicate not matched else `index` found\r\n */\r\n findIndexWhereRight = curry((pred, arr) => {\r\n let ind = length(arr) - 1;\r\n for (; ind >= 0; ind -= 1) {\r\n const predicateFulfilled = !!pred(arr[ind], ind, arr);\r\n if (predicateFulfilled) {\r\n return ind;\r\n }\r\n }\r\n return -1;\r\n }),\r\n\r\n /**\r\n * @function module:listUtils.findIndicesWhere\r\n * @param pred {Function}\r\n * @param xs {Array|String|*} - list or list like.\r\n * @returns {Array|undefined}\r\n */\r\n findIndicesWhere = curry((pred, xs) => {\r\n const limit = length(xs);\r\n let ind = 0,\r\n out = [];\r\n for (; ind < limit; ind++) {\r\n if (pred(xs[ind], ind, xs)) { out.push(ind); }\r\n }\r\n return out.length ? out : undefined;\r\n }),\r\n\r\n /**\r\n * @function module:listUtils.findWhere\r\n * @param pred {Function}\r\n * @param xs {Array|String|*} - list or list like.\r\n * @returns {*}\r\n */\r\n findWhere = curry((pred, xs) => {\r\n let ind = 0,\r\n limit = length(xs);\r\n if (!limit) { return; }\r\n for (; ind < limit; ind++) {\r\n let elm = xs[ind];\r\n if (pred(elm, ind, xs)) { return elm; }\r\n }\r\n })\r\n\r\n;\r\n","import {assignDeep} from './assignDeep';\r\nimport {keys} from '../jsPlatform/object';\r\nimport {reduce} from '../list/utils';\r\nimport {curry, curry2} from '../function/curry';\r\n\r\nexport const\r\n\r\n objUnion = curry((obj1, obj2) => assignDeep(obj1, obj2)),\r\n\r\n objIntersect = curry((obj1, obj2) => reduce((agg, key) => {\r\n if (obj2.hasOwnProperty(key)) {\r\n agg[key] = obj2[key];\r\n }\r\n return agg;\r\n }, {}, keys(obj1))),\r\n\r\n objDifference = curry((obj1, obj2) => reduce((agg, key) => {\r\n if (!obj2.hasOwnProperty(key)) {\r\n agg[key] = obj1[key];\r\n }\r\n return agg;\r\n }, {}, keys(obj1))),\r\n\r\n objComplement = curry2((obj0, ...objs) => reduce((agg, obj) =>\r\n assignDeep(agg, objDifference(obj, obj0)), {}, objs));\r\n","/**\r\n * @module console\r\n * @description Console exports.\r\n */\r\nexport const\r\n\r\n /**\r\n * `Console.log` method.\r\n * @function module:console.log\r\n * @params args {...*}\r\n * @returns {void}\r\n */\r\n log = console.log.bind(console),\r\n\r\n /**\r\n * `Console.error` method.\r\n * @function module:console.error\r\n * @params args {...*}\r\n * @returns {void}\r\n */\r\n error = console.error.bind(console),\r\n\r\n /**\r\n * Peeks (console.log) at incoming value(s) and returns the last value.\r\n * @function module:console.peek\r\n * @param args {...*}\r\n * @returns {*} Last given value (if one or more values) else first value.\r\n */\r\n peek = (...args) => (log(...args), args.pop())\r\n\r\n;\r\n","export const\r\n\r\n /**\r\n * Clones and object or array using `JSON.parse(JSON.stringify(...))` pattern.\r\n * @function module:object.jsonClone\r\n * @param x {*}\r\n * @returns {*}\r\n */\r\n jsonClone = x => JSON.parse(JSON.stringify(x))\r\n\r\n;\r\n","import {isArray, isType} from './is';\r\nimport {keys} from '../jsPlatform/object';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns an associated list from given object.\r\n * @note Useful for working with plain javascript objects.\r\n * @function module:object.toAssocList\r\n * @param obj {(Object|Array|*)}\r\n * @returns {Array.<*, *>}\r\n */\r\n toAssocList = obj => keys(obj).map(key => [key, obj[key]]),\r\n\r\n /**\r\n * Returns an associated list from given object (deeply (on incoming object's type)).\r\n * @note Does deep conversion on all values of passed in type's type.\r\n * @function module:object.toAssocListDeep\r\n * @param obj {*}\r\n * @param [TypeConstraint = Object] {(Constructor|Function)} - Type constraint to convert on.\r\n * @returns {*}\r\n */\r\n toAssocListDeep = (obj, TypeConstraint = Object) => keys(obj).map(key =>\r\n TypeConstraint && isType(TypeConstraint, obj[key]) ?\r\n [key, toAssocListDeep(obj[key], TypeConstraint)] :\r\n [key, obj[key]]\r\n ),\r\n\r\n /**\r\n * From associated list to object.\r\n * @function module:object.fromAssocList\r\n * @param xs {Array.} - Associated list.\r\n * @param [OutType = Object] {Constructor|Function} - Output type. Default `Object`.\r\n * @returns {*} - Default is `Object`\r\n */\r\n fromAssocList = (xs, OutType = Object) => xs.reduce((agg, [key, value]) => {\r\n agg[key] = value;\r\n return agg;\r\n }, new OutType()),\r\n\r\n /**\r\n * From associated list to object (deep conversion on associative lists (array of 2 value arrays)).\r\n * @note Considers array of arrays associated lists.\r\n * @function module:object.fromAssocListDeep\r\n * @param xs {Array.} - Associated list.\r\n * @param [OutType = Object] {Constructor|Function} - Output type. Default `Object`.\r\n * @returns {*} - Default is `Object`\r\n */\r\n fromAssocListDeep = (xs, OutType = Object) => xs.reduce((agg, [key, value]) => {\r\n if (isArray(value) && isArray(value[0]) && value[0].length === 2) {\r\n agg[key] = fromAssocListDeep(value, OutType);\r\n return agg;\r\n }\r\n agg[key] = value;\r\n return agg;\r\n }, new OutType())\r\n;\r\n","import {typeOf} from './typeOf';\r\nimport {toAssocList} from './assocList';\r\n\r\nexport const\r\n\r\n /**\r\n * Converts incoming value to an array.\r\n * @note For `WeakMap`, `WeakSet`, `Map` and `Set` result is the same as calling `Array.from` on such.\r\n * @note For `null`, `undefined`, `NaN`, `Number{}`, `Symbol{}`, `Boolean{}` returns an empty array.\r\n * @note Method does a shallow conversion;\r\n * @function module:object.toArray\r\n * @param x {*} - Thing to convert from.\r\n * @returns {Array}\r\n */\r\n toArray = x => {\r\n switch (typeOf(x)) {\r\n case 'Null':\r\n case 'Undefined':\r\n return [];\r\n case String.name:\r\n case Array.name:\r\n case 'WeakMap':\r\n case 'WeakSet':\r\n case 'Map':\r\n case 'Set':\r\n return Array.from(x);\r\n case Object.name:\r\n default:\r\n return toAssocList(x);\r\n }\r\n }\r\n\r\n;\r\n","/**\r\n * @module object\r\n * @description Object operations/combinators.\r\n */\r\n\r\nexport * from './jsPlatform/object';\r\nexport * from './object/lookup';\r\nexport * from './object/typeOf';\r\nexport * from './object/copy';\r\nexport * from './object/is';\r\nexport * from './object/of';\r\nexport * from './object/searchObj';\r\nexport * from './object/assignDeep';\r\nexport * from './object/setTheory';\r\nexport * from './object/console';\r\nexport * from './object/jsonClone';\r\nexport * from './object/toArray';\r\nexport * from './object/assocList';\r\n","import {reduceRight} from '../jsPlatform/array';\r\n\r\n/**\r\n * Composes all functions passed in from right to left passing each functions return value to\r\n * the function on the left of itself.\r\n * @function module:function.compose\r\n * @type {Function}\r\n * @param args {...{Function}}\r\n * @returns {Function}\r\n */\r\nexport const compose = (...args) =>\r\n arg0 => reduceRight((value, fn) => fn(value), arg0, args);\r\n","/**\r\n * @memberOf function\r\n */\r\n\r\n/**\r\n * Returns passed in parameter.\r\n * @haskellType `id :: a -> a`\r\n * @function module:function.id\r\n * @param x {*}\r\n * @returns {*}\r\n */\r\nexport const id = x => x;\r\n","/**\r\n * @memberOf function\r\n */\r\n\r\nimport {apply} from '../jsPlatform/function';\r\nimport {curry, curry2} from './curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Negates a function that takes one/no argument.\r\n * @function module:function.negateF\r\n * @param fn {Function}\r\n * @returns {function(*=): boolean}\r\n */\r\n negateF = fn => x => !fn(x),\r\n\r\n /**\r\n * Takes a function that takes two parameters and returns a negated version of given\r\n * function.\r\n * @function module:_negate.negateF2\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n negateF2 = fn => curry((a, b) => !fn(a, b)),\r\n\r\n /**\r\n * Takes a function that takes three parameters and returns a\r\n * negated version of given function.\r\n * @function module:_negate.negateF3\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n negateF3 = fn => curry((a, b, c) => !fn(a, b, c)),\r\n\r\n /**\r\n * Returns a negated version of given function.\r\n * Returned function is variadiac (takes one or more arguments).\r\n * @note function returned is uncurried.\r\n * @uncurried\r\n * @function module:function.negateFN\r\n * @param fn {Function}\r\n * @returns {Function}\r\n */\r\n negateFN = fn => curry2((...args) => !apply(fn, args));\r\n","import {curry} from './curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Run `operation` until predicate returns `true` (like a functional\r\n * version of a while loop).\r\n * @function module:function.until\r\n * @param predicate {Function} :: a -> Boolean\r\n * @param operation {Function} :: a -> a\r\n * @param typeInstance {*} :: * - A monoidal zero or some starting point.\r\n * @returns {*} - What ever type `typeInstance` is\r\n */\r\n until = curry((predicate, operation, typeInstance) => {\r\n let result = typeInstance;\r\n while (!predicate(result)) {\r\n result = operation(result);\r\n }\r\n return result;\r\n });\r\n","import {typeOf} from '../object/typeOf';\r\n\r\nexport const\r\n\r\n /**\r\n * Returns a function or throws an error if given `f` is not a function.\r\n * @function module:function.fnOrError\r\n * @param symbolName {String} - Error message prefix.\r\n * @param f {Function|*} - Expected function.\r\n * @returns {Function}\r\n * @throws {Error} - Error if `f` is not of `function`\r\n */\r\n fnOrError = (symbolName, f) => {\r\n if (!f || !(f instanceof Function)) {\r\n throw new Error(`${symbolName} should be a function. ` +\r\n `Type received: ${typeOf(f)}; Value received: ${f}.`);\r\n }\r\n return f;\r\n }\r\n\r\n;\r\n","/**\r\n * No-op ('op' as in 'operation') - Performs no operation 'always' (good for places where\r\n * a value should always be a function etc.).\r\n * @function module:function.noop\r\n * @returns {undefined}\r\n */\r\nexport const noop = () => undefined;\r\n","/**\r\n * @module function\r\n */\r\nexport * from './jsPlatform/function';\r\nexport * from './function/compose';\r\nexport * from './function/curry';\r\nexport * from './function/flip';\r\nexport * from './function/id';\r\nexport * from './function/negate';\r\nexport * from './function/until';\r\nexport * from './function/fnOrError';\r\nexport * from './function/noop';\r\n","/**\r\n * @module object\r\n */\r\nimport {curry} from '../function/curry';\r\n\r\n/**\r\n * Normalizes step for `from` and `to` combination.\r\n * @function module:list.normalizeStep\r\n * @param from {Number}\r\n * @param to {Number}\r\n * @param [step = 1] {Number}\r\n * @returns {Number}\r\n * @private\r\n */\r\nconst normalizeStep = (from, to, step) => {\r\n if (from > to) {\r\n return step > 0 ? -step : step; // make step negative\r\n }\r\n return step < 0 ? -1 * step : step; // make step positive\r\n};\r\n\r\nexport const\r\n\r\n /**\r\n * Range function - gives you an array contain numbers in given range.\r\n * @note normalizes `step` to be valid if range numbers given are invalid\r\n * (forces `step` to be negative if range required is in the negative direction\r\n * and forces `step` to be positive if range required is in the other direction).\r\n * @function module:list.range\r\n * @param from {Number}\r\n * @param to {Number}\r\n * @param [step = 1] {Number}\r\n * @returns {Array.}\r\n */\r\n range = curry((from, to, step = 1) => {\r\n let i = from;\r\n const out = [];\r\n step = normalizeStep(from, to, step);\r\n if (step === 0 || from === to) { return [from]; }\r\n for (; (to - i) * step >= 0; i += step) { out.push(i); }\r\n return out;\r\n })\r\n;\r\n","/**\r\n * Created by elydelacruz on 9/6/2017.\r\n */\r\n\r\nimport {fPureTakesOne} from '../utils';\r\n\r\n/**\r\n * Functional version of `String.prototype.split`.\r\n * @function module:_string.split\r\n * @param separator {String|RegExp}\r\n * @param str {String}\r\n * @returns {Array}\r\n */\r\nexport const split = fPureTakesOne('split');\r\n","/**\r\n * @module jsPlatform_\r\n * @private\r\n */\r\nexport * from './jsPlatform/object';\r\nexport * from './jsPlatform/array';\r\nexport * from './jsPlatform/list';\r\nexport * from './jsPlatform/string';\r\nexport * from './jsPlatform/function';\r\n","/**\r\n * List operations module.\r\n * @module list\r\n */\r\nimport {concat as listAppend, indexOf, slice, includes} from './jsPlatform/list';\r\nimport {apply} from './jsPlatform/function';\r\nimport {length} from './jsPlatform/object';\r\nimport {negateF3, negateF2} from './function/negate';\r\nimport {curry, curry2, curry3} from './function/curry';\r\nimport {isTruthy, isFalsy} from './boolean';\r\nimport {lookup} from './object/lookup';\r\nimport {of} from './object/of';\r\nimport {isset, isString} from './object/is';\r\nimport {typeOf} from './object/typeOf';\r\nimport map from './list/map';\r\n\r\nimport {\r\n sliceFrom, sliceTo, lengths,\r\n toShortest, aggregateArray,\r\n reduceUntil, reduce, reduceRight, lastIndex,\r\n findIndexWhere, findIndexWhereRight, findIndicesWhere,\r\n findWhere, sliceCopy, genericAscOrdering\r\n}\r\n from './list/utils';\r\n\r\nexport * from './list/range';\r\n\r\nexport * from './list/utils';\r\n\r\nexport {map};\r\n\r\nexport {slice, includes, indexOf, lastIndexOf, push} from './jsPlatform';\r\n\r\nexport const\r\n\r\n /**\r\n * Append two, or more, lists, i.e.,\r\n * @example\r\n * expectEqual(append(take(13, alphabetString), drop(13, alphabetString)), alphabetString); // true\r\n *\r\n * // Another example\r\n * const result = append(\r\n * alphabetStr.split(''),\r\n * alphabetStr.split('')\r\n * ),\r\n * expected = repeat(2, alphabetStr).split('');\r\n *\r\n * shallowEquals(result, expected) === true // `true`\r\n *\r\n * @function module:list.append\r\n * @param [args] {...(Array|String|*)} - One or more lists or list likes (strings etc.).\r\n * @returns {(Array|String|*)} - Same type as list like passed in.\r\n */\r\n append = curry2((...args) => apply(listAppend, args)),\r\n\r\n /**\r\n * Returns head of list (first item of list).\r\n * @haskellType `head :: [a] -> a`\r\n * @function module:list.head\r\n * @param x {Array|String}\r\n * @returns {*} - First item from list\r\n */\r\n head = x => x[0],\r\n\r\n /**\r\n * Returns last item of list.\r\n * @haskellType `last :: [a] -> a`\r\n * @function module:list.last\r\n * @param xs {Array|String}\r\n * @returns {*}\r\n */\r\n last = xs => xs[lastIndex(xs)],\r\n\r\n /**\r\n * Returns tail part of list (everything after the first item as new list).\r\n * @haskelType `tail :: [a] -> [a]`\r\n * @function module:list.tail\r\n * @param xs {Array|String}\r\n * @returns {Array|String}\r\n */\r\n tail = xs => sliceFrom(1, xs),\r\n\r\n /**\r\n * Returns everything except last item of list as new list.\r\n * @haskellType `init :: [a] -> [a]`\r\n * @function module:list.init\r\n * @param xs {Array|String}\r\n * @returns {Array|String}\r\n */\r\n init = xs => sliceTo(lastIndex(xs), xs),\r\n\r\n /**\r\n * Returns `head` and `tail` of passed in list/string in a tuple.\r\n * @haskellType `uncons :: [a] -> Maybe (a, [a])`\r\n * @function module:list.uncons\r\n * @param xs {Array|String}\r\n * @returns {Array|undefined}\r\n */\r\n uncons = xs => !xs || length(xs) === 0 ? undefined : [head(xs), tail(xs)],\r\n\r\n /**\r\n * Returns `tail` and `head` of passed in list/string in a tuple.\r\n * @haskellType `unconsr :: [a] -> Maybe ([a], a)`\r\n * @function module:list.unconsr\r\n * @param xs {Array|String}\r\n * @returns {Array|String|*|undefined}\r\n */\r\n unconsr = xs => !xs || length(xs) === 0 ? undefined : [init(xs), last(xs)],\r\n\r\n /**\r\n * Concatenates all the elements of a container of lists.\r\n * @haskellType `concat :: Foldable t => t [a] -> [a]`\r\n * @function module:list.concat\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n concat = xs => {\r\n switch (length(xs)) {\r\n case undefined:\r\n case 0:\r\n return [];\r\n case 1:\r\n const item0 = xs[0];\r\n return item0 && item0.slice ? sliceCopy(item0) : item0;\r\n case 2:\r\n default:\r\n return apply(append, xs);\r\n }\r\n },\r\n\r\n /**\r\n * Map a function over all the elements of a container and concatenate the resulting lists.\r\n * @haskellType `concatMap :: Foldable t => (a -> [b]) -> t a -> [b]`\r\n * @function module:list.concatMap\r\n * @param fn {Function}\r\n * @param foldableOfA {Array}\r\n * @returns {Array}\r\n */\r\n concatMap = curry((fn, foldableOfA) => concat(map(fn, foldableOfA))),\r\n\r\n /**\r\n * Returns a copy of the passed in list reverses.\r\n * @haskellType `reverse :: [a] -> [a]`\r\n * @function module:list.reverse\r\n * @param xs {Array|String}\r\n * @returns {Array|String}\r\n */\r\n reverse = xs => {\r\n if (!isset(xs) || !xs.length) {\r\n return xs;\r\n }\r\n let out = of(xs),\r\n i = xs.length - 1;\r\n switch (typeOf(xs)) {\r\n case 'String':\r\n for (; i >= 0; i -= 1) {\r\n out += xs[i];\r\n }\r\n return out;\r\n default:\r\n for (; i >= 0; i -= 1) {\r\n out.push(xs[i]);\r\n }\r\n return out;\r\n }\r\n },\r\n\r\n /**\r\n * Takes an element and a list and `intersperses' that element between the\r\n * elements of the list.\r\n * @function module:list.intersperse\r\n * @note In our version of the function javascript is loosely typed so,\r\n * so is our function (to much overhead to make it typed) so `between` can be any value.\r\n * @param between {*} - Should be of the same type of elements contained in list.\r\n * @param arr {Array|String} - List.\r\n * @returns {Array|String}\r\n */\r\n intersperse = curry((between, xs) => {\r\n if (!xs || !xs.length) {\r\n return xs;\r\n }\r\n const limit = xs.length,\r\n lastInd = limit - 1;\r\n let out = of(xs),\r\n i = 0;\r\n if (isString(xs)) {\r\n for (; i < limit; i += 1) {\r\n out += i === lastInd ?\r\n xs[i] : xs[i] + between;\r\n }\r\n return out;\r\n }\r\n for (; i < limit; i += 1) {\r\n if (i === lastInd) {\r\n out.push(xs[i]);\r\n } else {\r\n out.push(xs[i], between);\r\n }\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * `intercalate xs xss` is equivalent to (concat (intersperse xs xss)). It inserts the list xs in between the lists in xss and concatenates the result.\r\n * @haskellType `intercalate :: [a] -> [[a]] -> [a]`\r\n * @function module:list.intercalate\r\n * @param xs {Array|String}\r\n * @param xss {Array|String}\r\n * @returns {Array|String}\r\n */\r\n intercalate = curry((xs, xss) => {\r\n if (isString(xss)) {\r\n return intersperse(xs, xss);\r\n }\r\n return concat(intersperse(xs, xss));\r\n }),\r\n\r\n /**\r\n * Transposes rows and columns into lists by index; E.g.,\r\n * Haskell example:\r\n * ```\r\n * transpose [[1,2,3],[4,5,6]] == [[1,4],[2,5],[3,6]]\r\n *\r\n * -- Notice the shorter arrays are ignored after their last index is copied over:\r\n * transpose [[10,11],[20],[],[30,31,32]] == [[10,20,30],[11,31],[32]]\r\n * ```\r\n * @note from columns to rows.\r\n * @note Empty lists are ignored.\r\n * @haskellType `transpose :: [[a]] -> [[a]]`\r\n * @function module:list.transpose\r\n * @param xss {Array}\r\n * @returns {Array}\r\n */\r\n transpose = xss => {\r\n let numLists = length(xss),\r\n ind = 0, ind2;\r\n if (!numLists) {\r\n return [];\r\n }\r\n const listLengths = apply(lengths, xss),\r\n longestListLen = maximum(listLengths),\r\n outLists = [];\r\n for (; ind < longestListLen; ind += 1) {\r\n const outList = [];\r\n for (ind2 = 0; ind2 < numLists; ind2 += 1) {\r\n if (listLengths[ind2] < ind + 1) {\r\n continue;\r\n }\r\n outList.push(xss[ind2][ind]);\r\n }\r\n outLists.push(outList);\r\n }\r\n return filter(x => length(x) > 0, outLists);\r\n },\r\n\r\n /**\r\n * Generates 2^n sub-sequences for passed in sequence (string/list) (`n` is\r\n * the length of the passed in sequence so: 2^length(xs)).\r\n * Note: The return value doubles per index/character passed in so use with caution!\r\n * Also note that for 2^16 (or for a sequence of 16 characters) this algorithm\r\n * will generate 65536 sub-sequences! So caution should be taken to not\r\n * use this with sequences above a certain length on certain platform (the browser thread in specific).\r\n * @function module:list.subsequences\r\n * @jsperftest https://jsperf.com/subsequences\r\n * @param xs {Array|String}\r\n * @returns {Array.}\r\n */\r\n subsequences = xs => {\r\n const listLen = length(xs),\r\n len = Math.pow(2, listLen),\r\n out = [];\r\n for (let i = 0; i < len; i += 1) {\r\n let entry = [];\r\n for (let j = 0; j < listLen; j += 1) {\r\n if (i & (1 << j)) {\r\n entry.push(xs[j]);\r\n }\r\n }\r\n out.push(entry);\r\n }\r\n return out;\r\n },\r\n\r\n /**\r\n * Returns an array with the given indices swapped.\r\n * @function module:list.swapped\r\n * @param ind1 {Number}\r\n * @param ind2 {Number}\r\n * @param list {Array}\r\n * @returns {Array} - Copy of incoming with swapped values at indices.\r\n */\r\n swapped = curry((ind1, ind2, list) => {\r\n const out = sliceCopy(list),\r\n tmp = out[ind1];\r\n out[ind1] = out[ind2];\r\n out[ind2] = tmp;\r\n return out;\r\n }),\r\n\r\n /**\r\n * Returns a list of permutations for passed in list.\r\n * Use caution with lists above a length of 15 (will take long due to nature of\r\n * algorithm).\r\n * @function module:list.permutations\r\n * @param xs {Array} - List.\r\n * @returns {Array} - Array of permutations.\r\n */\r\n permutations = xs => {\r\n const limit = length(xs);\r\n\r\n if (!limit || limit === 1) {\r\n return [xs];\r\n }\r\n\r\n let list = sliceCopy(xs),\r\n c = repeat(limit, 0),\r\n i = 0;\r\n\r\n const out = [list];\r\n\r\n for (; i < limit; i++) {\r\n if (c[i] < i) {\r\n list = swapped(i % 2 === 0 ? 0 : c[i], i, list);\r\n out.push(list);\r\n c[i] += 1;\r\n i = 0;\r\n continue;\r\n }\r\n c[i] = 0;\r\n }\r\n\r\n return out;\r\n },\r\n\r\n /**\r\n * Left associative fold. Reduces a container of elements down by the given operation (same as [].reduce).\r\n * @function module:list.foldl\r\n * @param fn {Function}\r\n * @param zero {*} - Aggregator.\r\n * @param functor {Array}\r\n * @returns {*} - Whatever type is lastly returned from `fn`.\r\n */\r\n foldl = reduce,\r\n\r\n /**\r\n * Right associative fold. Reduces a container of elements down by the given operation (same as [].reduceRight).\r\n * @function module:list.foldr\r\n * @param fn {Function}\r\n * @param zero {*} - Aggregator.\r\n * @param functor {Array}\r\n * @returns {*} - Whatever type is lastly returned from `fn`.\r\n */\r\n foldr = reduceRight,\r\n\r\n /**\r\n * A variant of `foldl` except that this one doesn't require the starting point. The starting point/value will be pulled\r\n * out from a copy of the container.\r\n * @function module:list.foldl1\r\n * @param op {Function}\r\n * @param xs {Array}\r\n * @returns {*} - Whatever type is lastly returned from `op`.\r\n */\r\n foldl1 = curry((op, xs) => {\r\n const parts = uncons(xs);\r\n return !parts ? [] : reduce(op, parts[0], parts[1]);\r\n }),\r\n\r\n /**\r\n * A variant of `foldr` except that this one doesn't require the starting point/value. The starting point/value will be pulled\r\n * out from a copy of the container.\r\n * @function module:list.foldr1\r\n * @param op {Function}\r\n * @param xs {Array}\r\n * @returns {*} - Whatever type is lastly returned from `op`.\r\n */\r\n foldr1 = curry((op, xs) => {\r\n const parts = unconsr(xs);\r\n return !parts ? [] : reduceRight(op, parts[1], parts[0]);\r\n }),\r\n\r\n /**\r\n * Performs a map then a reduce all in one (from left-to-right). Returns a tuple\r\n * containing the aggregated value and the result of mapping the passed in function on passed in list.\r\n * @function module:list.mapAccumL\r\n * @param op {Function} - Function : [aggregated, mapResult]\r\n * @param zero {*} - An instance of the passed in list type used to aggregateArray on.\r\n * @param xs {Array} - list type.\r\n * @return {Array} - [aggregated, list]\r\n */\r\n mapAccumL = curry((op, zero, xs) => {\r\n const list = sliceCopy(xs),\r\n limit = length(xs);\r\n if (!limit) {\r\n return [zero, list];\r\n }\r\n let ind = 0,\r\n agg = zero,\r\n mapped = [],\r\n tuple;\r\n for (; ind < limit; ind++) {\r\n tuple = op(agg, list[ind], ind);\r\n agg = tuple[0];\r\n mapped = tuple[1];\r\n }\r\n return [agg, mapped];\r\n }),\r\n\r\n /**\r\n * Performs a map and a reduce all in one (from right-to-left). Returns a tuple\r\n * containing the aggregated value and the result of mapping the passed in function on passed in list.\r\n * @function module:list.mapAccumR\r\n * @param op {Function} - Function : [aggregated, mapResult]\r\n * @param zero {*} - An instance of the passed in list type used to aggregateArray on.\r\n * @param xs {Array} - list type.\r\n * @return {Array} - [aggregated, list]\r\n */\r\n mapAccumR = curry((op, zero, xs) => {\r\n const list = sliceCopy(xs),\r\n limit = length(xs);\r\n if (!limit) {\r\n return [zero, list];\r\n }\r\n let ind = limit - 1,\r\n agg = zero,\r\n mapped = [],\r\n tuple;\r\n for (; ind >= 0; ind--) {\r\n tuple = op(agg, list[ind], ind);\r\n agg = tuple[0];\r\n mapped = tuple[1];\r\n }\r\n return [agg, mapped];\r\n }),\r\n\r\n /**\r\n * iterate f x returns an infinite list of repeated applications of f to x.\r\n * @function module:list.iterate\r\n * @example `iterate(5, f, x) == [x, f(x), f(f(x)), ...]`\r\n * @param limit {Number}\r\n * @param op {Function} - Operation.\r\n * @param x {*} - Starting point.\r\n * @returns {*}\r\n */\r\n iterate = curry((limit, op, x) => {\r\n let ind = 0,\r\n out = [],\r\n lastX = x;\r\n for (; ind < limit; ind += 1) {\r\n out.push(lastX);\r\n lastX = op(lastX, ind);\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Repeats `x` `limit` number of times.\r\n * @function module:list.repeat\r\n * @param limit {Number}\r\n * @param x {*}\r\n * @return {Array}\r\n */\r\n repeat = curry((limit, x) => iterate(limit, a => a, x)),\r\n\r\n /**\r\n * Same as `repeat` due to the nature of javascript (see haskell version for usage).\r\n * @function module:list.replicate\r\n * @param limit {Number}\r\n * @param x {*}\r\n * @return {Array}\r\n */\r\n replicate = repeat,\r\n\r\n /**\r\n * Replicates a list `limit` number of times and appends the results (concat)\r\n * @function module:list.cycle\r\n * @param limit {Number}\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n cycle = curry((limit, xs) => concat(replicate(limit, xs))),\r\n\r\n /**\r\n * Unfolds a value into a list of somethings.\r\n * @haskellType `unfoldr :: (b -> Maybe (a, b)) -> b -> [a]`\r\n * @function module:list.unfoldr\r\n * @param op {Function} - Operation to perform (should return a two component tuple (item to aggregateArray and item to unfold in next iteration).\r\n * @param x {*} - Starting parameter to unfold from.\r\n * @returns {Array} - An array of whatever you return from `op` yielded.\r\n */\r\n unfoldr = curry((op, x) => {\r\n let ind = 0,\r\n out = [],\r\n resultTuple = op(x, ind, out);\r\n while (resultTuple) {\r\n out.push(resultTuple[0]);\r\n resultTuple = op(resultTuple[1], ++ind, out);\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Finds index in string or list (alias for `findIndex`).\r\n * @function module:list.findIndex\r\n * @param pred {Function} - Predicate.\r\n * @param arr {Array|String}\r\n * @returns {Number} - `-1` if predicate not matched else `index` found\r\n */\r\n findIndex = findIndexWhere,\r\n\r\n /**\r\n * @function module:list.findIndices\r\n * @param pred {Function}\r\n * @param xs {Array} - list or list like.\r\n * @returns {Array|undefined}\r\n */\r\n findIndices = findIndicesWhere,\r\n\r\n /**\r\n * @function module:list.elemIndex\r\n * @param x {*} - Element to search for.\r\n * @param xs {Array} - list or list like.\r\n * @returns {*}\r\n */\r\n elemIndex = curry((x, xs) => {\r\n const foundInd = indexOf(x, xs);\r\n return foundInd !== -1 ? foundInd : undefined;\r\n }),\r\n\r\n /**\r\n * @function module:list.elemIndices\r\n * @param value {*} - Element to search for.\r\n * @param xs {Array} - list or list like.\r\n * @returns {*}\r\n */\r\n elemIndices = curry((value, xs) => findIndices(x => x === value, xs)),\r\n\r\n /**\r\n * Takes `n` items from start of list to `limit` (exclusive).\r\n * @function module:list.take\r\n * @param list {Array|String}\r\n * @param limit {Number}\r\n * @returns {String|Array} - Passed in type's type\r\n */\r\n take = sliceTo,\r\n\r\n /**\r\n * Drops `n` items from start of list to `count` (exclusive).\r\n * @function module:list.drop\r\n * @param list {Array|String}\r\n * @param count {Number}\r\n * @returns {String|Array} - Passed in type's type\r\n */\r\n drop = sliceFrom,\r\n\r\n /**\r\n * Splits `x` in two at given `index` (exclusive (includes element/character at\r\n * given index in second part of returned list)).\r\n * @function module:list.splitAt\r\n * @param ind {Number} - Index to split at.\r\n * @param list {Array|String} - functor (list or string) to split.\r\n * @returns {Array|String} - List like type passed\r\n */\r\n splitAt = (ind, list) => [sliceTo(ind, list), sliceFrom(ind, list)],\r\n\r\n /**\r\n * Gives an list with passed elements while predicate was true.\r\n * @function module:list.takeWhile\r\n * @param pred {Function} - Predicate<*, index, list|string>\r\n * @param list {Array|String}\r\n * @returns {Array}\r\n */\r\n takeWhile = curry((pred, list) =>\r\n reduceUntil(\r\n negateF3(pred), // predicate\r\n isString(list) ?\r\n (agg, x) => agg + x :\r\n aggregateArray, // operation\r\n of(list), // aggregate\r\n list\r\n )),\r\n\r\n /**\r\n * Returns an list without elements that match predicate.\r\n * @function module:list.dropWhile\r\n * @param pred {Function} - Predicate<*, index, list|string>\r\n * @param list {Array|String}\r\n * @refactor\r\n * @returns {Array|String}\r\n */\r\n dropWhile = curry((pred, list) => {\r\n const limit = length(list),\r\n splitPoint =\r\n findIndexWhere(\r\n (x, i, xs) => !pred(x, i, xs),\r\n list\r\n );\r\n\r\n return splitPoint === -1 ?\r\n sliceFrom(limit, list) :\r\n slice(splitPoint, limit, list);\r\n }),\r\n\r\n /**\r\n * @function module:list.dropWhileEnd\r\n * @param pred {Function} - Predicate<*, index, list|string>\r\n * @param list {Array|String}\r\n * @refactor\r\n * @returns {Array|String}\r\n */\r\n dropWhileEnd = curry((pred, list) => {\r\n const splitPoint =\r\n findIndexWhereRight(\r\n (x, i, xs) => !pred(x, i, xs),\r\n list\r\n );\r\n if (splitPoint === -1) {\r\n return of(list);\r\n }\r\n return sliceTo(splitPoint + 1, list);\r\n }),\r\n\r\n /**\r\n * Gives you the `span` of items matching predicate\r\n * and items not matching predicate; E.g., Gives an\r\n * array of arrays; E.g., [[matching-items], [non-matching-items]]\r\n * @function list.span\r\n * @param pred {Function} - List predicate (`(x, i, list) => bool`)\r\n * @param list {Array|String}\r\n * @returns {(Array>|Array)}\r\n * @type {Function}\r\n */\r\n span = curry((pred, list) => {\r\n const splitPoint = findIndexWhere(negateF3(pred), list);\r\n return splitPoint === -1 ?\r\n [sliceFrom(0, list), of(list)] :\r\n splitAt(splitPoint, list);\r\n }),\r\n\r\n /**\r\n * breakOnList, applied to a predicate p and a list xs, returns a tuple\r\n * where first element is longest prefix (possibly empty) of xs of elements\r\n * that do not satisfy p and second element is the remainder of the list:\r\n * @haskellExample\r\n * Replace `break` with `breakOnList` for our version.\r\n * ```\r\n * breakOnList (> 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4])\r\n * breakOnList (< 9) [1,2,3] == ([],[1,2,3])\r\n * breakOnList (> 9) [1,2,3] == ([1,2,3],[])\r\n * ```\r\n * @function module:list.breakOnList\r\n * @param pred {Function}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n breakOnList = curry((pred, list) => {\r\n const splitPoint = findIndexWhere(negateF3(pred), list);\r\n return splitPoint === -1 ?\r\n [of(list), sliceFrom(0, list)] : reverse(splitAt(splitPoint, list));\r\n }),\r\n\r\n /**\r\n * Gets item at index.\r\n * @function module:list.at\r\n * @param ind {Number} - Index.\r\n * @param xs {Array} - list or list like.\r\n * @returns {*|undefined} - Item or `undefined`.\r\n */\r\n at = lookup,\r\n\r\n /**\r\n * Find an item in structure of elements based on given predicate (`pred`).\r\n * @function module:list.find\r\n * @param pred {Function}\r\n * @param xs {Array} - list or list like.\r\n * @returns {*} - Found item.\r\n */\r\n find = findWhere,\r\n\r\n /**\r\n * For each function (same as `[].forEach` except in functional format).\r\n * @function module:list.forEach\r\n * @param fn {Function} - Operation (`(element, index, list) => {...}`, etc.)\r\n * @param xs {(Array|String)}\r\n * @returns {void}\r\n */\r\n forEach = curry((fn, list) => {\r\n const limit = length(list);\r\n if (!limit) {\r\n return;\r\n }\r\n let ind = 0;\r\n for (; ind < limit; ind += 1) {\r\n fn(list[ind], ind, list);\r\n }\r\n }),\r\n\r\n /**\r\n * Filters a structure of elements using given predicate (`pred`) (same as `[].filter`).\r\n * @function module:list.filter\r\n * @param pred {Function}\r\n * @param xs {Array} - list or list like.\r\n * @returns {Array} - Structure of filtered elements.\r\n */\r\n filter = curry((pred, xs) => {\r\n let ind = 0,\r\n limit = length(xs),\r\n out = [];\r\n if (!limit) {\r\n return out;\r\n }\r\n for (; ind < limit; ind++) {\r\n if (pred(xs[ind], ind, xs)) {\r\n out.push(xs[ind]);\r\n }\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Partitions a list on a predicate; Items that match predicate are in first list in tuple; Items that\r\n * do not match the tuple are in second list in the returned tuple.\r\n * Essentially `[filter(p, xs), filter(negateF3(p), xs)]`.\r\n * @function module:list.partition\r\n * @param pred {Function} - Predicate\r\n * @param list {Array}\r\n * @returns {Array|String} - Tuple of arrays or strings (depends on incoming list (of type list or string)).\r\n */\r\n partition = curry((pred, list) =>\r\n !length(list) ?\r\n [[], []] :\r\n [filter(pred, list), filter(negateF3(pred), list)]),\r\n\r\n /**\r\n * Returns a boolean indicating whether an element exists in given structure of elements.\r\n * @function module:list.elem\r\n * @param element {*}\r\n * @param xs {Array}\r\n * @returns {Boolean}\r\n */\r\n elem = includes,\r\n\r\n /**\r\n * The opposite of `elem` - Returns a boolean indicating whether an element exists in given list.\r\n * @function module:list.notElem\r\n * @param element {*}\r\n * @param xs {Array}\r\n * @returns {Boolean}\r\n */\r\n notElem = negateF2(includes),\r\n\r\n /**\r\n * Checks if list `xs1` is a prefix of list `xs2`\r\n * @function module:list.isPrefixOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isPrefixOf = curry((xs1, xs2) => {\r\n const limit1 = length(xs1),\r\n limit2 = length(xs2);\r\n if (limit2 < limit1 || !limit1 || !limit2 || indexOf(xs1[0], xs2) === -1) {\r\n return false;\r\n }\r\n let ind = 0;\r\n for (; ind < limit1; ind++) {\r\n if (xs1[ind] !== xs2[ind]) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }),\r\n\r\n /**\r\n * Checks if list `xs1` is a suffix of list `xs2`\r\n * @function module:list.isSuffixOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isSuffixOf = curry((xs1, xs2) => {\r\n const limit1 = length(xs1),\r\n limit2 = length(xs2);\r\n if (limit2 < limit1 || !limit1 || !limit2 || indexOf(xs1[0], xs2) === -1) {\r\n return false;\r\n }\r\n let ind1 = limit1 - 1,\r\n ind2 = limit2 - 1;\r\n for (; ind1 >= 0; ind1--) {\r\n if (xs1[ind1] !== xs2[ind2]) {\r\n return false;\r\n }\r\n ind2 -= 1;\r\n }\r\n return true;\r\n }),\r\n\r\n /**\r\n * Checks if list `xs1` is an infix of list `xs2`\r\n * @function module:list.isInfixOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isInfixOf = curry((xs1, xs2) => {\r\n const limit1 = length(xs1),\r\n limit2 = length(xs2);\r\n if (limit2 < limit1 || !limit1 || !limit2) {\r\n return false;\r\n }\r\n let ind1,\r\n foundLen,\r\n ind = 0;\r\n for (; ind < limit2; ind += 1) {\r\n foundLen = 0;\r\n for (ind1 = 0; ind1 < limit1; ind1 += 1) {\r\n if (xs2[ind1 + ind] === xs1[ind1]) {\r\n foundLen += 1;\r\n }\r\n if (foundLen === limit1) {\r\n return true;\r\n }\r\n }\r\n }\r\n return false;\r\n }),\r\n\r\n /**\r\n * Checks if list `xs1` is a sub-sequence of list `xs2`\r\n * @function module:list.isSubsequenceOf\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {boolean}\r\n */\r\n isSubsequenceOf = curry((xs1, xs2) => {\r\n const len = Math.pow(2, length(xs2)),\r\n lenXs1 = length(xs1);\r\n let foundLen,\r\n i;\r\n for (i = 0; i < len; i += 1) {\r\n foundLen = 0;\r\n for (let j = 0; j < len; j += 1) {\r\n if (i & (1 << j) && indexOf(xs2[j], xs1) > -1) {\r\n foundLen += 1;\r\n }\r\n if (foundLen === lenXs1) {\r\n return true;\r\n }\r\n }\r\n }\r\n return false;\r\n }),\r\n\r\n /**\r\n * The group function takes a list and returns a list of lists such that\r\n * the concatenation of the result is equal to the argument. Moreover, each\r\n * sublist in the result contains only equal elements. For example,\r\n * `group \"Mississippi\" = [\"M\",\"i\",\"ss\",\"i\",\"ss\",\"i\",\"pp\",\"i\"]`\r\n * It is a special case of groupBy, which allows the programmer to supply\r\n * their own equality test.\r\n * @haskellType `group :: Eq a => [a] -> [[a]]`\r\n * @function module:list.group\r\n * @param xs {Array|String}\r\n * @returns {Array|*}\r\n */\r\n group = xs => groupBy((a, b) => a === b, xs),\r\n\r\n /**\r\n * Allows you to group items in a list based on your supplied equality check.\r\n * @note Sames `group` but allows you to specify equality operation.\r\n * @haskellType `groupBy :: (a -> a -> Bool) -> [a] -> [[a]]`\r\n * @function module:list.groupBy\r\n * @param equalityOp {Function}\r\n * @param xs {Array}\r\n * @returns {*}\r\n */\r\n groupBy = curry((equalityOp, xs) => {\r\n const limit = length(xs);\r\n if (!limit) {\r\n return sliceCopy(xs);\r\n }\r\n let ind = 0,\r\n prevItem,\r\n item,\r\n predOp = x => {\r\n if (equalityOp(x, prevItem)) {\r\n ind++;\r\n }\r\n if (equalityOp(x, item)) {\r\n prevItem = x;\r\n return true;\r\n }\r\n return false;\r\n },\r\n agg = [];\r\n for (; ind < limit; ind += 1) {\r\n item = xs[ind];\r\n agg.push(takeWhile(predOp, slice(ind, limit, xs)));\r\n }\r\n return agg;\r\n }),\r\n\r\n /**\r\n * The inits function returns all initial segments of the argument, shortest first. For example,\r\n * ```\r\n * shallowEquals(inits('abc'), ['','a','ab','abc'])\r\n * ```\r\n * @function module:list.inits\r\n * @haskellType `inits :: [a] -> [[a]]`\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n inits = xs => {\r\n let limit = length(xs),\r\n ind = 0,\r\n agg = [];\r\n if (!limit) {\r\n return [];\r\n }\r\n for (; ind <= limit; ind += 1) {\r\n agg.push(sliceTo(ind, xs));\r\n }\r\n return agg;\r\n }, //map(list => init(list), xs),\r\n\r\n /**\r\n * The inits function returns all initial segments of the argument, shortest first. For example,\r\n * ```\r\n * shallowEquals(tails('abc'), ['abc', 'bc', 'c',''])\r\n * ```\r\n * @function module:list.tails\r\n * @haskellType `tails :: [a] -> [[a]]`\r\n * @param xs {Array}\r\n * @returns {Array}\r\n */\r\n tails = xs => {\r\n let limit = length(xs),\r\n ind = 0,\r\n agg = [];\r\n if (!limit) {\r\n return [];\r\n }\r\n for (; ind <= limit; ind += 1) {\r\n agg.push(slice(ind, limit, xs));\r\n }\r\n return agg;\r\n }, //map(list => tail(list), xs),\r\n\r\n /**\r\n * Strips prefix list from given list\r\n * @function module:list.stripPrefix\r\n * @param prefix {Array|String|*}\r\n * @param list {Array|string|*}\r\n * @returns {Array|*}\r\n */\r\n stripPrefix = curry((prefix, list) =>\r\n isPrefixOf(prefix, list) ?\r\n splitAt(length(prefix), list)[1] :\r\n sliceCopy(list)),\r\n\r\n /**\r\n * zip takes two lists and returns a list of corresponding pairs.\r\n * If one input list is short, excess elements of the longer list are discarded.\r\n * @haskellType `zip :: [a] -> [b] -> [(a, b)]`\r\n * @function module:list.zip\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array>}\r\n */\r\n zip = curry((arr1, arr2) => {\r\n if (!length(arr1) || !length(arr2)) {\r\n return [];\r\n }\r\n const [a1, a2] = toShortest(arr1, arr2);\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, [item, a2[ind]]),\r\n [], a1);\r\n }),\r\n\r\n /**\r\n * zipN takes one or more lists and returns a list containing lists of all indices\r\n * at a given index, index by index.\r\n * If one input list is short, excess elements of the longer list are discarded.\r\n * @function module:list.zipN\r\n * @param lists {Array|String} - One ore more lists of the same type.\r\n * @returns {Array}\r\n */\r\n zipN = curry2((...lists) => {\r\n const trimmedLists = apply(toShortest, lists);\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, map(xs => xs[ind], trimmedLists)),\r\n [], trimmedLists[0]);\r\n }),\r\n\r\n /**\r\n * @haskellType `zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]`\r\n * @function module:list.zip3\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @param arr3 {Array}\r\n * @returns {Array>}\r\n */\r\n zip3 = curry((arr1, arr2, arr3) => zipN(arr1, arr2, arr3)),\r\n\r\n /**\r\n * @haskellType `zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]`\r\n * @function module:list.zip4\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @param arr3 {Array}\r\n * @param arr4 {Array}\r\n * @returns {Array>}\r\n */\r\n zip4 = curry((arr1, arr2, arr3, arr4) => zipN(arr1, arr2, arr3, arr4)),\r\n\r\n /**\r\n * @haskellType `zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]`\r\n * @function module:list.zip5\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @param arr3 {Array}\r\n * @param arr4 {Array}\r\n * @param arr5 {Array}\r\n * @returns {Array>}\r\n */\r\n zip5 = curry((arr1, arr2, arr3, arr4, arr5) => zipN(arr1, arr2, arr3, arr4, arr5)),\r\n\r\n /**\r\n * zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]\r\n * zipWith generalises zip by zipping with the function given as the\r\n * first argument, instead of a function tupling function (function that returns a tuple). For example,\r\n * zipWith (+) is applied to two lists to produce the list of corresponding sums.\r\n * @note `_|_` means bottom or perpetual (@see\r\n * - https://wiki.haskell.org/Bottom\r\n * - https://stackoverflow.com/questions/19794681/what-does-this-syntax-mean-in-haskell-or\r\n * )\r\n * @example\r\n * ```\r\n * zipWith f [] _|_ = []\r\n * ```\r\n * @haskellType `zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]`\r\n * @function module:list.zipWith\r\n * @param op {Function} - Takes two parts of a tuple and returns a tuple.\r\n * E.g., ` op :: a -> b -> (a, b)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith = curry((op, xs1, xs2) => {\r\n if (!length(xs1) || !length(xs2)) {\r\n return [];\r\n }\r\n const [a1, a2] = toShortest(xs1, xs2);\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, op(item, a2[ind])),\r\n [], a1);\r\n }),\r\n\r\n /**\r\n * Zips all given lists with tupling function. Note: Haskell types do not have\r\n * a way (that I know of) to show one or more for params in a function so `@haskellType` below\r\n * is left there for general purpose not for exactness as is told by aforementioned.\r\n * @haskellType `zipWithN :: (a -> b -> c) -> [a] -> [b] -> [c]` - Where `N` is the number\r\n * of lists to zip.\r\n * @function module:list.zipWithN\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> (a, b, c)`\r\n * @param lists ...{Array}\r\n * @returns {Array>}\r\n */\r\n zipWithN = curry3((op, ...lists) => {\r\n const trimmedLists = apply(toShortest, lists),\r\n lenOfTrimmed = length(trimmedLists);\r\n if (!lenOfTrimmed) {\r\n return [];\r\n }\r\n else if (lenOfTrimmed === 1) {\r\n return sliceTo(length(trimmedLists[0]), trimmedLists[0]);\r\n }\r\n return reduce((agg, item, ind) =>\r\n aggregateArray(agg, apply(op, map(xs => xs[ind], trimmedLists))),\r\n [], trimmedLists[0]);\r\n }),\r\n\r\n /**\r\n * Zips 3 lists with tupling function.\r\n * @haskellType `zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]`\r\n * @function module:list.zipWith3\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> (a, b, c)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @param xs3 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith3 = curry((op, xs1, xs2, xs3) => zipWithN(op, xs1, xs2, xs3)),\r\n\r\n /**\r\n * Zips 4 lists with tupling function.\r\n * @haskellType `zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]`\r\n * @function module:list.zipWith4\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> d -> (a, b, c, d)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @param xs3 {Array}\r\n * @param xs4 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith4 = curry((op, xs1, xs2, xs3, xs4) => zipWithN(op, xs1, xs2, xs3, xs4)),\r\n\r\n /**\r\n * Zips 5 lists.\r\n * @haskellType `zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]`\r\n * @function module:list.zipWith5\r\n * @param op {Function} - Takes expected number of parts for tuple and returns a tuple\r\n * of said parts:\r\n * E.g., ` op :: a -> b -> c -> d -> e -> (a, b, c, d, e)`\r\n * @param xs1 {Array}\r\n * @param xs2 {Array}\r\n * @param xs3 {Array}\r\n * @param xs4 {Array}\r\n * @param xs5 {Array}\r\n * @returns {Array>}\r\n */\r\n zipWith5 = curry((op, xs1, xs2, xs3, xs4, xs5) => zipWithN(op, xs1, xs2, xs3, xs4, xs5)),\r\n\r\n /**\r\n * unzip transforms a list of pairs into a list of first components and a list of second components.\r\n * @haskellType `unzip :: [(a, b)] -> ([a], [b])`\r\n * @function module:list.unzip\r\n * @param arr {Array|*}\r\n * @returns {Array|*}\r\n */\r\n unzip = foldl((agg, item) => {\r\n agg[0].push(item[0]);\r\n agg[1].push(item[1]);\r\n return agg;\r\n }, [[], []]),\r\n\r\n /**\r\n * unzip transforms a list of pairs into a list of first components and a list of second components.\r\n * @sudoHaskellType `unzipN :: [(a, b, ...x)] -> ([a], [b], ...[x])`\r\n * @function module:list.unzipN\r\n * @param list {Array|*} - List of tuples (lists).\r\n * @returns {Array|*}\r\n */\r\n unzipN = list => {\r\n if (!length(list)) {\r\n return [];\r\n }\r\n const lenItem0 = length(list[0]);\r\n let zero = lenItem0 ?\r\n unfoldr(numLists => numLists-- ? [[], numLists] : undefined, lenItem0) :\r\n [];\r\n return foldl((agg, item) => {\r\n agg.forEach((outList, ind) => outList.push(item[ind]));\r\n return agg;\r\n }, zero, list);\r\n },\r\n\r\n /**\r\n * Returns true if any item in container passes predicate `p`.\r\n * @function module:list.any\r\n * @param p {Function} - Predicate.\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n any = curry((p, xs) => {\r\n let ind = 0,\r\n limit = length(xs);\r\n if (!limit) {\r\n return false;\r\n }\r\n for (; ind < limit; ind += 1) {\r\n if (p(xs[ind])) {\r\n return true;\r\n }\r\n }\r\n return false;\r\n }),\r\n\r\n /**\r\n * Returns true if all items in container pass predicate `p`.\r\n * @function module:list.all\r\n * @param p {Function} - Predicate.\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n all = curry((p, xs) => {\r\n const limit = length(xs);\r\n let ind = 0;\r\n if (!limit) {\r\n return false;\r\n }\r\n for (; ind < limit; ind++) {\r\n if (!p(xs[ind], ind, xs)) {\r\n return false;\r\n }\r\n }\r\n return true;\r\n }),\r\n\r\n /**\r\n * Conjuction of container of bools (or truthy and/or falsy values); Returns\r\n * `true` if all in container are 'truthy' else returns `false`\r\n * @function module:list.and\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n and = xs => all(isTruthy, xs),\r\n\r\n /**\r\n * Returns a boolean indicating whether any item in container is 'truthy' or not.\r\n * **Note** The haskell type for this function only takes two items, but here\r\n * we allow the passing of more than one item (may change later to adhere to the haskell type).\r\n * @function module:list.or\r\n * @haskellType `or :: Bool -> Bool -> Bool`\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n or = xs => any(isTruthy, xs),\r\n\r\n /**\r\n * Returns a boolean indicating whether all items in container are 'falsy' or not.\r\n * **Note** The haskell type for this function only takes two items, but here\r\n * we allow the passing of more than one item (may change later to adhere to the haskell type).\r\n * @function module:list.not\r\n * @haskellType `not :: Bool -> Bool`\r\n * @param xs {Array|String}\r\n * @returns {Boolean}\r\n */\r\n not = xs => all(isFalsy, xs),\r\n\r\n /**\r\n * Computes the sum of the numbers of a structure.\r\n * @function module:list.sum\r\n * @haskellType `sum :: (List t, Num a) => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {Number}\r\n */\r\n sum = list => foldl((agg, x) => agg + x, 0, list),\r\n\r\n /**\r\n * Computes the product of the numbers of a structure.\r\n * @function module:list.product\r\n * @haskellType `product :: (List t, Num a) => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {Number}\r\n */\r\n product = list => foldl((agg, x) => agg * x, 1, list),\r\n\r\n /**\r\n * Returns the largest element in a non-empty structure of elements.\r\n * @function module:list.maximum\r\n * @haskellType `maximum :: forall a . Ord a => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {*} - Whatever type the array is made of (if any).\r\n */\r\n maximum = list => last(sortBy(genericAscOrdering, list)),\r\n\r\n /**\r\n * Returns the smallest element in a non-empty structure of elements.\r\n * @function module:list.minimum\r\n * @haskellType `minimum :: forall a . Ord a => t a -> a`\r\n * @param list {Array|String}\r\n * @returns {*} - Whatever type the array is made of (if any).\r\n */\r\n minimum = list => head(sortBy(genericAscOrdering, list)),\r\n\r\n /**\r\n * scanl is similar to foldl, but returns a list of successive reduced values from the left:\r\n * ```\r\n * scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]\r\n * ```\r\n * Also note that:\r\n * ```\r\n * last (scanl f z xs) == foldl f z xs.\r\n * ```\r\n * @function module:list.scanl\r\n * @param fn {Function}\r\n * @param zero {*}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanl = curry((fn, zero, xs) => {\r\n if (!xs || !length(xs)) {\r\n return [];\r\n }\r\n const limit = length(xs);\r\n let ind = 0,\r\n result = zero,\r\n out = [];\r\n while (ind < limit) {\r\n result = fn(result, xs[ind], ind, xs);\r\n out.push(result);\r\n ind++;\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * `scanl1` is a variant of `scanl` that has no starting value argument:\r\n * `shallowCompare(scanl1(fn, [x1, x2, ...]), [x1, fn(x1, x2), ...]) // true`\r\n * @function module:list.scanl1\r\n * @param fn {Function}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanl1 = curry((fn, xs) => {\r\n if (!xs || !xs.length) {\r\n return [];\r\n }\r\n return scanl(fn, head(xs), tail(xs));\r\n }),\r\n\r\n /**\r\n * Same as `scanl` but from the right (similiar to `foldr`'s relationship to 'foldl').\r\n * Note also `scanr`'s relationship ot `foldr`:\r\n * `head (scanr(fn, z, xs)) === foldr(fn, z, xs).\r\n * @function module:list.scanr\r\n * @param fn {Function}\r\n * @param zero {*}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanr = curry((fn, zero, xs) => {\r\n if (!xs || !length(xs)) {\r\n return [];\r\n }\r\n const limit = length(xs);\r\n let ind = limit - 1,\r\n result = xs[0],\r\n out = [];\r\n while (ind > -1) {\r\n result = fn(result, xs[ind], ind, xs);\r\n out.push(result);\r\n ind--;\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Same as `scanr` but takes no zero/accumulator value.\r\n * @function module:list.scanr1\r\n * @param fn {Function}\r\n * @param xs {Array}\r\n * @returns {Array|*}\r\n */\r\n scanr1 = curry((fn, xs) => {\r\n if (!xs || !xs.length) {\r\n return [];\r\n }\r\n return scanr(fn, last(xs), init(xs));\r\n }),\r\n\r\n /**\r\n * The nub function removes duplicate elements from a list.\r\n * In particular, it keeps only the first occurrence of each element.\r\n * (The name nub means `essence'.) It is a special case of nubBy, which\r\n * allows the programmer to supply their own equality test.\r\n * ```shallowCompare( nub ([1,2,3,4,3,2,1,2,4,3,5]), [1,2,3,4,5] )```\r\n * @function module:list.nub\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n nub = list => nubBy((a, b) => a === b, list),\r\n\r\n /**\r\n * `remove(x, xs)` removes the first occurrence of `x` from `xs`.\r\n * For example, `remove('a', 'banana') === 'bnana';`\r\n * @function module:list.remove\r\n * @param x {*}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n remove = curry((x, list) => removeBy((a, b) => a === b, x, list)),\r\n\r\n /**\r\n * The sort function implements a stable sorting algorithm.\r\n * It is a special case of sortBy, which allows the programmer\r\n * to supply their own comparison function.\r\n * ```shallowCompare(sort ([1,6,4,3,2,5]), [1,2,3,4,5,6]) // true```\r\n * @function module:list.sort\r\n * @param xs {Array|String|*}\r\n * @returns {Array}\r\n */\r\n sort = xs => sortBy(genericAscOrdering, xs),\r\n\r\n /**\r\n * Sort a list by comparing the results of a key function applied to each\r\n * element. sortOn f is equivalent to sortBy (comparing f), but has the\r\n * performance advantage of only evaluating f once for each element in the\r\n * input list. This is called the decorate-sort-undecorate paradigm, or\r\n * Schwartzian transform.\r\n *\r\n * Elements are arranged from from lowest to highest, keeping duplicates\r\n * in the order they appeared in the input.\r\n *\r\n * Ex:\r\n * ```\r\n * shallowEquals(\r\n * sortOn (head, [[2, \"world\"], [4, \"!\"], [1, \"Hello\"]]),\r\n * [[1,\"Hello\"],[2,\"world\"],[4,\"!\"]]\r\n * ) // true\r\n * ```\r\n * @function module:list.sortOn\r\n * @param valueFn {Function}\r\n * @param xs {Array|String|*}\r\n * @returns {Array}\r\n */\r\n sortOn = curry((valueFn, xs) =>\r\n\r\n // Un-decorate\r\n map(decorated => decorated[1],\r\n\r\n // Decorate and sort\r\n sortBy(\r\n // Ordering\r\n ([a0], [b0]) => genericAscOrdering(a0, b0),\r\n\r\n // Decorate\r\n map(item => [valueFn(item), item], xs)\r\n )\r\n )\r\n ),\r\n\r\n /**\r\n * The sortBy function is the non-overloaded (in haskell terms) version of sort.\r\n * @haskellExample ```\r\n * >>> sortBy (\\(a,_) (b,_) -> compare a b) [(2, \"world\"), (4, \"!\"), (1, \"Hello\")]\r\n * [(1,\"Hello\"),(2,\"world\"),(4,\"!\")]\r\n * ```\r\n * @function module:list.sortBy\r\n * @param orderingFn {Function}\r\n * @param xs {Array|String|*}\r\n * @returns {Array|String|*}\r\n */\r\n sortBy = curry((orderingFn, xs) => sliceCopy(xs).sort(orderingFn || genericAscOrdering)),\r\n\r\n /**\r\n * The insert function takes an element and a list and inserts the element\r\n * into the list at the first position where it is less than or equal to the\r\n * next element. In particular, if the list is sorted before the call, the\r\n * result will also be sorted. It is a special case of insertBy, which allows\r\n * the programmer to supply their own comparison function.\r\n * @function module:list.insert\r\n * @param x {*}\r\n * @param xs {Array|*}\r\n * @returns {Array}\r\n */\r\n insert = curry((x, xs) => {\r\n if (!xs.length) {\r\n return of(xs, x);\r\n }\r\n const foundIndex = findIndex(item => x <= item, xs);\r\n return foundIndex === -1 ? concat([xs, of(xs, x)]) :\r\n concat(intersperse(of(xs, x), splitAt(foundIndex, xs)));\r\n }),\r\n\r\n /**\r\n * A version of `insert` that allows you to specify the ordering of the inserted\r\n * item; Before/at, or after\r\n * @function module:list.insertBy\r\n * @haskellType `insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]`\r\n * @note `Ordering` means 'something that is order-able'\r\n * operated on by this functions logic.\r\n * @param orderingFn {Function} - A function that returns `-1`, `0`, or 1`.\r\n * @param x {*} - Value to insert.\r\n * @param xs {Array} - List to insert into (note new list is returned)\r\n * @returns {Array} - New list.\r\n */\r\n insertBy = curry((orderingFn, x, xs) => {\r\n const limit = length(xs);\r\n if (!limit) {\r\n return [x];\r\n }\r\n let ind = 0;\r\n for (; ind < limit; ind += 1) {\r\n if (orderingFn(x, xs[ind]) <= 0) {\r\n const parts = splitAt(ind, xs);\r\n return concat([parts[0], [x], parts[1]]);\r\n }\r\n }\r\n return aggregateArray(sliceCopy(xs), x);\r\n }),\r\n\r\n /**\r\n * The nubBy function behaves just like nub, except it uses a user-supplied equality predicate.\r\n * @function module:list.nubBy\r\n * @param pred {Function}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n nubBy = curry((pred, list) => {\r\n if (!length(list)) {\r\n return [];\r\n }\r\n const limit = length(list);\r\n let ind = 0,\r\n currItem,\r\n out = [],\r\n anyOp = storedItem => pred(currItem, storedItem);\r\n for (; ind < limit; ind += 1) {\r\n currItem = list[ind];\r\n if (any(anyOp, out)) {\r\n continue;\r\n }\r\n out.push(currItem);\r\n }\r\n return out;\r\n }),\r\n\r\n /**\r\n * Behaves the same as `remove`, but takes a user-supplied equality predicate.\r\n * @function module:list.removeBy\r\n * @param pred {Function} - Equality predicate `(a, b) => bool`\r\n * @param x {*}\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n removeBy = curry((pred, x, list) => {\r\n const foundIndex = findIndex(item => pred(x, item), list);\r\n if (foundIndex > -1) {\r\n const parts = splitAt(foundIndex, list);\r\n return append(parts[0], tail(parts[1]));\r\n }\r\n return sliceCopy(list);\r\n }),\r\n\r\n /**\r\n * The `removeFirstsBy` function takes a predicate and two lists and returns the first list with the first\r\n * occurrence of each element of the second list removed.\r\n * @function module:list.removeFirstBy\r\n * @param pred {Function}\r\n * @param xs1 {Array|String|*}\r\n * @param xs2 {Array|String|*}\r\n * @returns {Array}\r\n */\r\n removeFirstsBy = curry((pred, xs1, xs2) =>\r\n foldl((agg, x) => removeBy(pred, x, agg), xs1, xs2)),\r\n\r\n /**\r\n * Returns the union on elements matching boolean check passed in.\r\n * @function module:list.unionBy\r\n * @param pred {Function} - `pred :: a -> a -> Bool`\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array}\r\n */\r\n unionBy = curry((pred, arr1, arr2) =>\r\n foldl((agg, b) => {\r\n const alreadyAdded = any(a => pred(a, b), agg);\r\n return !alreadyAdded ? (agg.push(b), agg) : agg;\r\n }, sliceCopy(arr1), arr2\r\n )),\r\n\r\n /**\r\n * Creates a union on matching elements from array1.\r\n * @function module:list.union\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array}\r\n */\r\n union = curry((arr1, arr2) =>\r\n append(arr1,\r\n filter(elm => !includes(elm, arr1), arr2))),\r\n\r\n /**\r\n * Performs an intersection on list 1 with elements from list 2.\r\n * @function module:list.intersect\r\n * @param arr1 {Array}\r\n * @param arr2 {Array}\r\n * @returns {Array}\r\n */\r\n intersect = curry((arr1, arr2) =>\r\n !arr1 || !arr2 || (!arr1 && !arr2) ? [] :\r\n filter(elm => includes(elm, arr2), arr1)),\r\n\r\n /**\r\n * Returns an intersection by predicate.\r\n * @function module:list.intersectBy\r\n * @param pred {Function} - `pred :: a -> b -> Bool`\r\n * @param list1 {Array}\r\n * @param list2 {Array}\r\n * @return {Array}\r\n */\r\n intersectBy = curry((pred, list1, list2) =>\r\n foldl((agg, a) =>\r\n any(b => pred(a, b), list2) ? (agg.push(a), agg) : agg\r\n , [], list1)),\r\n\r\n /**\r\n * Returns the difference of list 1 from list 2.\r\n * @note The `difference` operation here is non-associative; E.g., `a - b` is not equal to `b - a`;\r\n * @function module:list.difference\r\n * @param array1 {Array}\r\n * @param array2 {Array}\r\n * @returns {Array}\r\n */\r\n difference = curry((array1, array2) => { // augment this with max length and min length ordering on op\r\n if (array1 && !array2) {\r\n return sliceCopy(array1);\r\n }\r\n else if (!array1 && array2 || (!array1 && !array2)) {\r\n return [];\r\n }\r\n return reduce((agg, elm) =>\r\n !includes(elm, array2) ? (agg.push(elm), agg) : agg\r\n , [], array1);\r\n }),\r\n\r\n /**\r\n * Returns the complement of list 0 and the reset of the passed in arrays.\r\n * @function module:list.complement\r\n * @param arr0 {Array}\r\n * @param arrays {...Array}\r\n * @returns {Array}\r\n */\r\n complement = curry2((arr0, ...arrays) =>\r\n reduce((agg, arr) => append(agg, difference(arr, arr0)), [], arrays));\r\n","/**\r\n * @module errorThrowing\r\n * @description Contains error throwing facilities for when a value doesn't match a type.\r\n */\r\nimport {typeOf} from './object/typeOf';\r\nimport {isArray, toTypeRef, toTypeRefName, isOfType} from './object/is';\r\nimport {curry} from './function/curry';\r\n\r\nexport const\r\n\r\n /**\r\n * Pretty prints an array of types/type-strings for use by error messages;\r\n * Outputs \"`SomeTypeName`, ...\" from [SomeType, 'SomeTypeName', etc...]\r\n * @function module:errorThrowing.typeRefsToStringOrError\r\n * @param types {Array|TypesArray}\r\n * @return {String}\r\n * @private\r\n */\r\n typeRefsToStringOrError = types => types.length ?\r\n types.map(type => `\\`${toTypeRefName(type)}\\``).join(', ') : '',\r\n\r\n /**\r\n * Prints a message from an object. Object signature:\r\n * {contextName, valueName, value, expectedTypeName, foundTypeName, messageSuffix}\r\n * @function module:errorThrowing.defaultErrorMessageCall\r\n * @param tmplContext {Object|TemplateContext} - Object to use in error template.\r\n * @returns {string}\r\n * @private\r\n */\r\n defaultErrorMessageCall = tmplContext => {\r\n const {\r\n contextName, valueName, value, expectedTypeName,\r\n foundTypeName, messageSuffix\r\n } = tmplContext,\r\n isMultiTypeNames = isArray(expectedTypeName),\r\n typesCopy = isMultiTypeNames ? 'of type' : 'of one of the types',\r\n typesToMatchCopy = isMultiTypeNames ? typeRefsToStringOrError(expectedTypeName) : expectedTypeName;\r\n return (contextName ? `\\`${contextName}.` : '`') +\r\n `${valueName}\\` is not ${typesCopy}: ${typesToMatchCopy}. ` +\r\n `Type received: ${foundTypeName}. Value: ${value};` +\r\n `${messageSuffix ? ' ' + messageSuffix + ';' : ''}`;\r\n },\r\n\r\n /**\r\n * Gets the error message thrower seeded with passed in errorMessage template call.\r\n * @function module:errorThrowing.getErrorIfNotTypeThrower$\r\n * @param errorMessageCall {Function|ErrorMessageCall}\r\n * @param typeChecker {Function|TypeChecker} - Function:Boolean\r\n * @returns {Function|ErrorIfNotType}\r\n * @private\r\n */\r\n _getErrorIfNotTypeThrower = (errorMessageCall, typeChecker = isOfType) =>\r\n (ValueType, contextName, valueName, value, messageSuffix = null) => {\r\n const expectedTypeName = toTypeRef(ValueType),\r\n foundTypeName = typeOf(value);\r\n if (typeChecker(ValueType, value)) { return value; } // Value matches type\r\n throw new Error(errorMessageCall(\r\n {contextName, valueName, value, expectedTypeName, foundTypeName, messageSuffix}\r\n ));\r\n },\r\n\r\n /**\r\n * Gets the error message thrower seeded with passed in errorMessage template call.\r\n * @function module:errorThrowing.getErrorIfNotTypesThrower$\r\n * @param errorMessageCall {Function|ErrorMessageCall}\r\n * @param typeChecker {Function|TypeChecker} - Function:Boolean\r\n * @returns {Function|ErrorIfNotTypes}\r\n * @private\r\n */\r\n _getErrorIfNotTypesThrower = (errorMessageCall, typeChecker = isOfType) =>\r\n (valueTypes, contextName, valueName, value, messageSuffix = null) => {\r\n const expectedTypeNames = valueTypes.map(toTypeRef),\r\n matchFound = valueTypes.some(ValueType => typeChecker(ValueType, value)),\r\n foundTypeName = typeOf(value);\r\n if (matchFound) { return value; }\r\n throw new Error(\r\n errorMessageCall({\r\n contextName, valueName, value,\r\n expectedTypeName: expectedTypeNames, foundTypeName,\r\n messageSuffix\r\n })\r\n );\r\n },\r\n\r\n /**\r\n * Checks that passed in `value` is of given `type`. Throws an error if value\r\n * is not of given `type`. This is the un-curried version. For the curried version\r\n * see `module:errorThrowing.errorIfNotType`.\r\n * @function module:errorThrowing.errorIfNotType$\r\n * @param type {String|Function} - Type's name or type itself.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @param [messageSuffix=null] {String} - Optional.\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @private\r\n */\r\n _errorIfNotType = _getErrorIfNotTypeThrower(defaultErrorMessageCall),\r\n\r\n /**\r\n * Checks that passed in `value` is of one of the given `types`. Throws an error if value\r\n * is not of one of the given `types`. This is the un-curried version. For the curried version\r\n * see `module:errorThrowing.errorIfNotTypes`.\r\n * @type {Function|module:errorThrowing.errorIfNotTypes}\r\n * @function module:errorThrowing.errorIfNotTypes$\r\n * @param types {Array} - Array of one or more types or type names themselves.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @private\r\n */\r\n _errorIfNotTypes = _getErrorIfNotTypesThrower(defaultErrorMessageCall),\r\n\r\n /**\r\n * Returns a function that can be used to ensure that values are of a given type.\r\n * Also throws informative error messages containing the value types, names, expected type names,\r\n * etc.\r\n * @function module:errorThrowing.getErrorIfNotTypeThrower\r\n * @param errorMessageCall {Function|ErrorMessageCall} - Template function (takes an info-object and returns a printed string).\r\n * @returns {Function|ErrorIfNotType} - Returns a function with the same signature as `errorIfNotType` though curried.\r\n */\r\n getErrorIfNotTypeThrower = errorMessageCall => curry(_getErrorIfNotTypeThrower(errorMessageCall)),\r\n\r\n /**\r\n * Returns a function that can be used to ensure that a value is of one or more given types.\r\n * The returned function is used in cases where informative error messages\r\n * containing the value types, names, expected type names, are-required/should-be-used etc.\r\n * @function module:errorThrowing.getErrorIfNotTypesThrower\r\n * @param errorMessageCall {Function|ErrorMessageCall} - Template function (takes an info-object and returns a printed string).\r\n * @returns {Function|ErrorIfNotTypes} - Returns a function with the same signature as `errorIfNotTypes` though curried.\r\n */\r\n getErrorIfNotTypesThrower = errorMessageCall => curry(_getErrorIfNotTypesThrower(errorMessageCall)),\r\n\r\n /**\r\n * Checks that passed in `value` is of given `type`. Throws an error if value\r\n * is not of given `type`. Curried.\r\n * @function module:errorThrowing.errorIfNotType\r\n * @param type {String|Function} - Type's name or type itself.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @param [messageSuffix=null] {String} - Optional.\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @curried\r\n */\r\n errorIfNotType = curry(_errorIfNotType),\r\n\r\n /**\r\n * Checks that passed in `value` is of one of the given `types`. Throws an error if value\r\n * is not of one of the given `types`. Curried.\r\n * @function module:errorThrowing.errorIfNotTypes\r\n * @param types {Array} - Array of one or more types or type names themselves.\r\n * @param contextName {String} - Name of context to attribute errors if thrown.\r\n * @param valueName {String} - String rep of value.\r\n * @param value {*}\r\n * @returns {*} - Given `value` if `value` matches passed in type.\r\n * @curried\r\n */\r\n errorIfNotTypes = curry(_errorIfNotTypes)\r\n;\r\n\r\n/**\r\n * @typedef {*} Any - Synonym for 'any value'.\r\n */\r\n\r\n/**\r\n * @typedef {String|Function} TypeRef\r\n * @description Type reference. Type itself or Type's name; E.g., `Type.name`;\r\n */\r\n\r\n/**\r\n * @typedef {Object} TemplateContext\r\n * @description Template context used for error message renderers (functions that take a context obj and return a string).\r\n * @property value {*}\r\n * @property valueName {String}\r\n * @property expectedTypeName {String} - Expected name of constructor of `value`; E.g., usually `SomeConstructor.name`;\r\n * @property foundTypeName {String} - Found types name; E.g., `FoundConstructor.name`;\r\n * @property [messageSuffix=null] {*} - Message suffix (sometimes an extra hint or instructions for\r\n * directing user to fix where his/her error has occurred). Optional.\r\n */\r\n\r\n/**\r\n * @typedef {Array<(String|Function)>} TypesArray\r\n */\r\n\r\n/**\r\n * @typedef {Function} TypeChecker\r\n * @description Checks whether a value is of given type.\r\n * @param Type {TypeRef} - a Type or it's name; E.g., `Type.name`.\r\n * @param value {*}\r\n * @returns {Boolean}\r\n */\r\n\r\n/**\r\n * @typedef {Function} ErrorMessageCall\r\n * @description Error message template function.\r\n * @param tmplContext {TemplateContext}\r\n * @returns {String}\r\n */\r\n\r\n/**\r\n * @typedef {Function} ErrorIfNotType\r\n * @description Used to ensure value matches passed in type.\r\n * @param type {TypeRef} - Constructor name or constructor.\r\n * @param contextName {String}\r\n * @param valueName {String}\r\n * @param value {*}\r\n * @throws {Error} - If value doesn't match type.\r\n * @returns {*} - What ever value is.\r\n */\r\n\r\n/**\r\n * @typedef {Function} ErrorIfNotTypes\r\n * @description Used to ensure a value matches one of one or more types passed in.\r\n * @param valueTypes {TypesArray} - Array of constructor names or constructors.\r\n * @param contextName {String}\r\n * @param valueName {String}\r\n * @param value {*}\r\n * @throws {Error} - If value doesn't match type.\r\n * @returns {*} - Whatever value is.\r\n */\r\n","/**\r\n * @module string\r\n * @description Contains functions for strings.\r\n */\r\nimport {intercalate, map, filter} from './list';\r\nimport {split} from './jsPlatform/string';\r\nimport {compose} from './function/compose';\r\nimport {join} from './jsPlatform/array';\r\nimport {_errorIfNotType} from './errorThrowing';\r\n\r\nexport {split};\r\n\r\nexport const\r\n\r\n /**\r\n * Splits a string on all '\\n', '\\r', '\\n\\r', or '\\r\\n' characters.\r\n * @function module:string.lines\r\n * @param str {String}\r\n * @returns {Array}\r\n */\r\n lines = split(/[\\n\\r]/gm),\r\n\r\n /**\r\n * Splits a string on all '\\s' and/or all '\\t' characters.\r\n * @function module:string.words\r\n * @param str{String}\r\n * @returns {Array}\r\n */\r\n words = split(/[\\s\\t]/gm),\r\n\r\n /**\r\n * Intersperse an array of strings with '\\s' and then concats them.\r\n * @function module:string.unwords\r\n * @param arr {String}\r\n * @returns {Array}\r\n */\r\n unwords = intercalate(' '),\r\n\r\n /**\r\n * Intersperses a '\\n' character into a list of strings and then concats it.\r\n * @function module:string.unlines\r\n * @param list {Array|String|*}\r\n * @returns {Array}\r\n */\r\n unlines = intercalate('\\n'),\r\n\r\n /**\r\n * Lower cases first character of a non-empty string.\r\n * @function module:string.lcaseFirst\r\n * @param xs {String}\r\n * @returns {string}\r\n * @throws {Error} - Throws error if receiving anything that is not a string.\r\n */\r\n lcaseFirst = xs => {\r\n _errorIfNotType(String, 'lcaseFirst', 'xs', xs);\r\n return xs[0].toLowerCase() + xs.substring(1);\r\n },\r\n\r\n /**\r\n * Upper cases first character of a non-empty string.\r\n * @function module:string.ucaseFirst\r\n * @param xs {String}\r\n * @returns {string}\r\n * @throws {Error} - Throws error if receiving anything that is not a string.\r\n */\r\n ucaseFirst = xs => {\r\n _errorIfNotType(String, 'ucaseFirst', 'xs', xs);\r\n return xs[0].toUpperCase() + xs.substring(1);\r\n },\r\n\r\n /**\r\n * Camel cases (class case) a string.\r\n * @function module:string.camelCase\r\n * @param xs {String}\r\n * @param [pattern=/[^a-z\\d/i]/] {RegExp} - Pattern to split on. Optional.\r\n * @throws {Error} - Throws error if param `xs` is not a string.\r\n * @returns {string}\r\n * @curried\r\n */\r\n camelCase = (xs, pattern = /[^a-z\\d]/i) => compose(\r\n join(''),\r\n map(str => ucaseFirst(str.toLowerCase())),\r\n filter(x => !!x),\r\n split(pattern)\r\n )(_errorIfNotType(String, 'camelCase', 'xs', xs)),\r\n\r\n /**\r\n * Class cases a string. Uses pattern /[^a-z\\d/i]/ to split on.\r\n * If you require a different pattern use `string.camelCase(str, pattern)`\r\n * and then upper case first character (`ucaseFirst`).\r\n * @function module:string.classCase\r\n * @param xs {String}\r\n * @returns {string}\r\n * @throws {Error} - Throws error if `xs` is not a string (via `camelCase` call).\r\n */\r\n classCase = compose(ucaseFirst, camelCase)\r\n\r\n;\r\n\r\n/**\r\n * Functional version of `String.prototype.split`.\r\n * @function module:string.split\r\n * @param separator {String|RegExp}\r\n * @param str {String}\r\n * @returns {Array}\r\n */\r\n","/**\r\n * @module fjl\r\n * @description Exports all module methods (object, list, string modules etc.).\r\n * @goal to include everything from haskell's Prelude where it makes sense in order to create\r\n * a subset of functions which can make the javascript developer more efficient and make his/her\r\n * code more concise (and functional).\r\n * @motivation preludejs, lodash/fp, RamdaJs, Haskell.\r\n * @see http://hackage.haskell.org/package/base-4.10.0.0/docs/Prelude.html\r\n * @see http://hackage.haskell.org/package/base-4.10.0.0/docs/Data-List.html\r\n */\r\nexport * from './object';\r\nexport * from './boolean';\r\nexport * from './function';\r\nexport * from './list';\r\nexport * from './string';\r\nexport * from './utils';\r\nexport * from './errorThrowing';\r\n\r\n/**\r\n * @typedef {String|Function|ArrayBufferConstructor|ArrayConstructor|BooleanConstructor|MapConstructor|NumberConstructor|SetConstructor|WeakMapConstructor|WeakSetConstructor} TypeRef\r\n * @description Type reference. Either actual type or type's name; E.g., `Type.name`\r\n * Also note: Class cased names are use for values that do not have `name` properties; Namely: 'Null', 'NaN' and 'Undefined' (for their respective values respectively).\r\n */\r\n"],"names":["returnCurried","executeArity","unmetArityNum","fn","argsToCurry","func","x","executeAsCurriedFunc","Array","from","arguments","a","b","c","d","e","args","unmetArity","concatedArgs","concat","canBeCalled","length","newExpectedArity","curryN","Function","Error","curry","curry2","curry3","curry4","curry5","fPureTakesOne","name","arg","f","fPureTakes2","arg1","arg2","fPureTakes3","arg3","fPureTakes4","arg4","fPureTakes5","arg5","fPureTakesOneOrMore","defineReverse","prototype","reverse","reduceRight","agg","item","push","map","filter","reduce","forEach","some","every","join","apply","call","flipN","flip","flip3","flip4","flip5","instanceOf","instanceConstructor","instance","hasOwnProperty","native","Object","getOwnPropertyNames","key","operation","keys","assign","obj0","objs","topAgg","obj","_Number","Number","_NaN","_Null","_Undefined","typeOf","value","retVal","undefined","constructorName","constructor","isNaN","_String","String","_Object","_Boolean","Boolean","_Function","_Array","_Symbol","_Map","_Set","_WeakMap","_WeakSet","toTypeRef","type","toTypeRefs","types","toTypeRefName","Type","ref","toTypeRefNames","isFunction","isType","isOfType","isClass","test","substr","isCallable","isArray","isObject","isBoolean","isNumber","isString","isMap","isSet","isWeakMap","isWeakSet","isUndefined","isNull","isSymbol","isUsableImmutablePrimitive","typeOfX","isset","isEmptyList","isEmptyObject","isEmptyCollection","size","isEmpty","isOneOf","typeName","isFunctor","lookup","of","copy","out","slice","Symbol","Promise","searchObj","nsString","indexOf","parts","split","limit","ind","parent","node","assignDeep","propDescription","getOwnPropertyDescriptor","get","set","writable","includes","xs","lastIndexOf","isTruthy","isFalsy","alwaysTrue","alwaysFalse","equal","equalAll","i","aggregateArray","sliceFrom","startInd","sliceTo","toInd","sliceCopy","genericAscOrdering","lengths","lists","toShortest","listLengths","smallLen","Math","min","list","reduceUntil","pred","op","result","reduceUntilRight","arr","lastIndex","len","findIndexWhere","predicateFulfilled","findIndexWhereRight","findIndicesWhere","findWhere","elm","objUnion","obj1","obj2","objIntersect","objDifference","objComplement","log","console","bind","error","peek","pop","jsonClone","JSON","parse","stringify","toAssocList","toAssocListDeep","TypeConstraint","fromAssocList","OutType","fromAssocListDeep","toArray","compose","arg0","id","negateF","negateF2","negateF3","negateFN","until","predicate","typeInstance","fnOrError","symbolName","noop","normalizeStep","to","step","range","append","listAppend","head","last","tail","init","uncons","unconsr","item0","concatMap","foldableOfA","intersperse","between","lastInd","intercalate","xss","transpose","numLists","ind2","longestListLen","maximum","outLists","outList","subsequences","listLen","pow","entry","j","swapped","ind1","tmp","permutations","repeat","foldl","foldr","foldl1","foldr1","mapAccumL","zero","mapped","tuple","mapAccumR","iterate","lastX","replicate","cycle","unfoldr","resultTuple","findIndex","findIndices","elemIndex","foundInd","elemIndices","take","drop","splitAt","takeWhile","dropWhile","splitPoint","dropWhileEnd","span","breakOnList","at","find","partition","elem","notElem","isPrefixOf","xs1","xs2","limit1","limit2","isSuffixOf","isInfixOf","foundLen","isSubsequenceOf","lenXs1","group","groupBy","equalityOp","prevItem","predOp","inits","tails","stripPrefix","prefix","zip","arr1","arr2","a1","a2","zipN","trimmedLists","zip3","arr3","zip4","arr4","zip5","arr5","zipWith","zipWithN","lenOfTrimmed","zipWith3","xs3","zipWith4","xs4","zipWith5","xs5","unzip","unzipN","lenItem0","any","p","all","and","or","not","sum","product","sortBy","minimum","scanl","scanl1","scanr","scanr1","nub","nubBy","remove","removeBy","sort","sortOn","valueFn","decorated","a0","b0","orderingFn","insert","foundIndex","insertBy","currItem","anyOp","storedItem","removeFirstsBy","unionBy","alreadyAdded","union","intersect","intersectBy","list1","list2","difference","array1","array2","complement","arr0","arrays","typeRefsToStringOrError","defaultErrorMessageCall","tmplContext","contextName","valueName","expectedTypeName","foundTypeName","messageSuffix","isMultiTypeNames","typesCopy","typesToMatchCopy","_getErrorIfNotTypeThrower","errorMessageCall","typeChecker","ValueType","_getErrorIfNotTypesThrower","valueTypes","expectedTypeNames","matchFound","_errorIfNotType","_errorIfNotTypes","getErrorIfNotTypeThrower","getErrorIfNotTypesThrower","errorIfNotType","errorIfNotTypes","lines","words","unwords","unlines","lcaseFirst","toLowerCase","substring","ucaseFirst","toUpperCase","camelCase","pattern","str","classCase"],"mappings":"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"} \ No newline at end of file diff --git a/dist/iife/fjl.min.js b/dist/iife/fjl.min.js index a88d611c..1ad9fc70 100644 --- a/dist/iife/fjl.min.js +++ b/dist/iife/fjl.min.js @@ -1 +1 @@ -/**! fjl.js 1.7.0 | License: BSD-3-Clause | Built-on: Sat Nov 10 2018 11:42:45 GMT-0500 (Eastern Standard Time) **/var fjl=function(n){"use strict";function r(n){this.wrapped=n}function t(n){function t(n,r){return new Promise(function(t,u){var c={key:n,arg:r,resolve:t,reject:u,next:null};i?i=i.next=c:(o=i=c,e(n,r))})}function e(t,o){try{var i=n[t](o),c=i.value,f=c instanceof r;Promise.resolve(f?c.wrapped:c).then(function(n){if(f)return void e("next",n);u(i.done?"return":"normal",n)},function(n){e("throw",n)})}catch(n){u("throw",n)}}function u(n,r){switch(n){case"return":o.resolve({value:r,done:!0});break;case"throw":o.reject(r);break;default:o.resolve({value:r,done:!1})}o=o.next,o?e(o.key,o.arg):i=null}var o,i;this._invoke=t,"function"!=typeof n.return&&(this.return=void 0)}function e(n,r){return(e=Object.setPrototypeOf||function(n,r){return n.__proto__=r,n})(n,r)}function u(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Date.prototype.toString.call(Reflect.construct(Date,[],function(){})),!0}catch(n){return!1}}function o(n,r,t){return o=u()?Reflect.construct:function(n,r,t){var u=[null];u.push.apply(u,r);var o=Function.bind.apply(n,u),i=new o;return t&&e(i,t.prototype),i},o.apply(null,arguments)}function i(n,r){return a(n)||l(n,r)||v()}function c(n){return f(n)||s(n)||p()}function f(n){if(Array.isArray(n)){for(var r=0,t=new Array(n.length);r=r||!r,f=r-o.length;return i?n.apply(void 0,c(o)):h(r,f,n,o)},m=function(n,r){if(!(r&&r instanceof Function))throw new Error("`curry*` functions expect first parameter to be of type `Function` though received ".concat(r,"?"));for(var t=arguments.length,e=new Array(t>2?t-2:0),u=2;u1?r-1:0),e=1;e1?t-1:0),u=1;u1?r-1:0),e=1;e1?r-1:0),e=1;e1?r-1:0),e=1;e1?t-1:0),u=1;u1?t-1:0),u=1;u1?r-1:0),e=1;e-1}}(),Un=N("indexOf"),Ln=N("lastIndexOf"),Dn=function(n){return!!n},qn=function(n){return!n},Jn=function(){return!0},Vn=function(){return!1},Gn=g(function(n,r){return n===r}),Hn=w(function(n){for(var r=arguments.length,t=new Array(r>1?r-1:0),e=1;er?1:nu?Yn(u,n):Zn(n)},r)}),tr=g(function(n,r,t,e){var u=D(e);if(!u)return t;for(var o=0,i=t;o=0&&!n(e[o],o,e);o--)i=r(i,e[o],o,e);return i}),ur=tr(Vn),or=er(Vn),ir=function(n){var r=D(n);return r?r-1:0},cr=g(function(n,r){for(var t=0,e=D(r);t=0;t-=1){if(!!n(r[t],t,r))return t}return-1}),ar=g(function(n,r){for(var t=D(r),e=0,u=[];e1?r-1:0),e=1;e1&&void 0!==arguments[1]?arguments[1]:Object;return J(r).map(function(e){return t&&fn(t,r[e])?[e,n(r[e],t)]:[e,r[e]]})},Ar=function(n){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:Object;return n.reduce(function(n,r){var t=i(r,2),e=t[0],u=t[1];return n[e]=u,n},new r)},Or=function n(r){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:Object;return r.reduce(function(r,e){var u=i(e,2),o=u[0],c=u[1];return pn(c)&&pn(c[0])&&2===c[0].length?(r[o]=n(c,t),r):(r[o]=c,r)},new t)},Nr=function(n){switch(y(n)){case"Null":case"Undefined":return[];case String.name:case Array.name:case"WeakMap":case"WeakSet":case"Map":case"Set":return Array.from(n);case Object.name:default:return wr(n)}},Sr=function(){for(var n=arguments.length,r=new Array(n),t=0;tr?t>0?-t:t:t<0?-1*t:t},Mr=g(function(n,r){var t=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1,e=n,u=[];if(0===(t=Wr(n,r,t))||n===r)return[n];for(;(r-e)*t>=0;e+=t)u.push(e);return u}),Rr=N("split"),zr=w(function(){for(var n=arguments.length,r=new Array(n),t=0;t=0;t-=1)r+=n[t];return r;default:for(;t>=0;t-=1)r.push(n[t]);return r}},Gr=g(function(n,r){if(!r||!r.length)return r;var t=r.length,e=t-1,u=Wn(r),o=0;if(dn(r)){for(;o0},i)},Qr=function(n){for(var r=D(n),t=Math.pow(2,r),e=[],u=0;u=0;i--)o=n(c,e[i],i),c=o[0],f=o[1];return[c,f]}),ut=g(function(n,r,t){for(var e=0,u=[],o=t;e=0;u--){if(n[u]!==r[o])return!1;o-=1}return!0}),Ft=g(function(n,r){var t=D(n),e=D(r);if(e-1&&(t+=1),t===o)return!0}return!1}),Pt=function(n){return Wt(function(n,r){return n===r},n)},Wt=g(function(n,r){var t=D(r);if(!t)return Zn(r);for(var e,u,o=0,i=function(r){return n(r,e)&&o++,!!n(r,u)&&(e=r,!0)},c=[];o1?r-1:0),e=1;e-1;)o=n(o,t[u],u,t),i.push(o),u--;return i}),ce=g(function(n,r){return r&&r.length?ie(n,_r(r),Ur(r)):[]}),fe=function(n){return he(function(n,r){return n===r},n)},ae=g(function(n,r){return de(function(n,r){return n===r},n,r)}),se=function(n){return pe($n,n)},le=g(function(n,r){return Kn(function(n){return n[1]},pe(function(n,r){var t=i(n,1),e=t[0],u=i(r,1),o=u[0];return $n(e,o)},Kn(function(r){return[n(r),r]},r)))}),pe=g(function(n,r){return Zn(r).sort(n||$n)}),ve=g(function(n,r){if(!r.length)return Wn(r,n);var t=at(function(r){return n<=r},r);return qr(-1===t?[r,Wn(r,n)]:Gr(Wn(r,n),ht(t,r)))}),ye=g(function(n,r,t){var e=D(t);if(!e)return[r];for(var u=0;u-1){var u=ht(e,t);return zr(u[0],Br(u[1]))}return Zn(t)}),me=g(function(n,r,t){return Zr(function(r,t){return de(n,t,r)},r,t)}),ge=g(function(n,r,t){return Zr(function(r,t){return Qt(function(r){return n(r,t)},r)?r:(r.push(t),r)},Zn(r),t)}),we=g(function(n,r){return zr(n,St(function(r){return!Bn(r,n)},r))}),be=g(function(n,r){return n&&r&&(n||r)?St(function(n){return Bn(n,r)},n):[]}),Ae=g(function(n,r,t){return Zr(function(r,e){return Qt(function(r){return n(e,r)},t)?(r.push(e),r):r},[],r)}),Oe=g(function(n,r){return n&&!r?Zn(n):!n&&r||!n&&!r?[]:ur(function(n,t){return Bn(t,r)?n:(n.push(t),n)},[],n)}),Ne=w(function(n){for(var r=arguments.length,t=new Array(r>1?r-1:0),e=1;e1&&void 0!==arguments[1]?arguments[1]:an;return function(t,e,u,o){var i=arguments.length>4&&void 0!==arguments[4]?arguments[4]:null,c=tn(t),f=y(o);if(r(t,o))return o;throw new Error(n({contextName:e,valueName:u,value:o,expectedTypeName:c,foundTypeName:f,messageSuffix:i}))}},xe=function(n){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:an;return function(t,e,u,o){var i=arguments.length>4&&void 0!==arguments[4]?arguments[4]:null,c=t.map(tn),f=t.some(function(n){return r(n,o)}),a=y(o);if(f)return o;throw new Error(n({contextName:e,valueName:u,value:o,expectedTypeName:c,foundTypeName:a,messageSuffix:i}))}},je=ke(Te),Ie=xe(Te),Fe=function(n){return g(ke(n))},Ee=function(n){return g(xe(n))},Pe=g(je),We=g(Ie),Me=Rr(/[\n\r]/gm),Re=Rr(/[\s\t]/gm),ze=Hr(" "),Ce=Hr("\n"),_e=function(n){return je(String,"lcaseFirst","xs",n),n[0].toLowerCase()+n.substring(1)},Be=function(n){return je(String,"ucaseFirst","xs",n),n[0].toUpperCase()+n.substring(1)},Ue=function(n){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:/[^a-z\d]/i;return Sr(F(""),Kn(function(n){return Be(n.toLowerCase())}),St(function(n){return!!n}),Rr(r))(je(String,"camelCase","xs",n))},Le=Sr(Be,Ue);return n.instanceOf=U,n.hasOwnProperty=L,n.length=D,n.native=q,n.assign=V,n.keys=J,n.lookup=Pn,n.typeOf=y,n.copy=Mn,n.toTypeRef=tn,n.toTypeRefs=en,n.toTypeRefName=un,n.toTypeRefNames=on,n.isFunction=cn,n.isType=fn,n.isOfType=an,n.isClass=sn,n.isCallable=ln,n.isObject=vn,n.isBoolean=yn,n.isNumber=hn,n.isString=dn,n.isMap=mn,n.isSet=gn,n.isWeakMap=wn,n.isWeakSet=bn,n.isUndefined=An,n.isNull=On,n.isSymbol=Nn,n.isUsableImmutablePrimitive=Sn,n.isEmptyList=Tn,n.isEmptyObject=kn,n.isEmptyCollection=xn,n.isEmpty=jn,n.isset=In,n.isOneOf=Fn,n.isFunctor=En,n.isArray=pn,n.of=Wn,n.searchObj=Rn,n.assignDeep=zn,n.objUnion=lr,n.objIntersect=pr,n.objDifference=vr,n.objComplement=yr,n.log=hr,n.error=dr,n.peek=mr,n.jsonClone=gr,n.toArray=Nr,n.toAssocList=wr,n.toAssocListDeep=br,n.fromAssocList=Ar,n.fromAssocListDeep=Or,n.isTruthy=Dn,n.isFalsy=qn,n.alwaysTrue=Jn,n.alwaysFalse=Vn,n.equal=Gn,n.equalAll=Hn,n.apply=W,n.call=M,n.compose=Sr,n.curryN=m,n.curry=g,n.curry2=w,n.curry3=b,n.curry4=A,n.curry5=O,n.flipN=R,n.flip=z,n.flip3=C,n.flip4=_,n.flip5=B,n.id=Tr,n.negateF=kr,n.negateF2=xr,n.negateF3=jr,n.negateFN=Ir,n.until=Fr,n.fnOrError=Er,n.noop=Pr,n.map=Kn,n.append=zr,n.head=Cr,n.last=_r,n.tail=Br,n.init=Ur,n.uncons=Lr,n.unconsr=Dr,n.concat=qr,n.concatMap=Jr,n.reverse=Vr,n.intersperse=Gr,n.intercalate=Hr,n.transpose=Kr,n.subsequences=Qr,n.swapped=Xr,n.permutations=Yr,n.foldl=Zr,n.foldr=$r,n.foldl1=nt,n.foldr1=rt,n.mapAccumL=tt,n.mapAccumR=et,n.iterate=ut,n.repeat=ot,n.replicate=it,n.cycle=ct,n.unfoldr=ft,n.findIndex=at,n.findIndices=st,n.elemIndex=lt,n.elemIndices=pt,n.take=vt,n.drop=yt,n.splitAt=ht,n.takeWhile=dt,n.dropWhile=mt,n.dropWhileEnd=gt,n.span=wt,n.breakOnList=bt,n.at=At,n.find=Ot,n.forEach=Nt,n.filter=St,n.partition=Tt,n.elem=kt,n.notElem=xt,n.isPrefixOf=jt,n.isSuffixOf=It,n.isInfixOf=Ft,n.isSubsequenceOf=Et,n.group=Pt,n.groupBy=Wt,n.inits=Mt,n.tails=Rt,n.stripPrefix=zt,n.zip=Ct,n.zipN=_t,n.zip3=Bt,n.zip4=Ut,n.zip5=Lt,n.zipWith=Dt,n.zipWithN=qt,n.zipWith3=Jt,n.zipWith4=Vt,n.zipWith5=Gt,n.unzip=Ht,n.unzipN=Kt,n.any=Qt,n.all=Xt,n.and=Yt,n.or=Zt,n.not=$t,n.sum=ne,n.product=re,n.maximum=te,n.minimum=ee,n.scanl=ue,n.scanl1=oe,n.scanr=ie,n.scanr1=ce,n.nub=fe,n.remove=ae,n.sort=se,n.sortOn=le,n.sortBy=pe,n.insert=ve,n.insertBy=ye,n.nubBy=he,n.removeBy=de,n.removeFirstsBy=me,n.unionBy=ge,n.union=we,n.intersect=be,n.intersectBy=Ae,n.difference=Oe,n.complement=Ne,n.slice=_n,n.includes=Bn,n.indexOf=Un,n.lastIndexOf=Ln,n.push=E,n.range=Mr,n.sliceFrom=Xn,n.sliceTo=Yn,n.sliceCopy=Zn,n.genericAscOrdering=$n,n.lengths=nr,n.toShortest=rr,n.reduceUntil=tr,n.reduceUntilRight=er,n.reduce=ur,n.reduceRight=or,n.lastIndex=ir,n.findIndexWhere=cr,n.findIndexWhereRight=fr,n.findIndicesWhere=ar,n.findWhere=sr,n.aggregateArray=Qn,n.split=Rr,n.lines=Me,n.words=Re,n.unwords=ze,n.unlines=Ce,n.lcaseFirst=_e,n.ucaseFirst=Be,n.camelCase=Ue,n.classCase=Le,n.fPureTakesOne=N,n.fPureTakes2=S,n.fPureTakes3=T,n.fPureTakes4=k,n.fPureTakes5=x,n.fPureTakesOneOrMore=j,n.typeRefsToStringOrError=Se,n.defaultErrorMessageCall=Te,n._getErrorIfNotTypeThrower=ke,n._getErrorIfNotTypesThrower=xe,n._errorIfNotType=je,n._errorIfNotTypes=Ie,n.getErrorIfNotTypeThrower=Fe,n.getErrorIfNotTypesThrower=Ee,n.errorIfNotType=Pe,n.errorIfNotTypes=We,n}({}); \ No newline at end of file +/**! fjl.js 1.7.0 | License: BSD-3-Clause | Built-on: Sat Nov 10 2018 12:36:13 GMT-0500 (Eastern Standard Time) **/var fjl=function(n){"use strict";function r(n){this.wrapped=n}function t(n){function t(n,r){return new Promise(function(t,u){var c={key:n,arg:r,resolve:t,reject:u,next:null};i?i=i.next=c:(o=i=c,e(n,r))})}function e(t,o){try{var i=n[t](o),c=i.value,f=c instanceof r;Promise.resolve(f?c.wrapped:c).then(function(n){if(f)return void e("next",n);u(i.done?"return":"normal",n)},function(n){e("throw",n)})}catch(n){u("throw",n)}}function u(n,r){switch(n){case"return":o.resolve({value:r,done:!0});break;case"throw":o.reject(r);break;default:o.resolve({value:r,done:!1})}o=o.next,o?e(o.key,o.arg):i=null}var o,i;this._invoke=t,"function"!=typeof n.return&&(this.return=void 0)}function e(n,r){return(e=Object.setPrototypeOf||function(n,r){return n.__proto__=r,n})(n,r)}function u(){if("undefined"==typeof Reflect||!Reflect.construct)return!1;if(Reflect.construct.sham)return!1;if("function"==typeof Proxy)return!0;try{return Date.prototype.toString.call(Reflect.construct(Date,[],function(){})),!0}catch(n){return!1}}function o(n,r,t){return o=u()?Reflect.construct:function(n,r,t){var u=[null];u.push.apply(u,r);var o=Function.bind.apply(n,u),i=new o;return t&&e(i,t.prototype),i},o.apply(null,arguments)}function i(n,r){return a(n)||l(n,r)||v()}function c(n){return f(n)||s(n)||p()}function f(n){if(Array.isArray(n)){for(var r=0,t=new Array(n.length);r=r||!r,f=r-o.length;return i?n.apply(void 0,c(o)):h(r,f,n,o)},m=function(n,r){if(!(r&&r instanceof Function))throw new Error("`curry*` functions expect first parameter to be of type `Function` though received ".concat(r,"?"));for(var t=arguments.length,e=new Array(t>2?t-2:0),u=2;u1?r-1:0),e=1;e1?t-1:0),u=1;u1?r-1:0),e=1;e1?r-1:0),e=1;e1?r-1:0),e=1;e1?t-1:0),u=1;u1?t-1:0),u=1;u1?r-1:0),e=1;e-1}}(),Un=N("indexOf"),Ln=N("lastIndexOf"),Dn=function(n){return!!n},qn=function(n){return!n},Jn=function(){return!0},Vn=function(){return!1},Gn=g(function(n,r){return n===r}),Hn=w(function(n){for(var r=arguments.length,t=new Array(r>1?r-1:0),e=1;er?1:nu?Yn(u,n):Zn(n)},r)}),tr=g(function(n,r,t,e){var u=D(e);if(!u)return t;for(var o=0,i=t;o=0&&!n(e[o],o,e);o--)i=r(i,e[o],o,e);return i}),ur=tr(Vn),or=er(Vn),ir=function(n){var r=D(n);return r?r-1:0},cr=g(function(n,r){for(var t=0,e=D(r);t=0;t-=1){if(!!n(r[t],t,r))return t}return-1}),ar=g(function(n,r){for(var t=D(r),e=0,u=[];e1?r-1:0),e=1;e1&&void 0!==arguments[1]?arguments[1]:Object;return J(r).map(function(e){return t&&fn(t,r[e])?[e,n(r[e],t)]:[e,r[e]]})},Ar=function(n){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:Object;return n.reduce(function(n,r){var t=i(r,2),e=t[0],u=t[1];return n[e]=u,n},new r)},Or=function n(r){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:Object;return r.reduce(function(r,e){var u=i(e,2),o=u[0],c=u[1];return pn(c)&&pn(c[0])&&2===c[0].length?(r[o]=n(c,t),r):(r[o]=c,r)},new t)},Nr=function(n){switch(y(n)){case"Null":case"Undefined":return[];case String.name:case Array.name:case"WeakMap":case"WeakSet":case"Map":case"Set":return Array.from(n);case Object.name:default:return wr(n)}},Sr=function(){for(var n=arguments.length,r=new Array(n),t=0;tr?t>0?-t:t:t<0?-1*t:t},Mr=g(function(n,r){var t=arguments.length>2&&void 0!==arguments[2]?arguments[2]:1,e=n,u=[];if(0===(t=Wr(n,r,t))||n===r)return[n];for(;(r-e)*t>=0;e+=t)u.push(e);return u}),Rr=N("split"),zr=w(function(){for(var n=arguments.length,r=new Array(n),t=0;t=0;t-=1)r+=n[t];return r;default:for(;t>=0;t-=1)r.push(n[t]);return r}},Gr=g(function(n,r){if(!r||!r.length)return r;var t=r.length,e=t-1,u=Wn(r),o=0;if(dn(r)){for(;o0},i)},Qr=function(n){for(var r=D(n),t=Math.pow(2,r),e=[],u=0;u=0;i--)o=n(c,e[i],i),c=o[0],f=o[1];return[c,f]}),ut=g(function(n,r,t){for(var e=0,u=[],o=t;e=0;u--){if(n[u]!==r[o])return!1;o-=1}return!0}),Ft=g(function(n,r){var t=D(n),e=D(r);if(e-1&&(t+=1),t===o)return!0}return!1}),Pt=function(n){return Wt(function(n,r){return n===r},n)},Wt=g(function(n,r){var t=D(r);if(!t)return Zn(r);for(var e,u,o=0,i=function(r){return n(r,e)&&o++,!!n(r,u)&&(e=r,!0)},c=[];o1?r-1:0),e=1;e-1;)o=n(o,t[u],u,t),i.push(o),u--;return i}),ce=g(function(n,r){return r&&r.length?ie(n,_r(r),Ur(r)):[]}),fe=function(n){return he(function(n,r){return n===r},n)},ae=g(function(n,r){return de(function(n,r){return n===r},n,r)}),se=function(n){return pe($n,n)},le=g(function(n,r){return Kn(function(n){return n[1]},pe(function(n,r){var t=i(n,1),e=t[0],u=i(r,1),o=u[0];return $n(e,o)},Kn(function(r){return[n(r),r]},r)))}),pe=g(function(n,r){return Zn(r).sort(n||$n)}),ve=g(function(n,r){if(!r.length)return Wn(r,n);var t=at(function(r){return n<=r},r);return qr(-1===t?[r,Wn(r,n)]:Gr(Wn(r,n),ht(t,r)))}),ye=g(function(n,r,t){var e=D(t);if(!e)return[r];for(var u=0;u-1){var u=ht(e,t);return zr(u[0],Br(u[1]))}return Zn(t)}),me=g(function(n,r,t){return Zr(function(r,t){return de(n,t,r)},r,t)}),ge=g(function(n,r,t){return Zr(function(r,t){return Qt(function(r){return n(r,t)},r)?r:(r.push(t),r)},Zn(r),t)}),we=g(function(n,r){return zr(n,St(function(r){return!Bn(r,n)},r))}),be=g(function(n,r){return n&&r&&(n||r)?St(function(n){return Bn(n,r)},n):[]}),Ae=g(function(n,r,t){return Zr(function(r,e){return Qt(function(r){return n(e,r)},t)?(r.push(e),r):r},[],r)}),Oe=g(function(n,r){return n&&!r?Zn(n):!n&&r||!n&&!r?[]:ur(function(n,t){return Bn(t,r)?n:(n.push(t),n)},[],n)}),Ne=w(function(n){for(var r=arguments.length,t=new Array(r>1?r-1:0),e=1;e1&&void 0!==arguments[1]?arguments[1]:an;return function(t,e,u,o){var i=arguments.length>4&&void 0!==arguments[4]?arguments[4]:null,c=tn(t),f=y(o);if(r(t,o))return o;throw new Error(n({contextName:e,valueName:u,value:o,expectedTypeName:c,foundTypeName:f,messageSuffix:i}))}},xe=function(n){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:an;return function(t,e,u,o){var i=arguments.length>4&&void 0!==arguments[4]?arguments[4]:null,c=t.map(tn),f=t.some(function(n){return r(n,o)}),a=y(o);if(f)return o;throw new Error(n({contextName:e,valueName:u,value:o,expectedTypeName:c,foundTypeName:a,messageSuffix:i}))}},je=ke(Te),Ie=xe(Te),Fe=function(n){return g(ke(n))},Ee=function(n){return g(xe(n))},Pe=g(je),We=g(Ie),Me=Rr(/[\n\r]/gm),Re=Rr(/[\s\t]/gm),ze=Hr(" "),Ce=Hr("\n"),_e=function(n){return je(String,"lcaseFirst","xs",n),n[0].toLowerCase()+n.substring(1)},Be=function(n){return je(String,"ucaseFirst","xs",n),n[0].toUpperCase()+n.substring(1)},Ue=function(n){var r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:/[^a-z\d]/i;return Sr(F(""),Kn(function(n){return Be(n.toLowerCase())}),St(function(n){return!!n}),Rr(r))(je(String,"camelCase","xs",n))},Le=Sr(Be,Ue);return n.instanceOf=U,n.hasOwnProperty=L,n.length=D,n.native=q,n.assign=V,n.keys=J,n.lookup=Pn,n.typeOf=y,n.copy=Mn,n.toTypeRef=tn,n.toTypeRefs=en,n.toTypeRefName=un,n.toTypeRefNames=on,n.isFunction=cn,n.isType=fn,n.isOfType=an,n.isClass=sn,n.isCallable=ln,n.isObject=vn,n.isBoolean=yn,n.isNumber=hn,n.isString=dn,n.isMap=mn,n.isSet=gn,n.isWeakMap=wn,n.isWeakSet=bn,n.isUndefined=An,n.isNull=On,n.isSymbol=Nn,n.isUsableImmutablePrimitive=Sn,n.isEmptyList=Tn,n.isEmptyObject=kn,n.isEmptyCollection=xn,n.isEmpty=jn,n.isset=In,n.isOneOf=Fn,n.isFunctor=En,n.isArray=pn,n.of=Wn,n.searchObj=Rn,n.assignDeep=zn,n.objUnion=lr,n.objIntersect=pr,n.objDifference=vr,n.objComplement=yr,n.log=hr,n.error=dr,n.peek=mr,n.jsonClone=gr,n.toArray=Nr,n.toAssocList=wr,n.toAssocListDeep=br,n.fromAssocList=Ar,n.fromAssocListDeep=Or,n.isTruthy=Dn,n.isFalsy=qn,n.alwaysTrue=Jn,n.alwaysFalse=Vn,n.equal=Gn,n.equalAll=Hn,n.apply=W,n.call=M,n.compose=Sr,n.curryN=m,n.curry=g,n.curry2=w,n.curry3=b,n.curry4=A,n.curry5=O,n.flipN=R,n.flip=z,n.flip3=C,n.flip4=_,n.flip5=B,n.id=Tr,n.negateF=kr,n.negateF2=xr,n.negateF3=jr,n.negateFN=Ir,n.until=Fr,n.fnOrError=Er,n.noop=Pr,n.map=Kn,n.append=zr,n.head=Cr,n.last=_r,n.tail=Br,n.init=Ur,n.uncons=Lr,n.unconsr=Dr,n.concat=qr,n.concatMap=Jr,n.reverse=Vr,n.intersperse=Gr,n.intercalate=Hr,n.transpose=Kr,n.subsequences=Qr,n.swapped=Xr,n.permutations=Yr,n.foldl=Zr,n.foldr=$r,n.foldl1=nt,n.foldr1=rt,n.mapAccumL=tt,n.mapAccumR=et,n.iterate=ut,n.repeat=ot,n.replicate=it,n.cycle=ct,n.unfoldr=ft,n.findIndex=at,n.findIndices=st,n.elemIndex=lt,n.elemIndices=pt,n.take=vt,n.drop=yt,n.splitAt=ht,n.takeWhile=dt,n.dropWhile=mt,n.dropWhileEnd=gt,n.span=wt,n.breakOnList=bt,n.at=At,n.find=Ot,n.forEach=Nt,n.filter=St,n.partition=Tt,n.elem=kt,n.notElem=xt,n.isPrefixOf=jt,n.isSuffixOf=It,n.isInfixOf=Ft,n.isSubsequenceOf=Et,n.group=Pt,n.groupBy=Wt,n.inits=Mt,n.tails=Rt,n.stripPrefix=zt,n.zip=Ct,n.zipN=_t,n.zip3=Bt,n.zip4=Ut,n.zip5=Lt,n.zipWith=Dt,n.zipWithN=qt,n.zipWith3=Jt,n.zipWith4=Vt,n.zipWith5=Gt,n.unzip=Ht,n.unzipN=Kt,n.any=Qt,n.all=Xt,n.and=Yt,n.or=Zt,n.not=$t,n.sum=ne,n.product=re,n.maximum=te,n.minimum=ee,n.scanl=ue,n.scanl1=oe,n.scanr=ie,n.scanr1=ce,n.nub=fe,n.remove=ae,n.sort=se,n.sortOn=le,n.sortBy=pe,n.insert=ve,n.insertBy=ye,n.nubBy=he,n.removeBy=de,n.removeFirstsBy=me,n.unionBy=ge,n.union=we,n.intersect=be,n.intersectBy=Ae,n.difference=Oe,n.complement=Ne,n.slice=_n,n.includes=Bn,n.indexOf=Un,n.lastIndexOf=Ln,n.push=E,n.range=Mr,n.sliceFrom=Xn,n.sliceTo=Yn,n.sliceCopy=Zn,n.genericAscOrdering=$n,n.lengths=nr,n.toShortest=rr,n.reduceUntil=tr,n.reduceUntilRight=er,n.reduce=ur,n.reduceRight=or,n.lastIndex=ir,n.findIndexWhere=cr,n.findIndexWhereRight=fr,n.findIndicesWhere=ar,n.findWhere=sr,n.aggregateArray=Qn,n.split=Rr,n.lines=Me,n.words=Re,n.unwords=ze,n.unlines=Ce,n.lcaseFirst=_e,n.ucaseFirst=Be,n.camelCase=Ue,n.classCase=Le,n.fPureTakesOne=N,n.fPureTakes2=S,n.fPureTakes3=T,n.fPureTakes4=k,n.fPureTakes5=x,n.fPureTakesOneOrMore=j,n.typeRefsToStringOrError=Se,n.defaultErrorMessageCall=Te,n._getErrorIfNotTypeThrower=ke,n._getErrorIfNotTypesThrower=xe,n._errorIfNotType=je,n._errorIfNotTypes=Ie,n.getErrorIfNotTypeThrower=Fe,n.getErrorIfNotTypesThrower=Ee,n.errorIfNotType=Pe,n.errorIfNotTypes=We,n}({}); \ No newline at end of file diff --git a/dist/umd/object/defineProp.js b/dist/umd/object/defineProp.js new file mode 100644 index 00000000..491a4316 --- /dev/null +++ b/dist/umd/object/defineProp.js @@ -0,0 +1,214 @@ +(function (global, factory) { + if (typeof define === "function" && define.amd) { + define(["exports", "../function/curry", "../jsPlatform/function", "../errorThrowing", "./is"], factory); + } else if (typeof exports !== "undefined") { + factory(exports, require("../function/curry"), require("../jsPlatform/function"), require("../errorThrowing"), require("./is")); + } else { + var mod = { + exports: {} + }; + factory(mod.exports, global.curry, global._function, global.errorThrowing, global.is); + global.defineProp = mod.exports; + } +})(this, function (_exports, _curry, _function, _errorThrowing, _is) { + "use strict"; + + Object.defineProperty(_exports, "__esModule", { + value: true + }); + _exports.defineProps = _exports.defineEnumProps = _exports.defineEnumProp = _exports.defineProp = _exports.toTargetDescriptorTuple = _exports.toEnumerableDescriptor = _exports.createTypedDescriptor = void 0; + + function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); } + + function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } + + function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + + function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + + /** + * Creates `defineProps` and `defineEnumProps` methods based on `{enumerable}` param. + * @param {{enumerable: Boolean}} + * @returns {function(*, *)|PropsDefinerCall} + * @private + */ + function createDefinePropsMethod(_ref) { + var enumerable = _ref.enumerable; + var operation = enumerable ? defineEnumProp : defineProp; + return function (argTuples, target) { + argTuples.forEach(function (argTuple) { + var _argTuple = _slicedToArray(argTuple, 3), + TypeRef = _argTuple[0], + propName = _argTuple[1], + defaultValue = _argTuple[2]; + + (0, _function.apply)(operation, [TypeRef, target, propName, defaultValue]); + }); + return target; + }; + } + + var + /** + * Creates a descriptor for a property which is settable but throws + * errors when the `Type` is disobeyed. + * @function module:object.createTypedDescriptor + * @param Type {TypeRef} - {String|Function} + * @param target {*} + * @param propName {String} + * @returns {Descriptor} - Property descriptor with just getter and setter. + */ + createTypedDescriptor = function createTypedDescriptor(Type, target, propName) { + var _value; + + return { + get: function get() { + return _value; + }, + set: function set(value) { + _value = (0, _errorThrowing.errorIfNotType)(Type, propName, target, value); + } + }; + }, + + /** + * Returns a target-descriptor tuple whose 'descriptor' will be set to + * enumerable (`enumerable: true`). + * @function module:object.toEnumerableDescriptor + * @param {TargetDescriptorTuple} - [target, descriptor] tuple. + * @returns {TargetDescriptorTuple} - Array of target and descriptor. + */ + toEnumerableDescriptor = function toEnumerableDescriptor(_ref2) { + var _ref3 = _slicedToArray(_ref2, 2), + target = _ref3[0], + descriptor = _ref3[1]; + + descriptor.enumerable = true; + return [target, descriptor]; + }, + + /** + * Returns an target and descriptor tuple from given. + * @function module:object.toTargetDescriptorTuple + * @param targetOrTargetDescriptorTuple {(*|Array<*, *>)} - Target object or tuple of target and descriptor. + * @returns {(Array<*>|Array<*,*>)} + */ + toTargetDescriptorTuple = function toTargetDescriptorTuple(targetOrTargetDescriptorTuple) { + return (0, _is.isType)('Array', targetOrTargetDescriptorTuple) ? // Strict type check for array + targetOrTargetDescriptorTuple : [targetOrTargetDescriptorTuple]; + }, + + /** + * Allows you to define a "typed" property on given `target`. + * @function module:object.defineProp + * @param Type {TypeRef} - {String|Function} + * @param target {TargetDescriptorTuple} - Target or array of target and descriptor ([target, descriptor]). + * @param propName {String} + * @param [defaultValue=undefined] {*} + * @returns {TargetDescriptorTuple} + */ + defineProp = function defineProp(Type, target, propName) { + var defaultValue = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined; + + var _toTargetDescriptorTu = toTargetDescriptorTuple(target), + _toTargetDescriptorTu2 = _slicedToArray(_toTargetDescriptorTu, 2), + _target = _toTargetDescriptorTu2[0], + _descriptor = _toTargetDescriptorTu2[1], + descriptor = _descriptor || createTypedDescriptor(Type, _target, propName); + + Object.defineProperty(_target, propName, descriptor); + + if (!(0, _is.isUndefined)(defaultValue)) { + _target[propName] = defaultValue; + } + + return [_target, descriptor]; + }, + + /** + * Allows you to define a "typed", enumerated property on `target`. + * @function module:object.defineEnumProp + * @param Type {TypeRef} - {String|Function} + * @param target {TargetDescriptorTuple} - Target or array of target and descriptor ([target, descriptor]). + * @param propName {String} + * @param [defaultValue=undefined] {*} + * @returns {TargetDescriptorTuple} + */ + defineEnumProp = function defineEnumProp(Type, target, propName) { + var defaultValue = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined; + + var _toTargetDescriptorTu3 = toTargetDescriptorTuple(target), + _toTargetDescriptorTu4 = _slicedToArray(_toTargetDescriptorTu3, 2), + _target = _toTargetDescriptorTu4[0], + _descriptor = _toTargetDescriptorTu4[1], + descriptor = _descriptor || createTypedDescriptor(Type, _target, propName); + + return defineProp(Type, toEnumerableDescriptor([_target, descriptor]), propName, defaultValue); + }, + + /** + * Allows you to define multiple enum props at once on target. + * @function module:object.defineEnumProps + * @param argsTuple {Array.} - Array of argArrays for `defineEnumProp`. + * @param [target = undefined] {Target} - Target to use in internal calls if one is not provided but encountered 'argArray'. + * @returns {Array.} - Results of each call to `defineEnumProp`. + */ + defineEnumProps = (0, _curry.curry)(createDefinePropsMethod({ + enumerable: true + })), + + /** + * Allows you to define multiple props at once on target. + * @function module:object.defineProps + * @param argsTuple {Array.} - Array of argArrays for `defineProp`. + * @param [target = undefined] {Target} - Target to use in internal calls if one is not provided but encountered 'argArray'. + * @returns {Array.} - Results of each call to `defineProp`. + * @curried + */ + defineProps = (0, _curry.curry)(createDefinePropsMethod({ + enumerable: false + })); + /** ============================================================= */ + + /** Type definitions: */ + + /** ============================================================= */ + + /** + * @typedef {*} Target + */ + + /** + * @typedef {Object} Descriptor + */ + + /** + * @typedef {Array} TargetDescriptorTuple + */ + + /** + * @typedef {Array.} DefinePropArgsTuple + * @description Arguments list for `defineProp` and/or `defineEnumProp` (note: some + * parts of array/tuple are options (namely the last two args)); E.g., + * ``` + * [String, [someTarget], 'somePropName', 'someDefaultValue] // ... + * ``` + */ + + /** + * @typedef {Function} PropsDefinerCall + * @description Same type as `defineProp` and `defineEnumProp` + * @param argsTuple {DefinePropArgsTuple} + * @param target {Target} + * @returns {Array.} + */ + + + _exports.defineProps = defineProps; + _exports.defineEnumProps = defineEnumProps; + _exports.defineEnumProp = defineEnumProp; + _exports.defineProp = defineProp; + _exports.toTargetDescriptorTuple = toTargetDescriptorTuple; + _exports.toEnumerableDescriptor = toEnumerableDescriptor; + _exports.createTypedDescriptor = createTypedDescriptor; +}); \ No newline at end of file diff --git a/docs/boolean.js.html b/docs/boolean.js.html index 84b7c1e4..09972930 100644 --- a/docs/boolean.js.html +++ b/docs/boolean.js.html @@ -36,7 +36,7 @@

Source: boolean.js

    - +
    diff --git a/docs/data_Functor.js.html b/docs/data_Functor.js.html index df739cfb..3ae705a1 100644 --- a/docs/data_Functor.js.html +++ b/docs/data_Functor.js.html @@ -36,7 +36,7 @@

    Source: data/Functor.js

      - +
      diff --git a/docs/errorThrowing.js.html b/docs/errorThrowing.js.html index eb77c557..bed71a2b 100644 --- a/docs/errorThrowing.js.html +++ b/docs/errorThrowing.js.html @@ -36,7 +36,7 @@

      Source: errorThrowing.js

        - +
        diff --git a/docs/fjl.js.html b/docs/fjl.js.html index 6dba69f3..3edf7d62 100644 --- a/docs/fjl.js.html +++ b/docs/fjl.js.html @@ -36,7 +36,7 @@

        Source: fjl.js

          - +
          @@ -65,6 +65,12 @@

          Source: fjl.js

          export * from './string'; export * from './utils'; export * from './errorThrowing'; + +/** + * @typedef {String|Function|ArrayBufferConstructor|ArrayConstructor|BooleanConstructor|MapConstructor|NumberConstructor|SetConstructor|WeakMapConstructor|WeakSetConstructor} TypeRef + * @description Type reference. Either actual type or type's name; E.g., `Type.name` + * Also note: Class cased names are use for values that do not have `name` properties; Namely: 'Null', 'NaN' and 'Undefined' (for their respective values respectively). + */ diff --git a/docs/function.js.html b/docs/function.js.html index dd2118bb..9825662e 100644 --- a/docs/function.js.html +++ b/docs/function.js.html @@ -36,7 +36,7 @@

          Source: function.js

            - +
            diff --git a/docs/function_compose.js.html b/docs/function_compose.js.html index 22e7ea63..225842d3 100644 --- a/docs/function_compose.js.html +++ b/docs/function_compose.js.html @@ -36,7 +36,7 @@

            Source: function/compose.js

              - +
              diff --git a/docs/function_curry.js.html b/docs/function_curry.js.html index d56e2f5b..415c75ec 100644 --- a/docs/function_curry.js.html +++ b/docs/function_curry.js.html @@ -36,7 +36,7 @@

              Source: function/curry.js

                - +
                diff --git a/docs/function_flip.js.html b/docs/function_flip.js.html index 305b1f9e..e7fdab15 100644 --- a/docs/function_flip.js.html +++ b/docs/function_flip.js.html @@ -36,7 +36,7 @@

                Source: function/flip.js

                  - +
                  diff --git a/docs/function_fnOrError.js.html b/docs/function_fnOrError.js.html index 93ba9cba..73f6abcd 100644 --- a/docs/function_fnOrError.js.html +++ b/docs/function_fnOrError.js.html @@ -36,7 +36,7 @@

                  Source: function/fnOrError.js

                    - +
                    diff --git a/docs/function_id.js.html b/docs/function_id.js.html index 218cf4c1..8ffcd8b6 100644 --- a/docs/function_id.js.html +++ b/docs/function_id.js.html @@ -36,7 +36,7 @@

                    Source: function/id.js

                      - +
                      diff --git a/docs/function_negate.js.html b/docs/function_negate.js.html index 68eba5b4..7af9fc55 100644 --- a/docs/function_negate.js.html +++ b/docs/function_negate.js.html @@ -36,7 +36,7 @@

                      Source: function/negate.js

                        - +
                        diff --git a/docs/function_noop.js.html b/docs/function_noop.js.html index 443255a1..9d1d663c 100644 --- a/docs/function_noop.js.html +++ b/docs/function_noop.js.html @@ -36,7 +36,7 @@

                        Source: function/noop.js

                          - +
                          diff --git a/docs/function_trampoline.js.html b/docs/function_trampoline.js.html index 553fe995..5a69fc82 100644 --- a/docs/function_trampoline.js.html +++ b/docs/function_trampoline.js.html @@ -36,7 +36,7 @@

                          Source: function/trampoline.js

                            - +
                            diff --git a/docs/function_until.js.html b/docs/function_until.js.html index 692f7fd4..c68c575d 100644 --- a/docs/function_until.js.html +++ b/docs/function_until.js.html @@ -36,7 +36,7 @@

                            Source: function/until.js

                              - +
                              diff --git a/docs/global.html b/docs/global.html index 5d08c571..99e2e6be 100644 --- a/docs/global.html +++ b/docs/global.html @@ -34,7 +34,7 @@

                              Global

                                - +
                                @@ -135,6 +135,160 @@
                                Type:
                                + + + + + + + + + + + + + + + + + + + + + +
                                +

                                + DefinePropArgsTuple + +
                                + object/defineProp.js, + line 148 +
                                + +

                                + + +
                                +
                                + +
                                + Arguments list for `defineProp` and/or `defineEnumProp` (note: some parts of array/tuple are options (namely the last two args)); E.g., ``` [String, [someTarget], 'somePropName', 'someDefaultValue] // ... ``` +
                                + + + + + + + +
                                + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                + + + + + +
                                + + + + +
                                +

                                + Descriptor + +
                                + object/defineProp.js, + line 140 +
                                + +

                                + + +
                                +
                                + + + + + + + +
                                + + + + + + + + + + + + + + + + + + + + @@ -831,47 +985,41 @@
                                Returns:
                                -

                                - TemplateContext - -
                                - errorThrowing.js, - line 172 -
                                -

                                - +

                                + + PropsDefinerCall(argsTuple, target) → {Array.<TargetDescriptorTuple>} + + +
                                + object/defineProp.js, + line 157 +
                                + +

                                + +
                                +
                                - Template context used for error message renderers (functions that take a context obj and return a string). + Same type as `defineProp` and `defineEnumProp`
                                - - -
                                Properties:
                                - - - +
                                +
                                Parameters:
                                + +
                                @@ -881,12 +1029,8 @@
                                Properties:
                                - - - - @@ -897,31 +1041,21 @@
                                Properties:
                                - + - - - - @@ -930,83 +1064,434 @@
                                Properties:
                                - + - - - - + +
                                TypeAttributesDefaultDescription
                                valueargsTuple -* +DefinePropArgsTuple - - - - - -
                                valueNametarget -String +Target - - - - - -
                                - - - expectedTypeName - + + - - - -String + + - - + - - - + - - - + - - + +
                                +
                                Returns:
                                + - - - Expected name of constructor of `value`; E.g., usually `SomeConstructor.name`; - - - - - foundTypeName - +Array.<TargetDescriptorTuple> - - - -String - - + + + + + + +
                                + + + + + +
                                + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                + + + + +
                                + + + + +
                                +

                                + Target + +
                                + object/defineProp.js, + line 136 +
                                + +

                                + + +
                                +
                                + + + + + + + +
                                + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                + + + + + +
                                + + + + +
                                +

                                + TargetDescriptorTuple + +
                                + object/defineProp.js, + line 144 +
                                + +

                                + + +
                                +
                                + + + + + + + +
                                + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                + + + + + +
                                + + + + +
                                +

                                + TemplateContext + +
                                + errorThrowing.js, + line 172 +
                                + +

                                + + +
                                +
                                + +
                                + Template context used for error message renderers (functions that take a context obj and return a string). +
                                + + + + + + + +
                                Properties:
                                + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - @@ -915,77 +911,69 @@
                                Parameters:
                                - + - - - - - + - + - + + + + + + + + + +String + + + - + + + + + @@ -1013,13 +1001,13 @@
                                Returns:
                                -* +Descriptor -- - Default is `Object` +- - Property descriptor with just getter and setter. @@ -1074,14 +1062,14 @@
                                Returns:
                                -

                                +

                                - static fromAssocListDeep(xs, OutTypeopt) → {*} + static defineEnumProp(Type, target, propName, defaultValueopt) → {TargetDescriptorTuple}
                                - object/assocList.js, - line 41 + object/defineProp.js, + line 91

                                @@ -1093,7 +1081,7 @@

                                - From associated list to object (deep conversion on associative lists (array of 2 value arrays)). + Allows you to define a "typed", enumerated property on `target`.
                                @@ -1121,8 +1109,6 @@

                                Parameters:
                                -
                                - @@ -1133,13 +1119,13 @@
                                Parameters:
                                - + + + + + + + + + + + + + + - + + + - + + + + + + + + + + + + + + - + + + @@ -1231,13 +1266,11 @@
                                Returns:
                                -* - +TargetDescriptorTuple -- - Default is `Object` @@ -1292,14 +1325,14 @@
                                Returns:
                                -

                                +

                                - static hasOwnProperty(propName, typeInstance) → {Boolean} + static defineEnumProps(argsTuple, targetopt) → {Array.<TargetDescriptorTuple>}
                                - jsPlatform/object.js, - line 23 + object/defineProp.js, + line 111

                                @@ -1310,6 +1343,10 @@

                                +
                                + Allows you to define multiple enum props at once on target. +
                                + @@ -1331,6 +1368,8 @@
                                Parameters:

                                + + @@ -1343,46 +1382,64 @@
                                Parameters:
                                - + + + - + - + + + - + @@ -1410,11 +1467,13 @@
                                Returns:
                                -Boolean +Array.<TargetDescriptorTuple> + +- - Results of each call to `defineEnumProp`. @@ -1443,8 +1502,6 @@
                                Returns:
                                -
                                Deprecated:
                                • - Use property directly instead.
                                - @@ -1471,14 +1528,14 @@
                                Returns:
                                -

                                +

                                - static instanceOf(instanceConstructor, instance) → {Boolean} + static defineProp(Type, target, propName, defaultValueopt) → {TargetDescriptorTuple}
                                - jsPlatform/object.js, - line 12 + object/defineProp.js, + line 72

                                @@ -1490,7 +1547,7 @@

                                - Returns whether constructor has derived object. + Allows you to define a "typed" property on given `target`.
                                @@ -1514,6 +1571,8 @@

                                Parameters:
                                + + @@ -1526,74 +1585,154 @@
                                Parameters:
                                - + + + - + - + + + - + - -
                                NameTypeAttributesDefaultDescription
                                value + + +* + + + + + + + + + +
                                valueName + + +String + + + + + + + + + +
                                expectedTypeName + + +String + + + + + + + + + + Expected name of constructor of `value`; E.g., usually `SomeConstructor.name`;
                                foundTypeName + + +String + + + + @@ -1272,6 +1757,95 @@
                                Returns:
                                + + + + + + + + + + + + + + + + + + + + +
                                + +

                                + + TypeRef() + + +
                                + fjl.js, + line 19 +
                                + +

                                + + + +
                                +
                                + + +
                                + Type reference. Either actual type or type's name; E.g., `Type.name` Also note: Class cased names are use for values that do not have `name` properties; Namely: 'Null', 'NaN' and 'Undefined' (for their respective values respectively). +
                                + + + + + + + + + + + + + + + + + + + + + + + + + +
                                + + + + + + + + + + + + + + + + + + + + diff --git a/docs/index.html b/docs/index.html index 7a4db586..1be113b4 100644 --- a/docs/index.html +++ b/docs/index.html @@ -34,7 +34,7 @@

                                Home

                                  - +
                                  @@ -223,6 +223,8 @@

                                  New additions

                                  • Added native which includes all the static methods that live on Object though flipped and curried.
                                    • +
                                  • Added 'fjl-mutable' as part of source. All methods of 'fjl-mutable' now +live directly on 'fjl' and are defined in 'fjl/objects/defineProp' (or more directly in src at './src/objects/defineProp').

                                  Development changes.

                                  		TypeAttributesDefaultDescription
                                  xsType -Array.<Array> +TypeRef - - - - - - - - Associated list.{String|Function}
                                  OutTypetarget -Constructor -| - -function +* - - <optional>
                                  - - + - -
                                  propName - - - Object - Output type. Default `Object`.
                                  DefaultDescription
                                  xsType -Array.<Array> +TypeRef @@ -1156,28 +1142,52 @@
                                  Parameters:
                                  -                                   		+ + {String|Function}
                                  target + + +TargetDescriptorTuple + + + + + + + + Associated list.Target or array of target and descriptor ([target, descriptor]).
                                  OutTypepropName -Constructor -| - -function +String @@ -1186,8 +1196,6 @@
                                  Parameters:
                                  		 - <optional>
                                  - @@ -1196,14 +1204,41 @@
                                  Parameters:
                                  -                                   		+ +
                                  defaultValue + - Object +* + + + + + + <optional>
                                  + + + +                                   		Output type. Default `Object`.
                                  TypeAttributes
                                  propNameargsTuple -* +Array.<DefinePropArgsTuple> + + + + + + Array of argArrays for `defineEnumProp`.
                                  typeInstancetarget -* +Target + + <optional>
                                  + + + + + +                                   		Target to use in internal calls if one is not provided but encountered 'argArray'.
                                  TypeAttributes
                                  instanceConstructorType -function +TypeRef + + + + + + Constructor.{String|Function}
                                  instancetarget -* +TargetDescriptorTuple + + + + + + Target or array of target and descriptor ([target, descriptor]).
                                  - - + + + propName + - + + + +String - - + + - + + + - + - -
                                  -
                                  Returns:
                                  - + + + + + -Boolean + + + + + defaultValue + + + + + +* + + + + + + + + + <optional>
                                  + + + + + + + + + + + + + + + + + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +TargetDescriptorTuple @@ -1652,14 +1791,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isArray(value) → {boolean} + static defineProps(argsTuple, targetopt) → {Array.<TargetDescriptorTuple>}
                                  - object/is.js, - line 147 + object/defineProp.js, + line 120

                                  @@ -1671,7 +1810,7 @@

                                  - Checks if value is an array (same as `Array.isArray`). + Allows you to define multiple props at once on target.
                                  @@ -1695,6 +1834,8 @@

                                  Parameters:
                                  Type + Attributes + @@ -1707,23 +1848,64 @@
                                  Parameters:
                                  - value + argsTuple -* +Array.<DefinePropArgsTuple> + + + + + + + + + + + + + + + + + + Array of argArrays for `defineProp`. + + + + + + + target + + + + + +Target + + + <optional>
                                  + + + + + - + + + Target to use in internal calls if one is not provided but encountered 'argArray'. @@ -1751,12 +1933,14 @@
                                  Returns:
                                  -boolean +Array.<TargetDescriptorTuple> +- - Results of each call to `defineProp`. + @@ -1810,14 +1994,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isBoolean(value) → {Boolean} + static fromAssocList(xs, OutTypeopt) → {*}
                                  - object/is.js, - line 163 + object/assocList.js, + line 29

                                  @@ -1829,7 +2013,7 @@

                                  - Checks if value is a boolean. + From associated list to object.
                                  @@ -1853,8 +2037,12 @@

                                  Parameters:
                                  Type + Attributes + + Default + Description @@ -1865,23 +2053,77 @@
                                  Parameters:
                                  - value + xs -* +Array.<Array> + + + + + + - + + + + + + + Associated list. + + + + + + + OutType + + + + + +Constructor +| + +function + + + + + + + + + <optional>
                                  + + + + + + + + + + + + Object + + + + + Output type. Default `Object`. @@ -1909,11 +2151,13 @@
                                  Returns:
                                  -Boolean +* + +- - Default is `Object` @@ -1968,14 +2212,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isCallable(x) → {Boolean} + static fromAssocListDeep(xs, OutTypeopt) → {*}
                                  - object/is.js, - line 138 + object/assocList.js, + line 41

                                  @@ -1987,7 +2231,7 @@

                                  - Returns a boolean depicting whether a value is callable or not. + From associated list to object (deep conversion on associative lists (array of 2 value arrays)).
                                  @@ -2011,8 +2255,12 @@

                                  Parameters:
                                  Type + Attributes + + Default + Description @@ -2023,23 +2271,77 @@
                                  Parameters:
                                  - x + xs -* +Array.<Array> + + + + + + + + + + + + - + Associated list. + + + + + + + OutType + + + + + +Constructor +| + +function + + + + + + + + + <optional>
                                  + + + + + + + + + + + + Object + + + + + Output type. Default `Object`. @@ -2067,11 +2369,13 @@
                                  Returns:
                                  -Boolean +* + +- - Default is `Object` @@ -2126,14 +2430,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isClass(x) → {boolean} + static hasOwnProperty(propName, typeInstance) → {Boolean}
                                  - object/is.js, - line 130 + jsPlatform/object.js, + line 23

                                  @@ -2144,10 +2448,6 @@

                                  -
                                  - Checks if `value` is an es2015 `class`. -
                                  - @@ -2181,7 +2481,30 @@
                                  Parameters:
                                  - x + propName + + + + + +* + + + + + + + + + + + + + + + + + typeInstance @@ -2225,7 +2548,7 @@
                                  Returns:
                                  -boolean +Boolean @@ -2258,6 +2581,8 @@
                                  Returns:
                                  +
                                  Deprecated:
                                  • - Use property directly instead.
                                  + @@ -2284,14 +2609,14 @@

                                  Returns:
                                  -

                                  +

                                  - static isEmpty(value) → {Boolean} + static instanceOf(instanceConstructor, instance) → {Boolean}
                                  - object/is.js, - line 282 + jsPlatform/object.js, + line 12

                                  @@ -2303,7 +2628,7 @@

                                  - Checks to see if passed in value is empty; I.e., check for one of '', 0, `null`, `undefined`, `false`, empty array, empty object, empty function (zero arity), or empty collection (es6 Map, Set, WeakMap, or WeakSet etc. (`!value.size`); + Returns whether constructor has derived object.
                                  @@ -2339,7 +2664,30 @@

                                  Parameters:
                                  - value + instanceConstructor + + + + + +function + + + + + + + + + + Constructor. + + + + + + + instance @@ -2355,7 +2703,7 @@
                                  Parameters:
                                  - Value to check. + @@ -2442,14 +2790,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isEmptyCollection(x) → {Boolean} + static isArray(value) → {boolean}
                                  object/is.js, - line 274 + line 147

                                  @@ -2461,7 +2809,7 @@

                                  - Checks if collection is empty or not (Map, WeakMap, WeakSet, Set etc.). + Checks if value is an array (same as `Array.isArray`).
                                  @@ -2497,7 +2845,7 @@

                                  Parameters:
                                  - x + value @@ -2541,7 +2889,7 @@
                                  Returns:
                                  -Boolean +boolean @@ -2600,14 +2948,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isEmptyList(x) → {Boolean} + static isBoolean(value) → {Boolean}
                                  object/is.js, - line 258 + line 163

                                  @@ -2619,7 +2967,7 @@

                                  - Checks if !length. + Checks if value is a boolean.
                                  @@ -2655,7 +3003,7 @@

                                  Parameters:
                                  - x + value @@ -2758,14 +3106,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isEmptyObject(obj) → {Boolean} + static isCallable(x) → {Boolean}
                                  object/is.js, - line 266 + line 138

                                  @@ -2777,7 +3125,7 @@

                                  - Checks if object has own properties/enumerable-props or not. + Returns a boolean depicting whether a value is callable or not.
                                  @@ -2813,7 +3161,7 @@

                                  Parameters:
                                  - obj + x @@ -2916,14 +3264,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isFunction(value) → {Boolean} + static isClass(x) → {boolean}
                                  object/is.js, - line 75 + line 130

                                  @@ -2935,7 +3283,7 @@

                                  - Returns whether a value is a function or not. + Checks if `value` is an es2015 `class`.
                                  @@ -2971,7 +3319,7 @@

                                  Parameters:
                                  - value + x @@ -3015,7 +3363,7 @@
                                  Returns:
                                  -Boolean +boolean @@ -3074,14 +3422,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isMap(value) → {Boolean} + static isEmpty(value) → {Boolean}
                                  object/is.js, - line 187 + line 282

                                  @@ -3093,7 +3441,7 @@

                                  - Checks whether value is of `Map` or not. + Checks to see if passed in value is empty; I.e., check for one of '', 0, `null`, `undefined`, `false`, empty array, empty object, empty function (zero arity), or empty collection (es6 Map, Set, WeakMap, or WeakSet etc. (`!value.size`);
                                  @@ -3145,7 +3493,7 @@

                                  Parameters:
                                  - + Value to check. @@ -3232,14 +3580,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isNull(value) → {Boolean} + static isEmptyCollection(x) → {Boolean}
                                  object/is.js, - line 227 + line 274

                                  @@ -3251,7 +3599,7 @@

                                  - Checks if value is null. + Checks if collection is empty or not (Map, WeakMap, WeakSet, Set etc.).
                                  @@ -3287,7 +3635,7 @@

                                  Parameters:
                                  - value + x @@ -3390,14 +3738,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isNumber(value) → {Boolean} + static isEmptyList(x) → {Boolean}
                                  object/is.js, - line 171 + line 258

                                  @@ -3409,7 +3757,7 @@

                                  - Checks if value is a valid number (also checks if isNaN so that you don't have to). + Checks if !length.
                                  @@ -3445,7 +3793,7 @@

                                  Parameters:
                                  - value + x @@ -3548,14 +3896,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isObject(value) → {Boolean} + static isEmptyObject(obj) → {Boolean}
                                  object/is.js, - line 155 + line 266

                                  @@ -3567,7 +3915,7 @@

                                  - Checks whether value is an object or not. + Checks if object has own properties/enumerable-props or not.
                                  @@ -3603,11 +3951,16 @@

                                  Parameters:
                                  - value + obj + +* + + + @@ -3701,14 +4054,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isOfType(type, x) → {Boolean} + static isFunction(value) → {Boolean}
                                  object/is.js, - line 102 + line 75

                                  @@ -3720,7 +4073,7 @@

                                  - Loose type checker; E.g., If `type` is not a constructor, but a constructor name, does a type check on constructor names, else if first check fails and `type` is a constructor, performs an `instanceof` check on value with constructor. + Returns whether a value is a function or not.
                                  @@ -3756,33 +4109,7 @@

                                  Parameters:
                                  - type - - - - - -function -| - -String - - - - - - - - - - Type reference (constructor or `constructor.name`). - - - - - - - x + value @@ -3798,7 +4125,7 @@
                                  Parameters:
                                  - Value to check. + @@ -3877,11 +4204,6 @@
                                  Returns:
                                  -
                                  Example
                                  - - 
                                  isOfType(Number, 99) === true        // true  (passes strict type check (numbers are not instances of `Number`
                                     //        constructor)
isOfType('Number', 99) === true      // true  (passes strict type check)
isOfType(Number, NaN) === true       // true. (passes instance of check)
                                     //        If you want "true" strict type checking use `isType`
isOfType(Object, []) === true        // true  (passes instance of check)
isOfType(Array, []) === true         // true  (passes instance of check)
isOfType(Object, {}) === true        // true  (passes instance of check)
isOfType(Object.name, {}) === true   // true  (Passes strict type check)
class Abc extends String {}
isOfType(String, new Abc('abcd')) // true (passes instanceof check)
                                  - -
                                  @@ -3890,14 +4212,14 @@
                                  Example
                                  -

                                  +

                                  - static isset(x) → {Boolean} + static isMap(value) → {Boolean}
                                  object/is.js, - line 314 + line 187

                                  @@ -3909,7 +4231,7 @@

                                  - Returns whether passed in values is defined and not null or not. + Checks whether value is of `Map` or not.
                                  @@ -3945,7 +4267,7 @@

                                  Parameters:
                                  - x + value @@ -4048,14 +4370,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isSet(value) → {Boolean} + static isNull(value) → {Boolean}
                                  object/is.js, - line 195 + line 227

                                  @@ -4067,7 +4389,7 @@

                                  - Checks whether value is of `Set` or not. + Checks if value is null.
                                  @@ -4206,14 +4528,14 @@

                                  Returns:
                                  -

                                  +

                                  - static isString(value) → {Boolean} + static isNumber(value) → {Boolean}
                                  object/is.js, - line 179 + line 171

                                  @@ -4225,7 +4547,7 @@

                                  - Checks whether value is a string or not. + Checks if value is a valid number (also checks if isNaN so that you don't have to).
                                  @@ -4364,14 +4686,14 @@

                                  Returns:
                                  -

                                  +

                                  - static isSymbol(value) → {Boolean} + static isObject(value) → {Boolean}
                                  object/is.js, - line 235 + line 155

                                  @@ -4383,7 +4705,7 @@

                                  - Checks if value is a `Symbol`. + Checks whether value is an object or not.
                                  @@ -4424,11 +4746,6 @@

                                  Parameters:
                                  - -* - - - @@ -4522,14 +4839,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isType(type, obj) → {Boolean} + static isOfType(type, x) → {Boolean}
                                  object/is.js, - line 83 + line 102

                                  @@ -4541,7 +4858,7 @@

                                  - Strict type checker. Checks if given value is a direct instance of given type; E.g., + Loose type checker; E.g., If `type` is not a constructor, but a constructor name, does a type check on constructor names, else if first check fails and `type` is a constructor, performs an `instanceof` check on value with constructor.
                                  @@ -4586,9 +4903,6 @@

                                  Parameters:
                                  function | -ObjectConstructor -| - String @@ -4599,14 +4913,14 @@
                                  Parameters:
                                  - Constructor or constructor name + Type reference (constructor or `constructor.name`). - obj + x @@ -4622,7 +4936,7 @@
                                  Parameters:
                                  - + Value to check. @@ -4703,7 +5017,7 @@
                                  Returns:
                                  Example
                                  - 
                                  isType(String, 'abcdefg')  === true // true
  isType(String.name, 'abcdefg') === true
  isType(Number, NaN) === false
  isType(Number, 99) === true
  isType('Null', 99) === false // though, for `null` and `undefined` checks
                               // @see `isset`, in this module, instead
  isType('Undefined', undefined) === true // true
                                  + 
                                  isOfType(Number, 99) === true        // true  (passes strict type check (numbers are not instances of `Number`
                                     //        constructor)
isOfType('Number', 99) === true      // true  (passes strict type check)
isOfType(Number, NaN) === true       // true. (passes instance of check)
                                     //        If you want "true" strict type checking use `isType`
isOfType(Object, []) === true        // true  (passes instance of check)
isOfType(Array, []) === true         // true  (passes instance of check)
isOfType(Object, {}) === true        // true  (passes instance of check)
isOfType(Object.name, {}) === true   // true  (Passes strict type check)
class Abc extends String {}
isOfType(String, new Abc('abcd')) // true (passes instanceof check)
                                  @@ -4714,14 +5028,14 @@
                                  Example
                                  -

                                  +

                                  - static isUndefined(value) → {Boolean} + static isSet(value) → {Boolean}
                                  object/is.js, - line 219 + line 195

                                  @@ -4733,7 +5047,7 @@

                                  - Checks if value is undefined. + Checks whether value is of `Set` or not.
                                  @@ -4872,14 +5186,14 @@

                                  Returns:
                                  -

                                  +

                                  - static isUsableImmutablePrimitive(x) → {Boolean} + static isset(x) → {Boolean}
                                  object/is.js, - line 243 + line 314

                                  @@ -4891,7 +5205,7 @@

                                  - Checks if given `x` is set and of one of [String, Boolean, Number, Symbol] (null and undefined are immutable but are not "usable" (usually not what we want to operate on). + Returns whether passed in values is defined and not null or not.
                                  @@ -5030,14 +5344,14 @@

                                  Returns:
                                  -

                                  +

                                  - static isWeakMap(value) → {Boolean} + static isString(value) → {Boolean}
                                  object/is.js, - line 203 + line 179

                                  @@ -5049,7 +5363,7 @@

                                  - Checks whether value is of `WeakMap` or not. + Checks whether value is a string or not.
                                  @@ -5188,14 +5502,14 @@

                                  Returns:
                                  -

                                  +

                                  - static isWeakSet(value) → {Boolean} + static isSymbol(value) → {Boolean}
                                  object/is.js, - line 211 + line 235

                                  @@ -5207,7 +5521,7 @@

                                  - Checks whether value is of `WeakSet` or not. + Checks if value is a `Symbol`.
                                  @@ -5346,14 +5660,14 @@

                                  Returns:
                                  -

                                  +

                                  - static jsonClone(x) → {*} + static isType(type, obj) → {Boolean}
                                  - object/jsonClone.js, - line 3 + object/is.js, + line 83

                                  @@ -5365,7 +5679,7 @@

                                  - Clones and object or array using `JSON.parse(JSON.stringify(...))` pattern. + Strict type checker. Checks if given value is a direct instance of given type; E.g.,
                                  @@ -5401,7 +5715,36 @@

                                  Parameters:
                                  - x + type + + + + + +function +| + +ObjectConstructor +| + +String + + + + + + + + + + Constructor or constructor name + + + + + + + obj @@ -5445,7 +5788,7 @@
                                  Returns:
                                  -* +Boolean @@ -5496,6 +5839,11 @@
                                  Returns:
                                  +
                                  Example
                                  + + 
                                  isType(String, 'abcdefg')  === true // true
  isType(String.name, 'abcdefg') === true
  isType(Number, NaN) === false
  isType(Number, 99) === true
  isType('Null', 99) === false // though, for `null` and `undefined` checks
                               // @see `isset`, in this module, instead
  isType('Undefined', undefined) === true // true
                                  + + @@ -5504,14 +5852,14 @@
                                  Returns:
                                  -

                                  +

                                  - static keys(obj) → {Array.<String>} + static isUndefined(value) → {Boolean}
                                  - jsPlatform/object.js, - line 76 + object/is.js, + line 219

                                  @@ -5523,7 +5871,7 @@

                                  - Gets passed in object's own enumerable keys (same as `Object.keys`). + Checks if value is undefined.
                                  @@ -5559,7 +5907,7 @@

                                  Parameters:
                                  - obj + value @@ -5603,7 +5951,7 @@
                                  Returns:
                                  -Array.<String> +Boolean @@ -5662,14 +6010,14 @@
                                  Returns:
                                  -

                                  +

                                  - static length(x) → {Number} + static isUsableImmutablePrimitive(x) → {Boolean}
                                  - jsPlatform/object.js, - line 32 + object/is.js, + line 243

                                  @@ -5680,6 +6028,10 @@

                                  +
                                  + Checks if given `x` is set and of one of [String, Boolean, Number, Symbol] (null and undefined are immutable but are not "usable" (usually not what we want to operate on). +
                                  + @@ -5748,35 +6100,6 @@
                                  Parameters:
                                  -
                                  Throws:
                                  - - - -
                                  -
                                  -
                                  - - Throws an error if value doesn't have a `length` property ( `null`, `undefined`, {Boolean}, Symbol, et. al.). -
                                  -
                                  -
                                  -
                                  -
                                  -
                                  - Type -
                                  -
                                  - -Error - - -
                                  -
                                  -
                                  -
                                  -
                                  - - -
                                  @@ -5786,7 +6109,7 @@
                                  Returns:
                                  -Number +Boolean @@ -5845,14 +6168,14 @@
                                  Returns:
                                  -

                                  +

                                  - static lookup(key, obj) → {*} + static isWeakMap(value) → {Boolean}
                                  - object/lookup.js, - line 8 + object/is.js, + line 203

                                  @@ -5864,7 +6187,7 @@

                                  - Looks up property and returns it's value; Else `undefined`. Method is null safe (will not throw on `null` or `undefined`). + Checks whether value is of `WeakMap` or not.
                                  @@ -5900,36 +6223,13 @@

                                  Parameters:
                                  - key - - - - - -String - - - - - - - - - - Key to search on `obj` - - - - - - - obj + value -Object +* @@ -5939,7 +6239,7 @@
                                  Parameters:
                                  - Object to search `name` on. + @@ -5967,7 +6267,7 @@
                                  Returns:
                                  -* +Boolean @@ -6026,14 +6326,14 @@
                                  Returns:
                                  -

                                  +

                                  - static of(x, …argsopt) → {*|undefined} + static isWeakSet(value) → {Boolean}
                                  - object/of.js, - line 4 + object/is.js, + line 211

                                  @@ -6045,7 +6345,7 @@

                                  - Creates a value `of` given type; Checks for one of the following construction strategies (in order listed): + Checks whether value is of `WeakSet` or not.
                                  @@ -6069,8 +6369,6 @@

                                  Parameters:
                                  Type - Attributes - @@ -6083,38 +6381,7 @@
                                  Parameters:
                                  - x - - - - - -* - - - - - - - - - - - - - - - - - - Value to derive returned value's type from. - - - - - - - args + value @@ -6127,22 +6394,10 @@
                                  Parameters:
                                  - - - <optional>
                                  - - - - - - <repeatable>
                                  - - - - Any args to pass in to matched construction strategy. + @@ -6170,16 +6425,11 @@
                                  Returns:
                                  -* -| - -undefined - +Boolean -- - New value of given value's type else `undefined`. @@ -6226,11 +6476,6 @@
                                  Returns:
                                  -
                                  Example
                                  - - 
                                  // - If exists `(value).constructor.of` uses this.
// - If value is of one String, Boolean, Symbol, or Number types calls it's
//      constructor as a function (in cast form;  E.g., `constructor(...args)` )
// - Else if constructor is a function, thus far, then calls constructor using
//      the `new` keyword (with any passed in args).
                                  - - @@ -6239,14 +6484,14 @@
                                  Example
                                  -

                                  +

                                  - static searchObj(nsString, obj) → {*} + static jsonClone(x) → {*}
                                  - object/searchObj.js, - line 6 + object/jsonClone.js, + line 3

                                  @@ -6258,7 +6503,7 @@

                                  - Gives you value at key/namespace-key within `obj`; E.g., searchObj('all.your.base', {all: {your: {base: 99}}}) === 99 // `true` + Clones and object or array using `JSON.parse(JSON.stringify(...))` pattern.
                                  @@ -6294,30 +6539,7 @@

                                  Parameters:
                                  - nsString - - - - - -String - - - - - - - - - - - - - - - - - obj + x @@ -6412,11 +6634,6 @@
                                  Returns:
                                  -
                                  Example
                                  - - 
                                  ```
if (obj && obj.all && obj.all.your && obj.all.your.base) {
  // Thing we want to do
}

// So with our function becomes
if (searchObj('all.your.base', obj)) {
  // Thing we want to do
}
```
                                  - - @@ -6425,14 +6642,14 @@
                                  Example
                                  -

                                  +

                                  - static toArray(x) → {Array} + static keys(obj) → {Array.<String>}
                                  - object/toArray.js, - line 6 + jsPlatform/object.js, + line 76

                                  @@ -6444,7 +6661,7 @@

                                  - Converts incoming value to an array. + Gets passed in object's own enumerable keys (same as `Object.keys`).
                                  @@ -6480,7 +6697,7 @@

                                  Parameters:
                                  - x + obj @@ -6496,7 +6713,7 @@
                                  Parameters:
                                  - Thing to convert from. + @@ -6524,7 +6741,7 @@
                                  Returns:
                                  -Array +Array.<String> @@ -6583,14 +6800,14 @@
                                  Returns:
                                  -

                                  +

                                  - static toAssocList(obj) → {Array.<*, *>} + static length(x) → {Number}
                                  - object/assocList.js, - line 6 + jsPlatform/object.js, + line 32

                                  @@ -6601,10 +6818,6 @@

                                  -
                                  - Returns an associated list from given object. -
                                  - @@ -6638,18 +6851,12 @@
                                  Parameters:
                                  - obj + x -Object -| - -Array -| - * @@ -6679,6 +6886,35 @@
                                  Parameters:
                                  +
                                  Throws:
                                  + + + +
                                  +
                                  +
                                  + - Throws an error if value doesn't have a `length` property ( `null`, `undefined`, {Boolean}, Symbol, et. al.). +
                                  +
                                  +
                                  +
                                  +
                                  +
                                  + Type +
                                  +
                                  + +Error + + +
                                  +
                                  +
                                  +
                                  +
                                  + + +
                                  @@ -6688,7 +6924,7 @@
                                  Returns:
                                  -Array.<*, *> +Number @@ -6747,14 +6983,14 @@
                                  Returns:
                                  -

                                  +

                                  - static toAssocListDeep(obj, TypeConstraintopt) → {*} + static lookup(key, obj) → {*}
                                  - object/assocList.js, - line 15 + object/lookup.js, + line 8

                                  @@ -6766,7 +7002,7 @@

                                  - Returns an associated list from given object (deeply (on incoming object's type)). + Looks up property and returns it's value; Else `undefined`. Method is null safe (will not throw on `null` or `undefined`).
                                  @@ -6790,12 +7026,8 @@

                                  Parameters:
                                  Type - Attributes - - Default - Description @@ -6806,77 +7038,46 @@
                                  Parameters:
                                  - obj + key -* +String - - - - - - - - - - - - - + Key to search on `obj` - TypeConstraint + obj -Constructor -| - -function +Object - - - <optional>
                                  - - - - - - - - - - Object - - - - Type constraint to convert on. + Object to search `name` on. @@ -6963,14 +7164,14 @@
                                  Returns:
                                  -

                                  +

                                  - static toTypeRef(type) → {String} + static of(x, …argsopt) → {*|undefined}
                                  - object/is.js, - line 27 + object/of.js, + line 4

                                  @@ -6982,7 +7183,7 @@

                                  - Resolves/normalizes a type name from either a string or a constructor. + Creates a value `of` given type; Checks for one of the following construction strategies (in order listed):
                                  @@ -7006,6 +7207,8 @@

                                  Parameters:
                                  Type + Attributes + @@ -7018,26 +7221,66 @@
                                  Parameters:
                                  - type + x -function -| +* -String + + + + + + + + + + + + + + + + + Value to derive returned value's type from. + + + + + + + args + + + + + +* + + + <optional>
                                  + + + + + + <repeatable>
                                  + + + - String or function representing a type. + Any args to pass in to matched construction strategy. @@ -7065,11 +7308,16 @@
                                  Returns:
                                  -String +* +| + +undefined + +- - New value of given value's type else `undefined`. @@ -7111,18 +7359,16 @@
                                  Returns:
                                  - -
                                  To Do:
                                  -
                                  -
                                    -
                                  • write tests for this function.
                                    • -
                                  -
                                  +

                                  Example
                                  + + 
                                  // - If exists `(value).constructor.of` uses this.
// - If value is of one String, Boolean, Symbol, or Number types calls it's
//      constructor as a function (in cast form;  E.g., `constructor(...args)` )
// - Else if constructor is a function, thus far, then calls constructor using
//      the `new` keyword (with any passed in args).
                                  + + @@ -7131,15 +7377,15 @@
                                  Returns:
                                  -

                                  +

                                  - static toTypeRefName(Type) → {String} + static searchObj(nsString, obj) → {*}
                                  - object/is.js, - line 54 -
                                  + object/searchObj.js, + line 6 +

                                  @@ -7150,7 +7396,7 @@

                                  - Returns possible Type's TypeRef name. + Gives you value at key/namespace-key within `obj`; E.g., searchObj('all.your.base', {all: {your: {base: 99}}}) === 99 // `true`
                                  @@ -7186,15 +7432,35 @@

                                  Parameters:
                                  - Type + nsString -TypeRef -| +String + + + + + + + + + + + + + + + + obj + + + + + * @@ -7233,7 +7499,7 @@
                                  Returns:
                                  -String +* @@ -7279,18 +7545,16 @@
                                  Returns:
                                  - -
                                  To Do:
                                  -
                                  -
                                    -
                                  • Ensure tests are written for this function.
                                    • -
                                  -
                                  +

                                  Example
                                  + + 
                                  ```
if (obj && obj.all && obj.all.your && obj.all.your.base) {
  // Thing we want to do
}

// So with our function becomes
if (searchObj('all.your.base', obj)) {
  // Thing we want to do
}
```
                                  + + @@ -7299,14 +7563,14 @@
                                  Returns:
                                  -

                                  +

                                  - static toTypeRefNames(…types) → {Array.<String>} + static toArray(x) → {Array}
                                  - object/is.js, - line 66 + object/toArray.js, + line 6

                                  @@ -7318,7 +7582,7 @@

                                  - Returns possible Types' TypeRef names. + Converts incoming value to an array.
                                  @@ -7342,8 +7606,6 @@

                                  Parameters:
                                  Type - Attributes - @@ -7356,15 +7618,12 @@
                                  Parameters:
                                  - types + x -TypeRef -| - * @@ -7372,20 +7631,10 @@
                                  Parameters:
                                  - - - - - - - <repeatable>
                                  - - - - + Thing to convert from. @@ -7413,7 +7662,7 @@
                                  Returns:
                                  -Array.<String> +Array @@ -7459,13 +7708,6 @@
                                  Returns:
                                  - -
                                  To Do:
                                  -
                                  -
                                    -
                                  • Ensure tests are written for this function.
                                    • -
                                  -
                                  @@ -7479,14 +7721,14 @@
                                  Returns:
                                  -

                                  +

                                  - static toTypeRefs(…types) → {Array.<TypeRef>} + static toAssocList(obj) → {Array.<*, *>}
                                  - object/is.js, - line 44 + object/assocList.js, + line 6

                                  @@ -7498,7 +7740,7 @@

                                  - Returns an array of type refs from possible type refs (converts null, undefined, NaN, and other values into type refs (either constructor name or constructor name based on whether value(s) is a string, a constructor, or not). + Returns an associated list from given object.
                                  @@ -7522,8 +7764,6 @@

                                  Parameters:
                                  Type - Attributes - @@ -7536,13 +7776,16 @@
                                  Parameters:
                                  - types + obj -TypeRef +Object +| + +Array | * @@ -7552,16 +7795,6 @@
                                  Parameters:
                                  - - - - - - - <repeatable>
                                  - - - @@ -7593,7 +7826,7 @@
                                  Returns:
                                  -Array.<TypeRef> +Array.<*, *> @@ -7639,13 +7872,6 @@
                                  Returns:
                                  - -
                                  To Do:
                                  -
                                  -
                                    -
                                  • Ensure tests are written for this function.
                                    • -
                                  -
                                  @@ -7659,14 +7885,14 @@
                                  Returns:
                                  -

                                  +

                                  - static typeOf(value) → {string} + static toAssocListDeep(obj, TypeConstraintopt) → {*}
                                  - object/typeOf.js, - line 10 + object/assocList.js, + line 15

                                  @@ -7678,7 +7904,7 @@

                                  - Returns the constructor/class/type name of a value. + Returns an associated list from given object (deeply (on incoming object's type)).
                                  @@ -7702,8 +7928,12 @@

                                  Parameters:
                                  Type + Attributes + + Default + Description @@ -7714,7 +7944,7 @@
                                  Parameters:
                                  - value + obj @@ -7727,13 +7957,67 @@
                                  Parameters:
                                  + + + + + + + + + + + + + + + + TypeConstraint + + + + + +Constructor +| + +function + + + + + + + + + <optional>
                                  + + + + + + + + + + + + Object + + + + + Type constraint to convert on. + + + @@ -7758,13 +8042,11 @@
                                  Returns:
                                  -string - +* -- - Constructor's name or derived name (in the case of `null`, `undefined`, or `NaN` (whose normalized names are 'Null', 'Undefined', 'NaN' respectively). @@ -7814,49 +8096,32 @@
                                  Returns:
                                  - - - - - - - - - - - - - - - - -
                                  - -
                                  - -

                                  object

                                  - - - -
                                  + -
                                  +
                                  -
                                  - - - +

                                  + static toEnumerableDescriptor() → {TargetDescriptorTuple} + +
                                  + object/defineProp.js, + line 50 +
                                  + +

                                  -
                                  +
                                  - +
                                  + Returns a target-descriptor tuple whose 'descriptor' will be set to enumerable (`enumerable: true`). +
                                  @@ -7866,40 +8131,12071 @@

                                  object

                                  +
                                  +
                                  Parameters:
                                  + + + + + - + - + - + - + + + + - + + + + + + + + + + + + + + +
                                  TypeDescription
                                  + + +TargetDescriptorTuple + + + + [target, descriptor] tuple.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +TargetDescriptorTuple + + + + + +- - Array of target and descriptor. + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static toTargetDescriptorTuple(targetOrTargetDescriptorTuple) → {Array.<*>|Array.<*, *>} + + +
                                  + object/defineProp.js, + line 62 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Returns an target and descriptor tuple from given. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  targetOrTargetDescriptorTuple + + +* +| + +Array.<*, *> + + + + Target object or tuple of target and descriptor.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Array.<*> +| + +Array.<*, *> + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static toTypeRef(type) → {String} + + +
                                  + object/is.js, + line 27 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Resolves/normalizes a type name from either a string or a constructor. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  type + + +function +| + +String + + + + String or function representing a type.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +String + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  To Do:
                                  +
                                  +
                                    +
                                  • write tests for this function.
                                    • +
                                  +
                                  + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static toTypeRefName(Type) → {String} + + +
                                  + object/is.js, + line 54 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Returns possible Type's TypeRef name. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  Type + + +TypeRef +| + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +String + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  To Do:
                                  +
                                  +
                                    +
                                  • Ensure tests are written for this function.
                                    • +
                                  +
                                  + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static toTypeRefNames(…types) → {Array.<String>} + + +
                                  + object/is.js, + line 66 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Returns possible Types' TypeRef names. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDescription
                                  types + + +TypeRef +| + +* + + + + + + + + + + <repeatable>
                                  + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Array.<String> + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  To Do:
                                  +
                                  +
                                    +
                                  • Ensure tests are written for this function.
                                    • +
                                  +
                                  + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static toTypeRefs(…types) → {Array.<TypeRef>} + + +
                                  + object/is.js, + line 44 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Returns an array of type refs from possible type refs (converts null, undefined, NaN, and other values into type refs (either constructor name or constructor name based on whether value(s) is a string, a constructor, or not). +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDescription
                                  types + + +TypeRef +| + +* + + + + + + + + + + <repeatable>
                                  + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Array.<TypeRef> + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  To Do:
                                  +
                                  +
                                    +
                                  • Ensure tests are written for this function.
                                    • +
                                  +
                                  + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static typeOf(value) → {string} + + +
                                  + object/typeOf.js, + line 10 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Returns the constructor/class/type name of a value. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  value + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +string + + + + + +- - Constructor's name or derived name (in the case of `null`, `undefined`, or `NaN` (whose normalized names are 'Null', 'Undefined', 'NaN' respectively). + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + + + + +
                                  + +
                                  + + + + + + + +
                                  + +
                                  + +

                                  object

                                  + + + + +
                                  + +
                                  + +
                                  + + + + + + +
                                  + +
                                  +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + +
                                  + + + + + + + + + + + + + + + +

                                  Members

                                  + +
                                  + + +
                                  +

                                  + static, constant native :Object + +
                                  + jsPlatform/object.js, + line 51 +
                                  + +

                                  + + +
                                  +
                                  + +
                                  + Contains all the static functions from `Object` but curried and flipped; +
                                  + + + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + + +
                                  Example
                                  + + 
                                  // E.g., `Object.defineProperties(obj, descriptor)` can now be used like
import {defineProperties} from 'fjl'
defineProperties(descriptor, someObj),
// Et. al.
                                  + + +
                                  + +
                                  + + + +

                                  Methods

                                  + +
                                  + + +
                                  + +

                                  + + static assign(obj0, …objs) → {Object} + + +
                                  + jsPlatform/object.js, + line 84 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Defined as `Object.assign` else is the same thing but shimmed. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDescription
                                  obj0 + + +Object + + + + + + + + + +
                                  objs + + +Object + + + + + + + + + + <repeatable>
                                  + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Object + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static assignDeep(obj0, …objsopt) → {Object} + + +
                                  + object/assignDeep.js, + line 7 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Merges all objects down into one (takes two or more args). +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDescription
                                  obj0 + + +Object + + + + + + + + + +
                                  objs + + +Object + + + + + + <optional>
                                  + + + + + + <repeatable>
                                  + +                                   		One or more objects to merge onto `obj0`.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Object + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static copy(x, outopt) → {*} + + +
                                  + object/copy.js, + line 6 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Make a copy of a value or optionally copy incoming value onto an outgoing value (second parameter). +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDescription
                                  x + + +* + + + + + + + + + + Thing to copy.
                                  out + + +* + + + + + + <optional>
                                  + + + + + +                                   		Optional value to copy on to. Not required.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +* + + + + + +- - Copied thing or optionally outgoing value copied onto. + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static createTypedDescriptor(Type, target, propName) → {Descriptor} + + +
                                  + object/defineProp.js, + line 29 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Creates a descriptor for a property which is settable but throws errors when the `Type` is disobeyed. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  Type + + +TypeRef + + + + {String|Function}
                                  target + + +* + + + +
                                  propName + + +String + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Descriptor + + + + + +- - Property descriptor with just getter and setter. + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static defineEnumProp(Type, target, propName, defaultValueopt) → {TargetDescriptorTuple} + + +
                                  + object/defineProp.js, + line 91 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Allows you to define a "typed", enumerated property on `target`. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDescription
                                  Type + + +TypeRef + + + + + + + + + + {String|Function}
                                  target + + +TargetDescriptorTuple + + + + + + + + + + Target or array of target and descriptor ([target, descriptor]).
                                  propName + + +String + + + + + + + + + +
                                  defaultValue + + +* + + + + + + <optional>
                                  + + + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +TargetDescriptorTuple + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static defineEnumProps(argsTuple, targetopt) → {Array.<TargetDescriptorTuple>} + + +
                                  + object/defineProp.js, + line 111 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Allows you to define multiple enum props at once on target. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDescription
                                  argsTuple + + +Array.<DefinePropArgsTuple> + + + + + + + + + + Array of argArrays for `defineEnumProp`.
                                  target + + +Target + + + + + + <optional>
                                  + + + + + +                                   		Target to use in internal calls if one is not provided but encountered 'argArray'.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Array.<TargetDescriptorTuple> + + + + + +- - Results of each call to `defineEnumProp`. + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static defineProp(Type, target, propName, defaultValueopt) → {TargetDescriptorTuple} + + +
                                  + object/defineProp.js, + line 72 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Allows you to define a "typed" property on given `target`. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDescription
                                  Type + + +TypeRef + + + + + + + + + + {String|Function}
                                  target + + +TargetDescriptorTuple + + + + + + + + + + Target or array of target and descriptor ([target, descriptor]).
                                  propName + + +String + + + + + + + + + +
                                  defaultValue + + +* + + + + + + <optional>
                                  + + + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +TargetDescriptorTuple + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static defineProps(argsTuple, targetopt) → {Array.<TargetDescriptorTuple>} + + +
                                  + object/defineProp.js, + line 120 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Allows you to define multiple props at once on target. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDescription
                                  argsTuple + + +Array.<DefinePropArgsTuple> + + + + + + + + + + Array of argArrays for `defineProp`.
                                  target + + +Target + + + + + + <optional>
                                  + + + + + +                                   		Target to use in internal calls if one is not provided but encountered 'argArray'.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Array.<TargetDescriptorTuple> + + + + + +- - Results of each call to `defineProp`. + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static fromAssocList(xs, OutTypeopt) → {*} + + +
                                  + object/assocList.js, + line 29 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + From associated list to object. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDefaultDescription
                                  xs + + +Array.<Array> + + + + + + + + + + + + Associated list.
                                  OutType + + +Constructor +| + +function + + + + + + <optional>
                                  + + + + + +                                   		+ + Object + + Output type. Default `Object`.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +* + + + + + +- - Default is `Object` + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static fromAssocListDeep(xs, OutTypeopt) → {*} + + +
                                  + object/assocList.js, + line 41 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + From associated list to object (deep conversion on associative lists (array of 2 value arrays)). +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDefaultDescription
                                  xs + + +Array.<Array> + + + + + + + + + + + + Associated list.
                                  OutType + + +Constructor +| + +function + + + + + + <optional>
                                  + + + + + +                                   		+ + Object + + Output type. Default `Object`.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +* + + + + + +- - Default is `Object` + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static hasOwnProperty(propName, typeInstance) → {Boolean} + + +
                                  + jsPlatform/object.js, + line 23 +
                                  + +

                                  + + + +
                                  +
                                  + + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  propName + + +* + + + +
                                  typeInstance + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + +
                                  Deprecated:
                                  • - Use property directly instead.
                                  + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static instanceOf(instanceConstructor, instance) → {Boolean} + + +
                                  + jsPlatform/object.js, + line 12 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Returns whether constructor has derived object. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  instanceConstructor + + +function + + + + Constructor.
                                  instance + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isArray(value) → {boolean} + + +
                                  + object/is.js, + line 147 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Checks if value is an array (same as `Array.isArray`). +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  value + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isBoolean(value) → {Boolean} + + +
                                  + object/is.js, + line 163 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Checks if value is a boolean. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  value + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isCallable(x) → {Boolean} + + +
                                  + object/is.js, + line 138 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Returns a boolean depicting whether a value is callable or not. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  x + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isClass(x) → {boolean} + + +
                                  + object/is.js, + line 130 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Checks if `value` is an es2015 `class`. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  x + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isEmpty(value) → {Boolean} + + +
                                  + object/is.js, + line 282 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Checks to see if passed in value is empty; I.e., check for one of '', 0, `null`, `undefined`, `false`, empty array, empty object, empty function (zero arity), or empty collection (es6 Map, Set, WeakMap, or WeakSet etc. (`!value.size`); +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  value + + +* + + + + Value to check.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isEmptyCollection(x) → {Boolean} + + +
                                  + object/is.js, + line 274 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Checks if collection is empty or not (Map, WeakMap, WeakSet, Set etc.). +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  x + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isEmptyList(x) → {Boolean} + + +
                                  + object/is.js, + line 258 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Checks if !length. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  x + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isEmptyObject(obj) → {Boolean} + + +
                                  + object/is.js, + line 266 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Checks if object has own properties/enumerable-props or not. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  obj + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isFunction(value) → {Boolean} + + +
                                  + object/is.js, + line 75 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Returns whether a value is a function or not. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  value + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isMap(value) → {Boolean} + + +
                                  + object/is.js, + line 187 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Checks whether value is of `Map` or not. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  value + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isNull(value) → {Boolean} + + +
                                  + object/is.js, + line 227 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Checks if value is null. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  value + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isNumber(value) → {Boolean} + + +
                                  + object/is.js, + line 171 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Checks if value is a valid number (also checks if isNaN so that you don't have to). +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  value + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isObject(value) → {Boolean} + + +
                                  + object/is.js, + line 155 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Checks whether value is an object or not. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  value + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isOfType(type, x) → {Boolean} + + +
                                  + object/is.js, + line 102 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Loose type checker; E.g., If `type` is not a constructor, but a constructor name, does a type check on constructor names, else if first check fails and `type` is a constructor, performs an `instanceof` check on value with constructor. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  type + + +function +| + +String + + + + Type reference (constructor or `constructor.name`).
                                  x + + +* + + + + Value to check.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + +
                                  Example
                                  + + 
                                  isOfType(Number, 99) === true        // true  (passes strict type check (numbers are not instances of `Number`
                                     //        constructor)
isOfType('Number', 99) === true      // true  (passes strict type check)
isOfType(Number, NaN) === true       // true. (passes instance of check)
                                     //        If you want "true" strict type checking use `isType`
isOfType(Object, []) === true        // true  (passes instance of check)
isOfType(Array, []) === true         // true  (passes instance of check)
isOfType(Object, {}) === true        // true  (passes instance of check)
isOfType(Object.name, {}) === true   // true  (Passes strict type check)
class Abc extends String {}
isOfType(String, new Abc('abcd')) // true (passes instanceof check)
                                  + + + +
                                  + + + + +
                                  + +

                                  + + static isSet(value) → {Boolean} + + +
                                  + object/is.js, + line 195 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Checks whether value is of `Set` or not. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  value + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isset(x) → {Boolean} + + +
                                  + object/is.js, + line 314 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Returns whether passed in values is defined and not null or not. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  x + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isString(value) → {Boolean} + + +
                                  + object/is.js, + line 179 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Checks whether value is a string or not. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  value + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isSymbol(value) → {Boolean} + + +
                                  + object/is.js, + line 235 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Checks if value is a `Symbol`. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  value + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isType(type, obj) → {Boolean} + + +
                                  + object/is.js, + line 83 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Strict type checker. Checks if given value is a direct instance of given type; E.g., +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  type + + +function +| + +ObjectConstructor +| + +String + + + + Constructor or constructor name
                                  obj + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + +
                                  Example
                                  + + 
                                  isType(String, 'abcdefg')  === true // true
  isType(String.name, 'abcdefg') === true
  isType(Number, NaN) === false
  isType(Number, 99) === true
  isType('Null', 99) === false // though, for `null` and `undefined` checks
                               // @see `isset`, in this module, instead
  isType('Undefined', undefined) === true // true
                                  + + + +
                                  + + + + +
                                  + +

                                  + + static isUndefined(value) → {Boolean} + + +
                                  + object/is.js, + line 219 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Checks if value is undefined. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  value + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isUsableImmutablePrimitive(x) → {Boolean} + + +
                                  + object/is.js, + line 243 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Checks if given `x` is set and of one of [String, Boolean, Number, Symbol] (null and undefined are immutable but are not "usable" (usually not what we want to operate on). +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  x + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isWeakMap(value) → {Boolean} + + +
                                  + object/is.js, + line 203 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Checks whether value is of `WeakMap` or not. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  value + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static isWeakSet(value) → {Boolean} + + +
                                  + object/is.js, + line 211 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Checks whether value is of `WeakSet` or not. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  value + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Boolean + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static jsonClone(x) → {*} + + +
                                  + object/jsonClone.js, + line 3 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Clones and object or array using `JSON.parse(JSON.stringify(...))` pattern. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  x + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +* + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static keys(obj) → {Array.<String>} + + +
                                  + jsPlatform/object.js, + line 76 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Gets passed in object's own enumerable keys (same as `Object.keys`). +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  obj + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Array.<String> + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static length(x) → {Number} + + +
                                  + jsPlatform/object.js, + line 32 +
                                  + +

                                  + + + +
                                  +
                                  + + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  x + + +* + + + +
                                  + +
                                  + + + + + + + + + + + +
                                  Throws:
                                  + + + +
                                  +
                                  +
                                  + - Throws an error if value doesn't have a `length` property ( `null`, `undefined`, {Boolean}, Symbol, et. al.). +
                                  +
                                  +
                                  +
                                  +
                                  +
                                  + Type +
                                  +
                                  + +Error + + +
                                  +
                                  +
                                  +
                                  +
                                  + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Number + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static lookup(key, obj) → {*} + + +
                                  + object/lookup.js, + line 8 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Looks up property and returns it's value; Else `undefined`. Method is null safe (will not throw on `null` or `undefined`). +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  key + + +String + + + + Key to search on `obj`
                                  obj + + +Object + + + + Object to search `name` on.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +* + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static of(x, …argsopt) → {*|undefined} + + +
                                  + object/of.js, + line 4 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Creates a value `of` given type; Checks for one of the following construction strategies (in order listed): +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDescription
                                  x + + +* + + + + + + + + + + Value to derive returned value's type from.
                                  args + + +* + + + + + + <optional>
                                  + + + + + + <repeatable>
                                  + +                                   		Any args to pass in to matched construction strategy.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +* +| + +undefined + + + + + +- - New value of given value's type else `undefined`. + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + +
                                  Example
                                  + + 
                                  // - If exists `(value).constructor.of` uses this.
// - If value is of one String, Boolean, Symbol, or Number types calls it's
//      constructor as a function (in cast form;  E.g., `constructor(...args)` )
// - Else if constructor is a function, thus far, then calls constructor using
//      the `new` keyword (with any passed in args).
                                  + + + +
                                  + + + + +
                                  + +

                                  + + static searchObj(nsString, obj) → {*} + + +
                                  + object/searchObj.js, + line 6 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Gives you value at key/namespace-key within `obj`; E.g., searchObj('all.your.base', {all: {your: {base: 99}}}) === 99 // `true` +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  nsString + + +String + + + +
                                  obj + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +* + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + +
                                  Example
                                  + + 
                                  ```
if (obj && obj.all && obj.all.your && obj.all.your.base) {
  // Thing we want to do
}

// So with our function becomes
if (searchObj('all.your.base', obj)) {
  // Thing we want to do
}
```
                                  + + + +
                                  + + + + +
                                  + +

                                  + + static toArray(x) → {Array} + + +
                                  + object/toArray.js, + line 6 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Converts incoming value to an array. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  x + + +* + + + + Thing to convert from.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Array + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static toAssocList(obj) → {Array.<*, *>} + + +
                                  + object/assocList.js, + line 6 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Returns an associated list from given object. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  obj + + +Object +| + +Array +| + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Array.<*, *> + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static toAssocListDeep(obj, TypeConstraintopt) → {*} + + +
                                  + object/assocList.js, + line 15 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Returns an associated list from given object (deeply (on incoming object's type)). +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDefaultDescription
                                  obj + + +* + + + + + + + + + + + +
                                  TypeConstraint + + +Constructor +| + +function + + + + + + <optional>
                                  + + + + + +                                   		+ + Object + + Type constraint to convert on.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +* + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static toEnumerableDescriptor() → {TargetDescriptorTuple} + + +
                                  + object/defineProp.js, + line 50 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Returns a target-descriptor tuple whose 'descriptor' will be set to enumerable (`enumerable: true`). +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  TypeDescription
                                  + + +TargetDescriptorTuple + + + + [target, descriptor] tuple.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +TargetDescriptorTuple + + + + + +- - Array of target and descriptor. + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static toTargetDescriptorTuple(targetOrTargetDescriptorTuple) → {Array.<*>|Array.<*, *>} + + +
                                  + object/defineProp.js, + line 62 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Returns an target and descriptor tuple from given. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  targetOrTargetDescriptorTuple + + +* +| + +Array.<*, *> + + + + Target object or tuple of target and descriptor.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Array.<*> +| + +Array.<*, *> + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static toTypeRef(type) → {String} + + +
                                  + object/is.js, + line 27 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Resolves/normalizes a type name from either a string or a constructor. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  type + + +function +| + +String + + + + String or function representing a type.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +String + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  To Do:
                                  +
                                  +
                                    +
                                  • write tests for this function.
                                    • +
                                  +
                                  + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static toTypeRefName(Type) → {String} + + +
                                  + object/is.js, + line 54 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Returns possible Type's TypeRef name. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  Type + + +TypeRef +| + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +String + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  To Do:
                                  +
                                  +
                                    +
                                  • Ensure tests are written for this function.
                                    • +
                                  +
                                  + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static toTypeRefNames(…types) → {Array.<String>} + + +
                                  + object/is.js, + line 66 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Returns possible Types' TypeRef names. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDescription
                                  types + + +TypeRef +| + +* + + + + + + + + + + <repeatable>
                                  + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Array.<String> + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  To Do:
                                  +
                                  +
                                    +
                                  • Ensure tests are written for this function.
                                    • +
                                  +
                                  + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static toTypeRefs(…types) → {Array.<TypeRef>} + + +
                                  + object/is.js, + line 44 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Returns an array of type refs from possible type refs (converts null, undefined, NaN, and other values into type refs (either constructor name or constructor name based on whether value(s) is a string, a constructor, or not). +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDescription
                                  types + + +TypeRef +| + +* + + + + + + + + + + <repeatable>
                                  + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Array.<TypeRef> + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  To Do:
                                  +
                                  +
                                    +
                                  • Ensure tests are written for this function.
                                    • +
                                  +
                                  + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static typeOf(value) → {string} + + +
                                  + object/typeOf.js, + line 10 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Returns the constructor/class/type name of a value. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  value + + +* + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +string + + + + + +- - Constructor's name or derived name (in the case of `null`, `undefined`, or `NaN` (whose normalized names are 'Null', 'Undefined', 'NaN' respectively). + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + +
                                  + + + + + +
                                  + +
                                  + + + + + + + +
                                  + +
                                  + +

                                  object

                                  + + + + +
                                  + +
                                  + +
                                  + + + + + + +
                                  + +
                                  +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + +
                                  + + + + + + + + + + + + + + + +

                                  Members

                                  + +
                                  + + +
                                  +

                                  + static, constant native :Object + +
                                  + jsPlatform/object.js, + line 51 +
                                  + +

                                  + + +
                                  +
                                  + +
                                  + Contains all the static functions from `Object` but curried and flipped; +
                                  + + + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + + +
                                  Example
                                  + + 
                                  // E.g., `Object.defineProperties(obj, descriptor)` can now be used like
import {defineProperties} from 'fjl'
defineProperties(descriptor, someObj),
// Et. al.
                                  + + +
                                  + +
                                  + + + +

                                  Methods

                                  + +
                                  + + +
                                  + +

                                  + + static assign(obj0, …objs) → {Object} + + +
                                  + jsPlatform/object.js, + line 84 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Defined as `Object.assign` else is the same thing but shimmed. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDescription
                                  obj0 + + +Object + + + + + + + + + +
                                  objs + + +Object + + + + + + + + + + <repeatable>
                                  + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Object + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static assignDeep(obj0, …objsopt) → {Object} + + +
                                  + object/assignDeep.js, + line 7 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Merges all objects down into one (takes two or more args). +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDescription
                                  obj0 + + +Object + + + + + + + + + +
                                  objs + + +Object + + + + + + <optional>
                                  + + + + + + <repeatable>
                                  + +                                   		One or more objects to merge onto `obj0`.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Object + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static copy(x, outopt) → {*} + + +
                                  + object/copy.js, + line 6 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Make a copy of a value or optionally copy incoming value onto an outgoing value (second parameter). +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDescription
                                  x + + +* + + + + + + + + + + Thing to copy.
                                  out + + +* + + + + + + <optional>
                                  + + + + + +                                   		Optional value to copy on to. Not required.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +* + + + + + +- - Copied thing or optionally outgoing value copied onto. + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static createTypedDescriptor(Type, target, propName) → {Descriptor} + + +
                                  + object/defineProp.js, + line 29 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Creates a descriptor for a property which is settable but throws errors when the `Type` is disobeyed. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeDescription
                                  Type + + +TypeRef + + + + {String|Function}
                                  target + + +* + + + +
                                  propName + + +String + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Descriptor + + + + + +- - Property descriptor with just getter and setter. + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static defineEnumProp(Type, target, propName, defaultValueopt) → {TargetDescriptorTuple} + + +
                                  + object/defineProp.js, + line 91 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Allows you to define a "typed", enumerated property on `target`. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDescription
                                  Type + + +TypeRef + + + + + + + + + + {String|Function}
                                  target + + +TargetDescriptorTuple + + + + + + + + + + Target or array of target and descriptor ([target, descriptor]).
                                  propName + + +String + + + + + + + + + +
                                  defaultValue + + +* + + + + + + <optional>
                                  + + + + + +
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +TargetDescriptorTuple + + + + + + + + + +
                                  + + + + + +
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static defineEnumProps(argsTuple, targetopt) → {Array.<TargetDescriptorTuple>} + + +
                                  + object/defineProp.js, + line 111 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Allows you to define multiple enum props at once on target. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  NameTypeAttributesDescription
                                  argsTuple + + +Array.<DefinePropArgsTuple> + + + + + + + + + + Array of argArrays for `defineEnumProp`.
                                  target + + +Target + + + + + + <optional>
                                  + + + + + +                                   		Target to use in internal calls if one is not provided but encountered 'argArray'.
                                  + +
                                  + + + + + + + + + + + + + +
                                  +
                                  Returns:
                                  + + + + + +Array.<TargetDescriptorTuple> + + + + + +- - Results of each call to `defineEnumProp`. + + + + + +
                                  + + +
                                  - + + + + + + + + + + + + + + + + + + + + + + + + + + + +
                                  + + + + +
                                  + + + + +
                                  + +

                                  + + static defineProp(Type, target, propName, defaultValueopt) → {TargetDescriptorTuple} + + +
                                  + object/defineProp.js, + line 72 +
                                  + +

                                  + + + +
                                  +
                                  + + +
                                  + Allows you to define a "typed" property on given `target`. +
                                  + + + + + + + + + +
                                  +
                                  Parameters:
                                  + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + + + - + - + + + +
                                  NameTypeAttributesDescription
                                  Type + + +TypeRef + + + + + + + + + + {String|Function}
                                  target + + +TargetDescriptorTuple + + + + + + + + + + Target or array of target and descriptor ([target, descriptor]).
                                  propName + + +String + + + + + + + + + +
                                  defaultValue + + +* + - + + + + <optional>
                                  + - + - + +
                                  +
                                  @@ -7911,70 +20207,28 @@

                                  object

                                  -
                                  - - - - - +
                                  +
                                  Returns:
                                  -
                                  - + - - - +TargetDescriptorTuple - - - - -

                                  Members

                                  -
                                  - -
                                  -

                                  - static, constant native :Object - -
                                  - jsPlatform/object.js, - line 51 -
                                  - -

                                  -
                                  -
                                  - -
                                  - Contains all the static functions from `Object` but curried and flipped; +
                                  - - @@ -8014,33 +20268,21 @@
                                  Type:
                                  - -
                                  Example
                                  - - 
                                  // E.g., `Object.defineProperties(obj, descriptor)` can now be used like
import {defineProperties} from 'fjl'
defineProperties(descriptor, someObj),
// Et. al.
                                  - -
                                  -
                                  - - - -

                                  Methods

                                  - -
                                  +
                                  -

                                  +

                                  - static assign(obj0, …objs) → {Object} + static defineProps(argsTuple, targetopt) → {Array.<TargetDescriptorTuple>}
                                  - jsPlatform/object.js, - line 84 + object/defineProp.js, + line 120

                                  @@ -8052,7 +20294,7 @@

                                  - Defined as `Object.assign` else is the same thing but shimmed. + Allows you to define multiple props at once on target.
                                  @@ -8090,13 +20332,13 @@

                                  Parameters:
                                  - obj0 + argsTuple -Object +Array.<DefinePropArgsTuple> @@ -8114,20 +20356,20 @@
                                  Parameters:
                                  - + Array of argArrays for `defineProp`. - objs + target -Object +Target @@ -8136,18 +20378,18 @@
                                  Parameters:
                                  - + <optional>
                                  - <repeatable>
                                  + - + Target to use in internal calls if one is not provided but encountered 'argArray'. @@ -8175,12 +20417,14 @@
                                  Returns:
                                  -Object +Array.<TargetDescriptorTuple> +- - Results of each call to `defineProp`. + @@ -8234,14 +20478,14 @@
                                  Returns:
                                  -

                                  +

                                  - static assignDeep(obj0, …objsopt) → {Object} + static fromAssocList(xs, OutTypeopt) → {*}
                                  - object/assignDeep.js, - line 7 + object/assocList.js, + line 29

                                  @@ -8253,7 +20497,7 @@

                                  - Merges all objects down into one (takes two or more args). + From associated list to object.
                                  @@ -8281,6 +20525,8 @@

                                  Parameters:
                                  + Default + Description @@ -8291,13 +20537,13 @@
                                  Parameters:
                                  - obj0 + xs -Object +Array.<Array> @@ -8314,21 +20560,28 @@
                                  Parameters:
                                  + + + + - + Associated list. - objs + OutType -Object +Constructor +| + +function @@ -8343,14 +20596,18 @@
                                  Parameters:
                                  - <repeatable>
                                  - + + + Object + + + - One or more objects to merge onto `obj0`. + Output type. Default `Object`. @@ -8378,12 +20635,14 @@
                                  Returns:
                                  -Object +* +- - Default is `Object` + @@ -8437,14 +20696,14 @@
                                  Returns:
                                  -

                                  +

                                  - static copy(x, outopt) → {*} + static fromAssocListDeep(xs, OutTypeopt) → {*}
                                  - object/copy.js, - line 6 + object/assocList.js, + line 41

                                  @@ -8456,7 +20715,7 @@

                                  - Make a copy of a value or optionally copy incoming value onto an outgoing value (second parameter). + From associated list to object (deep conversion on associative lists (array of 2 value arrays)).
                                  @@ -8484,6 +20743,8 @@

                                  Parameters:
                                  + Default + Description @@ -8494,13 +20755,13 @@
                                  Parameters:
                                  - x + xs -* +Array.<Array> @@ -8517,21 +20778,28 @@
                                  Parameters:
                                  + + + + - Thing to copy. + Associated list. - out + OutType -* +Constructor +| + +function @@ -8550,8 +20818,14 @@
                                  Parameters:
                                  + + + Object + + + - Optional value to copy on to. Not required. + Output type. Default `Object`. @@ -8585,7 +20859,7 @@
                                  Returns:
                                  -- - Copied thing or optionally outgoing value copied onto. +- - Default is `Object` @@ -8640,14 +20914,14 @@
                                  Returns:
                                  -

                                  +

                                  - static fromAssocList(xs, OutTypeopt) → {*} + static hasOwnProperty(propName, typeInstance) → {Boolean}
                                  - object/assocList.js, - line 29 + jsPlatform/object.js, + line 23

                                  @@ -8658,10 +20932,6 @@

                                  -
                                  - From associated list to object. -
                                  - @@ -8683,12 +20953,8 @@
                                  Parameters:
                                  Type - Attributes - - Default - Description @@ -8699,77 +20965,46 @@
                                  Parameters:
                                  - xs + propName -Array.<Array> +* - - - - - - - - - - - - - Associated list. + - OutType + typeInstance -Constructor -| - -function +* - - - <optional>
                                  - - - - - - - - - - Object - - - - Output type. Default `Object`. + @@ -8797,13 +21032,11 @@
                                  Returns:
                                  -* - +Boolean -- - Default is `Object` @@ -8832,6 +21065,8 @@
                                  Returns:
                                  +
                                  Deprecated:
                                  • - Use property directly instead.
                                  + @@ -8858,14 +21093,14 @@

                                  Returns:
                                  -

                                  +

                                  - static fromAssocListDeep(xs, OutTypeopt) → {*} + static instanceOf(instanceConstructor, instance) → {Boolean}
                                  - object/assocList.js, - line 41 + jsPlatform/object.js, + line 12

                                  @@ -8877,7 +21112,7 @@

                                  - From associated list to object (deep conversion on associative lists (array of 2 value arrays)). + Returns whether constructor has derived object.
                                  @@ -8901,12 +21136,8 @@

                                  Parameters:
                                  Type - Attributes - - Default - Description @@ -8917,77 +21148,46 @@
                                  Parameters:
                                  - xs + instanceConstructor -Array.<Array> +function - - - - - - - - - - - - - Associated list. + Constructor. - OutType + instance -Constructor -| - -function +* - - - <optional>
                                  - - - - - - - - - - Object - - - - Output type. Default `Object`. + @@ -9015,13 +21215,11 @@
                                  Returns:
                                  -* - +Boolean -- - Default is `Object` @@ -9076,14 +21274,14 @@
                                  Returns:
                                  -

                                  +

                                  - static hasOwnProperty(propName, typeInstance) → {Boolean} + static isArray(value) → {boolean}
                                  - jsPlatform/object.js, - line 23 + object/is.js, + line 147

                                  @@ -9094,6 +21292,10 @@

                                  +
                                  + Checks if value is an array (same as `Array.isArray`). +
                                  + @@ -9127,30 +21329,7 @@
                                  Parameters:
                                  - propName - - - - - -* - - - - - - - - - - - - - - - - - typeInstance + value @@ -9194,7 +21373,7 @@
                                  Returns:
                                  -Boolean +boolean @@ -9227,8 +21406,6 @@
                                  Returns:
                                  -
                                  Deprecated:
                                  • - Use property directly instead.
                                  - @@ -9255,14 +21432,14 @@

                                  Returns:
                                  -

                                  +

                                  - static instanceOf(instanceConstructor, instance) → {Boolean} + static isBoolean(value) → {Boolean}
                                  - jsPlatform/object.js, - line 12 + object/is.js, + line 163

                                  @@ -9274,7 +21451,7 @@

                                  - Returns whether constructor has derived object. + Checks if value is a boolean.
                                  @@ -9310,30 +21487,7 @@

                                  Parameters:
                                  - instanceConstructor - - - - - -function - - - - - - - - - - Constructor. - - - - - - - instance + value @@ -9436,14 +21590,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isArray(value) → {boolean} + static isCallable(x) → {Boolean}
                                  object/is.js, - line 147 + line 138

                                  @@ -9455,7 +21609,7 @@

                                  - Checks if value is an array (same as `Array.isArray`). + Returns a boolean depicting whether a value is callable or not.
                                  @@ -9491,7 +21645,7 @@

                                  Parameters:
                                  - value + x @@ -9535,7 +21689,7 @@
                                  Returns:
                                  -boolean +Boolean @@ -9594,14 +21748,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isBoolean(value) → {Boolean} + static isClass(x) → {boolean}
                                  object/is.js, - line 163 + line 130

                                  @@ -9613,7 +21767,7 @@

                                  - Checks if value is a boolean. + Checks if `value` is an es2015 `class`.
                                  @@ -9649,7 +21803,7 @@

                                  Parameters:
                                  - value + x @@ -9693,7 +21847,7 @@
                                  Returns:
                                  -Boolean +boolean @@ -9752,14 +21906,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isCallable(x) → {Boolean} + static isEmpty(value) → {Boolean}
                                  object/is.js, - line 138 + line 282

                                  @@ -9771,7 +21925,7 @@

                                  - Returns a boolean depicting whether a value is callable or not. + Checks to see if passed in value is empty; I.e., check for one of '', 0, `null`, `undefined`, `false`, empty array, empty object, empty function (zero arity), or empty collection (es6 Map, Set, WeakMap, or WeakSet etc. (`!value.size`);
                                  @@ -9807,7 +21961,7 @@

                                  Parameters:
                                  - x + value @@ -9823,7 +21977,7 @@
                                  Parameters:
                                  - + Value to check. @@ -9910,14 +22064,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isClass(x) → {boolean} + static isEmptyCollection(x) → {Boolean}
                                  object/is.js, - line 130 + line 274

                                  @@ -9929,7 +22083,7 @@

                                  - Checks if `value` is an es2015 `class`. + Checks if collection is empty or not (Map, WeakMap, WeakSet, Set etc.).
                                  @@ -10009,7 +22163,7 @@

                                  Returns:
                                  -boolean +Boolean @@ -10068,14 +22222,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isEmpty(value) → {Boolean} + static isEmptyList(x) → {Boolean}
                                  object/is.js, - line 282 + line 258

                                  @@ -10087,7 +22241,7 @@

                                  - Checks to see if passed in value is empty; I.e., check for one of '', 0, `null`, `undefined`, `false`, empty array, empty object, empty function (zero arity), or empty collection (es6 Map, Set, WeakMap, or WeakSet etc. (`!value.size`); + Checks if !length.
                                  @@ -10123,7 +22277,7 @@

                                  Parameters:
                                  - value + x @@ -10139,7 +22293,7 @@
                                  Parameters:
                                  - Value to check. + @@ -10226,14 +22380,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isEmptyCollection(x) → {Boolean} + static isEmptyObject(obj) → {Boolean}
                                  object/is.js, - line 274 + line 266

                                  @@ -10245,7 +22399,7 @@

                                  - Checks if collection is empty or not (Map, WeakMap, WeakSet, Set etc.). + Checks if object has own properties/enumerable-props or not.
                                  @@ -10281,7 +22435,7 @@

                                  Parameters:
                                  - x + obj @@ -10384,14 +22538,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isEmptyList(x) → {Boolean} + static isFunction(value) → {Boolean}
                                  object/is.js, - line 258 + line 75

                                  @@ -10403,7 +22557,7 @@

                                  - Checks if !length. + Returns whether a value is a function or not.
                                  @@ -10439,7 +22593,7 @@

                                  Parameters:
                                  - x + value @@ -10542,14 +22696,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isEmptyObject(obj) → {Boolean} + static isMap(value) → {Boolean}
                                  object/is.js, - line 266 + line 187

                                  @@ -10561,7 +22715,7 @@

                                  - Checks if object has own properties/enumerable-props or not. + Checks whether value is of `Map` or not.
                                  @@ -10597,7 +22751,7 @@

                                  Parameters:
                                  - obj + value @@ -10700,14 +22854,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isFunction(value) → {Boolean} + static isNull(value) → {Boolean}
                                  object/is.js, - line 75 + line 227

                                  @@ -10719,7 +22873,7 @@

                                  - Returns whether a value is a function or not. + Checks if value is null.
                                  @@ -10858,14 +23012,14 @@

                                  Returns:
                                  -

                                  +

                                  - static isMap(value) → {Boolean} + static isNumber(value) → {Boolean}
                                  object/is.js, - line 187 + line 171

                                  @@ -10877,7 +23031,7 @@

                                  - Checks whether value is of `Map` or not. + Checks if value is a valid number (also checks if isNaN so that you don't have to).
                                  @@ -11016,14 +23170,14 @@

                                  Returns:
                                  -

                                  +

                                  - static isNull(value) → {Boolean} + static isObject(value) → {Boolean}
                                  object/is.js, - line 227 + line 155

                                  @@ -11035,7 +23189,7 @@

                                  - Checks if value is null. + Checks whether value is an object or not.
                                  @@ -11076,11 +23230,6 @@

                                  Parameters:
                                  - -* - - - @@ -11174,14 +23323,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isNumber(value) → {Boolean} + static isOfType(type, x) → {Boolean}
                                  object/is.js, - line 171 + line 102

                                  @@ -11193,7 +23342,7 @@

                                  - Checks if value is a valid number (also checks if isNaN so that you don't have to). + Loose type checker; E.g., If `type` is not a constructor, but a constructor name, does a type check on constructor names, else if first check fails and `type` is a constructor, performs an `instanceof` check on value with constructor.
                                  @@ -11229,7 +23378,33 @@

                                  Parameters:
                                  - value + type + + + + + +function +| + +String + + + + + + + + + + Type reference (constructor or `constructor.name`). + + + + + + + x @@ -11245,7 +23420,7 @@
                                  Parameters:
                                  - + Value to check. @@ -11324,6 +23499,11 @@
                                  Returns:
                                  +
                                  Example
                                  + + 
                                  isOfType(Number, 99) === true        // true  (passes strict type check (numbers are not instances of `Number`
                                     //        constructor)
isOfType('Number', 99) === true      // true  (passes strict type check)
isOfType(Number, NaN) === true       // true. (passes instance of check)
                                     //        If you want "true" strict type checking use `isType`
isOfType(Object, []) === true        // true  (passes instance of check)
isOfType(Array, []) === true         // true  (passes instance of check)
isOfType(Object, {}) === true        // true  (passes instance of check)
isOfType(Object.name, {}) === true   // true  (Passes strict type check)
class Abc extends String {}
isOfType(String, new Abc('abcd')) // true (passes instanceof check)
                                  + + @@ -11332,14 +23512,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isObject(value) → {Boolean} + static isSet(value) → {Boolean}
                                  object/is.js, - line 155 + line 195

                                  @@ -11351,7 +23531,7 @@

                                  - Checks whether value is an object or not. + Checks whether value is of `Set` or not.
                                  @@ -11392,6 +23572,11 @@

                                  Parameters:
                                  + +* + + + @@ -11485,14 +23670,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isOfType(type, x) → {Boolean} + static isset(x) → {Boolean}
                                  object/is.js, - line 102 + line 314

                                  @@ -11504,7 +23689,7 @@

                                  - Loose type checker; E.g., If `type` is not a constructor, but a constructor name, does a type check on constructor names, else if first check fails and `type` is a constructor, performs an `instanceof` check on value with constructor. + Returns whether passed in values is defined and not null or not.
                                  @@ -11538,32 +23723,6 @@

                                  Parameters:
                                  - - - type - - - - - -function -| - -String - - - - - - - - - - Type reference (constructor or `constructor.name`). - - - - x @@ -11582,7 +23741,7 @@
                                  Parameters:
                                  - Value to check. + @@ -11661,11 +23820,6 @@
                                  Returns:
                                  -
                                  Example
                                  - - 
                                  isOfType(Number, 99) === true        // true  (passes strict type check (numbers are not instances of `Number`
                                     //        constructor)
isOfType('Number', 99) === true      // true  (passes strict type check)
isOfType(Number, NaN) === true       // true. (passes instance of check)
                                     //        If you want "true" strict type checking use `isType`
isOfType(Object, []) === true        // true  (passes instance of check)
isOfType(Array, []) === true         // true  (passes instance of check)
isOfType(Object, {}) === true        // true  (passes instance of check)
isOfType(Object.name, {}) === true   // true  (Passes strict type check)
class Abc extends String {}
isOfType(String, new Abc('abcd')) // true (passes instanceof check)
                                  - - @@ -11674,14 +23828,14 @@
                                  Example
                                  -

                                  +

                                  - static isset(x) → {Boolean} + static isString(value) → {Boolean}
                                  object/is.js, - line 314 + line 179

                                  @@ -11693,7 +23847,7 @@

                                  - Returns whether passed in values is defined and not null or not. + Checks whether value is a string or not.
                                  @@ -11729,7 +23883,7 @@

                                  Parameters:
                                  - x + value @@ -11832,14 +23986,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isSet(value) → {Boolean} + static isSymbol(value) → {Boolean}
                                  object/is.js, - line 195 + line 235

                                  @@ -11851,7 +24005,7 @@

                                  - Checks whether value is of `Set` or not. + Checks if value is a `Symbol`.
                                  @@ -11990,14 +24144,14 @@

                                  Returns:
                                  -

                                  +

                                  - static isString(value) → {Boolean} + static isType(type, obj) → {Boolean}
                                  object/is.js, - line 179 + line 83

                                  @@ -12009,7 +24163,7 @@

                                  - Checks whether value is a string or not. + Strict type checker. Checks if given value is a direct instance of given type; E.g.,
                                  @@ -12045,7 +24199,36 @@

                                  Parameters:
                                  - value + type + + + + + +function +| + +ObjectConstructor +| + +String + + + + + + + + + + Constructor or constructor name + + + + + + + obj @@ -12140,6 +24323,11 @@
                                  Returns:
                                  +
                                  Example
                                  + + 
                                  isType(String, 'abcdefg')  === true // true
  isType(String.name, 'abcdefg') === true
  isType(Number, NaN) === false
  isType(Number, 99) === true
  isType('Null', 99) === false // though, for `null` and `undefined` checks
                               // @see `isset`, in this module, instead
  isType('Undefined', undefined) === true // true
                                  + + @@ -12148,14 +24336,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isSymbol(value) → {Boolean} + static isUndefined(value) → {Boolean}
                                  object/is.js, - line 235 + line 219

                                  @@ -12167,7 +24355,7 @@

                                  - Checks if value is a `Symbol`. + Checks if value is undefined.
                                  @@ -12306,14 +24494,14 @@

                                  Returns:
                                  -

                                  +

                                  - static isType(type, obj) → {Boolean} + static isUsableImmutablePrimitive(x) → {Boolean}
                                  object/is.js, - line 83 + line 243

                                  @@ -12325,7 +24513,7 @@

                                  - Strict type checker. Checks if given value is a direct instance of given type; E.g., + Checks if given `x` is set and of one of [String, Boolean, Number, Symbol] (null and undefined are immutable but are not "usable" (usually not what we want to operate on).
                                  @@ -12361,36 +24549,7 @@

                                  Parameters:
                                  - type - - - - - -function -| - -ObjectConstructor -| - -String - - - - - - - - - - Constructor or constructor name - - - - - - - obj + x @@ -12485,11 +24644,6 @@
                                  Returns:
                                  -
                                  Example
                                  - - 
                                  isType(String, 'abcdefg')  === true // true
  isType(String.name, 'abcdefg') === true
  isType(Number, NaN) === false
  isType(Number, 99) === true
  isType('Null', 99) === false // though, for `null` and `undefined` checks
                               // @see `isset`, in this module, instead
  isType('Undefined', undefined) === true // true
                                  - - @@ -12498,14 +24652,14 @@
                                  Example
                                  -

                                  +

                                  - static isUndefined(value) → {Boolean} + static isWeakMap(value) → {Boolean}
                                  object/is.js, - line 219 + line 203

                                  @@ -12517,7 +24671,7 @@

                                  - Checks if value is undefined. + Checks whether value is of `WeakMap` or not.
                                  @@ -12656,14 +24810,14 @@

                                  Returns:
                                  -

                                  +

                                  - static isUsableImmutablePrimitive(x) → {Boolean} + static isWeakSet(value) → {Boolean}
                                  object/is.js, - line 243 + line 211

                                  @@ -12675,7 +24829,7 @@

                                  - Checks if given `x` is set and of one of [String, Boolean, Number, Symbol] (null and undefined are immutable but are not "usable" (usually not what we want to operate on). + Checks whether value is of `WeakSet` or not.
                                  @@ -12711,7 +24865,7 @@

                                  Parameters:
                                  - x + value @@ -12814,14 +24968,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isWeakMap(value) → {Boolean} + static jsonClone(x) → {*}
                                  - object/is.js, - line 203 + object/jsonClone.js, + line 3

                                  @@ -12833,7 +24987,7 @@

                                  - Checks whether value is of `WeakMap` or not. + Clones and object or array using `JSON.parse(JSON.stringify(...))` pattern.
                                  @@ -12869,7 +25023,7 @@

                                  Parameters:
                                  - value + x @@ -12913,7 +25067,7 @@
                                  Returns:
                                  -Boolean +* @@ -12972,14 +25126,14 @@
                                  Returns:
                                  -

                                  +

                                  - static isWeakSet(value) → {Boolean} + static keys(obj) → {Array.<String>}
                                  - object/is.js, - line 211 + jsPlatform/object.js, + line 76

                                  @@ -12991,7 +25145,7 @@

                                  - Checks whether value is of `WeakSet` or not. + Gets passed in object's own enumerable keys (same as `Object.keys`).
                                  @@ -13027,7 +25181,7 @@

                                  Parameters:
                                  - value + obj @@ -13071,7 +25225,7 @@
                                  Returns:
                                  -Boolean +Array.<String> @@ -13130,14 +25284,14 @@
                                  Returns:
                                  -

                                  +

                                  - static jsonClone(x) → {*} + static length(x) → {Number}
                                  - object/jsonClone.js, - line 3 + jsPlatform/object.js, + line 32

                                  @@ -13148,10 +25302,6 @@

                                  -
                                  - Clones and object or array using `JSON.parse(JSON.stringify(...))` pattern. -
                                  - @@ -13220,6 +25370,35 @@
                                  Parameters:
                                  +
                                  Throws:
                                  + + + +
                                  +
                                  +
                                  + - Throws an error if value doesn't have a `length` property ( `null`, `undefined`, {Boolean}, Symbol, et. al.). +
                                  +
                                  +
                                  +
                                  +
                                  +
                                  + Type +
                                  +
                                  + +Error + + +
                                  +
                                  +
                                  +
                                  +
                                  + + +
                                  @@ -13229,7 +25408,7 @@
                                  Returns:
                                  -* +Number @@ -13288,14 +25467,14 @@
                                  Returns:
                                  -

                                  +

                                  - static keys(obj) → {Array.<String>} + static lookup(key, obj) → {*}
                                  - jsPlatform/object.js, - line 76 + object/lookup.js, + line 8

                                  @@ -13307,7 +25486,7 @@

                                  - Gets passed in object's own enumerable keys (same as `Object.keys`). + Looks up property and returns it's value; Else `undefined`. Method is null safe (will not throw on `null` or `undefined`).
                                  @@ -13341,6 +25520,29 @@

                                  Parameters:
                                  + + + key + + + + + +String + + + + + + + + + + Key to search on `obj` + + + + obj @@ -13349,7 +25551,7 @@
                                  Parameters:
                                  -* +Object @@ -13359,7 +25561,7 @@
                                  Parameters:
                                  - + Object to search `name` on. @@ -13387,7 +25589,7 @@
                                  Returns:
                                  -Array.<String> +* @@ -13446,14 +25648,14 @@
                                  Returns:
                                  -

                                  +

                                  - static length(x) → {Number} + static of(x, …argsopt) → {*|undefined}
                                  - jsPlatform/object.js, - line 32 + object/of.js, + line 4

                                  @@ -13464,6 +25666,10 @@

                                  +
                                  + Creates a value `of` given type; Checks for one of the following construction strategies (in order listed): +
                                  + @@ -13485,6 +25691,8 @@
                                  Parameters:
                                  Type + Attributes + @@ -13510,10 +25718,53 @@
                                  Parameters:
                                  + + + + + + + + - + Value to derive returned value's type from. + + + + + + + args + + + + + +* + + + + + + + + + <optional>
                                  + + + + + + <repeatable>
                                  + + + + + + + Any args to pass in to matched construction strategy. @@ -13532,35 +25783,6 @@
                                  Parameters:
                                  -
                                  Throws:
                                  - - - -
                                  -
                                  -
                                  - - Throws an error if value doesn't have a `length` property ( `null`, `undefined`, {Boolean}, Symbol, et. al.). -
                                  -
                                  -
                                  -
                                  -
                                  -
                                  - Type -
                                  -
                                  - -Error - - -
                                  -
                                  -
                                  -
                                  -
                                  - - -
                                  @@ -13570,12 +25792,17 @@
                                  Returns:
                                  -Number +* +| + +undefined +- - New value of given value's type else `undefined`. + @@ -13621,6 +25848,11 @@
                                  Returns:
                                  +
                                  Example
                                  + + 
                                  // - If exists `(value).constructor.of` uses this.
// - If value is of one String, Boolean, Symbol, or Number types calls it's
//      constructor as a function (in cast form;  E.g., `constructor(...args)` )
// - Else if constructor is a function, thus far, then calls constructor using
//      the `new` keyword (with any passed in args).
                                  + +
                                  @@ -13629,14 +25861,14 @@

                                  Returns:
                                  -

                                  +

                                  - static lookup(key, obj) → {*} + static searchObj(nsString, obj) → {*}
                                  - object/lookup.js, - line 8 + object/searchObj.js, + line 6

                                  @@ -13648,7 +25880,7 @@

                                  - Looks up property and returns it's value; Else `undefined`. Method is null safe (will not throw on `null` or `undefined`). + Gives you value at key/namespace-key within `obj`; E.g., searchObj('all.your.base', {all: {your: {base: 99}}}) === 99 // `true`
                                  @@ -13684,7 +25916,7 @@

                                  Parameters:
                                  - key + nsString @@ -13700,7 +25932,7 @@
                                  Parameters:
                                  - Key to search on `obj` + @@ -13713,7 +25945,7 @@
                                  Parameters:
                                  -Object +* @@ -13723,7 +25955,7 @@
                                  Parameters:
                                  - Object to search `name` on. + @@ -13802,6 +26034,11 @@
                                  Returns:
                                  +
                                  Example
                                  + + 
                                  ```
if (obj && obj.all && obj.all.your && obj.all.your.base) {
  // Thing we want to do
}

// So with our function becomes
if (searchObj('all.your.base', obj)) {
  // Thing we want to do
}
```
                                  + + @@ -13810,14 +26047,14 @@
                                  Returns:
                                  -

                                  +

                                  - static of(x, …argsopt) → {*|undefined} + static toArray(x) → {Array}
                                  - object/of.js, - line 4 + object/toArray.js, + line 6

                                  @@ -13829,7 +26066,7 @@

                                  - Creates a value `of` given type; Checks for one of the following construction strategies (in order listed): + Converts incoming value to an array.
                                  @@ -13840,65 +26077,32 @@

                                  -
                                  -
                                  Parameters:
                                  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
                                  NameTypeAttributesDescription
                                  x - - -* - - - - - +
                                  +
                                  Parameters:
                                  + + + + + + + - + - - - + - + - - + + + + - + - - - + @@ -13954,16 +26146,11 @@
                                  Returns:
                                  -* -| - -undefined - +Array -- - New value of given value's type else `undefined`. @@ -14010,11 +26197,6 @@
                                  Returns:
                                  -
                                  Example
                                  - - 
                                  // - If exists `(value).constructor.of` uses this.
// - If value is of one String, Boolean, Symbol, or Number types calls it's
//      constructor as a function (in cast form;  E.g., `constructor(...args)` )
// - Else if constructor is a function, thus far, then calls constructor using
//      the `new` keyword (with any passed in args).
                                  - - @@ -14023,14 +26205,14 @@
                                  Example
                                  -

                                  +

                                  - static searchObj(nsString, obj) → {*} + static toAssocList(obj) → {Array.<*, *>}
                                  - object/searchObj.js, - line 6 + object/assocList.js, + line 6

                                  @@ -14042,7 +26224,7 @@

                                  - Gives you value at key/namespace-key within `obj`; E.g., searchObj('all.your.base', {all: {your: {base: 99}}}) === 99 // `true` + Returns an associated list from given object.
                                  @@ -14078,35 +26260,18 @@

                                  Parameters:
                                  - + - - - - - - - - - +Object +| - - - - +Array +| - + + + + @@ -14264,7 +26428,7 @@
                                  Parameters:
                                  - + + + + + - + + + + + + + + + + + + + + + + + + + + + @@ -14308,7 +26526,7 @@
                                  Returns:
                                  -Array +* @@ -14367,14 +26585,14 @@
                                  Returns:
                                  -

                                  +

                                  - static toAssocList(obj) → {Array.<*, *>} + static toEnumerableDescriptor() → {TargetDescriptorTuple}
                                  - object/assocList.js, - line 6 + object/defineProp.js, + line 50

                                  @@ -14386,7 +26604,7 @@

                                  - Returns an associated list from given object. + Returns a target-descriptor tuple whose 'descriptor' will be set to enumerable (`enumerable: true`).
                                  @@ -14404,8 +26622,6 @@

                                  Parameters:
                                  - - @@ -14422,19 +26638,11 @@
                                  Parameters:
                                  - - + @@ -14472,11 +26680,13 @@
                                  Returns:
                                  -Array.<*, *> +TargetDescriptorTuple + +- - Array of target and descriptor. @@ -14531,14 +26741,14 @@
                                  Returns:
                                  -

                                  +

                                  - static toAssocListDeep(obj, TypeConstraintopt) → {*} + static toTargetDescriptorTuple(targetOrTargetDescriptorTuple) → {Array.<*>|Array.<*, *>}
                                  - object/assocList.js, - line 15 + object/defineProp.js, + line 62

                                  @@ -14550,7 +26760,7 @@

                                  - Returns an associated list from given object (deeply (on incoming object's type)). + Returns an target and descriptor tuple from given.
                                  @@ -14574,12 +26784,8 @@

                                  Parameters:
                                  - - - - @@ -14590,77 +26796,26 @@
                                  Parameters:
                                  - + - - - - - - - - - - - - - - - - - - - - - - - - - + @@ -14688,7 +26843,10 @@
                                  Returns:
                                  -* +Array.<*> +| + +Array.<*, *> diff --git a/docs/module-string.html b/docs/module-string.html index 42d56d84..da3ec4f0 100644 --- a/docs/module-string.html +++ b/docs/module-string.html @@ -34,7 +34,7 @@

                                  Module: string

                                    - +
                                    diff --git a/docs/module-utils.html b/docs/module-utils.html index aa6974d6..d481ff8d 100644 --- a/docs/module-utils.html +++ b/docs/module-utils.html @@ -34,7 +34,7 @@

                                    Module: utils

                                      - +
                                      diff --git a/docs/module.exports.html b/docs/module.exports.html index 03a45997..32906165 100644 --- a/docs/module.exports.html +++ b/docs/module.exports.html @@ -34,7 +34,7 @@

                                      Class: exports

                                        - +
                                        diff --git a/docs/object.js.html b/docs/object.js.html index 59cef4b7..d53aa004 100644 --- a/docs/object.js.html +++ b/docs/object.js.html @@ -36,7 +36,7 @@

                                        Source: object.js

                                          - +
                                          diff --git a/docs/object_assignDeep.js.html b/docs/object_assignDeep.js.html index 806997f2..eed0f18a 100644 --- a/docs/object_assignDeep.js.html +++ b/docs/object_assignDeep.js.html @@ -36,7 +36,7 @@

                                          Source: object/assignDeep.js

                                            - +
                                            diff --git a/docs/object_assocList.js.html b/docs/object_assocList.js.html index 1db7e8f6..6493f75d 100644 --- a/docs/object_assocList.js.html +++ b/docs/object_assocList.js.html @@ -36,7 +36,7 @@

                                            Source: object/assocList.js

                                              - +
                                              diff --git a/docs/object_console.js.html b/docs/object_console.js.html index 3f047332..6582cc40 100644 --- a/docs/object_console.js.html +++ b/docs/object_console.js.html @@ -36,7 +36,7 @@

                                              Source: object/console.js

                                                - +
                                                diff --git a/docs/object_copy.js.html b/docs/object_copy.js.html index cf57b033..7cca37e6 100644 --- a/docs/object_copy.js.html +++ b/docs/object_copy.js.html @@ -36,7 +36,7 @@

                                                Source: object/copy.js

                                                  - +
                                                  diff --git a/docs/object_defineProp.js.html b/docs/object_defineProp.js.html new file mode 100644 index 00000000..995f2169 --- /dev/null +++ b/docs/object_defineProp.js.html @@ -0,0 +1,243 @@ + + + + + + + Source: object/defineProp.js | Source: object/defineProp.js + + + + + + + + + + + + + +
                                                  + +
                                                  + + + + + +
                                                  +
                                                  + 
                                                  /**
+ * @module object
+ * @note Custom jsdoc type definitions defined toward end of file.
+ */
+import {curry} from '../function/curry';
+import {apply} from '../jsPlatform/function';
+import {errorIfNotType} from '../errorThrowing';
+import {isUndefined, isType} from './is';
+
+/**
+ * Creates `defineProps` and `defineEnumProps` methods based on `{enumerable}` param.
+ * @param {{enumerable: Boolean}}
+ * @returns {function(*, *)|PropsDefinerCall}
+ * @private
+ */
+function createDefinePropsMethod ({enumerable}) {
+    const operation = enumerable ? defineEnumProp : defineProp;
+    return (argTuples, target) => {
+        argTuples.forEach(argTuple => {
+            const [TypeRef, propName, defaultValue] = argTuple;
+            apply(operation, [TypeRef, target, propName, defaultValue]);
+        });
+        return target;
+    };
+}
+
+export const
+
+    /**
+     * Creates a descriptor for a property which is settable but throws
+     * errors when the `Type` is disobeyed.
+     * @function module:object.createTypedDescriptor
+     * @param Type {TypeRef} - {String|Function}
+     * @param target {*}
+     * @param propName {String}
+     * @returns {Descriptor} - Property descriptor with just getter and setter.
+     */
+    createTypedDescriptor = (Type, target, propName) => {
+        let _value;
+        return {
+            get: function () {
+                return _value;
+            },
+            set: function (value) {
+                _value = errorIfNotType(Type, propName, target, value);
+            }
+        };
+    },
+
+    /**
+     * Returns a target-descriptor tuple whose 'descriptor' will be set to
+     *  enumerable (`enumerable: true`).
+     * @function module:object.toEnumerableDescriptor
+     * @param {TargetDescriptorTuple} - [target, descriptor] tuple.
+     * @returns {TargetDescriptorTuple} - Array of target and descriptor.
+     */
+    toEnumerableDescriptor = ([target, descriptor]) => {
+        descriptor.enumerable = true;
+        return [target, descriptor];
+    },
+
+    /**
+     * Returns an target and descriptor tuple from given.
+     * @function module:object.toTargetDescriptorTuple
+     * @param targetOrTargetDescriptorTuple {(*|Array<*, *>)} - Target object or tuple of target and descriptor.
+     * @returns {(Array<*>|Array<*,*>)}
+     */
+    toTargetDescriptorTuple = targetOrTargetDescriptorTuple =>
+        isType('Array', targetOrTargetDescriptorTuple) ? // Strict type check for array
+            targetOrTargetDescriptorTuple : [targetOrTargetDescriptorTuple],
+
+    /**
+     * Allows you to define a "typed" property on given `target`.
+     * @function module:object.defineProp
+     * @param Type {TypeRef} - {String|Function}
+     * @param target {TargetDescriptorTuple} - Target or array of target and descriptor ([target, descriptor]).
+     * @param propName {String}
+     * @param [defaultValue=undefined] {*}
+     * @returns {TargetDescriptorTuple}
+     */
+    defineProp = (Type, target, propName, defaultValue = undefined) => {
+        const [_target, _descriptor] = toTargetDescriptorTuple(target),
+            descriptor = _descriptor || createTypedDescriptor(Type, _target, propName);
+        Object.defineProperty(_target, propName, descriptor);
+        if (!isUndefined(defaultValue)) {
+            _target[propName] = defaultValue;
+        }
+        return [_target, descriptor];
+    },
+
+    /**
+     * Allows you to define a "typed", enumerated property on `target`.
+     * @function module:object.defineEnumProp
+     * @param Type {TypeRef} - {String|Function}
+     * @param target {TargetDescriptorTuple} - Target or array of target and descriptor ([target, descriptor]).
+     * @param propName {String}
+     * @param [defaultValue=undefined] {*}
+     * @returns {TargetDescriptorTuple}
+     */
+    defineEnumProp = (Type, target, propName, defaultValue = undefined) => {
+        const [_target, _descriptor] = toTargetDescriptorTuple(target),
+            descriptor = _descriptor || createTypedDescriptor(Type, _target, propName);
+        return defineProp(
+            Type,
+            toEnumerableDescriptor([_target, descriptor]),
+            propName,
+            defaultValue
+        );
+    },
+
+    /**
+     * Allows you to define multiple enum props at once on target.
+     * @function module:object.defineEnumProps
+     * @param argsTuple {Array.<DefinePropArgsTuple>} - Array of argArrays for `defineEnumProp`.
+     * @param [target = undefined] {Target} - Target to use in internal calls if one is not provided but encountered 'argArray'.
+     * @returns {Array.<TargetDescriptorTuple>} - Results of each call to `defineEnumProp`.
+     */
+    defineEnumProps = curry(createDefinePropsMethod({enumerable: true})),
+
+    /**
+     * Allows you to define multiple props at once on target.
+     * @function module:object.defineProps
+     * @param argsTuple {Array.<DefinePropArgsTuple>} - Array of argArrays for `defineProp`.
+     * @param [target = undefined] {Target} - Target to use in internal calls if one is not provided but encountered 'argArray'.
+     * @returns {Array.<TargetDescriptorTuple>} - Results of each call to `defineProp`.
+     * @curried
+     */
+    defineProps = curry(createDefinePropsMethod({enumerable: false}))
+
+;
+
+/** ============================================================= */
+/** Type definitions:                                             */
+/** ============================================================= */
+
+/**
+ * @typedef {*} Target
+ */
+
+/**
+ * @typedef {Object} Descriptor
+ */
+
+/**
+ * @typedef {Array<Target, Descriptor>} TargetDescriptorTuple
+ */
+
+/**
+ * @typedef {Array.<TypeRef, TargetDescriptorTuple, String, *>}  DefinePropArgsTuple
+ * @description Arguments list for `defineProp` and/or `defineEnumProp` (note: some
+ *  parts of array/tuple are options (namely the last two args));  E.g.,
+ *  ```
+ *  [String, [someTarget], 'somePropName', 'someDefaultValue] // ...
+ *  ```
+ */
+
+/**
+ * @typedef {Function} PropsDefinerCall
+ * @description Same type as `defineProp` and `defineEnumProp`
+ * @param argsTuple {DefinePropArgsTuple}
+ * @param target {Target}
+ * @returns {Array.<TargetDescriptorTuple>}
+ */
+
                                                  +
                                                  +
                                                  + + + + +
                                                  + +
                                                  + +
                                                  functional-jslib - BSD 3.0 License - JsDoc Template -> tui-jsdoc-template - by NHN Entertainment - Frontend Development Lab
                                                  +
                                                  + + + + + + + + + diff --git a/docs/object_is.js.html b/docs/object_is.js.html index 3b9c401f..c1f2329e 100644 --- a/docs/object_is.js.html +++ b/docs/object_is.js.html @@ -36,7 +36,7 @@

                                                  Source: object/is.js

                                                    - +
                                                    diff --git a/docs/object_jsonClone.js.html b/docs/object_jsonClone.js.html index 1843a578..29b852eb 100644 --- a/docs/object_jsonClone.js.html +++ b/docs/object_jsonClone.js.html @@ -36,7 +36,7 @@

                                                    Source: object/jsonClone.js

                                                      - +
                                                      diff --git a/docs/object_lookup.js.html b/docs/object_lookup.js.html index b03d17f8..d84b1c51 100644 --- a/docs/object_lookup.js.html +++ b/docs/object_lookup.js.html @@ -36,7 +36,7 @@

                                                      Source: object/lookup.js

                                                        - +
                                                        diff --git a/docs/object_of.js.html b/docs/object_of.js.html index 122d6319..606ab5af 100644 --- a/docs/object_of.js.html +++ b/docs/object_of.js.html @@ -36,7 +36,7 @@

                                                        Source: object/of.js

                                                          - +
                                                          diff --git a/docs/object_searchObj.js.html b/docs/object_searchObj.js.html index 9f516c95..41731f12 100644 --- a/docs/object_searchObj.js.html +++ b/docs/object_searchObj.js.html @@ -36,7 +36,7 @@

                                                          Source: object/searchObj.js

                                                            - +
                                                            diff --git a/docs/object_toArray.js.html b/docs/object_toArray.js.html index 1b43404f..3ed462f2 100644 --- a/docs/object_toArray.js.html +++ b/docs/object_toArray.js.html @@ -36,7 +36,7 @@

                                                            Source: object/toArray.js

                                                              - +
                                                              diff --git a/docs/object_typeOf.js.html b/docs/object_typeOf.js.html index 7f40a405..2ce72c6c 100644 --- a/docs/object_typeOf.js.html +++ b/docs/object_typeOf.js.html @@ -36,7 +36,7 @@

                                                              Source: object/typeOf.js

                                                                - +
                                                                diff --git a/docs/string.js.html b/docs/string.js.html index df0b247f..7ef8159d 100644 --- a/docs/string.js.html +++ b/docs/string.js.html @@ -36,7 +36,7 @@

                                                                Source: string.js

                                                                  - +
                                                                  diff --git a/docs/utils.js.html b/docs/utils.js.html index 0f545dc9..ed61a1cd 100644 --- a/docs/utils.js.html +++ b/docs/utils.js.html @@ -36,7 +36,7 @@

                                                                  Source: utils.js

                                                                    - +
                                                                    diff --git a/markdown-fragments/sections/changelog.md b/markdown-fragments/sections/changelog.md index 148bd6fe..98abf9a0 100644 --- a/markdown-fragments/sections/changelog.md +++ b/markdown-fragments/sections/changelog.md @@ -10,6 +10,8 @@ - Added `native` which includes all the static methods that live on `Object` though flipped and curried. +- Added 'fjl-mutable' as part of source. All methods of 'fjl-mutable' now +live directly on 'fjl' and are defined in 'fjl/objects/defineProp' (or more directly in src at './src/objects/defineProp'). #### Development changes. - Updated 'dev-deps' to use latest babel. diff --git a/package.json b/package.json index 6c4fd20b..219ac363 100644 --- a/package.json +++ b/package.json @@ -2,8 +2,8 @@ "name": "fjl", "version": "1.7.0", "description": "Functional Javascript Library", - "main": "dist/package/fjl", - "module": "dist/package/fjl.mjs", + "main": "dist/cjs/fjl", + "module": "dist/es6-module/fjl.mjs", "scripts": { "build": "gulp docs build && npm run test-builds", "test-builds": "jest --testMatch **/tests/*-test-*.js", diff --git a/src/fjl.js b/src/fjl.js index cea09ca3..8ebc48e3 100644 --- a/src/fjl.js +++ b/src/fjl.js @@ -15,3 +15,9 @@ export * from './list'; export * from './string'; export * from './utils'; export * from './errorThrowing'; + +/** + * @typedef {String|Function|ArrayBufferConstructor|ArrayConstructor|BooleanConstructor|MapConstructor|NumberConstructor|SetConstructor|WeakMapConstructor|WeakSetConstructor} TypeRef + * @description Type reference. Either actual type or type's name; E.g., `Type.name` + * Also note: Class cased names are use for values that do not have `name` properties; Namely: 'Null', 'NaN' and 'Undefined' (for their respective values respectively). + */ diff --git a/src/object/defineProp.js b/src/object/defineProp.js new file mode 100644 index 00000000..5d45925d --- /dev/null +++ b/src/object/defineProp.js @@ -0,0 +1,163 @@ +/** + * @module object + * @note Custom jsdoc type definitions defined toward end of file. + */ +import {curry} from '../function/curry'; +import {apply} from '../jsPlatform/function'; +import {errorIfNotType} from '../errorThrowing'; +import {isUndefined, isType} from './is'; + +/** + * Creates `defineProps` and `defineEnumProps` methods based on `{enumerable}` param. + * @param {{enumerable: Boolean}} + * @returns {function(*, *)|PropsDefinerCall} + * @private + */ +function createDefinePropsMethod ({enumerable}) { + const operation = enumerable ? defineEnumProp : defineProp; + return (argTuples, target) => { + argTuples.forEach(argTuple => { + const [TypeRef, propName, defaultValue] = argTuple; + apply(operation, [TypeRef, target, propName, defaultValue]); + }); + return target; + }; +} + +export const + + /** + * Creates a descriptor for a property which is settable but throws + * errors when the `Type` is disobeyed. + * @function module:object.createTypedDescriptor + * @param Type {TypeRef} - {String|Function} + * @param target {*} + * @param propName {String} + * @returns {Descriptor} - Property descriptor with just getter and setter. + */ + createTypedDescriptor = (Type, target, propName) => { + let _value; + return { + get: function () { + return _value; + }, + set: function (value) { + _value = errorIfNotType(Type, propName, target, value); + } + }; + }, + + /** + * Returns a target-descriptor tuple whose 'descriptor' will be set to + * enumerable (`enumerable: true`). + * @function module:object.toEnumerableDescriptor + * @param {TargetDescriptorTuple} - [target, descriptor] tuple. + * @returns {TargetDescriptorTuple} - Array of target and descriptor. + */ + toEnumerableDescriptor = ([target, descriptor]) => { + descriptor.enumerable = true; + return [target, descriptor]; + }, + + /** + * Returns an target and descriptor tuple from given. + * @function module:object.toTargetDescriptorTuple + * @param targetOrTargetDescriptorTuple {(*|Array<*, *>)} - Target object or tuple of target and descriptor. + * @returns {(Array<*>|Array<*,*>)} + */ + toTargetDescriptorTuple = targetOrTargetDescriptorTuple => + isType('Array', targetOrTargetDescriptorTuple) ? // Strict type check for array + targetOrTargetDescriptorTuple : [targetOrTargetDescriptorTuple], + + /** + * Allows you to define a "typed" property on given `target`. + * @function module:object.defineProp + * @param Type {TypeRef} - {String|Function} + * @param target {TargetDescriptorTuple} - Target or array of target and descriptor ([target, descriptor]). + * @param propName {String} + * @param [defaultValue=undefined] {*} + * @returns {TargetDescriptorTuple} + */ + defineProp = (Type, target, propName, defaultValue = undefined) => { + const [_target, _descriptor] = toTargetDescriptorTuple(target), + descriptor = _descriptor || createTypedDescriptor(Type, _target, propName); + Object.defineProperty(_target, propName, descriptor); + if (!isUndefined(defaultValue)) { + _target[propName] = defaultValue; + } + return [_target, descriptor]; + }, + + /** + * Allows you to define a "typed", enumerated property on `target`. + * @function module:object.defineEnumProp + * @param Type {TypeRef} - {String|Function} + * @param target {TargetDescriptorTuple} - Target or array of target and descriptor ([target, descriptor]). + * @param propName {String} + * @param [defaultValue=undefined] {*} + * @returns {TargetDescriptorTuple} + */ + defineEnumProp = (Type, target, propName, defaultValue = undefined) => { + const [_target, _descriptor] = toTargetDescriptorTuple(target), + descriptor = _descriptor || createTypedDescriptor(Type, _target, propName); + return defineProp( + Type, + toEnumerableDescriptor([_target, descriptor]), + propName, + defaultValue + ); + }, + + /** + * Allows you to define multiple enum props at once on target. + * @function module:object.defineEnumProps + * @param argsTuple {Array.} - Array of argArrays for `defineEnumProp`. + * @param [target = undefined] {Target} - Target to use in internal calls if one is not provided but encountered 'argArray'. + * @returns {Array.} - Results of each call to `defineEnumProp`. + */ + defineEnumProps = curry(createDefinePropsMethod({enumerable: true})), + + /** + * Allows you to define multiple props at once on target. + * @function module:object.defineProps + * @param argsTuple {Array.} - Array of argArrays for `defineProp`. + * @param [target = undefined] {Target} - Target to use in internal calls if one is not provided but encountered 'argArray'. + * @returns {Array.} - Results of each call to `defineProp`. + * @curried + */ + defineProps = curry(createDefinePropsMethod({enumerable: false})) + +; + +/** ============================================================= */ +/** Type definitions: */ +/** ============================================================= */ + +/** + * @typedef {*} Target + */ + +/** + * @typedef {Object} Descriptor + */ + +/** + * @typedef {Array} TargetDescriptorTuple + */ + +/** + * @typedef {Array.} DefinePropArgsTuple + * @description Arguments list for `defineProp` and/or `defineEnumProp` (note: some + * parts of array/tuple are options (namely the last two args)); E.g., + * ``` + * [String, [someTarget], 'somePropName', 'someDefaultValue] // ... + * ``` + */ + +/** + * @typedef {Function} PropsDefinerCall + * @description Same type as `defineProp` and `defineEnumProp` + * @param argsTuple {DefinePropArgsTuple} + * @param target {Target} + * @returns {Array.} + */ diff --git a/tests/test-object.defineProp.js b/tests/test-object.defineProp.js new file mode 100644 index 00000000..ca2dc16c --- /dev/null +++ b/tests/test-object.defineProp.js @@ -0,0 +1,418 @@ +import {apply} from '../src/jsPlatform/function'; +import {keys} from '../src/jsPlatform/object'; +import {unfoldr} from '../src/list'; +import { + createTypedDescriptor, + toEnumerableDescriptor, + defineProp, + defineProps, + defineEnumProp, + defineEnumProps +} + from '../src/object/defineProp'; + +describe ('#fjlMutable', function () { + + describe ('#createTypedDescriptor', function () { + const someTarget = {}, + exampleNumberDescriptor = createTypedDescriptor(Number, someTarget, 'someNum'), + result = exampleNumberDescriptor; + it ('should return a descriptor with a setter and a getter', function () { + const ks = keys(result); + expect(ks.length).toEqual(2); + expect(result.hasOwnProperty('get')).toEqual(true); + expect(result.hasOwnProperty('set')).toEqual(true); + }); + + it ('should return a descriptor for whom\'s getter and setter functions' + + 'return and/or set the value for said descriptor.', function () { + expect(result.set(99)).toEqual(undefined); + expect(result.get()).toEqual(99); + }); + + it ('should return a descriptor with a setter that throws an `Error` when ' + + 'passed in value to be set is not of the defined type.', function () { + expect(() => result.set('not expected type')).toThrow(Error); + }); + + it ('should return a descriptor that retains it\'s value even after ' + + 'throwing a `setter` error (for incorrect type being passed in to `set`).', function () { + expect(() => result.set('not expected type')).toThrow(Error); + expect(result.get()).toEqual(99); + }); + + it ('should return a descriptor that doesn\'t expose internally stored value for ' + + 'it\'s defined property.', function () { + const ks = keys(result); + expect(ks.length).toEqual(2); + expect(result.hasOwnProperty('get')).toEqual(true); + expect(result.hasOwnProperty('set')).toEqual(true); + }); + }); + + describe ('#toEnumerableDescriptor', function () { + const descriptor = toEnumerableDescriptor([{}, {}])[1]; + + it ('should return an object with an `enumerable` property set to `true`', function () { + expect(descriptor.hasOwnProperty('enumerable')).toEqual(true); + expect(descriptor.enumerable).toEqual(true); + }); + + it ('should throw an error when no descriptor is passed in `TargetDescriptorPair`', function () { + expect(() => toEnumerableDescriptor([])).toThrow(Error); + expect(() => toEnumerableDescriptor([1]).toThrow(Error)); + }); + }); + + describe ('#defineProp', function () { + const someTarget = {}, + propName = 'someNum', + [target, descriptor] = defineProp(Number, [someTarget], propName); + it ('should return a `target` and `descriptor` pair (tuple)', function () { + expect(target).toEqual(someTarget); + expect(!!descriptor).toEqual(true); + }); + it ('should define property `propName` on `target`', function () { + expect(target.hasOwnProperty(propName)).toEqual(true); + }); + it ('should return a target whose defined `propName` throws an error when ' + + 'the wrong type is passed in', function () { + expect(() => { target[propName] = 'some value'; }).toThrow(Error); + }); + it ('should return a target whose defined `propName` doesn\'t throw' + + 'an error when the correct type of value is passed in', function () { + target[propName] = 99; + expect(target[propName]).toEqual(99); + }); + it ('should allow the user to pass in his/her own `descriptor`', function () { + const somePropName = 'somePropName', + someValue = (new Date()).getTime(), + customDescriptor = { + value: someValue, + enumerable: true + }, + [target2, descriptor2] = defineProp(Number, [someTarget, customDescriptor], somePropName); + expect(() => { target2[somePropName] = 99; }).toThrow(Error); + expect(target2[somePropName]).toEqual(someValue); + expect(descriptor2).toEqual(customDescriptor); + expect(descriptor2.enumerable).toEqual(true); + }); + }); + + describe ('#defineEnumProp', function () { + const someTarget = {}, + propName = 'someNum', + [target, descriptor] = defineEnumProp(Number, [someTarget], propName); + it ('should return a `target` and `descriptor` pair (tuple)', function () { + expect(target).toEqual(someTarget); + expect(!!descriptor).toEqual(true); + }); + it ('should define property `propName` on `target`', function () { + expect(target.hasOwnProperty(propName)).toEqual(true); + }); + it ('should set `enumerable` to `true` on returned descriptor', function () { + expect(descriptor.enumerable).toEqual(true); + expect(Object.getOwnPropertyDescriptor(target, propName).enumerable).toEqual(true); + }); + it ('should return a target whose defined `propName` throws an error when ' + + 'the wrong type is passed in', function () { + expect(() => { target[propName] = 'some value'; }).toThrow(Error); + }); + it ('should return a target whose defined `propName` doesn\'t throw' + + 'an error when the correct type of value is passed in', function () { + target[propName] = 99; + expect(target[propName]).toEqual(99); + }); + it ('should allow the user to pass in his/her own `descriptor`', function () { + const somePropName = 'somePropName', + someValue = (new Date()).getTime(), + customDescriptor = { + value: someValue, + enumerable: false + }, + [target2, descriptor2] = defineEnumProp(Number, [someTarget, customDescriptor], somePropName); + expect(() => { target2[somePropName] = 99; }).toThrow(Error); + expect(target2[somePropName]).toEqual(someValue); + expect(descriptor2).toEqual(customDescriptor); + expect(descriptor2.enumerable).toEqual(true); + }); + }); + + describe ('#defineProps', function () { + const + seedArgTuples = [ + [String, 'someStringProp'], + [Number, 'someNumberProp'], + [Boolean, 'someBooleanProp'], + [Function, 'someFunctionProp'], + [Array, 'someArrayProp'] + ], + seedArgTupleCorrectIncorrectValues = [ + ['99 bottles..', 99], + [99, 'should-be-number'], + [false, 1], + [function () {}, 99, 99], + [[1, 2, 3, 4, 5], function () {}] + ], + seedTarget = seedArgTuples.reduce((agg, tuple) => { + agg[tuple[1]] = null; + return agg; + }, {}), + seedPropNames = keys(seedTarget), + generateTargetData = () => unfoldr((argTuples, ind, _out) => { + const + _argTuples = argTuples.slice(0), + out = [_argTuples.slice(0), {}]; + if (!_out.length) { + return [out, _argTuples]; + } + else if (_argTuples.length) { + _argTuples.pop(); + return [out, _argTuples]; + } + return undefined; + }, + seedArgTuples); + + it ('data for tests should be in correct format', function () { + // Test our test parameters + expect(seedPropNames.length).toEqual(seedArgTuples.length); + seedPropNames.forEach((name, ind) => { + expect(seedArgTuples[ind][1]).toEqual(name); + }); + expect(seedPropNames.length).toEqual(seedArgTuples.length); + }); + + it ('should be able to define many props on given target with only argTuples of length `2`', function () { + generateTargetData().forEach(args => { + // log(args); + const target = defineProps.apply(null, args), + propNames = args[0].map(x => x[1]); + + // log(propNames, '\n', target); + + // Ensure targets have props set + propNames.forEach(name => { + expect(target.hasOwnProperty(name)).toEqual(true); + }); + }); + }); + + it ('should have defined properties that throw errors when they are set to the wrong type' + + 'and no errors when set to the correct type', function () { + generateTargetData().forEach(args => { + // log(args); + const target = defineProps.apply(null, args), + propNames = args[0].map(x => x[1]); + + // log(propNames, '\n', target); + + // Ensure targets have props set + propNames.forEach((name, ind) => { + const [correct, inCorrect] = seedArgTupleCorrectIncorrectValues[ind]; + + // Ensure prop exists + expect(target.hasOwnProperty(name)).toEqual(true); + + // Ensure setter obeys type rule + expect(() => { target[name] = inCorrect; }).toThrow(Error); + + // Ensure setter obeys type rule + expect(target[name] = correct).toEqual(correct); + }); + }); + }); + + it ('should return target with defined properties from operation', function () { + generateTargetData().forEach(args => { + // log(args); + const target = apply(defineProps, args), + argKeyNames = args[0].map(pair => pair[1]); + expect(target).toBeInstanceOf(Object); + argKeyNames.forEach(key => { + const propDescriptor = Object.getOwnPropertyDescriptor(target, key); + expect(['set', 'get'].every(k => propDescriptor[k] instanceof Function)); + }); + }); + }); + + it ('should be able to set types with argTuples of length of `3` (containing a `defaultValue`)', function () { + generateTargetData().map(argTuple => { + const [args, target] = argTuple; + // log(argTuple); + // Return new version of `argTuple` (seeded with `defaultValue`) + return [ + // Add `defaultValue` to arg lists + args.map((argSet, ind) => { + const [TypeRef, propName] = argSet, + [correct] = seedArgTupleCorrectIncorrectValues[ind]; + return [TypeRef, propName, correct]; + }), + target + ]; + }).forEach(args => { + // log(args); + const target = apply(defineProps, args), + argKeyNames = args[0].map(([_, key]) => key); + expect(target).toBeInstanceOf(Object); + argKeyNames.forEach(key => { + const propDescriptor = Object.getOwnPropertyDescriptor(target, key); + expect(['set', 'get'].every(k => propDescriptor[k] instanceof Function)); + }); + }); + }); + + }); + + describe ('#defineEnumProps', function () { + const + seedArgTuples = [ + [String, 'someStringProp'], + [Number, 'someNumberProp'], + [Boolean, 'someBooleanProp'], + [Function, 'someFunctionProp'], + [Array, 'someArrayProp'] + ], + seedArgTupleCorrectIncorrectValues = [ + ['99 bottles..', 99], + [99, 'should-be-number'], + [false, 1], + [function () {}, 99, 99], + [[1, 2, 3, 4, 5], function () {}] + ], + seedTarget = seedArgTuples.reduce((agg, tuple) => { + agg[tuple[1]] = null; + return agg; + }, {}), + seedPropNames = keys(seedTarget), + generateTargetData = () => unfoldr((argTuples, ind, _out) => { + const + _argTuples = argTuples.slice(0), + out = [_argTuples.slice(0), {}]; + if (!_out.length) { + return [out, _argTuples]; + } + else if (_argTuples.length) { + _argTuples.pop(); + return [out, _argTuples]; + } + return undefined; + }, + seedArgTuples); + + it ('data for tests should be in correct format', function () { + // Test our test parameters + expect(seedPropNames.length).toEqual(seedArgTuples.length); + seedPropNames.forEach((name, ind) => { + expect(seedArgTuples[ind][1]).toEqual(name); + }); + expect(seedPropNames.length).toEqual(seedArgTuples.length); + }); + + it ('should be able to define many enum props on given target with only argTuples of length `2`', function () { + generateTargetData().forEach(args => { + // log(args); + const target = apply(defineEnumProps, args), + propNames = args[0].map(([_, name]) => name); + + // log(propNames, '\n', target); + + // Ensure targets have enumerable props set + propNames.forEach(name => { + expect(target.hasOwnProperty(name)).toEqual(true); + expect(Object.getOwnPropertyDescriptor(target, name).enumerable) + .toEqual(true); + }); + }); + }); + + it ('should have defined properties that throw errors when they are set to the wrong type' + + 'and no errors when set to the correct type', function () { + generateTargetData().forEach(args => { + // log(args); + const target = apply(defineEnumProps, args), + propNames = args[0].map(([_, name]) => name); + + // log(propNames, '\n', target); + + // Ensure targets have enumerable props set + propNames.forEach((name, ind) => { + const [correct, inCorrect] = seedArgTupleCorrectIncorrectValues[ind]; + + // Ensure prop exists + expect(target.hasOwnProperty(name)).toEqual(true); + + // Ensure prop is enumerable + expect(Object.getOwnPropertyDescriptor(target, name).enumerable) + .toEqual(true); + + // Ensure setter obeys type rule + expect(() => { target[name] = inCorrect; }).toThrow(Error); + + // Ensure setter obeys type rule + expect(target[name] = correct).toEqual(correct); + }); + }); + }); + + it ('should return target and descriptor tuples from operation', function () { + generateTargetData().forEach(args => { + // log(args); + const target = apply(defineEnumProps, args), + propNames = args[0].map(([_, name]) => name); + expect(target).toBeInstanceOf(Object); + propNames.forEach(name => { + const propDescript = Object.getOwnPropertyDescriptor(target, name); + expect(propDescript.enumerable).toEqual(true); + expect(['set', 'get'].every(key => propDescript[key] instanceof Function)); + }); + }); + }); + + it ('should be able to set types with argTuples of length of `3`(with [target, descriptor] tuple) ' + + 'and `4` (with defaultValue)', function () { + generateTargetData().map(argTuple => { + const [args, target] = argTuple; + // log(argTuple); + // Return new version of `argTuple` seeded `defaultValue` + return [ + // Add `defaultValue` to arg lists + args.map((argSet, ind) => { + const [correct, _] = seedArgTupleCorrectIncorrectValues[ind]; + return argSet.concat([correct]); + }), + target + ]; + + }).forEach(args => { + // log(args); + + const target = apply(defineEnumProps, args), + propNames = args[0].map(([_, name]) => name); + expect(target).toBeInstanceOf(Object); + + // log(propNames, '\n', target); + + // Ensure targets have enumerable props set + propNames.forEach((name, ind) => { + const [correct, inCorrect] = seedArgTupleCorrectIncorrectValues[ind]; + + // Ensure prop exists + expect(target.hasOwnProperty(name)).toEqual(true); + + // Ensure prop is enumerable + expect(Object.getOwnPropertyDescriptor(target, name).enumerable) + .toEqual(true); + + // Ensure setter obeys type rule + expect(() => { target[name] = inCorrect; }).toThrow(Error); + + // Ensure setter obeys type rule + expect(target[name] = correct).toEqual(correct); + }); + }); + }); + + }); + +}); diff --git a/tests/test-object.js b/tests/test-object.js index e1d2ffb6..dfce67e4 100644 --- a/tests/test-object.js +++ b/tests/test-object.js @@ -720,7 +720,12 @@ describe ('#object', function () { Object.getOwnPropertyNames(Object).forEach(key => { const foundOnNative = native[key], foundOnObj = Object[key]; - if (typeof foundOnNative !== 'function') { return; } + + // Test functions only + if (typeof foundOnNative !== 'function') { + return; + } + it(`should have a "${key}" property whose value is of same type as \`Object[key]\``, () => { expect(typeof foundOnNative).toEqual(typeof foundOnObj); }); diff --git a/types/base-types.d.ts b/types/base-types.d.ts index 819be34b..17bbe84c 100644 --- a/types/base-types.d.ts +++ b/types/base-types.d.ts @@ -1 +1,7 @@ -declare type TypeRef = string | Function; +declare type TypeRef = + string | Function | ArrayBufferConstructor | ArrayConstructor | + BooleanConstructor | StringConstructor | + NumberConstructor | MapConstructor | + SetConstructor | WeakMapConstructor | + WeakSetConstructor | PromiseConstructorLike + ; diff --git a/types/index.d.ts b/types/index.d.ts index fb6cc1de..230ac199 100644 --- a/types/index.d.ts +++ b/types/index.d.ts @@ -1,3 +1,5 @@ +export as namespace fjl; + import './base-types'; import './utils'; import './function';
                                                                    NameTypeValue to derive returned value's type from.
                                                                    Description
                                                                    argsx @@ -13911,22 +26115,10 @@
                                                                    Parameters:
                                                                    		 - - <optional>
                                                                    - - - - - - <repeatable>
                                                                    - -                                                                     		Any args to pass in to matched construction strategy.Thing to convert from.
                                                                    nsStringobj -String - - - -
                                                                    obj - - * @@ -14145,7 +26310,7 @@
                                                                    Returns:
                                                                    -* +Array.<*, *> @@ -14196,11 +26361,6 @@
                                                                    Returns:
                                                                    -
                                                                    Example
                                                                    - - 
                                                                    ```
if (obj && obj.all && obj.all.your && obj.all.your.base) {
  // Thing we want to do
}

// So with our function becomes
if (searchObj('all.your.base', obj)) {
  // Thing we want to do
}
```
                                                                    - - @@ -14209,14 +26369,14 @@
                                                                    Example
                                                                    -

                                                                    +

                                                                    - static toArray(x) → {Array} + static toAssocListDeep(obj, TypeConstraintopt) → {*}
                                                                    - object/toArray.js, - line 6 + object/assocList.js, + line 15

                                                                    @@ -14228,7 +26388,7 @@

                                                                    - Converts incoming value to an array. + Returns an associated list from given object (deeply (on incoming object's type)).
                                                                    @@ -14252,8 +26412,12 @@

                                                                    Parameters:
                                                                    		TypeAttributesDefaultDescription
                                                                    xobj @@ -14277,10 +26441,64 @@
                                                                    Parameters:
                                                                    		 + + + + + + + + Thing to convert from.
                                                                    TypeConstraint + + +Constructor +| + +function + + + + + + <optional>
                                                                    + + + + + +                                                                     		+ + Object + + Type constraint to convert on.
                                                                    NameType
                                                                    obj -Object -| - -Array -| - -* +TargetDescriptorTuple @@ -14444,7 +26652,7 @@
                                                                    Parameters:
                                                                    -                                                                     		[target, descriptor] tuple.
                                                                    TypeAttributesDefaultDescription
                                                                    objtargetOrTargetDescriptorTuple * - - - - - - - - - - - -
                                                                    TypeConstraint - - -Constructor | -function +Array.<*, *> - - <optional>
                                                                    - - - - - -                                                                     		- - Object - - Type constraint to convert on.Target object or tuple of target and descriptor.