fortepiano 0.1.0

package/lib/http/Axios.d.ts

@@ -0,0 +1,3 @@
+import { AxiosStatic } from 'axios';
+import * as $H from '../Http';
+export declare const $axios: (_axios: AxiosStatic) => $H.Http;

package/lib/http/Axios.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.$axios = void 0;
+const E = __importStar(require("fp-ts/Either"));
+const function_1 = require("fp-ts/function");
+const RR = __importStar(require("fp-ts/ReadonlyRecord"));
+const t = __importStar(require("io-ts"));
+const $E = __importStar(require("../Error"));
+const $H = __importStar(require("../Http"));
+const $S = __importStar(require("../string"));
+const $TE = __importStar(require("../TaskEither"));
+const response = (url) => (response) => ({
+    url: response.config.url || url,
+    status: response.status,
+    headers: function_1.pipe(response.headers, t.readonly(t.record(t.string, t.unknown)).decode, E.map(RR.filter(t.union([t.string, t.readonlyArray(t.string)]).is)), E.getOrElse(() => ({}))),
+    body: response.data,
+});
+const request = (axios, method, url, options = {}) => $TE.tryCatch(() => axios
+    .request(Object.assign(Object.assign({ data: options.body, headers: Object.assign(Object.assign({}, options.headers), (options.json ? { 'Content-Type': 'application/json' } : null)), method, params: options.query }, (options.json
+    ? { responseType: 'json' }
+    : options.buffer
+        ? { responseType: 'arraybuffer' }
+        : null)), { url }))
+    .then(response(url))
+    .catch((error) => {
+    if (!axios.isAxiosError(error) || undefined === error.response) {
+        throw error;
+    }
+    throw $E.wrap(new $H.HttpError(response(url)(error.response), `Cannot make HTTP request "${$S.uppercase(method)} ${url}": ${error.message}`))(error);
+}), $E.fromUnknown(Error(`Cannot make HTTP request "${$S.uppercase(method)} ${url}"`)));
+const $axios = (_axios) => ({
+    delete: (url, options) => request(_axios, 'delete', url, options),
+    get: (url, options) => request(_axios, 'get', url, options),
+    patch: (url, options) => request(_axios, 'patch', url, options),
+    post: (url, options) => request(_axios, 'post', url, options),
+    put: (url, options) => request(_axios, 'put', url, options),
+    head: (url, options) => request(_axios, 'head', url, options),
+    options: (url, options) => request(_axios, 'options', url, options),
+});
+exports.$axios = $axios;

package/lib/http/Fetch.d.ts

@@ -0,0 +1,2 @@
+import * as $H from '../Http';
+export declare const $fetch: (_fetch: typeof fetch) => $H.Http;

package/lib/http/Fetch.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.$fetch = void 0;
+const Ei = __importStar(require("fp-ts/Either"));
+const function_1 = require("fp-ts/function");
+const J = __importStar(require("fp-ts/Json"));
+const O = __importStar(require("fp-ts/Option"));
+const RA = __importStar(require("fp-ts/ReadonlyArray"));
+const RR = __importStar(require("fp-ts/ReadonlyRecord"));
+const Se = __importStar(require("fp-ts/Semigroup"));
+const t = __importStar(require("io-ts"));
+const io_ts_types_1 = require("io-ts-types");
+const $Er = __importStar(require("../Error"));
+const $H = __importStar(require("../Http"));
+const $St = __importStar(require("../string"));
+const $TE = __importStar(require("../TaskEither"));
+const request = (_fetch, method, url, options = {}) => $TE.tryCatch(() => _fetch(function_1.pipe(options.query, O.fromNullable, O.map(RR.map((value) => value.toString())), O.map((query) => new URLSearchParams(query)), O.map((params) => params.toString()), O.filter(io_ts_types_1.NonEmptyString.is), O.match(() => url, (queryString) => `${url}?${queryString}`)), {
+    // eslint-disable-next-line no-nested-ternary
+    body: options.json
+        ? function_1.pipe(options.body, J.stringify, Ei.getOrElseW(function_1.constUndefined))
+        : t.record(t.string, t.unknown).is(options.body)
+            ? function_1.pipe(options.body, O.fromNullable, O.map(RR.reduceWithIndex(new FormData(), (name, form, value) => {
+                if (t.union([t.boolean, t.number, t.string]).is(value)) {
+                    form.append(name, value.toString());
+                }
+                return form;
+            })), O.getOrElseW(function_1.constUndefined))
+            : undefined,
+    headers: Object.assign(Object.assign({}, options.headers), (options.json ? { 'Content-Type': 'application/json' } : null)),
+    method: $St.uppercase(method),
+}).then((response) => (response.ok && options.json ? response.json() : response.text()).then((body) => {
+    const _response = {
+        url: response.url,
+        status: response.status,
+        headers: function_1.pipe([...response.headers.entries()], RR.fromFoldable(Se.last(), RA.Foldable)),
+        body,
+    };
+    if (!response.ok) {
+        throw new $H.HttpError(_response, `Cannot make HTTP request "${$St.uppercase(method)} ${url}": ${response.statusText}`);
+    }
+    return _response;
+})), $Er.fromUnknown(Error(`Cannot make HTTP request "${$St.uppercase(method)} ${url}"`)));
+const $fetch = (_fetch) => ({
+    delete: (url, options) => request(_fetch, 'delete', url, options),
+    get: (url, options) => request(_fetch, 'get', url, options),
+    patch: (url, options) => request(_fetch, 'patch', url, options),
+    post: (url, options) => request(_fetch, 'post', url, options),
+    put: (url, options) => request(_fetch, 'put', url, options),
+    head: (url, options) => request(_fetch, 'head', url, options),
+    options: (url, options) => request(_fetch, 'options', url, options),
+});
+exports.$fetch = $fetch;

package/lib/http/Got.d.ts

@@ -0,0 +1,3 @@
+import { Got } from 'got';
+import * as $H from '../Http';
+export declare const $got: (_got: Got) => $H.Http;

package/lib/http/Got.js

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.$got = void 0;
+const function_1 = require("fp-ts/function");
+const RR = __importStar(require("fp-ts/ReadonlyRecord"));
+const got_1 = require("got");
+const t = __importStar(require("io-ts"));
+const $E = __importStar(require("../Error"));
+const $H = __importStar(require("../Http"));
+const $S = __importStar(require("../string"));
+const $TE = __importStar(require("../TaskEither"));
+const request = (_got, method, url, options = {}) => $TE.tryCatch(() => _got(url, Object.assign({ headers: options.headers, method, retry: 0, searchParams: options.query }, (options.json
+    ? { json: options.body, responseType: 'json' }
+    : { form: options.body })))
+    .then((response) => ({
+    url: response.url,
+    status: response.statusCode,
+    headers: function_1.pipe(response.headers, RR.filter(t.union([t.string, t.readonlyArray(t.string)]).is)),
+    body: response.body,
+}))
+    .catch((error) => {
+    if (!(error instanceof got_1.HTTPError)) {
+        throw error;
+    }
+    throw $E.wrap(new $H.HttpError({
+        url: error.response.url,
+        status: error.response.statusCode,
+        headers: function_1.pipe(error.response.headers, RR.filter(t.union([t.string, t.readonlyArray(t.string)]).is)),
+        body: error.response.body,
+    }, `Cannot make HTTP request "${$S.uppercase(method)} ${url}": ${error.message}`))(error);
+}), $E.fromUnknown(Error(`Cannot make HTTP request "${$S.uppercase(method)} ${url}"`)));
+const $got = (_got) => ({
+    delete: (url, options) => request(_got, 'delete', url, options),
+    get: (url, options) => request(_got, 'get', url, options),
+    patch: (url, options) => request(_got, 'patch', url, options),
+    post: (url, options) => request(_got, 'post', url, options),
+    put: (url, options) => request(_got, 'put', url, options),
+    head: (url, options) => request(_got, 'head', url, options),
+    options: (url, options) => request(_got, 'options', url, options),
+});
+exports.$got = $got;

package/lib/http/Mock.d.ts

@@ -0,0 +1,2 @@
+import * as $H from '../Http';
+export declare const mock: $H.Http;

package/lib/http/Mock.js

@@ -0,0 +1,52 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.mock = void 0;
+const function_1 = require("fp-ts/function");
+const TE = __importStar(require("fp-ts/TaskEither"));
+const t = __importStar(require("io-ts"));
+const function_2 = require("../function");
+const $H = __importStar(require("../Http"));
+const $M = __importStar(require("../Mock"));
+const response = (url, error = false) => $M.struct({
+    url: $M.literal(url),
+    status: error ? $M.integer(300, 599) : $M.integer(200, 299),
+    headers: $M.readonlyRecord($M.string, $M.union($M.string, $M.readonlyArray($M.string))),
+    body: $M.unknown(),
+});
+const error = (url) => $M.struct({
+    name: $M.string,
+    message: $M.string,
+    stack: $M.string,
+    response: $M.nullable(response(url, true)),
+});
+const request = (url) => function_1.pipe($M.union(error(url), response(url)), TE.fromIOK(function_2.run), TE.chain((mock) => $H.HttpResponseC(t.unknown).is(mock)
+    ? TE.right(mock)
+    : TE.left(mock)));
+exports.mock = {
+    delete: request,
+    get: request,
+    patch: request,
+    post: request,
+    put: request,
+    head: request,
+    options: request,
+};

package/lib/index.d.ts

@@ -0,0 +1,48 @@
+import * as $aggregate from './Aggregate';
+import * as $binary from './Binary';
+import * as $buffer from './Buffer';
+import * as $cache from './Cache';
+import * as $console from './Console';
+import * as $crypto from './Crypto';
+import * as $date from './Date';
+import * as $eq from './Eq';
+import * as $error from './Error';
+import * as $generatorL from './GeneratorL';
+import * as $http from './Http';
+import * as $log from './Log';
+import * as $magma from './Magma';
+import * as $matrix from './Matrix';
+import * as $mock from './Mock';
+import * as $number from './number';
+import * as $option from './Option';
+import * as $random from './Random';
+import * as $reader from './Reader';
+import * as $readerEither from './ReaderEither';
+import * as $readerTask from './ReaderTask';
+import * as $readerTaskEither from './ReaderTaskEither';
+import * as $readonlyArray from './ReadonlyArray';
+import * as $readonlyRecord from './ReadonlyRecord';
+import * as $readonlyTuple from './ReadonlyTuple';
+import * as $storage from './Storage';
+import * as $stream from './Stream';
+import * as $string from './string';
+import * as $struct from './struct';
+import * as $taskEither from './TaskEither';
+import * as $type from './Type';
+import * as $validation from './Validation';
+export declare type PartialDeep<A> = A extends {
+    readonly [x: string]: unknown;
+} ? Partial<{
+    readonly [K in keyof A]: PartialDeep<A[K]>;
+}> : A;
+export declare type ValuesDeep<A> = A extends {
+    readonly [x: string]: unknown;
+} & {
+    readonly [K in keyof A]: unknown;
+} ? A[keyof A] | ValuesDeep<A[keyof A]> : A;
+export declare type IntersectionDeep<A, B> = A extends {
+    readonly [x: string]: unknown;
+} ? A & {
+    readonly [K in keyof B]: IntersectionDeep<K extends keyof A ? A[K] : unknown, B[K]>;
+} : B;
+export { $aggregate, $binary, $buffer, $cache, $console, $crypto, $date, $eq, $error, $generatorL, $http, $log, $magma, $matrix, $mock, $number, $option, $random, $reader, $readerEither, $readerTask, $readerTaskEither, $readonlyArray, $readonlyRecord, $readonlyTuple, $storage, $stream, $string, $struct, $taskEither, $type, $validation, };

package/lib/index.js

@@ -0,0 +1,86 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.$validation = exports.$type = exports.$taskEither = exports.$struct = exports.$string = exports.$stream = exports.$storage = exports.$readonlyTuple = exports.$readonlyRecord = exports.$readonlyArray = exports.$readerTaskEither = exports.$readerTask = exports.$readerEither = exports.$reader = exports.$random = exports.$option = exports.$number = exports.$mock = exports.$matrix = exports.$magma = exports.$log = exports.$http = exports.$generatorL = exports.$error = exports.$eq = exports.$date = exports.$crypto = exports.$console = exports.$cache = exports.$buffer = exports.$binary = exports.$aggregate = void 0;
+const $aggregate = __importStar(require("./Aggregate"));
+exports.$aggregate = $aggregate;
+const $binary = __importStar(require("./Binary"));
+exports.$binary = $binary;
+const $buffer = __importStar(require("./Buffer"));
+exports.$buffer = $buffer;
+const $cache = __importStar(require("./Cache"));
+exports.$cache = $cache;
+const $console = __importStar(require("./Console"));
+exports.$console = $console;
+const $crypto = __importStar(require("./Crypto"));
+exports.$crypto = $crypto;
+const $date = __importStar(require("./Date"));
+exports.$date = $date;
+const $eq = __importStar(require("./Eq"));
+exports.$eq = $eq;
+const $error = __importStar(require("./Error"));
+exports.$error = $error;
+const $generatorL = __importStar(require("./GeneratorL"));
+exports.$generatorL = $generatorL;
+const $http = __importStar(require("./Http"));
+exports.$http = $http;
+const $log = __importStar(require("./Log"));
+exports.$log = $log;
+const $magma = __importStar(require("./Magma"));
+exports.$magma = $magma;
+const $matrix = __importStar(require("./Matrix"));
+exports.$matrix = $matrix;
+const $mock = __importStar(require("./Mock"));
+exports.$mock = $mock;
+const $number = __importStar(require("./number"));
+exports.$number = $number;
+const $option = __importStar(require("./Option"));
+exports.$option = $option;
+const $random = __importStar(require("./Random"));
+exports.$random = $random;
+const $reader = __importStar(require("./Reader"));
+exports.$reader = $reader;
+const $readerEither = __importStar(require("./ReaderEither"));
+exports.$readerEither = $readerEither;
+const $readerTask = __importStar(require("./ReaderTask"));
+exports.$readerTask = $readerTask;
+const $readerTaskEither = __importStar(require("./ReaderTaskEither"));
+exports.$readerTaskEither = $readerTaskEither;
+const $readonlyArray = __importStar(require("./ReadonlyArray"));
+exports.$readonlyArray = $readonlyArray;
+const $readonlyRecord = __importStar(require("./ReadonlyRecord"));
+exports.$readonlyRecord = $readonlyRecord;
+const $readonlyTuple = __importStar(require("./ReadonlyTuple"));
+exports.$readonlyTuple = $readonlyTuple;
+const $storage = __importStar(require("./Storage"));
+exports.$storage = $storage;
+const $stream = __importStar(require("./Stream"));
+exports.$stream = $stream;
+const $string = __importStar(require("./string"));
+exports.$string = $string;
+const $struct = __importStar(require("./struct"));
+exports.$struct = $struct;
+const $taskEither = __importStar(require("./TaskEither"));
+exports.$taskEither = $taskEither;
+const $type = __importStar(require("./Type"));
+exports.$type = $type;
+const $validation = __importStar(require("./Validation"));
+exports.$validation = $validation;

package/lib/log/Void.d.ts

@@ -0,0 +1,3 @@
+import * as $L from '../Log';
+declare const _void: $L.Logger;
+export { _void as void };

package/lib/log/Void.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.void = void 0;
+const function_1 = require("fp-ts/function");
+const _void = () => function_1.constVoid;
+exports.void = _void;

package/lib/number.d.ts

@@ -0,0 +1,3 @@
+export declare const floor: (digits?: number, discardZeroSign?: boolean) => (a: number) => number;
+export declare const round: (digits?: number, discardZeroSign?: boolean) => (a: number) => number;
+export declare const ceil: (digits?: number, discardZeroSign?: boolean) => (a: number) => number;

package/lib/number.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ceil = exports.round = exports.floor = void 0;
+const function_1 = require("fp-ts/function");
+const approx = (method) => (digits = 0, discardZeroSign = true) => (a) => function_1.pipe(a.toString().split('e'), ([mantissa, exponent]) => `${mantissa}e${(exponent ? Number(exponent) : 0) + digits}`, (s) => Math[method](Number(s)), (n) => n.toString().split('e'), ([mantissa, exponent]) => `${mantissa}e${(exponent ? Number(exponent) : 0) - digits}`, Number, (n) => n === 0 && discardZeroSign ? Math.abs(n) : Math.sign(a) * Math.abs(n));
+exports.floor = approx('floor');
+exports.round = approx('round');
+exports.ceil = approx('ceil');

package/lib/storage/Flydrive.d.ts

@@ -0,0 +1,4 @@
+import { StorageManager } from '@slynova/flydrive';
+import { Lazy } from 'fp-ts/function';
+import * as $Sto from '../Storage';
+export declare const $flydrive: (flydrive: Lazy<StorageManager>) => $Sto.Storage;

package/lib/storage/Flydrive.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$flydrive = void 0;
+const function_1 = require("fp-ts/function");
+const TE = __importStar(require("fp-ts/TaskEither"));
+const $E = __importStar(require("../Error"));
+const function_2 = require("../function");
+const $Str = __importStar(require("../struct"));
+const $TE = __importStar(require("../TaskEither"));
+const $flydrive = (flydrive) => {
+    const _flydrive = function_2.memoize(flydrive);
+    return {
+        getStream: (path, { fileSystem } = {}) => $TE.tryCatch(() => __awaiter(void 0, void 0, void 0, function* () { return _flydrive().disk(fileSystem).getStream(path); }), $E.fromUnknown(Error(`Cannot get stream for file "${path}"${undefined !== fileSystem ? ` on file system "${fileSystem}"` : ''}`))),
+        getUrl: (path, { fileSystem } = {}) => function_1.pipe($TE.tryCatch(() => _flydrive()
+            .disk(fileSystem)
+            .exists(path)
+            .then(({ exists }) => exists ? Promise.resolve() : Promise.reject()), $E.fromUnknown(Error(`Cannot find file "${path}"${undefined !== fileSystem
+            ? ` on file system "${fileSystem}"`
+            : ''}`))), TE.apSecond($TE.tryCatch(() => Promise.resolve(_flydrive().disk(fileSystem).getUrl(path)), $E.fromUnknown(Error(`Cannot get URL for file "${path}"${undefined !== fileSystem
+            ? ` on file system "${fileSystem}"`
+            : ''}`))))),
+        read: (path, { fileSystem } = {}) => $TE.tryCatch(() => _flydrive()
+            .disk(fileSystem)
+            .getBuffer(path)
+            .then($Str.lookup('content')), $E.fromUnknown(Error(`Cannot read file "${path}"${undefined !== fileSystem
+            ? ` from file system "${fileSystem}"`
+            : ''}`))),
+        write: (path, { fileSystem } = {}) => (data) => $TE.tryCatch(() => _flydrive().disk(fileSystem).put(path, data).then(function_1.constVoid), $E.fromUnknown(Error(`Cannot write file "${path}"${undefined !== fileSystem
+            ? ` to file system "${fileSystem}"`
+            : ''}`))),
+        delete: (path, { fileSystem } = {}) => $TE.tryCatch(() => _flydrive()
+            .disk(fileSystem)
+            .delete(path)
+            .then(({ wasDeleted }) => false === wasDeleted ? Promise.reject() : Promise.resolve()), $E.fromUnknown(Error(`Cannot delete file "${path}"${undefined !== fileSystem
+            ? ` from file system "${fileSystem}"`
+            : ''}`))),
+    };
+};
+exports.$flydrive = $flydrive;

package/lib/storage/Fs.d.ts

@@ -0,0 +1,3 @@
+import _fs from 'fs';
+import * as $Sto from '../Storage';
+export declare const $fs: (fs: typeof _fs, root: string) => $Sto.Storage;

package/lib/storage/Fs.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$fs = void 0;
+const TE = __importStar(require("fp-ts/TaskEither"));
+const path_1 = __importDefault(require("path"));
+const $E = __importStar(require("../Error"));
+const $Str = __importStar(require("../Stream"));
+const $TE = __importStar(require("../TaskEither"));
+const $fs = (fs, root) => ({
+    getStream: (path) => $TE.tryCatch(() => __awaiter(void 0, void 0, void 0, function* () { return fs.createReadStream(path_1.default.join(root, path)); }), $E.fromUnknown(Error(`Cannot get stream for file "${path}"`))),
+    getUrl: (path) => TE.left(Error(`Cannot get URL for file "${path}"`)),
+    read: (path) => $TE.tryCatch(() => fs.promises.readFile(path_1.default.join(root, path)), $E.fromUnknown(Error(`Cannot read file "${path}"`))),
+    write: (path) => (data) => $TE.tryCatch(() => $Str.ReadableStreamC.is(data)
+        ? new Promise((resolve, reject) => {
+            data
+                .pipe(fs.createWriteStream(path).on('error', reject))
+                .on('end', resolve);
+        })
+        : fs.promises.writeFile(path_1.default.join(root, path), data), $E.fromUnknown(Error(`Cannot write file "${path}"`))),
+    delete: (path) => $TE.tryCatch(() => fs.promises.rm(path_1.default.join(root, path)), $E.fromUnknown(Error(`Cannot delete file "${path}"`))),
+});
+exports.$fs = $fs;

package/lib/string.d.ts

@@ -0,0 +1,5 @@
+export declare const uppercase: <S extends string>(s: S) => Uppercase<S>;
+export declare const lowercase: <S extends string>(s: S) => Lowercase<S>;
+export declare const capitalize: <S extends string>(s: S) => Capitalize<S>;
+export declare const uncapitalize: <S extends string>(s: S) => Uncapitalize<S>;
+export declare const test: (re: RegExp) => (s: string) => boolean;

package/lib/string.js

@@ -0,0 +1,33 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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.test = exports.uncapitalize = exports.capitalize = exports.lowercase = exports.uppercase = void 0;
+const S = __importStar(require("fp-ts/string"));
+const uppercase = (s) => s.toUpperCase();
+exports.uppercase = uppercase;
+const lowercase = (s) => s.toLowerCase();
+exports.lowercase = lowercase;
+const capitalize = (s) => (S.isEmpty(s) ? s : s[0].toUpperCase() + s.slice(1));
+exports.capitalize = capitalize;
+const uncapitalize = (s) => (S.isEmpty(s) ? s : s[0].toLowerCase() + s.slice(1));
+exports.uncapitalize = uncapitalize;
+const test = (re) => (s) => re.test(s);
+exports.test = test;

package/lib/struct.d.ts

@@ -0,0 +1,9 @@
+import { Predicate } from 'fp-ts/function';
+import { IntersectionDeep, PartialDeep } from '.';
+export declare type struct = object;
+export declare const toReadonlyArray: <A extends object>(a: A) => readonly (readonly [keyof A, A[keyof A]])[];
+export declare const lookup: <S extends object, K extends keyof S>(k: K) => (s: S) => S[K];
+export declare const modifyAt: <S extends object, K extends keyof S>(k: K, f: (a: S[K]) => S[K]) => (s: S) => S;
+export declare const updateAt: <S extends object, K extends keyof S>(k: K, a: S[K]) => (s: S) => S;
+export declare const filterDeep: <A extends object>(f: Predicate<unknown>) => (a: A) => PartialDeep<A>;
+export declare const patch: <A extends object, B extends PartialDeep<A> & object>(b: B) => (a: A) => IntersectionDeep<A, B>;