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

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

@@ -0,0 +1,198 @@
+import { apFirst as apFirst_, apSecond as apSecond_ } from './Apply';
+import { chainFirst as chainFirst_ } from './Chain';
+import { identity, pipe as pipeFromFunctionModule } from './function';
+export function map(F) {
+    return function (f) { return function (fa) { return F.map(fa, f); }; };
+}
+export function contramap(F) {
+    return function (f) { return function (fa) { return F.contramap(fa, f); }; };
+}
+export function mapWithIndex(F) {
+    return function (f) { return function (fa) { return F.mapWithIndex(fa, f); }; };
+}
+export function ap(F) {
+    return function (fa) { return function (fab) { return F.ap(fab, fa); }; };
+}
+export function chain(F) {
+    return function (f) { return function (fa) { return F.chain(fa, f); }; };
+}
+export function bimap(F) {
+    return function (f, g) { return function (fea) { return F.bimap(fea, f, g); }; };
+}
+export function mapLeft(F) {
+    return function (f) { return function (fea) { return F.mapLeft(fea, f); }; };
+}
+export function extend(F) {
+    return function (f) { return function (wa) { return F.extend(wa, f); }; };
+}
+export function reduce(F) {
+    return function (b, f) { return function (fa) { return F.reduce(fa, b, f); }; };
+}
+export function foldMap(F) {
+    return function (M) {
+        var foldMapM = F.foldMap(M);
+        return function (f) { return function (fa) { return foldMapM(fa, f); }; };
+    };
+}
+export function reduceRight(F) {
+    return function (b, f) { return function (fa) { return F.reduceRight(fa, b, f); }; };
+}
+export function reduceWithIndex(F) {
+    return function (b, f) { return function (fa) { return F.reduceWithIndex(fa, b, f); }; };
+}
+export function foldMapWithIndex(F) {
+    return function (M) {
+        var foldMapWithIndexM = F.foldMapWithIndex(M);
+        return function (f) { return function (fa) { return foldMapWithIndexM(fa, f); }; };
+    };
+}
+export function reduceRightWithIndex(F) {
+    return function (b, f) { return function (fa) { return F.reduceRightWithIndex(fa, b, f); }; };
+}
+export function alt(F) {
+    return function (that) { return function (fa) { return F.alt(fa, that); }; };
+}
+export function filter(F) {
+    return function (predicate) { return function (fa) { return F.filter(fa, predicate); }; };
+}
+export function filterMap(F) {
+    return function (f) { return function (fa) { return F.filterMap(fa, f); }; };
+}
+export function partition(F) {
+    return function (f) { return function (fa) { return F.partition(fa, f); }; };
+}
+export function partitionMap(F) {
+    return function (f) { return function (fa) { return F.partitionMap(fa, f); }; };
+}
+export function filterWithIndex(F) {
+    return function (predicate) { return function (fa) { return F.filterWithIndex(fa, predicate); }; };
+}
+export function filterMapWithIndex(F) {
+    return function (f) { return function (fa) { return F.filterMapWithIndex(fa, f); }; };
+}
+export function partitionWithIndex(F) {
+    return function (f) { return function (fa) { return F.partitionWithIndex(fa, f); }; };
+}
+export function partitionMapWithIndex(F) {
+    return function (f) { return function (fa) { return F.partitionMapWithIndex(fa, f); }; };
+}
+export function promap(F) {
+    return function (f, g) { return function (fbc) { return F.promap(fbc, f, g); }; };
+}
+export function compose(F) {
+    return function (ea) { return function (ab) { return F.compose(ab, ea); }; };
+}
+var isFunctor = function (I) { return typeof I.map === 'function'; };
+var isContravariant = function (I) { return typeof I.contramap === 'function'; };
+var isFunctorWithIndex = function (I) { return typeof I.mapWithIndex === 'function'; };
+var isApply = function (I) { return typeof I.ap === 'function'; };
+var isChain = function (I) { return typeof I.chain === 'function'; };
+var isBifunctor = function (I) { return typeof I.bimap === 'function'; };
+var isExtend = function (I) { return typeof I.extend === 'function'; };
+var isFoldable = function (I) { return typeof I.reduce === 'function'; };
+var isFoldableWithIndex = function (I) { return typeof I.reduceWithIndex === 'function'; };
+var isAlt = function (I) { return typeof I.alt === 'function'; };
+var isCompactable = function (I) { return typeof I.compact === 'function'; };
+var isFilterable = function (I) { return typeof I.filter === 'function'; };
+var isFilterableWithIndex = function (I) {
+    return typeof I.filterWithIndex === 'function';
+};
+var isProfunctor = function (I) { return typeof I.promap === 'function'; };
+var isSemigroupoid = function (I) { return typeof I.compose === 'function'; };
+var isMonadThrow = function (I) { return typeof I.throwError === 'function'; };
+/** @deprecated */
+export function pipeable(I) {
+    var r = {};
+    if (isFunctor(I)) {
+        r.map = map(I);
+    }
+    if (isContravariant(I)) {
+        r.contramap = contramap(I);
+    }
+    if (isFunctorWithIndex(I)) {
+        r.mapWithIndex = mapWithIndex(I);
+    }
+    if (isApply(I)) {
+        r.ap = ap(I);
+        r.apFirst = apFirst_(I);
+        r.apSecond = apSecond_(I);
+    }
+    if (isChain(I)) {
+        r.chain = chain(I);
+        r.chainFirst = chainFirst_(I);
+        r.flatten = r.chain(identity);
+    }
+    if (isBifunctor(I)) {
+        r.bimap = bimap(I);
+        r.mapLeft = mapLeft(I);
+    }
+    if (isExtend(I)) {
+        r.extend = extend(I);
+        r.duplicate = r.extend(identity);
+    }
+    if (isFoldable(I)) {
+        r.reduce = reduce(I);
+        r.foldMap = foldMap(I);
+        r.reduceRight = reduceRight(I);
+    }
+    if (isFoldableWithIndex(I)) {
+        r.reduceWithIndex = reduceWithIndex(I);
+        r.foldMapWithIndex = foldMapWithIndex(I);
+        r.reduceRightWithIndex = reduceRightWithIndex(I);
+    }
+    if (isAlt(I)) {
+        r.alt = alt(I);
+    }
+    if (isCompactable(I)) {
+        r.compact = I.compact;
+        r.separate = I.separate;
+    }
+    if (isFilterable(I)) {
+        r.filter = filter(I);
+        r.filterMap = filterMap(I);
+        r.partition = partition(I);
+        r.partitionMap = partitionMap(I);
+    }
+    if (isFilterableWithIndex(I)) {
+        r.filterWithIndex = filterWithIndex(I);
+        r.filterMapWithIndex = filterMapWithIndex(I);
+        r.partitionWithIndex = partitionWithIndex(I);
+        r.partitionMapWithIndex = partitionMapWithIndex(I);
+    }
+    if (isProfunctor(I)) {
+        r.promap = promap(I);
+    }
+    if (isSemigroupoid(I)) {
+        r.compose = compose(I);
+    }
+    if (isMonadThrow(I)) {
+        var fromOption = function (onNone) { return function (ma) {
+            return ma._tag === 'None' ? I.throwError(onNone()) : I.of(ma.value);
+        }; };
+        var fromEither = function (ma) {
+            return ma._tag === 'Left' ? I.throwError(ma.left) : I.of(ma.right);
+        };
+        var fromPredicate = function (predicate, onFalse) {
+            return function (a) {
+                return predicate(a) ? I.of(a) : I.throwError(onFalse(a));
+            };
+        };
+        var filterOrElse = function (predicate, onFalse) {
+            return function (ma) {
+                return I.chain(ma, function (a) { return (predicate(a) ? I.of(a) : I.throwError(onFalse(a))); });
+            };
+        };
+        r.fromOption = fromOption;
+        r.fromEither = fromEither;
+        r.fromPredicate = fromPredicate;
+        r.filterOrElse = filterOrElse;
+    }
+    return r;
+}
+/**
+ * Use [`pipe`](https://gcanti.github.io/fp-ts/modules/function.ts.html#pipe) from `function` module instead.
+ *
+ * @since 2.0.0
+ * @deprecated
+ */
+export var pipe = pipeFromFunctionModule;

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

@@ -0,0 +1,226 @@
+/**
+ * @since 2.10.0
+ */
+import * as E from './Eq'
+import * as M from './Monoid'
+import * as O from './Ord'
+import { ReadonlyNonEmptyArray } from './ReadonlyNonEmptyArray'
+import { Refinement } from './Refinement'
+import * as S from './Semigroup'
+import * as Sh from './Show'
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ *
+ * assert.deepStrictEqual(S.Eq.equals('a', 'a'), true)
+ * assert.deepStrictEqual(S.Eq.equals('a', 'b'), false)
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+export declare const Eq: E.Eq<string>
+/**
+ * `string` semigroup under concatenation.
+ *
+ * @example
+ * import * as S from 'fp-ts/string'
+ *
+ * assert.deepStrictEqual(S.Semigroup.concat('a', 'b'), 'ab')
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+export declare const Semigroup: S.Semigroup<string>
+/**
+ * An empty `string`.
+ *
+ * @since 2.10.0
+ */
+export declare const empty = ''
+/**
+ * `string` monoid under concatenation.
+ *
+ * The `empty` value is `''`.
+ *
+ * @example
+ * import * as S from 'fp-ts/string'
+ *
+ * assert.deepStrictEqual(S.Monoid.concat('a', 'b'), 'ab')
+ * assert.deepStrictEqual(S.Monoid.concat('a', S.Monoid.empty), 'a')
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+export declare const Monoid: M.Monoid<string>
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ *
+ * assert.deepStrictEqual(S.Ord.compare('a', 'a'), 0)
+ * assert.deepStrictEqual(S.Ord.compare('a', 'b'), -1)
+ * assert.deepStrictEqual(S.Ord.compare('b', 'a'), 1)
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+export declare const Ord: O.Ord<string>
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ *
+ * assert.deepStrictEqual(S.Show.show('a'), '"a"')
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+export declare const Show: Sh.Show<string>
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ *
+ * assert.deepStrictEqual(S.isString('a'), true)
+ * assert.deepStrictEqual(S.isString(1), false)
+ *
+ * @category refinements
+ * @since 2.11.0
+ */
+export declare const isString: Refinement<unknown, string>
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('a', S.toUpperCase), 'A')
+ *
+ * @since 2.11.0
+ */
+export declare const toUpperCase: (s: string) => string
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('A', S.toLowerCase), 'a')
+ *
+ * @since 2.11.0
+ */
+export declare const toLowerCase: (s: string) => string
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('abc', S.replace('b', 'd')), 'adc')
+ *
+ * @since 2.11.0
+ */
+export declare const replace: (searchValue: string | RegExp, replaceValue: string) => (s: string) => string
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe(' a ', S.trim), 'a')
+ *
+ * @since 2.11.0
+ */
+export declare const trim: (s: string) => string
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe(' a ', S.trimLeft), 'a ')
+ *
+ * @since 2.11.0
+ */
+export declare const trimLeft: (s: string) => string
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe(' a ', S.trimRight), ' a')
+ *
+ * @since 2.11.0
+ */
+export declare const trimRight: (s: string) => string
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('abcd', S.slice(1, 3)), 'bc')
+ *
+ * @since 2.11.0
+ */
+export declare const slice: (start: number, end: number) => (s: string) => string
+/**
+ * Test whether a `string` is empty.
+ *
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('', S.isEmpty), true)
+ * assert.deepStrictEqual(pipe('a', S.isEmpty), false)
+ *
+ * @since 2.10.0
+ */
+export declare const isEmpty: (s: string) => boolean
+/**
+ * Calculate the number of characters in a `string`.
+ *
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('abc', S.size), 3)
+ *
+ * @since 2.10.0
+ */
+export declare const size: (s: string) => number
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('abc', S.split('')), ['a', 'b', 'c'])
+ * assert.deepStrictEqual(pipe('', S.split('')), [''])
+ *
+ * @since 2.11.0
+ */
+export declare const split: (separator: string | RegExp) => (s: string) => ReadonlyNonEmptyArray<string>
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('abc', S.includes('b')), true)
+ * assert.deepStrictEqual(pipe('abc', S.includes('d')), false)
+ *
+ * @since 2.11.0
+ */
+export declare const includes: (searchString: string, position?: number) => (s: string) => boolean
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('abc', S.startsWith('a')), true)
+ * assert.deepStrictEqual(pipe('bc', S.startsWith('a')), false)
+ *
+ * @since 2.11.0
+ */
+export declare const startsWith: (searchString: string, position?: number) => (s: string) => boolean
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('abc', S.endsWith('c')), true)
+ * assert.deepStrictEqual(pipe('ab', S.endsWith('c')), false)
+ *
+ * @since 2.11.0
+ */
+export declare const endsWith: (searchString: string, position?: number) => (s: string) => boolean

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

@@ -0,0 +1,266 @@
+import { isNonEmpty } from './ReadonlyNonEmptyArray';
+// -------------------------------------------------------------------------------------
+// instances
+// -------------------------------------------------------------------------------------
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ *
+ * assert.deepStrictEqual(S.Eq.equals('a', 'a'), true)
+ * assert.deepStrictEqual(S.Eq.equals('a', 'b'), false)
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+export var Eq = {
+    equals: function (first, second) { return first === second; }
+};
+/**
+ * `string` semigroup under concatenation.
+ *
+ * @example
+ * import * as S from 'fp-ts/string'
+ *
+ * assert.deepStrictEqual(S.Semigroup.concat('a', 'b'), 'ab')
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+export var Semigroup = {
+    concat: function (first, second) { return first + second; }
+};
+/**
+ * An empty `string`.
+ *
+ * @since 2.10.0
+ */
+export var empty = '';
+/**
+ * `string` monoid under concatenation.
+ *
+ * The `empty` value is `''`.
+ *
+ * @example
+ * import * as S from 'fp-ts/string'
+ *
+ * assert.deepStrictEqual(S.Monoid.concat('a', 'b'), 'ab')
+ * assert.deepStrictEqual(S.Monoid.concat('a', S.Monoid.empty), 'a')
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+export var Monoid = {
+    concat: Semigroup.concat,
+    empty: empty
+};
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ *
+ * assert.deepStrictEqual(S.Ord.compare('a', 'a'), 0)
+ * assert.deepStrictEqual(S.Ord.compare('a', 'b'), -1)
+ * assert.deepStrictEqual(S.Ord.compare('b', 'a'), 1)
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+export var Ord = {
+    equals: Eq.equals,
+    compare: function (first, second) { return (first < second ? -1 : first > second ? 1 : 0); }
+};
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ *
+ * assert.deepStrictEqual(S.Show.show('a'), '"a"')
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+export var Show = {
+    show: function (s) { return JSON.stringify(s); }
+};
+// -------------------------------------------------------------------------------------
+// refinements
+// -------------------------------------------------------------------------------------
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ *
+ * assert.deepStrictEqual(S.isString('a'), true)
+ * assert.deepStrictEqual(S.isString(1), false)
+ *
+ * @category refinements
+ * @since 2.11.0
+ */
+export var isString = function (u) { return typeof u === 'string'; };
+// -------------------------------------------------------------------------------------
+// combinators
+// -------------------------------------------------------------------------------------
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('a', S.toUpperCase), 'A')
+ *
+ * @since 2.11.0
+ */
+export var toUpperCase = function (s) { return s.toUpperCase(); };
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('A', S.toLowerCase), 'a')
+ *
+ * @since 2.11.0
+ */
+export var toLowerCase = function (s) { return s.toLowerCase(); };
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('abc', S.replace('b', 'd')), 'adc')
+ *
+ * @since 2.11.0
+ */
+export var replace = function (searchValue, replaceValue) {
+    return function (s) {
+        return s.replace(searchValue, replaceValue);
+    };
+};
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe(' a ', S.trim), 'a')
+ *
+ * @since 2.11.0
+ */
+export var trim = function (s) { return s.trim(); };
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe(' a ', S.trimLeft), 'a ')
+ *
+ * @since 2.11.0
+ */
+export var trimLeft = function (s) { return s.trimLeft(); };
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe(' a ', S.trimRight), ' a')
+ *
+ * @since 2.11.0
+ */
+export var trimRight = function (s) { return s.trimRight(); };
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('abcd', S.slice(1, 3)), 'bc')
+ *
+ * @since 2.11.0
+ */
+export var slice = function (start, end) {
+    return function (s) {
+        return s.slice(start, end);
+    };
+};
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+/**
+ * Test whether a `string` is empty.
+ *
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('', S.isEmpty), true)
+ * assert.deepStrictEqual(pipe('a', S.isEmpty), false)
+ *
+ * @since 2.10.0
+ */
+export var isEmpty = function (s) { return s.length === 0; };
+/**
+ * Calculate the number of characters in a `string`.
+ *
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('abc', S.size), 3)
+ *
+ * @since 2.10.0
+ */
+export var size = function (s) { return s.length; };
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('abc', S.split('')), ['a', 'b', 'c'])
+ * assert.deepStrictEqual(pipe('', S.split('')), [''])
+ *
+ * @since 2.11.0
+ */
+export var split = function (separator) {
+    return function (s) {
+        var out = s.split(separator);
+        return isNonEmpty(out) ? out : [s];
+    };
+};
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('abc', S.includes('b')), true)
+ * assert.deepStrictEqual(pipe('abc', S.includes('d')), false)
+ *
+ * @since 2.11.0
+ */
+export var includes = function (searchString, position) {
+    return function (s) {
+        return s.includes(searchString, position);
+    };
+};
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('abc', S.startsWith('a')), true)
+ * assert.deepStrictEqual(pipe('bc', S.startsWith('a')), false)
+ *
+ * @since 2.11.0
+ */
+export var startsWith = function (searchString, position) {
+    return function (s) {
+        return s.startsWith(searchString, position);
+    };
+};
+/**
+ * @example
+ * import * as S from 'fp-ts/string'
+ * import { pipe } from 'fp-ts/function'
+ *
+ * assert.deepStrictEqual(pipe('abc', S.endsWith('c')), true)
+ * assert.deepStrictEqual(pipe('ab', S.endsWith('c')), false)
+ *
+ * @since 2.11.0
+ */
+export var endsWith = function (searchString, position) {
+    return function (s) {
+        return s.endsWith(searchString, position);
+    };
+};