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

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

@@ -0,0 +1,336 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Apply$1 = require("./Apply.cjs");
+const Array = require("./Array.cjs");
+const Chain$1 = require("./Chain.cjs");
+const Eq = require("./Eq.cjs");
+const _function = require("./function.cjs");
+const Functor$1 = require("./Functor.cjs");
+const internal = require("./internal.cjs");
+function make(value, forest) {
+  if (forest === void 0) {
+    forest = [];
+  }
+  return {
+    value,
+    forest
+  };
+}
+function getShow(S) {
+  var show = function(t) {
+    return Array.isEmpty(t.forest) ? "make(".concat(S.show(t.value), ")") : "make(".concat(S.show(t.value), ", [").concat(t.forest.map(show).join(", "), "])");
+  };
+  return {
+    show
+  };
+}
+function getEq(E) {
+  var SA;
+  var R = Eq.fromEquals(function(x, y) {
+    return E.equals(x.value, y.value) && SA.equals(x.forest, y.forest);
+  });
+  SA = Array.getEq(R);
+  return R;
+}
+var draw = function(indentation, forest) {
+  var r = "";
+  var len = forest.length;
+  var tree2;
+  for (var i = 0; i < len; i++) {
+    tree2 = forest[i];
+    var isLast = i === len - 1;
+    r += indentation + (isLast ? "└" : "├") + "─ " + tree2.value;
+    r += draw(indentation + (len > 1 && !isLast ? "│  " : "   "), tree2.forest);
+  }
+  return r;
+};
+function drawForest(forest) {
+  return draw("\n", forest);
+}
+function drawTree(tree2) {
+  return tree2.value + drawForest(tree2.forest);
+}
+function unfoldTree(b, f) {
+  var _a = f(b), a = _a[0], bs = _a[1];
+  return { value: a, forest: unfoldForest(bs, f) };
+}
+function unfoldForest(bs, f) {
+  return bs.map(function(b) {
+    return unfoldTree(b, f);
+  });
+}
+function unfoldTreeM(M) {
+  var unfoldForestMM = unfoldForestM(M);
+  return function(b, f) {
+    return M.chain(f(b), function(_a) {
+      var a = _a[0], bs = _a[1];
+      return M.map(unfoldForestMM(bs, f), function(ts) {
+        return { value: a, forest: ts };
+      });
+    });
+  };
+}
+function unfoldForestM(M) {
+  var traverseM = Array.traverse(M);
+  return function(bs, f) {
+    return _function.pipe(bs, traverseM(function(b) {
+      return unfoldTreeM(M)(b, f);
+    }));
+  };
+}
+function fold(f) {
+  var go = function(tree2) {
+    return f(tree2.value, tree2.forest.map(go));
+  };
+  return go;
+}
+var _map = function(fa, f) {
+  return _function.pipe(fa, map(f));
+};
+var _ap = function(fab, fa) {
+  return flatMap(fab, function(f) {
+    return _function.pipe(fa, map(f));
+  });
+};
+var _reduce = function(fa, b, f) {
+  return _function.pipe(fa, reduce(b, f));
+};
+var _foldMap = function(M) {
+  var foldMapM = foldMap(M);
+  return function(fa, f) {
+    return _function.pipe(fa, foldMapM(f));
+  };
+};
+var _reduceRight = function(fa, b, f) {
+  return _function.pipe(fa, reduceRight(b, f));
+};
+var _extend = function(wa, f) {
+  return _function.pipe(wa, extend(f));
+};
+var _traverse = function(F) {
+  var traverseF = traverse(F);
+  return function(ta, f) {
+    return _function.pipe(ta, traverseF(f));
+  };
+};
+var ap = function(fa) {
+  return function(fab) {
+    return _ap(fab, fa);
+  };
+};
+var flatMap = /* @__PURE__ */ _function.dual(2, function(ma, f) {
+  var _a = f(ma.value), value = _a.value, forest = _a.forest;
+  var concat = Array.getMonoid().concat;
+  return {
+    value,
+    forest: concat(forest, ma.forest.map(flatMap(f)))
+  };
+});
+var extend = function(f) {
+  return function(wa) {
+    return {
+      value: f(wa),
+      forest: wa.forest.map(extend(f))
+    };
+  };
+};
+var duplicate = /* @__PURE__ */ extend(_function.identity);
+var flatten = /* @__PURE__ */ flatMap(_function.identity);
+var map = function(f) {
+  return function(fa) {
+    return {
+      value: f(fa.value),
+      forest: fa.forest.map(map(f))
+    };
+  };
+};
+var reduce = function(b, f) {
+  return function(fa) {
+    var r = f(b, fa.value);
+    var len = fa.forest.length;
+    for (var i = 0; i < len; i++) {
+      r = _function.pipe(fa.forest[i], reduce(r, f));
+    }
+    return r;
+  };
+};
+var foldMap = function(M) {
+  return function(f) {
+    return reduce(M.empty, function(acc, a) {
+      return M.concat(acc, f(a));
+    });
+  };
+};
+var reduceRight = function(b, f) {
+  return function(fa) {
+    var r = b;
+    var len = fa.forest.length;
+    for (var i = len - 1; i >= 0; i--) {
+      r = _function.pipe(fa.forest[i], reduceRight(r, f));
+    }
+    return f(fa.value, r);
+  };
+};
+var extract = function(wa) {
+  return wa.value;
+};
+var traverse = function(F) {
+  var traverseF = Array.traverse(F);
+  var out = function(f) {
+    return function(ta) {
+      return F.ap(F.map(f(ta.value), function(value) {
+        return function(forest) {
+          return {
+            value,
+            forest
+          };
+        };
+      }), _function.pipe(ta.forest, traverseF(out(f))));
+    };
+  };
+  return out;
+};
+var sequence = function(F) {
+  return traverse(F)(_function.identity);
+};
+var of = function(a) {
+  return make(a);
+};
+var URI = "Tree";
+var Functor = {
+  URI,
+  map: _map
+};
+var flap = /* @__PURE__ */ Functor$1.flap(Functor);
+var Pointed = {
+  URI,
+  of
+};
+var Apply = {
+  URI,
+  map: _map,
+  ap: _ap
+};
+var apFirst = /* @__PURE__ */ Apply$1.apFirst(Apply);
+var apSecond = /* @__PURE__ */ Apply$1.apSecond(Apply);
+var Applicative = {
+  URI,
+  map: _map,
+  ap: _ap,
+  of
+};
+var Chain = {
+  URI,
+  map: _map,
+  ap: _ap,
+  chain: flatMap
+};
+var Monad = {
+  URI,
+  map: _map,
+  ap: _ap,
+  of,
+  chain: flatMap
+};
+var chainFirst = /* @__PURE__ */ Chain$1.chainFirst(Chain);
+var Foldable = {
+  URI,
+  reduce: _reduce,
+  foldMap: _foldMap,
+  reduceRight: _reduceRight
+};
+var Traversable = {
+  URI,
+  map: _map,
+  reduce: _reduce,
+  foldMap: _foldMap,
+  reduceRight: _reduceRight,
+  traverse: _traverse,
+  sequence
+};
+var Comonad = {
+  URI,
+  map: _map,
+  extend: _extend,
+  extract
+};
+var Do = /* @__PURE__ */ of(internal.emptyRecord);
+var bindTo = /* @__PURE__ */ Functor$1.bindTo(Functor);
+var let_ = /* @__PURE__ */ Functor$1.let(Functor);
+var bind = /* @__PURE__ */ Chain$1.bind(Chain);
+var apS = /* @__PURE__ */ Apply$1.apS(Apply);
+function elem(E) {
+  var go = function(a, fa) {
+    return E.equals(a, fa.value) || fa.forest.some(function(tree2) {
+      return go(a, tree2);
+    });
+  };
+  return go;
+}
+var exists = function(predicate) {
+  return function(ma) {
+    return predicate(ma.value) || ma.forest.some(exists(predicate));
+  };
+};
+var chain = flatMap;
+var tree = {
+  URI,
+  map: _map,
+  of,
+  ap: _ap,
+  chain: flatMap,
+  reduce: _reduce,
+  foldMap: _foldMap,
+  reduceRight: _reduceRight,
+  traverse: _traverse,
+  sequence,
+  extract,
+  extend: _extend
+};
+exports.Applicative = Applicative;
+exports.Apply = Apply;
+exports.Chain = Chain;
+exports.Comonad = Comonad;
+exports.Do = Do;
+exports.Foldable = Foldable;
+exports.Functor = Functor;
+exports.Monad = Monad;
+exports.Pointed = Pointed;
+exports.Traversable = Traversable;
+exports.URI = URI;
+exports.ap = ap;
+exports.apFirst = apFirst;
+exports.apS = apS;
+exports.apSecond = apSecond;
+exports.bind = bind;
+exports.bindTo = bindTo;
+exports.chain = chain;
+exports.chainFirst = chainFirst;
+exports.drawForest = drawForest;
+exports.drawTree = drawTree;
+exports.duplicate = duplicate;
+exports.elem = elem;
+exports.exists = exists;
+exports.extend = extend;
+exports.extract = extract;
+exports.flap = flap;
+exports.flatMap = flatMap;
+exports.flatten = flatten;
+exports.fold = fold;
+exports.foldMap = foldMap;
+exports.getEq = getEq;
+exports.getShow = getShow;
+exports.let = let_;
+exports.make = make;
+exports.map = map;
+exports.of = of;
+exports.reduce = reduce;
+exports.reduceRight = reduceRight;
+exports.sequence = sequence;
+exports.traverse = traverse;
+exports.tree = tree;
+exports.unfoldForest = unfoldForest;
+exports.unfoldForestM = unfoldForestM;
+exports.unfoldTree = unfoldTree;
+exports.unfoldTreeM = unfoldTreeM;
+//# sourceMappingURL=Tree.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Tree.cjs","sources":["../../../../../../node_modules/fp-ts/es6/Tree.js"],"sourcesContent":["import { apFirst as apFirst_, apS as apS_, apSecond as apSecond_ } from './Apply';\nimport * as A from './Array';\nimport { bind as bind_, chainFirst as chainFirst_ } from './Chain';\nimport { fromEquals } from './Eq';\nimport { dual, identity, pipe } from './function';\nimport { bindTo as bindTo_, flap as flap_, let as let__ } from './Functor';\nimport * as _ from './internal';\n/**\n * @category constructors\n * @since 2.0.0\n */\nexport function make(value, forest) {\n    if (forest === void 0) { forest = []; }\n    return {\n        value: value,\n        forest: forest\n    };\n}\n/**\n * @category instances\n * @since 2.0.0\n */\nexport function getShow(S) {\n    var show = function (t) {\n        return A.isEmpty(t.forest)\n            ? \"make(\".concat(S.show(t.value), \")\")\n            : \"make(\".concat(S.show(t.value), \", [\").concat(t.forest.map(show).join(', '), \"])\");\n    };\n    return {\n        show: show\n    };\n}\n/**\n * @category instances\n * @since 2.0.0\n */\nexport function getEq(E) {\n    // eslint-disable-next-line prefer-const\n    var SA;\n    var R = fromEquals(function (x, y) { return E.equals(x.value, y.value) && SA.equals(x.forest, y.forest); });\n    SA = A.getEq(R);\n    return R;\n}\nvar draw = function (indentation, forest) {\n    var r = '';\n    var len = forest.length;\n    var tree;\n    for (var i = 0; i < len; i++) {\n        tree = forest[i];\n        var isLast = i === len - 1;\n        r += indentation + (isLast ? '└' : '├') + '─ ' + tree.value;\n        r += draw(indentation + (len > 1 && !isLast ? '│  ' : '   '), tree.forest);\n    }\n    return r;\n};\n/**\n * Neat 2-dimensional drawing of a forest\n *\n * @since 2.0.0\n */\nexport function drawForest(forest) {\n    return draw('\\n', forest);\n}\n/**\n * Neat 2-dimensional drawing of a tree\n *\n * @example\n * import { make, drawTree } from 'fp-ts/Tree'\n *\n * const fa = make('a', [\n *   make('b'),\n *   make('c'),\n *   make('d', [make('e'), make('f')])\n * ])\n *\n * assert.strictEqual(drawTree(fa), `a\n * ├─ b\n * ├─ c\n * └─ d\n *    ├─ e\n *    └─ f`)\n *\n *\n * @since 2.0.0\n */\nexport function drawTree(tree) {\n    return tree.value + drawForest(tree.forest);\n}\n/**\n * Build a (possibly infinite) tree from a seed value in breadth-first order.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport function unfoldTree(b, f) {\n    var _a = f(b), a = _a[0], bs = _a[1];\n    return { value: a, forest: unfoldForest(bs, f) };\n}\n/**\n * Build a (possibly infinite) forest from a list of seed values in breadth-first order.\n *\n * @category constructors\n * @since 2.0.0\n */\nexport function unfoldForest(bs, f) {\n    return bs.map(function (b) { return unfoldTree(b, f); });\n}\nexport function unfoldTreeM(M) {\n    var unfoldForestMM = unfoldForestM(M);\n    return function (b, f) { return M.chain(f(b), function (_a) {\n        var a = _a[0], bs = _a[1];\n        return M.map(unfoldForestMM(bs, f), function (ts) { return ({ value: a, forest: ts }); });\n    }); };\n}\nexport function unfoldForestM(M) {\n    var traverseM = A.traverse(M);\n    return function (bs, f) {\n        return pipe(bs, traverseM(function (b) { return unfoldTreeM(M)(b, f); }));\n    };\n}\n/**\n * Fold a tree into a \"summary\" value in depth-first order.\n *\n * For each node in the tree, apply `f` to the `value` and the result of applying `f` to each `forest`.\n *\n * This is also known as the catamorphism on trees.\n *\n * @example\n * import { fold, make } from 'fp-ts/Tree'\n * import { concatAll } from 'fp-ts/Monoid'\n * import { MonoidSum } from 'fp-ts/number'\n *\n * const t = make(1, [make(2), make(3)])\n *\n * const sum = concatAll(MonoidSum)\n *\n * // Sum the values in a tree:\n * assert.deepStrictEqual(fold((a: number, bs: Array<number>) => a + sum(bs))(t), 6)\n *\n * // Find the maximum value in the tree:\n * assert.deepStrictEqual(fold((a: number, bs: Array<number>) => bs.reduce((b, acc) => Math.max(b, acc), a))(t), 3)\n *\n * // Count the number of leaves in the tree:\n * assert.deepStrictEqual(fold((_: number, bs: Array<number>) => (bs.length === 0 ? 1 : sum(bs)))(t), 2)\n *\n * @category folding\n * @since 2.6.0\n */\nexport function fold(f) {\n    var go = function (tree) { return f(tree.value, tree.forest.map(go)); };\n    return go;\n}\n/* istanbul ignore next */\nvar _map = function (fa, f) { return pipe(fa, map(f)); };\nvar _ap = function (fab, fa) { return flatMap(fab, function (f) { return pipe(fa, map(f)); }); };\n/* istanbul ignore next */\nvar _reduce = function (fa, b, f) { return pipe(fa, reduce(b, f)); };\n/* istanbul ignore next */\nvar _foldMap = function (M) {\n    var foldMapM = foldMap(M);\n    return function (fa, f) { return pipe(fa, foldMapM(f)); };\n};\n/* istanbul ignore next */\nvar _reduceRight = function (fa, b, f) { return pipe(fa, reduceRight(b, f)); };\n/* istanbul ignore next */\nvar _extend = function (wa, f) { return pipe(wa, extend(f)); };\n/* istanbul ignore next */\nvar _traverse = function (F) {\n    var traverseF = traverse(F);\n    return function (ta, f) { return pipe(ta, traverseF(f)); };\n};\n/**\n * @since 2.0.0\n */\nexport var ap = function (fa) { return function (fab) { return _ap(fab, fa); }; };\n/**\n * @category sequencing\n * @since 2.14.0\n */\nexport var flatMap = /*#__PURE__*/ dual(2, function (ma, f) {\n    var _a = f(ma.value), value = _a.value, forest = _a.forest;\n    var concat = A.getMonoid().concat;\n    return {\n        value: value,\n        forest: concat(forest, ma.forest.map(flatMap(f)))\n    };\n});\n/**\n * @since 2.0.0\n */\nexport var extend = function (f) { return function (wa) { return ({\n    value: f(wa),\n    forest: wa.forest.map(extend(f))\n}); }; };\n/**\n * @since 2.0.0\n */\nexport var duplicate = /*#__PURE__*/ extend(identity);\n/**\n * @category sequencing\n * @since 2.0.0\n */\nexport var flatten = /*#__PURE__*/ flatMap(identity);\n/**\n * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types\n * use the type constructor `F` to represent some computational context.\n *\n * @category mapping\n * @since 2.0.0\n */\nexport var map = function (f) { return function (fa) { return ({\n    value: f(fa.value),\n    forest: fa.forest.map(map(f))\n}); }; };\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var reduce = function (b, f) {\n    return function (fa) {\n        var r = f(b, fa.value);\n        var len = fa.forest.length;\n        for (var i = 0; i < len; i++) {\n            r = pipe(fa.forest[i], reduce(r, f));\n        }\n        return r;\n    };\n};\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var foldMap = function (M) { return function (f) {\n    return reduce(M.empty, function (acc, a) { return M.concat(acc, f(a)); });\n}; };\n/**\n * @category folding\n * @since 2.0.0\n */\nexport var reduceRight = function (b, f) {\n    return function (fa) {\n        var r = b;\n        var len = fa.forest.length;\n        for (var i = len - 1; i >= 0; i--) {\n            r = pipe(fa.forest[i], reduceRight(r, f));\n        }\n        return f(fa.value, r);\n    };\n};\n/**\n * @category Extract\n * @since 2.6.2\n */\nexport var extract = function (wa) { return wa.value; };\n/**\n * @category traversing\n * @since 2.6.3\n */\nexport var traverse = function (F) {\n    var traverseF = A.traverse(F);\n    var out = function (f) {\n        return function (ta) {\n            return F.ap(F.map(f(ta.value), function (value) { return function (forest) { return ({\n                value: value,\n                forest: forest\n            }); }; }), pipe(ta.forest, traverseF(out(f))));\n        };\n    };\n    return out;\n};\n/**\n * @category traversing\n * @since 2.6.3\n */\nexport var sequence = function (F) { return traverse(F)(identity); };\n/**\n * @category constructors\n * @since 2.7.0\n */\nexport var of = function (a) { return make(a); };\n/**\n * @category type lambdas\n * @since 2.0.0\n */\nexport var URI = 'Tree';\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Functor = {\n    URI: URI,\n    map: _map\n};\n/**\n * @category mapping\n * @since 2.10.0\n */\nexport var flap = /*#__PURE__*/ flap_(Functor);\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Pointed = {\n    URI: URI,\n    of: of\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Apply = {\n    URI: URI,\n    map: _map,\n    ap: _ap\n};\n/**\n * Combine two effectful actions, keeping only the result of the first.\n *\n * @since 2.0.0\n */\nexport var apFirst = /*#__PURE__*/ apFirst_(Apply);\n/**\n * Combine two effectful actions, keeping only the result of the second.\n *\n * @since 2.0.0\n */\nexport var apSecond = /*#__PURE__*/ apSecond_(Apply);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Applicative = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    of: of\n};\n/**\n * @category instances\n * @since 2.10.0\n */\nexport var Chain = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    chain: flatMap\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Monad = {\n    URI: URI,\n    map: _map,\n    ap: _ap,\n    of: of,\n    chain: flatMap\n};\n/**\n * Composes computations in sequence, using the return value of one computation to determine the next computation and\n * keeping only the result of the first.\n *\n * @since 2.0.0\n */\nexport var chainFirst = /*#__PURE__*/ chainFirst_(Chain);\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Foldable = {\n    URI: URI,\n    reduce: _reduce,\n    foldMap: _foldMap,\n    reduceRight: _reduceRight\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Traversable = {\n    URI: URI,\n    map: _map,\n    reduce: _reduce,\n    foldMap: _foldMap,\n    reduceRight: _reduceRight,\n    traverse: _traverse,\n    sequence: sequence\n};\n/**\n * @category instances\n * @since 2.7.0\n */\nexport var Comonad = {\n    URI: URI,\n    map: _map,\n    extend: _extend,\n    extract: extract\n};\n// -------------------------------------------------------------------------------------\n// do notation\n// -------------------------------------------------------------------------------------\n/**\n * @category do notation\n * @since 2.9.0\n */\nexport var Do = /*#__PURE__*/ of(_.emptyRecord);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bindTo = /*#__PURE__*/ bindTo_(Functor);\nvar let_ = /*#__PURE__*/ let__(Functor);\nexport { \n/**\n * @category do notation\n * @since 2.13.0\n */\nlet_ as let };\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var bind = /*#__PURE__*/ bind_(Chain);\n/**\n * @category do notation\n * @since 2.8.0\n */\nexport var apS = /*#__PURE__*/ apS_(Apply);\n// -------------------------------------------------------------------------------------\n// utils\n// -------------------------------------------------------------------------------------\n/**\n * @since 2.0.0\n */\nexport function elem(E) {\n    var go = function (a, fa) { return E.equals(a, fa.value) || fa.forest.some(function (tree) { return go(a, tree); }); };\n    return go;\n}\n/**\n * @since 2.11.0\n */\nexport var exists = function (predicate) {\n    return function (ma) {\n        return predicate(ma.value) || ma.forest.some(exists(predicate));\n    };\n};\n// -------------------------------------------------------------------------------------\n// legacy\n// -------------------------------------------------------------------------------------\n/**\n * Alias of `flatMap`.\n *\n * @category legacy\n * @since 2.0.0\n */\nexport var chain = flatMap;\n// -------------------------------------------------------------------------------------\n// deprecated\n// -------------------------------------------------------------------------------------\n/**\n * This instance is deprecated, use small, specific instances instead.\n * For example if a function needs a `Functor` instance, pass `T.Functor` instead of `T.tree`\n * (where `T` is from `import T from 'fp-ts/Tree'`)\n *\n * @category zone of death\n * @since 2.0.0\n * @deprecated\n */\nexport var tree = {\n    URI: URI,\n    map: _map,\n    of: of,\n    ap: _ap,\n    chain: flatMap,\n    reduce: _reduce,\n    foldMap: _foldMap,\n    reduceRight: _reduceRight,\n    traverse: _traverse,\n    sequence: sequence,\n    extract: extract,\n    extend: _extend\n};\n"],"names":["A.isEmpty","fromEquals","A.getEq","tree","A.traverse","pipe","dual","A.getMonoid","identity","flap_","apFirst_","apSecond_","chainFirst_","_.emptyRecord","bindTo_","let__","bind_","apS_"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -0,0 +1,336 @@
+import { apFirst as apFirst$1, apSecond as apSecond$1, apS as apS$1 } from "./Apply.js";
+import { traverse as traverse$1, getMonoid, isEmpty, getEq as getEq$1 } from "./Array.js";
+import { chainFirst as chainFirst$1, bind as bind$1 } from "./Chain.js";
+import { fromEquals } from "./Eq.js";
+import { pipe, dual, identity } from "./function.js";
+import { flap as flap$1, bindTo as bindTo$1, let as let_$1 } from "./Functor.js";
+import { emptyRecord } from "./internal.js";
+function make(value, forest) {
+  if (forest === void 0) {
+    forest = [];
+  }
+  return {
+    value,
+    forest
+  };
+}
+function getShow(S) {
+  var show = function(t) {
+    return isEmpty(t.forest) ? "make(".concat(S.show(t.value), ")") : "make(".concat(S.show(t.value), ", [").concat(t.forest.map(show).join(", "), "])");
+  };
+  return {
+    show
+  };
+}
+function getEq(E) {
+  var SA;
+  var R = fromEquals(function(x, y) {
+    return E.equals(x.value, y.value) && SA.equals(x.forest, y.forest);
+  });
+  SA = getEq$1(R);
+  return R;
+}
+var draw = function(indentation, forest) {
+  var r = "";
+  var len = forest.length;
+  var tree2;
+  for (var i = 0; i < len; i++) {
+    tree2 = forest[i];
+    var isLast = i === len - 1;
+    r += indentation + (isLast ? "└" : "├") + "─ " + tree2.value;
+    r += draw(indentation + (len > 1 && !isLast ? "│  " : "   "), tree2.forest);
+  }
+  return r;
+};
+function drawForest(forest) {
+  return draw("\n", forest);
+}
+function drawTree(tree2) {
+  return tree2.value + drawForest(tree2.forest);
+}
+function unfoldTree(b, f) {
+  var _a = f(b), a = _a[0], bs = _a[1];
+  return { value: a, forest: unfoldForest(bs, f) };
+}
+function unfoldForest(bs, f) {
+  return bs.map(function(b) {
+    return unfoldTree(b, f);
+  });
+}
+function unfoldTreeM(M) {
+  var unfoldForestMM = unfoldForestM(M);
+  return function(b, f) {
+    return M.chain(f(b), function(_a) {
+      var a = _a[0], bs = _a[1];
+      return M.map(unfoldForestMM(bs, f), function(ts) {
+        return { value: a, forest: ts };
+      });
+    });
+  };
+}
+function unfoldForestM(M) {
+  var traverseM = traverse$1(M);
+  return function(bs, f) {
+    return pipe(bs, traverseM(function(b) {
+      return unfoldTreeM(M)(b, f);
+    }));
+  };
+}
+function fold(f) {
+  var go = function(tree2) {
+    return f(tree2.value, tree2.forest.map(go));
+  };
+  return go;
+}
+var _map = function(fa, f) {
+  return pipe(fa, map(f));
+};
+var _ap = function(fab, fa) {
+  return flatMap(fab, function(f) {
+    return pipe(fa, map(f));
+  });
+};
+var _reduce = function(fa, b, f) {
+  return pipe(fa, reduce(b, f));
+};
+var _foldMap = function(M) {
+  var foldMapM = foldMap(M);
+  return function(fa, f) {
+    return pipe(fa, foldMapM(f));
+  };
+};
+var _reduceRight = function(fa, b, f) {
+  return pipe(fa, reduceRight(b, f));
+};
+var _extend = function(wa, f) {
+  return pipe(wa, extend(f));
+};
+var _traverse = function(F) {
+  var traverseF = traverse(F);
+  return function(ta, f) {
+    return pipe(ta, traverseF(f));
+  };
+};
+var ap = function(fa) {
+  return function(fab) {
+    return _ap(fab, fa);
+  };
+};
+var flatMap = /* @__PURE__ */ dual(2, function(ma, f) {
+  var _a = f(ma.value), value = _a.value, forest = _a.forest;
+  var concat = getMonoid().concat;
+  return {
+    value,
+    forest: concat(forest, ma.forest.map(flatMap(f)))
+  };
+});
+var extend = function(f) {
+  return function(wa) {
+    return {
+      value: f(wa),
+      forest: wa.forest.map(extend(f))
+    };
+  };
+};
+var duplicate = /* @__PURE__ */ extend(identity);
+var flatten = /* @__PURE__ */ flatMap(identity);
+var map = function(f) {
+  return function(fa) {
+    return {
+      value: f(fa.value),
+      forest: fa.forest.map(map(f))
+    };
+  };
+};
+var reduce = function(b, f) {
+  return function(fa) {
+    var r = f(b, fa.value);
+    var len = fa.forest.length;
+    for (var i = 0; i < len; i++) {
+      r = pipe(fa.forest[i], reduce(r, f));
+    }
+    return r;
+  };
+};
+var foldMap = function(M) {
+  return function(f) {
+    return reduce(M.empty, function(acc, a) {
+      return M.concat(acc, f(a));
+    });
+  };
+};
+var reduceRight = function(b, f) {
+  return function(fa) {
+    var r = b;
+    var len = fa.forest.length;
+    for (var i = len - 1; i >= 0; i--) {
+      r = pipe(fa.forest[i], reduceRight(r, f));
+    }
+    return f(fa.value, r);
+  };
+};
+var extract = function(wa) {
+  return wa.value;
+};
+var traverse = function(F) {
+  var traverseF = traverse$1(F);
+  var out = function(f) {
+    return function(ta) {
+      return F.ap(F.map(f(ta.value), function(value) {
+        return function(forest) {
+          return {
+            value,
+            forest
+          };
+        };
+      }), pipe(ta.forest, traverseF(out(f))));
+    };
+  };
+  return out;
+};
+var sequence = function(F) {
+  return traverse(F)(identity);
+};
+var of = function(a) {
+  return make(a);
+};
+var URI = "Tree";
+var Functor = {
+  URI,
+  map: _map
+};
+var flap = /* @__PURE__ */ flap$1(Functor);
+var Pointed = {
+  URI,
+  of
+};
+var Apply = {
+  URI,
+  map: _map,
+  ap: _ap
+};
+var apFirst = /* @__PURE__ */ apFirst$1(Apply);
+var apSecond = /* @__PURE__ */ apSecond$1(Apply);
+var Applicative = {
+  URI,
+  map: _map,
+  ap: _ap,
+  of
+};
+var Chain = {
+  URI,
+  map: _map,
+  ap: _ap,
+  chain: flatMap
+};
+var Monad = {
+  URI,
+  map: _map,
+  ap: _ap,
+  of,
+  chain: flatMap
+};
+var chainFirst = /* @__PURE__ */ chainFirst$1(Chain);
+var Foldable = {
+  URI,
+  reduce: _reduce,
+  foldMap: _foldMap,
+  reduceRight: _reduceRight
+};
+var Traversable = {
+  URI,
+  map: _map,
+  reduce: _reduce,
+  foldMap: _foldMap,
+  reduceRight: _reduceRight,
+  traverse: _traverse,
+  sequence
+};
+var Comonad = {
+  URI,
+  map: _map,
+  extend: _extend,
+  extract
+};
+var Do = /* @__PURE__ */ of(emptyRecord);
+var bindTo = /* @__PURE__ */ bindTo$1(Functor);
+var let_ = /* @__PURE__ */ let_$1(Functor);
+var bind = /* @__PURE__ */ bind$1(Chain);
+var apS = /* @__PURE__ */ apS$1(Apply);
+function elem(E) {
+  var go = function(a, fa) {
+    return E.equals(a, fa.value) || fa.forest.some(function(tree2) {
+      return go(a, tree2);
+    });
+  };
+  return go;
+}
+var exists = function(predicate) {
+  return function(ma) {
+    return predicate(ma.value) || ma.forest.some(exists(predicate));
+  };
+};
+var chain = flatMap;
+var tree = {
+  URI,
+  map: _map,
+  of,
+  ap: _ap,
+  chain: flatMap,
+  reduce: _reduce,
+  foldMap: _foldMap,
+  reduceRight: _reduceRight,
+  traverse: _traverse,
+  sequence,
+  extract,
+  extend: _extend
+};
+export {
+  Applicative,
+  Apply,
+  Chain,
+  Comonad,
+  Do,
+  Foldable,
+  Functor,
+  Monad,
+  Pointed,
+  Traversable,
+  URI,
+  ap,
+  apFirst,
+  apS,
+  apSecond,
+  bind,
+  bindTo,
+  chain,
+  chainFirst,
+  drawForest,
+  drawTree,
+  duplicate,
+  elem,
+  exists,
+  extend,
+  extract,
+  flap,
+  flatMap,
+  flatten,
+  fold,
+  foldMap,
+  getEq,
+  getShow,
+  let_ as let,
+  make,
+  map,
+  of,
+  reduce,
+  reduceRight,
+  sequence,
+  traverse,
+  tree,
+  unfoldForest,
+  unfoldForestM,
+  unfoldTree,
+  unfoldTreeM
+};
+//# sourceMappingURL=Tree.js.map