unwrapped 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # unwrapped
 
+## 0.1.1
+
+### Patch Changes
+
+- 2606226: added files tin .npmignore
+
 ## 0.1.0
 
 ### Minor Changes

package/dist/core/index.d.mts

@@ -0,0 +1,105 @@
+declare class ErrorBase {
+    code: string;
+    message?: string | undefined;
+    thrownError?: any;
+    constructor(code: string, message?: string, thrownError?: any, log?: boolean);
+    toString(): string;
+    logError(): void;
+}
+
+type ResultState<T, E = ErrorBase> = {
+    status: 'success';
+    value: T;
+} | {
+    status: 'error';
+    error: E;
+};
+declare class Result<T, E = ErrorBase> {
+    private _state;
+    constructor(state: ResultState<T, E>);
+    get state(): ResultState<T, E>;
+    static ok<T, E = ErrorBase>(value: T): Result<T, E>;
+    static err<E>(error: E): Result<never, E>;
+    static errTag(code: string, message?: string): Result<never, ErrorBase>;
+    unwrapOrNull(): T | null;
+    unwrapOrThrow(): T;
+    unwrapOr<O>(defaultValue: O): T | O;
+    isSuccess(): boolean;
+    isError(): boolean;
+    static tryPromise<T, E>(promise: Promise<T>, errorMapper: (error: unknown) => E): Promise<Result<T, E>>;
+    static tryFunction<T, E extends ErrorBase = ErrorBase>(fn: () => Promise<T>, errorMapper: (error: unknown) => E): Promise<Result<T, E>>;
+    chain<O, E2>(fn: (input: T) => ResultState<O, E | E2>): Result<O, E | E2>;
+    [Symbol.iterator](): Generator<Result<T, E>, T, any>;
+    static run<T, E>(generator: () => Generator<Result<any, E>, T, any>): Result<T, E>;
+}
+
+type AsyncResultState<T, E> = {
+    status: 'idle';
+} | {
+    status: 'loading';
+    promise: Promise<Result<T, E>>;
+} | ResultState<T, E>;
+type ChainFunction<I, O, E> = (input: I) => Result<O, E> | Promise<Result<O, E>>;
+type FlatChainFunction<I, O, E> = (input: I) => AsyncResult<O, E>;
+type AsyncResultListener<T, E> = (result: AsyncResult<T, E>) => any;
+declare class AsyncResult<T, E = ErrorBase> {
+    private _state;
+    private _listeners;
+    constructor(state?: AsyncResultState<T, E>);
+    get state(): AsyncResultState<T, E>;
+    private set state(value);
+    static ok<T>(value: T): AsyncResult<T, never>;
+    static err<E>(error: E): AsyncResult<never, E>;
+    isSuccess(): boolean;
+    isError(): boolean;
+    isLoading(): boolean;
+    listen(listener: AsyncResultListener<T, E>, immediate?: boolean): () => void;
+    listenUntilSettled(listener: AsyncResultListener<T, E>, immediate?: boolean): () => void;
+    setState(newState: AsyncResultState<T, E>): void;
+    copyOnceSettled(other: AsyncResult<T, E>): void;
+    update(newState: AsyncResultState<T, E>): void;
+    updateToValue(value: T): void;
+    updateToError(error: E): void;
+    updateFromResultPromise(promise: Promise<Result<T, E>>): void;
+    static fromResultPromise<T, E>(promise: Promise<Result<T, E>>): AsyncResult<T, E>;
+    updateFromValuePromise(promise: Promise<T>): void;
+    static fromValuePromise<T, E>(promise: Promise<T>): AsyncResult<T, E>;
+    waitForSettled(): Promise<AsyncResult<T, E>>;
+    waitForSettledResult(): Promise<Result<T, E>>;
+    toResultPromise(): Promise<Result<T, E>>;
+    toValuePromiseThrow(): Promise<T>;
+    toValueOrNullPromise(): Promise<T | null>;
+    unwrapOrNull(): T | null;
+    unwrapOrNullOnceSettled(): Promise<T | null>;
+    unwrapOrThrow(): T;
+    unwrapOrThrowOnceSettled(): Promise<T>;
+    chain<O, E2>(fn: ChainFunction<T, O, E | E2>): AsyncResult<O, E | E2>;
+    flatChain<O, E2>(fn: FlatChainFunction<T, O, E | E2>): AsyncResult<O, E | E2>;
+    mirror(other: AsyncResult<T, E>): () => void;
+    mirrorUntilSettled(other: AsyncResult<T, E>): () => void;
+    static ensureAvailable<R extends readonly AsyncResult<any, any>[]>(results: R): AsyncResult<{
+        [K in keyof R]: R[K] extends AsyncResult<infer T, any> ? T : never;
+    }, R[number] extends AsyncResult<any, infer E> ? E : never>;
+    [Symbol.iterator](): Generator<AsyncResult<T, E>, T, any>;
+    private static _runGeneratorProcessor;
+    static run<T, E = ErrorBase>(generatorFunc: () => Generator<AsyncResult<any, any>, T, any>): AsyncResult<T, E>;
+    runInPlace(generatorFunc: () => Generator<AsyncResult<any, any>, T, any>): void;
+}
+
+type KeyedAsyncCacheRefetchOptions = {
+    policy: 'refetch' | 'if-error' | 'no-refetch';
+};
+declare class KeyedAsyncCache<P, V, E = ErrorBase> {
+    private _cache;
+    private _fetcher;
+    private _paramsToKey;
+    constructor(fetcher: ChainFunction<P, V, E>, paramsToKey?: (params: P) => string);
+    private makeCacheItem;
+    private shouldRefetch;
+    get(params: P, refetch?: KeyedAsyncCacheRefetchOptions): AsyncResult<V, E>;
+    getSettledState(params: P, refetch?: KeyedAsyncCacheRefetchOptions): Promise<AsyncResultState<V, E>>;
+    anyLoading(): boolean;
+    clear(): void;
+}
+
+export { AsyncResult, type AsyncResultListener, type AsyncResultState, type ChainFunction, ErrorBase, type FlatChainFunction, KeyedAsyncCache, Result, type ResultState };

package/dist/core/index.d.ts

@@ -0,0 +1,105 @@
+declare class ErrorBase {
+    code: string;
+    message?: string | undefined;
+    thrownError?: any;
+    constructor(code: string, message?: string, thrownError?: any, log?: boolean);
+    toString(): string;
+    logError(): void;
+}
+
+type ResultState<T, E = ErrorBase> = {
+    status: 'success';
+    value: T;
+} | {
+    status: 'error';
+    error: E;
+};
+declare class Result<T, E = ErrorBase> {
+    private _state;
+    constructor(state: ResultState<T, E>);
+    get state(): ResultState<T, E>;
+    static ok<T, E = ErrorBase>(value: T): Result<T, E>;
+    static err<E>(error: E): Result<never, E>;
+    static errTag(code: string, message?: string): Result<never, ErrorBase>;
+    unwrapOrNull(): T | null;
+    unwrapOrThrow(): T;
+    unwrapOr<O>(defaultValue: O): T | O;
+    isSuccess(): boolean;
+    isError(): boolean;
+    static tryPromise<T, E>(promise: Promise<T>, errorMapper: (error: unknown) => E): Promise<Result<T, E>>;
+    static tryFunction<T, E extends ErrorBase = ErrorBase>(fn: () => Promise<T>, errorMapper: (error: unknown) => E): Promise<Result<T, E>>;
+    chain<O, E2>(fn: (input: T) => ResultState<O, E | E2>): Result<O, E | E2>;
+    [Symbol.iterator](): Generator<Result<T, E>, T, any>;
+    static run<T, E>(generator: () => Generator<Result<any, E>, T, any>): Result<T, E>;
+}
+
+type AsyncResultState<T, E> = {
+    status: 'idle';
+} | {
+    status: 'loading';
+    promise: Promise<Result<T, E>>;
+} | ResultState<T, E>;
+type ChainFunction<I, O, E> = (input: I) => Result<O, E> | Promise<Result<O, E>>;
+type FlatChainFunction<I, O, E> = (input: I) => AsyncResult<O, E>;
+type AsyncResultListener<T, E> = (result: AsyncResult<T, E>) => any;
+declare class AsyncResult<T, E = ErrorBase> {
+    private _state;
+    private _listeners;
+    constructor(state?: AsyncResultState<T, E>);
+    get state(): AsyncResultState<T, E>;
+    private set state(value);
+    static ok<T>(value: T): AsyncResult<T, never>;
+    static err<E>(error: E): AsyncResult<never, E>;
+    isSuccess(): boolean;
+    isError(): boolean;
+    isLoading(): boolean;
+    listen(listener: AsyncResultListener<T, E>, immediate?: boolean): () => void;
+    listenUntilSettled(listener: AsyncResultListener<T, E>, immediate?: boolean): () => void;
+    setState(newState: AsyncResultState<T, E>): void;
+    copyOnceSettled(other: AsyncResult<T, E>): void;
+    update(newState: AsyncResultState<T, E>): void;
+    updateToValue(value: T): void;
+    updateToError(error: E): void;
+    updateFromResultPromise(promise: Promise<Result<T, E>>): void;
+    static fromResultPromise<T, E>(promise: Promise<Result<T, E>>): AsyncResult<T, E>;
+    updateFromValuePromise(promise: Promise<T>): void;
+    static fromValuePromise<T, E>(promise: Promise<T>): AsyncResult<T, E>;
+    waitForSettled(): Promise<AsyncResult<T, E>>;
+    waitForSettledResult(): Promise<Result<T, E>>;
+    toResultPromise(): Promise<Result<T, E>>;
+    toValuePromiseThrow(): Promise<T>;
+    toValueOrNullPromise(): Promise<T | null>;
+    unwrapOrNull(): T | null;
+    unwrapOrNullOnceSettled(): Promise<T | null>;
+    unwrapOrThrow(): T;
+    unwrapOrThrowOnceSettled(): Promise<T>;
+    chain<O, E2>(fn: ChainFunction<T, O, E | E2>): AsyncResult<O, E | E2>;
+    flatChain<O, E2>(fn: FlatChainFunction<T, O, E | E2>): AsyncResult<O, E | E2>;
+    mirror(other: AsyncResult<T, E>): () => void;
+    mirrorUntilSettled(other: AsyncResult<T, E>): () => void;
+    static ensureAvailable<R extends readonly AsyncResult<any, any>[]>(results: R): AsyncResult<{
+        [K in keyof R]: R[K] extends AsyncResult<infer T, any> ? T : never;
+    }, R[number] extends AsyncResult<any, infer E> ? E : never>;
+    [Symbol.iterator](): Generator<AsyncResult<T, E>, T, any>;
+    private static _runGeneratorProcessor;
+    static run<T, E = ErrorBase>(generatorFunc: () => Generator<AsyncResult<any, any>, T, any>): AsyncResult<T, E>;
+    runInPlace(generatorFunc: () => Generator<AsyncResult<any, any>, T, any>): void;
+}
+
+type KeyedAsyncCacheRefetchOptions = {
+    policy: 'refetch' | 'if-error' | 'no-refetch';
+};
+declare class KeyedAsyncCache<P, V, E = ErrorBase> {
+    private _cache;
+    private _fetcher;
+    private _paramsToKey;
+    constructor(fetcher: ChainFunction<P, V, E>, paramsToKey?: (params: P) => string);
+    private makeCacheItem;
+    private shouldRefetch;
+    get(params: P, refetch?: KeyedAsyncCacheRefetchOptions): AsyncResult<V, E>;
+    getSettledState(params: P, refetch?: KeyedAsyncCacheRefetchOptions): Promise<AsyncResultState<V, E>>;
+    anyLoading(): boolean;
+    clear(): void;
+}
+
+export { AsyncResult, type AsyncResultListener, type AsyncResultState, type ChainFunction, ErrorBase, type FlatChainFunction, KeyedAsyncCache, Result, type ResultState };

package/dist/core/index.js

@@ -0,0 +1,434 @@
+"use strict";
+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);
+
+// src/core/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AsyncResult: () => AsyncResult,
+  ErrorBase: () => ErrorBase,
+  KeyedAsyncCache: () => KeyedAsyncCache,
+  Result: () => Result
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/error.ts
+var ErrorBase = class {
+  code;
+  message;
+  thrownError;
+  constructor(code, message, thrownError, log = true) {
+    this.code = code;
+    this.message = message;
+    this.thrownError = thrownError;
+    if (log) {
+      this.logError();
+    }
+  }
+  toString() {
+    return `Error ${this.code}: ${this.message ?? ""}`;
+  }
+  logError() {
+    console.error(this.toString(), this.thrownError);
+  }
+};
+
+// src/core/result.ts
+var Result = class _Result {
+  _state;
+  constructor(state) {
+    this._state = state;
+  }
+  get state() {
+    return this._state;
+  }
+  static ok(value) {
+    return new _Result({ status: "success", value });
+  }
+  static err(error) {
+    return new _Result({ status: "error", error });
+  }
+  static errTag(code, message) {
+    return _Result.err(new ErrorBase(code, message));
+  }
+  unwrapOrNull() {
+    if (this._state.status === "success") {
+      return this._state.value;
+    }
+    return null;
+  }
+  unwrapOrThrow() {
+    if (this._state.status === "success") {
+      return this._state.value;
+    }
+    throw new Error("Tried to unwrap a Result that is not successful");
+  }
+  unwrapOr(defaultValue) {
+    if (this._state.status === "success") {
+      return this._state.value;
+    }
+    return defaultValue;
+  }
+  isSuccess() {
+    return this._state.status === "success";
+  }
+  isError() {
+    return this._state.status === "error";
+  }
+  static tryPromise(promise, errorMapper) {
+    return promise.then((value) => _Result.ok(value)).catch((error) => _Result.err(errorMapper(error)));
+  }
+  static tryFunction(fn, errorMapper) {
+    return _Result.tryPromise(fn(), errorMapper);
+  }
+  chain(fn) {
+    if (this._state.status === "success") {
+      return new _Result(fn(this._state.value));
+    }
+    return _Result.err(this._state.error);
+  }
+  *[Symbol.iterator]() {
+    yield this;
+    if (this._state.status === "success") {
+      return this._state.value;
+    }
+    return void 0;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static run(generator) {
+    const iterator = generator();
+    let result = iterator.next();
+    while (!result.done) {
+      const yielded = result.value;
+      if (yielded._state.status === "error") {
+        return _Result.err(yielded._state.error);
+      }
+      result = iterator.next(yielded._state.value);
+    }
+    return _Result.ok(result.value);
+  }
+};
+
+// src/core/asyncResult.ts
+var AsyncResult = class _AsyncResult {
+  _state;
+  _listeners = /* @__PURE__ */ new Set();
+  constructor(state) {
+    this._state = state || { status: "idle" };
+  }
+  get state() {
+    return this._state;
+  }
+  set state(newState) {
+    this._state = newState;
+    this._listeners.forEach((listener) => listener(this));
+  }
+  static ok(value) {
+    return new _AsyncResult({ status: "success", value });
+  }
+  static err(error) {
+    return new _AsyncResult({ status: "error", error });
+  }
+  isSuccess() {
+    return this._state.status === "success";
+  }
+  isError() {
+    return this._state.status === "error";
+  }
+  isLoading() {
+    return this._state.status === "loading";
+  }
+  listen(listener, immediate = true) {
+    this._listeners.add(listener);
+    if (immediate) {
+      listener(this);
+    }
+    return () => {
+      this._listeners.delete(listener);
+    };
+  }
+  listenUntilSettled(listener, immediate = true) {
+    const unsub = this.listen((result) => {
+      listener(result);
+      if (result.state.status === "success" || result.state.status === "error") {
+        unsub();
+      }
+    }, immediate);
+    return unsub;
+  }
+  setState(newState) {
+    this.state = newState;
+  }
+  copyOnceSettled(other) {
+    this.updateFromResultPromise(other.toResultPromise());
+  }
+  update(newState) {
+    this.state = newState;
+  }
+  updateToValue(value) {
+    this.state = { status: "success", value };
+  }
+  updateToError(error) {
+    this.state = { status: "error", error };
+  }
+  updateFromResultPromise(promise) {
+    this.state = { status: "loading", promise };
+    promise.then((res) => {
+      this.state = res.state;
+    }).catch((error) => {
+      this.state = { status: "error", error };
+    });
+  }
+  static fromResultPromise(promise) {
+    const result = new _AsyncResult();
+    result.updateFromResultPromise(promise);
+    return result;
+  }
+  updateFromValuePromise(promise) {
+    const resultStatePromise = async () => {
+      try {
+        const value = await promise;
+        return Result.ok(value);
+      } catch (error) {
+        return Result.err(error);
+      }
+    };
+    this.updateFromResultPromise(resultStatePromise());
+  }
+  static fromValuePromise(promise) {
+    const result = new _AsyncResult();
+    result.updateFromValuePromise(promise);
+    return result;
+  }
+  async waitForSettled() {
+    if (this._state.status === "loading") {
+      try {
+        const value = await this._state.promise;
+        this._state = value.state;
+      } catch (error) {
+        this._state = { status: "error", error };
+      }
+    }
+    return this;
+  }
+  async waitForSettledResult() {
+    const settled = await this.waitForSettled();
+    if (settled.state.status === "idle" || settled.state.status === "loading") {
+      throw new Error("Cannot convert idle or loading AsyncResult to ResultState");
+    }
+    if (settled.state.status === "error") {
+      return Result.err(settled.state.error);
+    }
+    return Result.ok(settled.state.value);
+  }
+  async toResultPromise() {
+    if (this._state.status === "idle") {
+      throw new Error("Cannot convert idle AsyncResult to ResultState");
+    }
+    if (this._state.status === "loading") {
+      try {
+        const value = await this._state.promise;
+        this._state = value.state;
+      } catch (error) {
+        this._state = { status: "error", error };
+      }
+    }
+    return new Result(this._state);
+  }
+  async toValuePromiseThrow() {
+    const settled = await this.waitForSettled();
+    return settled.unwrapOrThrow();
+  }
+  async toValueOrNullPromise() {
+    const settled = await this.waitForSettled();
+    return settled.unwrapOrNull();
+  }
+  unwrapOrNull() {
+    if (this._state.status === "success") {
+      return this._state.value;
+    }
+    return null;
+  }
+  async unwrapOrNullOnceSettled() {
+    return (await this.waitForSettled()).unwrapOrNull();
+  }
+  unwrapOrThrow() {
+    if (this._state.status === "success") {
+      return this._state.value;
+    }
+    throw new Error("Tried to unwrap an AsyncResult that is not successful");
+  }
+  async unwrapOrThrowOnceSettled() {
+    return (await this.waitForSettled()).unwrapOrThrow();
+  }
+  chain(fn) {
+    const newResultBuilder = async () => {
+      const settled = await this.waitForSettled();
+      if (settled.state.status === "loading" || settled.state.status === "idle") {
+        throw new Error("Unexpected state after waitForSettled");
+      }
+      if (settled.state.status === "error") {
+        return Result.err(settled.state.error);
+      }
+      return fn(settled.state.value);
+    };
+    return _AsyncResult.fromResultPromise(newResultBuilder());
+  }
+  flatChain(fn) {
+    const newResultBuilder = async () => {
+      const settled = await this.waitForSettledResult();
+      if (settled.state.status === "error") {
+        return Result.err(settled.state.error);
+      }
+      const nextAsyncResult = fn(settled.state.value);
+      const nextSettled = await nextAsyncResult.waitForSettledResult();
+      return nextSettled;
+    };
+    return _AsyncResult.fromResultPromise(newResultBuilder());
+  }
+  // pipeParallel PipeFunction[] -> AsyncResult<T, E>[]
+  // pipeParallelAndCollapse PipeFunction[] -> AsyncResult<T[], E>
+  mirror(other) {
+    return other.listen((newState) => {
+      this.setState(newState.state);
+    }, true);
+  }
+  mirrorUntilSettled(other) {
+    return other.listenUntilSettled((newState) => {
+      this.setState(newState.state);
+    }, true);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static ensureAvailable(results) {
+    if (results.length === 0) {
+      return _AsyncResult.ok(void 0);
+    }
+    const promise = Promise.all(results.map((r) => r.waitForSettled())).then(
+      (settledResults) => {
+        for (const res of settledResults) {
+          if (res.state.status === "error") {
+            return Result.err(res.state.error);
+          }
+        }
+        const values = settledResults.map((r) => r.unwrapOrNull());
+        return Result.ok(values);
+      }
+    );
+    return _AsyncResult.fromResultPromise(promise);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  *[Symbol.iterator]() {
+    yield this;
+    if (this._state.status === "success") {
+      return this._state.value;
+    }
+    return void 0;
+  }
+  static _runGeneratorProcessor(iterator) {
+    return async () => {
+      let result = iterator.next();
+      while (!result.done) {
+        const yielded = result.value;
+        const settled = await yielded.waitForSettledResult();
+        if (settled.state.status === "error") {
+          return Result.err(settled.state.error);
+        }
+        result = iterator.next(settled.state.value);
+      }
+      return Result.ok(result.value);
+    };
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static run(generatorFunc) {
+    const iterator = generatorFunc();
+    return _AsyncResult.fromResultPromise(_AsyncResult._runGeneratorProcessor(iterator)());
+  }
+  runInPlace(generatorFunc) {
+    const iterator = generatorFunc();
+    this.updateFromResultPromise(_AsyncResult._runGeneratorProcessor(iterator)());
+  }
+};
+
+// src/core/cache.ts
+var _defaultRefetchOptions = { policy: "no-refetch" };
+function defaultParamsToKey(params) {
+  if (typeof params === "object") {
+    return JSON.stringify(params);
+  }
+  return String(params);
+}
+var KeyedAsyncCache = class {
+  _cache = /* @__PURE__ */ new Map();
+  _fetcher;
+  _paramsToKey;
+  constructor(fetcher, paramsToKey = defaultParamsToKey) {
+    this._fetcher = fetcher;
+    this._paramsToKey = paramsToKey;
+  }
+  makeCacheItem(result, fetcherParams) {
+    return { result, fetcherParams };
+  }
+  shouldRefetch(existingResult, refetch) {
+    if (refetch.policy === "refetch") {
+      return true;
+    }
+    if (refetch.policy === "if-error") {
+      return existingResult.result.state.status === "error";
+    }
+    return false;
+  }
+  get(params, refetch = _defaultRefetchOptions) {
+    const key = this._paramsToKey(params);
+    if (this._cache.has(key)) {
+      const cacheItem = this._cache.get(key);
+      if (!this.shouldRefetch(cacheItem, refetch)) {
+        return cacheItem.result;
+      } else {
+        cacheItem.result.updateFromResultPromise(Promise.resolve(this._fetcher(cacheItem.fetcherParams)));
+        return cacheItem.result;
+      }
+    }
+    const asyncResult = AsyncResult.fromResultPromise(Promise.resolve(this._fetcher(params)));
+    this._cache.set(key, this.makeCacheItem(asyncResult, params));
+    return asyncResult;
+  }
+  async getSettledState(params, refetch = _defaultRefetchOptions) {
+    const asyncResult = this.get(params, refetch);
+    await asyncResult.waitForSettled();
+    return asyncResult.state;
+  }
+  anyLoading() {
+    for (const cacheItem of this._cache.values()) {
+      if (cacheItem.result.isLoading()) {
+        return true;
+      }
+    }
+    return false;
+  }
+  clear() {
+    this._cache.clear();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AsyncResult,
+  ErrorBase,
+  KeyedAsyncCache,
+  Result
+});
+//# sourceMappingURL=index.js.map