vviinn-widgets 2.7.2 → 2.8.0

package/dist/vviinn-widgets/Handler-edcb46f4.js

@@ -0,0 +1,1422 @@
+// -------------------------------------------------------------------------------------
+// instances
+// -------------------------------------------------------------------------------------
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+var getBooleanAlgebra = function (B) { return function () { return ({
+    meet: function (x, y) { return function (a) { return B.meet(x(a), y(a)); }; },
+    join: function (x, y) { return function (a) { return B.join(x(a), y(a)); }; },
+    zero: function () { return B.zero; },
+    one: function () { return B.one; },
+    implies: function (x, y) { return function (a) { return B.implies(x(a), y(a)); }; },
+    not: function (x) { return function (a) { return B.not(x(a)); }; }
+}); }; };
+/**
+ * Unary functions form a semigroup as long as you can provide a semigroup for the codomain.
+ *
+ * @example
+ * import { Predicate, getSemigroup } from 'fp-ts/function'
+ * import * as B from 'fp-ts/boolean'
+ *
+ * const f: Predicate<number> = (n) => n <= 2
+ * const g: Predicate<number> = (n) => n >= 0
+ *
+ * const S1 = getSemigroup(B.SemigroupAll)<number>()
+ *
+ * assert.deepStrictEqual(S1.concat(f, g)(1), true)
+ * assert.deepStrictEqual(S1.concat(f, g)(3), false)
+ *
+ * const S2 = getSemigroup(B.SemigroupAny)<number>()
+ *
+ * assert.deepStrictEqual(S2.concat(f, g)(1), true)
+ * assert.deepStrictEqual(S2.concat(f, g)(3), true)
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+var getSemigroup$2 = function (S) { return function () { return ({
+    concat: function (f, g) { return function (a) { return S.concat(f(a), g(a)); }; }
+}); }; };
+/**
+ * Unary functions form a monoid as long as you can provide a monoid for the codomain.
+ *
+ * @example
+ * import { Predicate } from 'fp-ts/Predicate'
+ * import { getMonoid } from 'fp-ts/function'
+ * import * as B from 'fp-ts/boolean'
+ *
+ * const f: Predicate<number> = (n) => n <= 2
+ * const g: Predicate<number> = (n) => n >= 0
+ *
+ * const M1 = getMonoid(B.MonoidAll)<number>()
+ *
+ * assert.deepStrictEqual(M1.concat(f, g)(1), true)
+ * assert.deepStrictEqual(M1.concat(f, g)(3), false)
+ *
+ * const M2 = getMonoid(B.MonoidAny)<number>()
+ *
+ * assert.deepStrictEqual(M2.concat(f, g)(1), true)
+ * assert.deepStrictEqual(M2.concat(f, g)(3), true)
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+var getMonoid$2 = function (M) {
+    var getSemigroupM = getSemigroup$2(M);
+    return function () { return ({
+        concat: getSemigroupM().concat,
+        empty: function () { return M.empty; }
+    }); };
+};
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+var getSemiring = function (S) { return ({
+    add: function (f, g) { return function (x) { return S.add(f(x), g(x)); }; },
+    zero: function () { return S.zero; },
+    mul: function (f, g) { return function (x) { return S.mul(f(x), g(x)); }; },
+    one: function () { return S.one; }
+}); };
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+var getRing = function (R) {
+    var S = getSemiring(R);
+    return {
+        add: S.add,
+        mul: S.mul,
+        one: S.one,
+        zero: S.zero,
+        sub: function (f, g) { return function (x) { return R.sub(f(x), g(x)); }; }
+    };
+};
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.11.0
+ */
+var apply = function (a) { return function (f) { return f(a); }; };
+/**
+ * @since 2.0.0
+ */
+function identity(a) {
+    return a;
+}
+/**
+ * @since 2.0.0
+ */
+var unsafeCoerce = identity;
+/**
+ * @since 2.0.0
+ */
+function constant$1(a) {
+    return function () { return a; };
+}
+/**
+ * A thunk that returns always `true`.
+ *
+ * @since 2.0.0
+ */
+var constTrue = /*#__PURE__*/ constant$1(true);
+/**
+ * A thunk that returns always `false`.
+ *
+ * @since 2.0.0
+ */
+var constFalse = /*#__PURE__*/ constant$1(false);
+/**
+ * A thunk that returns always `null`.
+ *
+ * @since 2.0.0
+ */
+var constNull = /*#__PURE__*/ constant$1(null);
+/**
+ * A thunk that returns always `undefined`.
+ *
+ * @since 2.0.0
+ */
+var constUndefined = /*#__PURE__*/ constant$1(undefined);
+/**
+ * A thunk that returns always `void`.
+ *
+ * @since 2.0.0
+ */
+var constVoid = constUndefined;
+/**
+ * Flips the order of the arguments of a function of two arguments.
+ *
+ * @since 2.0.0
+ */
+function flip(f) {
+    return function (b, a) { return f(a, b); };
+}
+function flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {
+    switch (arguments.length) {
+        case 1:
+            return ab;
+        case 2:
+            return function () {
+                return bc(ab.apply(this, arguments));
+            };
+        case 3:
+            return function () {
+                return cd(bc(ab.apply(this, arguments)));
+            };
+        case 4:
+            return function () {
+                return de(cd(bc(ab.apply(this, arguments))));
+            };
+        case 5:
+            return function () {
+                return ef(de(cd(bc(ab.apply(this, arguments)))));
+            };
+        case 6:
+            return function () {
+                return fg(ef(de(cd(bc(ab.apply(this, arguments))))));
+            };
+        case 7:
+            return function () {
+                return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));
+            };
+        case 8:
+            return function () {
+                return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));
+            };
+        case 9:
+            return function () {
+                return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));
+            };
+    }
+    return;
+}
+/**
+ * @since 2.0.0
+ */
+function tuple$3() {
+    var t = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        t[_i] = arguments[_i];
+    }
+    return t;
+}
+/**
+ * @since 2.0.0
+ */
+function increment(n) {
+    return n + 1;
+}
+/**
+ * @since 2.0.0
+ */
+function decrement(n) {
+    return n - 1;
+}
+/**
+ * @since 2.0.0
+ */
+function absurd(_) {
+    throw new Error('Called `absurd` function which should be uncallable');
+}
+/**
+ * Creates a tupled version of this function: instead of `n` arguments, it accepts a single tuple argument.
+ *
+ * @example
+ * import { tupled } from 'fp-ts/function'
+ *
+ * const add = tupled((x: number, y: number): number => x + y)
+ *
+ * assert.strictEqual(add([1, 2]), 3)
+ *
+ * @since 2.4.0
+ */
+function tupled(f) {
+    return function (a) { return f.apply(void 0, a); };
+}
+/**
+ * Inverse function of `tupled`
+ *
+ * @since 2.4.0
+ */
+function untupled(f) {
+    return function () {
+        var a = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            a[_i] = arguments[_i];
+        }
+        return f(a);
+    };
+}
+function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
+    switch (arguments.length) {
+        case 1:
+            return a;
+        case 2:
+            return ab(a);
+        case 3:
+            return bc(ab(a));
+        case 4:
+            return cd(bc(ab(a)));
+        case 5:
+            return de(cd(bc(ab(a))));
+        case 6:
+            return ef(de(cd(bc(ab(a)))));
+        case 7:
+            return fg(ef(de(cd(bc(ab(a))))));
+        case 8:
+            return gh(fg(ef(de(cd(bc(ab(a)))))));
+        case 9:
+            return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
+        default: {
+            var ret = arguments[0];
+            for (var i = 1; i < arguments.length; i++) {
+                ret = arguments[i](ret);
+            }
+            return ret;
+        }
+    }
+}
+/**
+ * Type hole simulation
+ *
+ * @since 2.7.0
+ */
+var hole = absurd;
+/**
+ * @since 2.11.0
+ */
+var SK = function (_, b) { return b; };
+/**
+ * Use `Predicate` module instead.
+ *
+ * @since 2.0.0
+ * @deprecated
+ */
+function not(predicate) {
+    return function (a) { return !predicate(a); };
+}
+/**
+ * Use `Endomorphism` module instead.
+ *
+ * @category instances
+ * @since 2.10.0
+ * @deprecated
+ */
+var getEndomorphismMonoid = function () { return ({
+    concat: function (first, second) { return flow(first, second); },
+    empty: identity
+}); };
+
+var __spreadArray = (undefined && undefined.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+// -------------------------------------------------------------------------------------
+// Option
+// -------------------------------------------------------------------------------------
+/** @internal */
+var isNone = function (fa) { return fa._tag === 'None'; };
+/** @internal */
+var isSome = function (fa) { return fa._tag === 'Some'; };
+/** @internal */
+var none = { _tag: 'None' };
+/** @internal */
+var some = function (a) { return ({ _tag: 'Some', value: a }); };
+// -------------------------------------------------------------------------------------
+// Either
+// -------------------------------------------------------------------------------------
+/** @internal */
+var isLeft = function (ma) { return ma._tag === 'Left'; };
+/** @internal */
+var isRight = function (ma) { return ma._tag === 'Right'; };
+/** @internal */
+var left = function (e) { return ({ _tag: 'Left', left: e }); };
+/** @internal */
+var right = function (a) { return ({ _tag: 'Right', right: a }); };
+// -------------------------------------------------------------------------------------
+// ReadonlyNonEmptyArray
+// -------------------------------------------------------------------------------------
+/** @internal */
+var singleton = function (a) { return [a]; };
+/** @internal */
+var isNonEmpty = function (as) { return as.length > 0; };
+/** @internal */
+var head = function (as) { return as[0]; };
+/** @internal */
+var tail = function (as) { return as.slice(1); };
+// -------------------------------------------------------------------------------------
+// empty
+// -------------------------------------------------------------------------------------
+/** @internal */
+var emptyReadonlyArray = [];
+/** @internal */
+var emptyRecord = {};
+// -------------------------------------------------------------------------------------
+// Record
+// -------------------------------------------------------------------------------------
+/** @internal */
+var has = Object.prototype.hasOwnProperty;
+// -------------------------------------------------------------------------------------
+// NonEmptyArray
+// -------------------------------------------------------------------------------------
+/** @internal */
+var fromReadonlyNonEmptyArray = function (as) { return __spreadArray([as[0]], as.slice(1), true); };
+
+/**
+ * A `Magma` is a pair `(A, concat)` in which `A` is a non-empty set and `concat` is a binary operation on `A`
+ *
+ * See [Semigroup](https://gcanti.github.io/fp-ts/modules/Semigroup.ts.html) for some instances.
+ *
+ * @since 2.0.0
+ */
+// -------------------------------------------------------------------------------------
+// combinators
+// -------------------------------------------------------------------------------------
+/**
+ * The dual of a `Magma`, obtained by swapping the arguments of `concat`.
+ *
+ * @example
+ * import { reverse, concatAll } from 'fp-ts/Magma'
+ * import * as N from 'fp-ts/number'
+ *
+ * const subAll = concatAll(reverse(N.MagmaSub))(0)
+ *
+ * assert.deepStrictEqual(subAll([1, 2, 3]), 2)
+ *
+ * @category combinators
+ * @since 2.11.0
+ */
+var reverse$2 = function (M) { return ({
+    concat: function (first, second) { return M.concat(second, first); }
+}); };
+/**
+ * @category combinators
+ * @since 2.11.0
+ */
+var filterFirst = function (predicate) { return function (M) { return ({
+    concat: function (first, second) { return (predicate(first) ? M.concat(first, second) : second); }
+}); }; };
+/**
+ * @category combinators
+ * @since 2.11.0
+ */
+var filterSecond = function (predicate) { return function (M) { return ({
+    concat: function (first, second) { return (predicate(second) ? M.concat(first, second) : first); }
+}); }; };
+/**
+ * @category combinators
+ * @since 2.11.0
+ */
+var endo = function (f) { return function (M) { return ({
+    concat: function (first, second) { return M.concat(f(first), f(second)); }
+}); }; };
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+/**
+ * Given a sequence of `as`, concat them and return the total.
+ *
+ * If `as` is empty, return the provided `startWith` value.
+ *
+ * @example
+ * import { concatAll } from 'fp-ts/Magma'
+ * import * as N from 'fp-ts/number'
+ *
+ * const subAll = concatAll(N.MagmaSub)(0)
+ *
+ * assert.deepStrictEqual(subAll([1, 2, 3]), -6)
+ *
+ * @since 2.11.0
+ */
+var concatAll$1 = function (M) { return function (startWith) { return function (as) {
+    return as.reduce(function (a, acc) { return M.concat(a, acc); }, startWith);
+}; }; };
+
+// -------------------------------------------------------------------------------------
+// constructors
+// -------------------------------------------------------------------------------------
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+var fromEquals = function (equals) { return ({
+    equals: function (x, y) { return x === y || equals(x, y); }
+}); };
+// -------------------------------------------------------------------------------------
+// combinators
+// -------------------------------------------------------------------------------------
+/**
+ * @category combinators
+ * @since 2.10.0
+ */
+var struct$1 = function (eqs) {
+    return fromEquals(function (first, second) {
+        for (var key in eqs) {
+            if (!eqs[key].equals(first[key], second[key])) {
+                return false;
+            }
+        }
+        return true;
+    });
+};
+/**
+ * Given a tuple of `Eq`s returns a `Eq` for the tuple
+ *
+ * @example
+ * import { tuple } from 'fp-ts/Eq'
+ * import * as S from 'fp-ts/string'
+ * import * as N from 'fp-ts/number'
+ * import * as B from 'fp-ts/boolean'
+ *
+ * const E = tuple(S.Eq, N.Eq, B.Eq)
+ * assert.strictEqual(E.equals(['a', 1, true], ['a', 1, true]), true)
+ * assert.strictEqual(E.equals(['a', 1, true], ['b', 1, true]), false)
+ * assert.strictEqual(E.equals(['a', 1, true], ['a', 2, true]), false)
+ * assert.strictEqual(E.equals(['a', 1, true], ['a', 1, false]), false)
+ *
+ * @category combinators
+ * @since 2.10.0
+ */
+var tuple$2 = function () {
+    var eqs = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        eqs[_i] = arguments[_i];
+    }
+    return fromEquals(function (first, second) { return eqs.every(function (E, i) { return E.equals(first[i], second[i]); }); });
+};
+// -------------------------------------------------------------------------------------
+// non-pipeables
+// -------------------------------------------------------------------------------------
+/* istanbul ignore next */
+var contramap_$1 = function (fa, f) { return pipe(fa, contramap$1(f)); };
+// -------------------------------------------------------------------------------------
+// type class members
+// -------------------------------------------------------------------------------------
+/**
+ * @category Contravariant
+ * @since 2.0.0
+ */
+var contramap$1 = function (f) { return function (fa) {
+    return fromEquals(function (x, y) { return fa.equals(f(x), f(y)); });
+}; };
+// -------------------------------------------------------------------------------------
+// instances
+// -------------------------------------------------------------------------------------
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+var URI$1 = 'Eq';
+/**
+ * @category instances
+ * @since 2.5.0
+ */
+var eqStrict = {
+    equals: function (a, b) { return a === b; }
+};
+var empty = {
+    equals: function () { return true; }
+};
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+var getSemigroup$1 = function () { return ({
+    concat: function (x, y) { return fromEquals(function (a, b) { return x.equals(a, b) && y.equals(a, b); }); }
+}); };
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+var getMonoid$1 = function () { return ({
+    concat: getSemigroup$1().concat,
+    empty: empty
+}); };
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+var Contravariant$1 = {
+    URI: URI$1,
+    contramap: contramap_$1
+};
+// -------------------------------------------------------------------------------------
+// deprecated
+// -------------------------------------------------------------------------------------
+/**
+ * Use [`tuple`](#tuple) instead.
+ *
+ * @category combinators
+ * @since 2.0.0
+ * @deprecated
+ */
+var getTupleEq = tuple$2;
+/**
+ * Use [`struct`](#struct) instead.
+ *
+ * @category combinators
+ * @since 2.0.0
+ * @deprecated
+ */
+var getStructEq = struct$1;
+/**
+ * Use [`eqStrict`](#eqstrict) instead
+ *
+ * @since 2.0.0
+ * @deprecated
+ */
+var strictEqual = eqStrict.equals;
+/**
+ * This instance is deprecated, use small, specific instances instead.
+ * For example if a function needs a `Contravariant` instance, pass `E.Contravariant` instead of `E.eq`
+ * (where `E` is from `import E from 'fp-ts/Eq'`)
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var eq = Contravariant$1;
+/**
+ * Use [`Eq`](./boolean.ts.html#eq) instead.
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var eqBoolean = eqStrict;
+/**
+ * Use [`Eq`](./string.ts.html#eq) instead.
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var eqString = eqStrict;
+/**
+ * Use [`Eq`](./number.ts.html#eq) instead.
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var eqNumber = eqStrict;
+/**
+ * Use [`Eq`](./Date.ts.html#eq) instead.
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var eqDate = {
+    equals: function (first, second) { return first.valueOf() === second.valueOf(); }
+};
+
+// -------------------------------------------------------------------------------------
+// defaults
+// -------------------------------------------------------------------------------------
+/**
+ * @category defaults
+ * @since 2.10.0
+ */
+var equalsDefault = function (compare) { return function (first, second) {
+    return first === second || compare(first, second) === 0;
+}; };
+// -------------------------------------------------------------------------------------
+// constructors
+// -------------------------------------------------------------------------------------
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+var fromCompare = function (compare) { return ({
+    equals: equalsDefault(compare),
+    compare: function (first, second) { return (first === second ? 0 : compare(first, second)); }
+}); };
+// -------------------------------------------------------------------------------------
+// combinators
+// -------------------------------------------------------------------------------------
+/**
+ * Given a tuple of `Ord`s returns an `Ord` for the tuple.
+ *
+ * @example
+ * import { tuple } from 'fp-ts/Ord'
+ * import * as B from 'fp-ts/boolean'
+ * import * as S from 'fp-ts/string'
+ * import * as N from 'fp-ts/number'
+ *
+ * const O = tuple(S.Ord, N.Ord, B.Ord)
+ * assert.strictEqual(O.compare(['a', 1, true], ['b', 2, true]), -1)
+ * assert.strictEqual(O.compare(['a', 1, true], ['a', 2, true]), -1)
+ * assert.strictEqual(O.compare(['a', 1, true], ['a', 1, false]), 1)
+ *
+ * @category combinators
+ * @since 2.10.0
+ */
+var tuple$1 = function () {
+    var ords = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        ords[_i] = arguments[_i];
+    }
+    return fromCompare(function (first, second) {
+        var i = 0;
+        for (; i < ords.length - 1; i++) {
+            var r = ords[i].compare(first[i], second[i]);
+            if (r !== 0) {
+                return r;
+            }
+        }
+        return ords[i].compare(first[i], second[i]);
+    });
+};
+/**
+ * @category combinators
+ * @since 2.10.0
+ */
+var reverse$1 = function (O) { return fromCompare(function (first, second) { return O.compare(second, first); }); };
+// -------------------------------------------------------------------------------------
+// non-pipeables
+// -------------------------------------------------------------------------------------
+/* istanbul ignore next */
+var contramap_ = function (fa, f) { return pipe(fa, contramap(f)); };
+// -------------------------------------------------------------------------------------
+// type class members
+// -------------------------------------------------------------------------------------
+/**
+ * @category Contravariant
+ * @since 2.0.0
+ */
+var contramap = function (f) { return function (fa) {
+    return fromCompare(function (first, second) { return fa.compare(f(first), f(second)); });
+}; };
+// -------------------------------------------------------------------------------------
+// instances
+// -------------------------------------------------------------------------------------
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+var URI = 'Ord';
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+var getSemigroup = function () { return ({
+    concat: function (first, second) {
+        return fromCompare(function (a, b) {
+            var ox = first.compare(a, b);
+            return ox !== 0 ? ox : second.compare(a, b);
+        });
+    }
+}); };
+/**
+ * Returns a `Monoid` such that:
+ *
+ * - its `concat(ord1, ord2)` operation will order first by `ord1`, and then by `ord2`
+ * - its `empty` value is an `Ord` that always considers compared elements equal
+ *
+ * @example
+ * import { sort } from 'fp-ts/Array'
+ * import { contramap, reverse, getMonoid } from 'fp-ts/Ord'
+ * import * as S from 'fp-ts/string'
+ * import * as B from 'fp-ts/boolean'
+ * import { pipe } from 'fp-ts/function'
+ * import { concatAll } from 'fp-ts/Monoid'
+ * import * as N from 'fp-ts/number'
+ *
+ * interface User {
+ *   readonly id: number
+ *   readonly name: string
+ *   readonly age: number
+ *   readonly rememberMe: boolean
+ * }
+ *
+ * const byName = pipe(
+ *   S.Ord,
+ *   contramap((p: User) => p.name)
+ * )
+ *
+ * const byAge = pipe(
+ *   N.Ord,
+ *   contramap((p: User) => p.age)
+ * )
+ *
+ * const byRememberMe = pipe(
+ *   B.Ord,
+ *   contramap((p: User) => p.rememberMe)
+ * )
+ *
+ * const M = getMonoid<User>()
+ *
+ * const users: Array<User> = [
+ *   { id: 1, name: 'Guido', age: 47, rememberMe: false },
+ *   { id: 2, name: 'Guido', age: 46, rememberMe: true },
+ *   { id: 3, name: 'Giulio', age: 44, rememberMe: false },
+ *   { id: 4, name: 'Giulio', age: 44, rememberMe: true }
+ * ]
+ *
+ * // sort by name, then by age, then by `rememberMe`
+ * const O1 = concatAll(M)([byName, byAge, byRememberMe])
+ * assert.deepStrictEqual(sort(O1)(users), [
+ *   { id: 3, name: 'Giulio', age: 44, rememberMe: false },
+ *   { id: 4, name: 'Giulio', age: 44, rememberMe: true },
+ *   { id: 2, name: 'Guido', age: 46, rememberMe: true },
+ *   { id: 1, name: 'Guido', age: 47, rememberMe: false }
+ * ])
+ *
+ * // now `rememberMe = true` first, then by name, then by age
+ * const O2 = concatAll(M)([reverse(byRememberMe), byName, byAge])
+ * assert.deepStrictEqual(sort(O2)(users), [
+ *   { id: 4, name: 'Giulio', age: 44, rememberMe: true },
+ *   { id: 2, name: 'Guido', age: 46, rememberMe: true },
+ *   { id: 3, name: 'Giulio', age: 44, rememberMe: false },
+ *   { id: 1, name: 'Guido', age: 47, rememberMe: false }
+ * ])
+ *
+ * @category instances
+ * @since 2.4.0
+ */
+var getMonoid = function () { return ({
+    concat: getSemigroup().concat,
+    empty: fromCompare(function () { return 0; })
+}); };
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+var Contravariant = {
+    URI: URI,
+    contramap: contramap_
+};
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.11.0
+ */
+var trivial = {
+    equals: constTrue,
+    compare: /*#__PURE__*/ constant$1(0)
+};
+/**
+ * @since 2.11.0
+ */
+var equals = function (O) { return function (second) { return function (first) {
+    return first === second || O.compare(first, second) === 0;
+}; }; };
+// TODO: curry in v3
+/**
+ * Test whether one value is _strictly less than_ another
+ *
+ * @since 2.0.0
+ */
+var lt = function (O) { return function (first, second) { return O.compare(first, second) === -1; }; };
+// TODO: curry in v3
+/**
+ * Test whether one value is _strictly greater than_ another
+ *
+ * @since 2.0.0
+ */
+var gt = function (O) { return function (first, second) { return O.compare(first, second) === 1; }; };
+// TODO: curry in v3
+/**
+ * Test whether one value is _non-strictly less than_ another
+ *
+ * @since 2.0.0
+ */
+var leq = function (O) { return function (first, second) { return O.compare(first, second) !== 1; }; };
+// TODO: curry in v3
+/**
+ * Test whether one value is _non-strictly greater than_ another
+ *
+ * @since 2.0.0
+ */
+var geq = function (O) { return function (first, second) { return O.compare(first, second) !== -1; }; };
+// TODO: curry in v3
+/**
+ * Take the minimum of two values. If they are considered equal, the first argument is chosen
+ *
+ * @since 2.0.0
+ */
+var min$1 = function (O) { return function (first, second) {
+    return first === second || O.compare(first, second) < 1 ? first : second;
+}; };
+// TODO: curry in v3
+/**
+ * Take the maximum of two values. If they are considered equal, the first argument is chosen
+ *
+ * @since 2.0.0
+ */
+var max$1 = function (O) { return function (first, second) {
+    return first === second || O.compare(first, second) > -1 ? first : second;
+}; };
+/**
+ * Clamp a value between a minimum and a maximum
+ *
+ * @since 2.0.0
+ */
+var clamp = function (O) {
+    var minO = min$1(O);
+    var maxO = max$1(O);
+    return function (low, hi) { return function (a) { return maxO(minO(a, hi), low); }; };
+};
+/**
+ * Test whether a value is between a minimum and a maximum (inclusive)
+ *
+ * @since 2.0.0
+ */
+var between = function (O) {
+    var ltO = lt(O);
+    var gtO = gt(O);
+    return function (low, hi) { return function (a) { return (ltO(a, low) || gtO(a, hi) ? false : true); }; };
+};
+// -------------------------------------------------------------------------------------
+// deprecated
+// -------------------------------------------------------------------------------------
+/**
+ * Use [`tuple`](#tuple) instead.
+ *
+ * @category combinators
+ * @since 2.0.0
+ * @deprecated
+ */
+var getTupleOrd = tuple$1;
+/**
+ * Use [`reverse`](#reverse) instead.
+ *
+ * @category combinators
+ * @since 2.0.0
+ * @deprecated
+ */
+var getDualOrd = reverse$1;
+/**
+ * Use [`Contravariant`](#contravariant) instead.
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var ord = Contravariant;
+// default compare for primitive types
+function compare(first, second) {
+    return first < second ? -1 : first > second ? 1 : 0;
+}
+var strictOrd = {
+    equals: eqStrict.equals,
+    compare: compare
+};
+/**
+ * Use [`Ord`](./boolean.ts.html#ord) instead.
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var ordBoolean = strictOrd;
+/**
+ * Use [`Ord`](./string.ts.html#ord) instead.
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var ordString = strictOrd;
+/**
+ * Use [`Ord`](./number.ts.html#ord) instead.
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var ordNumber = strictOrd;
+/**
+ * Use [`Ord`](./Date.ts.html#ord) instead.
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var ordDate = /*#__PURE__*/ pipe(ordNumber, 
+/*#__PURE__*/
+contramap(function (date) { return date.valueOf(); }));
+
+/**
+ * If a type `A` can form a `Semigroup` it has an **associative** binary operation.
+ *
+ * ```ts
+ * interface Semigroup<A> {
+ *   readonly concat: (x: A, y: A) => A
+ * }
+ * ```
+ *
+ * Associativity means the following equality must hold for any choice of `x`, `y`, and `z`.
+ *
+ * ```ts
+ * concat(x, concat(y, z)) = concat(concat(x, y), z)
+ * ```
+ *
+ * A common example of a semigroup is the type `string` with the operation `+`.
+ *
+ * ```ts
+ * import { Semigroup } from 'fp-ts/Semigroup'
+ *
+ * const semigroupString: Semigroup<string> = {
+ *   concat: (x, y) => x + y
+ * }
+ *
+ * const x = 'x'
+ * const y = 'y'
+ * const z = 'z'
+ *
+ * semigroupString.concat(x, y) // 'xy'
+ *
+ * semigroupString.concat(x, semigroupString.concat(y, z)) // 'xyz'
+ *
+ * semigroupString.concat(semigroupString.concat(x, y), z) // 'xyz'
+ * ```
+ *
+ * *Adapted from https://typelevel.org/cats*
+ *
+ * @since 2.0.0
+ */
+// -------------------------------------------------------------------------------------
+// constructors
+// -------------------------------------------------------------------------------------
+/**
+ * Get a semigroup where `concat` will return the minimum, based on the provided order.
+ *
+ * @example
+ * import * as N from 'fp-ts/number'
+ * import * as S from 'fp-ts/Semigroup'
+ *
+ * const S1 = S.min(N.Ord)
+ *
+ * assert.deepStrictEqual(S1.concat(1, 2), 1)
+ *
+ * @category constructors
+ * @since 2.10.0
+ */
+var min = function (O) { return ({
+    concat: min$1(O)
+}); };
+/**
+ * Get a semigroup where `concat` will return the maximum, based on the provided order.
+ *
+ * @example
+ * import * as N from 'fp-ts/number'
+ * import * as S from 'fp-ts/Semigroup'
+ *
+ * const S1 = S.max(N.Ord)
+ *
+ * assert.deepStrictEqual(S1.concat(1, 2), 2)
+ *
+ * @category constructors
+ * @since 2.10.0
+ */
+var max = function (O) { return ({
+    concat: max$1(O)
+}); };
+/**
+ * @category constructors
+ * @since 2.10.0
+ */
+var constant = function (a) { return ({
+    concat: function () { return a; }
+}); };
+// -------------------------------------------------------------------------------------
+// combinators
+// -------------------------------------------------------------------------------------
+/**
+ * The dual of a `Semigroup`, obtained by swapping the arguments of `concat`.
+ *
+ * @example
+ * import { reverse } from 'fp-ts/Semigroup'
+ * import * as S from 'fp-ts/string'
+ *
+ * assert.deepStrictEqual(reverse(S.Semigroup).concat('a', 'b'), 'ba')
+ *
+ * @category combinators
+ * @since 2.10.0
+ */
+var reverse = reverse$2;
+/**
+ * Given a struct of semigroups returns a semigroup for the struct.
+ *
+ * @example
+ * import { struct } from 'fp-ts/Semigroup'
+ * import * as N from 'fp-ts/number'
+ *
+ * interface Point {
+ *   readonly x: number
+ *   readonly y: number
+ * }
+ *
+ * const S = struct<Point>({
+ *   x: N.SemigroupSum,
+ *   y: N.SemigroupSum
+ * })
+ *
+ * assert.deepStrictEqual(S.concat({ x: 1, y: 2 }, { x: 3, y: 4 }), { x: 4, y: 6 })
+ *
+ * @category combinators
+ * @since 2.10.0
+ */
+var struct = function (semigroups) { return ({
+    concat: function (first, second) {
+        var r = {};
+        for (var k in semigroups) {
+            if (has.call(semigroups, k)) {
+                r[k] = semigroups[k].concat(first[k], second[k]);
+            }
+        }
+        return r;
+    }
+}); };
+/**
+ * Given a tuple of semigroups returns a semigroup for the tuple.
+ *
+ * @example
+ * import { tuple } from 'fp-ts/Semigroup'
+ * import * as B from 'fp-ts/boolean'
+ * import * as N from 'fp-ts/number'
+ * import * as S from 'fp-ts/string'
+ *
+ * const S1 = tuple(S.Semigroup, N.SemigroupSum)
+ * assert.deepStrictEqual(S1.concat(['a', 1], ['b', 2]), ['ab', 3])
+ *
+ * const S2 = tuple(S.Semigroup, N.SemigroupSum, B.SemigroupAll)
+ * assert.deepStrictEqual(S2.concat(['a', 1, true], ['b', 2, false]), ['ab', 3, false])
+ *
+ * @category combinators
+ * @since 2.10.0
+ */
+var tuple = function () {
+    var semigroups = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        semigroups[_i] = arguments[_i];
+    }
+    return ({
+        concat: function (first, second) { return semigroups.map(function (s, i) { return s.concat(first[i], second[i]); }); }
+    });
+};
+/**
+ * Between each pair of elements insert `middle`.
+ *
+ * @example
+ * import { intercalate } from 'fp-ts/Semigroup'
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * const S1 = pipe(S.Semigroup, intercalate(' + '))
+ *
+ * assert.strictEqual(S1.concat('a', 'b'), 'a + b')
+ *
+ * @category combinators
+ * @since 2.10.0
+ */
+var intercalate = function (middle) { return function (S) { return ({
+    concat: function (x, y) { return S.concat(x, S.concat(middle, y)); }
+}); }; };
+// -------------------------------------------------------------------------------------
+// instances
+// -------------------------------------------------------------------------------------
+/**
+ * Always return the first argument.
+ *
+ * @example
+ * import * as S from 'fp-ts/Semigroup'
+ *
+ * assert.deepStrictEqual(S.first<number>().concat(1, 2), 1)
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+var first = function () { return ({ concat: identity }); };
+/**
+ * Always return the last argument.
+ *
+ * @example
+ * import * as S from 'fp-ts/Semigroup'
+ *
+ * assert.deepStrictEqual(S.last<number>().concat(1, 2), 2)
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+var last = function () { return ({ concat: function (_, y) { return y; } }); };
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+/**
+ * Given a sequence of `as`, concat them and return the total.
+ *
+ * If `as` is empty, return the provided `startWith` value.
+ *
+ * @example
+ * import { concatAll } from 'fp-ts/Semigroup'
+ * import * as N from 'fp-ts/number'
+ *
+ * const sum = concatAll(N.SemigroupSum)(0)
+ *
+ * assert.deepStrictEqual(sum([1, 2, 3]), 6)
+ * assert.deepStrictEqual(sum([]), 0)
+ *
+ * @since 2.10.0
+ */
+var concatAll = concatAll$1;
+// -------------------------------------------------------------------------------------
+// deprecated
+// -------------------------------------------------------------------------------------
+/**
+ * Use `void` module instead.
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var semigroupVoid = constant(undefined);
+/**
+ * Use [`getAssignSemigroup`](./struct.ts.html#getAssignSemigroup) instead.
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var getObjectSemigroup = function () { return ({
+    concat: function (first, second) { return Object.assign({}, first, second); }
+}); };
+/**
+ * Use [`last`](#last) instead.
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var getLastSemigroup = last;
+/**
+ * Use [`first`](#first) instead.
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var getFirstSemigroup = first;
+/**
+ * Use [`tuple`](#tuple) instead.
+ *
+ * @category combinators
+ * @since 2.0.0
+ * @deprecated
+ */
+var getTupleSemigroup = tuple;
+/**
+ * Use [`struct`](#struct) instead.
+ *
+ * @category combinators
+ * @since 2.0.0
+ * @deprecated
+ */
+var getStructSemigroup = struct;
+/**
+ * Use [`reverse`](#reverse) instead.
+ *
+ * @category combinators
+ * @since 2.0.0
+ * @deprecated
+ */
+var getDualSemigroup = reverse;
+/**
+ * Use [`max`](#max) instead.
+ *
+ * @category constructors
+ * @since 2.0.0
+ * @deprecated
+ */
+var getJoinSemigroup = max;
+/**
+ * Use [`min`](#min) instead.
+ *
+ * @category constructors
+ * @since 2.0.0
+ * @deprecated
+ */
+var getMeetSemigroup = min;
+/**
+ * Use [`intercalate`](#intercalate) instead.
+ *
+ * @category combinators
+ * @since 2.5.0
+ * @deprecated
+ */
+var getIntercalateSemigroup = intercalate;
+function fold(S) {
+    var concatAllS = concatAll(S);
+    return function (startWith, as) { return (as === undefined ? concatAllS(startWith) : concatAllS(startWith)(as)); };
+}
+/**
+ * Use [`SemigroupAll`](./boolean.ts.html#SemigroupAll) instead.
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var semigroupAll = {
+    concat: function (x, y) { return x && y; }
+};
+/**
+ * Use [`SemigroupAny`](./boolean.ts.html#SemigroupAny) instead.
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var semigroupAny = {
+    concat: function (x, y) { return x || y; }
+};
+/**
+ * Use [`getSemigroup`](./function.ts.html#getSemigroup) instead.
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var getFunctionSemigroup = getSemigroup$2;
+/**
+ * Use [`Semigroup`](./string.ts.html#Semigroup) instead.
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var semigroupString = {
+    concat: function (x, y) { return x + y; }
+};
+/**
+ * Use [`SemigroupSum`](./number.ts.html#SemigroupSum) instead.
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var semigroupSum = {
+    concat: function (x, y) { return x + y; }
+};
+/**
+ * Use [`SemigroupProduct`](./number.ts.html#SemigroupProduct) instead.
+ *
+ * @category instances
+ * @since 2.0.0
+ * @deprecated
+ */
+var semigroupProduct = {
+    concat: function (x, y) { return x * y; }
+};
+
+const semigroupDiff = {
+  concat: (x, y) => x - y,
+};
+const semigroupDiv = {
+  concat: (x, y) => x / y,
+};
+
+const fromRectangle$1 = ({ x, y }) => {
+  return {
+    x,
+    y,
+  };
+};
+const fromMouseEvent = ({ clientX, clientY }) => {
+  return {
+    x: clientX,
+    y: clientY,
+  };
+};
+const fromTouchEvent = ({ touches }) => {
+  return {
+    x: touches[0].clientX,
+    y: touches[0].clientY,
+  };
+};
+const pointDiffSemigroup = struct({
+  x: semigroupDiff,
+  y: semigroupDiff,
+});
+const pointSumSemigroup = struct({
+  x: semigroupSum,
+  y: semigroupSum,
+});
+const pointProductSemigroup = struct({
+  x: semigroupProduct,
+  y: semigroupProduct,
+});
+
+var HandlerDirection;
+(function (HandlerDirection) {
+  HandlerDirection[HandlerDirection["East"] = 0] = "East";
+  HandlerDirection[HandlerDirection["North"] = 1] = "North";
+  HandlerDirection[HandlerDirection["NorthEast"] = 2] = "NorthEast";
+  HandlerDirection[HandlerDirection["NorthWest"] = 3] = "NorthWest";
+  HandlerDirection[HandlerDirection["South"] = 4] = "South";
+  HandlerDirection[HandlerDirection["SouthEast"] = 5] = "SouthEast";
+  HandlerDirection[HandlerDirection["SouthWest"] = 6] = "SouthWest";
+  HandlerDirection[HandlerDirection["West"] = 7] = "West";
+})(HandlerDirection || (HandlerDirection = {}));
+const getCursorValue = (direction) => {
+  switch (direction) {
+    case HandlerDirection.East:
+      return "e-resize";
+    case HandlerDirection.North:
+      return "n-resize";
+    case HandlerDirection.NorthEast:
+      return "ne-resize";
+    case HandlerDirection.NorthWest:
+      return "nw-resize";
+    case HandlerDirection.South:
+      return "s-resize";
+    case HandlerDirection.SouthEast:
+      return "se-resize";
+    case HandlerDirection.SouthWest:
+      return "sw-resize";
+    case HandlerDirection.West:
+      return "w-resize";
+    default:
+      return "pointer";
+  }
+};
+const fromRectangle = (r) => [
+  {
+    position: fromRectangle$1(r),
+    direction: HandlerDirection.NorthWest,
+  },
+  {
+    position: pointSumSemigroup.concat(fromRectangle$1(r), {
+      x: r.width,
+      y: 0,
+    }),
+    direction: HandlerDirection.NorthEast,
+  },
+  {
+    position: pointSumSemigroup.concat(fromRectangle$1(r), {
+      x: 0,
+      y: r.height,
+    }),
+    direction: HandlerDirection.SouthWest,
+  },
+  {
+    position: pointSumSemigroup.concat(fromRectangle$1(r), {
+      x: r.width,
+      y: r.height,
+    }),
+    direction: HandlerDirection.SouthEast,
+  },
+];
+
+export { getMonoid as A, fromEquals as B, min as C, max as D, struct as E, getStructSemigroup as F, semigroupDiv as G, contramap as H, ordNumber as I, fromRectangle$1 as J, pointSumSemigroup as K, HandlerDirection as L, pointProductSemigroup as M, fromCompare as N, fromRectangle as O, fromMouseEvent as P, pointDiffSemigroup as Q, getCursorValue as R, SK as S, identity as a, isLeft as b, isRight as c, emptyReadonlyArray as d, emptyRecord as e, flow as f, head as g, has as h, isNone as i, isNonEmpty as j, constFalse as k, left as l, constTrue as m, none as n, isSome as o, pipe as p, constNull as q, right as r, some as s, tuple$3 as t, constUndefined as u, first as v, last as w, tail as x, singleton as y, fromReadonlyNonEmptyArray as z };