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

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

@@ -0,0 +1,55 @@
+/**
+ * @since 2.11.0
+ */
+import { Either } from './Either'
+import { Option } from './Option'
+/**
+ * @since 2.11.0
+ */
+export interface Refinement<A, B extends A> {
+  (a: A): a is B
+}
+/**
+ * Returns a `Refinement` from a `Option` returning function.
+ * This function ensures that a `Refinement` definition is type-safe.
+ *
+ * @category lifting
+ * @since 2.11.0
+ */
+export declare const fromOptionK: <A, B extends A>(getOption: (a: A) => Option<B>) => Refinement<A, B>
+/**
+ * @category lifting
+ * @since 2.11.0
+ */
+export declare const fromEitherK: <A, B extends A>(getEither: (a: A) => Either<unknown, B>) => Refinement<A, B>
+/**
+ * @category constructors
+ * @since 2.11.0
+ */
+export declare const id: <A>() => Refinement<A, A>
+/**
+ * @since 2.11.0
+ */
+export declare const not: <A, B extends A>(refinement: Refinement<A, B>) => Refinement<A, Exclude<A, B>>
+/**
+ * @since 2.11.0
+ */
+export declare const or: <A, C extends A>(
+  second: Refinement<A, C>
+) => <B extends A>(first: Refinement<A, B>) => Refinement<A, B | C>
+/**
+ * @since 2.11.0
+ */
+export declare const and: <A, C extends A>(
+  second: Refinement<A, C>
+) => <B extends A>(first: Refinement<A, B>) => Refinement<A, B & C>
+/**
+ * @since 2.11.0
+ */
+export declare const zero: <A, B extends A>() => Refinement<A, B>
+/**
+ * @since 2.11.0
+ */
+export declare const compose: <A, B extends A, C extends B>(
+  bc: Refinement<B, C>
+) => (ab: Refinement<A, B>) => Refinement<A, C>

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

@@ -0,0 +1,107 @@
+"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.compose = exports.zero = exports.and = exports.or = exports.not = exports.id = exports.fromEitherK = exports.fromOptionK = void 0;
+var _ = __importStar(require("./internal"));
+// -------------------------------------------------------------------------------------
+// constructors
+// -------------------------------------------------------------------------------------
+/**
+ * Returns a `Refinement` from a `Option` returning function.
+ * This function ensures that a `Refinement` definition is type-safe.
+ *
+ * @category lifting
+ * @since 2.11.0
+ */
+var fromOptionK = function (getOption) {
+    return function (a) { return _.isSome(getOption(a)); };
+};
+exports.fromOptionK = fromOptionK;
+/**
+ * @category lifting
+ * @since 2.11.0
+ */
+var fromEitherK = function (getEither) {
+    return function (a) { return _.isRight(getEither(a)); };
+};
+exports.fromEitherK = fromEitherK;
+/**
+ * @category constructors
+ * @since 2.11.0
+ */
+var id = function () {
+    return function (_) { return true; };
+};
+exports.id = id;
+// -------------------------------------------------------------------------------------
+// combinators
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.11.0
+ */
+var not = function (refinement) {
+    return function (a) {
+        return !refinement(a);
+    };
+};
+exports.not = not;
+/**
+ * @since 2.11.0
+ */
+var or = function (second) {
+    return function (first) {
+        return function (a) {
+            return first(a) || second(a);
+        };
+    };
+};
+exports.or = or;
+/**
+ * @since 2.11.0
+ */
+var and = function (second) {
+    return function (first) {
+        return function (a) {
+            return first(a) && second(a);
+        };
+    };
+};
+exports.and = and;
+/**
+ * @since 2.11.0
+ */
+var zero = function () {
+    return function (_) { return false; };
+};
+exports.zero = zero;
+/**
+ * @since 2.11.0
+ */
+var compose = function (bc) {
+    return function (ab) {
+        return function (i) { return ab(i) && bc(i); };
+    };
+};
+exports.compose = compose;

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

@@ -0,0 +1,53 @@
+import { Semiring } from './Semiring'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Ring<A> extends Semiring<A> {
+  readonly sub: (x: A, y: A) => A
+}
+/**
+ * Given a tuple of `Ring`s returns a `Ring` for the tuple
+ *
+ * @example
+ * import { tuple } from 'fp-ts/Ring'
+ * import * as N from 'fp-ts/number'
+ *
+ * const R = tuple(N.Field, N.Field, N.Field)
+ * assert.deepStrictEqual(R.add([1, 2, 3], [4, 5, 6]), [5, 7, 9])
+ * assert.deepStrictEqual(R.mul([1, 2, 3], [4, 5, 6]), [4, 10, 18])
+ * assert.deepStrictEqual(R.one, [1, 1, 1])
+ * assert.deepStrictEqual(R.sub([1, 2, 3], [4, 5, 6]), [-3, -3, -3])
+ * assert.deepStrictEqual(R.zero, [0, 0, 0])
+ *
+ * @since 2.10.0
+ */
+export declare const tuple: <A extends ReadonlyArray<unknown>>(
+  ...rings: { [K in keyof A]: Ring<A[K]> }
+) => Ring<Readonly<A>>
+/**
+ * `negate x` can be used as a shorthand for `zero - x`
+ *
+ * @since 2.0.0
+ */
+export declare const negate: <A>(R: Ring<A>) => (a: A) => A
+/**
+ * Use [`tuple`](#tuple) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getTupleRing: <T extends ReadonlyArray<Ring<any>>>(
+  ...rings: T
+) => Ring<{
+  [K in keyof T]: T[K] extends Ring<infer A> ? A : never
+}>
+/**
+ * Use [`getRing`](./function.ts.html#getring) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getFunctionRing: <A, B>(R: Ring<B>) => Ring<(a: A) => B>

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFunctionRing = exports.getTupleRing = exports.negate = exports.tuple = void 0;
+/**
+ * The `Ring` class is for types that support addition, multiplication, and subtraction operations.
+ *
+ * Instances must satisfy the following law in addition to the `Semiring` laws:
+ *
+ * - Additive inverse: `a - a <-> (zero - a) + a <-> zero`
+ *
+ * Adapted from https://github.com/purescript/purescript-prelude/blob/master/src/Data/Ring.purs
+ *
+ * @since 2.0.0
+ */
+var function_1 = require("./function");
+// -------------------------------------------------------------------------------------
+// combinators
+// -------------------------------------------------------------------------------------
+/**
+ * Given a tuple of `Ring`s returns a `Ring` for the tuple
+ *
+ * @example
+ * import { tuple } from 'fp-ts/Ring'
+ * import * as N from 'fp-ts/number'
+ *
+ * const R = tuple(N.Field, N.Field, N.Field)
+ * assert.deepStrictEqual(R.add([1, 2, 3], [4, 5, 6]), [5, 7, 9])
+ * assert.deepStrictEqual(R.mul([1, 2, 3], [4, 5, 6]), [4, 10, 18])
+ * assert.deepStrictEqual(R.one, [1, 1, 1])
+ * assert.deepStrictEqual(R.sub([1, 2, 3], [4, 5, 6]), [-3, -3, -3])
+ * assert.deepStrictEqual(R.zero, [0, 0, 0])
+ *
+ * @since 2.10.0
+ */
+var tuple = function () {
+    var rings = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        rings[_i] = arguments[_i];
+    }
+    return ({
+        add: function (x, y) { return rings.map(function (R, i) { return R.add(x[i], y[i]); }); },
+        zero: rings.map(function (R) { return R.zero; }),
+        mul: function (x, y) { return rings.map(function (R, i) { return R.mul(x[i], y[i]); }); },
+        one: rings.map(function (R) { return R.one; }),
+        sub: function (x, y) { return rings.map(function (R, i) { return R.sub(x[i], y[i]); }); }
+    });
+};
+exports.tuple = tuple;
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+/**
+ * `negate x` can be used as a shorthand for `zero - x`
+ *
+ * @since 2.0.0
+ */
+var negate = function (R) {
+    return function (a) {
+        return R.sub(R.zero, a);
+    };
+};
+exports.negate = negate;
+// -------------------------------------------------------------------------------------
+// deprecated
+// -------------------------------------------------------------------------------------
+/**
+ * Use [`tuple`](#tuple) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+exports.getTupleRing = exports.tuple;
+/**
+ * Use [`getRing`](./function.ts.html#getring) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+exports.getFunctionRing = function_1.getRing;

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

@@ -0,0 +1,302 @@
+import * as M from './Magma'
+import * as Or from './Ord'
+import { ReadonlyRecord } from './ReadonlyRecord'
+import Ord = Or.Ord
+import Magma = M.Magma
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Semigroup<A> extends Magma<A> {}
+/**
+ * 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 declare const min: <A>(O: Ord<A>) => Semigroup<A>
+/**
+ * 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 declare const max: <A>(O: Ord<A>) => Semigroup<A>
+/**
+ * @category constructors
+ * @since 2.10.0
+ */
+export declare const constant: <A>(a: A) => Semigroup<A>
+/**
+ * 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 declare const reverse: <A>(S: Semigroup<A>) => Semigroup<A>
+/**
+ * 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 declare const struct: <A>(semigroups: { [K in keyof A]: Semigroup<A[K]> }) => Semigroup<{
+  readonly [K in keyof A]: A[K]
+}>
+/**
+ * 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 declare const tuple: <A extends ReadonlyArray<unknown>>(
+  ...semigroups: { [K in keyof A]: Semigroup<A[K]> }
+) => Semigroup<Readonly<A>>
+/**
+ * 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 declare const intercalate: <A>(middle: A) => (S: Semigroup<A>) => Semigroup<A>
+/**
+ * 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 declare const first: <A = never>() => Semigroup<A>
+/**
+ * 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 declare const last: <A = never>() => Semigroup<A>
+/**
+ * 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 declare const concatAll: <A>(S: Semigroup<A>) => (startWith: A) => (as: ReadonlyArray<A>) => A
+/**
+ * Use `void` module instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const semigroupVoid: Semigroup<void>
+/**
+ * Use [`getAssignSemigroup`](./struct.ts.html#getAssignSemigroup) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getObjectSemigroup: <A extends object = never>() => Semigroup<A>
+/**
+ * Use [`last`](#last) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getLastSemigroup: <A = never>() => Semigroup<A>
+/**
+ * Use [`first`](#first) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getFirstSemigroup: <A = never>() => Semigroup<A>
+/**
+ * Use [`tuple`](#tuple) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getTupleSemigroup: <T extends ReadonlyArray<Semigroup<any>>>(
+  ...semigroups: T
+) => Semigroup<{
+  [K in keyof T]: T[K] extends Semigroup<infer A> ? A : never
+}>
+/**
+ * Use [`struct`](#struct) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getStructSemigroup: <O extends ReadonlyRecord<string, any>>(semigroups: {
+  [K in keyof O]: Semigroup<O[K]>
+}) => Semigroup<O>
+/**
+ * Use [`reverse`](#reverse) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getDualSemigroup: <A>(S: Semigroup<A>) => Semigroup<A>
+/**
+ * Use [`max`](#max) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getJoinSemigroup: <A>(O: Ord<A>) => Semigroup<A>
+/**
+ * Use [`min`](#min) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getMeetSemigroup: <A>(O: Ord<A>) => Semigroup<A>
+/**
+ * Use [`intercalate`](#intercalate) instead.
+ *
+ * @category zone of death
+ * @since 2.5.0
+ * @deprecated
+ */
+export declare const getIntercalateSemigroup: <A>(middle: A) => (S: Semigroup<A>) => Semigroup<A>
+/**
+ * Use [`concatAll`](#concatall) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare function fold<A>(S: Semigroup<A>): {
+  (startWith: A): (as: ReadonlyArray<A>) => A
+  (startWith: A, as: ReadonlyArray<A>): A
+}
+/**
+ * Use [`SemigroupAll`](./boolean.ts.html#SemigroupAll) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const semigroupAll: Semigroup<boolean>
+/**
+ * Use [`SemigroupAny`](./boolean.ts.html#SemigroupAny) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const semigroupAny: Semigroup<boolean>
+/**
+ * Use [`getSemigroup`](./function.ts.html#getSemigroup) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getFunctionSemigroup: <S>(S: Semigroup<S>) => <A = never>() => Semigroup<(a: A) => S>
+/**
+ * Use [`Semigroup`](./string.ts.html#Semigroup) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const semigroupString: Semigroup<string>
+/**
+ * Use [`SemigroupSum`](./number.ts.html#SemigroupSum) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const semigroupSum: Semigroup<number>
+/**
+ * Use [`SemigroupProduct`](./number.ts.html#SemigroupProduct) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const semigroupProduct: Semigroup<number>