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

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

@@ -0,0 +1,189 @@
+"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.right = right;
+exports.left = left;
+exports.rightF = rightF;
+exports.leftF = leftF;
+exports.fromNullable = fromNullable;
+exports.fromNullableK = fromNullableK;
+exports.chainNullableK = chainNullableK;
+exports.map = map;
+exports.ap = ap;
+exports.chain = chain;
+exports.flatMap = flatMap;
+exports.alt = alt;
+exports.bimap = bimap;
+exports.mapBoth = mapBoth;
+exports.mapLeft = mapLeft;
+exports.mapError = mapError;
+exports.altValidation = altValidation;
+exports.match = match;
+exports.matchE = matchE;
+exports.getOrElse = getOrElse;
+exports.orElse = orElse;
+exports.orElseFirst = orElseFirst;
+exports.tapError = tapError;
+exports.orLeft = orLeft;
+exports.swap = swap;
+exports.toUnion = toUnion;
+exports.getEitherM = getEitherM;
+var Apply_1 = require("./Apply");
+var E = __importStar(require("./Either"));
+var function_1 = require("./function");
+var Functor_1 = require("./Functor");
+function right(F) {
+    return (0, function_1.flow)(E.right, F.of);
+}
+function left(F) {
+    return (0, function_1.flow)(E.left, F.of);
+}
+function rightF(F) {
+    return function (fa) { return F.map(fa, E.right); };
+}
+function leftF(F) {
+    return function (fe) { return F.map(fe, E.left); };
+}
+function fromNullable(F) {
+    return function (e) { return (0, function_1.flow)(E.fromNullable(e), F.of); };
+}
+function fromNullableK(F) {
+    var fromNullableF = fromNullable(F);
+    return function (e) {
+        var fromNullableFE = fromNullableF(e);
+        return function (f) { return (0, function_1.flow)(f, fromNullableFE); };
+    };
+}
+function chainNullableK(M) {
+    var chainM = chain(M);
+    var fromNullableKM = fromNullableK(M);
+    return function (e) {
+        var fromNullableKMe = fromNullableKM(e);
+        return function (f) { return chainM(fromNullableKMe(f)); };
+    };
+}
+function map(F) {
+    return (0, Functor_1.map)(F, E.Functor);
+}
+function ap(F) {
+    return (0, Apply_1.ap)(F, E.Apply);
+}
+function chain(M) {
+    var flatMapM = flatMap(M);
+    return function (f) { return function (ma) { return flatMapM(ma, f); }; };
+}
+/** @internal */
+function flatMap(M) {
+    return function (ma, f) { return M.chain(ma, function (e) { return (E.isLeft(e) ? M.of(e) : f(e.right)); }); };
+}
+function alt(M) {
+    return function (second) { return function (first) { return M.chain(first, function (e) { return (E.isLeft(e) ? second() : M.of(e)); }); }; };
+}
+function bimap(F) {
+    var mapBothF = mapBoth(F);
+    return function (f, g) { return function (self) { return mapBothF(self, f, g); }; };
+}
+/** @internal */
+function mapBoth(F) {
+    return function (self, f, g) { return F.map(self, E.bimap(f, g)); };
+}
+function mapLeft(F) {
+    var mapErrorF = mapError(F);
+    return function (f) { return function (self) { return mapErrorF(self, f); }; };
+}
+/** @internal */
+function mapError(F) {
+    return function (self, f) { return F.map(self, E.mapLeft(f)); };
+}
+function altValidation(M, S) {
+    return function (second) { return function (first) {
+        return M.chain(first, E.match(function (e1) {
+            return M.map(second(), E.mapLeft(function (e2) { return S.concat(e1, e2); }));
+        }, right(M)));
+    }; };
+}
+function match(F) {
+    return function (onLeft, onRight) { return function (ma) { return F.map(ma, E.match(onLeft, onRight)); }; };
+}
+function matchE(M) {
+    return function (onLeft, onRight) { return function (ma) { return M.chain(ma, E.match(onLeft, onRight)); }; };
+}
+function getOrElse(M) {
+    return function (onLeft) { return function (ma) { return M.chain(ma, E.match(onLeft, M.of)); }; };
+}
+function orElse(M) {
+    return function (onLeft) { return function (ma) { return M.chain(ma, function (e) { return (E.isLeft(e) ? onLeft(e.left) : M.of(e)); }); }; };
+}
+function orElseFirst(M) {
+    var tapErrorM = tapError(M);
+    return function (onLeft) { return function (ma) { return tapErrorM(ma, onLeft); }; };
+}
+/** @internal */
+function tapError(M) {
+    var orElseM = orElse(M);
+    return function (ma, onLeft) {
+        return (0, function_1.pipe)(ma, orElseM(function (e) { return M.map(onLeft(e), function (eb) { return (E.isLeft(eb) ? eb : E.left(e)); }); }));
+    };
+}
+function orLeft(M) {
+    return function (onLeft) { return function (ma) {
+        return M.chain(ma, E.match(function (e) { return M.map(onLeft(e), E.left); }, function (a) { return M.of(E.right(a)); }));
+    }; };
+}
+function swap(F) {
+    return function (ma) { return F.map(ma, E.swap); };
+}
+function toUnion(F) {
+    return function (fa) { return F.map(fa, E.toUnion); };
+}
+/** @deprecated  */
+/* istanbul ignore next */
+function getEitherM(M) {
+    var _ap = ap(M);
+    var _map = map(M);
+    var _chain = chain(M);
+    var _alt = alt(M);
+    var _bimap = bimap(M);
+    var _mapLeft = mapLeft(M);
+    var _fold = matchE(M);
+    var _getOrElse = getOrElse(M);
+    var _orElse = orElse(M);
+    return {
+        map: function (fa, f) { return (0, function_1.pipe)(fa, _map(f)); },
+        ap: function (fab, fa) { return (0, function_1.pipe)(fab, _ap(fa)); },
+        of: right(M),
+        chain: function (ma, f) { return (0, function_1.pipe)(ma, _chain(f)); },
+        alt: function (fa, that) { return (0, function_1.pipe)(fa, _alt(that)); },
+        bimap: function (fea, f, g) { return (0, function_1.pipe)(fea, _bimap(f, g)); },
+        mapLeft: function (fea, f) { return (0, function_1.pipe)(fea, _mapLeft(f)); },
+        fold: function (fa, onLeft, onRight) { return (0, function_1.pipe)(fa, _fold(onLeft, onRight)); },
+        getOrElse: function (fa, onLeft) { return (0, function_1.pipe)(fa, _getOrElse(onLeft)); },
+        orElse: function (fa, f) { return (0, function_1.pipe)(fa, _orElse(f)); },
+        swap: swap(M),
+        rightM: rightF(M),
+        leftM: leftF(M),
+        left: left(M)
+    };
+}

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

@@ -0,0 +1,40 @@
+/**
+ * @since 2.11.0
+ */
+import { Monoid } from './Monoid'
+import { Semigroup } from './Semigroup'
+/**
+ * @since 2.11.0
+ */
+export interface Endomorphism<A> {
+  (a: A): A
+}
+/**
+ * @category type lambdas
+ * @since 2.11.0
+ */
+export declare const URI = 'Endomorphism'
+/**
+ * @category type lambdas
+ * @since 2.11.0
+ */
+export type URI = typeof URI
+declare module './HKT' {
+  interface URItoKind<A> {
+    readonly [URI]: Endomorphism<A>
+  }
+}
+/**
+ * Endomorphism form a `Semigroup` where the `concat` operation is the usual function composition.
+ *
+ * @category instances
+ * @since 2.11.0
+ */
+export declare const getSemigroup: <A = never>() => Semigroup<Endomorphism<A>>
+/**
+ * Endomorphism form a `Monoid` where the `empty` value is the `identity` function.
+ *
+ * @category instances
+ * @since 2.11.0
+ */
+export declare const getMonoid: <A = never>() => Monoid<Endomorphism<A>>

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

@@ -0,0 +1,33 @@
+"use strict";
+/**
+ * @since 2.11.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMonoid = exports.getSemigroup = exports.URI = void 0;
+var function_1 = require("./function");
+/**
+ * @category type lambdas
+ * @since 2.11.0
+ */
+exports.URI = 'Endomorphism';
+/**
+ * Endomorphism form a `Semigroup` where the `concat` operation is the usual function composition.
+ *
+ * @category instances
+ * @since 2.11.0
+ */
+var getSemigroup = function () { return ({
+    concat: function (first, second) { return (0, function_1.flow)(first, second); }
+}); };
+exports.getSemigroup = getSemigroup;
+/**
+ * Endomorphism form a `Monoid` where the `empty` value is the `identity` function.
+ *
+ * @category instances
+ * @since 2.11.0
+ */
+var getMonoid = function () { return ({
+    concat: (0, exports.getSemigroup)().concat,
+    empty: function_1.identity
+}); };
+exports.getMonoid = getMonoid;

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

@@ -0,0 +1,206 @@
+/**
+ * The `Eq` type class represents types which support decidable equality.
+ *
+ * Instances must satisfy the following laws:
+ *
+ * 1. Reflexivity: `E.equals(a, a) === true`
+ * 2. Symmetry: `E.equals(a, b) === E.equals(b, a)`
+ * 3. Transitivity: if `E.equals(a, b) === true` and `E.equals(b, c) === true`, then `E.equals(a, c) === true`
+ *
+ * @since 2.0.0
+ */
+import { Contravariant1 } from './Contravariant'
+import { Monoid } from './Monoid'
+import { ReadonlyRecord } from './ReadonlyRecord'
+import { Semigroup } from './Semigroup'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Eq<A> {
+  readonly equals: (x: A, y: A) => boolean
+}
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+export declare const fromEquals: <A>(equals: Eq<A>['equals']) => Eq<A>
+/**
+ * @since 2.10.0
+ */
+export declare const struct: <A>(eqs: { [K in keyof A]: Eq<A[K]> }) => Eq<{ readonly [K in keyof A]: A[K] }>
+/**
+ * Given a tuple of `Eq`s returns a `Eq` for the tuple
+ *
+ * @example
+ * import { tuple } from 'fp-ts/Eq'
+ * import * as S from 'fp-ts/string'
+ * import * as N from 'fp-ts/number'
+ * import * as B from 'fp-ts/boolean'
+ *
+ * const E = tuple(S.Eq, N.Eq, B.Eq)
+ * assert.strictEqual(E.equals(['a', 1, true], ['a', 1, true]), true)
+ * assert.strictEqual(E.equals(['a', 1, true], ['b', 1, true]), false)
+ * assert.strictEqual(E.equals(['a', 1, true], ['a', 2, true]), false)
+ * assert.strictEqual(E.equals(['a', 1, true], ['a', 1, false]), false)
+ *
+ * @since 2.10.0
+ */
+export declare const tuple: <A extends ReadonlyArray<unknown>>(...eqs: { [K in keyof A]: Eq<A[K]> }) => Eq<Readonly<A>>
+/**
+ * A typical use case for `contramap` would be like, given some `User` type, to construct an `Eq<User>`.
+ *
+ * We can do so with a function from `User -> X` where `X` is some value that we know how to compare
+ * for equality (meaning we have an `Eq<X>`)
+ *
+ * For example, given the following `User` type, we want to construct an `Eq<User>` that just looks at the `key` field
+ * for each user (since it's known to be unique).
+ *
+ * If we have a way of comparing `UUID`s for equality (`eqUUID: Eq<UUID>`) and we know how to go from `User -> UUID`,
+ * using `contramap` we can do this
+ *
+ * @example
+ * import { contramap, Eq } from 'fp-ts/Eq'
+ * import { pipe } from 'fp-ts/function'
+ * import * as S from 'fp-ts/string'
+ *
+ * type UUID = string
+ *
+ * interface User {
+ *   readonly key: UUID
+ *   readonly firstName: string
+ *   readonly lastName: string
+ * }
+ *
+ * const eqUUID: Eq<UUID> = S.Eq
+ *
+ * const eqUserByKey: Eq<User> = pipe(
+ *   eqUUID,
+ *   contramap((user) => user.key)
+ * )
+ *
+ * assert.deepStrictEqual(
+ *   eqUserByKey.equals(
+ *     { key: 'k1', firstName: 'a1', lastName: 'b1' },
+ *     { key: 'k2', firstName: 'a1', lastName: 'b1' }
+ *   ),
+ *   false
+ * )
+ * assert.deepStrictEqual(
+ *   eqUserByKey.equals(
+ *     { key: 'k1', firstName: 'a1', lastName: 'b1' },
+ *     { key: 'k1', firstName: 'a2', lastName: 'b1' }
+ *   ),
+ *   true
+ * )
+ *
+ * @since 2.0.0
+ */
+export declare const contramap: <A, B>(f: (b: B) => A) => (fa: Eq<A>) => Eq<B>
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+export declare const URI = 'Eq'
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+export type URI = typeof URI
+declare module './HKT' {
+  interface URItoKind<A> {
+    readonly [URI]: Eq<A>
+  }
+}
+/**
+ * @category instances
+ * @since 2.5.0
+ */
+export declare const eqStrict: Eq<unknown>
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+export declare const getSemigroup: <A>() => Semigroup<Eq<A>>
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+export declare const getMonoid: <A>() => Monoid<Eq<A>>
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+export declare const Contravariant: Contravariant1<URI>
+/**
+ * Use [`tuple`](#tuple) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getTupleEq: <T extends ReadonlyArray<Eq<any>>>(
+  ...eqs: T
+) => Eq<{
+  [K in keyof T]: T[K] extends Eq<infer A> ? A : never
+}>
+/**
+ * Use [`struct`](#struct) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const getStructEq: <O extends ReadonlyRecord<string, any>>(eqs: {
+  [K in keyof O]: Eq<O[K]>
+}) => Eq<O>
+/**
+ * Use [`eqStrict`](#eqstrict) instead
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const strictEqual: <A>(a: A, b: A) => boolean
+/**
+ * This instance is deprecated, use small, specific instances instead.
+ * For example if a function needs a `Contravariant` instance, pass `E.Contravariant` instead of `E.eq`
+ * (where `E` is from `import E from 'fp-ts/Eq'`)
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const eq: Contravariant1<URI>
+/**
+ * Use [`Eq`](./boolean.ts.html#eq) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const eqBoolean: Eq<boolean>
+/**
+ * Use [`Eq`](./string.ts.html#eq) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const eqString: Eq<string>
+/**
+ * Use [`Eq`](./number.ts.html#eq) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const eqNumber: Eq<number>
+/**
+ * Use [`Eq`](./Date.ts.html#eq) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const eqDate: Eq<Date>

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

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eqDate = exports.eqNumber = exports.eqString = exports.eqBoolean = exports.eq = exports.strictEqual = exports.getStructEq = exports.getTupleEq = exports.Contravariant = exports.getMonoid = exports.getSemigroup = exports.eqStrict = exports.URI = exports.contramap = exports.tuple = exports.struct = exports.fromEquals = void 0;
+var function_1 = require("./function");
+// -------------------------------------------------------------------------------------
+// constructors
+// -------------------------------------------------------------------------------------
+/**
+ * @category constructors
+ * @since 2.0.0
+ */
+var fromEquals = function (equals) { return ({
+    equals: function (x, y) { return x === y || equals(x, y); }
+}); };
+exports.fromEquals = fromEquals;
+// -------------------------------------------------------------------------------------
+// combinators
+// -------------------------------------------------------------------------------------
+/**
+ * @since 2.10.0
+ */
+var struct = function (eqs) {
+    return (0, exports.fromEquals)(function (first, second) {
+        for (var key in eqs) {
+            if (!eqs[key].equals(first[key], second[key])) {
+                return false;
+            }
+        }
+        return true;
+    });
+};
+exports.struct = struct;
+/**
+ * Given a tuple of `Eq`s returns a `Eq` for the tuple
+ *
+ * @example
+ * import { tuple } from 'fp-ts/Eq'
+ * import * as S from 'fp-ts/string'
+ * import * as N from 'fp-ts/number'
+ * import * as B from 'fp-ts/boolean'
+ *
+ * const E = tuple(S.Eq, N.Eq, B.Eq)
+ * assert.strictEqual(E.equals(['a', 1, true], ['a', 1, true]), true)
+ * assert.strictEqual(E.equals(['a', 1, true], ['b', 1, true]), false)
+ * assert.strictEqual(E.equals(['a', 1, true], ['a', 2, true]), false)
+ * assert.strictEqual(E.equals(['a', 1, true], ['a', 1, false]), false)
+ *
+ * @since 2.10.0
+ */
+var tuple = function () {
+    var eqs = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        eqs[_i] = arguments[_i];
+    }
+    return (0, exports.fromEquals)(function (first, second) { return eqs.every(function (E, i) { return E.equals(first[i], second[i]); }); });
+};
+exports.tuple = tuple;
+/* istanbul ignore next */
+var contramap_ = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.contramap)(f)); };
+/**
+ * A typical use case for `contramap` would be like, given some `User` type, to construct an `Eq<User>`.
+ *
+ * We can do so with a function from `User -> X` where `X` is some value that we know how to compare
+ * for equality (meaning we have an `Eq<X>`)
+ *
+ * For example, given the following `User` type, we want to construct an `Eq<User>` that just looks at the `key` field
+ * for each user (since it's known to be unique).
+ *
+ * If we have a way of comparing `UUID`s for equality (`eqUUID: Eq<UUID>`) and we know how to go from `User -> UUID`,
+ * using `contramap` we can do this
+ *
+ * @example
+ * import { contramap, Eq } from 'fp-ts/Eq'
+ * import { pipe } from 'fp-ts/function'
+ * import * as S from 'fp-ts/string'
+ *
+ * type UUID = string
+ *
+ * interface User {
+ *   readonly key: UUID
+ *   readonly firstName: string
+ *   readonly lastName: string
+ * }
+ *
+ * const eqUUID: Eq<UUID> = S.Eq
+ *
+ * const eqUserByKey: Eq<User> = pipe(
+ *   eqUUID,
+ *   contramap((user) => user.key)
+ * )
+ *
+ * assert.deepStrictEqual(
+ *   eqUserByKey.equals(
+ *     { key: 'k1', firstName: 'a1', lastName: 'b1' },
+ *     { key: 'k2', firstName: 'a1', lastName: 'b1' }
+ *   ),
+ *   false
+ * )
+ * assert.deepStrictEqual(
+ *   eqUserByKey.equals(
+ *     { key: 'k1', firstName: 'a1', lastName: 'b1' },
+ *     { key: 'k1', firstName: 'a2', lastName: 'b1' }
+ *   ),
+ *   true
+ * )
+ *
+ * @since 2.0.0
+ */
+var contramap = function (f) { return function (fa) {
+    return (0, exports.fromEquals)(function (x, y) { return fa.equals(f(x), f(y)); });
+}; };
+exports.contramap = contramap;
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+exports.URI = 'Eq';
+/**
+ * @category instances
+ * @since 2.5.0
+ */
+exports.eqStrict = {
+    equals: function (a, b) { return a === b; }
+};
+var empty = {
+    equals: function () { return true; }
+};
+/**
+ * @category instances
+ * @since 2.10.0
+ */
+var getSemigroup = function () { return ({
+    concat: function (x, y) { return (0, exports.fromEquals)(function (a, b) { return x.equals(a, b) && y.equals(a, b); }); }
+}); };
+exports.getSemigroup = getSemigroup;
+/**
+ * @category instances
+ * @since 2.6.0
+ */
+var getMonoid = function () { return ({
+    concat: (0, exports.getSemigroup)().concat,
+    empty: empty
+}); };
+exports.getMonoid = getMonoid;
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+exports.Contravariant = {
+    URI: exports.URI,
+    contramap: contramap_
+};
+// -------------------------------------------------------------------------------------
+// deprecated
+// -------------------------------------------------------------------------------------
+/**
+ * Use [`tuple`](#tuple) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+exports.getTupleEq = exports.tuple;
+/**
+ * Use [`struct`](#struct) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+exports.getStructEq = exports.struct;
+/**
+ * Use [`eqStrict`](#eqstrict) instead
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+exports.strictEqual = exports.eqStrict.equals;
+/**
+ * This instance is deprecated, use small, specific instances instead.
+ * For example if a function needs a `Contravariant` instance, pass `E.Contravariant` instead of `E.eq`
+ * (where `E` is from `import E from 'fp-ts/Eq'`)
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+exports.eq = exports.Contravariant;
+/**
+ * Use [`Eq`](./boolean.ts.html#eq) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+exports.eqBoolean = exports.eqStrict;
+/**
+ * Use [`Eq`](./string.ts.html#eq) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+exports.eqString = exports.eqStrict;
+/**
+ * Use [`Eq`](./number.ts.html#eq) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+exports.eqNumber = exports.eqStrict;
+/**
+ * Use [`Eq`](./Date.ts.html#eq) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+exports.eqDate = {
+    equals: function (first, second) { return first.valueOf() === second.valueOf(); }
+};