@tstdl/base 0.85.13 → 0.86.0-beta1

package/utils/async-iterable-helpers/take-until.js

@@ -1,57 +1,40 @@
-"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 take_until_exports = {};
-__export(take_until_exports, {
-  takeUntilAsync: () => takeUntilAsync
-});
-module.exports = __toCommonJS(take_until_exports);
-var import_rxjs = require("rxjs");
-var import_is_async_iterable = require("./is-async-iterable.js");
-function takeUntilAsync(iterable, cancellationToken) {
-  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable, cancellationToken) : sync(iterable, cancellationToken);
+import { firstValueFrom, map, race } from 'rxjs';
+import { isAsyncIterable } from './is-async-iterable.js';
+export function takeUntilAsync(iterable, cancellationToken) {
+    return isAsyncIterable(iterable)
+        ? async(iterable, cancellationToken)
+        : sync(iterable, cancellationToken);
 }
+// eslint-disable-next-line @typescript-eslint/require-await
 async function* sync(iterable, cancellationToken) {
-  if (cancellationToken.isSet) {
-    return;
-  }
-  for (const item of iterable) {
-    yield item;
     if (cancellationToken.isSet) {
-      break;
+        return;
+    }
+    for (const item of iterable) {
+        yield item;
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (cancellationToken.isSet) {
+            break;
+        }
     }
-  }
 }
 async function* async(iterable, cancellationToken) {
-  const iterator = iterable[Symbol.asyncIterator]();
-  const cancel$ = cancellationToken.set$.pipe((0, import_rxjs.map)(() => ({ done: true, value: void 0 })));
-  try {
-    while (true) {
-      const result = await (0, import_rxjs.firstValueFrom)((0, import_rxjs.race)([iterator.next(), cancel$]));
-      if (result.done == true) {
-        return result.value;
-      }
-      yield result.value;
+    const iterator = iterable[Symbol.asyncIterator]();
+    const cancel$ = cancellationToken.set$.pipe(map(() => ({ done: true, value: undefined }))); // eslint-disable-line @typescript-eslint/no-unsafe-argument
+    try {
+        while (true) {
+            const result = await firstValueFrom(race([iterator.next(), cancel$]));
+            if (result.done == true) {
+                return result.value;
+            }
+            yield result.value;
+        }
+    }
+    catch (error) {
+        (iterator.throw ?? iterator.return)?.(error);
+    }
+    finally {
+        iterator.return?.();
     }
-  } catch (error) {
-    (iterator.throw ?? iterator.return)?.(error);
-  } finally {
-    iterator.return?.();
-  }
-  return void 0;
+    return undefined;
 }

package/utils/async-iterable-helpers/take-while.js

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

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

@@ -1,35 +1,12 @@
-"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 take_exports = {};
-__export(take_exports, {
-  takeAsync: () => takeAsync
-});
-module.exports = __toCommonJS(take_exports);
-async function* takeAsync(iterable, count) {
-  if (count <= 0) {
-    return;
-  }
-  let counter = 0;
-  for await (const item of iterable) {
-    yield item;
-    if (++counter >= count) {
-      break;
+export async function* takeAsync(iterable, count) {
+    if (count <= 0) {
+        return;
+    }
+    let counter = 0;
+    for await (const item of iterable) {
+        yield item;
+        if (++counter >= count) {
+            break;
+        }
     }
-  }
 }

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

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

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

@@ -1,31 +1,10 @@
-"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 throttle_exports = {};
-__export(throttle_exports, {
-  throttle: () => throttle
-});
-module.exports = __toCommonJS(throttle_exports);
-var import_timing = require("../timing.js");
-async function* throttle(iterable, delayOrThrottleFunction) {
-  const throttleFunction = typeof delayOrThrottleFunction == "number" ? () => (0, import_timing.timeout)(delayOrThrottleFunction) : delayOrThrottleFunction;
-  for await (const item of iterable) {
-    yield item;
-    await throttleFunction();
-  }
+import { timeout } from '../timing.js';
+export async function* throttle(iterable, delayOrThrottleFunction) {
+    const throttleFunction = (typeof delayOrThrottleFunction == 'number')
+        ? () => timeout(delayOrThrottleFunction) // eslint-disable-line @typescript-eslint/promise-function-async
+        : delayOrThrottleFunction;
+    for await (const item of iterable) {
+        yield item;
+        await throttleFunction();
+    }
 }

package/utils/async-iterable-helpers/to-array.js

@@ -1,34 +1,11 @@
-"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 to_array_exports = {};
-__export(to_array_exports, {
-  toArrayAsync: () => toArrayAsync
-});
-module.exports = __toCommonJS(to_array_exports);
-var import_is_iterable = require("../iterable-helpers/is-iterable.js");
-async function toArrayAsync(iterable) {
-  if ((0, import_is_iterable.isIterable)(iterable)) {
-    return [...iterable];
-  }
-  const array = [];
-  for await (const item of iterable) {
-    array.push(item);
-  }
-  return array;
+import { isIterable } from '../iterable-helpers/is-iterable.js';
+export async function toArrayAsync(iterable) {
+    if (isIterable(iterable)) {
+        return [...iterable];
+    }
+    const array = [];
+    for await (const item of iterable) {
+        array.push(item);
+    }
+    return array;
 }

package/utils/async-iterable-helpers/to-async-iterable-iterator.js

@@ -1,64 +1,45 @@
-"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 to_async_iterable_iterator_exports = {};
-__export(to_async_iterable_iterator_exports, {
-  asyncIteratorToAsyncIterableIterator: () => asyncIteratorToAsyncIterableIterator,
-  iterableToAsyncIterableIterator: () => iterableToAsyncIterableIterator,
-  iteratorToAsyncIterableIterator: () => iteratorToAsyncIterableIterator
-});
-module.exports = __toCommonJS(to_async_iterable_iterator_exports);
-async function* iterableToAsyncIterableIterator(iterable) {
-  yield* iterable;
+// eslint-disable-next-line @typescript-eslint/require-await
+export async function* iterableToAsyncIterableIterator(iterable) {
+    yield* iterable;
 }
-async function* iteratorToAsyncIterableIterator(iterator) {
-  try {
-    while (true) {
-      const result = iterator.next();
-      if (result.done == true) {
-        return result.value;
-      }
-      try {
-        yield result.value;
-      } catch (error) {
-        iterator.throw?.(error);
-        throw error;
-      }
+// eslint-disable-next-line @typescript-eslint/require-await
+export async function* iteratorToAsyncIterableIterator(iterator) {
+    try {
+        while (true) {
+            const result = iterator.next();
+            if (result.done == true) {
+                return result.value;
+            }
+            try {
+                yield result.value;
+            }
+            catch (error) {
+                iterator.throw?.(error);
+                throw error;
+            }
+        }
+    }
+    finally {
+        iterator.return?.();
     }
-  } finally {
-    iterator.return?.();
-  }
 }
-async function* asyncIteratorToAsyncIterableIterator(iterator) {
-  try {
-    while (true) {
-      const result = await iterator.next();
-      if (result.done == true) {
-        return result.value;
-      }
-      try {
-        yield result.value;
-      } catch (error) {
-        await iterator.throw?.(error);
-        throw error;
-      }
+export async function* asyncIteratorToAsyncIterableIterator(iterator) {
+    try {
+        while (true) {
+            const result = await iterator.next();
+            if (result.done == true) {
+                return result.value;
+            }
+            try {
+                yield result.value;
+            }
+            catch (error) {
+                await iterator.throw?.(error);
+                throw error;
+            }
+        }
+    }
+    finally {
+        await iterator.return?.();
     }
-  } finally {
-    await iterator.return?.();
-  }
 }

package/utils/async-iterable-helpers/to-async-iterator.js

@@ -1,57 +1,35 @@
-"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 to_async_iterator_exports = {};
-__export(to_async_iterator_exports, {
-  iterableToAsyncIterator: () => iterableToAsyncIterator,
-  iteratorToAsyncIterator: () => iteratorToAsyncIterator
-});
-module.exports = __toCommonJS(to_async_iterator_exports);
-var import_is_iterable = require("../iterable-helpers/is-iterable.js");
-var import_type_guards = require("../type-guards.js");
-var import_is_async_iterable = require("./is-async-iterable.js");
-function iterableToAsyncIterator(iterable) {
-  let asyncIterator;
-  if ((0, import_is_iterable.isIterable)(iterable)) {
-    const iterator = iterable[Symbol.iterator]();
-    asyncIterator = iteratorToAsyncIterator(iterator);
-  } else if ((0, import_is_async_iterable.isAsyncIterable)(iterable)) {
-    asyncIterator = iterable[Symbol.asyncIterator]();
-  } else {
-    throw new Error("parameter is neither iterable nor async-iterable");
-  }
-  return asyncIterator;
-}
-function iteratorToAsyncIterator(iterator) {
-  const asyncIterator = {
-    async next(...args) {
-      return iterator.next(...args);
+import { isIterable } from '../iterable-helpers/is-iterable.js';
+import { isDefined } from '../type-guards.js';
+import { isAsyncIterable } from './is-async-iterable.js';
+export function iterableToAsyncIterator(iterable) {
+    let asyncIterator;
+    if (isIterable(iterable)) {
+        const iterator = iterable[Symbol.iterator]();
+        asyncIterator = iteratorToAsyncIterator(iterator);
     }
-  };
-  if ((0, import_type_guards.isDefined)(iterator.return)) {
-    asyncIterator.return = async function _return(value) {
-      return iterator.return(await value);
-    };
-  }
-  if ((0, import_type_guards.isDefined)(iterator.throw)) {
-    asyncIterator.throw = async function _throw(error) {
-      return iterator.throw(error);
+    else if (isAsyncIterable(iterable)) {
+        asyncIterator = iterable[Symbol.asyncIterator]();
+    }
+    else {
+        throw new Error('parameter is neither iterable nor async-iterable');
+    }
+    return asyncIterator;
+}
+export function iteratorToAsyncIterator(iterator) {
+    const asyncIterator = {
+        async next(...args) {
+            return iterator.next(...args);
+        }
     };
-  }
-  return asyncIterator;
+    if (isDefined(iterator.return)) { // eslint-disable-line @typescript-eslint/unbound-method
+        asyncIterator.return = async function _return(value) {
+            return iterator.return(await value);
+        };
+    }
+    if (isDefined(iterator.throw)) { // eslint-disable-line @typescript-eslint/unbound-method
+        asyncIterator.throw = async function _throw(error) {
+            return iterator.throw(error);
+        };
+    }
+    return asyncIterator;
 }

package/utils/async-iterable-helpers/to-set.js

@@ -1,34 +1,11 @@
-"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 to_set_exports = {};
-__export(to_set_exports, {
-  toSetAsync: () => toSetAsync
-});
-module.exports = __toCommonJS(to_set_exports);
-var import_is_iterable = require("../iterable-helpers/is-iterable.js");
-async function toSetAsync(iterable) {
-  if ((0, import_is_iterable.isIterable)(iterable)) {
-    return new Set(iterable);
-  }
-  const set = /* @__PURE__ */ new Set();
-  for await (const item of iterable) {
-    set.add(item);
-  }
-  return set;
+import { isIterable } from '../iterable-helpers/is-iterable.js';
+export async function toSetAsync(iterable) {
+    if (isIterable(iterable)) {
+        return new Set(iterable);
+    }
+    const set = new Set();
+    for await (const item of iterable) {
+        set.add(item);
+    }
+    return set;
 }

package/utils/async-iterable-helpers/to-sync-iterable.js

@@ -1,28 +1,7 @@
-"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 to_sync_iterable_exports = {};
-__export(to_sync_iterable_exports, {
-  toSync: () => toSync
-});
-module.exports = __toCommonJS(to_sync_iterable_exports);
-var import_is_iterable = require("../iterable-helpers/is-iterable.js");
-var import_to_array = require("./to-array.js");
-async function toSync(iterable) {
-  return (0, import_is_iterable.isIterable)(iterable) ? iterable : (0, import_to_array.toArrayAsync)(iterable);
+import { isIterable } from '../iterable-helpers/is-iterable.js';
+import { toArrayAsync } from './to-array.js';
+export async function toSync(iterable) {
+    return (isIterable(iterable))
+        ? iterable
+        : toArrayAsync(iterable);
 }