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

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

@@ -1,4 +1,4 @@
-globalThis && globalThis.__spreadArray || function(to, from, pack) {
+var __spreadArray = globalThis && globalThis.__spreadArray || function(to, from, pack) {
   if (pack || arguments.length === 2)
     for (var i = 0, l = from.length, ar; i < l; i++) {
       if (ar || !(i in from)) {
@@ -9,6 +9,196 @@ globalThis && globalThis.__spreadArray || function(to, from, pack) {
     }
   return to.concat(ar || Array.prototype.slice.call(from));
 };
+var getBooleanAlgebra = function(B) {
+  return function() {
+    return {
+      meet: function(x, y) {
+        return function(a) {
+          return B.meet(x(a), y(a));
+        };
+      },
+      join: function(x, y) {
+        return function(a) {
+          return B.join(x(a), y(a));
+        };
+      },
+      zero: function() {
+        return B.zero;
+      },
+      one: function() {
+        return B.one;
+      },
+      implies: function(x, y) {
+        return function(a) {
+          return B.implies(x(a), y(a));
+        };
+      },
+      not: function(x) {
+        return function(a) {
+          return B.not(x(a));
+        };
+      }
+    };
+  };
+};
+var getSemigroup = function(S) {
+  return function() {
+    return {
+      concat: function(f, g) {
+        return function(a) {
+          return S.concat(f(a), g(a));
+        };
+      }
+    };
+  };
+};
+var getMonoid = function(M) {
+  var getSemigroupM = getSemigroup(M);
+  return function() {
+    return {
+      concat: getSemigroupM().concat,
+      empty: function() {
+        return M.empty;
+      }
+    };
+  };
+};
+var getSemiring = function(S) {
+  return {
+    add: function(f, g) {
+      return function(x) {
+        return S.add(f(x), g(x));
+      };
+    },
+    zero: function() {
+      return S.zero;
+    },
+    mul: function(f, g) {
+      return function(x) {
+        return S.mul(f(x), g(x));
+      };
+    },
+    one: function() {
+      return S.one;
+    }
+  };
+};
+var getRing = function(R) {
+  var S = getSemiring(R);
+  return {
+    add: S.add,
+    mul: S.mul,
+    one: S.one,
+    zero: S.zero,
+    sub: function(f, g) {
+      return function(x) {
+        return R.sub(f(x), g(x));
+      };
+    }
+  };
+};
+var apply = function(a) {
+  return function(f) {
+    return f(a);
+  };
+};
+function identity(a) {
+  return a;
+}
+var unsafeCoerce = identity;
+function constant(a) {
+  return function() {
+    return a;
+  };
+}
+var constTrue = /* @__PURE__ */ constant(true);
+var constFalse = /* @__PURE__ */ constant(false);
+var constNull = /* @__PURE__ */ constant(null);
+var constUndefined = /* @__PURE__ */ constant(void 0);
+var constVoid = constUndefined;
+function flip(f) {
+  return function() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      args[_i] = arguments[_i];
+    }
+    if (args.length > 1) {
+      return f(args[1], args[0]);
+    }
+    return function(a) {
+      return f(a)(args[0]);
+    };
+  };
+}
+function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {
+  switch (arguments.length) {
+    case 1:
+      return ab;
+    case 2:
+      return function() {
+        return bc(ab.apply(this, arguments));
+      };
+    case 3:
+      return function() {
+        return cd(bc(ab.apply(this, arguments)));
+      };
+    case 4:
+      return function() {
+        return de(cd(bc(ab.apply(this, arguments))));
+      };
+    case 5:
+      return function() {
+        return ef(de(cd(bc(ab.apply(this, arguments)))));
+      };
+    case 6:
+      return function() {
+        return fg(ef(de(cd(bc(ab.apply(this, arguments))))));
+      };
+    case 7:
+      return function() {
+        return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));
+      };
+    case 8:
+      return function() {
+        return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));
+      };
+    case 9:
+      return function() {
+        return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));
+      };
+  }
+  return;
+}
+function tuple() {
+  var t = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    t[_i] = arguments[_i];
+  }
+  return t;
+}
+function increment(n) {
+  return n + 1;
+}
+function decrement(n) {
+  return n - 1;
+}
+function absurd(_) {
+  throw new Error("Called `absurd` function which should be uncallable");
+}
+function tupled(f) {
+  return function(a) {
+    return f.apply(void 0, a);
+  };
+}
+function untupled(f) {
+  return function() {
+    var a = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      a[_i] = arguments[_i];
+    }
+    return f(a);
+  };
+}
 function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   switch (arguments.length) {
     case 1:
@@ -38,7 +228,65 @@ function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
     }
   }
 }
+var hole = absurd;
+var SK = function(_, b) {
+  return b;
+};
+function not(predicate) {
+  return function(a) {
+    return !predicate(a);
+  };
+}
+var getEndomorphismMonoid = function() {
+  return {
+    concat: function(first, second) {
+      return flow(first, second);
+    },
+    empty: identity
+  };
+};
+var dual = function(arity, body) {
+  var isDataFirst = typeof arity === "number" ? function(args) {
+    return args.length >= arity;
+  } : arity;
+  return function() {
+    var args = Array.from(arguments);
+    if (isDataFirst(arguments)) {
+      return body.apply(this, args);
+    }
+    return function(self) {
+      return body.apply(void 0, __spreadArray([self], args, false));
+    };
+  };
+};
 export {
-  pipe
+  SK,
+  absurd,
+  apply,
+  constFalse,
+  constNull,
+  constTrue,
+  constUndefined,
+  constVoid,
+  constant,
+  decrement,
+  dual,
+  flip,
+  flow,
+  getBooleanAlgebra,
+  getEndomorphismMonoid,
+  getMonoid,
+  getRing,
+  getSemigroup,
+  getSemiring,
+  hole,
+  identity,
+  increment,
+  not,
+  pipe,
+  tuple,
+  tupled,
+  unsafeCoerce,
+  untupled
 };
 //# sourceMappingURL=function.js.map

package/dist/_node_modules/fp-ts/es6/function.js.map

@@ -1 +1 @@
-{"version":3,"file":"function.js","sources":["../../../../../../node_modules/fp-ts/es6/function.js"],"sourcesContent":["var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var getBooleanAlgebra = function (B) {\n    return function () { return ({\n        meet: function (x, y) { return function (a) { return B.meet(x(a), y(a)); }; },\n        join: function (x, y) { return function (a) { return B.join(x(a), y(a)); }; },\n        zero: function () { return B.zero; },\n        one: function () { return B.one; },\n        implies: function (x, y) { return function (a) { return B.implies(x(a), y(a)); }; },\n        not: function (x) { return function (a) { return B.not(x(a)); }; }\n    }); };\n};\n/**\n * Unary functions form a semigroup as long as you can provide a semigroup for the codomain.\n *\n * @example\n * import { Predicate, getSemigroup } from 'fp-ts/function'\n * import * as B from 'fp-ts/boolean'\n *\n * const f: Predicate<number> = (n) => n <= 2\n * const g: Predicate<number> = (n) => n >= 0\n *\n * const S1 = getSemigroup(B.SemigroupAll)<number>()\n *\n * assert.deepStrictEqual(S1.concat(f, g)(1), true)\n * assert.deepStrictEqual(S1.concat(f, g)(3), false)\n *\n * const S2 = getSemigroup(B.SemigroupAny)<number>()\n *\n * assert.deepStrictEqual(S2.concat(f, g)(1), true)\n * assert.deepStrictEqual(S2.concat(f, g)(3), true)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var getSemigroup = function (S) {\n    return function () { return ({\n        concat: function (f, g) { return function (a) { return S.concat(f(a), g(a)); }; }\n    }); };\n};\n/**\n * Unary functions form a monoid as long as you can provide a monoid for the codomain.\n *\n * @example\n * import { Predicate } from 'fp-ts/Predicate'\n * import { getMonoid } from 'fp-ts/function'\n * import * as B from 'fp-ts/boolean'\n *\n * const f: Predicate<number> = (n) => n <= 2\n * const g: Predicate<number> = (n) => n >= 0\n *\n * const M1 = getMonoid(B.MonoidAll)<number>()\n *\n * assert.deepStrictEqual(M1.concat(f, g)(1), true)\n * assert.deepStrictEqual(M1.concat(f, g)(3), false)\n *\n * const M2 = getMonoid(B.MonoidAny)<number>()\n *\n * assert.deepStrictEqual(M2.concat(f, g)(1), true)\n * assert.deepStrictEqual(M2.concat(f, g)(3), true)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var getMonoid = function (M) {\n    var getSemigroupM = getSemigroup(M);\n    return function () { return ({\n        concat: getSemigroupM().concat,\n        empty: function () { return M.empty; }\n    }); };\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var getSemiring = function (S) { return ({\n    add: function (f, g) { return function (x) { return S.add(f(x), g(x)); }; },\n    zero: function () { return S.zero; },\n    mul: function (f, g) { return function (x) { return S.mul(f(x), g(x)); }; },\n    one: function () { return S.one; }\n}); };\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var getRing = function (R) {\n    var S = getSemiring(R);\n    return {\n        add: S.add,\n        mul: S.mul,\n        one: S.one,\n        zero: S.zero,\n        sub: function (f, g) { return function (x) { return R.sub(f(x), g(x)); }; }\n    };\n};\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.11.0\n */\nexport var apply = function (a) {\n    return function (f) {\n        return f(a);\n    };\n};\n/**\n * @since 2.0.0\n */\nexport function identity(a) {\n    return a;\n}\n/**\n * @since 2.0.0\n */\nexport var unsafeCoerce = identity;\n/**\n * @since 2.0.0\n */\nexport function constant(a) {\n    return function () { return a; };\n}\n/**\n * A thunk that returns always `true`.\n *\n * @since 2.0.0\n */\nexport var constTrue = /*#__PURE__*/ constant(true);\n/**\n * A thunk that returns always `false`.\n *\n * @since 2.0.0\n */\nexport var constFalse = /*#__PURE__*/ constant(false);\n/**\n * A thunk that returns always `null`.\n *\n * @since 2.0.0\n */\nexport var constNull = /*#__PURE__*/ constant(null);\n/**\n * A thunk that returns always `undefined`.\n *\n * @since 2.0.0\n */\nexport var constUndefined = /*#__PURE__*/ constant(undefined);\n/**\n * A thunk that returns always `void`.\n *\n * @since 2.0.0\n */\nexport var constVoid = constUndefined;\nexport function flip(f) {\n    return function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (args.length > 1) {\n            return f(args[1], args[0]);\n        }\n        return function (a) { return f(a)(args[0]); };\n    };\n}\nexport function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {\n    switch (arguments.length) {\n        case 1:\n            return ab;\n        case 2:\n            return function () {\n                return bc(ab.apply(this, arguments));\n            };\n        case 3:\n            return function () {\n                return cd(bc(ab.apply(this, arguments)));\n            };\n        case 4:\n            return function () {\n                return de(cd(bc(ab.apply(this, arguments))));\n            };\n        case 5:\n            return function () {\n                return ef(de(cd(bc(ab.apply(this, arguments)))));\n            };\n        case 6:\n            return function () {\n                return fg(ef(de(cd(bc(ab.apply(this, arguments))))));\n            };\n        case 7:\n            return function () {\n                return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));\n            };\n        case 8:\n            return function () {\n                return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));\n            };\n        case 9:\n            return function () {\n                return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));\n            };\n    }\n    return;\n}\n/**\n * @since 2.0.0\n */\nexport function tuple() {\n    var t = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        t[_i] = arguments[_i];\n    }\n    return t;\n}\n/**\n * @since 2.0.0\n */\nexport function increment(n) {\n    return n + 1;\n}\n/**\n * @since 2.0.0\n */\nexport function decrement(n) {\n    return n - 1;\n}\n/**\n * @since 2.0.0\n */\nexport function absurd(_) {\n    throw new Error('Called `absurd` function which should be uncallable');\n}\n/**\n * Creates a tupled version of this function: instead of `n` arguments, it accepts a single tuple argument.\n *\n * @example\n * import { tupled } from 'fp-ts/function'\n *\n * const add = tupled((x: number, y: number): number => x + y)\n *\n * assert.strictEqual(add([1, 2]), 3)\n *\n * @since 2.4.0\n */\nexport function tupled(f) {\n    return function (a) { return f.apply(void 0, a); };\n}\n/**\n * Inverse function of `tupled`\n *\n * @since 2.4.0\n */\nexport function untupled(f) {\n    return function () {\n        var a = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            a[_i] = arguments[_i];\n        }\n        return f(a);\n    };\n}\nexport function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {\n    switch (arguments.length) {\n        case 1:\n            return a;\n        case 2:\n            return ab(a);\n        case 3:\n            return bc(ab(a));\n        case 4:\n            return cd(bc(ab(a)));\n        case 5:\n            return de(cd(bc(ab(a))));\n        case 6:\n            return ef(de(cd(bc(ab(a)))));\n        case 7:\n            return fg(ef(de(cd(bc(ab(a))))));\n        case 8:\n            return gh(fg(ef(de(cd(bc(ab(a)))))));\n        case 9:\n            return hi(gh(fg(ef(de(cd(bc(ab(a))))))));\n        default: {\n            var ret = arguments[0];\n            for (var i = 1; i < arguments.length; i++) {\n                ret = arguments[i](ret);\n            }\n            return ret;\n        }\n    }\n}\n/**\n * Type hole simulation\n *\n * @since 2.7.0\n */\nexport var hole = absurd;\n/**\n * @since 2.11.0\n */\nexport var SK = function (_, b) { return b; };\n/**\n * Use `Predicate` module instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport function not(predicate) {\n    return function (a) { return !predicate(a); };\n}\n/**\n * Use `Endomorphism` module instead.\n *\n * @category zone of death\n * @since 2.10.0\n * @deprecated\n */\nexport var getEndomorphismMonoid = function () { return ({\n    concat: function (first, second) { return flow(first, second); },\n    empty: identity\n}); };\n/** @internal */\nexport var dual = function (arity, body) {\n    var isDataFirst = typeof arity === 'number' ? function (args) { return args.length >= arity; } : arity;\n    return function () {\n        var args = Array.from(arguments);\n        if (isDataFirst(arguments)) {\n            return body.apply(this, args);\n        }\n        return function (self) { return body.apply(void 0, __spreadArray([self], args, false)); };\n    };\n};\n"],"names":["this"],"mappings":"AAAqBA,cAAQA,WAAK,iBAAkB,SAAU,IAAI,MAAM,MAAM;AAC1E,MAAI,QAAQ,UAAU,WAAW;AAAG,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,IAAI,IAAI,GAAG,KAAK;AACjF,UAAI,MAAM,EAAE,KAAK,OAAO;AACpB,YAAI,CAAC;AAAI,eAAK,MAAM,UAAU,MAAM,KAAK,MAAM,GAAG,CAAC;AACnD,WAAG,CAAC,IAAI,KAAK,CAAC;AAAA,MACjB;AAAA,IACJ;AACD,SAAO,GAAG,OAAO,MAAM,MAAM,UAAU,MAAM,KAAK,IAAI,CAAC;AAC3D;AA0QO,SAAS,KAAK,GAAG,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI;AACpD,UAAQ,UAAU,QAAM;AAAA,IACpB,KAAK;AACD,aAAO;AAAA,IACX,KAAK;AACD,aAAO,GAAG,CAAC;AAAA,IACf,KAAK;AACD,aAAO,GAAG,GAAG,CAAC,CAAC;AAAA,IACnB,KAAK;AACD,aAAO,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC;AAAA,IACvB,KAAK;AACD,aAAO,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;AAAA,IAC3B,KAAK;AACD,aAAO,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;AAAA,IAC/B,KAAK;AACD,aAAO,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAAA,IACnC,KAAK;AACD,aAAO,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAAA,IACvC,KAAK;AACD,aAAO,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAAA,IAC3C,SAAS;AACL,UAAI,MAAM,UAAU,CAAC;AACrB,eAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AACvC,cAAM,UAAU,CAAC,EAAE,GAAG;AAAA,MACzB;AACD,aAAO;AAAA,IACV;AAAA,EACJ;AACL;","x_google_ignoreList":[0]}
+{"version":3,"file":"function.js","sources":["../../../../../../node_modules/fp-ts/es6/function.js"],"sourcesContent":["var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var getBooleanAlgebra = function (B) {\n    return function () { return ({\n        meet: function (x, y) { return function (a) { return B.meet(x(a), y(a)); }; },\n        join: function (x, y) { return function (a) { return B.join(x(a), y(a)); }; },\n        zero: function () { return B.zero; },\n        one: function () { return B.one; },\n        implies: function (x, y) { return function (a) { return B.implies(x(a), y(a)); }; },\n        not: function (x) { return function (a) { return B.not(x(a)); }; }\n    }); };\n};\n/**\n * Unary functions form a semigroup as long as you can provide a semigroup for the codomain.\n *\n * @example\n * import { Predicate, getSemigroup } from 'fp-ts/function'\n * import * as B from 'fp-ts/boolean'\n *\n * const f: Predicate<number> = (n) => n <= 2\n * const g: Predicate<number> = (n) => n >= 0\n *\n * const S1 = getSemigroup(B.SemigroupAll)<number>()\n *\n * assert.deepStrictEqual(S1.concat(f, g)(1), true)\n * assert.deepStrictEqual(S1.concat(f, g)(3), false)\n *\n * const S2 = getSemigroup(B.SemigroupAny)<number>()\n *\n * assert.deepStrictEqual(S2.concat(f, g)(1), true)\n * assert.deepStrictEqual(S2.concat(f, g)(3), true)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var getSemigroup = function (S) {\n    return function () { return ({\n        concat: function (f, g) { return function (a) { return S.concat(f(a), g(a)); }; }\n    }); };\n};\n/**\n * Unary functions form a monoid as long as you can provide a monoid for the codomain.\n *\n * @example\n * import { Predicate } from 'fp-ts/Predicate'\n * import { getMonoid } from 'fp-ts/function'\n * import * as B from 'fp-ts/boolean'\n *\n * const f: Predicate<number> = (n) => n <= 2\n * const g: Predicate<number> = (n) => n >= 0\n *\n * const M1 = getMonoid(B.MonoidAll)<number>()\n *\n * assert.deepStrictEqual(M1.concat(f, g)(1), true)\n * assert.deepStrictEqual(M1.concat(f, g)(3), false)\n *\n * const M2 = getMonoid(B.MonoidAny)<number>()\n *\n * assert.deepStrictEqual(M2.concat(f, g)(1), true)\n * assert.deepStrictEqual(M2.concat(f, g)(3), true)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var getMonoid = function (M) {\n    var getSemigroupM = getSemigroup(M);\n    return function () { return ({\n        concat: getSemigroupM().concat,\n        empty: function () { return M.empty; }\n    }); };\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var getSemiring = function (S) { return ({\n    add: function (f, g) { return function (x) { return S.add(f(x), g(x)); }; },\n    zero: function () { return S.zero; },\n    mul: function (f, g) { return function (x) { return S.mul(f(x), g(x)); }; },\n    one: function () { return S.one; }\n}); };\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var getRing = function (R) {\n    var S = getSemiring(R);\n    return {\n        add: S.add,\n        mul: S.mul,\n        one: S.one,\n        zero: S.zero,\n        sub: function (f, g) { return function (x) { return R.sub(f(x), g(x)); }; }\n    };\n};\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.11.0\n */\nexport var apply = function (a) {\n    return function (f) {\n        return f(a);\n    };\n};\n/**\n * @since 2.0.0\n */\nexport function identity(a) {\n    return a;\n}\n/**\n * @since 2.0.0\n */\nexport var unsafeCoerce = identity;\n/**\n * @since 2.0.0\n */\nexport function constant(a) {\n    return function () { return a; };\n}\n/**\n * A thunk that returns always `true`.\n *\n * @since 2.0.0\n */\nexport var constTrue = /*#__PURE__*/ constant(true);\n/**\n * A thunk that returns always `false`.\n *\n * @since 2.0.0\n */\nexport var constFalse = /*#__PURE__*/ constant(false);\n/**\n * A thunk that returns always `null`.\n *\n * @since 2.0.0\n */\nexport var constNull = /*#__PURE__*/ constant(null);\n/**\n * A thunk that returns always `undefined`.\n *\n * @since 2.0.0\n */\nexport var constUndefined = /*#__PURE__*/ constant(undefined);\n/**\n * A thunk that returns always `void`.\n *\n * @since 2.0.0\n */\nexport var constVoid = constUndefined;\nexport function flip(f) {\n    return function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        if (args.length > 1) {\n            return f(args[1], args[0]);\n        }\n        return function (a) { return f(a)(args[0]); };\n    };\n}\nexport function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {\n    switch (arguments.length) {\n        case 1:\n            return ab;\n        case 2:\n            return function () {\n                return bc(ab.apply(this, arguments));\n            };\n        case 3:\n            return function () {\n                return cd(bc(ab.apply(this, arguments)));\n            };\n        case 4:\n            return function () {\n                return de(cd(bc(ab.apply(this, arguments))));\n            };\n        case 5:\n            return function () {\n                return ef(de(cd(bc(ab.apply(this, arguments)))));\n            };\n        case 6:\n            return function () {\n                return fg(ef(de(cd(bc(ab.apply(this, arguments))))));\n            };\n        case 7:\n            return function () {\n                return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));\n            };\n        case 8:\n            return function () {\n                return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));\n            };\n        case 9:\n            return function () {\n                return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));\n            };\n    }\n    return;\n}\n/**\n * @since 2.0.0\n */\nexport function tuple() {\n    var t = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        t[_i] = arguments[_i];\n    }\n    return t;\n}\n/**\n * @since 2.0.0\n */\nexport function increment(n) {\n    return n + 1;\n}\n/**\n * @since 2.0.0\n */\nexport function decrement(n) {\n    return n - 1;\n}\n/**\n * @since 2.0.0\n */\nexport function absurd(_) {\n    throw new Error('Called `absurd` function which should be uncallable');\n}\n/**\n * Creates a tupled version of this function: instead of `n` arguments, it accepts a single tuple argument.\n *\n * @example\n * import { tupled } from 'fp-ts/function'\n *\n * const add = tupled((x: number, y: number): number => x + y)\n *\n * assert.strictEqual(add([1, 2]), 3)\n *\n * @since 2.4.0\n */\nexport function tupled(f) {\n    return function (a) { return f.apply(void 0, a); };\n}\n/**\n * Inverse function of `tupled`\n *\n * @since 2.4.0\n */\nexport function untupled(f) {\n    return function () {\n        var a = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            a[_i] = arguments[_i];\n        }\n        return f(a);\n    };\n}\nexport function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {\n    switch (arguments.length) {\n        case 1:\n            return a;\n        case 2:\n            return ab(a);\n        case 3:\n            return bc(ab(a));\n        case 4:\n            return cd(bc(ab(a)));\n        case 5:\n            return de(cd(bc(ab(a))));\n        case 6:\n            return ef(de(cd(bc(ab(a)))));\n        case 7:\n            return fg(ef(de(cd(bc(ab(a))))));\n        case 8:\n            return gh(fg(ef(de(cd(bc(ab(a)))))));\n        case 9:\n            return hi(gh(fg(ef(de(cd(bc(ab(a))))))));\n        default: {\n            var ret = arguments[0];\n            for (var i = 1; i < arguments.length; i++) {\n                ret = arguments[i](ret);\n            }\n            return ret;\n        }\n    }\n}\n/**\n * Type hole simulation\n *\n * @since 2.7.0\n */\nexport var hole = absurd;\n/**\n * @since 2.11.0\n */\nexport var SK = function (_, b) { return b; };\n/**\n * Use `Predicate` module instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport function not(predicate) {\n    return function (a) { return !predicate(a); };\n}\n/**\n * Use `Endomorphism` module instead.\n *\n * @category zone of death\n * @since 2.10.0\n * @deprecated\n */\nexport var getEndomorphismMonoid = function () { return ({\n    concat: function (first, second) { return flow(first, second); },\n    empty: identity\n}); };\n/** @internal */\nexport var dual = function (arity, body) {\n    var isDataFirst = typeof arity === 'number' ? function (args) { return args.length >= arity; } : arity;\n    return function () {\n        var args = Array.from(arguments);\n        if (isDataFirst(arguments)) {\n            return body.apply(this, args);\n        }\n        return function (self) { return body.apply(void 0, __spreadArray([self], args, false)); };\n    };\n};\n"],"names":["this"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/_node_modules/fp-ts/es6/index.cjs

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Alt = require("./Alt.cjs");
+const Alternative = require("./Alternative.cjs");
+const Applicative = require("./Applicative.cjs");
+const Apply = require("./Apply.cjs");
+const Array = require("./Array.cjs");
+const Bifunctor = require("./Bifunctor.cjs");
+const boolean = require("./boolean.cjs");
+const BooleanAlgebra = require("./BooleanAlgebra.cjs");
+const Bounded = require("./Bounded.cjs");
+const BoundedDistributiveLattice = require("./BoundedDistributiveLattice.cjs");
+const BoundedJoinSemilattice = require("./BoundedJoinSemilattice.cjs");
+const BoundedLattice = require("./BoundedLattice.cjs");
+const BoundedMeetSemilattice = require("./BoundedMeetSemilattice.cjs");
+const Category = require("./Category.cjs");
+const Chain = require("./Chain.cjs");
+const ChainRec = require("./ChainRec.cjs");
+const Choice = require("./Choice.cjs");
+const Comonad = require("./Comonad.cjs");
+const Compactable = require("./Compactable.cjs");
+const Console = require("./Console.cjs");
+const Const = require("./Const.cjs");
+const Contravariant = require("./Contravariant.cjs");
+const Date = require("./Date.cjs");
+const DistributiveLattice = require("./DistributiveLattice.cjs");
+const Either = require("./Either.cjs");
+const EitherT = require("./EitherT.cjs");
+const Endomorphism = require("./Endomorphism.cjs");
+const Eq = require("./Eq.cjs");
+const Extend = require("./Extend.cjs");
+const Field = require("./Field.cjs");
+const Filterable = require("./Filterable.cjs");
+const FilterableWithIndex = require("./FilterableWithIndex.cjs");
+const Foldable = require("./Foldable.cjs");
+const FoldableWithIndex = require("./FoldableWithIndex.cjs");
+const FromEither = require("./FromEither.cjs");
+const FromIO = require("./FromIO.cjs");
+const FromReader = require("./FromReader.cjs");
+const FromState = require("./FromState.cjs");
+const FromTask = require("./FromTask.cjs");
+const FromThese = require("./FromThese.cjs");
+const _function = require("./function.cjs");
+const Functor = require("./Functor.cjs");
+const FunctorWithIndex = require("./FunctorWithIndex.cjs");
+const Group = require("./Group.cjs");
+const HeytingAlgebra = require("./HeytingAlgebra.cjs");
+const index = require("./HKT/index.cjs");
+const Identity = require("./Identity.cjs");
+const Invariant = require("./Invariant.cjs");
+const IO = require("./IO.cjs");
+const IOEither = require("./IOEither.cjs");
+const IOOption = require("./IOOption.cjs");
+const IORef = require("./IORef.cjs");
+const JoinSemilattice = require("./JoinSemilattice.cjs");
+const Json = require("./Json.cjs");
+const Lattice = require("./Lattice.cjs");
+const Magma = require("./Magma.cjs");
+const Map = require("./Map.cjs");
+const MeetSemilattice = require("./MeetSemilattice.cjs");
+const Monad = require("./Monad.cjs");
+const MonadIO = require("./MonadIO.cjs");
+const MonadTask = require("./MonadTask.cjs");
+const MonadThrow = require("./MonadThrow.cjs");
+const Monoid = require("./Monoid.cjs");
+const NaturalTransformation = require("./NaturalTransformation.cjs");
+const NonEmptyArray = require("./NonEmptyArray.cjs");
+const number = require("./number.cjs");
+const Option = require("./Option.cjs");
+const OptionT = require("./OptionT.cjs");
+const Ord = require("./Ord.cjs");
+const Ordering = require("./Ordering.cjs");
+const pipeable = require("./pipeable.cjs");
+const Pointed = require("./Pointed.cjs");
+const Predicate = require("./Predicate.cjs");
+const Profunctor = require("./Profunctor.cjs");
+const Random = require("./Random.cjs");
+const Reader = require("./Reader.cjs");
+const ReaderEither = require("./ReaderEither.cjs");
+const ReaderIO = require("./ReaderIO.cjs");
+const ReaderT = require("./ReaderT.cjs");
+const ReaderTask = require("./ReaderTask.cjs");
+const ReaderTaskEither = require("./ReaderTaskEither.cjs");
+const ReadonlyArray = require("./ReadonlyArray.cjs");
+const ReadonlyMap = require("./ReadonlyMap.cjs");
+const ReadonlyNonEmptyArray = require("./ReadonlyNonEmptyArray.cjs");
+const ReadonlyRecord = require("./ReadonlyRecord.cjs");
+const ReadonlySet = require("./ReadonlySet.cjs");
+const ReadonlyTuple = require("./ReadonlyTuple.cjs");
+const Record = require("./Record.cjs");
+const Refinement = require("./Refinement.cjs");
+const Ring = require("./Ring.cjs");
+const Semigroup = require("./Semigroup.cjs");
+const Semigroupoid = require("./Semigroupoid.cjs");
+const Semiring = require("./Semiring.cjs");
+const Separated = require("./Separated.cjs");
+const Set = require("./Set.cjs");
+const Show = require("./Show.cjs");
+const State = require("./State.cjs");
+const StateReaderTaskEither = require("./StateReaderTaskEither.cjs");
+const StateT = require("./StateT.cjs");
+const Store = require("./Store.cjs");
+const string = require("./string.cjs");
+const Strong = require("./Strong.cjs");
+const struct = require("./struct.cjs");
+const Task = require("./Task.cjs");
+const TaskEither = require("./TaskEither.cjs");
+const TaskOption = require("./TaskOption.cjs");
+const TaskThese = require("./TaskThese.cjs");
+const These = require("./These.cjs");
+const TheseT = require("./TheseT.cjs");
+const Traced = require("./Traced.cjs");
+const Traversable = require("./Traversable.cjs");
+const TraversableWithIndex = require("./TraversableWithIndex.cjs");
+const Tree = require("./Tree.cjs");
+const Tuple = require("./Tuple.cjs");
+const Unfoldable = require("./Unfoldable.cjs");
+const ValidationT = require("./ValidationT.cjs");
+const _void = require("./void.cjs");
+const Witherable = require("./Witherable.cjs");
+const Writer = require("./Writer.cjs");
+const WriterT = require("./WriterT.cjs");
+const Zero = require("./Zero.cjs");
+exports.alt = Alt;
+exports.alternative = Alternative;
+exports.applicative = Applicative;
+exports.apply = Apply;
+exports.array = Array;
+exports.bifunctor = Bifunctor;
+exports.boolean = boolean;
+exports.booleanAlgebra = BooleanAlgebra;
+exports.bounded = Bounded;
+exports.boundedDistributiveLattice = BoundedDistributiveLattice;
+exports.boundedJoinSemilattice = BoundedJoinSemilattice;
+exports.boundedLattice = BoundedLattice;
+exports.boundedMeetSemilattice = BoundedMeetSemilattice;
+exports.category = Category;
+exports.chain = Chain;
+exports.chainRec = ChainRec;
+exports.choice = Choice;
+exports.comonad = Comonad;
+exports.compactable = Compactable;
+exports.console = Console;
+exports.const = Const;
+exports.contravariant = Contravariant;
+exports.date = Date;
+exports.distributiveLattice = DistributiveLattice;
+exports.either = Either;
+exports.eitherT = EitherT;
+exports.endomorphism = Endomorphism;
+exports.eq = Eq;
+exports.extend = Extend;
+exports.field = Field;
+exports.filterable = Filterable;
+exports.filterableWithIndex = FilterableWithIndex;
+exports.foldable = Foldable;
+exports.foldableWithIndex = FoldableWithIndex;
+exports.fromEither = FromEither;
+exports.fromIO = FromIO;
+exports.fromReader = FromReader;
+exports.fromState = FromState;
+exports.fromTask = FromTask;
+exports.fromThese = FromThese;
+exports.function = _function;
+exports.functor = Functor;
+exports.functorWithIndex = FunctorWithIndex;
+exports.group = Group;
+exports.heytingAlgebra = HeytingAlgebra;
+exports.hkt = index;
+exports.identity = Identity;
+exports.invariant = Invariant;
+exports.io = IO;
+exports.ioEither = IOEither;
+exports.ioOption = IOOption;
+exports.ioRef = IORef;
+exports.joinSemilattice = JoinSemilattice;
+exports.json = Json;
+exports.lattice = Lattice;
+exports.magma = Magma;
+exports.map = Map;
+exports.meetSemilattice = MeetSemilattice;
+exports.monad = Monad;
+exports.monadIO = MonadIO;
+exports.monadTask = MonadTask;
+exports.monadThrow = MonadThrow;
+exports.monoid = Monoid;
+exports.naturalTransformation = NaturalTransformation;
+exports.nonEmptyArray = NonEmptyArray;
+exports.number = number;
+exports.option = Option;
+exports.optionT = OptionT;
+exports.ord = Ord;
+exports.ordering = Ordering;
+exports.pipeable = pipeable;
+exports.pointed = Pointed;
+exports.predicate = Predicate;
+exports.profunctor = Profunctor;
+exports.random = Random;
+exports.reader = Reader;
+exports.readerEither = ReaderEither;
+exports.readerIO = ReaderIO;
+exports.readerT = ReaderT;
+exports.readerTask = ReaderTask;
+exports.readerTaskEither = ReaderTaskEither;
+exports.readonlyArray = ReadonlyArray;
+exports.readonlyMap = ReadonlyMap;
+exports.readonlyNonEmptyArray = ReadonlyNonEmptyArray;
+exports.readonlyRecord = ReadonlyRecord;
+exports.readonlySet = ReadonlySet;
+exports.readonlyTuple = ReadonlyTuple;
+exports.record = Record;
+exports.refinement = Refinement;
+exports.ring = Ring;
+exports.semigroup = Semigroup;
+exports.semigroupoid = Semigroupoid;
+exports.semiring = Semiring;
+exports.separated = Separated;
+exports.set = Set;
+exports.show = Show;
+exports.state = State;
+exports.stateReaderTaskEither = StateReaderTaskEither;
+exports.stateT = StateT;
+exports.store = Store;
+exports.string = string;
+exports.strong = Strong;
+exports.struct = struct;
+exports.task = Task;
+exports.taskEither = TaskEither;
+exports.taskOption = TaskOption;
+exports.taskThese = TaskThese;
+exports.these = These;
+exports.theseT = TheseT;
+exports.traced = Traced;
+exports.traversable = Traversable;
+exports.traversableWithIndex = TraversableWithIndex;
+exports.tree = Tree;
+exports.tuple = Tuple;
+exports.unfoldable = Unfoldable;
+exports.validationT = ValidationT;
+exports.void = _void;
+exports.witherable = Witherable;
+exports.writer = Writer;
+exports.writerT = WriterT;
+exports.zero = Zero;
+//# sourceMappingURL=index.cjs.map

package/dist/_node_modules/fp-ts/es6/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}