ramda-adjunct 2.34.0

package/lib/invokeArgs.js

@@ -0,0 +1,40 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isNotFunction = _interopRequireDefault(require("./isNotFunction"));
+
+var _isEmptyArray = _interopRequireDefault(require("./isEmptyArray"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Invokes the method at path of object with given arguments.
+ *
+ * @func invokeArgs
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.27.0|v2.27.0}
+ * @category Object
+ * @sig Array -> Array -> Object -> *
+ * @param {Array.<string|number>} path The path of the method to invoke
+ * @param {Array} args The arguments to invoke the method with
+ * @param {Object} obj The object to query
+ * @return {*}
+ * @example
+ *
+ * RA.invokeArgs(['abs'], [-1], Math); //=> 1
+ * RA.invokeArgs(['path', 'to', 'non-existent', 'method'], [-1], Math); //=> undefined
+ */
+var invokeArgs = (0, _ramda.curryN)(3, function (mpath, args, obj) {
+  var method = (0, _ramda.path)(mpath, obj);
+  var context = (0, _ramda.path)((0, _ramda.init)(mpath), obj);
+  if ((0, _isNotFunction["default"])(method)) return undefined;
+  if ((0, _isEmptyArray["default"])(mpath)) return undefined;
+  var boundMethod = (0, _ramda.bind)(method, context);
+  return (0, _ramda.apply)(boundMethod, args);
+});
+var _default = invokeArgs;
+exports["default"] = _default;

package/lib/isArray.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if input value is `Array`.
+ *
+ * @func isArray
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.3.0|v0.3.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotArray|isNotArray}
+ * @example
+ *
+ * RA.isArray([]); //=> true
+ * RA.isArray(null); //=> false
+ * RA.isArray({}); //=> false
+ */
+var isArray = (0, _ramda.curryN)(1, (0, _isFunction["default"])(Array.isArray) ? Array.isArray : (0, _ramda.pipe)(_ramda.type, (0, _ramda.identical)('Array')));
+var _default = isArray;
+exports["default"] = _default;

package/lib/isArrayLike.js

@@ -0,0 +1,98 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isArray = _interopRequireDefault(require("./isArray"));
+
+var _isString = _interopRequireDefault(require("./isString"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+/* eslint-disable max-len */
+
+/**
+ * Tests whether or not an object is similar to an array.
+ *
+ * @func isArrayLike
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.9.0|v1.9.0}
+ * @licence https://github.com/ramda/ramda/blob/master/LICENSE.txt
+ * @category List
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @returns {boolean} `true` if `val` has a numeric length property and extreme indices defined; `false` otherwise.
+ * @see {@link RA.isNotArrayLike|isNotArrayLike}
+
+ * @example
+ *
+ * RA.isArrayLike([]); //=> true
+ * RA.isArrayLike(true); //=> false
+ * RA.isArrayLike({}); //=> false
+ * RA.isArrayLike({length: 10}); //=> false
+ * RA.isArrayLike({0: 'zero', 9: 'nine', length: 10}); //=> true
+ */
+
+/* eslint-enable max-len */
+var isArrayLike = (0, _ramda.curryN)(1, function (val) {
+  if ((0, _isArray["default"])(val)) {
+    return true;
+  }
+
+  if (!val) {
+    return false;
+  }
+
+  if ((0, _isString["default"])(val)) {
+    return false;
+  }
+
+  if (_typeof(val) !== 'object') {
+    return false;
+  }
+
+  if (val.nodeType === 1) {
+    return !!val.length;
+  }
+
+  if (val.length === 0) {
+    return true;
+  }
+
+  if (val.length > 0) {
+    return (0, _ramda.has)(0, val) && (0, _ramda.has)(val.length - 1, val);
+  }
+
+  return false;
+});
+var _default = isArrayLike;
+/**
+ The MIT License (MIT)
+
+ Copyright (c) 2013-2016 Scott Sauyet and Michael Hurley
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+*/
+
+exports["default"] = _default;

package/lib/isAsyncFunction.js

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Checks if input value is `Async Function`.
+ *
+ * @func isAsyncFunction
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.5.0|v0.5.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isFunction|isFunction}, {@link RA.isNotAsyncFunction|isNotAsyncFunction}, {@link RA.isGeneratorFunction|isGeneratorFunction}
+ * @example
+ *
+ * RA.isAsyncFunction(async function test() { }); //=> true
+ * RA.isAsyncFunction(null); //=> false
+ * RA.isAsyncFunction(function test() { }); //=> false
+ * RA.isAsyncFunction(() => {}); //=> false
+ */
+var isAsyncFunction = (0, _ramda.curryN)(1, (0, _ramda.pipe)(_ramda.type, (0, _ramda.identical)('AsyncFunction')));
+var _default = isAsyncFunction;
+exports["default"] = _default;

package/lib/isBigInt.js

@@ -0,0 +1,29 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Checks if value is a BigInt.
+ *
+ * @func isBigInt
+ * @memberOf RA
+ * @category Type
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.27.0|v2.27.0}
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @example
+ *
+ * RA.isBigInt(5); // => false
+ * RA.isBigInt(Number.MAX_VALUE); // => false
+ * RA.isBigInt(-Infinity); // => false
+ * RA.isBigInt(10); // => false
+ * RA.isBigInt(10n); // => true
+ * RA.isBigInt(BitInt(9007199254740991)); // => true
+ */
+var isBigInt = (0, _ramda.curryN)(1, (0, _ramda.pipe)(_ramda.type, (0, _ramda.identical)('BigInt')));
+var _default = isBigInt;
+exports["default"] = _default;

package/lib/isBoolean.js

@@ -0,0 +1,27 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Checks if input value is `Boolean`.
+ *
+ * @func isBoolean
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.3.0|v0.3.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotBoolean|isNotBoolean}
+ * @example
+ *
+ * RA.isBoolean(false); //=> true
+ * RA.isBoolean(true); //=> true
+ * RA.isBoolean(null); //=> false
+ */
+var isBoolean = (0, _ramda.curryN)(1, (0, _ramda.pipe)(_ramda.type, (0, _ramda.identical)('Boolean')));
+var _default = isBoolean;
+exports["default"] = _default;

package/lib/isDate.js

@@ -0,0 +1,26 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Checks if value is `Date` object.
+ *
+ * @func isDate
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.6.0|v0.6.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotDate|isNotDate}, {@link RA.isValidDate|isValidDate}, {@link RA.isNotValidDate|isNotValidDate}
+ * @example
+ *
+ * RA.isDate(new Date()); //=> true
+ * RA.isDate('1997-07-16T19:20+01:00'); //=> false
+ */
+var isDate = (0, _ramda.curryN)(1, (0, _ramda.pipe)(_ramda.type, (0, _ramda.identical)('Date')));
+var _default = isDate;
+exports["default"] = _default;

package/lib/isEmptyArray.js

@@ -0,0 +1,35 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isArray = _interopRequireDefault(require("./isArray"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if input value is an empty `Array`.
+ *
+ * @func isEmptyArray
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.4.0|v2.4.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotEmptyArray|isNotEmptyArray}
+ * @example
+ *
+ * RA.isEmptyArray([]); // => true
+ * RA.isEmptyArray([42]); // => false
+ * RA.isEmptyArray({}); // => false
+ * RA.isEmptyArray(null); // => false
+ * RA.isEmptyArray(undefined); // => false
+ * RA.isEmptyArray(42); // => false
+ * RA.isEmptyArray('42'); // => false
+ */
+var isEmptyArray = (0, _ramda.both)(_isArray["default"], _ramda.isEmpty);
+var _default = isEmptyArray;
+exports["default"] = _default;

package/lib/isEmptyString.js

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Checks if input value is an empty `String`.
+ *
+ * @func isEmptyString
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.4.0|v2.4.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotEmptyString|isNotEmptyString}
+ * @example
+ *
+ * RA.isEmptyString(''); // => true
+ * RA.isEmptyString('42'); // => false
+ * RA.isEmptyString(new String('42')); // => false
+ * RA.isEmptyString(new String('')); // => false
+ * RA.isEmptyString([42]); // => false
+ * RA.isEmptyString({}); // => false
+ * RA.isEmptyString(null); // => false
+ * RA.isEmptyString(undefined); // => false
+ * RA.isEmptyString(42); // => false
+ */
+var isEmptyString = (0, _ramda.equals)('');
+var _default = isEmptyString;
+exports["default"] = _default;

package/lib/isError.js

@@ -0,0 +1,26 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`, `SyntaxError`, `TypeError` or `URIError` object.
+ *
+ * @func isError
+ * @category Type
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.30.0|v2.30.0}
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean} Returns `true` if value is an error object, `false` otherwise
+ * @example
+ *
+ * RA.isError(new Error()); //=> true
+ * RA.isError(Error); //=> false
+ * RA.isError(1); // => false
+ */
+var isError = (0, _ramda.curryN)(1, (0, _ramda.pipe)(_ramda.type, (0, _ramda.identical)('Error')));
+var _default = isError;
+exports["default"] = _default;

package/lib/isEven.js

@@ -0,0 +1,39 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isInteger = _interopRequireDefault(require("./isInteger"));
+
+var _isOdd = _interopRequireDefault(require("./isOdd"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if value is even integer number.
+ * An even number is an integer which is "evenly divisible" by two.
+ * Zero is an even number because zero divided by two equals zero,
+ * which despite not being a natural number, is an integer.
+ * Even numbers are either positive or negative.
+ *
+ * @func isEven
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.18.0|v1.18.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isOdd|isOdd}
+ * @example
+ *
+ * RA.isEven(0); // => true
+ * RA.isEven(1); // => false
+ * RA.isEven(-Infinity); // => false
+ * RA.isEven(4); // => true
+ * RA.isEven(3); // => false
+ */
+var isEven = (0, _ramda.curryN)(1, (0, _ramda.both)(_isInteger["default"], (0, _ramda.complement)(_isOdd["default"])));
+var _default = isEven;
+exports["default"] = _default;

package/lib/isFalse.js

@@ -0,0 +1,35 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Checks if input value is the Boolean primitive `false`. Will return false for all values created
+ * using the `Boolean` function as a constructor.
+ *
+ * @func isFalse
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.6.0|v2.6.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isTrue|isTrue}, {@link RA.isTruthy|isTruthy}, {@link RA.isFalsy|isFalsy}
+ * @example
+ *
+ * RA.isFalse(false); // => true
+ * RA.isFalse(Boolean(false)); // => true
+ * RA.isFalse(true); // => false
+ * RA.isFalse(0); // => false
+ * RA.isFalse(''); // => false
+ * RA.isFalse(null); // => false
+ * RA.isFalse(undefined); // => false
+ * RA.isFalse(NaN); // => false
+ * RA.isFalse([]); // => false
+ * RA.isFalse(new Boolean(false)); // => false
+ */
+var isFalse = (0, _ramda.identical)(false);
+var _default = isFalse;
+exports["default"] = _default;

package/lib/isFalsy.js

@@ -0,0 +1,35 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isTruthy = _interopRequireDefault(require("./isTruthy"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * A falsy value is a value that translates to false when evaluated in a Boolean context.
+ * Falsy values are `false`, `0`, `""`, `null`, `undefined`, and `NaN`.
+ *
+ * @func isFalsy
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.2.0|v2.2..0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Glossary/Falsy|falsy}, {@link RA.isTruthy|isTruthy}
+ * @example
+ *
+ * RA.isFalsy(false); // => true
+ * RA.isFalsy(0); // => true
+ * RA.isFalsy(''); // => true
+ * RA.isFalsy(null); // => true
+ * RA.isFalsy(undefined); // => true
+ * RA.isFalsy(NaN); // => true
+ */
+var isFalsy = (0, _ramda.complement)(_isTruthy["default"]);
+var _default = isFalsy;
+exports["default"] = _default;

package/lib/isFinite.js

@@ -0,0 +1,46 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = exports.isFinitePonyfill = void 0;
+
+var _ramda = require("ramda");
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+var _Number = _interopRequireDefault(require("./internal/ponyfills/Number.isFinite"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var isFinitePonyfill = (0, _ramda.curryN)(1, _Number["default"]);
+/**
+ * Checks whether the passed value is a finite `Number`.
+ *
+ * @func isFinite
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.7.0|v0.7.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotFinite|isNotFinite}
+ * @example
+ *
+ * RA.isFinite(Infinity); //=> false
+ * RA.isFinite(NaN); //=> false
+ * RA.isFinite(-Infinity); //=> false
+ *
+ * RA.isFinite(0); // true
+ * RA.isFinite(2e64); // true
+ *
+ * RA.isFinite('0');  // => false
+ *                    // would've been true with global isFinite('0')
+ * RA.isFinite(null); // => false
+ *                    // would've been true with global isFinite(null)
+ */
+
+exports.isFinitePonyfill = isFinitePonyfill;
+
+var _isFinite = (0, _isFunction["default"])(Number.isFinite) ? (0, _ramda.curryN)(1, (0, _ramda.bind)(Number.isFinite, Number)) : isFinitePonyfill;
+
+var _default = _isFinite;
+exports["default"] = _default;

package/lib/isFloat.js

@@ -0,0 +1,44 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isInteger = _interopRequireDefault(require("./isInteger"));
+
+var _isFinite = _interopRequireDefault(require("./isFinite"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks whether the passed value is a `float`.
+ *
+ * @func isFloat
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.14.0|v1.14.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotFloat|isNotFloat}
+ * @example
+ *
+ * RA.isFloat(0); //=> false
+ * RA.isFloat(1); //=> false
+ * RA.isFloat(-100000); //=> false
+ *
+ * RA.isFloat(0.1);       //=> true
+ * RA.isFloat(Math.PI);   //=> true
+ *
+ * RA.isFloat(NaN);       //=> false
+ * RA.isFloat(Infinity);  //=> false
+ * RA.isFloat(-Infinity); //=> false
+ * RA.isFloat('10');      //=> false
+ * RA.isFloat(true);      //=> false
+ * RA.isFloat(false);     //=> false
+ * RA.isFloat([1]);       //=> false
+ */
+var isFloat = (0, _ramda.both)(_isFinite["default"], (0, _ramda.complement)(_isInteger["default"]));
+var _default = isFloat;
+exports["default"] = _default;

package/lib/isFunction.js

@@ -0,0 +1,36 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isGeneratorFunction = _interopRequireDefault(require("./isGeneratorFunction"));
+
+var _isAsyncFunction = _interopRequireDefault(require("./isAsyncFunction"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Checks if input value is `Function`.
+ *
+ * @func isFunction
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.5.0|v0.5.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isNotFunction|isNotFunction}, {@link RA.isAsyncFunction|isNotAsyncFunction}, {@link RA.isGeneratorFunction|isGeneratorFunction}
+ * @example
+ *
+ * RA.isFunction(function test() { }); //=> true
+ * RA.isFunction(function* test() { }); //=> true
+ * RA.isFunction(async function test() { }); //=> true
+ * RA.isFunction(() => {}); //=> true
+ * RA.isFunction(null); //=> false
+ * RA.isFunction('abc'); //=> false
+ */
+var isFunction = (0, _ramda.anyPass)([(0, _ramda.pipe)(_ramda.type, (0, _ramda.identical)('Function')), _isGeneratorFunction["default"], _isAsyncFunction["default"]]);
+var _default = isFunction;
+exports["default"] = _default;

package/lib/isGeneratorFunction.js

@@ -0,0 +1,40 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var GeneratorFunction = null;
+var legacyCheck = null;
+
+try {
+  GeneratorFunction = new Function('return function* () {}')().constructor; // eslint-disable-line no-new-func
+
+  legacyCheck = (0, _ramda.is)(GeneratorFunction);
+} catch (e) {
+  legacyCheck = _ramda.F;
+}
+/**
+ * Checks if input value is `Generator Function`.
+ *
+ * @func isGeneratorFunction
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/0.5.0|v0.5.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @see {@link RA.isFunction|isFunction}, {@link RA.isAsyncFunction|isAsyncFunction}, {@link RA.isNotGeneratorFunction|isNotGeneratorFunction}
+ * @example
+ *
+ * RA.isGeneratorFunction(function* test() { }); //=> true
+ * RA.isGeneratorFunction(null); //=> false
+ * RA.isGeneratorFunction(function test() { }); //=> false
+ * RA.isGeneratorFunction(() => {}); //=> false
+ */
+
+
+var isGeneratorFunction = (0, _ramda.curryN)(1, (0, _ramda.either)((0, _ramda.pipe)(_ramda.type, (0, _ramda.identical)('GeneratorFunction')), legacyCheck));
+var _default = isGeneratorFunction;
+exports["default"] = _default;