@tstdl/base 0.86.0-beta2 → 0.86.0-beta4

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

@@ -1,24 +1,47 @@
-import { ObservableSet } from '../../../collections/observable/observable-set.js';
-import { MultiError } from '../../../error/multi.error.js';
-export async function parallelForEach(iterable, concurrency, func) {
-    const running = new ObservableSet();
-    const errors = [];
-    let index = 0;
-    for await (const item of iterable) {
-        if (errors.length > 0) {
-            break;
-        }
-        const run = func(item, index++);
-        running.add(run);
-        run.catch((error) => errors.push(error)).finally(() => running.delete(run));
-        if (running.length >= concurrency) {
-            await running.$length;
-        }
-    }
-    while (running.length > 0) {
-        await running.$empty;
-    }
+"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, {
+  parallelForEach: () => parallelForEach
+});
+module.exports = __toCommonJS(for_each_exports);
+var import_observable_set = require("../../../collections/observable/observable-set.js");
+var import_multi_error = require("../../../error/multi.error.js");
+async function parallelForEach(iterable, concurrency, func) {
+  const running = new import_observable_set.ObservableSet();
+  const errors = [];
+  let index = 0;
+  for await (const item of iterable) {
     if (errors.length > 0) {
-        throw (errors.length > 1) ? new MultiError(errors) : errors[0];
+      break;
+    }
+    const run = func(item, index++);
+    running.add(run);
+    run.catch((error) => errors.push(error)).finally(() => running.delete(run));
+    if (running.length >= concurrency) {
+      await running.$length;
     }
+  }
+  while (running.length > 0) {
+    await running.$empty;
+  }
+  if (errors.length > 0) {
+    throw errors.length > 1 ? new import_multi_error.MultiError(errors) : errors[0];
+  }
 }

package/utils/async-iterable-helpers/parallel/group.js

@@ -1,10 +1,33 @@
-import { FactoryMap } from '../../factory-map.js';
-import { parallelForEach } from './for-each.js';
-export async function parallelGroup(iterable, concurrency, selector) {
-    const map = new FactoryMap(() => []);
-    await parallelForEach(iterable, concurrency, async (item, index) => {
-        const groupKey = await selector(item, index);
-        map.get(groupKey).push(item);
-    });
-    return map.backingMap;
+"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 group_exports = {};
+__export(group_exports, {
+  parallelGroup: () => parallelGroup
+});
+module.exports = __toCommonJS(group_exports);
+var import_factory_map = require("../../factory-map.js");
+var import_for_each = require("./for-each.js");
+async function parallelGroup(iterable, concurrency, selector) {
+  const map = new import_factory_map.FactoryMap(() => []);
+  await (0, import_for_each.parallelForEach)(iterable, concurrency, async (item, index) => {
+    const groupKey = await selector(item, index);
+    map.get(groupKey).push(item);
+  });
+  return map.backingMap;
 }

package/utils/async-iterable-helpers/parallel/index.js

@@ -1,7 +1,24 @@
-export * from './feed.js';
-export * from './filter.js';
-export * from './for-each.js';
-export * from './group.js';
-export * from './map.js';
-export * from './tap.js';
-export * from './types.js';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parallel_exports = {};
+module.exports = __toCommonJS(parallel_exports);
+__reExport(parallel_exports, require("./feed.js"), module.exports);
+__reExport(parallel_exports, require("./filter.js"), module.exports);
+__reExport(parallel_exports, require("./for-each.js"), module.exports);
+__reExport(parallel_exports, require("./group.js"), module.exports);
+__reExport(parallel_exports, require("./map.js"), module.exports);
+__reExport(parallel_exports, require("./tap.js"), module.exports);
+__reExport(parallel_exports, require("./types.js"), module.exports);

package/utils/async-iterable-helpers/parallel/map.js

@@ -1,7 +1,30 @@
-import { parallelFeed } from './feed.js';
-export function parallelMap(iterable, concurrency, keepOrder, mapper) {
-    return parallelFeed(iterable, concurrency, keepOrder, async (item, index, feed) => {
-        const mapped = await mapper(item, index);
-        feed(mapped, index);
-    });
+"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 map_exports = {};
+__export(map_exports, {
+  parallelMap: () => parallelMap
+});
+module.exports = __toCommonJS(map_exports);
+var import_feed = require("./feed.js");
+function parallelMap(iterable, concurrency, keepOrder, mapper) {
+  return (0, import_feed.parallelFeed)(iterable, concurrency, keepOrder, async (item, index, feed) => {
+    const mapped = await mapper(item, index);
+    feed(mapped, index);
+  });
 }

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

@@ -1,7 +1,30 @@
-import { parallelFeed } from './feed.js';
-export function parallelTap(iterable, concurrency, keepOrder, tapper) {
-    return parallelFeed(iterable, concurrency, keepOrder, async (item, index, feed) => {
-        await tapper(item, index);
-        feed(item, index);
-    });
+"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, {
+  parallelTap: () => parallelTap
+});
+module.exports = __toCommonJS(tap_exports);
+var import_feed = require("./feed.js");
+function parallelTap(iterable, concurrency, keepOrder, tapper) {
+  return (0, import_feed.parallelFeed)(iterable, concurrency, keepOrder, async (item, index, feed) => {
+    await tapper(item, index);
+    feed(item, index);
+  });
 }

package/utils/async-iterable-helpers/parallel/types.js

@@ -1 +1,16 @@
-export {};
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

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

@@ -1,38 +1,53 @@
-import { isAsyncIterable } from './is-async-iterable.js';
-export function reduceAsync(iterable, reducer, initialValue) {
-    return (isAsyncIterable(iterable))
-        ? async(iterable, reducer, initialValue)
-        : sync(iterable, reducer, initialValue);
+"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 reduce_exports = {};
+__export(reduce_exports, {
+  reduceAsync: () => reduceAsync
+});
+module.exports = __toCommonJS(reduce_exports);
+var import_is_async_iterable = require("./is-async-iterable.js");
+function reduceAsync(iterable, reducer, initialValue) {
+  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable, reducer, initialValue) : sync(iterable, reducer, initialValue);
 }
 async function sync(iterable, reducer, initialValue) {
-    let accumulator = initialValue;
-    let index = 0;
-    for (const currentValue of iterable) {
-        if (accumulator == undefined) {
-            accumulator = currentValue;
-        }
-        else {
-            const returnValue = reducer(accumulator, currentValue, index++);
-            accumulator = (returnValue instanceof Promise)
-                ? await returnValue
-                : returnValue;
-        }
+  let accumulator = initialValue;
+  let index = 0;
+  for (const currentValue of iterable) {
+    if (accumulator == void 0) {
+      accumulator = currentValue;
+    } else {
+      const returnValue = reducer(accumulator, currentValue, index++);
+      accumulator = returnValue instanceof Promise ? await returnValue : returnValue;
     }
-    return accumulator;
+  }
+  return accumulator;
 }
 async function async(iterable, reducer, initialValue) {
-    let accumulator = initialValue;
-    let index = 0;
-    for await (const currentValue of iterable) {
-        if (accumulator == undefined) {
-            accumulator = currentValue;
-        }
-        else {
-            const returnValue = reducer(accumulator, currentValue, index++);
-            accumulator = (returnValue instanceof Promise)
-                ? await returnValue
-                : returnValue;
-        }
+  let accumulator = initialValue;
+  let index = 0;
+  for await (const currentValue of iterable) {
+    if (accumulator == void 0) {
+      accumulator = currentValue;
+    } else {
+      const returnValue = reducer(accumulator, currentValue, index++);
+      accumulator = returnValue instanceof Promise ? await returnValue : returnValue;
     }
-    return accumulator;
+  }
+  return accumulator;
 }

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

@@ -1,52 +1,67 @@
-import { isAsyncIterable } from './is-async-iterable.js';
-export function retryAsync(iterable, throwOnRetryFalse, predicate) {
-    return isAsyncIterable(iterable)
-        ? async(iterable, throwOnRetryFalse, predicate)
-        : sync(iterable, throwOnRetryFalse, 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 retry_exports = {};
+__export(retry_exports, {
+  retryAsync: () => retryAsync
+});
+module.exports = __toCommonJS(retry_exports);
+var import_is_async_iterable = require("./is-async-iterable.js");
+function retryAsync(iterable, throwOnRetryFalse, predicate) {
+  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable, throwOnRetryFalse, predicate) : sync(iterable, throwOnRetryFalse, predicate);
 }
 async function* sync(iterable, throwOnRetryFalse, predicate) {
-    let index = -1;
-    for (const item of iterable) {
-        index++;
-        let success = false;
-        let retry = true;
-        while (!success && retry) {
-            try {
-                yield item;
-                success = true;
-            }
-            catch (error) {
-                const returnValue = predicate(error, item, index);
-                retry = (returnValue instanceof Promise)
-                    ? await returnValue
-                    : returnValue;
-                if (!retry && throwOnRetryFalse) {
-                    throw error;
-                }
-            }
+  let index = -1;
+  for (const item of iterable) {
+    index++;
+    let success = false;
+    let retry = true;
+    while (!success && retry) {
+      try {
+        yield item;
+        success = true;
+      } catch (error) {
+        const returnValue = predicate(error, item, index);
+        retry = returnValue instanceof Promise ? await returnValue : returnValue;
+        if (!retry && throwOnRetryFalse) {
+          throw error;
         }
+      }
     }
+  }
 }
 async function* async(iterable, throwOnRetryFalse, predicate) {
-    let index = -1;
-    for await (const item of iterable) {
-        index++;
-        let success = false;
-        let retry = true;
-        while (!success && retry) {
-            try {
-                yield item;
-                success = true;
-            }
-            catch (error) {
-                const returnValue = predicate(error, item, index);
-                retry = (returnValue instanceof Promise)
-                    ? await returnValue
-                    : returnValue;
-                if (!retry && throwOnRetryFalse) {
-                    throw error;
-                }
-            }
+  let index = -1;
+  for await (const item of iterable) {
+    index++;
+    let success = false;
+    let retry = true;
+    while (!success && retry) {
+      try {
+        yield item;
+        success = true;
+      } catch (error) {
+        const returnValue = predicate(error, item, index);
+        retry = returnValue instanceof Promise ? await returnValue : returnValue;
+        if (!retry && throwOnRetryFalse) {
+          throw error;
         }
+      }
     }
+  }
 }

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

@@ -1,19 +1,42 @@
-export async function singleOrDefaultAsync(iterable, defaultValue, predicate = (() => true)) {
-    let matched = false;
-    let result = defaultValue;
-    let index = 0;
-    for await (const item of iterable) {
-        let matches = predicate(item, index++);
-        if (matches instanceof Promise) {
-            matches = await matches;
-        }
-        if (matches) {
-            if (matched) {
-                throw new Error('more than one item matched predicate');
-            }
-            matched = true;
-            result = 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 single_or_default_exports = {};
+__export(single_or_default_exports, {
+  singleOrDefaultAsync: () => singleOrDefaultAsync
+});
+module.exports = __toCommonJS(single_or_default_exports);
+async function singleOrDefaultAsync(iterable, defaultValue, predicate = () => true) {
+  let matched = false;
+  let result = defaultValue;
+  let index = 0;
+  for await (const item of iterable) {
+    let matches = predicate(item, index++);
+    if (matches instanceof Promise) {
+      matches = await matches;
     }
-    return result;
+    if (matches) {
+      if (matched) {
+        throw new Error("more than one item matched predicate");
+      }
+      matched = true;
+      result = item;
+    }
+  }
+  return result;
 }

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

@@ -1,22 +1,45 @@
-export async function singleAsync(iterable, predicate = (() => true)) {
-    let matched = false;
-    let result;
-    let index = 0;
-    for await (const item of iterable) {
-        let matches = predicate(item, index++);
-        if (matches instanceof Promise) {
-            matches = await matches;
-        }
-        if (matches) {
-            if (matched) {
-                throw new Error('more than one item matched predicate');
-            }
-            matched = true;
-            result = 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 single_exports = {};
+__export(single_exports, {
+  singleAsync: () => singleAsync
+});
+module.exports = __toCommonJS(single_exports);
+async function singleAsync(iterable, predicate = () => true) {
+  let matched = false;
+  let result;
+  let index = 0;
+  for await (const item of iterable) {
+    let matches = predicate(item, index++);
+    if (matches instanceof Promise) {
+      matches = await matches;
     }
-    if (!matched) {
-        throw new Error('no item matched predicate');
+    if (matches) {
+      if (matched) {
+        throw new Error("more than one item matched predicate");
+      }
+      matched = true;
+      result = item;
     }
-    return result;
+  }
+  if (!matched) {
+    throw new Error("no item matched predicate");
+  }
+  return result;
 }

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

@@ -1,4 +1,27 @@
-import { takeWhileAsync } from './take-while.js';
-export function skipAsync(iterable, count) {
-    return takeWhileAsync(iterable, false, (_item, index) => index >= count);
+"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 skip_exports = {};
+__export(skip_exports, {
+  skipAsync: () => skipAsync
+});
+module.exports = __toCommonJS(skip_exports);
+var import_take_while = require("./take-while.js");
+function skipAsync(iterable, count) {
+  return (0, import_take_while.takeWhileAsync)(iterable, false, (_item, index) => index >= count);
 }

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

@@ -1,7 +1,30 @@
-import { quickSortInPlaceAsync } from '../sort.js';
-import { toArrayAsync } from './to-array.js';
-export async function sortAsync(iterable, comparator) {
-    const array = await toArrayAsync(iterable);
-    await quickSortInPlaceAsync(array, comparator);
-    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 sort_exports = {};
+__export(sort_exports, {
+  sortAsync: () => sortAsync
+});
+module.exports = __toCommonJS(sort_exports);
+var import_sort = require("../sort.js");
+var import_to_array = require("./to-array.js");
+async function sortAsync(iterable, comparator) {
+  const array = await (0, import_to_array.toArrayAsync)(iterable);
+  await (0, import_sort.quickSortInPlaceAsync)(array, comparator);
+  return array;
 }