ramda-adjunct 2.34.0

package/es/index.js

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

package/es/internal/ap.js

@@ -0,0 +1,20 @@
+import { ap as apR, curryN, pathSatisfies, both, either } from 'ramda';
+import isFunction from '../isFunction';
+import * as fl from '../fantasy-land/mapping';
+var isFunctor = either(pathSatisfies(isFunction, ['map']), pathSatisfies(isFunction, [fl.map]));
+var isApply = both(isFunctor, either(pathSatisfies(isFunction, ['ap']), pathSatisfies(isFunction, [fl.ap])));
+var ap = curryN(2, function (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/es/internal/compareLength.js

@@ -0,0 +1,5 @@
+import { curry, compose, length } from 'ramda';
+var compareLength = curry(function (comparator, value, list) {
+  return compose(comparator(value), length)(list);
+});
+export default compareLength;

package/es/internal/isOfTypeObject.js

@@ -0,0 +1,7 @@
+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); }
+
+var isOfTypeObject = function isOfTypeObject(val) {
+  return _typeof(val) === 'object';
+};
+
+export default isOfTypeObject;

package/es/internal/makeFlat.js

@@ -0,0 +1,46 @@
+import isArrayLike from '../isArrayLike';
+/**
+ * `makeFlat` is a helper function that returns a one-level or fully recursive
+ * function based on the flag passed in.
+ *
+ * @func makeFlat
+ * @memberOf RA
+ *
+ * @category List
+ * @param {!bool} = should recursively flatten
+ * @param {!Array} = the nested list to be flattened
+ * @return {!Array} = the flattened list
+ * @sig Bool -> List -> List
+ *
+ */
+
+var makeFlat = function makeFlat(recursive) {
+  return function flatt(list) {
+    var value;
+    var jlen;
+    var j;
+    var result = [];
+    var idx = 0;
+
+    while (idx < list.length) {
+      if (isArrayLike(list[idx])) {
+        value = recursive ? flatt(list[idx]) : list[idx];
+        j = 0;
+        jlen = value.length;
+
+        while (j < jlen) {
+          result[result.length] = value[j];
+          j += 1;
+        }
+      } else {
+        result[result.length] = list[idx];
+      }
+
+      idx += 1;
+    }
+
+    return result;
+  };
+};
+
+export default makeFlat;

package/es/internal/ponyfills/Array.from.js

@@ -0,0 +1,40 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+import { bind } from 'ramda';
+import isIterable from '../../isIterable';
+import isNotUndefined from '../../isNotUndefined';
+import isNotNil from '../../isNotNil';
+import isNotFunction from '../../isNotFunction';
+
+var copyArray = function copyArray(items, mapFn, thisArg) {
+  var boundMapFn = isNotUndefined(thisArg) ? bind(mapFn, thisArg) : mapFn;
+  return isNotUndefined(mapFn) ? _toConsumableArray(items).map(boundMapFn) : _toConsumableArray(items);
+};
+
+var fromArray = function fromArray(items, mapFn, thisArg) {
+  if (items == null) {
+    throw new TypeError('Array.from requires an array-like object - not null or undefined');
+  }
+
+  if (isNotNil(mapFn) && isNotFunction(mapFn)) {
+    throw new TypeError('Array.from: when provided, the second argument must be a function');
+  }
+
+  if (isIterable(items)) {
+    return copyArray(items, mapFn, thisArg);
+  }
+
+  return [];
+};
+
+export default fromArray;

package/es/internal/ponyfills/Math.sign.js

@@ -0,0 +1,5 @@
+var signPonyfill = function signPonyfill(number) {
+  return (number > 0) - (number < 0) || +number;
+};
+
+export default signPonyfill;

package/es/internal/ponyfills/Math.trunc.js

@@ -0,0 +1,14 @@
+import isFinite from '../../isFinite';
+
+var truncPonyfill = function truncPonyfill(v) {
+  var numV = Number(v);
+
+  if (!isFinite(numV)) {
+    return numV;
+  } // eslint-disable-next-line no-nested-ternary
+
+
+  return numV - numV % 1 || (numV < 0 ? -0 : numV === 0 ? numV : 0);
+};
+
+export default truncPonyfill;

package/es/internal/ponyfills/Number.MAX_SAFE_INTEGER.js

@@ -0,0 +1,2 @@
+var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || Math.pow(2, 53) - 1;
+export default MAX_SAFE_INTEGER;

package/es/internal/ponyfills/Number.MIN_SAFE_INTEGER.js

@@ -0,0 +1,2 @@
+var MIN_SAFE_INTEGER = Number.MIN_SAFE_INTEGER || -Math.pow(2, 53) - 1;
+export default MIN_SAFE_INTEGER;

package/es/internal/ponyfills/Number.isFinite.js

@@ -0,0 +1,5 @@
+import { both } from 'ramda';
+import isNumber from '../../isNumber'; // eslint-disable-next-line no-restricted-globals
+
+var isFinitePonyfill = both(isNumber, isFinite);
+export default isFinitePonyfill;

package/es/internal/ponyfills/Number.isInteger.js

@@ -0,0 +1,4 @@
+import { both, converge, equals, identity } from 'ramda';
+import isFinite from '../../isFinite';
+var isIntegerPonyfill = both(isFinite, converge(equals, [Math.floor, identity]));
+export default isIntegerPonyfill;

package/es/internal/ponyfills/Number.isNaN.js

@@ -0,0 +1,5 @@
+import { both } from 'ramda';
+import isNumber from '../../isNumber'; // eslint-disable-next-line no-restricted-globals
+
+var isNaNPonyfill = both(isNumber, isNaN);
+export default isNaNPonyfill;

package/es/internal/ponyfills/Number.isSafeInteger.js

@@ -0,0 +1,7 @@
+import { both } from 'ramda';
+import isInteger from '../../isInteger';
+import MAX_SAFE_INTEGER from './Number.MAX_SAFE_INTEGER';
+var isSafeIntegerPonyfill = both(isInteger, function (value) {
+  return Math.abs(value) <= MAX_SAFE_INTEGER;
+});
+export default isSafeIntegerPonyfill;

package/es/internal/ponyfills/Promise.allSettled.js

@@ -0,0 +1,38 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+import { map } from 'ramda';
+import allP from '../../allP';
+import resolveP from '../../resolveP';
+
+var onFulfill = function onFulfill(value) {
+  return {
+    status: 'fulfilled',
+    value: value
+  };
+};
+
+var onReject = function onReject(reason) {
+  return {
+    status: 'rejected',
+    reason: reason
+  };
+};
+
+var allSettledPonyfill = function allSettledPonyfill(iterable) {
+  var array = map(function (p) {
+    return resolveP(p).then(onFulfill)["catch"](onReject);
+  }, _toConsumableArray(iterable));
+  return allP(array);
+};
+
+export default allSettledPonyfill;

package/es/internal/ponyfills/Promise.any.js

@@ -0,0 +1,77 @@
+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); }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+
+function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+import { map } from 'ramda';
+import resolveP from '../../resolveP';
+export var AggregatedError = /*#__PURE__*/function (_Error) {
+  _inherits(AggregatedError, _Error);
+
+  var _super = _createSuper(AggregatedError);
+
+  function AggregatedError() {
+    var _this;
+
+    var errors = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    var message = arguments.length > 1 ? arguments[1] : undefined;
+
+    _classCallCheck(this, AggregatedError);
+
+    _this = _super.call(this, message);
+    _this.errors = errors;
+    return _this;
+  }
+
+  return AggregatedError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+var anyPonyfill = function anyPonyfill(iterable) {
+  var exceptions = [];
+  return new Promise(function (resolve, reject) {
+    var onReject = function onReject(e) {
+      exceptions.push(e);
+
+      if (exceptions.length === iterable.length) {
+        reject(new AggregatedError(exceptions));
+      }
+    };
+
+    map(function (p) {
+      return resolveP(p).then(resolve)["catch"](onReject);
+    }, _toConsumableArray(iterable));
+  });
+};
+
+export default anyPonyfill;

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

@@ -0,0 +1,24 @@
+import isFunction from '../../isFunction';
+import isNotUndefined from '../../isNotUndefined';
+import repeat from './String.repeat';
+
+var padEndPonyfill = function padEndPonyfill(padString, targetLength, value) {
+  // eslint-disable-next-line no-bitwise
+  var finalLength = targetLength >> 0;
+  var finalPadString = String(isNotUndefined(padString) ? padString : ' ');
+
+  if (value.length > finalLength) {
+    return String(value);
+  }
+
+  finalLength -= value.length;
+
+  if (finalLength > finalPadString.length) {
+    var remainingLength = finalLength / finalPadString.length;
+    finalPadString += isFunction(String.prototype.repeat) ? finalPadString.repeat(remainingLength) : repeat(finalPadString, remainingLength);
+  }
+
+  return String(value) + finalPadString.slice(0, finalLength);
+};
+
+export default padEndPonyfill;

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

@@ -0,0 +1,26 @@
+import isFunction from '../../isFunction';
+import isNotUndefined from '../../isNotUndefined';
+import repeat from './String.repeat';
+
+var padStartPonyfill = function padStartPonyfill(padString, targetLength, value) {
+  // eslint-disable-next-line no-bitwise
+  var finalLength = targetLength >> 0; // truncate if number, or convert non-number to 0;
+
+  var finalPadString = String(isNotUndefined(padString) ? padString : ' '); // return the original string, if targeted length is less than original strings length
+
+  if (value.length >= finalLength) {
+    return String(value);
+  }
+
+  finalLength -= value.length;
+
+  if (finalLength > finalPadString.length) {
+    var lenghtToPad = finalLength / finalPadString.length; // append to original to ensure we are longer than needed
+
+    finalPadString += isFunction(String.prototype.repeat) ? finalPadString.repeat(lenghtToPad) : repeat(finalPadString, lenghtToPad);
+  }
+
+  return finalPadString.slice(0, finalLength) + String(value);
+};
+
+export default padStartPonyfill;

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

@@ -0,0 +1,46 @@
+import isNotFinite from '../../isNotFinite';
+import isNegative from '../../isNegative';
+
+var repeat = function repeat(value, count) {
+  var validCount = Number(count);
+
+  if (validCount !== count) {
+    validCount = 0;
+  }
+
+  if (isNegative(validCount)) {
+    throw new RangeError('repeat count must be non-negative');
+  }
+
+  if (isNotFinite(validCount)) {
+    throw new RangeError('repeat count must be less than infinity');
+  }
+
+  validCount = Math.floor(validCount);
+
+  if (value.length === 0 || validCount === 0) {
+    return '';
+  } // Ensuring validCount is a 31-bit integer allows us to heavily optimize the
+  // main part. But anyway, most current (August 2014) browsers can't handle
+  // strings 1 << 28 chars or longer, so:
+  // eslint-disable-next-line no-bitwise
+
+
+  if (value.length * validCount >= 1 << 28) {
+    throw new RangeError('repeat count must not overflow maximum string size');
+  }
+
+  var maxCount = value.length * validCount;
+  validCount = Math.floor(Math.log(validCount) / Math.log(2));
+  var result = value;
+
+  while (validCount) {
+    result += value;
+    validCount -= 1;
+  }
+
+  result += result.substring(0, maxCount - result.length);
+  return result;
+};
+
+export default repeat;