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

package/dist/_node_modules/fp-ts/lib/FromEither.js

@@ -0,0 +1,133 @@
+import { commonjsGlobal } from "../../../_virtual/_commonjsHelpers.js";
+import { __exports as FromEither } from "../../../_virtual/FromEither.js";
+import { __require as requireChain } from "./Chain.js";
+import { __require as require_function } from "./function.js";
+import { __require as requireInternal } from "./internal.js";
+var hasRequiredFromEither;
+function requireFromEither() {
+  if (hasRequiredFromEither)
+    return FromEither;
+  hasRequiredFromEither = 1;
+  var __createBinding = commonjsGlobal && commonjsGlobal.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === void 0)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === void 0)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = commonjsGlobal && commonjsGlobal.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = commonjsGlobal && commonjsGlobal.__importStar || function(mod) {
+    if (mod && mod.__esModule)
+      return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod)
+        if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  Object.defineProperty(FromEither, "__esModule", { value: true });
+  FromEither.tapEither = FromEither.filterOrElse = FromEither.chainFirstEitherK = FromEither.chainEitherK = FromEither.fromEitherK = FromEither.chainOptionK = FromEither.fromOptionK = FromEither.fromPredicate = FromEither.fromOption = void 0;
+  var Chain_1 = requireChain();
+  var function_1 = require_function();
+  var _ = __importStar(requireInternal());
+  function fromOption(F) {
+    return function(onNone) {
+      return function(ma) {
+        return F.fromEither(_.isNone(ma) ? _.left(onNone()) : _.right(ma.value));
+      };
+    };
+  }
+  FromEither.fromOption = fromOption;
+  function fromPredicate(F) {
+    return function(predicate, onFalse) {
+      return function(a) {
+        return F.fromEither(predicate(a) ? _.right(a) : _.left(onFalse(a)));
+      };
+    };
+  }
+  FromEither.fromPredicate = fromPredicate;
+  function fromOptionK(F) {
+    var fromOptionF = fromOption(F);
+    return function(onNone) {
+      var from = fromOptionF(onNone);
+      return function(f) {
+        return (0, function_1.flow)(f, from);
+      };
+    };
+  }
+  FromEither.fromOptionK = fromOptionK;
+  function chainOptionK(F, M) {
+    var fromOptionKF = fromOptionK(F);
+    return function(onNone) {
+      var from = fromOptionKF(onNone);
+      return function(f) {
+        return function(ma) {
+          return M.chain(ma, from(f));
+        };
+      };
+    };
+  }
+  FromEither.chainOptionK = chainOptionK;
+  function fromEitherK(F) {
+    return function(f) {
+      return (0, function_1.flow)(f, F.fromEither);
+    };
+  }
+  FromEither.fromEitherK = fromEitherK;
+  function chainEitherK(F, M) {
+    var fromEitherKF = fromEitherK(F);
+    return function(f) {
+      return function(ma) {
+        return M.chain(ma, fromEitherKF(f));
+      };
+    };
+  }
+  FromEither.chainEitherK = chainEitherK;
+  function chainFirstEitherK(F, M) {
+    var tapEitherM = tapEither(F, M);
+    return function(f) {
+      return function(ma) {
+        return tapEitherM(ma, f);
+      };
+    };
+  }
+  FromEither.chainFirstEitherK = chainFirstEitherK;
+  function filterOrElse(F, M) {
+    return function(predicate, onFalse) {
+      return function(ma) {
+        return M.chain(ma, function(a) {
+          return F.fromEither(predicate(a) ? _.right(a) : _.left(onFalse(a)));
+        });
+      };
+    };
+  }
+  FromEither.filterOrElse = filterOrElse;
+  function tapEither(F, M) {
+    var fromEither = fromEitherK(F);
+    var tapM = (0, Chain_1.tap)(M);
+    return function(self, f) {
+      return tapM(self, fromEither(f));
+    };
+  }
+  FromEither.tapEither = tapEither;
+  return FromEither;
+}
+export {
+  requireFromEither as __require
+};
+//# sourceMappingURL=FromEither.js.map

package/dist/_node_modules/fp-ts/lib/FromEither.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FromEither.js","sources":["../../../../../../node_modules/fp-ts/lib/FromEither.js"],"sourcesContent":["\"use strict\";\n/**\n * The `FromEither` type class represents those data types which support errors.\n *\n * @since 2.10.0\n */\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.tapEither = exports.filterOrElse = exports.chainFirstEitherK = exports.chainEitherK = exports.fromEitherK = exports.chainOptionK = exports.fromOptionK = exports.fromPredicate = exports.fromOption = void 0;\nvar Chain_1 = require(\"./Chain\");\nvar function_1 = require(\"./function\");\nvar _ = __importStar(require(\"./internal\"));\nfunction fromOption(F) {\n    return function (onNone) { return function (ma) { return F.fromEither(_.isNone(ma) ? _.left(onNone()) : _.right(ma.value)); }; };\n}\nexports.fromOption = fromOption;\nfunction fromPredicate(F) {\n    return function (predicate, onFalse) {\n        return function (a) {\n            return F.fromEither(predicate(a) ? _.right(a) : _.left(onFalse(a)));\n        };\n    };\n}\nexports.fromPredicate = fromPredicate;\nfunction fromOptionK(F) {\n    var fromOptionF = fromOption(F);\n    return function (onNone) {\n        var from = fromOptionF(onNone);\n        return function (f) { return (0, function_1.flow)(f, from); };\n    };\n}\nexports.fromOptionK = fromOptionK;\nfunction chainOptionK(F, M) {\n    var fromOptionKF = fromOptionK(F);\n    return function (onNone) {\n        var from = fromOptionKF(onNone);\n        return function (f) { return function (ma) { return M.chain(ma, from(f)); }; };\n    };\n}\nexports.chainOptionK = chainOptionK;\nfunction fromEitherK(F) {\n    return function (f) { return (0, function_1.flow)(f, F.fromEither); };\n}\nexports.fromEitherK = fromEitherK;\nfunction chainEitherK(F, M) {\n    var fromEitherKF = fromEitherK(F);\n    return function (f) { return function (ma) { return M.chain(ma, fromEitherKF(f)); }; };\n}\nexports.chainEitherK = chainEitherK;\nfunction chainFirstEitherK(F, M) {\n    var tapEitherM = tapEither(F, M);\n    return function (f) { return function (ma) { return tapEitherM(ma, f); }; };\n}\nexports.chainFirstEitherK = chainFirstEitherK;\nfunction filterOrElse(F, M) {\n    return function (predicate, onFalse) {\n        return function (ma) {\n            return M.chain(ma, function (a) { return F.fromEither(predicate(a) ? _.right(a) : _.left(onFalse(a))); });\n        };\n    };\n}\nexports.filterOrElse = filterOrElse;\n/** @internal */\nfunction tapEither(F, M) {\n    var fromEither = fromEitherK(F);\n    var tapM = (0, Chain_1.tap)(M);\n    return function (self, f) { return tapM(self, fromEither(f)); };\n}\nexports.tapEither = tapEither;\n"],"names":["this","require$$0","require$$1","require$$2"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/_node_modules/fp-ts/lib/Functor.cjs

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Functor = require("../../../_virtual/Functor.cjs");
+const _function = require("./function.cjs");
+var hasRequiredFunctor;
+function requireFunctor() {
+  if (hasRequiredFunctor)
+    return Functor.__exports;
+  hasRequiredFunctor = 1;
+  Object.defineProperty(Functor.__exports, "__esModule", { value: true });
+  Functor.__exports.asUnit = Functor.__exports.as = Functor.__exports.getFunctorComposition = Functor.__exports.let = Functor.__exports.bindTo = Functor.__exports.flap = Functor.__exports.map = void 0;
+  var function_1 = _function.__require();
+  function map(F, G) {
+    return function(f) {
+      return function(fa) {
+        return F.map(fa, function(ga) {
+          return G.map(ga, f);
+        });
+      };
+    };
+  }
+  Functor.__exports.map = map;
+  function flap(F) {
+    return function(a) {
+      return function(fab) {
+        return F.map(fab, function(f) {
+          return f(a);
+        });
+      };
+    };
+  }
+  Functor.__exports.flap = flap;
+  function bindTo(F) {
+    return function(name) {
+      return function(fa) {
+        return F.map(fa, function(a) {
+          var _a;
+          return _a = {}, _a[name] = a, _a;
+        });
+      };
+    };
+  }
+  Functor.__exports.bindTo = bindTo;
+  function let_(F) {
+    return function(name, f) {
+      return function(fa) {
+        return F.map(fa, function(a) {
+          var _a;
+          return Object.assign({}, a, (_a = {}, _a[name] = f(a), _a));
+        });
+      };
+    };
+  }
+  Functor.__exports.let = let_;
+  function getFunctorComposition(F, G) {
+    var _map = map(F, G);
+    return {
+      map: function(fga, f) {
+        return (0, function_1.pipe)(fga, _map(f));
+      }
+    };
+  }
+  Functor.__exports.getFunctorComposition = getFunctorComposition;
+  function as(F) {
+    return function(self, b) {
+      return F.map(self, function() {
+        return b;
+      });
+    };
+  }
+  Functor.__exports.as = as;
+  function asUnit(F) {
+    var asM = as(F);
+    return function(self) {
+      return asM(self, void 0);
+    };
+  }
+  Functor.__exports.asUnit = asUnit;
+  return Functor.__exports;
+}
+exports.__require = requireFunctor;
+//# sourceMappingURL=Functor.cjs.map

package/dist/_node_modules/fp-ts/lib/Functor.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Functor.cjs","sources":["../../../../../../node_modules/fp-ts/lib/Functor.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.asUnit = exports.as = exports.getFunctorComposition = exports.let = exports.bindTo = exports.flap = exports.map = void 0;\n/**\n * A `Functor` is a type constructor which supports a mapping operation `map`.\n *\n * `map` can be used to turn functions `a -> b` into functions `f a -> f b` whose argument and return types use the type\n * constructor `f` to represent some computational context.\n *\n * Instances must satisfy the following laws:\n *\n * 1. Identity: `F.map(fa, a => a) <-> fa`\n * 2. Composition: `F.map(fa, a => bc(ab(a))) <-> F.map(F.map(fa, ab), bc)`\n *\n * @since 2.0.0\n */\nvar function_1 = require(\"./function\");\nfunction map(F, G) {\n    return function (f) { return function (fa) { return F.map(fa, function (ga) { return G.map(ga, f); }); }; };\n}\nexports.map = map;\nfunction flap(F) {\n    return function (a) { return function (fab) { return F.map(fab, function (f) { return f(a); }); }; };\n}\nexports.flap = flap;\nfunction bindTo(F) {\n    return function (name) { return function (fa) { return F.map(fa, function (a) {\n        var _a;\n        return (_a = {}, _a[name] = a, _a);\n    }); }; };\n}\nexports.bindTo = bindTo;\nfunction let_(F) {\n    return function (name, f) { return function (fa) { return F.map(fa, function (a) {\n        var _a;\n        return Object.assign({}, a, (_a = {}, _a[name] = f(a), _a));\n    }); }; };\n}\nexports.let = let_;\n/** @deprecated */\nfunction getFunctorComposition(F, G) {\n    var _map = map(F, G);\n    return {\n        map: function (fga, f) { return (0, function_1.pipe)(fga, _map(f)); }\n    };\n}\nexports.getFunctorComposition = getFunctorComposition;\n/** @internal */\nfunction as(F) {\n    return function (self, b) { return F.map(self, function () { return b; }); };\n}\nexports.as = as;\n/** @internal */\nfunction asUnit(F) {\n    var asM = as(F);\n    return function (self) { return asM(self, undefined); };\n}\nexports.asUnit = asUnit;\n"],"names":["Functor","require$$0"],"mappings":";;;;;;;;;AACA,SAAO,eAAeA,mBAAS,cAAc,EAAE,OAAO,KAAI,CAAE;AAC5DA,UAAA,UAAA,SAAiBA,QAAA,UAAA,KAAaA,QAAA,UAAA,wBAAgCA,kBAAW,MAAGA,QAAAA,UAAc,SAAGA,QAAAA,iBAAeA,QAAAA,UAAA,MAAc;AAc1H,MAAI,aAAaC,UAAAA;AACjB,WAAS,IAAI,GAAG,GAAG;AACf,WAAO,SAAU,GAAG;AAAE,aAAO,SAAU,IAAI;AAAE,eAAO,EAAE,IAAI,IAAI,SAAU,IAAI;AAAE,iBAAO,EAAE,IAAI,IAAI,CAAC;AAAA,QAAI,CAAA;AAAA,MAAI;AAAA;EAC3G;AACUD,UAAA,UAAA,MAAG;AACd,WAAS,KAAK,GAAG;AACb,WAAO,SAAU,GAAG;AAAE,aAAO,SAAU,KAAK;AAAE,eAAO,EAAE,IAAI,KAAK,SAAU,GAAG;AAAE,iBAAO,EAAE,CAAC;AAAA,SAAI;AAAA,MAAI;AAAA;EACpG;AACWA,UAAA,UAAA,OAAG;AACf,WAAS,OAAO,GAAG;AACf,WAAO,SAAU,MAAM;AAAE,aAAO,SAAU,IAAI;AAAE,eAAO,EAAE,IAAI,IAAI,SAAU,GAAG;AAC1E,cAAI;AACJ,iBAAQ,KAAK,CAAA,GAAI,GAAG,IAAI,IAAI,GAAG;AAAA,QACvC,CAAK;AAAA,MAAI;AAAA;EACR;AACaA,UAAA,UAAA,SAAG;AACjB,WAAS,KAAK,GAAG;AACb,WAAO,SAAU,MAAM,GAAG;AAAE,aAAO,SAAU,IAAI;AAAE,eAAO,EAAE,IAAI,IAAI,SAAU,GAAG;AAC7E,cAAI;AACJ,iBAAO,OAAO,OAAO,IAAI,IAAI,KAAK,CAAA,GAAI,GAAG,IAAI,IAAI,EAAE,CAAC,GAAG,GAAE;AAAA,QACjE,CAAK;AAAA,MAAI;AAAA;EACR;AACUA,UAAA,UAAA,MAAG;AAEd,WAAS,sBAAsB,GAAG,GAAG;AACjC,QAAI,OAAO,IAAI,GAAG,CAAC;AACnB,WAAO;AAAA,MACH,KAAK,SAAU,KAAK,GAAG;AAAE,gBAAW,GAAA,WAAW,MAAM,KAAK,KAAK,CAAC,CAAC;AAAA,MAAI;AAAA,IAC7E;AAAA,EACC;AAC4BA,UAAA,UAAA,wBAAG;AAEhC,WAAS,GAAG,GAAG;AACX,WAAO,SAAU,MAAM,GAAG;AAAE,aAAO,EAAE,IAAI,MAAM,WAAY;AAAE,eAAO;AAAA,MAAI,CAAA;AAAA,IAAE;AAAA,EAC7E;AACSA,UAAA,UAAA,KAAG;AAEb,WAAS,OAAO,GAAG;AACf,QAAI,MAAM,GAAG,CAAC;AACd,WAAO,SAAU,MAAM;AAAE,aAAO,IAAI,MAAM,MAAS;AAAA;EACtD;AACDA,UAAA,UAAA,SAAiB;;;;","x_google_ignoreList":[0]}

package/dist/_node_modules/fp-ts/lib/Functor.js

@@ -0,0 +1,82 @@
+import { __exports as Functor } from "../../../_virtual/Functor.js";
+import { __require as require_function } from "./function.js";
+var hasRequiredFunctor;
+function requireFunctor() {
+  if (hasRequiredFunctor)
+    return Functor;
+  hasRequiredFunctor = 1;
+  Object.defineProperty(Functor, "__esModule", { value: true });
+  Functor.asUnit = Functor.as = Functor.getFunctorComposition = Functor.let = Functor.bindTo = Functor.flap = Functor.map = void 0;
+  var function_1 = require_function();
+  function map(F, G) {
+    return function(f) {
+      return function(fa) {
+        return F.map(fa, function(ga) {
+          return G.map(ga, f);
+        });
+      };
+    };
+  }
+  Functor.map = map;
+  function flap(F) {
+    return function(a) {
+      return function(fab) {
+        return F.map(fab, function(f) {
+          return f(a);
+        });
+      };
+    };
+  }
+  Functor.flap = flap;
+  function bindTo(F) {
+    return function(name) {
+      return function(fa) {
+        return F.map(fa, function(a) {
+          var _a;
+          return _a = {}, _a[name] = a, _a;
+        });
+      };
+    };
+  }
+  Functor.bindTo = bindTo;
+  function let_(F) {
+    return function(name, f) {
+      return function(fa) {
+        return F.map(fa, function(a) {
+          var _a;
+          return Object.assign({}, a, (_a = {}, _a[name] = f(a), _a));
+        });
+      };
+    };
+  }
+  Functor.let = let_;
+  function getFunctorComposition(F, G) {
+    var _map = map(F, G);
+    return {
+      map: function(fga, f) {
+        return (0, function_1.pipe)(fga, _map(f));
+      }
+    };
+  }
+  Functor.getFunctorComposition = getFunctorComposition;
+  function as(F) {
+    return function(self, b) {
+      return F.map(self, function() {
+        return b;
+      });
+    };
+  }
+  Functor.as = as;
+  function asUnit(F) {
+    var asM = as(F);
+    return function(self) {
+      return asM(self, void 0);
+    };
+  }
+  Functor.asUnit = asUnit;
+  return Functor;
+}
+export {
+  requireFunctor as __require
+};
+//# sourceMappingURL=Functor.js.map

package/dist/_node_modules/fp-ts/lib/Functor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Functor.js","sources":["../../../../../../node_modules/fp-ts/lib/Functor.js"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.asUnit = exports.as = exports.getFunctorComposition = exports.let = exports.bindTo = exports.flap = exports.map = void 0;\n/**\n * A `Functor` is a type constructor which supports a mapping operation `map`.\n *\n * `map` can be used to turn functions `a -> b` into functions `f a -> f b` whose argument and return types use the type\n * constructor `f` to represent some computational context.\n *\n * Instances must satisfy the following laws:\n *\n * 1. Identity: `F.map(fa, a => a) <-> fa`\n * 2. Composition: `F.map(fa, a => bc(ab(a))) <-> F.map(F.map(fa, ab), bc)`\n *\n * @since 2.0.0\n */\nvar function_1 = require(\"./function\");\nfunction map(F, G) {\n    return function (f) { return function (fa) { return F.map(fa, function (ga) { return G.map(ga, f); }); }; };\n}\nexports.map = map;\nfunction flap(F) {\n    return function (a) { return function (fab) { return F.map(fab, function (f) { return f(a); }); }; };\n}\nexports.flap = flap;\nfunction bindTo(F) {\n    return function (name) { return function (fa) { return F.map(fa, function (a) {\n        var _a;\n        return (_a = {}, _a[name] = a, _a);\n    }); }; };\n}\nexports.bindTo = bindTo;\nfunction let_(F) {\n    return function (name, f) { return function (fa) { return F.map(fa, function (a) {\n        var _a;\n        return Object.assign({}, a, (_a = {}, _a[name] = f(a), _a));\n    }); }; };\n}\nexports.let = let_;\n/** @deprecated */\nfunction getFunctorComposition(F, G) {\n    var _map = map(F, G);\n    return {\n        map: function (fga, f) { return (0, function_1.pipe)(fga, _map(f)); }\n    };\n}\nexports.getFunctorComposition = getFunctorComposition;\n/** @internal */\nfunction as(F) {\n    return function (self, b) { return F.map(self, function () { return b; }); };\n}\nexports.as = as;\n/** @internal */\nfunction asUnit(F) {\n    var asM = as(F);\n    return function (self) { return asM(self, undefined); };\n}\nexports.asUnit = asUnit;\n"],"names":["require$$0"],"mappings":";;;;;;;AACA,SAAO,eAAe,SAAS,cAAc,EAAE,OAAO,KAAI,CAAE;AAC5D,UAAA,SAAiB,QAAA,KAAa,QAAA,wBAAgC,QAAW,MAAG,QAAc,SAAG,eAAe,QAAA,MAAc;AAc1H,MAAI,aAAaA;AACjB,WAAS,IAAI,GAAG,GAAG;AACf,WAAO,SAAU,GAAG;AAAE,aAAO,SAAU,IAAI;AAAE,eAAO,EAAE,IAAI,IAAI,SAAU,IAAI;AAAE,iBAAO,EAAE,IAAI,IAAI,CAAC;AAAA,QAAI,CAAA;AAAA,MAAI;AAAA;EAC3G;AACU,UAAA,MAAG;AACd,WAAS,KAAK,GAAG;AACb,WAAO,SAAU,GAAG;AAAE,aAAO,SAAU,KAAK;AAAE,eAAO,EAAE,IAAI,KAAK,SAAU,GAAG;AAAE,iBAAO,EAAE,CAAC;AAAA,SAAI;AAAA,MAAI;AAAA;EACpG;AACW,UAAA,OAAG;AACf,WAAS,OAAO,GAAG;AACf,WAAO,SAAU,MAAM;AAAE,aAAO,SAAU,IAAI;AAAE,eAAO,EAAE,IAAI,IAAI,SAAU,GAAG;AAC1E,cAAI;AACJ,iBAAQ,KAAK,CAAA,GAAI,GAAG,IAAI,IAAI,GAAG;AAAA,QACvC,CAAK;AAAA,MAAI;AAAA;EACR;AACa,UAAA,SAAG;AACjB,WAAS,KAAK,GAAG;AACb,WAAO,SAAU,MAAM,GAAG;AAAE,aAAO,SAAU,IAAI;AAAE,eAAO,EAAE,IAAI,IAAI,SAAU,GAAG;AAC7E,cAAI;AACJ,iBAAO,OAAO,OAAO,IAAI,IAAI,KAAK,CAAA,GAAI,GAAG,IAAI,IAAI,EAAE,CAAC,GAAG,GAAE;AAAA,QACjE,CAAK;AAAA,MAAI;AAAA;EACR;AACU,UAAA,MAAG;AAEd,WAAS,sBAAsB,GAAG,GAAG;AACjC,QAAI,OAAO,IAAI,GAAG,CAAC;AACnB,WAAO;AAAA,MACH,KAAK,SAAU,KAAK,GAAG;AAAE,gBAAW,GAAA,WAAW,MAAM,KAAK,KAAK,CAAC,CAAC;AAAA,MAAI;AAAA,IAC7E;AAAA,EACC;AAC4B,UAAA,wBAAG;AAEhC,WAAS,GAAG,GAAG;AACX,WAAO,SAAU,MAAM,GAAG;AAAE,aAAO,EAAE,IAAI,MAAM,WAAY;AAAE,eAAO;AAAA,MAAI,CAAA;AAAA,IAAE;AAAA,EAC7E;AACS,UAAA,KAAG;AAEb,WAAS,OAAO,GAAG;AACf,QAAI,MAAM,GAAG,CAAC;AACd,WAAO,SAAU,MAAM;AAAE,aAAO,IAAI,MAAM,MAAS;AAAA;EACtD;AACD,UAAA,SAAiB;;;","x_google_ignoreList":[0]}

package/dist/_node_modules/fp-ts/lib/Magma.cjs

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Magma = require("../../../_virtual/Magma.cjs");
+var hasRequiredMagma;
+function requireMagma() {
+  if (hasRequiredMagma)
+    return Magma.__exports;
+  hasRequiredMagma = 1;
+  Object.defineProperty(Magma.__exports, "__esModule", { value: true });
+  Magma.__exports.concatAll = Magma.__exports.endo = Magma.__exports.filterSecond = Magma.__exports.filterFirst = Magma.__exports.reverse = void 0;
+  var reverse = function(M) {
+    return {
+      concat: function(first, second) {
+        return M.concat(second, first);
+      }
+    };
+  };
+  Magma.__exports.reverse = reverse;
+  var filterFirst = function(predicate) {
+    return function(M) {
+      return {
+        concat: function(first, second) {
+          return predicate(first) ? M.concat(first, second) : second;
+        }
+      };
+    };
+  };
+  Magma.__exports.filterFirst = filterFirst;
+  var filterSecond = function(predicate) {
+    return function(M) {
+      return {
+        concat: function(first, second) {
+          return predicate(second) ? M.concat(first, second) : first;
+        }
+      };
+    };
+  };
+  Magma.__exports.filterSecond = filterSecond;
+  var endo = function(f) {
+    return function(M) {
+      return {
+        concat: function(first, second) {
+          return M.concat(f(first), f(second));
+        }
+      };
+    };
+  };
+  Magma.__exports.endo = endo;
+  var concatAll = function(M) {
+    return function(startWith) {
+      return function(as) {
+        return as.reduce(function(a, acc) {
+          return M.concat(a, acc);
+        }, startWith);
+      };
+    };
+  };
+  Magma.__exports.concatAll = concatAll;
+  return Magma.__exports;
+}
+exports.__require = requireMagma;
+//# sourceMappingURL=Magma.cjs.map

package/dist/_node_modules/fp-ts/lib/Magma.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Magma.cjs","sources":["../../../../../../node_modules/fp-ts/lib/Magma.js"],"sourcesContent":["\"use strict\";\n/**\n * A `Magma` is a pair `(A, concat)` in which `A` is a non-empty set and `concat` is a binary operation on `A`\n *\n * See [Semigroup](https://gcanti.github.io/fp-ts/modules/Semigroup.ts.html) for some instances.\n *\n * @since 2.0.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.concatAll = exports.endo = exports.filterSecond = exports.filterFirst = exports.reverse = void 0;\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * The dual of a `Magma`, obtained by swapping the arguments of `concat`.\n *\n * @example\n * import { reverse, concatAll } from 'fp-ts/Magma'\n * import * as N from 'fp-ts/number'\n *\n * const subAll = concatAll(reverse(N.MagmaSub))(0)\n *\n * assert.deepStrictEqual(subAll([1, 2, 3]), 2)\n *\n * @since 2.11.0\n */\nvar reverse = function (M) { return ({\n    concat: function (first, second) { return M.concat(second, first); }\n}); };\nexports.reverse = reverse;\n/**\n * @since 2.11.0\n */\nvar filterFirst = function (predicate) {\n    return function (M) { return ({\n        concat: function (first, second) { return (predicate(first) ? M.concat(first, second) : second); }\n    }); };\n};\nexports.filterFirst = filterFirst;\n/**\n * @since 2.11.0\n */\nvar filterSecond = function (predicate) {\n    return function (M) { return ({\n        concat: function (first, second) { return (predicate(second) ? M.concat(first, second) : first); }\n    }); };\n};\nexports.filterSecond = filterSecond;\n/**\n * @since 2.11.0\n */\nvar endo = function (f) {\n    return function (M) { return ({\n        concat: function (first, second) { return M.concat(f(first), f(second)); }\n    }); };\n};\nexports.endo = endo;\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/Magma'\n * import * as N from 'fp-ts/number'\n *\n * const subAll = concatAll(N.MagmaSub)(0)\n *\n * assert.deepStrictEqual(subAll([1, 2, 3]), -6)\n *\n * @since 2.11.0\n */\nvar concatAll = function (M) {\n    return function (startWith) {\n        return function (as) {\n            return as.reduce(function (a, acc) { return M.concat(a, acc); }, startWith);\n        };\n    };\n};\nexports.concatAll = concatAll;\n"],"names":["Magma"],"mappings":";;;;;;;;AAQA,SAAO,eAAeA,iBAAS,cAAc,EAAE,OAAO,KAAI,CAAE;AAC3CA,QAAAA,UAAA,YAAGA,gBAAY,OAAGA,MAAAA,UAAoB,eAAGA,MAAmB,UAAA,cAAGA,MAAAA,UAAe,UAAG;AAiBlG,MAAI,UAAU,SAAU,GAAG;AAAE,WAAQ;AAAA,MACjC,QAAQ,SAAU,OAAO,QAAQ;AAAE,eAAO,EAAE,OAAO,QAAQ,KAAK;AAAA,MAAI;AAAA,IACvE;AAAA;AACcA,QAAA,UAAA,UAAG;AAIlB,MAAI,cAAc,SAAU,WAAW;AACnC,WAAO,SAAU,GAAG;AAAE,aAAQ;AAAA,QAC1B,QAAQ,SAAU,OAAO,QAAQ;AAAE,iBAAQ,UAAU,KAAK,IAAI,EAAE,OAAO,OAAO,MAAM,IAAI;AAAA,QAAU;AAAA,MACrG;AAAA;EACL;AACmBA,QAAA,UAAA,cAAG;AAItB,MAAI,eAAe,SAAU,WAAW;AACpC,WAAO,SAAU,GAAG;AAAE,aAAQ;AAAA,QAC1B,QAAQ,SAAU,OAAO,QAAQ;AAAE,iBAAQ,UAAU,MAAM,IAAI,EAAE,OAAO,OAAO,MAAM,IAAI;AAAA,QAAS;AAAA,MACrG;AAAA;EACL;AACoBA,QAAA,UAAA,eAAG;AAIvB,MAAI,OAAO,SAAU,GAAG;AACpB,WAAO,SAAU,GAAG;AAAE,aAAQ;AAAA,QAC1B,QAAQ,SAAU,OAAO,QAAQ;AAAE,iBAAO,EAAE,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,CAAC;AAAA,QAAI;AAAA,MAC7E;AAAA;EACL;AACYA,QAAA,UAAA,OAAG;AAmBf,MAAI,YAAY,SAAU,GAAG;AACzB,WAAO,SAAU,WAAW;AACxB,aAAO,SAAU,IAAI;AACjB,eAAO,GAAG,OAAO,SAAU,GAAG,KAAK;AAAE,iBAAO,EAAE,OAAO,GAAG,GAAG;AAAA,QAAI,GAAE,SAAS;AAAA,MACtF;AAAA,IACA;AAAA,EACA;AACAA,QAAA,UAAA,YAAoB;;;;","x_google_ignoreList":[0]}

package/dist/_node_modules/fp-ts/lib/Magma.js

@@ -0,0 +1,62 @@
+import { __exports as Magma } from "../../../_virtual/Magma.js";
+var hasRequiredMagma;
+function requireMagma() {
+  if (hasRequiredMagma)
+    return Magma;
+  hasRequiredMagma = 1;
+  Object.defineProperty(Magma, "__esModule", { value: true });
+  Magma.concatAll = Magma.endo = Magma.filterSecond = Magma.filterFirst = Magma.reverse = void 0;
+  var reverse = function(M) {
+    return {
+      concat: function(first, second) {
+        return M.concat(second, first);
+      }
+    };
+  };
+  Magma.reverse = reverse;
+  var filterFirst = function(predicate) {
+    return function(M) {
+      return {
+        concat: function(first, second) {
+          return predicate(first) ? M.concat(first, second) : second;
+        }
+      };
+    };
+  };
+  Magma.filterFirst = filterFirst;
+  var filterSecond = function(predicate) {
+    return function(M) {
+      return {
+        concat: function(first, second) {
+          return predicate(second) ? M.concat(first, second) : first;
+        }
+      };
+    };
+  };
+  Magma.filterSecond = filterSecond;
+  var endo = function(f) {
+    return function(M) {
+      return {
+        concat: function(first, second) {
+          return M.concat(f(first), f(second));
+        }
+      };
+    };
+  };
+  Magma.endo = endo;
+  var concatAll = function(M) {
+    return function(startWith) {
+      return function(as) {
+        return as.reduce(function(a, acc) {
+          return M.concat(a, acc);
+        }, startWith);
+      };
+    };
+  };
+  Magma.concatAll = concatAll;
+  return Magma;
+}
+export {
+  requireMagma as __require
+};
+//# sourceMappingURL=Magma.js.map

package/dist/_node_modules/fp-ts/lib/Magma.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Magma.js","sources":["../../../../../../node_modules/fp-ts/lib/Magma.js"],"sourcesContent":["\"use strict\";\n/**\n * A `Magma` is a pair `(A, concat)` in which `A` is a non-empty set and `concat` is a binary operation on `A`\n *\n * See [Semigroup](https://gcanti.github.io/fp-ts/modules/Semigroup.ts.html) for some instances.\n *\n * @since 2.0.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.concatAll = exports.endo = exports.filterSecond = exports.filterFirst = exports.reverse = void 0;\n// -------------------------------------------------------------------------------------\n// combinators\n// -------------------------------------------------------------------------------------\n/**\n * The dual of a `Magma`, obtained by swapping the arguments of `concat`.\n *\n * @example\n * import { reverse, concatAll } from 'fp-ts/Magma'\n * import * as N from 'fp-ts/number'\n *\n * const subAll = concatAll(reverse(N.MagmaSub))(0)\n *\n * assert.deepStrictEqual(subAll([1, 2, 3]), 2)\n *\n * @since 2.11.0\n */\nvar reverse = function (M) { return ({\n    concat: function (first, second) { return M.concat(second, first); }\n}); };\nexports.reverse = reverse;\n/**\n * @since 2.11.0\n */\nvar filterFirst = function (predicate) {\n    return function (M) { return ({\n        concat: function (first, second) { return (predicate(first) ? M.concat(first, second) : second); }\n    }); };\n};\nexports.filterFirst = filterFirst;\n/**\n * @since 2.11.0\n */\nvar filterSecond = function (predicate) {\n    return function (M) { return ({\n        concat: function (first, second) { return (predicate(second) ? M.concat(first, second) : first); }\n    }); };\n};\nexports.filterSecond = filterSecond;\n/**\n * @since 2.11.0\n */\nvar endo = function (f) {\n    return function (M) { return ({\n        concat: function (first, second) { return M.concat(f(first), f(second)); }\n    }); };\n};\nexports.endo = endo;\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/Magma'\n * import * as N from 'fp-ts/number'\n *\n * const subAll = concatAll(N.MagmaSub)(0)\n *\n * assert.deepStrictEqual(subAll([1, 2, 3]), -6)\n *\n * @since 2.11.0\n */\nvar concatAll = function (M) {\n    return function (startWith) {\n        return function (as) {\n            return as.reduce(function (a, acc) { return M.concat(a, acc); }, startWith);\n        };\n    };\n};\nexports.concatAll = concatAll;\n"],"names":[],"mappings":";;;;;;AAQA,SAAO,eAAe,OAAS,cAAc,EAAE,OAAO,KAAI,CAAE;AAC3C,QAAA,YAAG,MAAY,OAAG,MAAoB,eAAG,MAAmB,cAAG,MAAe,UAAG;AAiBlG,MAAI,UAAU,SAAU,GAAG;AAAE,WAAQ;AAAA,MACjC,QAAQ,SAAU,OAAO,QAAQ;AAAE,eAAO,EAAE,OAAO,QAAQ,KAAK;AAAA,MAAI;AAAA,IACvE;AAAA;AACc,QAAA,UAAG;AAIlB,MAAI,cAAc,SAAU,WAAW;AACnC,WAAO,SAAU,GAAG;AAAE,aAAQ;AAAA,QAC1B,QAAQ,SAAU,OAAO,QAAQ;AAAE,iBAAQ,UAAU,KAAK,IAAI,EAAE,OAAO,OAAO,MAAM,IAAI;AAAA,QAAU;AAAA,MACrG;AAAA;EACL;AACmB,QAAA,cAAG;AAItB,MAAI,eAAe,SAAU,WAAW;AACpC,WAAO,SAAU,GAAG;AAAE,aAAQ;AAAA,QAC1B,QAAQ,SAAU,OAAO,QAAQ;AAAE,iBAAQ,UAAU,MAAM,IAAI,EAAE,OAAO,OAAO,MAAM,IAAI;AAAA,QAAS;AAAA,MACrG;AAAA;EACL;AACoB,QAAA,eAAG;AAIvB,MAAI,OAAO,SAAU,GAAG;AACpB,WAAO,SAAU,GAAG;AAAE,aAAQ;AAAA,QAC1B,QAAQ,SAAU,OAAO,QAAQ;AAAE,iBAAO,EAAE,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,CAAC;AAAA,QAAI;AAAA,MAC7E;AAAA;EACL;AACY,QAAA,OAAG;AAmBf,MAAI,YAAY,SAAU,GAAG;AACzB,WAAO,SAAU,WAAW;AACxB,aAAO,SAAU,IAAI;AACjB,eAAO,GAAG,OAAO,SAAU,GAAG,KAAK;AAAE,iBAAO,EAAE,OAAO,GAAG,GAAG;AAAA,QAAI,GAAE,SAAS;AAAA,MACtF;AAAA,IACA;AAAA,EACA;AACA,QAAA,YAAoB;;;","x_google_ignoreList":[0]}