@tstdl/base 0.87.15 → 0.88.0-alpha2

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

@@ -1,47 +1,24 @@
-"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) {
-      break;
+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;
     }
-    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;
+    if (errors.length > 0) {
+        throw (errors.length > 1) ? new MultiError(errors) : errors[0];
     }
-  }
-  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,33 +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 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;
+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;
 }

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

@@ -1,24 +1,7 @@
-"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);
+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';

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

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

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

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

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

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

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

@@ -1,53 +1,38 @@
-"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);
+import { isAsyncIterable } from './is-async-iterable.js';
+export function reduceAsync(iterable, reducer, initialValue) {
+    return (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 == void 0) {
-      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 == undefined) {
+            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 == void 0) {
-      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 == undefined) {
+            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,67 +1,52 @@
-"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);
+import { isAsyncIterable } from './is-async-iterable.js';
+export function retryAsync(iterable, throwOnRetryFalse, predicate) {
+    return 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,42 +1,19 @@
-"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;
+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;
+        }
     }
-    if (matches) {
-      if (matched) {
-        throw new Error("more than one item matched predicate");
-      }
-      matched = true;
-      result = item;
-    }
-  }
-  return result;
+    return result;
 }

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

@@ -1,45 +1,22 @@
-"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;
+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;
+        }
     }
-    if (matches) {
-      if (matched) {
-        throw new Error("more than one item matched predicate");
-      }
-      matched = true;
-      result = item;
+    if (!matched) {
+        throw new Error('no item matched predicate');
     }
-  }
-  if (!matched) {
-    throw new Error("no item matched predicate");
-  }
-  return result;
+    return result;
 }

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

@@ -1,27 +1,4 @@
-"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_filter = require("./filter.js");
-function skipAsync(iterable, count) {
-  return (0, import_filter.filterAsync)(iterable, (_item, index) => index >= count);
+import { filterAsync } from './filter.js';
+export function skipAsync(iterable, count) {
+    return filterAsync(iterable, (_item, index) => index >= count);
 }

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

@@ -1,30 +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 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;
+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;
 }