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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var isBoolean = function(u) {
+  return typeof u === "boolean";
+};
+var matchW = function(onFalse, onTrue) {
+  return function(value) {
+    return value ? onTrue() : onFalse();
+  };
+};
+var foldW = matchW;
+var match = foldW;
+var fold = match;
+var Eq = {
+  equals: function(first, second) {
+    return first === second;
+  }
+};
+var BooleanAlgebra = {
+  meet: function(first, second) {
+    return first && second;
+  },
+  join: function(first, second) {
+    return first || second;
+  },
+  zero: false,
+  one: true,
+  implies: function(first, second) {
+    return !first || second;
+  },
+  not: function(b) {
+    return !b;
+  }
+};
+var SemigroupAll = {
+  concat: function(first, second) {
+    return first && second;
+  }
+};
+var SemigroupAny = {
+  concat: function(first, second) {
+    return first || second;
+  }
+};
+var MonoidAll = {
+  concat: SemigroupAll.concat,
+  empty: true
+};
+var MonoidAny = {
+  concat: SemigroupAny.concat,
+  empty: false
+};
+var Ord = {
+  equals: Eq.equals,
+  compare: function(first, second) {
+    return first < second ? -1 : first > second ? 1 : 0;
+  }
+};
+var Show = {
+  show: function(b) {
+    return JSON.stringify(b);
+  }
+};
+exports.BooleanAlgebra = BooleanAlgebra;
+exports.Eq = Eq;
+exports.MonoidAll = MonoidAll;
+exports.MonoidAny = MonoidAny;
+exports.Ord = Ord;
+exports.SemigroupAll = SemigroupAll;
+exports.SemigroupAny = SemigroupAny;
+exports.Show = Show;
+exports.fold = fold;
+exports.foldW = foldW;
+exports.isBoolean = isBoolean;
+exports.match = match;
+exports.matchW = matchW;
+//# sourceMappingURL=boolean.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.cjs","sources":["../../../../../../node_modules/fp-ts/es6/boolean.js"],"sourcesContent":["// -------------------------------------------------------------------------------------\n// refinements\n// -------------------------------------------------------------------------------------\n/**\n * @category refinements\n * @since 2.11.0\n */\nexport var isBoolean = function (u) { return typeof u === 'boolean'; };\n/**\n * Less strict version of [`match`](#match).\n *\n * The `W` suffix (short for **W**idening) means that the handler return types will be merged.\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var matchW = function (onFalse, onTrue) {\n    return function (value) {\n        return value ? onTrue() : onFalse();\n    };\n};\n/**\n * Alias of [`matchW`](#matchw).\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var foldW = matchW;\n/**\n * Defines the fold over a boolean value.\n * Takes two thunks `onTrue`, `onFalse` and a `boolean` value.\n * If `value` is false, `onFalse()` is returned, otherwise `onTrue()`.\n *\n * @example\n * import { some, map } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n * import { match } from 'fp-ts/boolean'\n *\n * assert.deepStrictEqual(\n *  pipe(\n *    some(true),\n *    map(match(() => 'false', () => 'true'))\n *  ),\n *  some('true')\n * )\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var match = foldW;\n/**\n * Alias of [`match`](#match).\n *\n * @category pattern matching\n * @since 2.2.0\n */\nexport var fold = match;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Eq = {\n    equals: function (first, second) { return first === second; }\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var BooleanAlgebra = {\n    meet: function (first, second) { return first && second; },\n    join: function (first, second) { return first || second; },\n    zero: false,\n    one: true,\n    implies: function (first, second) { return !first || second; },\n    not: function (b) { return !b; }\n};\n/**\n * `boolean` semigroup under conjunction.\n *\n * @example\n * import { SemigroupAll } from 'fp-ts/boolean'\n *\n * assert.deepStrictEqual(SemigroupAll.concat(true, true), true)\n * assert.deepStrictEqual(SemigroupAll.concat(true, false), false)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var SemigroupAll = {\n    concat: function (first, second) { return first && second; }\n};\n/**\n * `boolean` semigroup under disjunction.\n *\n * @example\n * import { SemigroupAny } from 'fp-ts/boolean'\n *\n * assert.deepStrictEqual(SemigroupAny.concat(true, true), true)\n * assert.deepStrictEqual(SemigroupAny.concat(true, false), true)\n * assert.deepStrictEqual(SemigroupAny.concat(false, false), false)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var SemigroupAny = {\n    concat: function (first, second) { return first || second; }\n};\n/**\n * `boolean` monoid under conjunction.\n *\n * The `empty` value is `true`.\n *\n * @example\n * import { MonoidAll } from 'fp-ts/boolean'\n *\n * assert.deepStrictEqual(MonoidAll.concat(true, true), true)\n * assert.deepStrictEqual(MonoidAll.concat(true, false), false)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var MonoidAll = {\n    concat: SemigroupAll.concat,\n    empty: true\n};\n/**\n * `boolean` monoid under disjunction.\n *\n * The `empty` value is `false`.\n *\n * @example\n * import { MonoidAny } from 'fp-ts/boolean'\n *\n * assert.deepStrictEqual(MonoidAny.concat(true, true), true)\n * assert.deepStrictEqual(MonoidAny.concat(true, false), true)\n * assert.deepStrictEqual(MonoidAny.concat(false, false), false)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var MonoidAny = {\n    concat: SemigroupAny.concat,\n    empty: false\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Ord = {\n    equals: Eq.equals,\n    compare: function (first, second) { return (first < second ? -1 : first > second ? 1 : 0); }\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Show = {\n    show: function (b) { return JSON.stringify(b); }\n};\n"],"names":[],"mappings":";;AAOU,IAAC,YAAY,SAAU,GAAG;AAAE,SAAO,OAAO,MAAM;AAAa;AAS7D,IAAC,SAAS,SAAU,SAAS,QAAQ;AAC3C,SAAO,SAAU,OAAO;AACpB,WAAO,QAAQ,WAAW;EAClC;AACA;AAOU,IAAC,QAAQ;AAsBT,IAAC,QAAQ;AAOT,IAAC,OAAO;AAQR,IAAC,KAAK;AAAA,EACZ,QAAQ,SAAU,OAAO,QAAQ;AAAE,WAAO,UAAU;AAAA,EAAS;AACjE;AAKU,IAAC,iBAAiB;AAAA,EACxB,MAAM,SAAU,OAAO,QAAQ;AAAE,WAAO,SAAS;AAAA,EAAS;AAAA,EAC1D,MAAM,SAAU,OAAO,QAAQ;AAAE,WAAO,SAAS;AAAA,EAAS;AAAA,EAC1D,MAAM;AAAA,EACN,KAAK;AAAA,EACL,SAAS,SAAU,OAAO,QAAQ;AAAE,WAAO,CAAC,SAAS;AAAA,EAAS;AAAA,EAC9D,KAAK,SAAU,GAAG;AAAE,WAAO,CAAC;AAAA,EAAI;AACpC;AAaU,IAAC,eAAe;AAAA,EACtB,QAAQ,SAAU,OAAO,QAAQ;AAAE,WAAO,SAAS;AAAA,EAAS;AAChE;AAcU,IAAC,eAAe;AAAA,EACtB,QAAQ,SAAU,OAAO,QAAQ;AAAE,WAAO,SAAS;AAAA,EAAS;AAChE;AAeU,IAAC,YAAY;AAAA,EACnB,QAAQ,aAAa;AAAA,EACrB,OAAO;AACX;AAgBU,IAAC,YAAY;AAAA,EACnB,QAAQ,aAAa;AAAA,EACrB,OAAO;AACX;AAKU,IAAC,MAAM;AAAA,EACb,QAAQ,GAAG;AAAA,EACX,SAAS,SAAU,OAAO,QAAQ;AAAE,WAAQ,QAAQ,SAAS,KAAK,QAAQ,SAAS,IAAI;AAAA,EAAK;AAChG;AAKU,IAAC,OAAO;AAAA,EACd,MAAM,SAAU,GAAG;AAAE,WAAO,KAAK,UAAU,CAAC;AAAA,EAAI;AACpD;;;;;;;;;;;;;;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,77 @@
+var isBoolean = function(u) {
+  return typeof u === "boolean";
+};
+var matchW = function(onFalse, onTrue) {
+  return function(value) {
+    return value ? onTrue() : onFalse();
+  };
+};
+var foldW = matchW;
+var match = foldW;
+var fold = match;
+var Eq = {
+  equals: function(first, second) {
+    return first === second;
+  }
+};
+var BooleanAlgebra = {
+  meet: function(first, second) {
+    return first && second;
+  },
+  join: function(first, second) {
+    return first || second;
+  },
+  zero: false,
+  one: true,
+  implies: function(first, second) {
+    return !first || second;
+  },
+  not: function(b) {
+    return !b;
+  }
+};
+var SemigroupAll = {
+  concat: function(first, second) {
+    return first && second;
+  }
+};
+var SemigroupAny = {
+  concat: function(first, second) {
+    return first || second;
+  }
+};
+var MonoidAll = {
+  concat: SemigroupAll.concat,
+  empty: true
+};
+var MonoidAny = {
+  concat: SemigroupAny.concat,
+  empty: false
+};
+var Ord = {
+  equals: Eq.equals,
+  compare: function(first, second) {
+    return first < second ? -1 : first > second ? 1 : 0;
+  }
+};
+var Show = {
+  show: function(b) {
+    return JSON.stringify(b);
+  }
+};
+export {
+  BooleanAlgebra,
+  Eq,
+  MonoidAll,
+  MonoidAny,
+  Ord,
+  SemigroupAll,
+  SemigroupAny,
+  Show,
+  fold,
+  foldW,
+  isBoolean,
+  match,
+  matchW
+};
+//# sourceMappingURL=boolean.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.js","sources":["../../../../../../node_modules/fp-ts/es6/boolean.js"],"sourcesContent":["// -------------------------------------------------------------------------------------\n// refinements\n// -------------------------------------------------------------------------------------\n/**\n * @category refinements\n * @since 2.11.0\n */\nexport var isBoolean = function (u) { return typeof u === 'boolean'; };\n/**\n * Less strict version of [`match`](#match).\n *\n * The `W` suffix (short for **W**idening) means that the handler return types will be merged.\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var matchW = function (onFalse, onTrue) {\n    return function (value) {\n        return value ? onTrue() : onFalse();\n    };\n};\n/**\n * Alias of [`matchW`](#matchw).\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var foldW = matchW;\n/**\n * Defines the fold over a boolean value.\n * Takes two thunks `onTrue`, `onFalse` and a `boolean` value.\n * If `value` is false, `onFalse()` is returned, otherwise `onTrue()`.\n *\n * @example\n * import { some, map } from 'fp-ts/Option'\n * import { pipe } from 'fp-ts/function'\n * import { match } from 'fp-ts/boolean'\n *\n * assert.deepStrictEqual(\n *  pipe(\n *    some(true),\n *    map(match(() => 'false', () => 'true'))\n *  ),\n *  some('true')\n * )\n *\n * @category pattern matching\n * @since 2.10.0\n */\nexport var match = foldW;\n/**\n * Alias of [`match`](#match).\n *\n * @category pattern matching\n * @since 2.2.0\n */\nexport var fold = match;\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Eq = {\n    equals: function (first, second) { return first === second; }\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var BooleanAlgebra = {\n    meet: function (first, second) { return first && second; },\n    join: function (first, second) { return first || second; },\n    zero: false,\n    one: true,\n    implies: function (first, second) { return !first || second; },\n    not: function (b) { return !b; }\n};\n/**\n * `boolean` semigroup under conjunction.\n *\n * @example\n * import { SemigroupAll } from 'fp-ts/boolean'\n *\n * assert.deepStrictEqual(SemigroupAll.concat(true, true), true)\n * assert.deepStrictEqual(SemigroupAll.concat(true, false), false)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var SemigroupAll = {\n    concat: function (first, second) { return first && second; }\n};\n/**\n * `boolean` semigroup under disjunction.\n *\n * @example\n * import { SemigroupAny } from 'fp-ts/boolean'\n *\n * assert.deepStrictEqual(SemigroupAny.concat(true, true), true)\n * assert.deepStrictEqual(SemigroupAny.concat(true, false), true)\n * assert.deepStrictEqual(SemigroupAny.concat(false, false), false)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var SemigroupAny = {\n    concat: function (first, second) { return first || second; }\n};\n/**\n * `boolean` monoid under conjunction.\n *\n * The `empty` value is `true`.\n *\n * @example\n * import { MonoidAll } from 'fp-ts/boolean'\n *\n * assert.deepStrictEqual(MonoidAll.concat(true, true), true)\n * assert.deepStrictEqual(MonoidAll.concat(true, false), false)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var MonoidAll = {\n    concat: SemigroupAll.concat,\n    empty: true\n};\n/**\n * `boolean` monoid under disjunction.\n *\n * The `empty` value is `false`.\n *\n * @example\n * import { MonoidAny } from 'fp-ts/boolean'\n *\n * assert.deepStrictEqual(MonoidAny.concat(true, true), true)\n * assert.deepStrictEqual(MonoidAny.concat(true, false), true)\n * assert.deepStrictEqual(MonoidAny.concat(false, false), false)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var MonoidAny = {\n    concat: SemigroupAny.concat,\n    empty: false\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Ord = {\n    equals: Eq.equals,\n    compare: function (first, second) { return (first < second ? -1 : first > second ? 1 : 0); }\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Show = {\n    show: function (b) { return JSON.stringify(b); }\n};\n"],"names":[],"mappings":"AAOU,IAAC,YAAY,SAAU,GAAG;AAAE,SAAO,OAAO,MAAM;AAAa;AAS7D,IAAC,SAAS,SAAU,SAAS,QAAQ;AAC3C,SAAO,SAAU,OAAO;AACpB,WAAO,QAAQ,WAAW;EAClC;AACA;AAOU,IAAC,QAAQ;AAsBT,IAAC,QAAQ;AAOT,IAAC,OAAO;AAQR,IAAC,KAAK;AAAA,EACZ,QAAQ,SAAU,OAAO,QAAQ;AAAE,WAAO,UAAU;AAAA,EAAS;AACjE;AAKU,IAAC,iBAAiB;AAAA,EACxB,MAAM,SAAU,OAAO,QAAQ;AAAE,WAAO,SAAS;AAAA,EAAS;AAAA,EAC1D,MAAM,SAAU,OAAO,QAAQ;AAAE,WAAO,SAAS;AAAA,EAAS;AAAA,EAC1D,MAAM;AAAA,EACN,KAAK;AAAA,EACL,SAAS,SAAU,OAAO,QAAQ;AAAE,WAAO,CAAC,SAAS;AAAA,EAAS;AAAA,EAC9D,KAAK,SAAU,GAAG;AAAE,WAAO,CAAC;AAAA,EAAI;AACpC;AAaU,IAAC,eAAe;AAAA,EACtB,QAAQ,SAAU,OAAO,QAAQ;AAAE,WAAO,SAAS;AAAA,EAAS;AAChE;AAcU,IAAC,eAAe;AAAA,EACtB,QAAQ,SAAU,OAAO,QAAQ;AAAE,WAAO,SAAS;AAAA,EAAS;AAChE;AAeU,IAAC,YAAY;AAAA,EACnB,QAAQ,aAAa;AAAA,EACrB,OAAO;AACX;AAgBU,IAAC,YAAY;AAAA,EACnB,QAAQ,aAAa;AAAA,EACrB,OAAO;AACX;AAKU,IAAC,MAAM;AAAA,EACb,QAAQ,GAAG;AAAA,EACX,SAAS,SAAU,OAAO,QAAQ;AAAE,WAAQ,QAAQ,SAAS,KAAK,QAAQ,SAAS,IAAI;AAAA,EAAK;AAChG;AAKU,IAAC,OAAO;AAAA,EACd,MAAM,SAAU,GAAG;AAAE,WAAO,KAAK,UAAU,CAAC;AAAA,EAAI;AACpD;","x_google_ignoreList":[0]}

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-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)) {
@@ -11,6 +11,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:
@@ -40,5 +230,63 @@ 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));
+    };
+  };
+};
+exports.SK = SK;
+exports.absurd = absurd;
+exports.apply = apply;
+exports.constFalse = constFalse;
+exports.constNull = constNull;
+exports.constTrue = constTrue;
+exports.constUndefined = constUndefined;
+exports.constVoid = constVoid;
+exports.constant = constant;
+exports.decrement = decrement;
+exports.dual = dual;
+exports.flip = flip;
+exports.flow = flow;
+exports.getBooleanAlgebra = getBooleanAlgebra;
+exports.getEndomorphismMonoid = getEndomorphismMonoid;
+exports.getMonoid = getMonoid;
+exports.getRing = getRing;
+exports.getSemigroup = getSemigroup;
+exports.getSemiring = getSemiring;
+exports.hole = hole;
+exports.identity = identity;
+exports.increment = increment;
+exports.not = not;
 exports.pipe = pipe;
+exports.tuple = tuple;
+exports.tupled = tupled;
+exports.unsafeCoerce = unsafeCoerce;
+exports.untupled = untupled;
 //# sourceMappingURL=function.cjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"function.cjs","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.cjs","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]}