ramda-adjunct 2.34.0

package/es/internal/ponyfills/String.replaceAll.js

@@ -0,0 +1,34 @@
+import { replace } from 'ramda';
+import isRegExp from '../../isRegExp';
+import escapeRegExp from '../../escapeRegExp';
+
+var checkArguments = function checkArguments(searchValue, replaceValue, str) {
+  if (str == null || searchValue == null || replaceValue == null) {
+    throw TypeError('Input values must not be `null` or `undefined`');
+  }
+};
+
+var checkValue = function checkValue(value, valueName) {
+  if (typeof value !== 'string') {
+    if (!(value instanceof String)) {
+      throw TypeError("`".concat(valueName, "` must be a string"));
+    }
+  }
+};
+
+var checkSearchValue = function checkSearchValue(searchValue) {
+  if (typeof searchValue !== 'string' && !(searchValue instanceof String) && !(searchValue instanceof RegExp)) {
+    throw TypeError('`searchValue` must be a string or an regexp');
+  }
+};
+
+var replaceAll = function replaceAll(searchValue, replaceValue, str) {
+  checkArguments(searchValue, replaceValue, str);
+  checkValue(str, 'str');
+  checkValue(replaceValue, 'replaceValue');
+  checkSearchValue(searchValue);
+  var regexp = new RegExp(isRegExp(searchValue) ? searchValue : escapeRegExp(searchValue), 'g');
+  return replace(regexp, replaceValue, str);
+};
+
+export default replaceAll;

package/es/internal/ponyfills/String.trimEnd.js

@@ -0,0 +1,3 @@
+import { replace } from 'ramda';
+var trimStart = replace(/[\s\uFEFF\xA0]+$/, '');
+export default trimStart;

package/es/internal/ponyfills/String.trimStart.js

@@ -0,0 +1,3 @@
+import { replace } from 'ramda';
+var trimStart = replace(/^[\s\uFEFF\xA0]+/, '');
+export default trimStart;

package/es/invoke.js

@@ -0,0 +1,20 @@
+import { __ } from 'ramda';
+import invokeArgs from './invokeArgs';
+/**
+ * Invokes the method at path of object.
+ *
+ * @func invoke
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.31.0|v2.31.0}
+ * @category Object
+ * @sig Array -> Object -> *
+ * @param {Array.<string|number>} path The path of the method to invoke
+ * @param {Object} obj The object to query
+ * @return {*}
+ * @example
+ *
+ * RA.invoke(['random'], Math); //=> 0.5113253820009047
+ */
+
+var invoke = invokeArgs(__, [], __);
+export default invoke;

package/es/invokeArgs.js

@@ -0,0 +1,30 @@
+import { curryN, path, apply, init, bind } from 'ramda';
+import isNotFunction from './isNotFunction';
+import isEmptyArray from './isEmptyArray';
+/**
+ * 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 = curryN(3, function (mpath, args, obj) {
+  var method = path(mpath, obj);
+  var context = path(init(mpath), obj);
+  if (isNotFunction(method)) return undefined;
+  if (isEmptyArray(mpath)) return undefined;
+  var boundMethod = bind(method, context);
+  return apply(boundMethod, args);
+});
+export default invokeArgs;

package/es/isArray.js

@@ -0,0 +1,22 @@
+import { curryN, pipe, type, identical } from 'ramda';
+import isFunction from './isFunction';
+/**
+ * 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 = curryN(1, isFunction(Array.isArray) ? Array.isArray : pipe(type, identical('Array')));
+export default isArray;

package/es/isArrayLike.js

@@ -0,0 +1,87 @@
+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); }
+
+import { has, curryN } from 'ramda';
+import isArray from './isArray';
+import isString from './isString';
+/* 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 = curryN(1, function (val) {
+  if (isArray(val)) {
+    return true;
+  }
+
+  if (!val) {
+    return false;
+  }
+
+  if (isString(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 has(0, val) && has(val.length - 1, val);
+  }
+
+  return false;
+});
+export 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.
+*/

package/es/isAsyncFunction.js

@@ -0,0 +1,22 @@
+import { pipe, type, identical, curryN } from '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 = curryN(1, pipe(type, identical('AsyncFunction')));
+export default isAsyncFunction;

package/es/isBigInt.js

@@ -0,0 +1,23 @@
+import { type, pipe, identical, curryN } from '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 = curryN(1, pipe(type, identical('BigInt')));
+export default isBigInt;

package/es/isBoolean.js

@@ -0,0 +1,21 @@
+import { type, identical, pipe, curryN } from '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 = curryN(1, pipe(type, identical('Boolean')));
+export default isBoolean;

package/es/isDate.js

@@ -0,0 +1,20 @@
+import { type, identical, pipe, curryN } from '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 = curryN(1, pipe(type, identical('Date')));
+export default isDate;

package/es/isEmptyArray.js

@@ -0,0 +1,26 @@
+import { both, isEmpty } from 'ramda';
+import isArray from './isArray';
+/**
+ * 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 = both(isArray, isEmpty);
+export default isEmptyArray;

package/es/isEmptyString.js

@@ -0,0 +1,27 @@
+import { equals } from '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 = equals('');
+export default isEmptyString;

package/es/isError.js

@@ -0,0 +1,20 @@
+import { type, identical, pipe, curryN } from '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 = curryN(1, pipe(type, identical('Error')));
+export default isError;

package/es/isEven.js

@@ -0,0 +1,29 @@
+import { both, complement, curryN } from 'ramda';
+import isInteger from './isInteger';
+import isOdd from './isOdd';
+/**
+ * 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 = curryN(1, both(isInteger, complement(isOdd)));
+export default isEven;

package/es/isFalse.js

@@ -0,0 +1,29 @@
+import { identical } from '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 = identical(false);
+export default isFalse;

package/es/isFalsy.js

@@ -0,0 +1,26 @@
+import { complement } from 'ramda';
+import isTruthy from './isTruthy';
+/**
+ * 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 = complement(isTruthy);
+export default isFalsy;

package/es/isFinite.js

@@ -0,0 +1,33 @@
+import { bind, curryN } from 'ramda';
+import isFunction from './isFunction';
+import ponyfill from './internal/ponyfills/Number.isFinite';
+export var isFinitePonyfill = curryN(1, ponyfill);
+/**
+ * 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)
+ */
+
+var _isFinite = isFunction(Number.isFinite) ? curryN(1, bind(Number.isFinite, Number)) : isFinitePonyfill;
+
+export default _isFinite;

package/es/isFloat.js

@@ -0,0 +1,34 @@
+import { complement, both } from 'ramda';
+import isInteger from './isInteger';
+import isFinite from './isFinite';
+/**
+ * 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 = both(isFinite, complement(isInteger));
+export default isFloat;

package/es/isFunction.js

@@ -0,0 +1,26 @@
+import { anyPass, type, pipe, identical } from 'ramda';
+import isGeneratorFunction from './isGeneratorFunction';
+import isAsyncFunction from './isAsyncFunction';
+/**
+ * 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 = anyPass([pipe(type, identical('Function')), isGeneratorFunction, isAsyncFunction]);
+export default isFunction;

package/es/isGeneratorFunction.js

@@ -0,0 +1,33 @@
+import { type, is, F as stubFalse, either, identical, pipe, curryN } from 'ramda';
+var GeneratorFunction = null;
+var legacyCheck = null;
+
+try {
+  GeneratorFunction = new Function('return function* () {}')().constructor; // eslint-disable-line no-new-func
+
+  legacyCheck = is(GeneratorFunction);
+} catch (e) {
+  legacyCheck = stubFalse;
+}
+/**
+ * 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 = curryN(1, either(pipe(type, identical('GeneratorFunction')), legacyCheck));
+export default isGeneratorFunction;

package/es/isIndexed.js

@@ -0,0 +1,21 @@
+import { either, curryN } from 'ramda';
+import isArray from './isArray';
+import isString from './isString';
+/**
+ * Determine if input value is an indexed data type.
+ *
+ * @func isIndexed
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.26.0|v2.26.0}
+ * @category Type
+ * @sig * -> Boolean
+ * @param {*} val The value to test
+ * @return {boolean}
+ * @example
+ *
+ * RA.isIndexed([1]) //=> true
+ * RA.isIndexed('test') //=> true
+ */
+
+var isIndexed = curryN(1, either(isString, isArray));
+export default isIndexed;

package/es/isInteger.js

@@ -0,0 +1,35 @@
+import { bind, curryN } from 'ramda';
+import isFunction from './isFunction';
+import ponyfill from './internal/ponyfills/Number.isInteger';
+export var isIntegerPonyfill = curryN(1, ponyfill);
+/**
+ * Checks whether the passed value is an `integer`.
+ *
+ * @func isInteger
+ * @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.isNotInteger|isNotInteger}
+ * @example
+ *
+ * RA.isInteger(0); //=> true
+ * RA.isInteger(1); //=> true
+ * RA.isInteger(-100000); //=> true
+ *
+ * RA.isInteger(0.1);       //=> false
+ * RA.isInteger(Math.PI);   //=> false
+ *
+ * RA.isInteger(NaN);       //=> false
+ * RA.isInteger(Infinity);  //=> false
+ * RA.isInteger(-Infinity); //=> false
+ * RA.isInteger('10');      //=> false
+ * RA.isInteger(true);      //=> false
+ * RA.isInteger(false);     //=> false
+ * RA.isInteger([1]);       //=> false
+ */
+
+var isInteger = isFunction(Number.isInteger) ? curryN(1, bind(Number.isInteger, Number)) : isIntegerPonyfill;
+export default isInteger;