@tstdl/base 0.86.0-beta1 → 0.86.0-beta10

package/utils/async-iterable-helpers/buffer.js

@@ -1,53 +1,70 @@
-import { CircularBuffer } from '../../data-structures/circular-buffer.js';
-import { CancellationToken } from '../cancellation-token.js';
-import { hasOwnProperty } from '../object/object.js';
-import { takeUntilAsync } from './take-until.js';
-// eslint-disable-next-line max-lines-per-function, max-statements
-export async function* bufferAsync(iterable, size) {
-    const buffer = new CircularBuffer(Math.max(1, size));
-    const consumerEndedToken = new CancellationToken();
-    let consumerHasError = false;
-    let consumerError;
-    void (async () => {
-        try {
-            for await (const item of takeUntilAsync(iterable, consumerEndedToken)) {
-                buffer.add({ end: false, value: item });
-                if (buffer.isFull) {
-                    await buffer.$onFreeSlots;
-                }
-                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-                if (consumerHasError) {
-                    throw consumerError;
-                }
-                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-                if (consumerEndedToken.isSet) {
-                    return;
-                }
-            }
-            buffer.add({ end: true });
+"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);
+var buffer_exports = {};
+__export(buffer_exports, {
+  bufferAsync: () => bufferAsync
+});
+module.exports = __toCommonJS(buffer_exports);
+var import_circular_buffer = require("../../data-structures/circular-buffer.js");
+var import_cancellation_token = require("../cancellation-token.js");
+var import_object = require("../object/object.js");
+var import_take_until = require("./take-until.js");
+async function* bufferAsync(iterable, size) {
+  const buffer = new import_circular_buffer.CircularBuffer(Math.max(1, size));
+  const consumerEndedToken = new import_cancellation_token.CancellationToken();
+  let consumerHasError = false;
+  let consumerError;
+  void (async () => {
+    try {
+      for await (const item of (0, import_take_until.takeUntilAsync)(iterable, consumerEndedToken)) {
+        buffer.add({ end: false, value: item });
+        if (buffer.isFull) {
+          await buffer.$onFreeSlots;
         }
-        catch (error) {
-            buffer.add({ end: true, error: error });
+        if (consumerHasError) {
+          throw consumerError;
         }
-    })();
-    try {
-        for await (const item of buffer.consumeAsync()) {
-            if (item.end) {
-                if (hasOwnProperty(item, 'error')) {
-                    throw item.error;
-                }
-                break;
-            }
-            yield item.value;
+        if (consumerEndedToken.isSet) {
+          return;
         }
+      }
+      buffer.add({ end: true });
+    } catch (error) {
+      buffer.add({ end: true, error });
     }
-    catch (error) {
-        consumerHasError = true;
-        consumerError = error;
-        throw error;
-    }
-    finally {
-        consumerEndedToken.set();
-        buffer.clear();
+  })();
+  try {
+    for await (const item of buffer.consumeAsync()) {
+      if (item.end) {
+        if ((0, import_object.hasOwnProperty)(item, "error")) {
+          throw item.error;
+        }
+        break;
+      }
+      yield item.value;
     }
+  } catch (error) {
+    consumerHasError = true;
+    consumerError = error;
+    throw error;
+  } finally {
+    consumerEndedToken.set();
+    buffer.clear();
+  }
 }

package/utils/async-iterable-helpers/concat.js

@@ -1,6 +1,28 @@
-// eslint-disable-next-line @typescript-eslint/require-await
-export async function* concatAsync(...iterables) {
-    for (const iterable of iterables) {
-        yield* iterable;
-    }
+"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);
+var concat_exports = {};
+__export(concat_exports, {
+  concatAsync: () => concatAsync
+});
+module.exports = __toCommonJS(concat_exports);
+async function* concatAsync(...iterables) {
+  for (const iterable of iterables) {
+    yield* iterable;
+  }
 }

package/utils/async-iterable-helpers/default-if-empty.js

@@ -1,10 +1,33 @@
-export async function* defaultIfEmptyAsync(iterable, defaultValue) {
-    let empty = true;
-    for await (const item of iterable) {
-        empty = false;
-        yield item;
-    }
-    if (empty) {
-        yield defaultValue;
-    }
+"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);
+var default_if_empty_exports = {};
+__export(default_if_empty_exports, {
+  defaultIfEmptyAsync: () => defaultIfEmptyAsync
+});
+module.exports = __toCommonJS(default_if_empty_exports);
+async function* defaultIfEmptyAsync(iterable, defaultValue) {
+  let empty = true;
+  for await (const item of iterable) {
+    empty = false;
+    yield item;
+  }
+  if (empty) {
+    yield defaultValue;
+  }
 }

package/utils/async-iterable-helpers/deferred.js

@@ -1,4 +1,27 @@
-export async function* deferredAsyncIterable(source) {
-    const iterable = await source();
-    yield* iterable;
+"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);
+var deferred_exports = {};
+__export(deferred_exports, {
+  deferredAsyncIterable: () => deferredAsyncIterable
+});
+module.exports = __toCommonJS(deferred_exports);
+async function* deferredAsyncIterable(source) {
+  const iterable = await source();
+  yield* iterable;
 }

package/utils/async-iterable-helpers/difference.js

@@ -1,28 +1,52 @@
-import { concatAsync } from './concat.js';
-import { mapAsync } from './map.js';
-import { toArrayAsync } from './to-array.js';
-export async function* differenceAsync(baseIterable, iterable, selector = (item) => item) {
-    const diffItems = mapAsync(iterable, selector);
-    const diffItemsArray = await toArrayAsync(diffItems);
-    const diffItemsSet = new Set(diffItemsArray);
-    let index = 0;
-    for await (const item of baseIterable) {
-        const selected = await selector(item, index++);
-        if (!diffItemsSet.has(selected)) {
-            yield item;
-        }
+"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);
+var difference_exports = {};
+__export(difference_exports, {
+  differenceAsync: () => differenceAsync,
+  differenceManyAsync: () => differenceManyAsync
+});
+module.exports = __toCommonJS(difference_exports);
+var import_concat = require("./concat.js");
+var import_map = require("./map.js");
+var import_to_array = require("./to-array.js");
+async function* differenceAsync(baseIterable, iterable, selector = (item) => item) {
+  const diffItems = (0, import_map.mapAsync)(iterable, selector);
+  const diffItemsArray = await (0, import_to_array.toArrayAsync)(diffItems);
+  const diffItemsSet = new Set(diffItemsArray);
+  let index = 0;
+  for await (const item of baseIterable) {
+    const selected = await selector(item, index++);
+    if (!diffItemsSet.has(selected)) {
+      yield item;
     }
+  }
 }
-export async function* differenceManyAsync(baseIterable, iterables, selector = (item) => item) {
-    const items = concatAsync(...iterables);
-    const diffItems = mapAsync(items, selector);
-    const diffItemsArray = await toArrayAsync(diffItems);
-    const diffItemsSet = new Set(diffItemsArray);
-    let index = 0;
-    for await (const item of baseIterable) {
-        const selected = selector(item, index++);
-        if (!diffItemsSet.has(selected)) {
-            yield item;
-        }
+async function* differenceManyAsync(baseIterable, iterables, selector = (item) => item) {
+  const items = (0, import_concat.concatAsync)(...iterables);
+  const diffItems = (0, import_map.mapAsync)(items, selector);
+  const diffItemsArray = await (0, import_to_array.toArrayAsync)(diffItems);
+  const diffItemsSet = new Set(diffItemsArray);
+  let index = 0;
+  for await (const item of baseIterable) {
+    const selected = selector(item, index++);
+    if (!diffItemsSet.has(selected)) {
+      yield item;
     }
+  }
 }

package/utils/async-iterable-helpers/distinct.js

@@ -1,30 +1,51 @@
-import { isAsyncIterable } from './is-async-iterable.js';
-export function distinctAsync(iterable, selector = (item) => item) {
-    return isAsyncIterable(iterable)
-        ? async(iterable, selector)
-        : sync(iterable, selector);
+"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);
+var distinct_exports = {};
+__export(distinct_exports, {
+  distinctAsync: () => distinctAsync
+});
+module.exports = __toCommonJS(distinct_exports);
+var import_is_async_iterable = require("./is-async-iterable.js");
+function distinctAsync(iterable, selector = (item) => item) {
+  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable, selector) : sync(iterable, selector);
 }
 async function* sync(iterable, selector) {
-    const items = new Set();
-    let index = 0;
-    for (const item of iterable) {
-        const returnValue = selector(item, index++);
-        const selection = (returnValue instanceof Promise) ? await returnValue : returnValue;
-        if (!items.has(selection)) {
-            items.add(selection);
-            yield item;
-        }
+  const items = /* @__PURE__ */ new Set();
+  let index = 0;
+  for (const item of iterable) {
+    const returnValue = selector(item, index++);
+    const selection = returnValue instanceof Promise ? await returnValue : returnValue;
+    if (!items.has(selection)) {
+      items.add(selection);
+      yield item;
     }
+  }
 }
 async function* async(iterable, selector) {
-    const items = new Set();
-    let index = 0;
-    for await (const item of iterable) {
-        const returnValue = selector(item, index++);
-        const selection = (returnValue instanceof Promise) ? await returnValue : returnValue;
-        if (!items.has(selection)) {
-            items.add(selection);
-            yield item;
-        }
+  const items = /* @__PURE__ */ new Set();
+  let index = 0;
+  for await (const item of iterable) {
+    const returnValue = selector(item, index++);
+    const selection = returnValue instanceof Promise ? await returnValue : returnValue;
+    if (!items.has(selection)) {
+      items.add(selection);
+      yield item;
     }
+  }
 }

package/utils/async-iterable-helpers/drain.js

@@ -1,5 +1,27 @@
-export async function drainAsync(iterable) {
-    for await (const _item of iterable) {
-        // just drain
-    }
+"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);
+var drain_exports = {};
+__export(drain_exports, {
+  drainAsync: () => drainAsync
+});
+module.exports = __toCommonJS(drain_exports);
+async function drainAsync(iterable) {
+  for await (const _item of iterable) {
+  }
 }

package/utils/async-iterable-helpers/filter.js

@@ -1,30 +1,51 @@
-import { isAsyncIterable } from './is-async-iterable.js';
-export function filterAsync(iterable, predicate) {
-    return isAsyncIterable(iterable)
-        ? async(iterable, predicate)
-        : sync(iterable, predicate);
+"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);
+var filter_exports = {};
+__export(filter_exports, {
+  filterAsync: () => filterAsync
+});
+module.exports = __toCommonJS(filter_exports);
+var import_is_async_iterable = require("./is-async-iterable.js");
+function filterAsync(iterable, predicate) {
+  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable, predicate) : sync(iterable, predicate);
 }
 async function* sync(iterable, predicate) {
-    let index = 0;
-    for (const item of iterable) {
-        let matches = predicate(item, index++);
-        if (matches instanceof Promise) {
-            matches = await matches;
-        }
-        if (matches) {
-            yield item;
-        }
+  let index = 0;
+  for (const item of iterable) {
+    let matches = predicate(item, index++);
+    if (matches instanceof Promise) {
+      matches = await matches;
     }
+    if (matches) {
+      yield item;
+    }
+  }
 }
 async function* async(iterable, predicate) {
-    let index = 0;
-    for await (const item of iterable) {
-        let matches = predicate(item, index++);
-        if (matches instanceof Promise) {
-            matches = await matches;
-        }
-        if (matches) {
-            yield item;
-        }
+  let index = 0;
+  for await (const item of iterable) {
+    let matches = predicate(item, index++);
+    if (matches instanceof Promise) {
+      matches = await matches;
+    }
+    if (matches) {
+      yield item;
     }
+  }
 }

package/utils/async-iterable-helpers/first-or-default.js

@@ -1,9 +1,31 @@
-import { filterAsync } from './filter.js';
-export async function firstOrDefaultAsync(iterable, defaultValue, predicate) {
-    const source = (predicate == undefined) ? iterable : filterAsync(iterable, predicate);
-    // eslint-disable-next-line no-unreachable-loop
-    for await (const item of source) {
-        return item;
-    }
-    return defaultValue;
+"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);
+var first_or_default_exports = {};
+__export(first_or_default_exports, {
+  firstOrDefaultAsync: () => firstOrDefaultAsync
+});
+module.exports = __toCommonJS(first_or_default_exports);
+var import_filter = require("./filter.js");
+async function firstOrDefaultAsync(iterable, defaultValue, predicate) {
+  const source = predicate == void 0 ? iterable : (0, import_filter.filterAsync)(iterable, predicate);
+  for await (const item of source) {
+    return item;
+  }
+  return defaultValue;
 }

package/utils/async-iterable-helpers/first.js

@@ -1,9 +1,31 @@
-import { filterAsync } from './filter.js';
-export async function firstAsync(iterable, predicate) {
-    const source = (predicate == undefined) ? iterable : filterAsync(iterable, predicate);
-    // eslint-disable-next-line no-unreachable-loop
-    for await (const item of source) {
-        return item;
-    }
-    throw new Error('iterable was either empty or no element matched predicate');
+"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);
+var first_exports = {};
+__export(first_exports, {
+  firstAsync: () => firstAsync
+});
+module.exports = __toCommonJS(first_exports);
+var import_filter = require("./filter.js");
+async function firstAsync(iterable, predicate) {
+  const source = predicate == void 0 ? iterable : (0, import_filter.filterAsync)(iterable, predicate);
+  for await (const item of source) {
+    return item;
+  }
+  throw new Error("iterable was either empty or no element matched predicate");
 }

package/utils/async-iterable-helpers/for-each.js

@@ -1,25 +1,45 @@
-import { isAsyncIterable } from './is-async-iterable.js';
-// eslint-disable-next-line @typescript-eslint/promise-function-async
-export function forEachAsync(iterable, func) {
-    return isAsyncIterable(iterable)
-        ? async(iterable, func)
-        : sync(iterable, func);
+"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);
+var for_each_exports = {};
+__export(for_each_exports, {
+  forEachAsync: () => forEachAsync
+});
+module.exports = __toCommonJS(for_each_exports);
+var import_is_async_iterable = require("./is-async-iterable.js");
+function forEachAsync(iterable, func) {
+  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable, func) : sync(iterable, func);
 }
 async function sync(iterable, func) {
-    let index = 0;
-    for (const item of iterable) {
-        const returnValue = func(item, index++);
-        if (returnValue instanceof Promise) {
-            await returnValue;
-        }
+  let index = 0;
+  for (const item of iterable) {
+    const returnValue = func(item, index++);
+    if (returnValue instanceof Promise) {
+      await returnValue;
     }
+  }
 }
 async function async(iterable, func) {
-    let index = 0;
-    for await (const item of iterable) {
-        const returnValue = func(item, index++);
-        if (returnValue instanceof Promise) {
-            await returnValue;
-        }
+  let index = 0;
+  for await (const item of iterable) {
+    const returnValue = func(item, index++);
+    if (returnValue instanceof Promise) {
+      await returnValue;
     }
+  }
 }