@fncts/base 0.0.1

package/_mjs/typeclass/Equatable/fast-equals.mjs

@@ -0,0 +1,476 @@
+/* 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
+ */
+
+export 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
+ */
+
+export 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
+ */
+
+export 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
+ */
+
+export 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
+ */
+
+export 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
+ */
+
+export 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
+ */
+
+export 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
+ */
+
+export 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
+ */
+
+export 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
+ */
+
+export 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
+ */
+
+export 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
+ */
+
+export 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
+ */
+
+export 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
+ */
+
+export 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
+ */
+
+export 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
+ */
+
+export 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
+ */
+
+export 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";
+export 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.mjs.map

package/_mjs/typeclass/Equatable/fast-equals.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fast-equals.mjs","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/_mjs/typeclass/Equatable.mjs

@@ -0,0 +1,5 @@
+// codegen:start { preset: barrel, include: Equatable/*.ts }
+export * from "./Equatable/api.mjs";
+export * from "./Equatable/definition.mjs";
+export * from "./Equatable/fast-equals.mjs";
+//# sourceMappingURL=Equatable.mjs.map

package/_mjs/typeclass/Equatable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Equatable.mjs","mappings":"AAAA;AACA,cAAc,qBAAd;AACA,cAAc,4BAAd;AACA,cAAc,6BAAd","names":[],"sourceRoot":"","sources":["../../_src/typeclass/Equatable.ts"],"sourcesContent":[null]}

package/_mjs/typeclass/Fail.mjs

@@ -0,0 +1,11 @@
+import * as tsplus_module_1 from "@fncts/typelevel/HKT";
+/**
+ * @tsplus static fncts.FailOps __call
+ */
+
+export function mkFail(F) {
+  return {
+    fail: F.fail
+  };
+}
+//# sourceMappingURL=Fail.mjs.map

package/_mjs/typeclass/Fail.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Fail.mjs","mappings":";AAgBA;;;;AAGA,OAAM,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/_mjs/typeclass/Filterable.mjs

@@ -0,0 +1,16 @@
+import * as tsplus_module_1 from "@fncts/typelevel/HKT";
+import * as tsplus_module_2 from "@fncts/base/typeclass/Functor";
+export const Filterable = {};
+export 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.mjs.map

package/_mjs/typeclass/Filterable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Filterable.mjs","mappings":";;AAuBA,OAAO,MAAMA,UAAU,GAAkB,EAAlC;AAaP,OAAM,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/_mjs/typeclass/FilterableWithIndex.mjs

@@ -0,0 +1,18 @@
+import * as tsplus_module_1 from "@fncts/typelevel/HKT";
+import * as tsplus_module_2 from "@fncts/base/typeclass/FunctorWithIndex";
+import * as tsplus_module_3 from "@fncts/base/typeclass/Filterable";
+export const FilterableWithIndex = {};
+export 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.mjs.map

package/_mjs/typeclass/FilterableWithIndex.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterableWithIndex.mjs","mappings":";;;AAyBA,OAAO,MAAMA,mBAAmB,GAA2B,EAApD;AAgBP,OAAM,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]}

package/_mjs/typeclass/Foldable.mjs

@@ -0,0 +1,19 @@
+import * as tsplus_module_1 from "@fncts/typelevel/HKT";
+export const Foldable = {};
+/**
+ * @tsplus static fncts.FoldableOps __call
+ */
+
+export function mkFoldable(F) {
+  const foldMap_ = M => (fa, f) => F.foldLeft_(fa, M.nat, (b, a) => M.combine_(b, f(a)));
+
+  return {
+    foldLeft_: F.foldLeft_,
+    foldLeft: (b, f) => fa => F.foldLeft_(fa, b, f),
+    foldRight_: F.foldRight_,
+    foldRight: (b, f) => fa => F.foldRight_(fa, b, f),
+    foldMap_,
+    foldMap: M => f => fa => foldMap_(M)(fa, f)
+  };
+}
+//# sourceMappingURL=Foldable.mjs.map

package/_mjs/typeclass/Foldable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Foldable.mjs","mappings":";AAmBA,OAAO,MAAMA,QAAQ,GAAgB,EAA9B;AAOP;;;;AAGA,OAAM,SAAUC,UAAV,CAAmDC,CAAnD,EAAwE;EAC5E,MAAMC,QAAQ,GAAqBC,CAAD,IAAO,CAACC,EAAD,EAAKC,CAAL,KAAWJ,CAAC,CAACK,SAAF,CAAYF,EAAZ,EAAgBD,CAAC,CAACI,GAAlB,EAAuB,CAACC,CAAD,EAAIC,CAAJ,KAAUN,CAAC,CAACO,QAAF,CAAWF,CAAX,EAAcH,CAAC,CAACI,CAAD,CAAf,CAAjC,CAApD;;EAEA,OAAqC;IACnCH,SAAS,EAAEL,CAAC,CAACK,SADsB;IAEnCK,QAAQ,EAAE,CAACH,CAAD,EAAIH,CAAJ,KAAWD,EAAD,IAAQH,CAAC,CAACK,SAAF,CAAYF,EAAZ,EAAgBI,CAAhB,EAAmBH,CAAnB,CAFO;IAGnCO,UAAU,EAAEX,CAAC,CAACW,UAHqB;IAInCC,SAAS,EAAE,CAACL,CAAD,EAAIH,CAAJ,KAAWD,EAAD,IAAQH,CAAC,CAACW,UAAF,CAAaR,EAAb,EAAiBI,CAAjB,EAAoBH,CAApB,CAJM;IAKnCH,QALmC;IAMnCY,OAAO,EAAGX,CAAD,IAAQE,CAAD,IAAQD,EAAD,IAAQF,QAAQ,CAACC,CAAD,CAAR,CAAYC,EAAZ,EAAgBC,CAAhB;EANI,CAArC;AAQD","names":["Foldable","mkFoldable","F","foldMap_","M","fa","f","foldLeft_","nat","b","a","combine_","foldLeft","foldRight_","foldRight","foldMap"],"sourceRoot":"","sources":["../../_src/typeclass/Foldable.ts"],"sourcesContent":[null]}

package/_mjs/typeclass/FoldableWithIndex.mjs

@@ -0,0 +1,20 @@
+import * as tsplus_module_1 from "@fncts/typelevel/HKT";
+import * as tsplus_module_2 from "@fncts/base/typeclass/Foldable";
+export const FoldableWithIndex = {};
+/**
+ * @tsplus static fncts.FoldableWithIndexOps __call
+ */
+
+export function mkFoldableWithIndex(F) {
+  const foldMapWithIndex_ = M => (fa, f) => F.foldLeftWithIndex_(fa, M.nat, (i, b, a) => M.combine_(b, f(i, a)));
+
+  return { ...tsplus_module_2.mkFoldable(F),
+    foldLeftWithIndex_: F.foldLeftWithIndex_,
+    foldLeftWithIndex: (b, f) => fa => F.foldLeftWithIndex_(fa, b, f),
+    foldRightWithIndex_: F.foldRightWithIndex_,
+    foldRightWithIndex: (b, f) => fa => F.foldRightWithIndex_(fa, b, f),
+    foldMapWithIndex_,
+    foldMapWithIndex: M => f => fa => foldMapWithIndex_(M)(fa, f)
+  };
+}
+//# sourceMappingURL=FoldableWithIndex.mjs.map

package/_mjs/typeclass/FoldableWithIndex.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FoldableWithIndex.mjs","mappings":";;AAsBA,OAAO,MAAMA,iBAAiB,GAAyB,EAAhD;AAOP;;;;AAGA,OAAM,SAAUC,mBAAV,CACJC,CADI,EAC0B;EAE9B,MAAMC,iBAAiB,GAA8BC,CAAD,IAAO,CAACC,EAAD,EAAKC,CAAL,KACzDJ,CAAC,CAACK,kBAAF,CAAqBF,EAArB,EAAyBD,CAAC,CAACI,GAA3B,EAAgC,CAACC,CAAD,EAAIC,CAAJ,EAAOC,CAAP,KAAaP,CAAC,CAACQ,QAAF,CAAWF,CAAX,EAAcJ,CAAC,CAACG,CAAD,EAAIE,CAAJ,CAAf,CAA7C,CADF;;EAEA,OAA8C,EAC5C,GAAGE,2BAASX,CAAT,CADyC;IAE5CK,kBAAkB,EAAEL,CAAC,CAACK,kBAFsB;IAG5CO,iBAAiB,EAAE,CAACJ,CAAD,EAAIJ,CAAJ,KAAWD,EAAD,IAAQH,CAAC,CAACK,kBAAF,CAAqBF,EAArB,EAAyBK,CAAzB,EAA4BJ,CAA5B,CAHO;IAI5CS,mBAAmB,EAAEb,CAAC,CAACa,mBAJqB;IAK5CC,kBAAkB,EAAE,CAACN,CAAD,EAAIJ,CAAJ,KAAWD,EAAD,IAAQH,CAAC,CAACa,mBAAF,CAAsBV,EAAtB,EAA0BK,CAA1B,EAA6BJ,CAA7B,CALM;IAM5CH,iBAN4C;IAO5Cc,gBAAgB,EAAGb,CAAD,IAAQE,CAAD,IAAQD,EAAD,IAAQF,iBAAiB,CAACC,CAAD,CAAjB,CAAqBC,EAArB,EAAyBC,CAAzB;EAPI,CAA9C;AASD","names":["FoldableWithIndex","mkFoldableWithIndex","F","foldMapWithIndex_","M","fa","f","foldLeftWithIndex_","nat","i","b","a","combine_","tsplus_module_2","foldLeftWithIndex","foldRightWithIndex_","foldRightWithIndex","foldMapWithIndex"],"sourceRoot":"","sources":["../../_src/typeclass/FoldableWithIndex.ts"],"sourcesContent":[null]}

package/_mjs/typeclass/Functor.mjs

@@ -0,0 +1,15 @@
+import * as tsplus_module_1 from "@fncts/typelevel/HKT";
+export const Functor = {};
+/**
+ * @tsplus static fncts.FunctorOps __call
+ */
+
+export function mkFunctor(F) {
+  return {
+    map_: F.map_,
+    map: f => fa => F.map_(fa, f),
+    as_: (fa, b) => F.map_(fa, () => b()),
+    as: b => fa => F.map_(fa, () => b())
+  };
+}
+//# sourceMappingURL=Functor.mjs.map

package/_mjs/typeclass/Functor.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Functor.mjs","mappings":";AAeA,OAAO,MAAMA,OAAO,GAAe,EAA5B;AAMP;;;;AAGA,OAAM,SAAUC,SAAV,CAAiDC,CAAjD,EAAoE;EACxE,OAAmC;IACjCC,IAAI,EAAED,CAAC,CAACC,IADyB;IAEjCC,GAAG,EAAGC,CAAD,IAAQC,EAAD,IAAQJ,CAAC,CAACC,IAAF,CAAOG,EAAP,EAAWD,CAAX,CAFa;IAGjCE,GAAG,EAAE,CAACD,EAAD,EAAKE,CAAL,KAAWN,CAAC,CAACC,IAAF,CAAOG,EAAP,EAAW,MAAME,CAAC,EAAlB,CAHiB;IAIjCC,EAAE,EAAGD,CAAD,IAAQF,EAAD,IAAQJ,CAAC,CAACC,IAAF,CAAOG,EAAP,EAAW,MAAME,CAAC,EAAlB;EAJc,CAAnC;AAMD","names":["Functor","mkFunctor","F","map_","map","f","fa","as_","b","as"],"sourceRoot":"","sources":["../../_src/typeclass/Functor.ts"],"sourcesContent":[null]}

package/_mjs/typeclass/FunctorWithIndex.mjs

@@ -0,0 +1,14 @@
+import * as tsplus_module_1 from "@fncts/typelevel/HKT";
+import * as tsplus_module_2 from "@fncts/base/typeclass/Functor";
+export const FunctorWithIndex = {};
+/**
+ * @tsplus static fncts.FunctorWithIndexOps __call
+ */
+
+export function mkFunctorWithIndex(F) {
+  return { ...tsplus_module_2.mkFunctor(F),
+    mapWithIndex_: F.mapWithIndex_,
+    mapWithIndex: f => fa => F.mapWithIndex_(fa, f)
+  };
+}
+//# sourceMappingURL=FunctorWithIndex.mjs.map

package/_mjs/typeclass/FunctorWithIndex.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctorWithIndex.mjs","mappings":";;AAkBA,OAAO,MAAMA,gBAAgB,GAAwB,EAA9C;AAEP;;;;AAGA,OAAM,SAAUC,kBAAV,CAA0DC,CAA1D,EAAsF;EAC1F,OAA4C,EAC1C,GAAGC,0BAAQD,CAAR,CADuC;IAE1CE,aAAa,EAAEF,CAAC,CAACE,aAFyB;IAG1CC,YAAY,EAAGC,CAAD,IAAQC,EAAD,IAAQL,CAAC,CAACE,aAAF,CAAgBG,EAAhB,EAAoBD,CAApB;EAHa,CAA5C;AAKD","names":["FunctorWithIndex","mkFunctorWithIndex","F","tsplus_module_2","mapWithIndex_","mapWithIndex","f","fa"],"sourceRoot":"","sources":["../../_src/typeclass/FunctorWithIndex.ts"],"sourcesContent":[null]}

package/_mjs/typeclass/Has.mjs

@@ -0,0 +1,10 @@
+/**
+ * @tsplus operator fncts.Has &
+ * @tsplus fluent fncts.Has merge
+ */
+export function merge(self, that) {
+  return { ...self,
+    ...that
+  };
+}
+//# sourceMappingURL=Has.mjs.map

package/_mjs/typeclass/Has.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Has.mjs","mappings":"AAYA;;;;AAIA,OAAM,SAAUA,KAAV,CAAwDC,IAAxD,EAAiEC,IAAjE,EAAwE;EAC5E,OAAO,EAAE,GAAGD,IAAL;IAAW,GAAGC;EAAd,CAAP;AACD","names":["merge","self","that"],"sourceRoot":"","sources":["../../_src/typeclass/Has.ts"],"sourcesContent":[null]}