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

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

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endsWith = exports.startsWith = exports.includes = exports.split = exports.size = exports.isEmpty = exports.slice = exports.trimRight = exports.trimLeft = exports.trim = exports.replace = exports.toLowerCase = exports.toUpperCase = exports.isString = exports.Show = exports.Ord = exports.Monoid = exports.empty = exports.Semigroup = exports.Eq = void 0;
+var ReadonlyNonEmptyArray_1 = require("./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
+ */
+exports.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
+ */
+exports.Semigroup = {
+    concat: function (first, second) { return first + second; }
+};
+/**
+ * An empty `string`.
+ *
+ * @since 2.10.0
+ */
+exports.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
+ */
+exports.Monoid = {
+    concat: exports.Semigroup.concat,
+    empty: exports.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
+ */
+exports.Ord = {
+    equals: exports.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
+ */
+exports.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
+ */
+var isString = function (u) { return typeof u === 'string'; };
+exports.isString = isString;
+// -------------------------------------------------------------------------------------
+// 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
+ */
+var toUpperCase = function (s) { return s.toUpperCase(); };
+exports.toUpperCase = 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
+ */
+var toLowerCase = function (s) { return s.toLowerCase(); };
+exports.toLowerCase = 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
+ */
+var replace = function (searchValue, replaceValue) {
+    return function (s) {
+        return s.replace(searchValue, replaceValue);
+    };
+};
+exports.replace = replace;
+/**
+ * @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
+ */
+var trim = function (s) { return s.trim(); };
+exports.trim = 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
+ */
+var trimLeft = function (s) { return s.trimLeft(); };
+exports.trimLeft = 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
+ */
+var trimRight = function (s) { return s.trimRight(); };
+exports.trimRight = 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
+ */
+var slice = function (start, end) {
+    return function (s) {
+        return s.slice(start, end);
+    };
+};
+exports.slice = slice;
+// -------------------------------------------------------------------------------------
+// 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
+ */
+var isEmpty = function (s) { return s.length === 0; };
+exports.isEmpty = isEmpty;
+/**
+ * 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
+ */
+var size = function (s) { return s.length; };
+exports.size = size;
+/**
+ * @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
+ */
+var split = function (separator) {
+    return function (s) {
+        var out = s.split(separator);
+        return (0, ReadonlyNonEmptyArray_1.isNonEmpty)(out) ? out : [s];
+    };
+};
+exports.split = split;
+/**
+ * @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
+ */
+var includes = function (searchString, position) {
+    return function (s) {
+        return s.includes(searchString, position);
+    };
+};
+exports.includes = includes;
+/**
+ * @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
+ */
+var startsWith = function (searchString, position) {
+    return function (s) {
+        return s.startsWith(searchString, position);
+    };
+};
+exports.startsWith = startsWith;
+/**
+ * @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
+ */
+var endsWith = function (searchString, position) {
+    return function (s) {
+        return s.endsWith(searchString, position);
+    };
+};
+exports.endsWith = endsWith;

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

@@ -0,0 +1,42 @@
+import { Semigroup } from './Semigroup'
+/**
+ * Return a semigroup which works like `Object.assign`.
+ *
+ * @example
+ * import { getAssignSemigroup } from 'fp-ts/struct'
+ *
+ * interface Person {
+ *   readonly name: string
+ *   readonly age: number
+ * }
+ *
+ * const S = getAssignSemigroup<Person>()
+ * assert.deepStrictEqual(S.concat({ name: 'name', age: 23 }, { name: 'name', age: 24 }), { name: 'name', age: 24 })
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+export declare const getAssignSemigroup: <A extends object = never>() => Semigroup<A>
+/**
+ * Creates a new object by recursively evolving a shallow copy of `a`, according to the `transformation` functions.
+ *
+ * @example
+ * import { pipe } from 'fp-ts/function'
+ * import { evolve } from 'fp-ts/struct'
+ *
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     { a: 'a', b: 1 },
+ *     evolve({
+ *       a: (a) => a.length,
+ *       b: (b) => b * 2
+ *     })
+ *   ),
+ *   { a: 1, b: 2 }
+ * )
+ *
+ * @since 2.11.0
+ */
+export declare const evolve: <A, F extends { [K in keyof A]: (a: A[K]) => unknown }>(
+  transformations: F
+) => (a: A) => { [K in keyof F]: ReturnType<F[K]> }

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/lib/struct.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.evolve = exports.getAssignSemigroup = void 0;
+/**
+ * @since 2.10.0
+ */
+var _ = __importStar(require("./internal"));
+// -------------------------------------------------------------------------------------
+// instances
+// -------------------------------------------------------------------------------------
+/**
+ * Return a semigroup which works like `Object.assign`.
+ *
+ * @example
+ * import { getAssignSemigroup } from 'fp-ts/struct'
+ *
+ * interface Person {
+ *   readonly name: string
+ *   readonly age: number
+ * }
+ *
+ * const S = getAssignSemigroup<Person>()
+ * assert.deepStrictEqual(S.concat({ name: 'name', age: 23 }, { name: 'name', age: 24 }), { name: 'name', age: 24 })
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+var getAssignSemigroup = function () { return ({
+    concat: function (first, second) { return Object.assign({}, first, second); }
+}); };
+exports.getAssignSemigroup = getAssignSemigroup;
+// -------------------------------------------------------------------------------------
+// utils
+// -------------------------------------------------------------------------------------
+/**
+ * Creates a new object by recursively evolving a shallow copy of `a`, according to the `transformation` functions.
+ *
+ * @example
+ * import { pipe } from 'fp-ts/function'
+ * import { evolve } from 'fp-ts/struct'
+ *
+ * assert.deepStrictEqual(
+ *   pipe(
+ *     { a: 'a', b: 1 },
+ *     evolve({
+ *       a: (a) => a.length,
+ *       b: (b) => b * 2
+ *     })
+ *   ),
+ *   { a: 1, b: 2 }
+ * )
+ *
+ * @since 2.11.0
+ */
+var evolve = function (transformations) {
+    return function (a) {
+        var out = {};
+        for (var k in a) {
+            if (_.has.call(a, k)) {
+                out[k] = transformations[k](a[k]);
+            }
+        }
+        return out;
+    };
+};
+exports.evolve = evolve;

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

@@ -0,0 +1,15 @@
+/**
+ * @since 2.11.0
+ */
+import * as M from './Monoid'
+import * as Se from './Semigroup'
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export declare const Semigroup: Se.Semigroup<void>
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+export declare const Monoid: M.Monoid<void>

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

@@ -0,0 +1,43 @@
+"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.Monoid = exports.Semigroup = void 0;
+var Se = __importStar(require("./Semigroup"));
+// -------------------------------------------------------------------------------------
+// instances
+// -------------------------------------------------------------------------------------
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+exports.Semigroup = Se.constant(undefined);
+/**
+ * @category instances
+ * @since 2.11.0
+ */
+exports.Monoid = {
+    concat: exports.Semigroup.concat,
+    empty: undefined
+};

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/number/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../lib/number.js",
+  "module": "../es6/number.js",
+  "typings": "../lib/number.d.ts",
+  "sideEffects": false
+}

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "fp-ts",
+  "version": "2.16.11",
+  "description": "Functional programming in TypeScript",
+  "main": "./lib/index.js",
+  "module": "./es6/index.js",
+  "typings": "lib/index.d.ts",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gcanti/fp-ts.git"
+  },
+  "author": "Giulio Canti <giulio.canti@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/gcanti/fp-ts/issues"
+  },
+  "homepage": "https://github.com/gcanti/fp-ts",
+  "tags": [
+    "typescript",
+    "algebraic-data-types",
+    "functional-programming"
+  ],
+  "keywords": [
+    "typescript",
+    "algebraic-data-types",
+    "functional-programming"
+  ]
+}

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

@@ -0,0 +1,6 @@
+{
+  "main": "../lib/pipeable.js",
+  "module": "../es6/pipeable.js",
+  "typings": "../lib/pipeable.d.ts",
+  "sideEffects": false
+}

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

@@ -0,0 +1,6 @@
+{
+  "main": "../lib/string.js",
+  "module": "../es6/string.js",
+  "typings": "../lib/string.d.ts",
+  "sideEffects": false
+}

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/struct/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../lib/struct.js",
+  "module": "../es6/struct.js",
+  "typings": "../lib/struct.d.ts",
+  "sideEffects": false
+}

package/dist/layers/baseLayer/nodejs/node_modules/fp-ts/void/package.json

@@ -0,0 +1,6 @@
+{
+  "main": "../lib/void.js",
+  "module": "../es6/void.js",
+  "typings": "../lib/void.d.ts",
+  "sideEffects": false
+}

package/dist/layers/baseLayer/nodejs/node_modules/id128/CHANGES

@@ -0,0 +1,20 @@
+- 0.1.0 : Move extraneous exports from index.js into utils.js.
+- 0.2.0 : Add browser support for Browserify/Webpack.
+- 0.3.0 : Pass named arguments to .generate instead of positional.
+- 1.0.0 : Added support for Uuid V1 and extracted competitive benchmarks.
+- 1.0.1 : Remove lockfile from release.
+- 1.0.2 : Fix bad version push.
+- 1.0.3 : Delete the extra benchmarks for real.
+- 1.1.0 : Performance improvements and renamed resetClockSequence to reset.
+- 1.1.1 : Fixed repo link.
+- 1.2.0 : Added generic UUID factory.
+- 1.3.0 : Added UUID V6 support.
+- 1.4.0 : Exposed encoding verifiers.
+- 1.5.0 : Fixed benchmarks and added support for node +12.5.
+- 1.6.0 : Added Typescript support and top-level id comparators.
+- 1.6.1 : Tweaked random memory allocation and updated benchmarks.
+- 1.6.2 : Fixed docs
+- 1.6.3 : Fixed memory profile by reusing the buffer of random.
+- 1.6.4 : Fixed worker support
+- 1.6.5 : Removed erroneous packaged files
+- 1.6.6 : Fix CHANGES and add credit for worker support

package/dist/layers/baseLayer/nodejs/node_modules/id128/LICENSE

@@ -0,0 +1,18 @@
+Copyright 2018 Aaron Cohen <aarondcohen@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.