@tstdl/base 0.87.15 → 0.88.0-alpha2

package/utils/async-iterable-helpers/group-single.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 group_single_exports = {};
-__export(group_single_exports, {
-  groupSingleAsync: () => groupSingleAsync
-});
-module.exports = __toCommonJS(group_single_exports);
-var import_group_to_single_map = require("./group-to-single-map.js");
-async function* groupSingleAsync(iterable, selector) {
-  yield* await (0, import_group_to_single_map.groupToSingleMapAsync)(iterable, selector);
+import { groupToSingleMapAsync } from './group-to-single-map.js';
+export async function* groupSingleAsync(iterable, selector) {
+    yield* await groupToSingleMapAsync(iterable, selector);
 }

package/utils/async-iterable-helpers/group-to-map.js

@@ -1,46 +1,25 @@
-"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_to_map_exports = {};
-__export(group_to_map_exports, {
-  groupToMapAsync: () => groupToMapAsync
-});
-module.exports = __toCommonJS(group_to_map_exports);
-var import_factory_map = require("../factory-map.js");
-var import_is_async_iterable = require("./is-async-iterable.js");
-async function groupToMapAsync(iterable, selector) {
-  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable, selector) : sync(iterable, selector);
+import { FactoryMap } from '../factory-map.js';
+import { isAsyncIterable } from './is-async-iterable.js';
+export async function groupToMapAsync(iterable, selector) {
+    return isAsyncIterable(iterable)
+        ? async(iterable, selector)
+        : sync(iterable, selector);
 }
 async function async(iterable, selector) {
-  const map = new import_factory_map.FactoryMap(() => []);
-  let index = 0;
-  for await (const item of iterable) {
-    const groupKey = await selector(item, index++);
-    map.get(groupKey).push(item);
-  }
-  return map.backingMap;
+    const map = new FactoryMap(() => []);
+    let index = 0;
+    for await (const item of iterable) {
+        const groupKey = await selector(item, index++);
+        map.get(groupKey).push(item);
+    }
+    return map.backingMap;
 }
 async function sync(iterable, selector) {
-  const map = new import_factory_map.FactoryMap(() => []);
-  let index = 0;
-  for (const item of iterable) {
-    const groupKey = await selector(item, index++);
-    map.get(groupKey).push(item);
-  }
-  return map.backingMap;
+    const map = new FactoryMap(() => []);
+    let index = 0;
+    for (const item of iterable) {
+        const groupKey = await selector(item, index++);
+        map.get(groupKey).push(item);
+    }
+    return map.backingMap;
 }

package/utils/async-iterable-helpers/group-to-single-map.js

@@ -1,51 +1,30 @@
-"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_to_single_map_exports = {};
-__export(group_to_single_map_exports, {
-  groupToSingleMapAsync: () => groupToSingleMapAsync
-});
-module.exports = __toCommonJS(group_to_single_map_exports);
-var import_is_async_iterable = require("./is-async-iterable.js");
-async function groupToSingleMapAsync(iterable, selector) {
-  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable, selector) : sync(iterable, selector);
+import { isAsyncIterable } from './is-async-iterable.js';
+export async function groupToSingleMapAsync(iterable, selector) {
+    return isAsyncIterable(iterable)
+        ? async(iterable, selector)
+        : sync(iterable, selector);
 }
 async function async(iterable, selector) {
-  const map = /* @__PURE__ */ new Map();
-  let index = 0;
-  for await (const item of iterable) {
-    const groupKey = await selector(item, index++);
-    if (map.has(groupKey)) {
-      throw new Error("group has more than one item");
+    const map = new Map();
+    let index = 0;
+    for await (const item of iterable) {
+        const groupKey = await selector(item, index++);
+        if (map.has(groupKey)) {
+            throw new Error('group has more than one item');
+        }
+        map.set(groupKey, item);
     }
-    map.set(groupKey, item);
-  }
-  return map;
+    return map;
 }
 async function sync(iterable, selector) {
-  const map = /* @__PURE__ */ new Map();
-  let index = 0;
-  for (const item of iterable) {
-    const groupKey = await selector(item, index++);
-    if (map.has(groupKey)) {
-      throw new Error("group has more than one item");
+    const map = new Map();
+    let index = 0;
+    for (const item of iterable) {
+        const groupKey = await selector(item, index++);
+        if (map.has(groupKey)) {
+            throw new Error('group has more than one item');
+        }
+        map.set(groupKey, item);
     }
-    map.set(groupKey, item);
-  }
-  return map;
+    return map;
 }

package/utils/async-iterable-helpers/group.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 group_exports = {};
-__export(group_exports, {
-  groupAsync: () => groupAsync
-});
-module.exports = __toCommonJS(group_exports);
-var import_group_to_map = require("./group-to-map.js");
-async function* groupAsync(iterable, selector) {
-  yield* await (0, import_group_to_map.groupToMapAsync)(iterable, selector);
+import { groupToMapAsync } from './group-to-map.js';
+export async function* groupAsync(iterable, selector) {
+    yield* await groupToMapAsync(iterable, selector);
 }

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

@@ -1,29 +1,8 @@
-"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 includes_exports = {};
-__export(includes_exports, {
-  includesAsync: () => includesAsync
-});
-module.exports = __toCommonJS(includes_exports);
-var import_any = require("../iterable-helpers/any.js");
-var import_any2 = require("./any.js");
-var import_is_async_iterable = require("./is-async-iterable.js");
-async function includesAsync(iterable, value) {
-  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? (0, import_any2.anyAsync)(iterable, (item) => item == value) : (0, import_any.any)(iterable, (item) => item == value);
+import { any } from '../iterable-helpers/any.js';
+import { anyAsync } from './any.js';
+import { isAsyncIterable } from './is-async-iterable.js';
+export async function includesAsync(iterable, value) {
+    return isAsyncIterable(iterable)
+        ? anyAsync(iterable, (item) => item == value)
+        : any(iterable, (item) => item == value);
 }

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

@@ -1,65 +1,48 @@
-"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 async_iterable_helpers_exports = {};
-module.exports = __toCommonJS(async_iterable_helpers_exports);
-__reExport(async_iterable_helpers_exports, require("./all.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./any.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./assert.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./batch.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./buffer.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./concat.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./default-if-empty.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./deferred.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./difference.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./distinct.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./drain.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./filter.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./first-or-default.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./first.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./for-each.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./group-single.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./group-to-map.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./group-to-single-map.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./group.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./includes.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./interrupt.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./is-async-iterable.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./last-or-default.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./last.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./map-many.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./map.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./materialize.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./metadata.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./multiplex.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./pairwise.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./reduce.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./retry.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./single-or-default.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./single.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./skip.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./sort.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./take-until.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./take-while.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./take.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./tap.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./throttle.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./to-array.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./to-async-iterable-iterator.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./to-async-iterator.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./to-set.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./to-sync-iterable.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./types.js"), module.exports);
-__reExport(async_iterable_helpers_exports, require("./while.js"), module.exports);
+export * from './all.js';
+export * from './any.js';
+export * from './assert.js';
+export * from './batch.js';
+export * from './buffer.js';
+export * from './concat.js';
+export * from './default-if-empty.js';
+export * from './deferred.js';
+export * from './difference.js';
+export * from './distinct.js';
+export * from './drain.js';
+export * from './filter.js';
+export * from './first-or-default.js';
+export * from './first.js';
+export * from './for-each.js';
+export * from './group-single.js';
+export * from './group-to-map.js';
+export * from './group-to-single-map.js';
+export * from './group.js';
+export * from './includes.js';
+export * from './interrupt.js';
+export * from './is-async-iterable.js';
+export * from './last-or-default.js';
+export * from './last.js';
+export * from './map-many.js';
+export * from './map.js';
+export * from './materialize.js';
+export * from './metadata.js';
+export * from './multiplex.js';
+export * from './pairwise.js';
+export * from './reduce.js';
+export * from './retry.js';
+export * from './single-or-default.js';
+export * from './single.js';
+export * from './skip.js';
+export * from './sort.js';
+export * from './take-until.js';
+export * from './take-while.js';
+export * from './take.js';
+export * from './tap.js';
+export * from './throttle.js';
+export * from './to-array.js';
+export * from './to-async-iterable-iterator.js';
+export * from './to-async-iterator.js';
+export * from './to-set.js';
+export * from './to-sync-iterable.js';
+export * from './types.js';
+export * from './while.js';

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

@@ -1,47 +1,23 @@
-"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 interrupt_exports = {};
-__export(interrupt_exports, {
-  interruptEveryAsync: () => interruptEveryAsync,
-  interruptPerSecondAsync: () => interruptPerSecondAsync
-});
-module.exports = __toCommonJS(interrupt_exports);
-var import_timer = require("../timer.js");
-var import_timing = require("../timing.js");
-async function* interruptEveryAsync(iterable, every) {
-  let counter = 0;
-  for await (const item of iterable) {
-    if (counter++ % every == 0) {
-      await (0, import_timing.immediate)();
+import { Timer } from '../timer.js';
+import { immediate } from '../timing.js';
+export async function* interruptEveryAsync(iterable, every) {
+    let counter = 0;
+    for await (const item of iterable) {
+        if ((counter++ % every) == 0) {
+            await immediate();
+        }
+        yield item;
     }
-    yield item;
-  }
 }
-async function* interruptPerSecondAsync(iterable, value) {
-  const delay = Math.round(1e9 / value);
-  const stopwatch = new import_timer.Timer(true);
-  for await (const item of iterable) {
-    const elapsed = stopwatch.nanoseconds;
-    if (elapsed >= delay) {
-      stopwatch.restart();
-      await (0, import_timing.immediate)();
+export async function* interruptPerSecondAsync(iterable, value) {
+    const delay = Math.round(1e9 / value);
+    const stopwatch = new Timer(true);
+    for await (const item of iterable) {
+        const elapsed = stopwatch.nanoseconds;
+        if (elapsed >= delay) {
+            stopwatch.restart();
+            await immediate();
+        }
+        yield item;
     }
-    yield item;
-  }
 }

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

@@ -1,31 +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 is_async_iterable_exports = {};
-__export(is_async_iterable_exports, {
-  isAsyncIterable: () => isAsyncIterable,
-  isAsyncIterableIterator: () => isAsyncIterableIterator
-});
-module.exports = __toCommonJS(is_async_iterable_exports);
-var import_type_guards = require("../type-guards.js");
-function isAsyncIterable(value) {
-  return (0, import_type_guards.isNotNullOrUndefined)(value) && (0, import_type_guards.isFunction)(value[Symbol.asyncIterator]);
+import { isFunction, isNotNullOrUndefined } from '../type-guards.js';
+export function isAsyncIterable(value) {
+    return isNotNullOrUndefined(value) && isFunction(value[Symbol.asyncIterator]);
 }
-function isAsyncIterableIterator(value) {
-  return isAsyncIterable(value) && (0, import_type_guards.isFunction)(value.next);
+export function isAsyncIterableIterator(value) {
+    return isAsyncIterable(value) && isFunction(value.next);
 }

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

@@ -1,37 +1,14 @@
-"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 last_or_default_exports = {};
-__export(last_or_default_exports, {
-  lastOrDefaultAsync: () => lastOrDefaultAsync
-});
-module.exports = __toCommonJS(last_or_default_exports);
-var import_filter = require("./filter.js");
-async function lastOrDefaultAsync(iterable, defaultValue, predicate) {
-  const source = predicate == void 0 ? iterable : (0, import_filter.filterAsync)(iterable, predicate);
-  let hasLastItem = false;
-  let lastItem;
-  for await (const item of source) {
-    hasLastItem = true;
-    lastItem = item;
-  }
-  if (hasLastItem) {
-    return lastItem;
-  }
-  return defaultValue;
+import { filterAsync } from './filter.js';
+export async function lastOrDefaultAsync(iterable, defaultValue, predicate) {
+    const source = (predicate == undefined) ? iterable : filterAsync(iterable, predicate);
+    let hasLastItem = false;
+    let lastItem;
+    for await (const item of source) {
+        hasLastItem = true;
+        lastItem = item;
+    }
+    if (hasLastItem) {
+        return lastItem; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+    }
+    return defaultValue;
 }

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

@@ -1,37 +1,14 @@
-"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 last_exports = {};
-__export(last_exports, {
-  lastAsync: () => lastAsync
-});
-module.exports = __toCommonJS(last_exports);
-var import_filter = require("./filter.js");
-async function lastAsync(iterable, predicate) {
-  const source = predicate == void 0 ? iterable : (0, import_filter.filterAsync)(iterable, predicate);
-  let hasLastItem = false;
-  let lastItem;
-  for await (const item of source) {
-    hasLastItem = true;
-    lastItem = item;
-  }
-  if (hasLastItem) {
-    return lastItem;
-  }
-  throw new Error("iterable was either empty or no element matched predicate");
+import { filterAsync } from './filter.js';
+export async function lastAsync(iterable, predicate) {
+    const source = (predicate == undefined) ? iterable : filterAsync(iterable, predicate);
+    let hasLastItem = false;
+    let lastItem;
+    for await (const item of source) {
+        hasLastItem = true;
+        lastItem = item;
+    }
+    if (hasLastItem) {
+        return lastItem; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+    }
+    throw new Error('iterable was either empty or no element matched predicate');
 }

package/utils/async-iterable-helpers/map-many.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 map_many_exports = {};
-__export(map_many_exports, {
-  mapManyAsync: () => mapManyAsync
-});
-module.exports = __toCommonJS(map_many_exports);
-var import_is_async_iterable = require("./is-async-iterable.js");
-function mapManyAsync(iterable, mapper) {
-  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable, mapper) : sync(iterable, mapper);
+import { isAsyncIterable } from './is-async-iterable.js';
+export function mapManyAsync(iterable, mapper) {
+    return isAsyncIterable(iterable)
+        ? async(iterable, mapper)
+        : sync(iterable, mapper);
 }
 async function* sync(iterable, mapper) {
-  let index = 0;
-  for (const item of iterable) {
-    let mapped = mapper(item, index++);
-    if (mapped instanceof Promise) {
-      mapped = await mapped;
+    let index = 0;
+    for (const item of iterable) {
+        let mapped = mapper(item, index++);
+        if (mapped instanceof Promise) {
+            mapped = await mapped;
+        }
+        yield* mapped;
     }
-    yield* mapped;
-  }
 }
 async function* async(iterable, mapper) {
-  let index = 0;
-  for await (const item of iterable) {
-    let mapped = mapper(item, index++);
-    if (mapped instanceof Promise) {
-      mapped = await mapped;
+    let index = 0;
+    for await (const item of iterable) {
+        let mapped = mapper(item, index++);
+        if (mapped instanceof Promise) {
+            mapped = await mapped;
+        }
+        yield* mapped;
     }
-    yield* mapped;
-  }
 }