@bifravst/aws-cdk-lambda-helpers 5.0.0 → 5.0.1

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/es6/Semigroup.js

@@ -0,0 +1,373 @@
+/**
+ * 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
+ */
+import { getSemigroup, identity } from './function';
+import * as _ from './internal';
+import * as M from './Magma';
+import * as Or from './Ord';
+// -------------------------------------------------------------------------------------
+// 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
+ */
+export var min = function (O) { return ({
+    concat: Or.min(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
+ */
+export var max = function (O) { return ({
+    concat: Or.max(O)
+}); };
+/**
+ * @category constructors
+ * @since 2.10.0
+ */
+export 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')
+ *
+ * @since 2.10.0
+ */
+export var reverse = M.reverse;
+/**
+ * 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 })
+ *
+ * @since 2.10.0
+ */
+export 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])
+ *
+ * @since 2.10.0
+ */
+export 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')
+ *
+ * @since 2.10.0
+ */
+export 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
+ */
+export 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
+ */
+export 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
+ */
+export var concatAll = M.concatAll;
+// -------------------------------------------------------------------------------------
+// deprecated
+// -------------------------------------------------------------------------------------
+/**
+ * Use `void` module instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var semigroupVoid = constant(undefined);
+/**
+ * Use [`getAssignSemigroup`](./struct.ts.html#getAssignSemigroup) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var getObjectSemigroup = function () { return ({
+    concat: function (first, second) { return Object.assign({}, first, second); }
+}); };
+/**
+ * Use [`last`](#last) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var getLastSemigroup = last;
+/**
+ * Use [`first`](#first) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var getFirstSemigroup = first;
+/**
+ * Use [`tuple`](#tuple) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var getTupleSemigroup = tuple;
+/**
+ * Use [`struct`](#struct) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var getStructSemigroup = struct;
+/**
+ * Use [`reverse`](#reverse) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var getDualSemigroup = reverse;
+/**
+ * Use [`max`](#max) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var getJoinSemigroup = max;
+/**
+ * Use [`min`](#min) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var getMeetSemigroup = min;
+/**
+ * Use [`intercalate`](#intercalate) instead.
+ *
+ * @category zone of death
+ * @since 2.5.0
+ * @deprecated
+ */
+export var getIntercalateSemigroup = intercalate;
+export 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 zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var semigroupAll = {
+    concat: function (x, y) { return x && y; }
+};
+/**
+ * Use [`SemigroupAny`](./boolean.ts.html#SemigroupAny) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var semigroupAny = {
+    concat: function (x, y) { return x || y; }
+};
+/**
+ * Use [`getSemigroup`](./function.ts.html#getSemigroup) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var getFunctionSemigroup = getSemigroup;
+/**
+ * Use [`Semigroup`](./string.ts.html#Semigroup) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var semigroupString = {
+    concat: function (x, y) { return x + y; }
+};
+/**
+ * Use [`SemigroupSum`](./number.ts.html#SemigroupSum) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var semigroupSum = {
+    concat: function (x, y) { return x + y; }
+};
+/**
+ * Use [`SemigroupProduct`](./number.ts.html#SemigroupProduct) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var semigroupProduct = {
+    concat: function (x, y) { return x * y; }
+};

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/es6/Semigroupoid.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @since 2.0.0
+ */
+import { HKT2, Kind2, Kind3, Kind4, URIS2, URIS3, URIS4 } from './HKT'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Semigroupoid<F> {
+  readonly URI: F
+  readonly compose: <A, B, C>(bc: HKT2<F, B, C>, ab: HKT2<F, A, B>) => HKT2<F, A, C>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Semigroupoid2<F extends URIS2> {
+  readonly URI: F
+  readonly compose: <A, B, C>(ab: Kind2<F, B, C>, la: Kind2<F, A, B>) => Kind2<F, A, C>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Semigroupoid2C<F extends URIS2, A> {
+  readonly URI: F
+  readonly _E: A
+  readonly compose: <B, C>(ab: Kind2<F, B, C>, la: Kind2<F, A, B>) => Kind2<F, A, C>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Semigroupoid3<F extends URIS3> {
+  readonly URI: F
+  readonly compose: <R, A, B, C>(ab: Kind3<F, R, B, C>, la: Kind3<F, R, A, B>) => Kind3<F, R, A, C>
+}
+/**
+ * @category model
+ * @since 2.2.0
+ */
+export interface Semigroupoid3C<F extends URIS3, A> {
+  readonly URI: F
+  readonly _E: A
+  readonly compose: <R, B, C>(ab: Kind3<F, R, B, C>, la: Kind3<F, R, A, B>) => Kind3<F, R, A, C>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Semigroupoid4<F extends URIS4> {
+  readonly URI: F
+  readonly compose: <S, R, A, B, C>(ab: Kind4<F, S, R, B, C>, la: Kind4<F, S, R, A, B>) => Kind4<F, S, R, A, C>
+}

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/es6/Semigroupoid.js

@@ -0,0 +1 @@
+export {};

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/es6/Semiring.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Semiring<A> {
+  readonly add: (x: A, y: A) => A
+  readonly zero: A
+  readonly mul: (x: A, y: A) => A
+  readonly one: A
+}
+/**
+ * Use [`getSemiring`](./function.ts.html#getsemiring) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getFunctionSemiring: <A, B>(S: Semiring<B>) => Semiring<(a: A) => B>

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/es6/Semiring.js

@@ -0,0 +1,35 @@
+/**
+ * The `Semiring` class is for types that support an addition and multiplication operation.
+ *
+ * Instances must satisfy the following laws:
+ *
+ * - Commutative monoid under addition:
+ *   - Associativity: `(a + b) + c <-> a + (b + c)`
+ *   - Identity: `zero + a = a + zero <-> a`
+ *   - Commutative: `a + b <-> b + a`
+ * - Monoid under multiplication:
+ *   - Associativity: `(a * b) * c <-> a * (b * c)`
+ *   - Identity: `one * a <-> a * one <-> a`
+ * - Multiplication distributes over addition:
+ *   - Left distributivity: `a * (b + c) <-> (a * b) + (a * c)`
+ *   - Right distributivity: `(a + b) * c <-> (a * c) + (b * c)`
+ * - Annihilation: `zero * a <-> a * zero <-> zero`
+ *
+ * **Note:** The `number` type is not fully law abiding members of this class hierarchy due to the potential
+ * for arithmetic overflows, and the presence of `NaN` and `Infinity` values. The behaviour is
+ * unspecified in these cases.
+ *
+ * @since 2.0.0
+ */
+import { getSemiring } from './function';
+// -------------------------------------------------------------------------------------
+// deprecated
+// -------------------------------------------------------------------------------------
+/**
+ * Use [`getSemiring`](./function.ts.html#getsemiring) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export var getFunctionSemiring = getSemiring;

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/es6/Separated.d.ts

@@ -0,0 +1,91 @@
+/**
+ * ```ts
+ * interface Separated<E, A> {
+ *    readonly left: E
+ *    readonly right: A
+ * }
+ * ```
+ *
+ * Represents a result of separating a whole into two parts.
+ *
+ * @since 2.10.0
+ */
+import { Bifunctor2 } from './Bifunctor'
+import { Functor2 } from './Functor'
+/**
+ * A `Separated` type which holds `left` and `right` parts.
+ *
+ * @category model
+ * @since 2.10.0
+ */
+export interface Separated<E, A> {
+  readonly left: E
+  readonly right: A
+}
+/**
+ * @category constructors
+ * @since 2.10.0
+ */
+export declare const separated: <E, A>(left: E, right: A) => Separated<E, A>
+/**
+ * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types
+ * use the type constructor `F` to represent some computational context.
+ *
+ * @category mapping
+ * @since 2.10.0
+ */
+export declare const map: <A, B>(f: (a: A) => B) => <E>(fa: Separated<E, A>) => Separated<E, B>
+/**
+ * Map a function over the first type argument of a bifunctor.
+ *
+ * @category error handling
+ * @since 2.10.0
+ */
+export declare const mapLeft: <E, G>(f: (e: E) => G) => <A>(fa: Separated<E, A>) => Separated<G, A>
+/**
+ * Map a pair of functions over the two type arguments of the bifunctor.
+ *
+ * @category mapping
+ * @since 2.10.0
+ */
+export declare const bimap: <E, G, A, B>(f: (e: E) => G, g: (a: A) => B) => (fa: Separated<E, A>) => Separated<G, B>
+/**
+ * @category type lambdas
+ * @since 2.10.0
+ */
+export declare const URI = 'Separated'
+/**
+ * @category type lambdas
+ * @since 2.10.0
+ */
+export type URI = typeof URI
+declare module './HKT' {
+  interface URItoKind2<E, A> {
+    readonly [URI]: Separated<E, A>
+  }
+}
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+export declare const Bifunctor: Bifunctor2<URI>
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+export declare const Functor: Functor2<URI>
+/**
+ * @category mapping
+ * @since 2.10.0
+ */
+export declare const flap: <A>(
+  a: A
+) => <E, B>(fab: import('./HKT').Kind2<'Separated', E, (a: A) => B>) => import('./HKT').Kind2<'Separated', E, B>
+/**
+ * @since 2.10.0
+ */
+export declare const left: <E, A>(s: Separated<E, A>) => E
+/**
+ * @since 2.10.0
+ */
+export declare const right: <E, A>(s: Separated<E, A>) => A

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/es6/Separated.js

@@ -0,0 +1,97 @@
+/**
+ * ```ts
+ * interface Separated<E, A> {
+ *    readonly left: E
+ *    readonly right: A
+ * }
+ * ```
+ *
+ * Represents a result of separating a whole into two parts.
+ *
+ * @since 2.10.0
+ */
+import { pipe } from './function';
+import { flap as flap_ } from './Functor';
+// -------------------------------------------------------------------------------------
+// constructors
+// -------------------------------------------------------------------------------------
+/**
+ * @category constructors
+ * @since 2.10.0
+ */
+export var separated = function (left, right) { return ({ left: left, right: right }); };
+var _map = function (fa, f) { return pipe(fa, map(f)); };
+var _mapLeft = function (fa, f) { return pipe(fa, mapLeft(f)); };
+var _bimap = function (fa, g, f) { return pipe(fa, bimap(g, f)); };
+/**
+ * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types
+ * use the type constructor `F` to represent some computational context.
+ *
+ * @category mapping
+ * @since 2.10.0
+ */
+export var map = function (f) {
+    return function (fa) {
+        return separated(left(fa), f(right(fa)));
+    };
+};
+/**
+ * Map a function over the first type argument of a bifunctor.
+ *
+ * @category error handling
+ * @since 2.10.0
+ */
+export var mapLeft = function (f) {
+    return function (fa) {
+        return separated(f(left(fa)), right(fa));
+    };
+};
+/**
+ * Map a pair of functions over the two type arguments of the bifunctor.
+ *
+ * @category mapping
+ * @since 2.10.0
+ */
+export var bimap = function (f, g) {
+    return function (fa) {
+        return separated(f(left(fa)), g(right(fa)));
+    };
+};
+/**
+ * @category type lambdas
+ * @since 2.10.0
+ */
+export var URI = 'Separated';
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+export var Bifunctor = {
+    URI: URI,
+    mapLeft: _mapLeft,
+    bimap: _bimap
+};
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+export var Functor = {
+    URI: URI,
+    map: _map
+};
+/**
+ * @category mapping
+ * @since 2.10.0
+ */
+export var flap = /*#__PURE__*/ flap_(Functor);
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.10.0
+ */
+export var left = function (s) { return s.left; };
+/**
+ * @since 2.10.0
+ */
+export var right = function (s) { return s.right; };