@wener/utils 1.0.0 → 1.1.1

package/README.md

@@ -1,8 +1,5 @@
 # Daily use utils
 
-* [Document](https://apis.wener.me/docs/@wener/utils/index.html)
-
-
 <!-- LINK:BEGIN -->
 
 # Links
@@ -15,6 +12,11 @@
     * APIs playground with docs & stories
     * Github [wenerme/apis](https://github.com/wenerme/apis)
 * Library
+  * [@wener/reaction](https://www.npmjs.com/package/@wener/reaction) - ![VERSION](https://img.shields.io/npm/v/@wener/reaction) - ![LICENSE](https://img.shields.io/npm/l/@wener/reaction)
+    * React hooks, render, logical components
+    * helpful typing
+    * some external minimal helpful utils
+      * reduce packages
   * [@wener/utils](https://www.npmjs.com/package/@wener/utils) - ![VERSION](https://img.shields.io/npm/v/@wener/utils) - ![LICENSE](https://img.shields.io/npm/l/@wener/utils)
     * utils for daily use
     * [Document](https://apis.wener.me/docs/@wener/utils/)

package/jest.config.js

@@ -1,16 +1,18 @@
-const { pathsToModuleNameMapper } = require('ts-jest/utils');
-const { compilerOptions } = require('./tsconfig');
+// const { pathsToModuleNameMapper } = require('ts-jest/utils');
+// const { compilerOptions } = require('./tsconfig');
 
 module.exports = {
   setupFiles: ['<rootDir>/jest.setup.js'],
   transform: {
-    '^.+\\.(ts|tsx)$': 'ts-jest'
+    '^.+\\.(ts|tsx)$': 'ts-jest',
   },
   globals: {
     'ts-jest': {
-      tsConfig: 'tsconfig.jest.json'
+      tsConfig: 'tsconfig.jest.json',
       // tsConfig: 'tsconfig.json',
-    }
+    },
   },
+  // roots: ['<rootDir>/src/', '<rootDir>/tests/'],
+  testMatch: ['<rootDir>/src/**/?(*.)+(spec|test).[jt]s?(x)'],
   // moduleNameMapper: pathsToModuleNameMapper(compilerOptions.paths, { prefix: '<rootDir>/' })
 };

package/lib/cjs/arrays/MaybeArray.js

@@ -1,40 +1,52 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrayOfMaybeArray = exports.lastOfMaybeArray = exports.firstOfMaybeArray = exports.objectOfMaybeArray = void 0;
-function objectOfMaybeArray(o, keys, picker) {
-    if (keys === void 0) { keys = null; }
-    if (picker === void 0) { picker = firstOfMaybeArray; }
-    if (keys === null) {
-        return Object.fromEntries(Object.entries(o).map(function (_a) {
-            var k = _a[0], v = _a[1];
-            return [k, picker(v)];
-        }));
-    }
-    return Object.fromEntries(keys.map(function (v) { return [v, picker(v)]; }));
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var MaybeArray_exports = {};
+__export(MaybeArray_exports, {
+  arrayOfMaybeArray: () => arrayOfMaybeArray,
+  firstOfMaybeArray: () => firstOfMaybeArray,
+  lastOfMaybeArray: () => lastOfMaybeArray,
+  objectOfMaybeArray: () => objectOfMaybeArray
+});
+module.exports = __toCommonJS(MaybeArray_exports);
+function objectOfMaybeArray(o, keys = null, picker = firstOfMaybeArray) {
+  if (keys === null) {
+    return Object.fromEntries(Object.entries(o).map(([k, v]) => [k, picker(v)]));
+  }
+  return Object.fromEntries(keys.map((v) => [v, picker(v)]));
 }
-exports.objectOfMaybeArray = objectOfMaybeArray;
 function firstOfMaybeArray(v) {
-    if (Array.isArray(v)) {
-        return v[0];
-    }
-    return v;
+  if (Array.isArray(v)) {
+    return v[0];
+  }
+  return v;
 }
-exports.firstOfMaybeArray = firstOfMaybeArray;
 function lastOfMaybeArray(v) {
-    if (Array.isArray(v)) {
-        return v[v.length - 1];
-    }
-    return v;
+  if (Array.isArray(v)) {
+    return v[v.length - 1];
+  }
+  return v;
 }
-exports.lastOfMaybeArray = lastOfMaybeArray;
 function arrayOfMaybeArray(v) {
-    if (Array.isArray(v)) {
-        return v;
-    }
-    if (v === null || v === undefined) {
-        return [];
-    }
-    return [v];
+  if (Array.isArray(v)) {
+    return v;
+  }
+  if (v === null || v === void 0) {
+    return [];
+  }
+  return [v];
 }
-exports.arrayOfMaybeArray = arrayOfMaybeArray;
-//# sourceMappingURL=MaybeArray.js.map

package/lib/cjs/arrays/index.js

@@ -1,5 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./MaybeArray"), exports);
-//# sourceMappingURL=index.js.map
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var arrays_exports = {};
+module.exports = __toCommonJS(arrays_exports);
+__reExport(arrays_exports, require("./MaybeArray"), module.exports);

package/lib/cjs/asyncs/AsyncInterval.js

@@ -1,28 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.clearAsyncInterval = exports.setAsyncInterval = void 0;
-var tslib_1 = require("tslib");
-function setAsyncInterval(cb, interval, initial) {
-    var _this = this;
-    if (initial === void 0) { initial = interval; }
-    var id;
-    var handler = function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-        return tslib_1.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, cb()];
-                case 1:
-                    _a.sent();
-                    id = setTimeout(handler, interval);
-                    return [2 /*return*/];
-            }
-        });
-    }); };
-    id = setTimeout(handler, initial);
-    return function () { return id; };
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AsyncInterval_exports = {};
+__export(AsyncInterval_exports, {
+  clearAsyncInterval: () => clearAsyncInterval,
+  setAsyncInterval: () => setAsyncInterval
+});
+module.exports = __toCommonJS(AsyncInterval_exports);
+function setAsyncInterval(cb, interval, initial = interval) {
+  let id;
+  const handler = async () => {
+    await cb();
+    id = setTimeout(handler, interval);
+  };
+  id = setTimeout(handler, initial);
+  return () => id;
 }
-exports.setAsyncInterval = setAsyncInterval;
 function clearAsyncInterval(v) {
-    clearTimeout(v === null || v === void 0 ? void 0 : v());
+  clearTimeout(v == null ? void 0 : v());
 }
-exports.clearAsyncInterval = clearAsyncInterval;
-//# sourceMappingURL=AsyncInterval.js.map

package/lib/cjs/asyncs/LazyPromise.js

@@ -1,26 +1,43 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLazyPromise = void 0;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var LazyPromise_exports = {};
+__export(LazyPromise_exports, {
+  createLazyPromise: () => createLazyPromise
+});
+module.exports = __toCommonJS(LazyPromise_exports);
 function createLazyPromise() {
-    var holder = {
-        resolve: function (_) {
-            throw new Error('pending resolve');
-        },
-        reject: function (_) {
-            throw new Error('pending reject');
-        },
-    };
-    return Object.assign(new Promise(function (resolve, reject) {
-        holder.reject = reject;
-        holder.resolve = resolve;
-    }), {
-        resolve: function (v) {
-            holder.resolve(v);
-        },
-        reject: function (v) {
-            holder.resolve(v);
-        },
-    });
+  const holder = {
+    resolve(_) {
+      throw new Error("pending resolve");
+    },
+    reject(_) {
+      throw new Error("pending reject");
+    }
+  };
+  return Object.assign(new Promise((resolve, reject) => {
+    holder.reject = reject;
+    holder.resolve = resolve;
+  }), {
+    resolve(v) {
+      holder.resolve(v);
+    },
+    reject(v) {
+      holder.resolve(v);
+    }
+  });
 }
-exports.createLazyPromise = createLazyPromise;
-//# sourceMappingURL=LazyPromise.js.map

package/lib/cjs/asyncs/MaybePromise.js

@@ -1,3 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=MaybePromise.js.map
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var MaybePromise_exports = {};
+module.exports = __toCommonJS(MaybePromise_exports);

package/lib/cjs/asyncs/generatorOfStream.js

@@ -1,30 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generatorOfStream = void 0;
-var tslib_1 = require("tslib");
-function generatorOfStream(stream) {
-    var done;
-    return tslib_1.__generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                done = false;
-                stream.on('end', function () {
-                    done = true;
-                });
-                _a.label = 1;
-            case 1:
-                if (!!done) return [3 /*break*/, 3];
-                return [4 /*yield*/, new Promise(function (resolve, reject) {
-                        stream.once('data', resolve);
-                        stream.once('end', resolve);
-                        stream.once('error', reject);
-                    })];
-            case 2:
-                _a.sent();
-                return [3 /*break*/, 1];
-            case 3: return [2 /*return*/];
-        }
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var generatorOfStream_exports = {};
+__export(generatorOfStream_exports, {
+  generatorOfStream: () => generatorOfStream
+});
+module.exports = __toCommonJS(generatorOfStream_exports);
+function* generatorOfStream(stream) {
+  let done = false;
+  stream.on("end", () => {
+    done = true;
+  });
+  while (!done) {
+    yield new Promise((resolve, reject) => {
+      stream.once("data", resolve);
+      stream.once("end", resolve);
+      stream.once("error", reject);
     });
+  }
 }
-exports.generatorOfStream = generatorOfStream;
-//# sourceMappingURL=generatorOfStream.js.map

package/lib/cjs/asyncs/index.js

@@ -1,11 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./LazyPromise"), exports);
-tslib_1.__exportStar(require("./AsyncInterval"), exports);
-tslib_1.__exportStar(require("./MaybePromise"), exports);
-tslib_1.__exportStar(require("./sleep"), exports);
-tslib_1.__exportStar(require("./timeout"), exports);
-tslib_1.__exportStar(require("./isPromise"), exports);
-tslib_1.__exportStar(require("./promiseOfCallback"), exports);
-//# sourceMappingURL=index.js.map
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var asyncs_exports = {};
+module.exports = __toCommonJS(asyncs_exports);
+__reExport(asyncs_exports, require("./LazyPromise"), module.exports);
+__reExport(asyncs_exports, require("./AsyncInterval"), module.exports);
+__reExport(asyncs_exports, require("./MaybePromise"), module.exports);
+__reExport(asyncs_exports, require("./sleep"), module.exports);
+__reExport(asyncs_exports, require("./timeout"), module.exports);
+__reExport(asyncs_exports, require("./isPromise"), module.exports);
+__reExport(asyncs_exports, require("./promiseOfCallback"), module.exports);

package/lib/cjs/asyncs/isPromise.js

@@ -1,8 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPromise = void 0;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var isPromise_exports = {};
+__export(isPromise_exports, {
+  isPromise: () => isPromise
+});
+module.exports = __toCommonJS(isPromise_exports);
 function isPromise(v) {
-    return v && (v instanceof Promise || (v.then && v.catch));
+  return v && (v instanceof Promise || v.then && v.catch);
 }
-exports.isPromise = isPromise;
-//# sourceMappingURL=isPromise.js.map

package/lib/cjs/asyncs/promiseOfCallback.js

@@ -1,22 +1,37 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.promiseOfCallback = void 0;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var promiseOfCallback_exports = {};
+__export(promiseOfCallback_exports, {
+  promiseOfCallback: () => promiseOfCallback
+});
+module.exports = __toCommonJS(promiseOfCallback_exports);
 function promiseOfCallback(fun) {
-    return new Promise(function (resolve, reject) {
-        try {
-            fun(function (e, v) {
-                if (e) {
-                    reject(e);
-                }
-                else {
-                    resolve(v);
-                }
-            });
+  return new Promise((resolve, reject) => {
+    try {
+      fun((e, v) => {
+        if (e) {
+          reject(e);
+        } else {
+          resolve(v);
         }
-        catch (e) {
-            reject(e);
-        }
-    });
+      });
+    } catch (e) {
+      reject(e);
+    }
+  });
 }
-exports.promiseOfCallback = promiseOfCallback;
-//# sourceMappingURL=promiseOfCallback.js.map

package/lib/cjs/asyncs/sleep.js

@@ -1,5 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sleep = void 0;
-exports.sleep = function (ms) { return new Promise(function (resolve) { return setTimeout(resolve, ms); }); };
-//# sourceMappingURL=sleep.js.map
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sleep_exports = {};
+__export(sleep_exports, {
+  sleep: () => sleep
+});
+module.exports = __toCommonJS(sleep_exports);
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

package/lib/cjs/asyncs/timeout.js

@@ -1,30 +1,44 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TimeoutError = exports.timeout = void 0;
-var tslib_1 = require("tslib");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var timeout_exports = {};
+__export(timeout_exports, {
+  TimeoutError: () => TimeoutError,
+  timeout: () => timeout
+});
+module.exports = __toCommonJS(timeout_exports);
 function timeout(v, ms) {
-    var error = new TimeoutError();
-    var timeout;
-    return Promise.race([
-        v,
-        new Promise(function (resolve, reject) {
-            timeout = setTimeout(function () { return reject(error); }, ms);
-        }),
-    ]).then(function (v) {
-        clearTimeout(timeout);
-        return v;
-    }, function (e) {
-        clearTimeout(timeout);
-        throw e;
-    });
+  const error = new TimeoutError();
+  let timeout2;
+  return Promise.race([
+    v,
+    new Promise((_, reject) => {
+      timeout2 = setTimeout(() => reject(error), ms);
+    })
+  ]).then((v2) => {
+    clearTimeout(timeout2);
+    return v2;
+  }, (e) => {
+    clearTimeout(timeout2);
+    throw e;
+  });
+}
+class TimeoutError extends Error {
+  constructor() {
+    super("TimeoutError");
+  }
 }
-exports.timeout = timeout;
-var TimeoutError = /** @class */ (function (_super) {
-    tslib_1.__extends(TimeoutError, _super);
-    function TimeoutError() {
-        return _super.call(this, 'TimeoutError') || this;
-    }
-    return TimeoutError;
-}(Error));
-exports.TimeoutError = TimeoutError;
-//# sourceMappingURL=timeout.js.map