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

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/lib/Compactable.js

@@ -0,0 +1,49 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compact = compact;
+exports.separate = separate;
+exports.getCompactableComposition = getCompactableComposition;
+var function_1 = require("./function");
+var Functor_1 = require("./Functor");
+var Option_1 = require("./Option");
+var S = __importStar(require("./Separated"));
+function compact(F, G) {
+    return function (fga) { return F.map(fga, G.compact); };
+}
+function separate(F, C, G) {
+    var _compact = compact(F, C);
+    var _map = (0, Functor_1.map)(F, G);
+    return function (fge) { return S.separated(_compact((0, function_1.pipe)(fge, _map(Option_1.getLeft))), _compact((0, function_1.pipe)(fge, _map(Option_1.getRight)))); };
+}
+/** @deprecated */
+function getCompactableComposition(F, G) {
+    var map = (0, Functor_1.getFunctorComposition)(F, G).map;
+    return {
+        map: map,
+        compact: compact(F, G),
+        separate: separate(F, G, G)
+    };
+}

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/lib/Console.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @since 2.0.0
+ */
+import { IO } from './IO'
+/**
+ * @since 2.0.0
+ */
+export declare const log: <A>(a: A) => IO<void>
+/**
+ * @since 2.0.0
+ */
+export declare const warn: <A>(a: A) => IO<void>
+/**
+ * @since 2.0.0
+ */
+export declare const error: <A>(a: A) => IO<void>
+/**
+ * @since 2.0.0
+ */
+export declare const info: <A>(a: A) => IO<void>

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/lib/Console.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.info = exports.error = exports.warn = exports.log = void 0;
+/**
+ * @since 2.0.0
+ */
+var log = function (a) {
+    return function () {
+        return console.log(a);
+    };
+};
+exports.log = log;
+/**
+ * @since 2.0.0
+ */
+var warn = function (a) {
+    return function () {
+        return console.warn(a);
+    };
+};
+exports.warn = warn;
+/**
+ * @since 2.0.0
+ */
+var error = function (a) {
+    return function () {
+        return console.error(a);
+    };
+};
+exports.error = error;
+/**
+ * @since 2.0.0
+ */
+var info = function (a) {
+    return function () {
+        return console.info(a);
+    };
+};
+exports.info = info;

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/lib/Const.d.ts

@@ -0,0 +1,169 @@
+/**
+ * The `Const` type constructor, which wraps its first type argument and ignores its second.
+ * That is, `Const<E, A>` is isomorphic to `E` for any `A`.
+ *
+ * `Const` has some useful instances. For example, the `Applicative` instance allows us to collect results using a `Monoid`
+ * while ignoring return values.
+ *
+ * @since 2.0.0
+ */
+import { Applicative2C } from './Applicative'
+import { Apply2C } from './Apply'
+import { Bifunctor2 } from './Bifunctor'
+import { BooleanAlgebra } from './BooleanAlgebra'
+import { Bounded } from './Bounded'
+import { Contravariant2 } from './Contravariant'
+import { Eq } from './Eq'
+import { Functor2 } from './Functor'
+import { HeytingAlgebra } from './HeytingAlgebra'
+import { Monoid } from './Monoid'
+import { Ord } from './Ord'
+import { Ring } from './Ring'
+import { Semigroup } from './Semigroup'
+import { Semiring } from './Semiring'
+import { Show } from './Show'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export type Const<E, A> = E & {
+  readonly _A: A
+}
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+export declare const make: <E, A = never>(e: E) => Const<E, A>
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export declare function getShow<E, A>(S: Show<E>): Show<Const<E, A>>
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export declare const getEq: <E, A>(E: Eq<E>) => Eq<Const<E, A>>
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+export declare const getOrd: <E, A>(O: Ord<E>) => Ord<Const<E, A>>
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+export declare const getBounded: <E, A>(B: Bounded<E>) => Bounded<Const<E, A>>
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+export declare const getSemigroup: <E, A>(S: Semigroup<E>) => Semigroup<Const<E, A>>
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+export declare const getMonoid: <E, A>(M: Monoid<E>) => Monoid<Const<E, A>>
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+export declare const getSemiring: <E, A>(S: Semiring<E>) => Semiring<Const<E, A>>
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+export declare const getRing: <E, A>(S: Ring<E>) => Ring<Const<E, A>>
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+export declare const getHeytingAlgebra: <E, A>(H: HeytingAlgebra<E>) => HeytingAlgebra<Const<E, A>>
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+export declare const getBooleanAlgebra: <E, A>(H: BooleanAlgebra<E>) => BooleanAlgebra<Const<E, A>>
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export declare function getApply<E>(S: Semigroup<E>): Apply2C<URI, E>
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+export declare function getApplicative<E>(M: Monoid<E>): Applicative2C<URI, E>
+/**
+ * @since 2.0.0
+ */
+export declare const contramap: <A, B>(f: (b: B) => A) => <E>(fa: Const<E, A>) => Const<E, B>
+/**
+ * `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.0.0
+ */
+export declare const map: <A, B>(f: (a: A) => B) => <E>(fa: Const<E, A>) => Const<E, B>
+/**
+ * Map a pair of functions over the two type arguments of the bifunctor.
+ *
+ * @category mapping
+ * @since 2.6.2
+ */
+export declare const bimap: <E, G, A, B>(f: (e: E) => G, g: (a: A) => B) => (fa: Const<E, A>) => Const<G, B>
+/**
+ * Map a function over the first type argument of a bifunctor.
+ *
+ * @category error handling
+ * @since 2.6.2
+ */
+export declare const mapLeft: <E, G>(f: (e: E) => G) => <A>(fa: Const<E, A>) => Const<G, A>
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+export declare const URI = 'Const'
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+export type URI = typeof URI
+declare module './HKT' {
+  interface URItoKind2<E, A> {
+    readonly [URI]: Const<E, A>
+  }
+}
+/**
+ * @category instances
+ * @since 2.7.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<'Const', E, (a: A) => B>) => import('./HKT').Kind2<'Const', E, B>
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+export declare const Contravariant: Contravariant2<URI>
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+export declare const Bifunctor: Bifunctor2<URI>
+/**
+ * This instance is deprecated, use small, specific instances instead.
+ * For example if a function needs a `Functor` instance, pass `C.Functor` instead of `C.const_`
+ * (where `C` is from `import C from 'fp-ts/Const'`)
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const const_: Functor2<URI> & Contravariant2<URI> & Bifunctor2<URI>

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/lib/Const.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.const_ = exports.Bifunctor = exports.Contravariant = exports.flap = exports.Functor = exports.URI = exports.mapLeft = exports.bimap = exports.map = exports.contramap = exports.getBooleanAlgebra = exports.getHeytingAlgebra = exports.getRing = exports.getSemiring = exports.getMonoid = exports.getSemigroup = exports.getBounded = exports.getOrd = exports.getEq = exports.make = void 0;
+exports.getShow = getShow;
+exports.getApply = getApply;
+exports.getApplicative = getApplicative;
+var function_1 = require("./function");
+var Functor_1 = require("./Functor");
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+exports.make = function_1.unsafeCoerce;
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+function getShow(S) {
+    return {
+        show: function (c) { return "make(".concat(S.show(c), ")"); }
+    };
+}
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+exports.getEq = function_1.identity;
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+exports.getOrd = function_1.identity;
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+exports.getBounded = function_1.identity;
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+exports.getSemigroup = function_1.identity;
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+exports.getMonoid = function_1.identity;
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+exports.getSemiring = function_1.identity;
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+exports.getRing = function_1.identity;
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+exports.getHeytingAlgebra = function_1.identity;
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+exports.getBooleanAlgebra = function_1.identity;
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+function getApply(S) {
+    return {
+        URI: exports.URI,
+        _E: undefined,
+        map: _map,
+        ap: function (fab, fa) { return (0, exports.make)(S.concat(fab, fa)); }
+    };
+}
+/**
+ * @category instances
+ * @since 2.0.0
+ */
+function getApplicative(M) {
+    var A = getApply(M);
+    return {
+        URI: exports.URI,
+        _E: undefined,
+        map: A.map,
+        ap: A.ap,
+        of: function () { return (0, exports.make)(M.empty); }
+    };
+}
+var _contramap = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.contramap)(f)); };
+/* istanbul ignore next */
+var _map = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.map)(f)); };
+/* istanbul ignore next */
+var _bimap = function (fa, f, g) { return (0, function_1.pipe)(fa, (0, exports.bimap)(f, g)); };
+/* istanbul ignore next */
+var _mapLeft = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.mapLeft)(f)); };
+/**
+ * @since 2.0.0
+ */
+var contramap = function () { return function_1.unsafeCoerce; };
+exports.contramap = contramap;
+/**
+ * `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.0.0
+ */
+var map = function () { return function_1.unsafeCoerce; };
+exports.map = map;
+/**
+ * Map a pair of functions over the two type arguments of the bifunctor.
+ *
+ * @category mapping
+ * @since 2.6.2
+ */
+var bimap = function (f) { return function (fa) {
+    return (0, exports.make)(f(fa));
+}; };
+exports.bimap = bimap;
+/**
+ * Map a function over the first type argument of a bifunctor.
+ *
+ * @category error handling
+ * @since 2.6.2
+ */
+var mapLeft = function (f) { return function (fa) { return (0, exports.make)(f(fa)); }; };
+exports.mapLeft = mapLeft;
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+exports.URI = 'Const';
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+exports.Functor = {
+    URI: exports.URI,
+    map: _map
+};
+/**
+ * @category mapping
+ * @since 2.10.0
+ */
+exports.flap = (0, Functor_1.flap)(exports.Functor);
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+exports.Contravariant = {
+    URI: exports.URI,
+    contramap: _contramap
+};
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+exports.Bifunctor = {
+    URI: exports.URI,
+    bimap: _bimap,
+    mapLeft: _mapLeft
+};
+// -------------------------------------------------------------------------------------
+// deprecated
+// -------------------------------------------------------------------------------------
+/**
+ * This instance is deprecated, use small, specific instances instead.
+ * For example if a function needs a `Functor` instance, pass `C.Functor` instead of `C.const_`
+ * (where `C` is from `import C from 'fp-ts/Const'`)
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+exports.const_ = {
+    URI: exports.URI,
+    map: _map,
+    contramap: _contramap,
+    bimap: _bimap,
+    mapLeft: _mapLeft
+};

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/lib/Contravariant.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @since 2.0.0
+ */
+import { HKT, Kind, Kind2, Kind3, Kind4, URIS, URIS2, URIS3, URIS4 } from './HKT'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Contravariant<F> {
+  readonly URI: F
+  readonly contramap: <A, B>(fa: HKT<F, A>, f: (b: B) => A) => HKT<F, B>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Contravariant1<F extends URIS> {
+  readonly URI: F
+  readonly contramap: <A, B>(fa: Kind<F, A>, f: (b: B) => A) => Kind<F, B>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Contravariant2<F extends URIS2> {
+  readonly URI: F
+  readonly contramap: <E, A, B>(fa: Kind2<F, E, A>, f: (b: B) => A) => Kind2<F, E, B>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Contravariant2C<F extends URIS2, E> {
+  readonly URI: F
+  readonly _E: E
+  readonly contramap: <A, B>(fa: Kind2<F, E, A>, f: (b: B) => A) => Kind2<F, E, B>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Contravariant3<F extends URIS3> {
+  readonly URI: F
+  readonly contramap: <R, E, A, B>(fa: Kind3<F, R, E, A>, f: (b: B) => A) => Kind3<F, R, E, B>
+}
+/**
+ * @category model
+ * @since 2.2.0
+ */
+export interface Contravariant3C<F extends URIS3, E> {
+  readonly URI: F
+  readonly _E: E
+  readonly contramap: <R, A, B>(fa: Kind3<F, R, E, A>, f: (b: B) => A) => Kind3<F, R, E, B>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Contravariant4<F extends URIS4> {
+  readonly URI: F
+  readonly contramap: <S, R, E, A, B>(fa: Kind4<F, S, R, E, A>, f: (b: B) => A) => Kind4<F, S, R, E, B>
+}

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/lib/Contravariant.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/lib/Date.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @since 2.0.0
+ */
+import * as E from './Eq'
+import { IO } from './IO'
+import * as O from './Ord'
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+export declare const Eq: E.Eq<Date>
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+export declare const eqDate: E.Eq<Date>
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+export declare const eqMonth: E.Eq<Date>
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+export declare const eqYear: E.Eq<Date>
+/**
+ * @example
+ * import { Ord } from 'fp-ts/Date'
+ *
+ * assert.deepStrictEqual(Ord.compare(new Date(1, 1, 2020), new Date(1, 1, 2021)), -1)
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+export declare const Ord: O.Ord<Date>
+/**
+ * Returns the current `Date`
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+export declare const create: IO<Date>
+/**
+ * Returns the number of milliseconds elapsed since January 1, 1970, 00:00:00 UTC
+ *
+ * @since 2.0.0
+ */
+export declare const now: IO<number>

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/lib/Date.js

@@ -0,0 +1,89 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.now = exports.create = exports.Ord = exports.eqYear = exports.eqMonth = exports.eqDate = exports.Eq = void 0;
+var function_1 = require("./function");
+var N = __importStar(require("./number"));
+var O = __importStar(require("./Ord"));
+// -------------------------------------------------------------------------------------
+// instances
+// -------------------------------------------------------------------------------------
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+exports.Eq = {
+    equals: function (first, second) { return first.valueOf() === second.valueOf(); }
+};
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+exports.eqDate = {
+    equals: function (x, y) { return x.getDate() === y.getDate(); }
+};
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+exports.eqMonth = {
+    equals: function (x, y) { return x.getMonth() === y.getMonth(); }
+};
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+exports.eqYear = {
+    equals: function (x, y) { return x.getFullYear() === y.getFullYear(); }
+};
+/**
+ * @example
+ * import { Ord } from 'fp-ts/Date'
+ *
+ * assert.deepStrictEqual(Ord.compare(new Date(1, 1, 2020), new Date(1, 1, 2021)), -1)
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+exports.Ord = (0, function_1.pipe)(N.Ord, 
+/*#__PURE__*/ O.contramap(function (date) { return date.valueOf(); }));
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+/**
+ * Returns the current `Date`
+ *
+ * @category constructors
+ * @since 2.0.0
+ */
+var create = function () { return new Date(); };
+exports.create = create;
+/**
+ * Returns the number of milliseconds elapsed since January 1, 1970, 00:00:00 UTC
+ *
+ * @since 2.0.0
+ */
+var now = function () { return new Date().getTime(); };
+exports.now = now;

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/lib/DistributiveLattice.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A `DistributiveLattice` must satisfy the following laws in addition to `Lattice` laws:
+ *
+ * - Distributivity for meet: `a ∨ (b ∧ c) <-> (a ∨ b) ∧ (a ∨ c)`
+ * - Distributivity for join: `a ∧ (b ∨ c) <-> (a ∧ b) ∨ (a ∧ c)`
+ *
+ * @since 2.0.0
+ */
+import { Lattice } from './Lattice'
+import { Ord } from './Ord'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface DistributiveLattice<A> extends Lattice<A> {}
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+export declare function getMinMaxDistributiveLattice<A>(O: Ord<A>): DistributiveLattice<A>