@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.cjs

@@ -1,7 +1,326 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Applicative$1 = require("./Applicative.cjs");
+const Apply$1 = require("./Apply.cjs");
+const Chain$1 = require("./Chain.cjs");
+const ChainRec$1 = require("./ChainRec.cjs");
+const FromEither$1 = require("./FromEither.cjs");
+const _function = require("./function.cjs");
+const Functor$1 = require("./Functor.cjs");
 const internal = require("./internal.cjs");
+const Separated = require("./Separated.cjs");
+const Witherable = require("./Witherable.cjs");
+var left = internal.left;
+var right = internal.right;
+var flatMap = /* @__PURE__ */ _function.dual(2, function(ma, f) {
+  return isLeft(ma) ? ma : f(ma.right);
+});
+var _map = function(fa, f) {
+  return _function.pipe(fa, map(f));
+};
+var _ap = function(fab, fa) {
+  return _function.pipe(fab, ap(fa));
+};
+var _reduce = function(fa, b, f) {
+  return _function.pipe(fa, reduce(b, f));
+};
+var _foldMap = function(M) {
+  return function(fa, f) {
+    var foldMapM = foldMap(M);
+    return _function.pipe(fa, foldMapM(f));
+  };
+};
+var _reduceRight = function(fa, b, f) {
+  return _function.pipe(fa, reduceRight(b, f));
+};
+var _traverse = function(F) {
+  var traverseF = traverse(F);
+  return function(ta, f) {
+    return _function.pipe(ta, traverseF(f));
+  };
+};
+var _bimap = function(fa, f, g) {
+  return _function.pipe(fa, bimap(f, g));
+};
+var _mapLeft = function(fa, f) {
+  return _function.pipe(fa, mapLeft(f));
+};
+var _alt = function(fa, that) {
+  return _function.pipe(fa, alt(that));
+};
+var _extend = function(wa, f) {
+  return _function.pipe(wa, extend(f));
+};
+var _chainRec = function(a, f) {
+  return ChainRec$1.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.separated(ma, ma) : isLeft(ma.right) ? Separated.separated(right(ma.right.left), empty) : Separated.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.separated(ma, ma) : p(ma.right) ? Separated.separated(empty, right(ma.right)) : Separated.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.separated(ma, ma);
+      }
+      var e = f(ma.right);
+      return isLeft(e) ? Separated.separated(right(e.left), empty) : Separated.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: Witherable.witherDefault(Traversable, C),
+    wilt: Witherable.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 = _function.dual(2, Functor$1.as(Functor));
+var asUnit = Functor$1.asUnit(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: _function.identity
+};
+var fromPredicate = /* @__PURE__ */ FromEither$1.fromPredicate(FromEither);
+var fromOption = /* @__PURE__ */ FromEither$1.fromOption(FromEither);
 var isLeft = internal.isLeft;
+var isRight = internal.isRight;
 var matchW = function(onLeft, onRight) {
   return function(ma) {
     return isLeft(ma) ? onLeft(ma.left) : onRight(ma.right);
@@ -10,9 +329,311 @@ 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__ */ Functor$1.flap(Functor);
+var apFirst = /* @__PURE__ */ Apply$1.apFirst(Apply);
+var apFirstW = apFirst;
+var apSecond = /* @__PURE__ */ Apply$1.apSecond(Apply);
+var apSecondW = apSecond;
+var tap = /* @__PURE__ */ _function.dual(2, Chain$1.tap(Chain));
+var flattenW = /* @__PURE__ */ flatMap(_function.identity);
+var flatten = flattenW;
+var duplicate = /* @__PURE__ */ extend(_function.identity);
+var fromOptionK = /* @__PURE__ */ FromEither$1.fromOptionK(FromEither);
+var chainOptionK = /* @__PURE__ */ FromEither$1.chainOptionK(FromEither, Chain);
+var chainOptionKW = chainOptionK;
+var _FromEither = {
+  fromEither: FromEither.fromEither
+};
+var liftNullable = /* @__PURE__ */ internal.liftNullable(_FromEither);
+var liftOption = /* @__PURE__ */ internal.liftOption(_FromEither);
+var _FlatMap = {
+  flatMap
+};
+var flatMapNullable = /* @__PURE__ */ internal.flatMapNullable(_FromEither, _FlatMap);
+var flatMapOption = /* @__PURE__ */ internal.flatMapOption(_FromEither, _FlatMap);
+var filterOrElse = /* @__PURE__ */ FromEither$1.filterOrElse(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 _function.flow(f, from);
+  };
+};
+var chainNullableK = function(e) {
+  var from = fromNullableK(e);
+  return function(f) {
+    return flatMap(from(f));
+  };
+};
+var toUnion = /* @__PURE__ */ foldW(_function.identity, _function.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(internal.emptyRecord);
+var bindTo = /* @__PURE__ */ Functor$1.bindTo(Functor);
+var let_ = /* @__PURE__ */ Functor$1.let(Functor);
+var bind = /* @__PURE__ */ Chain$1.bind(Chain);
+var bindW = bind;
+var apS = /* @__PURE__ */ Apply$1.apS(Apply);
+var apSW = apS;
+var ApT = /* @__PURE__ */ of(internal.emptyReadonlyArray);
+var traverseReadonlyNonEmptyArrayWithIndex = function(f) {
+  return function(as2) {
+    var e = f(0, internal.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 internal.isNonEmpty(as2) ? g(as2) : ApT;
+  };
+};
+var traverseArrayWithIndex = traverseReadonlyArrayWithIndex;
+var traverseArray = function(f) {
+  return traverseReadonlyArrayWithIndex(function(_, a) {
+    return f(a);
+  });
+};
+var sequenceArray = /* @__PURE__ */ traverseArray(_function.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__ */ Apply$1.getApplySemigroup(Apply);
+var getApplyMonoid = /* @__PURE__ */ Applicative$1.getApplicativeMonoid(Applicative);
+var getValidationSemigroup = function(SE, SA) {
+  return Apply$1.getApplySemigroup(getApplicativeValidation(SE))(SA);
+};
+var getValidationMonoid = function(SE, MA) {
+  return Applicative$1.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
+  };
+}
+exports.Alt = Alt;
+exports.ApT = ApT;
+exports.Applicative = Applicative;
+exports.Apply = Apply;
+exports.Bifunctor = Bifunctor;
+exports.Chain = Chain;
+exports.ChainRec = ChainRec;
+exports.Do = Do;
+exports.Extend = Extend;
+exports.Foldable = Foldable;
+exports.FromEither = FromEither;
+exports.Functor = Functor;
+exports.Monad = Monad;
+exports.MonadThrow = MonadThrow;
+exports.Pointed = Pointed;
+exports.Traversable = Traversable;
+exports.URI = URI;
+exports.alt = alt;
+exports.altW = altW;
+exports.ap = ap;
+exports.apFirst = apFirst;
+exports.apFirstW = apFirstW;
+exports.apS = apS;
+exports.apSW = apSW;
+exports.apSecond = apSecond;
+exports.apSecondW = apSecondW;
+exports.apW = apW;
+exports.as = as;
+exports.asUnit = asUnit;
+exports.bimap = bimap;
+exports.bind = bind;
+exports.bindTo = bindTo;
+exports.bindW = bindW;
+exports.chain = chain;
+exports.chainFirst = chainFirst;
+exports.chainFirstW = chainFirstW;
+exports.chainNullableK = chainNullableK;
+exports.chainOptionK = chainOptionK;
+exports.chainOptionKW = chainOptionKW;
+exports.chainW = chainW;
+exports.duplicate = duplicate;
+exports.either = either;
+exports.elem = elem;
+exports.exists = exists;
+exports.extend = extend;
+exports.filterOrElse = filterOrElse;
+exports.filterOrElseW = filterOrElseW;
+exports.flap = flap;
+exports.flatMap = flatMap;
+exports.flatMapNullable = flatMapNullable;
+exports.flatMapOption = flatMapOption;
+exports.flatten = flatten;
+exports.flattenW = flattenW;
 exports.fold = fold;
+exports.foldMap = foldMap;
 exports.foldW = foldW;
+exports.fromNullable = fromNullable;
+exports.fromNullableK = fromNullableK;
+exports.fromOption = fromOption;
+exports.fromOptionK = fromOptionK;
+exports.fromPredicate = fromPredicate;
+exports.getAltValidation = getAltValidation;
+exports.getApplicativeValidation = getApplicativeValidation;
+exports.getApplyMonoid = getApplyMonoid;
+exports.getApplySemigroup = getApplySemigroup;
+exports.getCompactable = getCompactable;
+exports.getEq = getEq;
+exports.getFilterable = getFilterable;
+exports.getOrElse = getOrElse;
+exports.getOrElseW = getOrElseW;
+exports.getSemigroup = getSemigroup;
+exports.getShow = getShow;
+exports.getValidation = getValidation;
+exports.getValidationMonoid = getValidationMonoid;
+exports.getValidationSemigroup = getValidationSemigroup;
+exports.getWitherable = getWitherable;
 exports.isLeft = isLeft;
+exports.isRight = isRight;
+exports.left = left;
+exports.let = let_;
+exports.liftNullable = liftNullable;
+exports.liftOption = liftOption;
+exports.map = map;
+exports.mapLeft = mapLeft;
 exports.match = match;
 exports.matchW = matchW;
+exports.of = of;
+exports.orElse = orElse;
+exports.orElseW = orElseW;
+exports.parseJSON = parseJSON;
+exports.reduce = reduce;
+exports.reduceRight = reduceRight;
+exports.right = right;
+exports.sequence = sequence;
+exports.sequenceArray = sequenceArray;
+exports.stringifyJSON = stringifyJSON;
+exports.swap = swap;
+exports.tap = tap;
+exports.throwError = throwError;
+exports.toError = toError;
+exports.toUnion = toUnion;
+exports.traverse = traverse;
+exports.traverseArray = traverseArray;
+exports.traverseArrayWithIndex = traverseArrayWithIndex;
+exports.traverseReadonlyArrayWithIndex = traverseReadonlyArrayWithIndex;
+exports.traverseReadonlyNonEmptyArrayWithIndex = traverseReadonlyNonEmptyArrayWithIndex;
+exports.tryCatch = tryCatch;
+exports.tryCatchK = tryCatchK;
 //# sourceMappingURL=Either.cjs.map