@tstdl/base 0.86.0-beta1 → 0.86.0-beta10

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

@@ -1,40 +1,57 @@
-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);
+"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);
 }
-// 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) {
-        return;
-    }
-    for (const item of iterable) {
-        yield item;
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        if (cancellationToken.isSet) {
-            break;
-        }
+      break;
     }
+  }
 }
 async function* async(iterable, cancellationToken) {
-    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?.();
+  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;
     }
-    return undefined;
+  } catch (error) {
+    (iterator.throw ?? iterator.return)?.(error);
+  } finally {
+    iterator.return?.();
+  }
+  return void 0;
 }

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

@@ -1,36 +1,53 @@
-import { isAsyncIterable } from './is-async-iterable.js';
-export function takeWhileAsync(iterable, yieldLastOnFalse, predicate) {
-    return isAsyncIterable(iterable)
-        ? async(iterable, yieldLastOnFalse, predicate)
-        : sync(iterable, yieldLastOnFalse, 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 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);
 }
 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;
-        }
-        if (!take) {
-            break;
-        }
+  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;
+    }
+  }
 }
 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,12 +1,35 @@
-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;
-        }
+"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;
     }
+  }
 }

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

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

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

@@ -1,10 +1,31 @@
-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();
-    }
+"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();
+  }
 }

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

@@ -1,11 +1,34 @@
-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;
+"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;
 }

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

@@ -1,45 +1,64 @@
-// eslint-disable-next-line @typescript-eslint/require-await
-export async function* iterableToAsyncIterableIterator(iterable) {
-    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 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* 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?.();
+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?.();
+  }
 }
-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?.();
+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?.();
+  }
 }

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

@@ -1,35 +1,57 @@
-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);
-    }
-    else if (isAsyncIterable(iterable)) {
-        asyncIterator = iterable[Symbol.asyncIterator]();
-    }
-    else {
-        throw new Error('parameter is neither iterable nor async-iterable');
-    }
-    return asyncIterator;
+"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;
 }
-export function iteratorToAsyncIterator(iterator) {
-    const asyncIterator = {
-        async next(...args) {
-            return iterator.next(...args);
-        }
-    };
-    if (isDefined(iterator.return)) { // eslint-disable-line @typescript-eslint/unbound-method
-        asyncIterator.return = async function _return(value) {
-            return iterator.return(await value);
-        };
+function iteratorToAsyncIterator(iterator) {
+  const asyncIterator = {
+    async next(...args) {
+      return iterator.next(...args);
     }
-    if (isDefined(iterator.throw)) { // eslint-disable-line @typescript-eslint/unbound-method
-        asyncIterator.throw = async function _throw(error) {
-            return iterator.throw(error);
-        };
-    }
-    return asyncIterator;
+  };
+  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);
+    };
+  }
+  return asyncIterator;
 }

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

@@ -1,11 +1,34 @@
-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;
+"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;
 }

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

@@ -1,7 +1,28 @@
-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);
+"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);
 }