@slicemachine/manager 0.22.2-alpha.dani-snippets.6 → 0.22.2-alpha.dani-repeatable-links-codegen.1

package/dist/_node_modules/fp-ts/es6/Either.js

@@ -1,5 +1,324 @@
-import { isLeft as isLeft$1 } from "./internal.js";
+import { getApplicativeMonoid } from "./Applicative.js";
+import { apFirst as apFirst$1, apSecond as apSecond$1, apS as apS$1, getApplySemigroup as getApplySemigroup$1 } from "./Apply.js";
+import { tap as tap$1, bind as bind$1 } from "./Chain.js";
+import { tailRec } from "./ChainRec.js";
+import { fromPredicate as fromPredicate$1, fromOption as fromOption$1, fromOptionK as fromOptionK$1, chainOptionK as chainOptionK$1, filterOrElse as filterOrElse$1 } from "./FromEither.js";
+import { dual, identity, flow, pipe } from "./function.js";
+import { as as as$1, asUnit as asUnit$1, flap as flap$1, bindTo as bindTo$1, let as let_$1 } from "./Functor.js";
+import { isLeft as isLeft$1, left as left$1, right as right$1, isRight as isRight$1, liftNullable as liftNullable$1, liftOption as liftOption$1, flatMapNullable as flatMapNullable$1, flatMapOption as flatMapOption$1, head, isNonEmpty, emptyRecord, emptyReadonlyArray } from "./internal.js";
+import { separated } from "./Separated.js";
+import { witherDefault, wiltDefault } from "./Witherable.js";
+var left = left$1;
+var right = right$1;
+var flatMap = /* @__PURE__ */ dual(2, function(ma, f) {
+  return isLeft(ma) ? ma : f(ma.right);
+});
+var _map = function(fa, f) {
+  return pipe(fa, map(f));
+};
+var _ap = function(fab, fa) {
+  return pipe(fab, ap(fa));
+};
+var _reduce = function(fa, b, f) {
+  return pipe(fa, reduce(b, f));
+};
+var _foldMap = function(M) {
+  return function(fa, f) {
+    var foldMapM = foldMap(M);
+    return pipe(fa, foldMapM(f));
+  };
+};
+var _reduceRight = function(fa, b, f) {
+  return pipe(fa, reduceRight(b, f));
+};
+var _traverse = function(F) {
+  var traverseF = traverse(F);
+  return function(ta, f) {
+    return pipe(ta, traverseF(f));
+  };
+};
+var _bimap = function(fa, f, g) {
+  return pipe(fa, bimap(f, g));
+};
+var _mapLeft = function(fa, f) {
+  return pipe(fa, mapLeft(f));
+};
+var _alt = function(fa, that) {
+  return pipe(fa, alt(that));
+};
+var _extend = function(wa, f) {
+  return pipe(wa, extend(f));
+};
+var _chainRec = function(a, f) {
+  return tailRec(f(a), function(e) {
+    return isLeft(e) ? right(left(e.left)) : isLeft(e.right) ? left(f(e.right.left)) : right(right(e.right.right));
+  });
+};
+var URI = "Either";
+var getShow = function(SE, SA) {
+  return {
+    show: function(ma) {
+      return isLeft(ma) ? "left(".concat(SE.show(ma.left), ")") : "right(".concat(SA.show(ma.right), ")");
+    }
+  };
+};
+var getEq = function(EL, EA) {
+  return {
+    equals: function(x, y) {
+      return x === y || (isLeft(x) ? isLeft(y) && EL.equals(x.left, y.left) : isRight(y) && EA.equals(x.right, y.right));
+    }
+  };
+};
+var getSemigroup = function(S) {
+  return {
+    concat: function(x, y) {
+      return isLeft(y) ? x : isLeft(x) ? y : right(S.concat(x.right, y.right));
+    }
+  };
+};
+var getCompactable = function(M) {
+  var empty = left(M.empty);
+  return {
+    URI,
+    _E: void 0,
+    compact: function(ma) {
+      return isLeft(ma) ? ma : ma.right._tag === "None" ? empty : right(ma.right.value);
+    },
+    separate: function(ma) {
+      return isLeft(ma) ? separated(ma, ma) : isLeft(ma.right) ? separated(right(ma.right.left), empty) : separated(empty, right(ma.right.right));
+    }
+  };
+};
+var getFilterable = function(M) {
+  var empty = left(M.empty);
+  var _a = getCompactable(M), compact = _a.compact, separate = _a.separate;
+  var filter = function(ma, predicate) {
+    return isLeft(ma) ? ma : predicate(ma.right) ? ma : empty;
+  };
+  var partition = function(ma, p) {
+    return isLeft(ma) ? separated(ma, ma) : p(ma.right) ? separated(empty, right(ma.right)) : separated(right(ma.right), empty);
+  };
+  return {
+    URI,
+    _E: void 0,
+    map: _map,
+    compact,
+    separate,
+    filter,
+    filterMap: function(ma, f) {
+      if (isLeft(ma)) {
+        return ma;
+      }
+      var ob = f(ma.right);
+      return ob._tag === "None" ? empty : right(ob.value);
+    },
+    partition,
+    partitionMap: function(ma, f) {
+      if (isLeft(ma)) {
+        return separated(ma, ma);
+      }
+      var e = f(ma.right);
+      return isLeft(e) ? separated(right(e.left), empty) : separated(empty, right(e.right));
+    }
+  };
+};
+var getWitherable = function(M) {
+  var F_ = getFilterable(M);
+  var C = getCompactable(M);
+  return {
+    URI,
+    _E: void 0,
+    map: _map,
+    compact: F_.compact,
+    separate: F_.separate,
+    filter: F_.filter,
+    filterMap: F_.filterMap,
+    partition: F_.partition,
+    partitionMap: F_.partitionMap,
+    traverse: _traverse,
+    sequence,
+    reduce: _reduce,
+    foldMap: _foldMap,
+    reduceRight: _reduceRight,
+    wither: witherDefault(Traversable, C),
+    wilt: wiltDefault(Traversable, C)
+  };
+};
+var getApplicativeValidation = function(SE) {
+  return {
+    URI,
+    _E: void 0,
+    map: _map,
+    ap: function(fab, fa) {
+      return isLeft(fab) ? isLeft(fa) ? left(SE.concat(fab.left, fa.left)) : fab : isLeft(fa) ? fa : right(fab.right(fa.right));
+    },
+    of
+  };
+};
+var getAltValidation = function(SE) {
+  return {
+    URI,
+    _E: void 0,
+    map: _map,
+    alt: function(me, that) {
+      if (isRight(me)) {
+        return me;
+      }
+      var ea = that();
+      return isLeft(ea) ? left(SE.concat(me.left, ea.left)) : ea;
+    }
+  };
+};
+var map = function(f) {
+  return function(fa) {
+    return isLeft(fa) ? fa : right(f(fa.right));
+  };
+};
+var Functor = {
+  URI,
+  map: _map
+};
+var as = dual(2, as$1(Functor));
+var asUnit = asUnit$1(Functor);
+var of = right;
+var Pointed = {
+  URI,
+  of
+};
+var apW = function(fa) {
+  return function(fab) {
+    return isLeft(fab) ? fab : isLeft(fa) ? fa : right(fab.right(fa.right));
+  };
+};
+var ap = apW;
+var Apply = {
+  URI,
+  map: _map,
+  ap: _ap
+};
+var Applicative = {
+  URI,
+  map: _map,
+  ap: _ap,
+  of
+};
+var Chain = {
+  URI,
+  map: _map,
+  ap: _ap,
+  chain: flatMap
+};
+var Monad = {
+  URI,
+  map: _map,
+  ap: _ap,
+  of,
+  chain: flatMap
+};
+var reduce = function(b, f) {
+  return function(fa) {
+    return isLeft(fa) ? b : f(b, fa.right);
+  };
+};
+var foldMap = function(M) {
+  return function(f) {
+    return function(fa) {
+      return isLeft(fa) ? M.empty : f(fa.right);
+    };
+  };
+};
+var reduceRight = function(b, f) {
+  return function(fa) {
+    return isLeft(fa) ? b : f(fa.right, b);
+  };
+};
+var Foldable = {
+  URI,
+  reduce: _reduce,
+  foldMap: _foldMap,
+  reduceRight: _reduceRight
+};
+var traverse = function(F) {
+  return function(f) {
+    return function(ta) {
+      return isLeft(ta) ? F.of(left(ta.left)) : F.map(f(ta.right), right);
+    };
+  };
+};
+var sequence = function(F) {
+  return function(ma) {
+    return isLeft(ma) ? F.of(left(ma.left)) : F.map(ma.right, right);
+  };
+};
+var Traversable = {
+  URI,
+  map: _map,
+  reduce: _reduce,
+  foldMap: _foldMap,
+  reduceRight: _reduceRight,
+  traverse: _traverse,
+  sequence
+};
+var bimap = function(f, g) {
+  return function(fa) {
+    return isLeft(fa) ? left(f(fa.left)) : right(g(fa.right));
+  };
+};
+var mapLeft = function(f) {
+  return function(fa) {
+    return isLeft(fa) ? left(f(fa.left)) : fa;
+  };
+};
+var Bifunctor = {
+  URI,
+  bimap: _bimap,
+  mapLeft: _mapLeft
+};
+var altW = function(that) {
+  return function(fa) {
+    return isLeft(fa) ? that() : fa;
+  };
+};
+var alt = altW;
+var Alt = {
+  URI,
+  map: _map,
+  alt: _alt
+};
+var extend = function(f) {
+  return function(wa) {
+    return isLeft(wa) ? wa : right(f(wa));
+  };
+};
+var Extend = {
+  URI,
+  map: _map,
+  extend: _extend
+};
+var ChainRec = {
+  URI,
+  map: _map,
+  ap: _ap,
+  chain: flatMap,
+  chainRec: _chainRec
+};
+var throwError = left;
+var MonadThrow = {
+  URI,
+  map: _map,
+  ap: _ap,
+  of,
+  chain: flatMap,
+  throwError
+};
+var FromEither = {
+  URI,
+  fromEither: identity
+};
+var fromPredicate = /* @__PURE__ */ fromPredicate$1(FromEither);
+var fromOption = /* @__PURE__ */ fromOption$1(FromEither);
 var isLeft = isLeft$1;
+var isRight = isRight$1;
 var matchW = function(onLeft, onRight) {
   return function(ma) {
     return isLeft(ma) ? onLeft(ma.left) : onRight(ma.right);
@@ -8,11 +327,313 @@ var matchW = function(onLeft, onRight) {
 var foldW = matchW;
 var match = matchW;
 var fold = match;
+var getOrElseW = function(onLeft) {
+  return function(ma) {
+    return isLeft(ma) ? onLeft(ma.left) : ma.right;
+  };
+};
+var getOrElse = getOrElseW;
+var flap = /* @__PURE__ */ flap$1(Functor);
+var apFirst = /* @__PURE__ */ apFirst$1(Apply);
+var apFirstW = apFirst;
+var apSecond = /* @__PURE__ */ apSecond$1(Apply);
+var apSecondW = apSecond;
+var tap = /* @__PURE__ */ dual(2, tap$1(Chain));
+var flattenW = /* @__PURE__ */ flatMap(identity);
+var flatten = flattenW;
+var duplicate = /* @__PURE__ */ extend(identity);
+var fromOptionK = /* @__PURE__ */ fromOptionK$1(FromEither);
+var chainOptionK = /* @__PURE__ */ chainOptionK$1(FromEither, Chain);
+var chainOptionKW = chainOptionK;
+var _FromEither = {
+  fromEither: FromEither.fromEither
+};
+var liftNullable = /* @__PURE__ */ liftNullable$1(_FromEither);
+var liftOption = /* @__PURE__ */ liftOption$1(_FromEither);
+var _FlatMap = {
+  flatMap
+};
+var flatMapNullable = /* @__PURE__ */ flatMapNullable$1(_FromEither, _FlatMap);
+var flatMapOption = /* @__PURE__ */ flatMapOption$1(_FromEither, _FlatMap);
+var filterOrElse = /* @__PURE__ */ filterOrElse$1(FromEither, Chain);
+var filterOrElseW = filterOrElse;
+var swap = function(ma) {
+  return isLeft(ma) ? right(ma.left) : left(ma.right);
+};
+var orElseW = function(onLeft) {
+  return function(ma) {
+    return isLeft(ma) ? onLeft(ma.left) : ma;
+  };
+};
+var orElse = orElseW;
+var fromNullable = function(e) {
+  return function(a) {
+    return a == null ? left(e) : right(a);
+  };
+};
+var tryCatch = function(f, onThrow) {
+  try {
+    return right(f());
+  } catch (e) {
+    return left(onThrow(e));
+  }
+};
+var tryCatchK = function(f, onThrow) {
+  return function() {
+    var a = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      a[_i] = arguments[_i];
+    }
+    return tryCatch(function() {
+      return f.apply(void 0, a);
+    }, onThrow);
+  };
+};
+var fromNullableK = function(e) {
+  var from = fromNullable(e);
+  return function(f) {
+    return flow(f, from);
+  };
+};
+var chainNullableK = function(e) {
+  var from = fromNullableK(e);
+  return function(f) {
+    return flatMap(from(f));
+  };
+};
+var toUnion = /* @__PURE__ */ foldW(identity, identity);
+function toError(e) {
+  return e instanceof Error ? e : new Error(String(e));
+}
+function elem(E) {
+  return function(a, ma) {
+    if (ma === void 0) {
+      var elemE_1 = elem(E);
+      return function(ma2) {
+        return elemE_1(a, ma2);
+      };
+    }
+    return isLeft(ma) ? false : E.equals(a, ma.right);
+  };
+}
+var exists = function(predicate) {
+  return function(ma) {
+    return isLeft(ma) ? false : predicate(ma.right);
+  };
+};
+var Do = /* @__PURE__ */ of(emptyRecord);
+var bindTo = /* @__PURE__ */ bindTo$1(Functor);
+var let_ = /* @__PURE__ */ let_$1(Functor);
+var bind = /* @__PURE__ */ bind$1(Chain);
+var bindW = bind;
+var apS = /* @__PURE__ */ apS$1(Apply);
+var apSW = apS;
+var ApT = /* @__PURE__ */ of(emptyReadonlyArray);
+var traverseReadonlyNonEmptyArrayWithIndex = function(f) {
+  return function(as2) {
+    var e = f(0, head(as2));
+    if (isLeft(e)) {
+      return e;
+    }
+    var out = [e.right];
+    for (var i = 1; i < as2.length; i++) {
+      var e_1 = f(i, as2[i]);
+      if (isLeft(e_1)) {
+        return e_1;
+      }
+      out.push(e_1.right);
+    }
+    return right(out);
+  };
+};
+var traverseReadonlyArrayWithIndex = function(f) {
+  var g = traverseReadonlyNonEmptyArrayWithIndex(f);
+  return function(as2) {
+    return isNonEmpty(as2) ? g(as2) : ApT;
+  };
+};
+var traverseArrayWithIndex = traverseReadonlyArrayWithIndex;
+var traverseArray = function(f) {
+  return traverseReadonlyArrayWithIndex(function(_, a) {
+    return f(a);
+  });
+};
+var sequenceArray = /* @__PURE__ */ traverseArray(identity);
+var chainW = flatMap;
+var chain = flatMap;
+var chainFirst = tap;
+var chainFirstW = tap;
+function parseJSON(s, onError) {
+  return tryCatch(function() {
+    return JSON.parse(s);
+  }, onError);
+}
+var stringifyJSON = function(u, onError) {
+  return tryCatch(function() {
+    var s = JSON.stringify(u);
+    if (typeof s !== "string") {
+      throw new Error("Converting unsupported structure to JSON");
+    }
+    return s;
+  }, onError);
+};
+var either = {
+  URI,
+  map: _map,
+  of,
+  ap: _ap,
+  chain: flatMap,
+  reduce: _reduce,
+  foldMap: _foldMap,
+  reduceRight: _reduceRight,
+  traverse: _traverse,
+  sequence,
+  bimap: _bimap,
+  mapLeft: _mapLeft,
+  alt: _alt,
+  extend: _extend,
+  chainRec: _chainRec,
+  throwError
+};
+var getApplySemigroup = /* @__PURE__ */ getApplySemigroup$1(Apply);
+var getApplyMonoid = /* @__PURE__ */ getApplicativeMonoid(Applicative);
+var getValidationSemigroup = function(SE, SA) {
+  return getApplySemigroup$1(getApplicativeValidation(SE))(SA);
+};
+var getValidationMonoid = function(SE, MA) {
+  return getApplicativeMonoid(getApplicativeValidation(SE))(MA);
+};
+function getValidation(SE) {
+  var ap2 = getApplicativeValidation(SE).ap;
+  var alt2 = getAltValidation(SE).alt;
+  return {
+    URI,
+    _E: void 0,
+    map: _map,
+    of,
+    chain: flatMap,
+    bimap: _bimap,
+    mapLeft: _mapLeft,
+    reduce: _reduce,
+    foldMap: _foldMap,
+    reduceRight: _reduceRight,
+    extend: _extend,
+    traverse: _traverse,
+    sequence,
+    chainRec: _chainRec,
+    throwError,
+    ap: ap2,
+    alt: alt2
+  };
+}
 export {
+  Alt,
+  ApT,
+  Applicative,
+  Apply,
+  Bifunctor,
+  Chain,
+  ChainRec,
+  Do,
+  Extend,
+  Foldable,
+  FromEither,
+  Functor,
+  Monad,
+  MonadThrow,
+  Pointed,
+  Traversable,
+  URI,
+  alt,
+  altW,
+  ap,
+  apFirst,
+  apFirstW,
+  apS,
+  apSW,
+  apSecond,
+  apSecondW,
+  apW,
+  as,
+  asUnit,
+  bimap,
+  bind,
+  bindTo,
+  bindW,
+  chain,
+  chainFirst,
+  chainFirstW,
+  chainNullableK,
+  chainOptionK,
+  chainOptionKW,
+  chainW,
+  duplicate,
+  either,
+  elem,
+  exists,
+  extend,
+  filterOrElse,
+  filterOrElseW,
+  flap,
+  flatMap,
+  flatMapNullable,
+  flatMapOption,
+  flatten,
+  flattenW,
   fold,
+  foldMap,
   foldW,
+  fromNullable,
+  fromNullableK,
+  fromOption,
+  fromOptionK,
+  fromPredicate,
+  getAltValidation,
+  getApplicativeValidation,
+  getApplyMonoid,
+  getApplySemigroup,
+  getCompactable,
+  getEq,
+  getFilterable,
+  getOrElse,
+  getOrElseW,
+  getSemigroup,
+  getShow,
+  getValidation,
+  getValidationMonoid,
+  getValidationSemigroup,
+  getWitherable,
   isLeft,
+  isRight,
+  left,
+  let_ as let,
+  liftNullable,
+  liftOption,
+  map,
+  mapLeft,
   match,
-  matchW
+  matchW,
+  of,
+  orElse,
+  orElseW,
+  parseJSON,
+  reduce,
+  reduceRight,
+  right,
+  sequence,
+  sequenceArray,
+  stringifyJSON,
+  swap,
+  tap,
+  throwError,
+  toError,
+  toUnion,
+  traverse,
+  traverseArray,
+  traverseArrayWithIndex,
+  traverseReadonlyArrayWithIndex,
+  traverseReadonlyNonEmptyArrayWithIndex,
+  tryCatch,
+  tryCatchK
 };
 //# sourceMappingURL=Either.js.map