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

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

@@ -0,0 +1,313 @@
+/**
+ * The state monad transformer. It can be used to add state to other monads.
+ *
+ * The `of` function leaves the state unchanged, while `chain` uses the final state of the first computation
+ * as the initial state of the second.
+ *
+ * @since 2.0.0
+ */
+import { Chain, Chain1, Chain2, Chain2C, Chain3, Chain3C } from './Chain'
+import { Functor, Functor1, Functor2, Functor2C, Functor3, Functor3C } from './Functor'
+import { HKT, Kind, Kind2, Kind3, URIS, URIS2, URIS3 } from './HKT'
+import { Monad, Monad1, Monad2, Monad2C, Monad3, Monad3C } from './Monad'
+import { Pointed, Pointed1, Pointed2, Pointed2C, Pointed3, Pointed3C } from './Pointed'
+import { State } from './State'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface StateT<M, S, A> {
+  (s: S): HKT<M, [A, S]>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface StateT1<M extends URIS, S, A> {
+  (s: S): Kind<M, [A, S]>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface StateT2<M extends URIS2, S, E, A> {
+  (s: S): Kind2<M, E, [A, S]>
+}
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface StateT3<M extends URIS3, S, R, E, A> {
+  (s: S): Kind3<M, R, E, [A, S]>
+}
+/**
+ * @since 2.10.0
+ */
+export declare function of<F extends URIS3>(F: Pointed3<F>): <A, S, R, E>(a: A) => StateT3<F, S, R, E, A>
+export declare function of<F extends URIS3, E>(F: Pointed3C<F, E>): <A, S, R>(a: A) => StateT3<F, S, R, E, A>
+export declare function of<F extends URIS2>(F: Pointed2<F>): <A, S, E>(a: A) => StateT2<F, S, E, A>
+export declare function of<F extends URIS2, E>(F: Pointed2C<F, E>): <A, S>(a: A) => StateT2<F, S, E, A>
+export declare function of<F extends URIS>(F: Pointed1<F>): <A, S>(a: A) => StateT1<F, S, A>
+export declare function of<F>(F: Pointed<F>): <A, S>(a: A) => StateT<F, S, A>
+/**
+ * @since 2.10.0
+ */
+export declare function map<F extends URIS3>(
+  F: Functor3<F>
+): <A, B>(f: (a: A) => B) => <S, R, E>(fa: StateT3<F, S, R, E, A>) => StateT3<F, S, R, E, B>
+export declare function map<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <A, B>(f: (a: A) => B) => <S, R>(fa: StateT3<F, S, R, E, A>) => StateT3<F, S, R, E, B>
+export declare function map<F extends URIS2>(
+  F: Functor2<F>
+): <A, B>(f: (a: A) => B) => <S, E>(fa: StateT2<F, S, E, A>) => StateT2<F, S, E, B>
+export declare function map<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <A, B>(f: (a: A) => B) => <S>(fa: StateT2<F, S, E, A>) => StateT2<F, S, E, B>
+export declare function map<F extends URIS>(
+  F: Functor1<F>
+): <A, B>(f: (a: A) => B) => <S>(fa: StateT1<F, S, A>) => StateT1<F, S, B>
+export declare function map<F>(F: Functor<F>): <A, B>(f: (a: A) => B) => <S>(fa: StateT<F, S, A>) => StateT<F, S, B>
+/**
+ * @since 2.10.0
+ */
+export declare function ap<M extends URIS3>(
+  M: Chain3<M>
+): <S, R, E, A>(fa: StateT3<M, S, R, E, A>) => <B>(fab: StateT3<M, S, R, E, (a: A) => B>) => StateT3<M, S, R, E, B>
+export declare function ap<M extends URIS3, E>(
+  M: Chain3C<M, E>
+): <S, R, A>(fa: StateT3<M, S, R, E, A>) => <B>(fab: StateT3<M, S, R, E, (a: A) => B>) => StateT3<M, S, R, E, B>
+export declare function ap<M extends URIS2>(
+  M: Chain2<M>
+): <S, E, A>(fa: StateT2<M, S, E, A>) => <B>(fab: StateT2<M, S, E, (a: A) => B>) => StateT2<M, S, E, B>
+export declare function ap<M extends URIS2, E>(
+  M: Chain2C<M, E>
+): <S, A>(fa: StateT2<M, S, E, A>) => <B>(fab: StateT2<M, S, E, (a: A) => B>) => StateT2<M, S, E, B>
+export declare function ap<M extends URIS>(
+  M: Chain1<M>
+): <S, A>(fa: StateT1<M, S, A>) => <B>(fab: StateT1<M, S, (a: A) => B>) => StateT1<M, S, B>
+export declare function ap<M>(
+  M: Chain<M>
+): <S, A>(fa: StateT<M, S, A>) => <B>(fab: StateT<M, S, (a: A) => B>) => StateT<M, S, B>
+/**
+ * @since 2.10.0
+ */
+export declare function chain<M extends URIS3>(
+  M: Chain3<M>
+): <A, S, R, E, B>(f: (a: A) => StateT3<M, S, R, E, B>) => (ma: StateT3<M, S, R, E, A>) => StateT3<M, S, R, E, B>
+export declare function chain<M extends URIS3, E>(
+  M: Chain3C<M, E>
+): <A, S, R, B>(f: (a: A) => StateT3<M, S, R, E, B>) => (ma: StateT3<M, S, R, E, A>) => StateT3<M, S, R, E, B>
+export declare function chain<M extends URIS2>(
+  M: Chain2<M>
+): <A, S, E, B>(f: (a: A) => StateT2<M, S, E, B>) => (ma: StateT2<M, S, E, A>) => StateT2<M, S, E, B>
+export declare function chain<M extends URIS2, E>(
+  M: Chain2C<M, E>
+): <A, S, B>(f: (a: A) => StateT2<M, S, E, B>) => (ma: StateT2<M, S, E, A>) => StateT2<M, S, E, B>
+export declare function chain<M extends URIS>(
+  M: Chain1<M>
+): <A, S, B>(f: (a: A) => StateT1<M, S, B>) => (ma: StateT1<M, S, A>) => StateT1<M, S, B>
+export declare function chain<M>(
+  M: Chain<M>
+): <A, S, B>(f: (a: A) => StateT<M, S, B>) => (ma: StateT<M, S, A>) => StateT<M, S, B>
+/**
+ * @since 2.10.0
+ */
+export declare function fromState<F extends URIS3>(
+  F: Pointed3<F>
+): <S, A, R, E>(sa: State<S, A>) => StateT3<F, S, R, E, A>
+export declare function fromState<F extends URIS3, E>(
+  F: Pointed3C<F, E>
+): <S, A, R>(sa: State<S, A>) => StateT3<F, S, R, E, A>
+export declare function fromState<F extends URIS2>(F: Pointed2<F>): <S, A, E>(sa: State<S, A>) => StateT2<F, S, E, A>
+export declare function fromState<F extends URIS2, E>(
+  F: Pointed2C<F, E>
+): <S, A>(sa: State<S, A>) => StateT2<F, S, E, A>
+export declare function fromState<F extends URIS>(F: Pointed1<F>): <S, A>(sa: State<S, A>) => StateT1<F, S, A>
+export declare function fromState<F>(F: Pointed<F>): <S, A>(sa: State<S, A>) => StateT<F, S, A>
+/**
+ * @since 2.10.0
+ */
+export declare function fromF<F extends URIS3>(
+  F: Functor3<F>
+): <R, E, A, S>(ma: Kind3<F, R, E, A>) => StateT3<F, S, R, E, A>
+export declare function fromF<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <R, A, S>(ma: Kind3<F, R, E, A>) => StateT3<F, S, R, E, A>
+export declare function fromF<F extends URIS2>(F: Functor2<F>): <E, A, S>(ma: Kind2<F, E, A>) => StateT2<F, S, E, A>
+export declare function fromF<F extends URIS2, E>(F: Functor2C<F, E>): <A, S>(ma: Kind2<F, E, A>) => StateT2<F, S, E, A>
+export declare function fromF<F extends URIS>(F: Functor1<F>): <A, S>(ma: Kind<F, A>) => StateT1<F, S, A>
+export declare function fromF<F>(F: Functor<F>): <A, S>(ma: HKT<F, A>) => StateT<F, S, A>
+/**
+ * @since 2.10.0
+ */
+export declare function evaluate<F extends URIS3>(
+  F: Functor3<F>
+): <S>(s: S) => <R, E, A>(ma: StateT3<F, S, R, E, A>) => Kind3<F, R, E, A>
+export declare function evaluate<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <S>(s: S) => <R, A>(ma: StateT3<F, S, R, E, A>) => Kind3<F, R, E, A>
+export declare function evaluate<F extends URIS2>(
+  F: Functor2<F>
+): <S>(s: S) => <E, A>(ma: StateT2<F, S, E, A>) => Kind2<F, E, A>
+export declare function evaluate<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <S>(s: S) => <A>(ma: StateT2<F, S, E, A>) => Kind2<F, E, A>
+export declare function evaluate<F extends URIS>(F: Functor1<F>): <S>(s: S) => <A>(ma: StateT1<F, S, A>) => Kind<F, A>
+export declare function evaluate<F>(F: Functor<F>): <S>(s: S) => <A>(ma: StateT<F, S, A>) => HKT<F, A>
+/**
+ * @since 2.10.0
+ */
+export declare function execute<F extends URIS3>(
+  F: Functor3<F>
+): <S>(s: S) => <R, E, A>(ma: StateT3<F, S, R, E, A>) => Kind3<F, R, E, S>
+export declare function execute<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <S>(s: S) => <R, A>(ma: StateT3<F, S, R, E, A>) => Kind3<F, R, E, S>
+export declare function execute<F extends URIS2>(
+  F: Functor2<F>
+): <S>(s: S) => <E, A>(ma: StateT2<F, S, E, A>) => Kind2<F, E, S>
+export declare function execute<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <S>(s: S) => <A>(ma: StateT2<F, S, E, A>) => Kind2<F, E, S>
+export declare function execute<F extends URIS>(F: Functor1<F>): <S>(s: S) => <A>(ma: StateT1<F, S, A>) => Kind<F, S>
+export declare function execute<F>(F: Functor<F>): <S>(s: S) => <A>(ma: StateT<F, S, A>) => HKT<F, S>
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface StateM<M> {
+  readonly map: <S, A, B>(fa: StateT<M, S, A>, f: (a: A) => B) => StateT<M, S, B>
+  readonly of: <S, A>(a: A) => StateT<M, S, A>
+  readonly ap: <S, A, B>(fab: StateT<M, S, (a: A) => B>, fa: StateT<M, S, A>) => StateT<M, S, B>
+  readonly chain: <S, A, B>(fa: StateT<M, S, A>, f: (a: A) => StateT<M, S, B>) => StateT<M, S, B>
+  readonly get: <S>() => StateT<M, S, S>
+  readonly put: <S>(s: S) => StateT<M, S, void>
+  readonly modify: <S>(f: (s: S) => S) => StateT<M, S, void>
+  readonly gets: <S, A>(f: (s: S) => A) => StateT<M, S, A>
+  readonly fromState: <S, A>(fa: State<S, A>) => StateT<M, S, A>
+  readonly fromM: <S, A>(ma: HKT<M, A>) => StateT<M, S, A>
+  readonly evalState: <S, A>(ma: StateT<M, S, A>, s: S) => HKT<M, A>
+  readonly execState: <S, A>(ma: StateT<M, S, A>, s: S) => HKT<M, S>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface StateM1<M extends URIS> {
+  readonly map: <S, A, B>(fa: StateT1<M, S, A>, f: (a: A) => B) => StateT1<M, S, B>
+  readonly of: <S, A>(a: A) => StateT1<M, S, A>
+  readonly ap: <S, A, B>(fab: StateT1<M, S, (a: A) => B>, fa: StateT1<M, S, A>) => StateT1<M, S, B>
+  readonly chain: <S, A, B>(fa: StateT1<M, S, A>, f: (a: A) => StateT1<M, S, B>) => StateT1<M, S, B>
+  readonly get: <S>() => StateT1<M, S, S>
+  readonly put: <S>(s: S) => StateT1<M, S, void>
+  readonly modify: <S>(f: (s: S) => S) => StateT1<M, S, void>
+  readonly gets: <S, A>(f: (s: S) => A) => StateT1<M, S, A>
+  readonly fromState: <S, A>(fa: State<S, A>) => StateT1<M, S, A>
+  readonly fromM: <S, A>(ma: Kind<M, A>) => StateT1<M, S, A>
+  readonly evalState: <S, A>(ma: StateT1<M, S, A>, s: S) => Kind<M, A>
+  readonly execState: <S, A>(ma: StateT1<M, S, A>, s: S) => Kind<M, S>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface StateM2<M extends URIS2> {
+  readonly map: <S, E, A, B>(fa: StateT2<M, S, E, A>, f: (a: A) => B) => StateT2<M, S, E, B>
+  readonly of: <S, E, A>(a: A) => StateT2<M, S, E, A>
+  readonly ap: <S, E, A, B>(fab: StateT2<M, S, E, (a: A) => B>, fa: StateT2<M, S, E, A>) => StateT2<M, S, E, B>
+  readonly chain: <S, E, A, B>(fa: StateT2<M, S, E, A>, f: (a: A) => StateT2<M, S, E, B>) => StateT2<M, S, E, B>
+  readonly get: <E, S>() => StateT2<M, S, E, S>
+  readonly put: <E, S>(s: S) => StateT2<M, S, E, void>
+  readonly modify: <E, S>(f: (s: S) => S) => StateT2<M, S, E, void>
+  readonly gets: <S, E, A>(f: (s: S) => A) => StateT2<M, S, E, A>
+  readonly fromState: <S, E, A>(fa: State<S, A>) => StateT2<M, S, E, A>
+  readonly fromM: <S, E, A>(ma: Kind2<M, E, A>) => StateT2<M, S, E, A>
+  readonly evalState: <S, E, A>(ma: StateT2<M, S, E, A>, s: S) => Kind2<M, E, A>
+  readonly execState: <S, E, A>(ma: StateT2<M, S, E, A>, s: S) => Kind2<M, E, S>
+}
+/**
+ * @category zone of death
+ * @since 2.5.4
+ * @deprecated
+ */
+export interface StateM2C<M extends URIS2, E> {
+  readonly map: <S, A, B>(fa: StateT2<M, S, E, A>, f: (a: A) => B) => StateT2<M, S, E, B>
+  readonly of: <S, A>(a: A) => StateT2<M, S, E, A>
+  readonly ap: <S, A, B>(fab: StateT2<M, S, E, (a: A) => B>, fa: StateT2<M, S, E, A>) => StateT2<M, S, E, B>
+  readonly chain: <S, A, B>(fa: StateT2<M, S, E, A>, f: (a: A) => StateT2<M, S, E, B>) => StateT2<M, S, E, B>
+  readonly get: <S>() => StateT2<M, S, E, S>
+  readonly put: <S>(s: S) => StateT2<M, S, E, void>
+  readonly modify: <S>(f: (s: S) => S) => StateT2<M, S, E, void>
+  readonly gets: <S, A>(f: (s: S) => A) => StateT2<M, S, E, A>
+  readonly fromState: <S, A>(fa: State<S, A>) => StateT2<M, S, E, A>
+  readonly fromM: <S, A>(ma: Kind2<M, E, A>) => StateT2<M, S, E, A>
+  readonly evalState: <S, A>(ma: StateT2<M, S, E, A>, s: S) => Kind2<M, E, A>
+  readonly execState: <S, A>(ma: StateT2<M, S, E, A>, s: S) => Kind2<M, E, S>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export interface StateM3<M extends URIS3> {
+  readonly map: <S, R, E, A, B>(fa: StateT3<M, S, R, E, A>, f: (a: A) => B) => StateT3<M, S, R, E, B>
+  readonly of: <S, R, E, A>(a: A) => StateT3<M, S, R, E, A>
+  readonly ap: <S, R, E, A, B>(
+    fab: StateT3<M, S, R, E, (a: A) => B>,
+    fa: StateT3<M, S, R, E, A>
+  ) => StateT3<M, S, R, E, B>
+  readonly chain: <S, R, E, A, B>(
+    fa: StateT3<M, S, R, E, A>,
+    f: (a: A) => StateT3<M, S, R, E, B>
+  ) => StateT3<M, S, R, E, B>
+  readonly get: <R, E, S>() => StateT3<M, S, R, E, S>
+  readonly put: <R, E, S>(s: S) => StateT3<M, S, R, E, void>
+  readonly modify: <R, E, S>(f: (s: S) => S) => StateT3<M, S, R, E, void>
+  readonly gets: <S, R, E, A>(f: (s: S) => A) => StateT3<M, S, R, E, A>
+  readonly fromState: <S, R, E, A>(fa: State<S, A>) => StateT3<M, S, R, E, A>
+  readonly fromM: <S, R, E, A>(ma: Kind3<M, R, E, A>) => StateT3<M, S, R, E, A>
+  readonly evalState: <S, R, E, A>(ma: StateT3<M, S, R, E, A>, s: S) => Kind3<M, R, E, A>
+  readonly execState: <S, R, E, A>(ma: StateT3<M, S, R, E, A>, s: S) => Kind3<M, R, E, S>
+}
+/**
+ * @category zone of death
+ * @since 2.5.4
+ * @deprecated
+ */
+export interface StateM3C<M extends URIS3, E> {
+  readonly map: <S, R, A, B>(fa: StateT3<M, S, R, E, A>, f: (a: A) => B) => StateT3<M, S, R, E, B>
+  readonly of: <S, R, A>(a: A) => StateT3<M, S, R, E, A>
+  readonly ap: <S, R, A, B>(fab: StateT3<M, S, R, E, (a: A) => B>, fa: StateT3<M, S, R, E, A>) => StateT3<M, S, R, E, B>
+  readonly chain: <S, R, A, B>(
+    fa: StateT3<M, S, R, E, A>,
+    f: (a: A) => StateT3<M, S, R, E, B>
+  ) => StateT3<M, S, R, E, B>
+  readonly get: <R, S>() => StateT3<M, S, R, E, S>
+  readonly put: <R, S>(s: S) => StateT3<M, S, R, E, void>
+  readonly modify: <R, S>(f: (s: S) => S) => StateT3<M, S, R, E, void>
+  readonly gets: <S, R, A>(f: (s: S) => A) => StateT3<M, S, R, E, A>
+  readonly fromState: <S, R, A>(fa: State<S, A>) => StateT3<M, S, R, E, A>
+  readonly fromM: <S, R, A>(ma: Kind3<M, R, E, A>) => StateT3<M, S, R, E, A>
+  readonly evalState: <S, R, A>(ma: StateT3<M, S, R, E, A>, s: S) => Kind3<M, R, E, A>
+  readonly execState: <S, R, A>(ma: StateT3<M, S, R, E, A>, s: S) => Kind3<M, R, E, S>
+}
+/**
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare function getStateM<M extends URIS3>(M: Monad3<M>): StateM3<M>
+/** @deprecated */
+export declare function getStateM<M extends URIS3, E>(M: Monad3C<M, E>): StateM3C<M, E>
+/** @deprecated */
+export declare function getStateM<M extends URIS2>(M: Monad2<M>): StateM2<M>
+/** @deprecated */
+export declare function getStateM<M extends URIS2, E>(M: Monad2C<M, E>): StateM2C<M, E>
+/** @deprecated */
+export declare function getStateM<M extends URIS>(M: Monad1<M>): StateM1<M>
+/** @deprecated */
+export declare function getStateM<M>(M: Monad<M>): StateM<M>

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.of = of;
+exports.map = map;
+exports.ap = ap;
+exports.chain = chain;
+exports.flatMap = flatMap;
+exports.fromState = fromState;
+exports.fromF = fromF;
+exports.evaluate = evaluate;
+exports.execute = execute;
+exports.getStateM = getStateM;
+var function_1 = require("./function");
+var ReadonlyTuple_1 = require("./ReadonlyTuple");
+function of(F) {
+    return function (a) { return function (s) { return F.of([a, s]); }; };
+}
+function map(F) {
+    return function (f) { return function (fa) { return function (s) { return F.map(fa(s), function (_a) {
+        var a = _a[0], s1 = _a[1];
+        return [f(a), s1];
+    }); }; }; };
+}
+function ap(M) {
+    return function (fa) { return function (fab) { return function (s) { return M.chain(fab(s), function (_a) {
+        var f = _a[0], s = _a[1];
+        return M.map(fa(s), function (_a) {
+            var a = _a[0], s = _a[1];
+            return [f(a), s];
+        });
+    }); }; }; };
+}
+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 function (s) { return M.chain(ma(s), function (_a) {
+        var a = _a[0], s1 = _a[1];
+        return f(a)(s1);
+    }); }; };
+}
+function fromState(F) {
+    return function (sa) { return function (s) { return F.of(sa(s)); }; };
+}
+function fromF(F) {
+    return function (ma) { return function (s) { return F.map(ma, function (a) { return [a, s]; }); }; };
+}
+function evaluate(F) {
+    return function (s) { return function (ma) { return F.map(ma(s), function (_a) {
+        var a = _a[0];
+        return a;
+    }); }; };
+}
+function execute(F) {
+    return function (s) { return function (ma) { return F.map(ma(s), ReadonlyTuple_1.snd); }; };
+}
+/** @deprecated */
+/* istanbul ignore next */
+function getStateM(M) {
+    var _ap = ap(M);
+    var _map = map(M);
+    var _chain = chain(M);
+    var _evaluate = evaluate(M);
+    var _execute = execute(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: of(M),
+        chain: function (ma, f) { return (0, function_1.pipe)(ma, _chain(f)); },
+        get: function () { return function (s) { return M.of([s, s]); }; },
+        put: function (s) { return function () { return M.of([undefined, s]); }; },
+        modify: function (f) { return function (s) { return M.of([undefined, f(s)]); }; },
+        gets: function (f) { return function (s) { return M.of([f(s), s]); }; },
+        fromState: fromState(M),
+        fromM: fromF(M),
+        evalState: function (fa, s) { return (0, function_1.pipe)(fa, _evaluate(s)); },
+        execState: function (fa, s) { return (0, function_1.pipe)(fa, _execute(s)); }
+    };
+}

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

@@ -0,0 +1,117 @@
+/**
+ * @since 2.0.0
+ */
+import { Comonad2 } from './Comonad'
+import { Endomorphism } from './Endomorphism'
+import { Functor as FunctorHKT, Functor1, Functor2, Functor2C, Functor3, Functor3C } from './Functor'
+import { HKT, Kind, Kind2, Kind3, URIS, URIS2, URIS3 } from './HKT'
+/**
+ * @category model
+ * @since 2.0.0
+ */
+export interface Store<S, A> {
+  readonly peek: (s: S) => A
+  readonly pos: S
+}
+/**
+ * Reposition the focus at the specified position
+ *
+ * @since 2.0.0
+ */
+export declare function seek<S>(s: S): <A>(wa: Store<S, A>) => Store<S, A>
+/**
+ * Reposition the focus at the specified position, which depends on the current position
+ *
+ * @since 2.0.0
+ */
+export declare function seeks<S>(f: Endomorphism<S>): <A>(wa: Store<S, A>) => Store<S, A>
+/**
+ * Extract a value from a position which depends on the current position
+ *
+ * @since 2.0.0
+ */
+export declare function peeks<S>(f: Endomorphism<S>): <A>(wa: Store<S, A>) => A
+/**
+ * Extract a collection of values from positions which depend on the current position
+ *
+ * @since 2.0.0
+ */
+export declare function experiment<F extends URIS3>(
+  F: Functor3<F>
+): <R, E, S>(f: (s: S) => Kind3<F, R, E, S>) => <A>(wa: Store<S, A>) => Kind3<F, R, E, A>
+export declare function experiment<F extends URIS3, E>(
+  F: Functor3C<F, E>
+): <R, S>(f: (s: S) => Kind3<F, R, E, S>) => <A>(wa: Store<S, A>) => Kind3<F, R, E, A>
+export declare function experiment<F extends URIS2>(
+  F: Functor2<F>
+): <E, S>(f: (s: S) => Kind2<F, E, S>) => <A>(wa: Store<S, A>) => Kind2<F, E, A>
+export declare function experiment<F extends URIS2, E>(
+  F: Functor2C<F, E>
+): <S>(f: (s: S) => Kind2<F, E, S>) => <A>(wa: Store<S, A>) => Kind2<F, E, A>
+export declare function experiment<F extends URIS>(
+  F: Functor1<F>
+): <S>(f: (s: S) => Kind<F, S>) => <A>(wa: Store<S, A>) => Kind<F, A>
+export declare function experiment<F>(
+  F: FunctorHKT<F>
+): <S>(f: (s: S) => HKT<F, S>) => <A>(wa: Store<S, A>) => HKT<F, A>
+/**
+ * @since 2.0.0
+ */
+export declare const extend: <E, A, B>(f: (wa: Store<E, A>) => B) => (wa: Store<E, A>) => Store<E, B>
+/**
+ * @category Extract
+ * @since 2.6.2
+ */
+export declare const extract: <E, A>(wa: Store<E, A>) => A
+/**
+ * @since 2.0.0
+ */
+export declare const duplicate: <E, A>(wa: Store<E, A>) => Store<E, Store<E, A>>
+/**
+ * `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: Store<E, A>) => Store<E, B>
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+export declare const URI = 'Store'
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+export type URI = typeof URI
+declare module './HKT' {
+  interface URItoKind2<E, A> {
+    readonly [URI]: Store<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: Kind2<'Store', E, (a: A) => B>) => Kind2<'Store', E, B>
+/**
+ * @category instances
+ * @since 2.7.0
+ */
+export declare const Comonad: Comonad2<URI>
+/**
+ * This instance is deprecated, use small, specific instances instead.
+ * For example if a function needs a `Comonad` instance, pass `S.Comonad` instead of `S.store`
+ * (where `S` is from `import S from 'fp-ts/Store'`)
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+export declare const store: Comonad2<URI>

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

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.store = exports.Comonad = exports.flap = exports.Functor = exports.URI = exports.map = exports.duplicate = exports.extract = exports.extend = void 0;
+exports.seek = seek;
+exports.seeks = seeks;
+exports.peeks = peeks;
+exports.experiment = experiment;
+var function_1 = require("./function");
+var Functor_1 = require("./Functor");
+/**
+ * Reposition the focus at the specified position
+ *
+ * @since 2.0.0
+ */
+function seek(s) {
+    return function (wa) { return ({ peek: wa.peek, pos: s }); };
+}
+/**
+ * Reposition the focus at the specified position, which depends on the current position
+ *
+ * @since 2.0.0
+ */
+function seeks(f) {
+    return function (wa) { return ({ peek: wa.peek, pos: f(wa.pos) }); };
+}
+/**
+ * Extract a value from a position which depends on the current position
+ *
+ * @since 2.0.0
+ */
+function peeks(f) {
+    return function (wa) { return wa.peek(f(wa.pos)); };
+}
+function experiment(F) {
+    return function (f) { return function (wa) { return F.map(f(wa.pos), function (s) { return wa.peek(s); }); }; };
+}
+/* istanbul ignore next */
+var _map = function (fa, f) { return (0, function_1.pipe)(fa, (0, exports.map)(f)); };
+/* istanbul ignore next */
+var _extend = function (wa, f) { return (0, function_1.pipe)(wa, (0, exports.extend)(f)); };
+/**
+ * @since 2.0.0
+ */
+var extend = function (f) { return function (wa) { return ({
+    peek: function (s) { return f({ peek: wa.peek, pos: s }); },
+    pos: wa.pos
+}); }; };
+exports.extend = extend;
+/**
+ * @category Extract
+ * @since 2.6.2
+ */
+var extract = function (wa) { return wa.peek(wa.pos); };
+exports.extract = extract;
+/**
+ * @since 2.0.0
+ */
+exports.duplicate = (0, exports.extend)(function_1.identity);
+/**
+ * `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 (f) { return function (fa) { return ({
+    peek: function (s) { return f(fa.peek(s)); },
+    pos: fa.pos
+}); }; };
+exports.map = map;
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+exports.URI = 'Store';
+/**
+ * @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.Comonad = {
+    URI: exports.URI,
+    map: _map,
+    extend: _extend,
+    extract: exports.extract
+};
+// -------------------------------------------------------------------------------------
+// deprecated
+// -------------------------------------------------------------------------------------
+/**
+ * This instance is deprecated, use small, specific instances instead.
+ * For example if a function needs a `Comonad` instance, pass `S.Comonad` instead of `S.store`
+ * (where `S` is from `import S from 'fp-ts/Store'`)
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+exports.store = exports.Comonad;