ramda-adjunct 2.34.0

package/lib/move.js

@@ -0,0 +1,31 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns a new list with the item at the position `fromIdx` moved to the position `toIdx`. If the
+ * `toIdx` is out of the `list` range, the item will be placed at the last position of the `list`.
+ * When negative indices are provided, the behavior of the move is unspecified.
+ *
+ * @func move
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
+ * @category List
+ * @sig Number -> Number -> [a] -> [a]
+ * @param {number} fromIdx The position of item to be moved
+ * @param {number} toIdx The position of item after move
+ * @param {Array} list The list containing the item to be moved
+ * @return {Array}
+ * @example
+ *
+ * const list = ['a', 'b', 'c', 'd', 'e'];
+ * RA.move(1, 3, list) //=> ['a', 'c', 'd', 'b', 'e']
+ */
+var move = (0, _ramda.curry)(function (fromIdx, toIdx, list) {
+  return (0, _ramda.compose)((0, _ramda.insert)(toIdx, (0, _ramda.nth)(fromIdx, list)), (0, _ramda.remove)(fromIdx, 1))(list);
+});
+var _default = move;
+exports["default"] = _default;

package/lib/nand.js

@@ -0,0 +1,33 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns false if both arguments are truthy; true otherwise.
+ *
+ * @func nand
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.19.0|v2.19.0}
+ * @category Logic
+ * @sig a -> b -> Boolean
+ * @param {*} a
+ * @param {*} b
+ * @return {Boolean} false if both arguments are truesy
+ * @example
+ *
+ * RA.nand(true, true); //=> false
+ * RA.nand(false, true); //=> true
+ * RA.nand(true, false); //=> true
+ * RA.nand(false, false); //=> true
+ * RA.nand(1.0, 1.0); //=> false
+ * RA.nand(1.0, 0); //=> true
+ * RA.nand(0, 1.0); //=> true
+ * RA.nand(0, 0); //=> true
+ */
+var nand = (0, _ramda.complement)(_ramda.and); // eslint-disable-line ramda/complement-simplification
+
+var _default = nand;
+exports["default"] = _default;

package/lib/neither.js

@@ -0,0 +1,45 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/* eslint-disable max-len */
+
+/**
+ * A function which calls the two provided functions and returns the complement of `||`ing the
+ * results.
+ * It returns false if the first function is truth-y and the complement of the second function
+ * otherwise. Note that this is short-circuited, meaning that the second function will not be
+ * invoked if the first returns a truth-y value. In short it will return true if neither predicate
+ * returns true.
+ *
+ * In addition to functions, `RA.neither` also accepts any fantasy-land compatible
+ * applicative functor.
+ *
+ * @func neither
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.3.0|v2.3.0}
+ * @category Logic
+ * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)
+ * @param {Function} f A predicate
+ * @param {Function} g Another predicate
+ * @return {Function} Returns a function that applies its arguments to `f` and `g` and returns the complement of `||`ing their outputs together.
+ * @see {@link http://ramdajs.com/docs/#either|R.either}, {@link http://ramdajs.com/docs/#or|R.or}
+ * @example
+ *
+ * const gt10 = R.gt(R.__, 10)
+ * const even = (x) => x % 2 === 0;
+ * const f = RA.neither(gt10, even);
+ *
+ * f(12); //=> false
+ * f(8); //=> false
+ * f(11); //=> false
+ * f(9); //=> true
+ */
+
+/* eslint-enable max-len */
+var neither = (0, _ramda.curry)((0, _ramda.compose)(_ramda.complement, _ramda.either));
+var _default = neither;
+exports["default"] = _default;

package/lib/noneP.js

@@ -0,0 +1,39 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _allP = _interopRequireDefault(require("./allP"));
+
+var _rejectP = _interopRequireDefault(require("./rejectP"));
+
+var _resolveP = _interopRequireDefault(require("./resolveP"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Returns a Promise that is resolved with an array of reasons when all of the provided Promises reject, or rejected when any Promise is resolved.
+ * This pattern is like allP, but fulfillments and rejections are transposed - rejections become the fulfillment values and vice versa.
+ *
+ * @func noneP
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category Function
+ * @sig [Promise a] -> Promise [a]
+ * @param {Iterable.<*>} iterable An iterable object such as an Array or String
+ * @return {Promise} A Promise that is resolved with a list of rejection reasons if all Promises are rejected, or a Promise that is rejected with the fulfillment value of the first Promise that resolves.
+ * @see {@link RA.allP|allP}
+ * @example
+ *
+ * RA.noneP([Promise.reject('hello'), Promise.reject('world')]); //=> Promise(['hello', 'world'])
+ * RA.noneP([]); //=> Promise([])
+ * RA.noneP([Promise.reject(), Promise.resolve('hello world')]); //=> Promise('hello world')
+ * RA.noneP([Promise.reject(), 'hello world']); //=> Promise('hello world')
+ */
+var noneP = (0, _ramda.curryN)(1, (0, _ramda.pipe)((0, _ramda.map)(_resolveP["default"]), (0, _ramda.map)(function (p) {
+  return p.then(_rejectP["default"], _resolveP["default"]);
+}), _allP["default"]));
+var _default = noneP;
+exports["default"] = _default;

package/lib/nonePass.js

@@ -0,0 +1,37 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Takes a list of predicates and returns a predicate that returns true for a given list of
+ * arguments if none of the provided predicates are satisfied by those arguments. It is the
+ * complement of Ramda's anyPass.
+ *
+ * The function returned is a curried function whose arity matches that of the
+ * highest-arity predicate.
+ *
+ * @func nonePass
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.5.0|v2.5.0}
+ * @category Logic
+ * @sig [(*... -> Boolean)] -> (*... -> Boolean)
+ * @param {Array} predicates An array of predicates to check
+ * @return {Function} The combined predicate
+ * @see {@link http://ramdajs.com/docs/#anyPass|R.anyPass}
+ * @example
+ *
+ * const gt10 = R.gt(R.__, 10)
+ * const even = (x) => x % 2 === 0;
+ * const f = RA.nonePass([gt10, even]);
+ *
+ * f(12); //=> false
+ * f(8); //=> false
+ * f(11); //=> false
+ * f(9); //=> true
+ */
+var nonePass = (0, _ramda.curryN)(1, (0, _ramda.compose)(_ramda.complement, _ramda.anyPass));
+var _default = nonePass;
+exports["default"] = _default;

package/lib/noop.js

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _stubUndefined = _interopRequireDefault(require("./stubUndefined"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * A function that performs no operations.
+ *
+ * @func noop
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.0.0|v1.0.0}
+ * @category Function
+ * @sig ... -> undefined
+ * @return {undefined}
+ * @example
+ *
+ * RA.noop(); //=> undefined
+ * RA.noop(1, 2, 3); //=> undefined
+ */
+var noop = (0, _ramda.always)((0, _stubUndefined["default"])());
+var _default = noop;
+exports["default"] = _default;

package/lib/nor.js

@@ -0,0 +1,34 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns true if both arguments are falsy; false otherwise.
+ *
+ * @func nor
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.20.0|v2.20.0}
+ * @category Logic
+ * @sig a -> b -> a ⊽ b
+ * @param {*} a
+ * @param {*} b
+ * @return {boolean} true if both arguments are falsy
+ * @see {@link RA.neither|neither}
+ * @example
+ *
+ * RA.nor(true, true); //=> false
+ * RA.nor(false, true); //=> false
+ * RA.nor(true, false); //=> false
+ * RA.nor(false, false); //=> true
+ * RA.nor(1, 1); //=> false
+ * RA.nor(1, 0); //=> false
+ * RA.nor(0, 1); //=> false
+ * RA.nor(0, 0); //=> true
+ */
+var nor = (0, _ramda.complement)(_ramda.or); // eslint-disable-line ramda/complement-simplification
+
+var _default = nor;
+exports["default"] = _default;

package/lib/notAllPass.js

@@ -0,0 +1,37 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Takes a list of predicates and returns a predicate that returns true for a given list of
+ * arguments if one or more of the provided predicates is not satisfied by those arguments. It is
+ * the complement of Ramda's allPass.
+ *
+ * The function returned is a curried function whose arity matches that of the
+ * highest-arity predicate.
+ *
+ * @func notAllPass
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.4.0|v2.4.0}
+ * @category Logic
+ * @sig [(*... -> Boolean)] -> (*... -> Boolean)
+ * @param {Array} predicates An array of predicates to check
+ * @return {Function} The combined predicate
+ * @see {@link http://ramdajs.com/docs/#allPass|R.allPass}
+ * @example
+ *
+ * const gt10 = R.gt(R.__, 10)
+ * const even = (x) => x % 2 === 0;
+ * const f = RA.notAllPass([gt10, even]);
+ *
+ * f(12); //=> false
+ * f(8); //=> true
+ * f(11); //=> true
+ * f(9); //=> true
+ */
+var notAllPass = (0, _ramda.curry)((0, _ramda.compose)(_ramda.complement, _ramda.allPass));
+var _default = notAllPass;
+exports["default"] = _default;

package/lib/notAllUnique.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _allUnique = _interopRequireDefault(require("./allUnique"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Returns true if at least one item of the list is repeated. `R.equals` is used to determine equality.
+ *
+ * @func notAllUnique
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category List
+ * @sig [a] -> Boolean
+ * @param {Array} list The list of values
+ * @return {boolean}
+ * @see {@link RA.allUnique|allUnique}, {@link https://ramdajs.com/docs/#equals|equals}
+ * @example
+ *
+ * RA.notAllUnique([ 1, 1, 2, 3 ]); //=> true
+ * RA.notAllUnique([ 1, 2, 3, 4 ]); //=> false
+ * RA.notAllUnique([]); //=> false
+ *
+ */
+var notAllUnique = (0, _ramda.complement)(_allUnique["default"]);
+var _default = notAllUnique;
+exports["default"] = _default;

package/lib/notBoth.js

@@ -0,0 +1,45 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/* eslint-disable max-len */
+
+/**
+ * A function which calls the two provided functions and returns the complement of `&&`ing the
+ * results.
+ * It returns true if the first function is false-y and the complement of the second function
+ * otherwise. Note that this is short-circuited, meaning that the second function will not be
+ * invoked if the first returns a false-y value. In short it will return true unless both predicates
+ * return true.
+ *
+ * In addition to functions, `RA.notBoth` also accepts any fantasy-land compatible
+ * applicative functor.
+ *
+ * @func notBoth
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.3.0|v2.3.0}
+ * @category Logic
+ * @sig (*... -> Boolean) -> (*... -> Boolean) -> (*... -> Boolean)
+ * @param {Function} f A predicate
+ * @param {Function} g Another predicate
+ * @return {Function} Returns a function that applies its arguments to `f` and `g` and returns the complement of `&&`ing their outputs together.
+ * @see {@link http://ramdajs.com/docs/#both|R.both}
+ * @example
+ *
+ * const gt10 = R.gt(R.__, 10)
+ * const even = (x) => x % 2 === 0;
+ * const f = RA.notBoth(gt10, even);
+ *
+ * f(12); //=> false
+ * f(8); //=> true
+ * f(11); //=> true
+ * f(9); //=> true
+ */
+
+/* eslint-enable max-len */
+var notBoth = (0, _ramda.curry)((0, _ramda.compose)(_ramda.complement, _ramda.both));
+var _default = notBoth;
+exports["default"] = _default;

package/lib/notEqual.js

@@ -0,0 +1,36 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Returns `true` if its arguments are not equivalent, `false` otherwise. Handles
+ * cyclical data structures.
+ *
+ * Dispatches symmetrically to the `equals` methods of both arguments, if
+ * present.
+ *
+ * @func notEqual
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.29.0|v2.29.0}
+ * @category Relation
+ * @sig a -> b -> Boolean
+ * @param {*} a
+ * @param {*} b
+ * @return {Boolean}
+ * @see {@link https://ramdajs.com/docs/#equals|equals}
+ * @example
+ *
+ * RA.notEqual(1, 1); //=> false
+ * RA.notEqual(1, '1'); //=> true
+ * RA.notEqual([1, 2, 3], [1, 2, 3]); //=> false
+ *
+ * const a = {}; a.v = a;
+ * const b = {}; b.v = b;
+ * RA.notEqual(a, b); //=> false
+ */
+var notEqual = (0, _ramda.complement)(_ramda.equals);
+var _default = notEqual;
+exports["default"] = _default;

package/lib/omitBy.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/* eslint-disable max-len */
+
+/**
+ * Returns a partial copy of an object containing only the keys
+ * that don't satisfy the supplied predicate.
+ *
+ * @func omitBy
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.6.0|v2.6.0}
+ * @category Object
+ * @sig ((v, k) -> Boolean) -> {k: v} -> {k: v}
+ * @param {!Function} pred A predicate to determine whether or not a key should be included on the output object
+ * @param {!Object} obj The object to copy from
+ * @return {!Object} A new object only with properties that don't satisfy `pred`
+ *
+ * @example
+ *
+ * const isLowerCase = (val, key) => key.toLowerCase() === key;
+ * RA.omitBy(isLowerCase, {a: 1, b: 2, A: 3, B: 4}); //=> {A: 3, B: 4}
+ */
+
+/* eslint-enable max-len */
+var omitBy = (0, _ramda.useWith)(_ramda.pickBy, [_ramda.complement, _ramda.identity]);
+var _default = omitBy;
+exports["default"] = _default;

package/lib/omitIndexes.js

@@ -0,0 +1,34 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+// helpers
+var rejectIndexed = (0, _ramda.addIndex)(_ramda.reject);
+var containsIndex = (0, _ramda.curry)(function (indexes, val, index) {
+  return (0, _ramda.contains)(index, indexes);
+});
+/**
+ * Returns a partial copy of an array omitting the indexes specified.
+ *
+ * @func omitIndexes
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.19.0|v1.19.0}
+ * @category List
+ * @sig [Int] -> [a] -> [a]
+ * @see {@link http://ramdajs.com/docs/#omit|R.omit}, {@link RA.pickIndexes|pickIndexes}
+ * @param {!Array} indexes The array of indexes to omit from the new array
+ * @param {!Array} list The array to copy from
+ * @return {!Array} The new array with omitted indexes
+ * @example
+ *
+ * RA.omitIndexes([-1, 1, 3], ['a', 'b', 'c', 'd']); //=> ['a', 'c']
+ */
+
+var omitIndexes = (0, _ramda.curry)(function (indexes, list) {
+  return rejectIndexed(containsIndex(indexes), list);
+});
+var _default = omitIndexes;
+exports["default"] = _default;

package/lib/overlaps.js

@@ -0,0 +1,38 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+var _isNotEmpty = _interopRequireDefault(require("./isNotEmpty"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Returns true if two lists have at least one element common to both lists.
+ *
+ * @func overlaps
+ * @memberOf RA
+ * @category Relation
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.30.0|v2.30.0}
+ * @sig [a] -> [a] -> Boolean
+ * @param {Array} list1 The first list
+ * @param {Array} list2 The second list
+ * @return {boolean} True if two lists have at least one element common to both lists
+ * @example
+ *
+ * RA.overlaps(['-v', '--verbose'], ['node', 'script.js', '-v']); //=> true
+ * RA.overlaps(['-v', '--verbose'], []); //=> false
+ * RA.overlaps([1, 2, 3], [3, 4, 5]); //=> true
+ * RA.overlaps([1, 2, 3], [4, 5]); //=> false
+ */
+var overlaps = (0, _ramda.curryN)(2, function (list1, list2) {
+  if ((0, _ramda.isEmpty)(list1)) {
+    return true;
+  }
+
+  return (0, _ramda.pipe)(_ramda.intersection, _isNotEmpty["default"])(list1, list2);
+});
+var _default = overlaps;
+exports["default"] = _default;

package/lib/padCharsEnd.js

@@ -0,0 +1,44 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = exports.padEndInvoker = exports.padEndPonyfill = void 0;
+
+var _ramda = require("ramda");
+
+var _String = _interopRequireDefault(require("./internal/ponyfills/String.padEnd"));
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var padEndPonyfill = (0, _ramda.curry)(_String["default"]);
+exports.padEndPonyfill = padEndPonyfill;
+var padEndInvoker = (0, _ramda.flip)((0, _ramda.invoker)(2, 'padEnd'));
+/**
+ * The function pads the current string with a given string
+ * (repeated, if needed) so that the resulting string reaches a given length.
+ * The padding is applied from the end of the current string.
+ *
+ * @func padCharsEnd
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category String
+ * @sig String -> Number -> String -> String
+ * @param {string} padString The string to pad the current string with
+ * @param {number} targetLength The length of the resulting string once
+ * the current string has been padded
+ * @param {string} value String value to be padded
+ * @return {string} A new string of the specified length with the pad string
+ * applied at the end of the current string
+ * @see {@link RA.padEnd|padEnd}, {@link RA.padCharsStart|padCharsStart}, {@link RA.padStart|padStart}
+ * @example
+ *
+ * RA.padCharsEnd('-', 3, 'a'); // => 'a--'
+ * RA.padCharsEnd('foo', 10, 'abc'); // => 'abcfoofoof'
+ * RA.padCharsEnd('123456', 6, 'abc'); // => 'abc123'
+ */
+
+exports.padEndInvoker = padEndInvoker;
+var padCharsEnd = (0, _isFunction["default"])(String.prototype.padEnd) ? padEndInvoker : padEndPonyfill;
+var _default = padCharsEnd;
+exports["default"] = _default;

package/lib/padCharsStart.js

@@ -0,0 +1,42 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = exports.padStartPonyfill = exports.padStartInvoker = void 0;
+
+var _ramda = require("ramda");
+
+var _isFunction = _interopRequireDefault(require("./isFunction"));
+
+var _String = _interopRequireDefault(require("./internal/ponyfills/String.padStart"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+var padStartInvoker = (0, _ramda.flip)((0, _ramda.invoker)(2, 'padStart'));
+exports.padStartInvoker = padStartInvoker;
+var padStartPonyfill = (0, _ramda.curry)(_String["default"]);
+/**
+ * The function pads the current string with a given string
+ * (repeated, if needed) so that the resulting string reaches a given length.
+ * The padding is applied from the start of the current string.
+ *
+ * @func padCharsStart
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category String
+ * @sig String -> Number -> String -> String
+ * @param {string} padString The string to pad the current string with
+ * @param {number} targetLength The length of the resulting string once the current string has been padded
+ * @param {string} value String value to be padded
+ * @return {string} A new string of the specified length with the pad string on the start of current string
+ * @see {@link RA.padStart|padStart}, {@link RA.padEnd|padEnd}, {@link RA.padCharsEnd|padCharsEnd}
+ * @example
+ *
+ * RA.padCharsStart('-', 3, 'a'); // => '--a'
+ * RA.padCharsStart('foo', 10, 'abc'); // => 'foofoofabc'
+ * RA.padCharsStart('123456', 6, 'abc'); // => '123abc'
+ */
+
+exports.padStartPonyfill = padStartPonyfill;
+var padCharsStart = (0, _isFunction["default"])(String.prototype.padStart) ? padStartInvoker : padStartPonyfill;
+var _default = padCharsStart;
+exports["default"] = _default;

package/lib/padEnd.js

@@ -0,0 +1,32 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _padCharsEnd = _interopRequireDefault(require("./padCharsEnd"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * The function pads the current string with an empty string
+ * so that the resulting string reaches a given length.
+ * The padding is applied from the end of the current string.
+ *
+ * @func padEnd
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category String
+ * @sig Number -> String -> String
+ * @param {number} targetLength The length of the resulting string once
+ * the current string has been padded
+ * @param {string} value String value to be padded
+ * @return {string} A new string of the specified length with the pad string
+ * applied at the end of the current string
+ * @see {@link RA.padCharsEnd|padCharsEnd}, {@link RA.padCharsStart|padCharsStart}, {@link RA.padStart|padStart}
+ * @example
+ *
+ * RA.padEnd(3, 'a'); // => 'a  '
+ */
+var padEnd = (0, _padCharsEnd["default"])(' ');
+var _default = padEnd;
+exports["default"] = _default;

package/lib/padStart.js

@@ -0,0 +1,30 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _padCharsStart = _interopRequireDefault(require("./padCharsStart"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+/**
+ * Pads string on the left side if it's shorter than length.
+ *
+ * @func padStart
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.25.0|v2.25.0}
+ * @category String
+ * @sig Number -> String -> String
+ * @param {number} targetLength The length of the resulting string once
+ * the current string has been padded
+ * @param {string} value String value to be padded
+ * @return {string} A new string of the specified length with the empty string
+ * applied to the beginning of the current string
+ * @see {@link RA.padCharsEnd|padCharsEnd}, {@link RA.padCharsStart|padCharsStart}, {@link RA.padEnd|padEnd}
+ * @example
+ *
+ * RA.padStart(3, 'a'); // => '  a'
+ */
+var padStart = (0, _padCharsStart["default"])(' ');
+var _default = padStart;
+exports["default"] = _default;