typed-utilities/build/index.js

Strongly typed general purpose utilities

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
var _exportNames = {
  AsyncLock: true,
  AsyncSemaphore: true,
  AsyncResult: true,
  Deferred: true,
  Either: true,
  Option: true,
  Result: true,
  Err: true,
  Ok: true
};
Object.defineProperty(exports, "AsyncLock", {
  enumerable: true,
  get: function () {
    return _AsyncLock.AsyncLock;
  }
});
Object.defineProperty(exports, "AsyncResult", {
  enumerable: true,
  get: function () {
    return _AsyncResult.AsyncResult;
  }
});
Object.defineProperty(exports, "AsyncSemaphore", {
  enumerable: true,
  get: function () {
    return _AsyncSemaphore.AsyncSemaphore;
  }
});
Object.defineProperty(exports, "Deferred", {
  enumerable: true,
  get: function () {
    return _Deferred.Deferred;
  }
});
Object.defineProperty(exports, "Either", {
  enumerable: true,
  get: function () {
    return _Either.Either;
  }
});
Object.defineProperty(exports, "Err", {
  enumerable: true,
  get: function () {
    return _Result.Err;
  }
});
Object.defineProperty(exports, "Ok", {
  enumerable: true,
  get: function () {
    return _Result.Ok;
  }
});
Object.defineProperty(exports, "Option", {
  enumerable: true,
  get: function () {
    return _Option.Option;
  }
});
Object.defineProperty(exports, "Result", {
  enumerable: true,
  get: function () {
    return _Result.Result;
  }
});

var _AsyncLock = require("./AsyncLock");

var _AsyncSemaphore = require("./AsyncSemaphore");

var _AsyncResult = require("./AsyncResult");

var _Deferred = require("./Deferred");

var _Either = require("./Either");

var _Option = require("./Option");

var _Result = require("./Result");

var _Array = require("./Array");

Object.keys(_Array).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _Array[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _Array[key];
    }
  });
});

var _Base64DataUri = require("./Base64DataUri");

Object.keys(_Base64DataUri).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _Base64DataUri[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _Base64DataUri[key];
    }
  });
});

var _ConstructorType = require("./ConstructorType");

Object.keys(_ConstructorType).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _ConstructorType[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _ConstructorType[key];
    }
  });
});

var _deepTransform = require("./deepTransform");

Object.keys(_deepTransform).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _deepTransform[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _deepTransform[key];
    }
  });
});

var _exponentialBackOff = require("./exponentialBackOff");

Object.keys(_exponentialBackOff).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _exponentialBackOff[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _exponentialBackOff[key];
    }
  });
});

var _id = require("./id");

Object.keys(_id).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _id[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _id[key];
    }
  });
});

var _interpolate = require("./interpolate");

Object.keys(_interpolate).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _interpolate[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _interpolate[key];
    }
  });
});

var _iterAsync = require("./iterAsync");

Object.keys(_iterAsync).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _iterAsync[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _iterAsync[key];
    }
  });
});

var _Iterator = require("./Iterator");

Object.keys(_Iterator).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _Iterator[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _Iterator[key];
    }
  });
});

var _lazyMemo = require("./lazyMemo");

Object.keys(_lazyMemo).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _lazyMemo[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _lazyMemo[key];
    }
  });
});

var _Memo = require("./Memo");

Object.keys(_Memo).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _Memo[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _Memo[key];
    }
  });
});

var _omit = require("./omit");

Object.keys(_omit).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _omit[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _omit[key];
    }
  });
});

var _pick = require("./pick");

Object.keys(_pick).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _pick[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _pick[key];
    }
  });
});

var _PromiseType = require("./PromiseType");

Object.keys(_PromiseType).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _PromiseType[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _PromiseType[key];
    }
  });
});

var _range = require("./range");

Object.keys(_range).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _range[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _range[key];
    }
  });
});

var _RegExp = require("./RegExp");

Object.keys(_RegExp).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _RegExp[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _RegExp[key];
    }
  });
});

var _sequenceId = require("./sequenceId");

Object.keys(_sequenceId).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _sequenceId[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _sequenceId[key];
    }
  });
});

var _sleep = require("./sleep");

Object.keys(_sleep).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _sleep[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _sleep[key];
    }
  });
});

var _sortByProperty = require("./sortByProperty");

Object.keys(_sortByProperty).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _sortByProperty[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _sortByProperty[key];
    }
  });
});

var _tap = require("./tap");

Object.keys(_tap).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _tap[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _tap[key];
    }
  });
});

var _useAsync = require("./useAsync");

Object.keys(_useAsync).forEach(function (key) {
  if (key === "default" || key === "__esModule") return;
  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
  if (key in exports && exports[key] === _useAsync[key]) return;
  Object.defineProperty(exports, key, {
    enumerable: true,
    get: function () {
      return _useAsync[key];
    }
  });
});

if (typeof AggregateError === `undefined`) {
  throw new Error(`Global AggregateError is required`);
}
//# sourceMappingURL=index.js.map