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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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