@slicemachine/manager 0.22.2-alpha.dani-repeatable-links-codegen.2 → 0.22.2-alpha.dani-repeatable-links-warning.1

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

@@ -1,58 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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

@@ -1,58 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,44 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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

@@ -1,44 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,144 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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

@@ -1,144 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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":";;;;AA4DU,IAAC,MAAM,SAAU,GAAG;AAAE,SAAQ;AAAA,IACpC,QAAQA,MAAO,CAAC;AAAA,EACpB;AAAM;AAeI,IAAC,MAAM,SAAU,GAAG;AAAE,SAAQ;AAAA,IACpC,QAAQC,MAAO,CAAC;AAAA,EACpB;AAAM;AAKI,IAAC,WAAW,SAAU,GAAG;AAAE,SAAQ;AAAA,IACzC,QAAQ,WAAY;AAAE,aAAO;AAAA,IAAI;AAAA,EACrC;AAAM;AAeI,IAAC,UAAUC;AAsBX,IAAC,SAAS,SAAU,YAAY;AAAE,SAAQ;AAAA,IAChD,QAAQ,SAAUC,QAAO,QAAQ;AAC7B,UAAI,IAAI,CAAA;AACR,eAAS,KAAK,YAAY;AACtB,YAAIC,IAAM,KAAK,YAAY,CAAC,GAAG;AAC3B,YAAE,CAAC,IAAI,WAAW,CAAC,EAAE,OAAOD,OAAM,CAAC,GAAG,OAAO,CAAC,CAAC;AAAA,QAClD;AAAA,MACJ;AACD,aAAO;AAAA,IACV;AAAA,EACL;AAAM;AAkBI,IAAC,QAAQ,WAAY;AAC3B,MAAI,aAAa,CAAA;AACjB,WAAS,KAAK,GAAG,KAAK,UAAU,QAAQ,MAAM;AAC1C,eAAW,EAAE,IAAI,UAAU,EAAE;AAAA,EAChC;AACD,SAAQ;AAAA,IACJ,QAAQ,SAAUA,QAAO,QAAQ;AAAE,aAAO,WAAW,IAAI,SAAU,GAAG,GAAG;AAAE,eAAO,EAAE,OAAOA,OAAM,CAAC,GAAG,OAAO,CAAC,CAAC;AAAA,MAAI,CAAA;AAAA,IAAI;AAAA,EAC9H;AACA;AAeU,IAAC,cAAc,SAAU,QAAQ;AACvC,SAAO,SAAU,GAAG;AAAE,WAAQ;AAAA,MAC1B,QAAQ,SAAU,GAAG,GAAG;AAAE,eAAO,EAAE,OAAO,GAAG,EAAE,OAAO,QAAQ,CAAC,CAAC;AAAA,MAAI;AAAA,IACvE;AAAA;AACL;AAeU,IAAC,QAAQ,WAAY;AAAE,SAAQ,EAAE,QAAQ,SAAU;AAAK;AAYxD,IAAC,OAAO,WAAY;AAAE,SAAQ,EAAE,QAAQ,SAAU,GAAG,GAAG;AAAE,WAAO;AAAA,EAAI,EAAA;AAAO;AAoB5E,IAAC,YAAYE;AAWb,IAAC,gBAAgB,SAAS,MAAS;AAQnC,IAAC,qBAAqB,WAAY;AAAE,SAAQ;AAAA,IAClD,QAAQ,SAAUF,QAAO,QAAQ;AAAE,aAAO,OAAO,OAAO,IAAIA,QAAO,MAAM;AAAA,IAAI;AAAA,EACjF;AAAM;AAQI,IAAC,mBAAmB;AAQpB,IAAC,oBAAoB;AAQrB,IAAC,oBAAoB;AAQrB,IAAC,qBAAqB;AAQtB,IAAC,mBAAmB;AAQpB,IAAC,mBAAmB;AAQpB,IAAC,mBAAmB;AAQpB,IAAC,0BAA0B;AAC9B,SAAS,KAAK,GAAG;AACpB,MAAI,aAAa,UAAU,CAAC;AAC5B,SAAO,SAAU,WAAW,IAAI;AAAE,WAAQ,OAAO,SAAY,WAAW,SAAS,IAAI,WAAW,SAAS,EAAE,EAAE;AAAA,EAAG;AACpH;AAQU,IAAC,eAAe;AAAA,EACtB,QAAQ,SAAU,GAAG,GAAG;AAAE,WAAO,KAAK;AAAA,EAAI;AAC9C;AAQU,IAAC,eAAe;AAAA,EACtB,QAAQ,SAAU,GAAG,GAAG;AAAE,WAAO,KAAK;AAAA,EAAI;AAC9C;AAQU,IAAC,uBAAuB;AAQxB,IAAC,kBAAkB;AAAA,EACzB,QAAQ,SAAU,GAAG,GAAG;AAAE,WAAO,IAAI;AAAA,EAAI;AAC7C;AAQU,IAAC,eAAe;AAAA,EACtB,QAAQ,SAAU,GAAG,GAAG;AAAE,WAAO,IAAI;AAAA,EAAI;AAC7C;AAQU,IAAC,mBAAmB;AAAA,EAC1B,QAAQ,SAAU,GAAG,GAAG;AAAE,WAAO,IAAI;AAAA,EAAI;AAC7C;","x_google_ignoreList":[0]}

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

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

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

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

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

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

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

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

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

@@ -1,6 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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

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

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

@@ -1 +0,0 @@
-{"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]}