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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const internal = require("./internal.cjs");
+var fromOptionK = function(getOption) {
+  return function(a) {
+    return internal.isSome(getOption(a));
+  };
+};
+var fromEitherK = function(getEither) {
+  return function(a) {
+    return internal.isRight(getEither(a));
+  };
+};
+var id = function() {
+  return function(_) {
+    return true;
+  };
+};
+var not = function(refinement) {
+  return function(a) {
+    return !refinement(a);
+  };
+};
+var or = function(second) {
+  return function(first) {
+    return function(a) {
+      return first(a) || second(a);
+    };
+  };
+};
+var and = function(second) {
+  return function(first) {
+    return function(a) {
+      return first(a) && second(a);
+    };
+  };
+};
+var zero = function() {
+  return function(_) {
+    return false;
+  };
+};
+var compose = function(bc) {
+  return function(ab) {
+    return function(i) {
+      return ab(i) && bc(i);
+    };
+  };
+};
+exports.and = and;
+exports.compose = compose;
+exports.fromEitherK = fromEitherK;
+exports.fromOptionK = fromOptionK;
+exports.id = id;
+exports.not = not;
+exports.or = or;
+exports.zero = zero;
+//# sourceMappingURL=Refinement.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Refinement.cjs","sources":["../../../../../../node_modules/fp-ts/es6/Refinement.js"],"sourcesContent":["import * as _ from './internal';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * Returns a `Refinement` from a `Option` returning function.\n * This function ensures that a `Refinement` definition is type-safe.\n *\n * @category lifting\n * @since 2.11.0\n */\nexport var fromOptionK = function (getOption) {\n    return function (a) { return _.isSome(getOption(a)); };\n};\n/**\n * @category lifting\n * @since 2.11.0\n */\nexport var fromEitherK = function (getEither) {\n    return function (a) { return _.isRight(getEither(a)); };\n};\n/**\n * @category constructors\n * @since 2.11.0\n */\nexport var id = function () {\n    return function (_) { return true; };\n};\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.11.0\n */\nexport var not = function (refinement) {\n    return function (a) {\n        return !refinement(a);\n    };\n};\n/**\n * @since 2.11.0\n */\nexport var or = function (second) {\n    return function (first) {\n        return function (a) {\n            return first(a) || second(a);\n        };\n    };\n};\n/**\n * @since 2.11.0\n */\nexport var and = function (second) {\n    return function (first) {\n        return function (a) {\n            return first(a) && second(a);\n        };\n    };\n};\n/**\n * @since 2.11.0\n */\nexport var zero = function () {\n    return function (_) { return false; };\n};\n/**\n * @since 2.11.0\n */\nexport var compose = function (bc) {\n    return function (ab) {\n        return function (i) { return ab(i) && bc(i); };\n    };\n};\n"],"names":["_.isSome","_.isRight"],"mappings":";;;AAWU,IAAC,cAAc,SAAU,WAAW;AAC1C,SAAO,SAAU,GAAG;AAAE,WAAOA,SAAAA,OAAS,UAAU,CAAC,CAAC;AAAA;AACtD;AAKU,IAAC,cAAc,SAAU,WAAW;AAC1C,SAAO,SAAU,GAAG;AAAE,WAAOC,SAAAA,QAAU,UAAU,CAAC,CAAC;AAAA;AACvD;AAKU,IAAC,KAAK,WAAY;AACxB,SAAO,SAAU,GAAG;AAAE,WAAO;AAAA,EAAK;AACtC;AAOU,IAAC,MAAM,SAAU,YAAY;AACnC,SAAO,SAAU,GAAG;AAChB,WAAO,CAAC,WAAW,CAAC;AAAA,EAC5B;AACA;AAIU,IAAC,KAAK,SAAU,QAAQ;AAC9B,SAAO,SAAU,OAAO;AACpB,WAAO,SAAU,GAAG;AAChB,aAAO,MAAM,CAAC,KAAK,OAAO,CAAC;AAAA,IACvC;AAAA,EACA;AACA;AAIU,IAAC,MAAM,SAAU,QAAQ;AAC/B,SAAO,SAAU,OAAO;AACpB,WAAO,SAAU,GAAG;AAChB,aAAO,MAAM,CAAC,KAAK,OAAO,CAAC;AAAA,IACvC;AAAA,EACA;AACA;AAIU,IAAC,OAAO,WAAY;AAC1B,SAAO,SAAU,GAAG;AAAE,WAAO;AAAA,EAAM;AACvC;AAIU,IAAC,UAAU,SAAU,IAAI;AAC/B,SAAO,SAAU,IAAI;AACjB,WAAO,SAAU,GAAG;AAAE,aAAO,GAAG,CAAC,KAAK,GAAG,CAAC;AAAA;EAClD;AACA;;;;;;;;;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,58 @@
+import { isSome, isRight } from "./internal.js";
+var fromOptionK = function(getOption) {
+  return function(a) {
+    return isSome(getOption(a));
+  };
+};
+var fromEitherK = function(getEither) {
+  return function(a) {
+    return isRight(getEither(a));
+  };
+};
+var id = function() {
+  return function(_) {
+    return true;
+  };
+};
+var not = function(refinement) {
+  return function(a) {
+    return !refinement(a);
+  };
+};
+var or = function(second) {
+  return function(first) {
+    return function(a) {
+      return first(a) || second(a);
+    };
+  };
+};
+var and = function(second) {
+  return function(first) {
+    return function(a) {
+      return first(a) && second(a);
+    };
+  };
+};
+var zero = function() {
+  return function(_) {
+    return false;
+  };
+};
+var compose = function(bc) {
+  return function(ab) {
+    return function(i) {
+      return ab(i) && bc(i);
+    };
+  };
+};
+export {
+  and,
+  compose,
+  fromEitherK,
+  fromOptionK,
+  id,
+  not,
+  or,
+  zero
+};
+//# sourceMappingURL=Refinement.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Refinement.js","sources":["../../../../../../node_modules/fp-ts/es6/Refinement.js"],"sourcesContent":["import * as _ from './internal';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * Returns a `Refinement` from a `Option` returning function.\n * This function ensures that a `Refinement` definition is type-safe.\n *\n * @category lifting\n * @since 2.11.0\n */\nexport var fromOptionK = function (getOption) {\n    return function (a) { return _.isSome(getOption(a)); };\n};\n/**\n * @category lifting\n * @since 2.11.0\n */\nexport var fromEitherK = function (getEither) {\n    return function (a) { return _.isRight(getEither(a)); };\n};\n/**\n * @category constructors\n * @since 2.11.0\n */\nexport var id = function () {\n    return function (_) { return true; };\n};\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.11.0\n */\nexport var not = function (refinement) {\n    return function (a) {\n        return !refinement(a);\n    };\n};\n/**\n * @since 2.11.0\n */\nexport var or = function (second) {\n    return function (first) {\n        return function (a) {\n            return first(a) || second(a);\n        };\n    };\n};\n/**\n * @since 2.11.0\n */\nexport var and = function (second) {\n    return function (first) {\n        return function (a) {\n            return first(a) && second(a);\n        };\n    };\n};\n/**\n * @since 2.11.0\n */\nexport var zero = function () {\n    return function (_) { return false; };\n};\n/**\n * @since 2.11.0\n */\nexport var compose = function (bc) {\n    return function (ab) {\n        return function (i) { return ab(i) && bc(i); };\n    };\n};\n"],"names":["_.isSome","_.isRight"],"mappings":";AAWU,IAAC,cAAc,SAAU,WAAW;AAC1C,SAAO,SAAU,GAAG;AAAE,WAAOA,OAAS,UAAU,CAAC,CAAC;AAAA;AACtD;AAKU,IAAC,cAAc,SAAU,WAAW;AAC1C,SAAO,SAAU,GAAG;AAAE,WAAOC,QAAU,UAAU,CAAC,CAAC;AAAA;AACvD;AAKU,IAAC,KAAK,WAAY;AACxB,SAAO,SAAU,GAAG;AAAE,WAAO;AAAA,EAAK;AACtC;AAOU,IAAC,MAAM,SAAU,YAAY;AACnC,SAAO,SAAU,GAAG;AAChB,WAAO,CAAC,WAAW,CAAC;AAAA,EAC5B;AACA;AAIU,IAAC,KAAK,SAAU,QAAQ;AAC9B,SAAO,SAAU,OAAO;AACpB,WAAO,SAAU,GAAG;AAChB,aAAO,MAAM,CAAC,KAAK,OAAO,CAAC;AAAA,IACvC;AAAA,EACA;AACA;AAIU,IAAC,MAAM,SAAU,QAAQ;AAC/B,SAAO,SAAU,OAAO;AACpB,WAAO,SAAU,GAAG;AAChB,aAAO,MAAM,CAAC,KAAK,OAAO,CAAC;AAAA,IACvC;AAAA,EACA;AACA;AAIU,IAAC,OAAO,WAAY;AAC1B,SAAO,SAAU,GAAG;AAAE,WAAO;AAAA,EAAM;AACvC;AAIU,IAAC,UAAU,SAAU,IAAI;AAC/B,SAAO,SAAU,IAAI;AACjB,WAAO,SAAU,GAAG;AAAE,aAAO,GAAG,CAAC,KAAK,GAAG,CAAC;AAAA;EAClD;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _function = require("./function.cjs");
+var tuple = function() {
+  var rings = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    rings[_i] = arguments[_i];
+  }
+  return {
+    add: function(x, y) {
+      return rings.map(function(R, i) {
+        return R.add(x[i], y[i]);
+      });
+    },
+    zero: rings.map(function(R) {
+      return R.zero;
+    }),
+    mul: function(x, y) {
+      return rings.map(function(R, i) {
+        return R.mul(x[i], y[i]);
+      });
+    },
+    one: rings.map(function(R) {
+      return R.one;
+    }),
+    sub: function(x, y) {
+      return rings.map(function(R, i) {
+        return R.sub(x[i], y[i]);
+      });
+    }
+  };
+};
+var negate = function(R) {
+  return function(a) {
+    return R.sub(R.zero, a);
+  };
+};
+var getTupleRing = tuple;
+var getFunctionRing = _function.getRing;
+exports.getFunctionRing = getFunctionRing;
+exports.getTupleRing = getTupleRing;
+exports.negate = negate;
+exports.tuple = tuple;
+//# sourceMappingURL=Ring.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Ring.cjs","sources":["../../../../../../node_modules/fp-ts/es6/Ring.js"],"sourcesContent":["/**\n * The `Ring` class is for types that support addition, multiplication, and subtraction operations.\n *\n * Instances must satisfy the following law in addition to the `Semiring` laws:\n *\n * - Additive inverse: `a - a <-> (zero - a) + a <-> zero`\n *\n * Adapted from https://github.com/purescript/purescript-prelude/blob/master/src/Data/Ring.purs\n *\n * @since 2.0.0\n */\nimport { getRing } from './function';\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * Given a tuple of `Ring`s returns a `Ring` for the tuple\n *\n * @example\n * import { tuple } from 'fp-ts/Ring'\n * import * as N from 'fp-ts/number'\n *\n * const R = tuple(N.Field, N.Field, N.Field)\n * assert.deepStrictEqual(R.add([1, 2, 3], [4, 5, 6]), [5, 7, 9])\n * assert.deepStrictEqual(R.mul([1, 2, 3], [4, 5, 6]), [4, 10, 18])\n * assert.deepStrictEqual(R.one, [1, 1, 1])\n * assert.deepStrictEqual(R.sub([1, 2, 3], [4, 5, 6]), [-3, -3, -3])\n * assert.deepStrictEqual(R.zero, [0, 0, 0])\n *\n * @since 2.10.0\n */\nexport var tuple = function () {\n    var rings = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        rings[_i] = arguments[_i];\n    }\n    return ({\n        add: function (x, y) { return rings.map(function (R, i) { return R.add(x[i], y[i]); }); },\n        zero: rings.map(function (R) { return R.zero; }),\n        mul: function (x, y) { return rings.map(function (R, i) { return R.mul(x[i], y[i]); }); },\n        one: rings.map(function (R) { return R.one; }),\n        sub: function (x, y) { return rings.map(function (R, i) { return R.sub(x[i], y[i]); }); }\n    });\n};\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * `negate x` can be used as a shorthand for `zero - x`\n *\n * @since 2.0.0\n */\nexport var negate = function (R) {\n    return function (a) {\n        return R.sub(R.zero, a);\n    };\n};\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use [`tuple`](#tuple) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getTupleRing = tuple;\n/**\n * Use [`getRing`](./function.ts.html#getring) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getFunctionRing = getRing;\n"],"names":["getRing"],"mappings":";;;AA+BU,IAAC,QAAQ,WAAY;AAC3B,MAAI,QAAQ,CAAA;AACZ,WAAS,KAAK,GAAG,KAAK,UAAU,QAAQ,MAAM;AAC1C,UAAM,EAAE,IAAI,UAAU,EAAE;AAAA,EAC3B;AACD,SAAQ;AAAA,IACJ,KAAK,SAAU,GAAG,GAAG;AAAE,aAAO,MAAM,IAAI,SAAU,GAAG,GAAG;AAAE,eAAO,EAAE,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;AAAA,MAAI,CAAA;AAAA,IAAI;AAAA,IACzF,MAAM,MAAM,IAAI,SAAU,GAAG;AAAE,aAAO,EAAE;AAAA,KAAO;AAAA,IAC/C,KAAK,SAAU,GAAG,GAAG;AAAE,aAAO,MAAM,IAAI,SAAU,GAAG,GAAG;AAAE,eAAO,EAAE,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;AAAA,MAAI,CAAA;AAAA,IAAI;AAAA,IACzF,KAAK,MAAM,IAAI,SAAU,GAAG;AAAE,aAAO,EAAE;AAAA,KAAM;AAAA,IAC7C,KAAK,SAAU,GAAG,GAAG;AAAE,aAAO,MAAM,IAAI,SAAU,GAAG,GAAG;AAAE,eAAO,EAAE,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;AAAA,MAAI,CAAA;AAAA,IAAI;AAAA,EACjG;AACA;AASU,IAAC,SAAS,SAAU,GAAG;AAC7B,SAAO,SAAU,GAAG;AAChB,WAAO,EAAE,IAAI,EAAE,MAAM,CAAC;AAAA,EAC9B;AACA;AAWU,IAAC,eAAe;AAQhB,IAAC,kBAAkBA,UAAAA;;;;;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,44 @@
+import { getRing } from "./function.js";
+var tuple = function() {
+  var rings = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    rings[_i] = arguments[_i];
+  }
+  return {
+    add: function(x, y) {
+      return rings.map(function(R, i) {
+        return R.add(x[i], y[i]);
+      });
+    },
+    zero: rings.map(function(R) {
+      return R.zero;
+    }),
+    mul: function(x, y) {
+      return rings.map(function(R, i) {
+        return R.mul(x[i], y[i]);
+      });
+    },
+    one: rings.map(function(R) {
+      return R.one;
+    }),
+    sub: function(x, y) {
+      return rings.map(function(R, i) {
+        return R.sub(x[i], y[i]);
+      });
+    }
+  };
+};
+var negate = function(R) {
+  return function(a) {
+    return R.sub(R.zero, a);
+  };
+};
+var getTupleRing = tuple;
+var getFunctionRing = getRing;
+export {
+  getFunctionRing,
+  getTupleRing,
+  negate,
+  tuple
+};
+//# sourceMappingURL=Ring.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Ring.js","sources":["../../../../../../node_modules/fp-ts/es6/Ring.js"],"sourcesContent":["/**\n * The `Ring` class is for types that support addition, multiplication, and subtraction operations.\n *\n * Instances must satisfy the following law in addition to the `Semiring` laws:\n *\n * - Additive inverse: `a - a <-> (zero - a) + a <-> zero`\n *\n * Adapted from https://github.com/purescript/purescript-prelude/blob/master/src/Data/Ring.purs\n *\n * @since 2.0.0\n */\nimport { getRing } from './function';\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * Given a tuple of `Ring`s returns a `Ring` for the tuple\n *\n * @example\n * import { tuple } from 'fp-ts/Ring'\n * import * as N from 'fp-ts/number'\n *\n * const R = tuple(N.Field, N.Field, N.Field)\n * assert.deepStrictEqual(R.add([1, 2, 3], [4, 5, 6]), [5, 7, 9])\n * assert.deepStrictEqual(R.mul([1, 2, 3], [4, 5, 6]), [4, 10, 18])\n * assert.deepStrictEqual(R.one, [1, 1, 1])\n * assert.deepStrictEqual(R.sub([1, 2, 3], [4, 5, 6]), [-3, -3, -3])\n * assert.deepStrictEqual(R.zero, [0, 0, 0])\n *\n * @since 2.10.0\n */\nexport var tuple = function () {\n    var rings = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        rings[_i] = arguments[_i];\n    }\n    return ({\n        add: function (x, y) { return rings.map(function (R, i) { return R.add(x[i], y[i]); }); },\n        zero: rings.map(function (R) { return R.zero; }),\n        mul: function (x, y) { return rings.map(function (R, i) { return R.mul(x[i], y[i]); }); },\n        one: rings.map(function (R) { return R.one; }),\n        sub: function (x, y) { return rings.map(function (R, i) { return R.sub(x[i], y[i]); }); }\n    });\n};\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * `negate x` can be used as a shorthand for `zero - x`\n *\n * @since 2.0.0\n */\nexport var negate = function (R) {\n    return function (a) {\n        return R.sub(R.zero, a);\n    };\n};\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use [`tuple`](#tuple) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getTupleRing = tuple;\n/**\n * Use [`getRing`](./function.ts.html#getring) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getFunctionRing = getRing;\n"],"names":[],"mappings":";AA+BU,IAAC,QAAQ,WAAY;AAC3B,MAAI,QAAQ,CAAA;AACZ,WAAS,KAAK,GAAG,KAAK,UAAU,QAAQ,MAAM;AAC1C,UAAM,EAAE,IAAI,UAAU,EAAE;AAAA,EAC3B;AACD,SAAQ;AAAA,IACJ,KAAK,SAAU,GAAG,GAAG;AAAE,aAAO,MAAM,IAAI,SAAU,GAAG,GAAG;AAAE,eAAO,EAAE,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;AAAA,MAAI,CAAA;AAAA,IAAI;AAAA,IACzF,MAAM,MAAM,IAAI,SAAU,GAAG;AAAE,aAAO,EAAE;AAAA,KAAO;AAAA,IAC/C,KAAK,SAAU,GAAG,GAAG;AAAE,aAAO,MAAM,IAAI,SAAU,GAAG,GAAG;AAAE,eAAO,EAAE,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;AAAA,MAAI,CAAA;AAAA,IAAI;AAAA,IACzF,KAAK,MAAM,IAAI,SAAU,GAAG;AAAE,aAAO,EAAE;AAAA,KAAM;AAAA,IAC7C,KAAK,SAAU,GAAG,GAAG;AAAE,aAAO,MAAM,IAAI,SAAU,GAAG,GAAG;AAAE,eAAO,EAAE,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;AAAA,MAAI,CAAA;AAAA,IAAI;AAAA,EACjG;AACA;AASU,IAAC,SAAS,SAAU,GAAG;AAC7B,SAAO,SAAU,GAAG;AAChB,WAAO,EAAE,IAAI,EAAE,MAAM,CAAC;AAAA,EAC9B;AACA;AAWU,IAAC,eAAe;AAQhB,IAAC,kBAAkB;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _function = require("./function.cjs");
+const internal = require("./internal.cjs");
+const Magma = require("./Magma.cjs");
+const Ord = require("./Ord.cjs");
+var min = function(O) {
+  return {
+    concat: Ord.min(O)
+  };
+};
+var max = function(O) {
+  return {
+    concat: Ord.max(O)
+  };
+};
+var constant = function(a) {
+  return {
+    concat: function() {
+      return a;
+    }
+  };
+};
+var reverse = Magma.reverse;
+var struct = function(semigroups) {
+  return {
+    concat: function(first2, second) {
+      var r = {};
+      for (var k in semigroups) {
+        if (internal.has.call(semigroups, k)) {
+          r[k] = semigroups[k].concat(first2[k], second[k]);
+        }
+      }
+      return r;
+    }
+  };
+};
+var tuple = function() {
+  var semigroups = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    semigroups[_i] = arguments[_i];
+  }
+  return {
+    concat: function(first2, second) {
+      return semigroups.map(function(s, i) {
+        return s.concat(first2[i], second[i]);
+      });
+    }
+  };
+};
+var intercalate = function(middle) {
+  return function(S) {
+    return {
+      concat: function(x, y) {
+        return S.concat(x, S.concat(middle, y));
+      }
+    };
+  };
+};
+var first = function() {
+  return { concat: _function.identity };
+};
+var last = function() {
+  return { concat: function(_, y) {
+    return y;
+  } };
+};
+var concatAll = Magma.concatAll;
+var semigroupVoid = constant(void 0);
+var getObjectSemigroup = function() {
+  return {
+    concat: function(first2, second) {
+      return Object.assign({}, first2, second);
+    }
+  };
+};
+var getLastSemigroup = last;
+var getFirstSemigroup = first;
+var getTupleSemigroup = tuple;
+var getStructSemigroup = struct;
+var getDualSemigroup = reverse;
+var getJoinSemigroup = max;
+var getMeetSemigroup = min;
+var getIntercalateSemigroup = intercalate;
+function fold(S) {
+  var concatAllS = concatAll(S);
+  return function(startWith, as) {
+    return as === void 0 ? concatAllS(startWith) : concatAllS(startWith)(as);
+  };
+}
+var semigroupAll = {
+  concat: function(x, y) {
+    return x && y;
+  }
+};
+var semigroupAny = {
+  concat: function(x, y) {
+    return x || y;
+  }
+};
+var getFunctionSemigroup = _function.getSemigroup;
+var semigroupString = {
+  concat: function(x, y) {
+    return x + y;
+  }
+};
+var semigroupSum = {
+  concat: function(x, y) {
+    return x + y;
+  }
+};
+var semigroupProduct = {
+  concat: function(x, y) {
+    return x * y;
+  }
+};
+exports.concatAll = concatAll;
+exports.constant = constant;
+exports.first = first;
+exports.fold = fold;
+exports.getDualSemigroup = getDualSemigroup;
+exports.getFirstSemigroup = getFirstSemigroup;
+exports.getFunctionSemigroup = getFunctionSemigroup;
+exports.getIntercalateSemigroup = getIntercalateSemigroup;
+exports.getJoinSemigroup = getJoinSemigroup;
+exports.getLastSemigroup = getLastSemigroup;
+exports.getMeetSemigroup = getMeetSemigroup;
+exports.getObjectSemigroup = getObjectSemigroup;
+exports.getStructSemigroup = getStructSemigroup;
+exports.getTupleSemigroup = getTupleSemigroup;
+exports.intercalate = intercalate;
+exports.last = last;
+exports.max = max;
+exports.min = min;
+exports.reverse = reverse;
+exports.semigroupAll = semigroupAll;
+exports.semigroupAny = semigroupAny;
+exports.semigroupProduct = semigroupProduct;
+exports.semigroupString = semigroupString;
+exports.semigroupSum = semigroupSum;
+exports.semigroupVoid = semigroupVoid;
+exports.struct = struct;
+exports.tuple = tuple;
+//# sourceMappingURL=Semigroup.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Semigroup.cjs","sources":["../../../../../../node_modules/fp-ts/es6/Semigroup.js"],"sourcesContent":["/**\n * If a type `A` can form a `Semigroup` it has an **associative** binary operation.\n *\n * ```ts\n * interface Semigroup<A> {\n *   readonly concat: (x: A, y: A) => A\n * }\n * ```\n *\n * Associativity means the following equality must hold for any choice of `x`, `y`, and `z`.\n *\n * ```ts\n * concat(x, concat(y, z)) = concat(concat(x, y), z)\n * ```\n *\n * A common example of a semigroup is the type `string` with the operation `+`.\n *\n * ```ts\n * import { Semigroup } from 'fp-ts/Semigroup'\n *\n * const semigroupString: Semigroup<string> = {\n *   concat: (x, y) => x + y\n * }\n *\n * const x = 'x'\n * const y = 'y'\n * const z = 'z'\n *\n * semigroupString.concat(x, y) // 'xy'\n *\n * semigroupString.concat(x, semigroupString.concat(y, z)) // 'xyz'\n *\n * semigroupString.concat(semigroupString.concat(x, y), z) // 'xyz'\n * ```\n *\n * *Adapted from https://typelevel.org/cats*\n *\n * @since 2.0.0\n */\nimport { getSemigroup, identity } from './function';\nimport * as _ from './internal';\nimport * as M from './Magma';\nimport * as Or from './Ord';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * Get a semigroup where `concat` will return the minimum, based on the provided order.\n *\n * @example\n * import * as N from 'fp-ts/number'\n * import * as S from 'fp-ts/Semigroup'\n *\n * const S1 = S.min(N.Ord)\n *\n * assert.deepStrictEqual(S1.concat(1, 2), 1)\n *\n * @category constructors\n * @since 2.10.0\n */\nexport var min = function (O) { return ({\n    concat: Or.min(O)\n}); };\n/**\n * Get a semigroup where `concat` will return the maximum, based on the provided order.\n *\n * @example\n * import * as N from 'fp-ts/number'\n * import * as S from 'fp-ts/Semigroup'\n *\n * const S1 = S.max(N.Ord)\n *\n * assert.deepStrictEqual(S1.concat(1, 2), 2)\n *\n * @category constructors\n * @since 2.10.0\n */\nexport var max = function (O) { return ({\n    concat: Or.max(O)\n}); };\n/**\n * @category constructors\n * @since 2.10.0\n */\nexport var constant = function (a) { return ({\n    concat: function () { return a; }\n}); };\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * The dual of a `Semigroup`, obtained by swapping the arguments of `concat`.\n *\n * @example\n * import { reverse } from 'fp-ts/Semigroup'\n * import * as S from 'fp-ts/string'\n *\n * assert.deepStrictEqual(reverse(S.Semigroup).concat('a', 'b'), 'ba')\n *\n * @since 2.10.0\n */\nexport var reverse = M.reverse;\n/**\n * Given a struct of semigroups returns a semigroup for the struct.\n *\n * @example\n * import { struct } from 'fp-ts/Semigroup'\n * import * as N from 'fp-ts/number'\n *\n * interface Point {\n *   readonly x: number\n *   readonly y: number\n * }\n *\n * const S = struct<Point>({\n *   x: N.SemigroupSum,\n *   y: N.SemigroupSum\n * })\n *\n * assert.deepStrictEqual(S.concat({ x: 1, y: 2 }, { x: 3, y: 4 }), { x: 4, y: 6 })\n *\n * @since 2.10.0\n */\nexport var struct = function (semigroups) { return ({\n    concat: function (first, second) {\n        var r = {};\n        for (var k in semigroups) {\n            if (_.has.call(semigroups, k)) {\n                r[k] = semigroups[k].concat(first[k], second[k]);\n            }\n        }\n        return r;\n    }\n}); };\n/**\n * Given a tuple of semigroups returns a semigroup for the tuple.\n *\n * @example\n * import { tuple } from 'fp-ts/Semigroup'\n * import * as B from 'fp-ts/boolean'\n * import * as N from 'fp-ts/number'\n * import * as S from 'fp-ts/string'\n *\n * const S1 = tuple(S.Semigroup, N.SemigroupSum)\n * assert.deepStrictEqual(S1.concat(['a', 1], ['b', 2]), ['ab', 3])\n *\n * const S2 = tuple(S.Semigroup, N.SemigroupSum, B.SemigroupAll)\n * assert.deepStrictEqual(S2.concat(['a', 1, true], ['b', 2, false]), ['ab', 3, false])\n *\n * @since 2.10.0\n */\nexport var tuple = function () {\n    var semigroups = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        semigroups[_i] = arguments[_i];\n    }\n    return ({\n        concat: function (first, second) { return semigroups.map(function (s, i) { return s.concat(first[i], second[i]); }); }\n    });\n};\n/**\n * Between each pair of elements insert `middle`.\n *\n * @example\n * import { intercalate } from 'fp-ts/Semigroup'\n * import * as S from 'fp-ts/string'\n * import { pipe } from 'fp-ts/function'\n *\n * const S1 = pipe(S.Semigroup, intercalate(' + '))\n *\n * assert.strictEqual(S1.concat('a', 'b'), 'a + b')\n *\n * @since 2.10.0\n */\nexport var intercalate = function (middle) {\n    return function (S) { return ({\n        concat: function (x, y) { return S.concat(x, S.concat(middle, y)); }\n    }); };\n};\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * Always return the first argument.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.first<number>().concat(1, 2), 1)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var first = function () { return ({ concat: identity }); };\n/**\n * Always return the last argument.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.last<number>().concat(1, 2), 2)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var last = function () { return ({ concat: function (_, y) { return y; } }); };\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * Given a sequence of `as`, concat them and return the total.\n *\n * If `as` is empty, return the provided `startWith` value.\n *\n * @example\n * import { concatAll } from 'fp-ts/Semigroup'\n * import * as N from 'fp-ts/number'\n *\n * const sum = concatAll(N.SemigroupSum)(0)\n *\n * assert.deepStrictEqual(sum([1, 2, 3]), 6)\n * assert.deepStrictEqual(sum([]), 0)\n *\n * @since 2.10.0\n */\nexport var concatAll = M.concatAll;\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use `void` module instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var semigroupVoid = constant(undefined);\n/**\n * Use [`getAssignSemigroup`](./struct.ts.html#getAssignSemigroup) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getObjectSemigroup = function () { return ({\n    concat: function (first, second) { return Object.assign({}, first, second); }\n}); };\n/**\n * Use [`last`](#last) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getLastSemigroup = last;\n/**\n * Use [`first`](#first) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getFirstSemigroup = first;\n/**\n * Use [`tuple`](#tuple) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getTupleSemigroup = tuple;\n/**\n * Use [`struct`](#struct) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getStructSemigroup = struct;\n/**\n * Use [`reverse`](#reverse) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getDualSemigroup = reverse;\n/**\n * Use [`max`](#max) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getJoinSemigroup = max;\n/**\n * Use [`min`](#min) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getMeetSemigroup = min;\n/**\n * Use [`intercalate`](#intercalate) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var getIntercalateSemigroup = intercalate;\nexport function fold(S) {\n    var concatAllS = concatAll(S);\n    return function (startWith, as) { return (as === undefined ? concatAllS(startWith) : concatAllS(startWith)(as)); };\n}\n/**\n * Use [`SemigroupAll`](./boolean.ts.html#SemigroupAll) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var semigroupAll = {\n    concat: function (x, y) { return x && y; }\n};\n/**\n * Use [`SemigroupAny`](./boolean.ts.html#SemigroupAny) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var semigroupAny = {\n    concat: function (x, y) { return x || y; }\n};\n/**\n * Use [`getSemigroup`](./function.ts.html#getSemigroup) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getFunctionSemigroup = getSemigroup;\n/**\n * Use [`Semigroup`](./string.ts.html#Semigroup) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var semigroupString = {\n    concat: function (x, y) { return x + y; }\n};\n/**\n * Use [`SemigroupSum`](./number.ts.html#SemigroupSum) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var semigroupSum = {\n    concat: function (x, y) { return x + y; }\n};\n/**\n * Use [`SemigroupProduct`](./number.ts.html#SemigroupProduct) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var semigroupProduct = {\n    concat: function (x, y) { return x * y; }\n};\n"],"names":["Or.min","Or.max","M.reverse","first","_.has","identity","M.concatAll","getSemigroup"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -0,0 +1,144 @@
+import { identity, getSemigroup } from "./function.js";
+import { has } from "./internal.js";
+import { reverse as reverse$1, concatAll as concatAll$1 } from "./Magma.js";
+import { min as min$1, max as max$1 } from "./Ord.js";
+var min = function(O) {
+  return {
+    concat: min$1(O)
+  };
+};
+var max = function(O) {
+  return {
+    concat: max$1(O)
+  };
+};
+var constant = function(a) {
+  return {
+    concat: function() {
+      return a;
+    }
+  };
+};
+var reverse = reverse$1;
+var struct = function(semigroups) {
+  return {
+    concat: function(first2, second) {
+      var r = {};
+      for (var k in semigroups) {
+        if (has.call(semigroups, k)) {
+          r[k] = semigroups[k].concat(first2[k], second[k]);
+        }
+      }
+      return r;
+    }
+  };
+};
+var tuple = function() {
+  var semigroups = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    semigroups[_i] = arguments[_i];
+  }
+  return {
+    concat: function(first2, second) {
+      return semigroups.map(function(s, i) {
+        return s.concat(first2[i], second[i]);
+      });
+    }
+  };
+};
+var intercalate = function(middle) {
+  return function(S) {
+    return {
+      concat: function(x, y) {
+        return S.concat(x, S.concat(middle, y));
+      }
+    };
+  };
+};
+var first = function() {
+  return { concat: identity };
+};
+var last = function() {
+  return { concat: function(_, y) {
+    return y;
+  } };
+};
+var concatAll = concatAll$1;
+var semigroupVoid = constant(void 0);
+var getObjectSemigroup = function() {
+  return {
+    concat: function(first2, second) {
+      return Object.assign({}, first2, second);
+    }
+  };
+};
+var getLastSemigroup = last;
+var getFirstSemigroup = first;
+var getTupleSemigroup = tuple;
+var getStructSemigroup = struct;
+var getDualSemigroup = reverse;
+var getJoinSemigroup = max;
+var getMeetSemigroup = min;
+var getIntercalateSemigroup = intercalate;
+function fold(S) {
+  var concatAllS = concatAll(S);
+  return function(startWith, as) {
+    return as === void 0 ? concatAllS(startWith) : concatAllS(startWith)(as);
+  };
+}
+var semigroupAll = {
+  concat: function(x, y) {
+    return x && y;
+  }
+};
+var semigroupAny = {
+  concat: function(x, y) {
+    return x || y;
+  }
+};
+var getFunctionSemigroup = getSemigroup;
+var semigroupString = {
+  concat: function(x, y) {
+    return x + y;
+  }
+};
+var semigroupSum = {
+  concat: function(x, y) {
+    return x + y;
+  }
+};
+var semigroupProduct = {
+  concat: function(x, y) {
+    return x * y;
+  }
+};
+export {
+  concatAll,
+  constant,
+  first,
+  fold,
+  getDualSemigroup,
+  getFirstSemigroup,
+  getFunctionSemigroup,
+  getIntercalateSemigroup,
+  getJoinSemigroup,
+  getLastSemigroup,
+  getMeetSemigroup,
+  getObjectSemigroup,
+  getStructSemigroup,
+  getTupleSemigroup,
+  intercalate,
+  last,
+  max,
+  min,
+  reverse,
+  semigroupAll,
+  semigroupAny,
+  semigroupProduct,
+  semigroupString,
+  semigroupSum,
+  semigroupVoid,
+  struct,
+  tuple
+};
+//# sourceMappingURL=Semigroup.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Semigroup.js","sources":["../../../../../../node_modules/fp-ts/es6/Semigroup.js"],"sourcesContent":["/**\n * If a type `A` can form a `Semigroup` it has an **associative** binary operation.\n *\n * ```ts\n * interface Semigroup<A> {\n *   readonly concat: (x: A, y: A) => A\n * }\n * ```\n *\n * Associativity means the following equality must hold for any choice of `x`, `y`, and `z`.\n *\n * ```ts\n * concat(x, concat(y, z)) = concat(concat(x, y), z)\n * ```\n *\n * A common example of a semigroup is the type `string` with the operation `+`.\n *\n * ```ts\n * import { Semigroup } from 'fp-ts/Semigroup'\n *\n * const semigroupString: Semigroup<string> = {\n *   concat: (x, y) => x + y\n * }\n *\n * const x = 'x'\n * const y = 'y'\n * const z = 'z'\n *\n * semigroupString.concat(x, y) // 'xy'\n *\n * semigroupString.concat(x, semigroupString.concat(y, z)) // 'xyz'\n *\n * semigroupString.concat(semigroupString.concat(x, y), z) // 'xyz'\n * ```\n *\n * *Adapted from https://typelevel.org/cats*\n *\n * @since 2.0.0\n */\nimport { getSemigroup, identity } from './function';\nimport * as _ from './internal';\nimport * as M from './Magma';\nimport * as Or from './Ord';\n// -------------------------------------------------------------------------------------\n// constructors\n// -------------------------------------------------------------------------------------\n/**\n * Get a semigroup where `concat` will return the minimum, based on the provided order.\n *\n * @example\n * import * as N from 'fp-ts/number'\n * import * as S from 'fp-ts/Semigroup'\n *\n * const S1 = S.min(N.Ord)\n *\n * assert.deepStrictEqual(S1.concat(1, 2), 1)\n *\n * @category constructors\n * @since 2.10.0\n */\nexport var min = function (O) { return ({\n    concat: Or.min(O)\n}); };\n/**\n * Get a semigroup where `concat` will return the maximum, based on the provided order.\n *\n * @example\n * import * as N from 'fp-ts/number'\n * import * as S from 'fp-ts/Semigroup'\n *\n * const S1 = S.max(N.Ord)\n *\n * assert.deepStrictEqual(S1.concat(1, 2), 2)\n *\n * @category constructors\n * @since 2.10.0\n */\nexport var max = function (O) { return ({\n    concat: Or.max(O)\n}); };\n/**\n * @category constructors\n * @since 2.10.0\n */\nexport var constant = function (a) { return ({\n    concat: function () { return a; }\n}); };\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * The dual of a `Semigroup`, obtained by swapping the arguments of `concat`.\n *\n * @example\n * import { reverse } from 'fp-ts/Semigroup'\n * import * as S from 'fp-ts/string'\n *\n * assert.deepStrictEqual(reverse(S.Semigroup).concat('a', 'b'), 'ba')\n *\n * @since 2.10.0\n */\nexport var reverse = M.reverse;\n/**\n * Given a struct of semigroups returns a semigroup for the struct.\n *\n * @example\n * import { struct } from 'fp-ts/Semigroup'\n * import * as N from 'fp-ts/number'\n *\n * interface Point {\n *   readonly x: number\n *   readonly y: number\n * }\n *\n * const S = struct<Point>({\n *   x: N.SemigroupSum,\n *   y: N.SemigroupSum\n * })\n *\n * assert.deepStrictEqual(S.concat({ x: 1, y: 2 }, { x: 3, y: 4 }), { x: 4, y: 6 })\n *\n * @since 2.10.0\n */\nexport var struct = function (semigroups) { return ({\n    concat: function (first, second) {\n        var r = {};\n        for (var k in semigroups) {\n            if (_.has.call(semigroups, k)) {\n                r[k] = semigroups[k].concat(first[k], second[k]);\n            }\n        }\n        return r;\n    }\n}); };\n/**\n * Given a tuple of semigroups returns a semigroup for the tuple.\n *\n * @example\n * import { tuple } from 'fp-ts/Semigroup'\n * import * as B from 'fp-ts/boolean'\n * import * as N from 'fp-ts/number'\n * import * as S from 'fp-ts/string'\n *\n * const S1 = tuple(S.Semigroup, N.SemigroupSum)\n * assert.deepStrictEqual(S1.concat(['a', 1], ['b', 2]), ['ab', 3])\n *\n * const S2 = tuple(S.Semigroup, N.SemigroupSum, B.SemigroupAll)\n * assert.deepStrictEqual(S2.concat(['a', 1, true], ['b', 2, false]), ['ab', 3, false])\n *\n * @since 2.10.0\n */\nexport var tuple = function () {\n    var semigroups = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        semigroups[_i] = arguments[_i];\n    }\n    return ({\n        concat: function (first, second) { return semigroups.map(function (s, i) { return s.concat(first[i], second[i]); }); }\n    });\n};\n/**\n * Between each pair of elements insert `middle`.\n *\n * @example\n * import { intercalate } from 'fp-ts/Semigroup'\n * import * as S from 'fp-ts/string'\n * import { pipe } from 'fp-ts/function'\n *\n * const S1 = pipe(S.Semigroup, intercalate(' + '))\n *\n * assert.strictEqual(S1.concat('a', 'b'), 'a + b')\n *\n * @since 2.10.0\n */\nexport var intercalate = function (middle) {\n    return function (S) { return ({\n        concat: function (x, y) { return S.concat(x, S.concat(middle, y)); }\n    }); };\n};\n// -------------------------------------------------------------------------------------\n// instances\n// -------------------------------------------------------------------------------------\n/**\n * Always return the first argument.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.first<number>().concat(1, 2), 1)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var first = function () { return ({ concat: identity }); };\n/**\n * Always return the last argument.\n *\n * @example\n * import * as S from 'fp-ts/Semigroup'\n *\n * assert.deepStrictEqual(S.last<number>().concat(1, 2), 2)\n *\n * @category instances\n * @since 2.10.0\n */\nexport var last = function () { return ({ concat: function (_, y) { return y; } }); };\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * Given a sequence of `as`, concat them and return the total.\n *\n * If `as` is empty, return the provided `startWith` value.\n *\n * @example\n * import { concatAll } from 'fp-ts/Semigroup'\n * import * as N from 'fp-ts/number'\n *\n * const sum = concatAll(N.SemigroupSum)(0)\n *\n * assert.deepStrictEqual(sum([1, 2, 3]), 6)\n * assert.deepStrictEqual(sum([]), 0)\n *\n * @since 2.10.0\n */\nexport var concatAll = M.concatAll;\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use `void` module instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var semigroupVoid = constant(undefined);\n/**\n * Use [`getAssignSemigroup`](./struct.ts.html#getAssignSemigroup) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getObjectSemigroup = function () { return ({\n    concat: function (first, second) { return Object.assign({}, first, second); }\n}); };\n/**\n * Use [`last`](#last) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getLastSemigroup = last;\n/**\n * Use [`first`](#first) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getFirstSemigroup = first;\n/**\n * Use [`tuple`](#tuple) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getTupleSemigroup = tuple;\n/**\n * Use [`struct`](#struct) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getStructSemigroup = struct;\n/**\n * Use [`reverse`](#reverse) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getDualSemigroup = reverse;\n/**\n * Use [`max`](#max) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getJoinSemigroup = max;\n/**\n * Use [`min`](#min) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getMeetSemigroup = min;\n/**\n * Use [`intercalate`](#intercalate) instead.\n *\n * @category zone of death\n * @since 2.5.0\n * @deprecated\n */\nexport var getIntercalateSemigroup = intercalate;\nexport function fold(S) {\n    var concatAllS = concatAll(S);\n    return function (startWith, as) { return (as === undefined ? concatAllS(startWith) : concatAllS(startWith)(as)); };\n}\n/**\n * Use [`SemigroupAll`](./boolean.ts.html#SemigroupAll) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var semigroupAll = {\n    concat: function (x, y) { return x && y; }\n};\n/**\n * Use [`SemigroupAny`](./boolean.ts.html#SemigroupAny) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var semigroupAny = {\n    concat: function (x, y) { return x || y; }\n};\n/**\n * Use [`getSemigroup`](./function.ts.html#getSemigroup) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getFunctionSemigroup = getSemigroup;\n/**\n * Use [`Semigroup`](./string.ts.html#Semigroup) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var semigroupString = {\n    concat: function (x, y) { return x + y; }\n};\n/**\n * Use [`SemigroupSum`](./number.ts.html#SemigroupSum) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var semigroupSum = {\n    concat: function (x, y) { return x + y; }\n};\n/**\n * Use [`SemigroupProduct`](./number.ts.html#SemigroupProduct) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var semigroupProduct = {\n    concat: function (x, y) { return x * y; }\n};\n"],"names":["Or.min","Or.max","M.reverse","first","_.has","M.concatAll"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=Semigroupoid.cjs.map

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

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

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

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=Semigroupoid.js.map

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

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

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const _function = require("./function.cjs");
+var getFunctionSemiring = _function.getSemiring;
+exports.getFunctionSemiring = getFunctionSemiring;
+//# sourceMappingURL=Semiring.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Semiring.cjs","sources":["../../../../../../node_modules/fp-ts/es6/Semiring.js"],"sourcesContent":["/**\n * The `Semiring` class is for types that support an addition and multiplication operation.\n *\n * Instances must satisfy the following laws:\n *\n * - Commutative monoid under addition:\n *   - Associativity: `(a + b) + c <-> a + (b + c)`\n *   - Identity: `zero + a = a + zero <-> a`\n *   - Commutative: `a + b <-> b + a`\n * - Monoid under multiplication:\n *   - Associativity: `(a * b) * c <-> a * (b * c)`\n *   - Identity: `one * a <-> a * one <-> a`\n * - Multiplication distributes over addition:\n *   - Left distributivity: `a * (b + c) <-> (a * b) + (a * c)`\n *   - Right distributivity: `(a + b) * c <-> (a * c) + (b * c)`\n * - Annihilation: `zero * a <-> a * zero <-> zero`\n *\n * **Note:** The `number` type is not fully law abiding members of this class hierarchy due to the potential\n * for arithmetic overflows, and the presence of `NaN` and `Infinity` values. The behaviour is\n * unspecified in these cases.\n *\n * @since 2.0.0\n */\nimport { getSemiring } from './function';\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use [`getSemiring`](./function.ts.html#getsemiring) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getFunctionSemiring = getSemiring;\n"],"names":["getSemiring"],"mappings":";;;AAkCU,IAAC,sBAAsBA,UAAAA;;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,6 @@
+import { getSemiring } from "./function.js";
+var getFunctionSemiring = getSemiring;
+export {
+  getFunctionSemiring
+};
+//# sourceMappingURL=Semiring.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Semiring.js","sources":["../../../../../../node_modules/fp-ts/es6/Semiring.js"],"sourcesContent":["/**\n * The `Semiring` class is for types that support an addition and multiplication operation.\n *\n * Instances must satisfy the following laws:\n *\n * - Commutative monoid under addition:\n *   - Associativity: `(a + b) + c <-> a + (b + c)`\n *   - Identity: `zero + a = a + zero <-> a`\n *   - Commutative: `a + b <-> b + a`\n * - Monoid under multiplication:\n *   - Associativity: `(a * b) * c <-> a * (b * c)`\n *   - Identity: `one * a <-> a * one <-> a`\n * - Multiplication distributes over addition:\n *   - Left distributivity: `a * (b + c) <-> (a * b) + (a * c)`\n *   - Right distributivity: `(a + b) * c <-> (a * c) + (b * c)`\n * - Annihilation: `zero * a <-> a * zero <-> zero`\n *\n * **Note:** The `number` type is not fully law abiding members of this class hierarchy due to the potential\n * for arithmetic overflows, and the presence of `NaN` and `Infinity` values. The behaviour is\n * unspecified in these cases.\n *\n * @since 2.0.0\n */\nimport { getSemiring } from './function';\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * Use [`getSemiring`](./function.ts.html#getsemiring) instead.\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var getFunctionSemiring = getSemiring;\n"],"names":[],"mappings":";AAkCU,IAAC,sBAAsB;","x_google_ignoreList":[0]}