@fncts/base 0.0.1

package/_cjs/typeclass/Equatable/fast-equals.cjs

@@ -0,0 +1,520 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addToCache = addToCache;
+exports.areArraysEqual = areArraysEqual;
+exports.areMapsEqual = areMapsEqual;
+exports.areObjectsEqual = areObjectsEqual;
+exports.areRegExpsEqual = areRegExpsEqual;
+exports.areSetsEqual = areSetsEqual;
+exports.createCircularEqualCreator = createCircularEqualCreator;
+exports.createComparator = createComparator;
+exports.getNewCache = void 0;
+exports.getNewCacheFallback = getNewCacheFallback;
+exports.hasPair = hasPair;
+exports.hasValue = hasValue;
+exports.isPlainObject = isPlainObject;
+exports.isPromiseLike = isPromiseLike;
+exports.isReactElement = isReactElement;
+exports.sameValueZeroEqual = sameValueZeroEqual;
+exports.toPairs = toPairs;
+exports.toValues = toValues;
+
+/* Forked from https://github.com/planttheidea/fast-equals */
+const HAS_WEAKSET_SUPPORT = typeof WeakSet === "function";
+const {
+  keys
+} = Object;
+/**
+ * @function addToCache
+ *
+ * add object to cache if an object
+ *
+ * @param value the value to potentially add to cache
+ * @param cache the cache to add to
+ */
+
+function addToCache(value, cache) {
+  if (value && typeof value === "object") {
+    cache.add(value);
+  }
+}
+/**
+ * @function hasPair
+ *
+ * @description
+ * does the `pairToMatch` exist in the list of `pairs` provided based on the
+ * `isEqual` check
+ *
+ * @param pairs the pairs to compare against
+ * @param pairToMatch the pair to match
+ * @param isEqual the equality comparator used
+ * @param meta the meta provided
+ * @returns does the pair exist in the pairs provided
+ */
+
+
+function hasPair(pairs, pairToMatch, isEqual, meta) {
+  const {
+    length
+  } = pairs;
+  let pair;
+
+  for (let index = 0; index < length; index++) {
+    pair = pairs[index];
+
+    if (isEqual(pair[0], pairToMatch[0], meta) && isEqual(pair[1], pairToMatch[1], meta)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+/**
+ * @function hasValue
+ *
+ * @description
+ * does the `valueToMatch` exist in the list of `values` provided based on the
+ * `isEqual` check
+ *
+ * @param values the values to compare against
+ * @param valueToMatch the value to match
+ * @param isEqual the equality comparator used
+ * @param meta the meta provided
+ * @returns does the value exist in the values provided
+ */
+
+
+function hasValue(values, valueToMatch, isEqual, meta) {
+  const {
+    length
+  } = values;
+
+  for (let index = 0; index < length; index++) {
+    if (isEqual(values[index], valueToMatch, meta)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+/**
+ * @function sameValueZeroEqual
+ *
+ * @description
+ * are the values passed strictly equal or both NaN
+ *
+ * @param a the value to compare against
+ * @param b the value to test
+ * @returns are the values equal by the SameValueZero principle
+ */
+
+
+function sameValueZeroEqual(a, b) {
+  return a === b || a !== a && b !== b;
+}
+/**
+ * @function isPlainObject
+ *
+ * @description
+ * is the value a plain object
+ *
+ * @param value the value to test
+ * @returns is the value a plain object
+ */
+
+
+function isPlainObject(value) {
+  return value.constructor === Object || value.constructor == null;
+}
+/**
+ * @function isPromiseLike
+ *
+ * @description
+ * is the value promise-like (meaning it is thenable)
+ *
+ * @param value the value to test
+ * @returns is the value promise-like
+ */
+
+
+function isPromiseLike(value) {
+  return !!value && typeof value.then === "function";
+}
+/**
+ * @function isReactElement
+ *
+ * @description
+ * is the value passed a react element
+ *
+ * @param value the value to test
+ * @returns is the value a react element
+ */
+
+
+function isReactElement(value) {
+  return !!(value && value.$$typeof);
+}
+/**
+ * @function getNewCacheFallback
+ *
+ * @description
+ * in cases where WeakSet is not supported, creates a new custom
+ * object that mimics the necessary API aspects for cache purposes
+ *
+ * @returns the new cache object
+ */
+
+
+function getNewCacheFallback() {
+  return Object.create({
+    _values: [],
+
+    add(value) {
+      // @ts-expect-error
+      this._values.push(value);
+    },
+
+    has(value) {
+      // @ts-expect-error
+      return this._values.indexOf(value) !== -1;
+    }
+
+  });
+}
+/**
+ * @function getNewCache
+ *
+ * @description
+ * get a new cache object to prevent circular references
+ *
+ * @returns the new cache object
+ */
+
+
+const getNewCache = /*#__PURE__*/(canUseWeakMap => {
+  if (canUseWeakMap) {
+    return function _getNewCache() {
+      return new WeakSet();
+    };
+  }
+
+  return getNewCacheFallback;
+})(HAS_WEAKSET_SUPPORT);
+/**
+ * @function createCircularEqualCreator
+ *
+ * @description
+ * create a custom isEqual handler specific to circular objects
+ *
+ * @param [isEqual] the isEqual comparator to use instead of isDeepEqual
+ * @returns the method to create the `isEqual` function
+ */
+
+
+exports.getNewCache = getNewCache;
+
+function createCircularEqualCreator(isEqual) {
+  return function createCircularEqual(comparator) {
+    const _comparator = isEqual ? isEqual(comparator) : comparator;
+
+    return function circularEqual(a, b, cache = getNewCache()) {
+      const hasA = cache.has(a);
+      const hasB = cache.has(b);
+
+      if (hasA || hasB) {
+        return hasA && hasB;
+      }
+
+      addToCache(a, cache);
+      addToCache(b, cache);
+      return _comparator(a, b, cache);
+    };
+  };
+}
+/**
+ * @function toPairs
+ *
+ * @description
+ * convert the map passed into pairs (meaning an array of [key, value] tuples)
+ *
+ * @param map the map to convert to [key, value] pairs (entries)
+ * @returns the [key, value] pairs
+ */
+
+
+function toPairs(map) {
+  const pairs = new Array(map.size);
+  let index = 0;
+  map.forEach((value, key) => {
+    pairs[index++] = [key, value];
+  });
+  return pairs;
+}
+/**
+ * @function toValues
+ *
+ * @description
+ * convert the set passed into values
+ *
+ * @param set the set to convert to values
+ * @returns the values
+ */
+
+
+function toValues(set) {
+  const values = new Array(set.size);
+  let index = 0;
+  set.forEach(value => {
+    values[index++] = value;
+  });
+  return values;
+}
+/**
+ * @function areArraysEqual
+ *
+ * @description
+ * are the arrays equal in value
+ *
+ * @param a the array to test
+ * @param b the array to test against
+ * @param isEqual the comparator to determine equality
+ * @param meta the meta object to pass through
+ * @returns are the arrays equal
+ */
+
+
+function areArraysEqual(a, b, isEqual, meta) {
+  const {
+    length
+  } = a;
+
+  if (b.length !== length) {
+    return false;
+  }
+
+  for (let index = 0; index < length; index++) {
+    if (!isEqual(a[index], b[index], meta)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+/**
+ * @function areMapsEqual
+ *
+ * @description
+ * are the maps equal in value
+ *
+ * @param a the map to test
+ * @param b the map to test against
+ * @param isEqual the comparator to determine equality
+ * @param meta the meta map to pass through
+ * @returns are the maps equal
+ */
+
+
+function areMapsEqual(a, b, isEqual, meta) {
+  if (a.size !== b.size) {
+    return false;
+  }
+
+  const pairsA = toPairs(a);
+  const pairsB = toPairs(b);
+  const {
+    length
+  } = pairsA;
+
+  for (let index = 0; index < length; index++) {
+    if (!hasPair(pairsB, pairsA[index], isEqual, meta) || !hasPair(pairsA, pairsB[index], isEqual, meta)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+const OWNER = "_owner";
+const hasOwnProperty = /*#__PURE__*/Function.prototype.bind.call(Function.prototype.call, Object.prototype.hasOwnProperty);
+/**
+ * @function areObjectsEqual
+ *
+ * @description
+ * are the objects equal in value
+ *
+ * @param a the object to test
+ * @param b the object to test against
+ * @param isEqual the comparator to determine equality
+ * @param meta the meta object to pass through
+ * @returns are the objects equal
+ */
+
+function areObjectsEqual(a, b, isEqual, meta) {
+  const keysA = keys(a);
+  const {
+    length
+  } = keysA;
+
+  if (keys(b).length !== length) {
+    return false;
+  }
+
+  let key;
+
+  for (let index = 0; index < length; index++) {
+    key = keysA[index];
+
+    if (!hasOwnProperty(b, key)) {
+      return false;
+    }
+
+    if (key === OWNER && isReactElement(a)) {
+      if (!isReactElement(b)) {
+        return false;
+      }
+    } else if (!isEqual(a[key], b[key], meta)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+/**
+ * @function areRegExpsEqual
+ *
+ * @description
+ * are the regExps equal in value
+ *
+ * @param a the regExp to test
+ * @param b the regExp to test agains
+ * @returns are the regExps equal
+ */
+
+
+function areRegExpsEqual(a, b) {
+  return a.source === b.source && a.global === b.global && a.ignoreCase === b.ignoreCase && a.multiline === b.multiline && a.unicode === b.unicode && a.sticky === b.sticky && a.lastIndex === b.lastIndex;
+}
+/**
+ * @function areSetsEqual
+ *
+ * @description
+ * are the sets equal in value
+ *
+ * @param a the set to test
+ * @param b the set to test against
+ * @param isEqual the comparator to determine equality
+ * @param meta the meta set to pass through
+ * @returns are the sets equal
+ */
+
+
+function areSetsEqual(a, b, isEqual, meta) {
+  if (a.size !== b.size) {
+    return false;
+  }
+
+  const valuesA = toValues(a);
+  const valuesB = toValues(b);
+  const {
+    length
+  } = valuesA;
+
+  for (let index = 0; index < length; index++) {
+    if (!hasValue(valuesB, valuesA[index], isEqual, meta) || !hasValue(valuesA, valuesB[index], isEqual, meta)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+const {
+  isArray
+} = Array;
+const HAS_MAP_SUPPORT = typeof Map === "function";
+const HAS_SET_SUPPORT = typeof Set === "function";
+const OBJECT_TYPEOF = "object";
+
+function createComparator(createIsEqual) {
+  const isEqual =
+  /* eslint-disable no-use-before-define */
+  typeof createIsEqual === "function" ? createIsEqual(comparator) : comparator;
+  /* eslint-enable */
+
+  /**
+   * @function comparator
+   *
+   * @description
+   * compare the value of the two objects and return true if they are equivalent in values
+   *
+   * @param a the value to test against
+   * @param b the value to test
+   * @param [meta] an optional meta object that is passed through to all equality test calls
+   * @returns are a and b equivalent in value
+   */
+
+  function comparator(a, b, meta) {
+    if (sameValueZeroEqual(a, b)) {
+      return true;
+    }
+
+    if (a && b && typeof a === OBJECT_TYPEOF && typeof b === OBJECT_TYPEOF) {
+      if (isPlainObject(a) && isPlainObject(b)) {
+        return areObjectsEqual(a, b, isEqual, meta);
+      }
+
+      const arrayA = isArray(a);
+      const arrayB = isArray(b);
+
+      if (arrayA || arrayB) {
+        return arrayA === arrayB && areArraysEqual(a, b, isEqual, meta);
+      }
+
+      const aDate = a instanceof Date;
+      const bDate = b instanceof Date;
+
+      if (aDate || bDate) {
+        return aDate === bDate && sameValueZeroEqual(a.getTime(), b.getTime());
+      }
+
+      const aRegExp = a instanceof RegExp;
+      const bRegExp = b instanceof RegExp;
+
+      if (aRegExp || bRegExp) {
+        return aRegExp === bRegExp && areRegExpsEqual(a, b);
+      }
+
+      if (isPromiseLike(a) || isPromiseLike(b)) {
+        return a === b;
+      }
+
+      if (HAS_MAP_SUPPORT) {
+        const aMap = a instanceof Map;
+        const bMap = b instanceof Map;
+
+        if (aMap || bMap) {
+          return aMap === bMap && areMapsEqual(a, b, isEqual, meta);
+        }
+      }
+
+      if (HAS_SET_SUPPORT) {
+        const aSet = a instanceof Set;
+        const bSet = b instanceof Set;
+
+        if (aSet || bSet) {
+          return aSet === bSet && areSetsEqual(a, b, isEqual, meta);
+        }
+      }
+
+      return areObjectsEqual(a, b, isEqual, meta);
+    }
+
+    return false;
+  }
+
+  return comparator;
+}
+//# sourceMappingURL=fast-equals.cjs.map

package/_cjs/typeclass/Equatable/fast-equals.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fast-equals.cjs","mappings":"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","names":["HAS_WEAKSET_SUPPORT","WeakSet","keys","Object","addToCache","value","cache","add","hasPair","pairs","pairToMatch","isEqual","meta","length","pair","index","hasValue","values","valueToMatch","sameValueZeroEqual","a","b","isPlainObject","constructor","isPromiseLike","then","isReactElement","$$typeof","getNewCacheFallback","create","_values","push","has","indexOf","getNewCache","canUseWeakMap","_getNewCache","createCircularEqualCreator","createCircularEqual","comparator","_comparator","circularEqual","hasA","hasB","toPairs","map","Array","size","forEach","key","toValues","set","areArraysEqual","areMapsEqual","pairsA","pairsB","OWNER","hasOwnProperty","Function","prototype","bind","call","areObjectsEqual","keysA","areRegExpsEqual","source","global","ignoreCase","multiline","unicode","sticky","lastIndex","areSetsEqual","valuesA","valuesB","isArray","HAS_MAP_SUPPORT","Map","HAS_SET_SUPPORT","Set","OBJECT_TYPEOF","createComparator","createIsEqual","arrayA","arrayB","aDate","Date","bDate","getTime","aRegExp","RegExp","bRegExp","aMap","bMap","aSet","bSet"],"sourceRoot":"","sources":["../../../_src/typeclass/Equatable/fast-equals.ts"],"sourcesContent":[null]}

package/_cjs/typeclass/Equatable.cjs

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _api = /*#__PURE__*/require("./Equatable/api.js");
+
+Object.keys(_api).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _api[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _api[key];
+    }
+  });
+});
+
+var _definition = /*#__PURE__*/require("./Equatable/definition.js");
+
+Object.keys(_definition).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _definition[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _definition[key];
+    }
+  });
+});
+
+var _fastEquals = /*#__PURE__*/require("./Equatable/fast-equals.js");
+
+Object.keys(_fastEquals).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _fastEquals[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _fastEquals[key];
+    }
+  });
+});
+//# sourceMappingURL=Equatable.cjs.map

package/_cjs/typeclass/Equatable.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Equatable.cjs","mappings":";;;;;;AACA;;AAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;;AACA;;AAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;;AACA;;AAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA","names":[],"sourceRoot":"","sources":["../../_src/typeclass/Equatable.ts"],"sourcesContent":[null]}

package/_cjs/typeclass/Fail.cjs

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mkFail = mkFail;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/typelevel/HKT"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * @tsplus static fncts.FailOps __call
+ */
+function mkFail(F) {
+  return {
+    fail: F.fail
+  };
+}
+//# sourceMappingURL=Fail.cjs.map

package/_cjs/typeclass/Fail.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fail.cjs","mappings":";;;;;;;;;;;;;AAgBA;;;AAGM,SAAUA,MAAV,CAA8CC,CAA9C,EAA8D;EAClE,OAAoB;IAClBC,IAAI,EAAED,CAAC,CAACC;EADU,CAApB;AAGD","names":["mkFail","F","fail"],"sourceRoot":"","sources":["../../_src/typeclass/Fail.ts"],"sourcesContent":[null]}

package/_cjs/typeclass/Filterable.cjs

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Filterable = void 0;
+exports.mkFilterable = mkFilterable;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/typelevel/HKT"));
+
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/Functor"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const Filterable = {};
+exports.Filterable = Filterable;
+
+function mkFilterable(F) {
+  return { ...tsplus_module_2.mkFunctor(F),
+    filter_: F.filter_,
+    filter: p => fa => F.filter_(fa, p),
+    partition_: F.partition_,
+    partition: p => fa => F.partition_(fa, p),
+    filterMap_: F.filterMap_,
+    filterMap: f => fa => F.filterMap_(fa, f),
+    partitionMap_: F.partitionMap_,
+    partitionMap: f => fa => F.partitionMap_(fa, f)
+  };
+}
+//# sourceMappingURL=Filterable.cjs.map

package/_cjs/typeclass/Filterable.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Filterable.cjs","mappings":";;;;;;;;;;;;;;;;AAuBO,MAAMA,UAAU,GAAkB,EAAlC;;;AAaD,SAAUC,YAAV,CAA0BC,CAA1B,EAAoD;EACxD,OAA0C,EACxC,GAAGC,0BAAQD,CAAR,CADqC;IAExCE,OAAO,EAAEF,CAAC,CAACE,OAF6B;IAGxCC,MAAM,EACAC,CAAJ,IACyBC,EAAzB,IACEL,CAAC,CAACE,OAAF,CAAUG,EAAV,EAAcD,CAAd,CANoC;IAOxCE,UAAU,EAAEN,CAAC,CAACM,UAP0B;IAQxCC,SAAS,EACHH,CAAJ,IACyBC,EAAzB,IACEL,CAAC,CAACM,UAAF,CAAaD,EAAb,EAAiBD,CAAjB,CAXoC;IAYxCI,UAAU,EAAER,CAAC,CAACQ,UAZ0B;IAaxCC,SAAS,EAAGC,CAAD,IAAQL,EAAD,IAAQL,CAAC,CAACQ,UAAF,CAAaH,EAAb,EAAiBK,CAAjB,CAbc;IAcxCC,aAAa,EAAEX,CAAC,CAACW,aAduB;IAexCC,YAAY,EAAGF,CAAD,IAAQL,EAAD,IAAQL,CAAC,CAACW,aAAF,CAAgBN,EAAhB,EAAoBK,CAApB;EAfW,CAA1C;AAiBD","names":["Filterable","mkFilterable","F","tsplus_module_2","filter_","filter","p","fa","partition_","partition","filterMap_","filterMap","f","partitionMap_","partitionMap"],"sourceRoot":"","sources":["../../_src/typeclass/Filterable.ts"],"sourcesContent":[null]}

package/_cjs/typeclass/FilterableWithIndex.cjs

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FilterableWithIndex = void 0;
+exports.mkFilterableWithIndex = mkFilterableWithIndex;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/typelevel/HKT"));
+
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/FunctorWithIndex"));
+
+var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/Filterable"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const FilterableWithIndex = {};
+exports.FilterableWithIndex = FilterableWithIndex;
+
+function mkFilterableWithIndex(F) {
+  return { ...tsplus_module_2.mkFunctorWithIndex(F),
+    ...tsplus_module_3.mkFilterable(F),
+    filterWithIndex_: F.filterWithIndex_,
+    filterWithIndex: f => fa => F.filterWithIndex_(fa, f),
+    partitionWithIndex_: F.partitionWithIndex_,
+    partitionWithIndex: f => fa => F.partitionWithIndex_(fa, f),
+    filterMapWithIndex_: F.filterMapWithIndex_,
+    filterMapWithIndex: f => fa => F.filterMapWithIndex_(fa, f),
+    partitionMapWithIndex_: F.partitionMapWithIndex_,
+    partitionMapWithIndex: f => fa => F.partitionMapWithIndex_(fa, f)
+  };
+}
+//# sourceMappingURL=FilterableWithIndex.cjs.map

package/_cjs/typeclass/FilterableWithIndex.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterableWithIndex.cjs","mappings":";;;;;;;;;;;;;;;;;;AAyBO,MAAMA,mBAAmB,GAA2B,EAApD;;;AAgBD,SAAUC,qBAAV,CAAmCC,CAAnC,EAAsE;EAC1E,OAAmD,EACjD,GAAGC,mCAAiBD,CAAjB,CAD8C;IAEjD,GAAGE,6BAAWF,CAAX,CAF8C;IAGjDG,gBAAgB,EAAEH,CAAC,CAACG,gBAH6B;IAIjDC,eAAe,EACNC,CAAP,IACsBC,EAAtB,IACEN,CAAC,CAACG,gBAAF,CAAmBG,EAAnB,EAAuBD,CAAvB,CAP6C;IAQjDE,mBAAmB,EAAEP,CAAC,CAACO,mBAR0B;IASjDC,kBAAkB,EACTH,CAAP,IACsBC,EAAtB,IACEN,CAAC,CAACO,mBAAF,CAAsBD,EAAtB,EAA0BD,CAA1B,CAZ6C;IAajDI,mBAAmB,EAAET,CAAC,CAACS,mBAb0B;IAcjDC,kBAAkB,EAAGL,CAAD,IAAQC,EAAD,IAAQN,CAAC,CAACS,mBAAF,CAAsBH,EAAtB,EAA0BD,CAA1B,CAdc;IAejDM,sBAAsB,EAAEX,CAAC,CAACW,sBAfuB;IAgBjDC,qBAAqB,EAAGP,CAAD,IAAQC,EAAD,IAAQN,CAAC,CAACW,sBAAF,CAAyBL,EAAzB,EAA6BD,CAA7B;EAhBW,CAAnD;AAkBD","names":["FilterableWithIndex","mkFilterableWithIndex","F","tsplus_module_2","tsplus_module_3","filterWithIndex_","filterWithIndex","f","fa","partitionWithIndex_","partitionWithIndex","filterMapWithIndex_","filterMapWithIndex","partitionMapWithIndex_","partitionMapWithIndex"],"sourceRoot":"","sources":["../../_src/typeclass/FilterableWithIndex.ts"],"sourcesContent":[null]}