ramda-adjunct 5.0.0 → 5.0.1

package/src/fantasy-land/traits.js

@@ -1,57 +0,0 @@
-import { equals, pathSatisfies } from 'ramda';
-
-import isString from '../isString.js';
-import isNumber from '../isNumber.js';
-import isFunction from '../isFunction.js';
-import { isSameType } from './util.js';
-import * as fl from './mapping.js';
-
-export const functorTrait = {
-  [fl.map](fn) {
-    return this.constructor[fl.of](fn(this.value));
-  },
-};
-
-export const applyTrait = {
-  [fl.ap](applyWithFn) {
-    return applyWithFn.map((fn) => fn(this.value));
-  },
-};
-
-export const setoidTrait = {
-  [fl.equals](setoid) {
-    return isSameType(this, setoid) && equals(this.value, setoid.value);
-  },
-};
-
-export const semigroupTrait = {
-  [fl.concat](semigroup) {
-    let concatenatedValue = this.value;
-
-    if (isString(this.value) || isNumber(this.value)) {
-      concatenatedValue = this.value + semigroup.value;
-    } else if (pathSatisfies(isFunction, ['value', fl.concat], this)) {
-      concatenatedValue = this.value[fl.concat](semigroup.value);
-    } else if (pathSatisfies(isFunction, ['value', 'concat'], this)) {
-      concatenatedValue = this.value.concat(semigroup.value);
-    }
-
-    return this.constructor[fl.of](concatenatedValue);
-  },
-};
-
-export const chainTrait = {
-  [fl.chain](fn) {
-    const newChain = fn(this.value);
-
-    return isSameType(this, newChain) ? newChain : this;
-  },
-};
-
-export const ordTrait = {
-  [fl.lte](ord) {
-    return (
-      isSameType(this, ord) && (this.value < ord.value || this[fl.equals](ord))
-    );
-  },
-};

package/src/fantasy-land/util.js

@@ -1,23 +0,0 @@
-import {
-  useWith,
-  curry,
-  curryN,
-  equals,
-  path,
-  either,
-  complement,
-} from 'ramda';
-
-// type :: Monad a => a -> String
-export const type = either(path(['@@type']), path(['constructor', '@@type']));
-
-// typeEquals :: Monad a => String -> a -> Boolean
-export const typeEquals = curry(
-  (typeIdent, monad) => type(monad) === typeIdent
-);
-
-// isSameType :: (Monad a, Monad b) => a -> b -> Boolean
-export const isSameType = curryN(2, useWith(equals, [type, type]));
-
-// isNotSameType :: (Monad a, Monad b) => a -> b -> Boolean
-export const isNotSameType = complement(isSameType);

package/src/filterIndexed.js

@@ -1,28 +0,0 @@
-import { addIndex, filter } from 'ramda';
-
-/**
- * {@link http://ramdajs.com/docs/#filter|R.filter} function that more closely resembles `Array.prototype.filter`.
- * It takes two new parameters to its callback function: the current index, and the entire list.
- *
- * `filterIndexed` implementation is simple: `
- *  const filterIndexed = R.addIndex(R.filter);
- * `
- *
- * @func filterIndexed
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.31.0|v2.31.0}
- * @category List
- * @typedef Idx = Number
- * @sig Filterable f => ((a, Idx, f a) -> Boolean) -> f a -> f a
- * @param {Function} pred The predicate function
- * @param {Array} list The collection to filter
- * @return {Array} Filterable
- * @see {@link http://ramdajs.com/docs/#addIndex|R.addIndex}, {@link http://ramdajs.com/docs/#filter|R.filter}
- * @example
- *
- * const isValueGtIndex = (val, idx) => val > idx;
- * RA.filterIndexed(isValueGtIndex, [5, 4, 3, 2, 1, 0]); //=> [5, 4, 3]
- */
-const filterIndexed = addIndex(filter);
-
-export default filterIndexed;

package/src/findOr.js

@@ -1,30 +0,0 @@
-import { pipe, curry, find, defaultTo } from 'ramda';
-
-/**
- * Returns the first element of the list which matches the predicate.
- * Returns default value if no element matches or matched element is `null`, `undefined` or `NaN`.
- * Dispatches to the find method of the second argument, if present.
- * Acts as a transducer if a transformer is given in list position.
- *
- * @func findOr
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.32.0|v2.32.0}
- * @category List
- * @sig  a -> (b -> Boolean) -> [b] -> b | a
- * @param {*} defaultValue The default value
- * @param {Function} fn The predicate function used to determine if the element is the desired one.
- * @param {Array} list The array to consider.
- * @return {*} The element found, or the default value.
- * @see {@link http://ramdajs.com/docs/#defaultTo|R.defaultTo}, {@link http://ramdajs.com/docs/#find|R.find}
- * @example
- *
- * RA.findOr(1, isUndefined, [1, 2, undefined]); // => 1
- * RA.findOr(1, val => val === 2, [1, 2, undefined]); // => 2
- * RA.findOr(1, val => val === 3, [1, 2, undefined]); // => 1
- */
-
-const findOr = curry((defaultVal, fn, list) =>
-  pipe(find(fn), defaultTo(defaultVal))(list)
-);
-
-export default findOr;

package/src/flattenDepth.js

@@ -1,39 +0,0 @@
-import { curry } from 'ramda';
-
-import _makeFlat from './internal/makeFlat.js';
-
-const flatten1 = _makeFlat(false);
-
-/**
- * Flattens the list to the specified depth.
- *
- * @func flattenDepth
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.19.0|v2.19.0}
- * @category List
- * @sig Number -> [a] -> [b]
- * @param {!number} depth The maximum recursion depth
- * @param {!Array} list The array to flatten
- * @return {!Array} Returns the new flattened array
- * @see {@link http://ramdajs.com/docs/#flatten|R.flatten}, {@link http://ramdajs.com/docs/#unnest|R.unnest}
- * @example
- *
- * RA.flattenDepth(
- *   2,
- *   [1, [2], [3, [4, 5], 6, [[[7], 8]]], 9, 10]
- * ); //=> [1, 2, 3, 4, 5, 6, [[7], 8], 9, 10];
- */
-const flattenDepth = curry((depth, list) => {
-  let currentDept = depth;
-  let flatList = [...list];
-
-  while (currentDept > 0) {
-    flatList = flatten1(flatList);
-
-    currentDept -= 1;
-  }
-
-  return flatList;
-});
-
-export default flattenDepth;

package/src/flattenPath.js

@@ -1,28 +0,0 @@
-import { pathOr, curry, mergeRight } from 'ramda';
-
-/**
- * Flattens a property path so that its fields are spread out into the provided object.
- * It's like {@link RA.spreadPath|spreadPath}, but preserves object under the property path.
- *
- * @func flattenPath
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.19.0|v1.19.0}
- * @category Object
- * @typedef Idx = String | Int
- * @sig [Idx] -> {k: v} -> {k: v}
- * @param {!Array.<string|number>} path The property path to flatten
- * @param {!Object} obj The provided object
- * @return {!Object} The flattened object
- * @see {@link RA.flattenProp|flattenProp}, {@link RA.spreadPath|spreadPath}
- * @example
- *
- * RA.flattenPath(
- *   ['b1', 'b2'],
- *   { a: 1, b1: { b2: { c: 3, d: 4 } } }
- * ); // => { a: 1, c: 3, d: 4, b1: { b2: { c: 3, d: 4 } } };
- */
-const flattenPath = curry((path, obj) =>
-  mergeRight(obj, pathOr({}, path, obj))
-);
-
-export default flattenPath;

package/src/flattenProp.js

@@ -1,28 +0,0 @@
-import { of, curry } from 'ramda';
-
-import flattenPath from './flattenPath.js';
-
-/**
- * Flattens a property so that its fields are spread out into the provided object.
- * It's like {@link RA.spreadProp|spreadProp}, but preserves object under the property path.
- *
- * @func flattenProp
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/1.19.0|v1.19.0}
- * @category Object
- * @typedef Idx = String | Int
- * @sig [Idx] -> {k: v} -> {k: v}
- * @param {!string|number} prop The property to flatten
- * @param {!Object} obj The provided object
- * @return {!Object} The flattened object
- * @see {@link RA.flattenPath|flattenPath}, {@link RA.spreadProp|spreadProp}
- * @example
- *
- * RA.flattenProp(
- *   'b',
- *   { a: 1, b: { c: 3, d: 4 } }
- * ); // => { a: 1, c: 3, d: 4, b: { c: 3, d: 4 } };
- */
-const flattenProp = curry((prop, obj) => flattenPath(of(Array, prop), obj));
-
-export default flattenProp;

package/src/floor.js

@@ -1,27 +0,0 @@
-import { bind, curryN } from 'ramda';
-
-/**
- * Returns the largest integer less than or equal to a given number.
- *
- * Note: floor(null) returns integer 0 and do not give a NaN error.
- *
- * @func floor
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.15.0|v2.15.0}
- * @category Math
- * @sig Number -> Number
- * @param {number} number The number to floor
- * @return {number} A number representing the largest integer less than or equal to the specified number
- * @example
- *
- * RA.floor(45.95); //=> 45
- * RA.floor(45.05); //=> 45
- * RA.floor(4); //=> 4
- * RA.floor(-45.05); //=> -46
- * RA.floor(-45.95); //=> -46
- * RA.floor(null); //=> 0
- */
-
-const floor = curryN(1, bind(Math.floor, Math));
-
-export default floor;

package/src/fnull.js

@@ -1,38 +0,0 @@
-import { isNil, curryN, curry, apply } from 'ramda';
-
-import defaultWhen from './defaultWhen.js';
-import mapIndexed from './mapIndexed.js';
-
-/**
- * Returns a function which is called with the given arguments. If any of the given arguments are null or undefined,
- * the corresponding default value for that argument is used instead.
- *
- * @func fnull
- * @memberOf RA
- * @category Function
- * @sig (a ... -> b) -> [c] -> a ... | c -> b
- * @param {Function} function to be executed
- * @param {Array} defaults default arguments
- * @return {Function} will apply provided arguments or default ones
- * @example
- *
- * const addDefaults = RA.fnull((a, b) => a + b, [4, 5])
- *
- * addDefaults(1, 2); // => 3
- * addDefaults(null, 2); // => 6
- * addDefaults(2, null); // => 7
- * addDefaults(undefined, undefined); // => 9
- */
-
-const fnull = curry((fn, defaults) =>
-  curryN(fn.length, (...args) => {
-    const argsWithDefaults = mapIndexed(
-      (val, idx) => defaultWhen(isNil, defaults[idx], val),
-      args
-    );
-
-    return apply(fn, argsWithDefaults);
-  })
-);
-
-export default fnull;

package/src/inRange.js

@@ -1,34 +0,0 @@
-import { ifElse, curry, useWith, both, gte, lte, gt } from 'ramda';
-
-const inRangeImp = ifElse(
-  gte,
-  () => {
-    throw new Error(
-      'low must not be greater than high in inRange(low, high, value)'
-    );
-  },
-  useWith(both, [lte, gt])
-);
-
-/**
- * Checks if `value` is between `low` and up to but not including `high`.
- *
- * @func inRange
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/2.7.0|v2.7.0}
- * @category Relation
- * @sig Number -> Number -> Number -> Boolean
- * @param {number} low Start of the range
- * @param {number} high The end of the range
- * @param {number} value The value to test
- * @return {boolean}
- * @throws {Error} When `low` is greater than or equal to `high`
- * @example
- *
- * RA.inRange(0, 5, 3); //=> true
- * RA.inRange(0, 5, 0); //=> true
- * RA.inRange(0, 5, 4); //=> true
- * RA.inRange(0, 5, 5); //=> false
- * RA.inRange(0, 5, -1); //=> false
- */
-export default curry((low, high, value) => inRangeImp(low, high)(value));

package/src/included.js

@@ -1,28 +0,0 @@
-import { flip, includes } from 'ramda';
-
-/**
- * Returns true if the specified value is equal, in R.equals terms,
- * to at least one element of the given list or false otherwise.
- * Given list can be a string.
- *
- * Like {@link http://ramdajs.com/docs/#includes|R.includes} but with argument order reversed.
- *
- * @func included
- * @memberOf RA
- * @since {@link https://char0n.github.io/ramda-adjunct/3.0.0|v3.0.0}
- * @category List
- * @sig [a] -> a -> Boolean
- * @param {Array|String} list The list to consider
- * @param {*} a The item to compare against
- * @return {boolean} Returns Boolean `true` if an equivalent item is in the list or `false` otherwise
- * @see {@link http://ramdajs.com/docs/#includes|R.includes}
- * @example
- *
- * RA.included([1, 2, 3], 3); //=> true
- * RA.included([1, 2, 3], 4); //=> false
- * RA.included([{ name: 'Fred' }], { name: 'Fred' }); //=> true
- * RA.included([[42]], [42]); //=> true
- */
-const included = flip(includes);
-
-export default included;

package/src/index.js

@@ -1,241 +0,0 @@
-/**
- * @namespace RA
- */
-
-// Type
-export { default as isNotUndefined } from './isNotUndefined.js';
-export { default as isUndefined } from './isUndefined.js';
-export { default as isNull } from './isNull.js';
-export { default as isNotNull } from './isNotNull.js';
-export { default as isNotNil } from './isNotNil.js';
-export { default as isArray } from './isArray.js';
-export { default as isIterable } from './isIterable.js';
-export { default as isEmptyArray } from './isEmptyArray.js';
-export { default as isNotArray } from './isNotArray.js';
-export { default as isNonEmptyArray } from './isNonEmptyArray.js';
-export { default as isBoolean } from './isBoolean.js';
-export { default as isNotBoolean } from './isNotBoolean.js';
-export { default as isNilOrEmpty } from './isNilOrEmpty.js';
-export { default as isString } from './isString.js';
-export { default as isEmptyString } from './isEmptyString.js';
-export { default as isNotString } from './isNotString.js';
-export { default as isNonEmptyString } from './isNonEmptyString.js';
-export { default as isArrayLike } from './isArrayLike.js';
-export { default as isNotArrayLike } from './isNotArrayLike.js';
-export { default as isGeneratorFunction } from './isGeneratorFunction.js';
-export { default as isNotGeneratorFunction } from './isNotGeneratorFunction.js';
-export { default as isAsyncFunction } from './isAsyncFunction.js';
-export { default as isNotAsyncFunction } from './isNotAsyncFunction.js';
-export { default as isFunction } from './isFunction.js';
-export { default as isNotFunction } from './isNotFunction.js';
-export { default as isObj } from './isObj.js';
-export { default as isObject } from './isObj.js'; // alias of isObj
-export { default as isNotObj } from './isNotObj.js';
-export { default as isNotObject } from './isNotObj.js'; // alias of isNotObj
-export { default as isObjLike } from './isObjLike.js';
-export { default as isObjectLike } from './isObjLike.js'; // alias of isObjLike
-export { default as isNotObjLike } from './isNotObjLike.js';
-export { default as isNotObjectLike } from './isNotObjLike.js'; // alias of isNotObjLike
-export { default as isPlainObj } from './isPlainObj.js';
-export { default as isPlainObject } from './isPlainObj.js';
-export { default as isNotPlainObj } from './isNotPlainObj.js';
-export { default as isNotPlainObject } from './isNotPlainObj.js'; // alias of isNotPlainObj
-export { default as isDate } from './isDate.js';
-export { default as isNotDate } from './isNotDate.js';
-export { default as isValidDate } from './isValidDate.js';
-export { default as isNotValidDate } from './isNotValidDate.js';
-export { default as isInvalidDate } from './isNotValidDate.js'; // alias of isNotValidDate
-export { default as isNumber } from './isNumber.js';
-export { default as isNotNumber } from './isNotNumber.js';
-export { default as isPositive } from './isPositive.js';
-export { default as isNegative } from './isNegative.js';
-export { default as isPositiveZero } from './isPositiveZero.js';
-export { default as isNegativeZero } from './isNegativeZero.js';
-export { default as isNotNilOrEmpty } from './isNotNilOrEmpty.js';
-export { default as isNonPositive } from './isNonPositive.js';
-export { default as isNonNegative } from './isNonNegative.js';
-export { default as isMap } from './isMap.js';
-export { default as isNotMap } from './isNotMap.js';
-export { default as isNaN } from './isNaN.js';
-export { default as isNotNaN } from './isNotNaN.js';
-export { default as isFinite } from './isFinite.js';
-export { default as isNotFinite } from './isNotFinite.js';
-export { default as isInteger } from './isInteger.js';
-export { default as isInteger32 } from './isInteger32.js';
-export { default as isInt32 } from './isInteger32.js'; // alias of isInteger32
-export { default as isUinteger32 } from './isUinteger32.js';
-export { default as isUint32 } from './isUinteger32.js'; // alias of isUinteger32
-export { default as isNotInteger } from './isNotInteger.js';
-export { default as isBigInt } from './isBigInt.js';
-export { default as isFloat } from './isFloat.js';
-export { default as isNotFloat } from './isNotFloat.js';
-export { default as isValidNumber } from './isValidNumber.js';
-export { default as isNotValidNumber } from './isNotValidNumber.js';
-export { default as isOdd } from './isOdd.js';
-export { default as isEven } from './isEven.js';
-export { default as isPair } from './isPair.js';
-export { default as isNotPair } from './isNotPair.js';
-export { default as isThenable } from './isThenable.js';
-export { default as isPromise } from './isPromise.js';
-export { default as isTrue } from './isTrue.js';
-export { default as isFalse } from './isFalse.js';
-export { default as isTruthy } from './isTruthy.js';
-export { default as isFalsy } from './isFalsy.js';
-export { default as isRegExp } from './isRegExp.js';
-export { default as isNotRegExp } from './isNotRegExp.js';
-export { default as isSet } from './isSet.js';
-export { default as isNotSet } from './isNotSet.js';
-export { default as isSparseArray } from './isSparseArray.js';
-export { default as isSymbol } from './isSymbol.js';
-export { default as isSafeInteger } from './isSafeInteger.js';
-export { default as isIndexed } from './isIndexed.js';
-export { default as isError } from './isError.js';
-export { default as isNaturalNumber } from './isNaturalNumber.js';
-export { default as isPrimitive } from './isPrimitive.js';
-export { default as isNotPrimitive } from './isNotPrimitive.js';
-export { default as isSentinelValue } from './isSentinelValue.js';
-export { default as isBlank } from './isBlank.js';
-// Function
-export { default as stubUndefined } from './stubUndefined.js';
-export { default as stubNull } from './stubNull.js';
-export { default as stubObj } from './stubObj.js';
-export { default as stubObject } from './stubObj.js';
-export { default as stubString } from './stubString.js';
-export { default as stubArray } from './stubArray.js';
-export { default as noop } from './noop.js';
-export { default as liftFN } from './liftFN.js';
-export { default as liftF } from './liftF.js';
-export { default as cata } from './cata.js';
-export { default as weave } from './weave.js';
-export { default as weaveLazy } from './weaveLazy.js';
-export { default as curryRightN } from './curryRightN.js';
-export { default as curryRight } from './curryRight.js';
-export { default as allP } from './allP.js';
-export { default as catchP } from './catchP.js';
-export { default as noneP } from './noneP.js';
-export { default as resolveP } from './resolveP.js';
-export { default as rejectP } from './rejectP.js';
-export { default as delayP } from './delayP.js';
-export { default as thenCatchP } from './thenCatchP.js';
-export { default as allSettledP } from './allSettledP.js';
-export { default as Y } from './Y.js';
-export { default as seq } from './seq.js';
-export { default as sequencing } from './seq.js';
-export { default as dispatch } from './dispatch.js';
-export { default as async } from './async.js';
-export { default as anyP } from './anyP.js';
-export { default as firstP } from './anyP.js'; // alias of anyP
-export { default as lastP } from './lastP.js';
-export { default as fnull } from './fnull.js';
-// List
-export { default as mapIndexed } from './mapIndexed.js';
-export { default as reduceIndexed } from './reduceIndexed.js';
-export { default as filterIndexed } from './filterIndexed.js';
-export { default as pickIndexes } from './pickIndexes.js';
-export { default as list } from './list.js';
-export { default as ensureArray } from './ensureArray.js';
-export { default as concatAll } from './concatAll.js';
-export { default as concatRight } from './concatRight.js';
-export { default as reduceP } from './reduceP.js';
-export { default as reduceRightP } from './reduceRightP.js';
-export { default as sliceFrom } from './sliceFrom.js';
-export { default as sliceTo } from './sliceTo.js';
-export { default as omitIndexes } from './omitIndexes.js';
-export { default as compact } from './compact.js';
-export { default as appendFlipped } from './appendFlipped.js';
-export { default as included } from './included.js';
-export { default as move } from './move.js';
-export { default as lengthGt } from './lengthGt.js';
-export { default as lengthLt } from './lengthLt.js';
-export { default as lengthGte } from './lengthGte.js';
-export { default as lengthLte } from './lengthLte.js';
-export { default as lengthEq } from './lengthEq.js';
-export { default as lengthNotEq } from './lengthNotEq.js';
-export { default as allEqual } from './allEqual.js';
-export { default as repeatStr } from './repeatStr.js';
-export { default as allIdentical } from './allIdentical.js';
-export { default as allIdenticalTo } from './allIdenticalTo.js';
-export { default as allEqualTo } from './allEqualTo.js';
-export { default as flattenDepth } from './flattenDepth.js';
-export { default as toArray } from './toArray.js';
-export { default as allUnique } from './allUnique.js';
-export { default as notAllUnique } from './notAllUnique.js';
-export { default as sortByProps } from './sortByProps.js';
-export { default as sortByProp } from './sortByProp.js';
-export { default as sortByPaths } from './sortByPaths.js';
-export { default as skipTake } from './skipTake.js';
-export { default as rangeStep } from './rangeStep.js';
-export { default as findOr } from './findOr.js';
-// Object
-export { default as invoke } from './invoke.js';
-export { default as invokeArgs } from './invokeArgs.js';
-export { default as paths } from './paths.js';
-export { default as renameKey } from './renameKey.js';
-export { default as renameKeys } from './renameKeys.js';
-export { default as renameKeysWith } from './renameKeysWith.js';
-export { default as renameKeyWith } from './renameKeyWith.js';
-export { default as copyKeys } from './copyKeys.js';
-export { default as mergeProps } from './mergeProps.js';
-export { default as mergePaths } from './mergePaths.js';
-export { default as mergeProp } from './mergeProp.js';
-export { default as mergePath } from './mergePath.js';
-export { default as omitBy } from './omitBy.js';
-export { default as pathOrLazy } from './pathOrLazy.js';
-export { default as viewOr } from './viewOr.js';
-export { default as spreadProp } from './spreadProp.js';
-export { default as spreadPath } from './spreadPath.js';
-export { default as flattenProp } from './flattenProp.js';
-export { default as flattenPath } from './flattenPath.js';
-export { default as unzipObjWith } from './unzipObjWith.js';
-export { default as zipObjWith } from './zipObjWith.js';
-export { default as isPrototypeOf } from './isPrototypeOf.js';
-// Relation
-export { default as lensEq } from './lensEq.js';
-export { default as lensNotEq } from './lensNotEq.js';
-export { default as lensSatisfies } from './lensSatisfies.js';
-export { default as lensNotSatisfy } from './lensNotSatisfy.js';
-export { default as lensTraverse } from './lensTraverse.js';
-export { default as lensIso } from './lensIso.js';
-export { default as propNotEq } from './propNotEq.js';
-export { default as pathNotEq } from './pathNotEq.js';
-export { default as inRange } from './inRange.js';
-export { default as notEqual } from './notEqual.js';
-export { default as overlaps } from './overlaps.js';
-// Logic
-export { default as defaultWhen } from './defaultWhen.js';
-export { default as notBoth } from './notBoth.js';
-export { default as nand } from './nand.js';
-export { default as neither } from './neither.js';
-export { default as nor } from './nor.js';
-export { default as notAllPass } from './notAllPass.js';
-export { default as nonePass } from './nonePass.js';
-export { default as argsPass } from './argsPass.js';
-export { default as dropArgs } from './dropArgs.js';
-// Math
-export { default as round } from './round.js';
-export { default as ceil } from './ceil.js';
-export { default as divideNum } from './divideNum.js';
-export { default as floor } from './floor.js';
-export { default as trunc } from './trunc.js';
-export { default as sign } from './sign.js';
-export { default as subtractNum } from './subtractNum.js';
-export { default as toInteger32 } from './toInteger32.js';
-export { default as toInt32 } from './toInteger32.js'; // alias of toInteger32
-export { default as toUinteger32 } from './toUinteger32.js';
-export { default as toUint32 } from './toUinteger32.js'; // alias of to toUinteger32
-export { default as toNumber } from './toNumber.js';
-// String
-export { default as replaceAll } from './replaceAll.js';
-export { default as escapeRegExp } from './escapeRegExp.js';
-export { default as trimStart } from './trimStart.js';
-export { default as trimLeft } from './trimStart.js'; // alias of trimStart
-export { default as trimEnd } from './trimEnd.js';
-export { default as trimRight } from './trimEnd.js'; // alias of trimEnd
-export { default as trimCharsEnd } from './trimCharsEnd.js';
-export { default as trimCharsStart } from './trimCharsStart.js';
-export { default as padCharsStart } from './padCharsStart.js';
-export { default as padCharsEnd } from './padCharsEnd.js';
-export { default as padEnd } from './padEnd.js';
-export { default as padStart } from './padStart.js';
-// Types
-export { default as Identity } from './fantasy-land/Identity.js';

package/src/internal/ap.js

@@ -1,30 +0,0 @@
-import { ap as apR, curryN, pathSatisfies, both, either } from 'ramda';
-
-import isFunction from '../isFunction.js';
-import * as fl from '../fantasy-land/mapping.js';
-
-const isFunctor = either(
-  pathSatisfies(isFunction, ['map']),
-  pathSatisfies(isFunction, [fl.map])
-);
-const isApply = both(
-  isFunctor,
-  either(pathSatisfies(isFunction, ['ap']), pathSatisfies(isFunction, [fl.ap]))
-);
-
-const ap = curryN(2, (applyF, applyX) => {
-  // return original ramda `ap` if not Apply spec
-  if (!isApply(applyF) || !isApply(applyX)) {
-    return apR(applyF, applyX);
-  }
-
-  try {
-    // new version of `ap` starting from ramda version > 0.23.0
-    return applyF.ap(applyX);
-  } catch (e) {
-    // old version of `ap` till ramda version <= 0.23.0
-    return applyX.ap(applyF);
-  }
-});
-
-export default ap;

package/src/internal/compareLength.js

@@ -1,7 +0,0 @@
-import { curry, compose, length } from 'ramda';
-
-const compareLength = curry((comparator, value, list) =>
-  compose(comparator(value), length)(list)
-);
-
-export default compareLength;

package/src/internal/isCoercible.js

@@ -1,12 +0,0 @@
-import { both, hasIn } from 'ramda';
-
-import isObj from '../isObj.js';
-import isSymbol from '../isSymbol.js';
-import neither from '../neither.js';
-
-const isCoercible = neither(
-  isSymbol,
-  both(isObj, neither(hasIn('toString'), hasIn('valueOf')))
-);
-
-export default isCoercible;