@tstdl/base 0.87.13 → 0.88.0-alpha1

package/threading/thread-worker.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 thread_worker_exports = {};
-__export(thread_worker_exports, {
-  exposeThreadWorker: () => exposeThreadWorker
-});
-module.exports = __toCommonJS(thread_worker_exports);
-var import_rpc = require("../rpc/index.js");
-function exposeThreadWorker(worker, endpointOrSource, name = "default") {
-  import_rpc.Rpc.expose(worker, endpointOrSource, `thread-worker:${name}`);
+import { Rpc } from '../rpc/index.js';
+export function exposeThreadWorker(worker, endpointOrSource, name = 'default') {
+    Rpc.expose(worker, endpointOrSource, `thread-worker:${name}`);
 }

package/tokens.js

@@ -1,25 +1,2 @@
-"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 tokens_exports = {};
-__export(tokens_exports, {
-  DOCUMENT: () => DOCUMENT
-});
-module.exports = __toCommonJS(tokens_exports);
-var import_token = require("./injector/token.js");
-const DOCUMENT = (0, import_token.injectionToken)("document");
+import { injectionToken } from './injector/token.js';
+export const DOCUMENT = injectionToken('document');

package/types/geo-json.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 geo_json_exports = {};
-module.exports = __toCommonJS(geo_json_exports);
+export {};

package/types.js

@@ -1,16 +1,2 @@
-"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);
+/* eslint-disable @typescript-eslint/ban-types, @typescript-eslint/consistent-indexed-object-style */
+export {};

package/utils/alphabet.js

@@ -1,36 +1,13 @@
-"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 alphabet_exports = {};
-__export(alphabet_exports, {
-  Alphabet: () => Alphabet
-});
-module.exports = __toCommonJS(alphabet_exports);
-var Alphabet;
-(function(Alphabet2) {
-  Alphabet2["LowerCase"] = "abcdefghijklmnopqrstuvwxyz";
-  Alphabet2["UpperCase"] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-  Alphabet2["Numbers"] = "0123456789";
-  Alphabet2["LowerUpperCase"] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-  Alphabet2["LowerCaseNumbers"] = "abcdefghijklmnopqrstuvwxyz0123456789";
-  Alphabet2["UpperCaseNumbers"] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-  Alphabet2["LowerUpperCaseNumbers"] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-  Alphabet2["ZBase32"] = "ybndrfg8ejkmcpqxot1uwisza345h769";
-  Alphabet2["LowerCaseHex"] = "0123456789abcdef";
-  Alphabet2["UpperCaseHex"] = "0123456789ABCDEF";
+export var Alphabet;
+(function (Alphabet) {
+    Alphabet["LowerCase"] = "abcdefghijklmnopqrstuvwxyz";
+    Alphabet["UpperCase"] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    Alphabet["Numbers"] = "0123456789";
+    Alphabet["LowerUpperCase"] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    Alphabet["LowerCaseNumbers"] = "abcdefghijklmnopqrstuvwxyz0123456789";
+    Alphabet["UpperCaseNumbers"] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    Alphabet["LowerUpperCaseNumbers"] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    Alphabet["ZBase32"] = "ybndrfg8ejkmcpqxot1uwisza345h769";
+    Alphabet["LowerCaseHex"] = "0123456789abcdef";
+    Alphabet["UpperCaseHex"] = "0123456789ABCDEF";
 })(Alphabet || (Alphabet = {}));

package/utils/any-iterable-iterator.js

@@ -1,28 +1,5 @@
-"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 any_iterable_iterator_exports = {};
-__export(any_iterable_iterator_exports, {
-  isAnyIterable: () => isAnyIterable
-});
-module.exports = __toCommonJS(any_iterable_iterator_exports);
-var import_is_async_iterable = require("./async-iterable-helpers/is-async-iterable.js");
-var import_is_iterable = require("./iterable-helpers/is-iterable.js");
-function isAnyIterable(obj) {
-  return (0, import_is_iterable.isIterable)(obj) || (0, import_is_async_iterable.isAsyncIterable)(obj);
+import { isAsyncIterable } from './async-iterable-helpers/is-async-iterable.js';
+import { isIterable } from './iterable-helpers/is-iterable.js';
+export function isAnyIterable(obj) {
+    return isIterable(obj) || isAsyncIterable(obj);
 }

package/utils/array/array-backtracker.js

@@ -1,70 +1,47 @@
-"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 array_backtracker_exports = {};
-__export(array_backtracker_exports, {
-  ArrayBacktracker: () => ArrayBacktracker
-});
-module.exports = __toCommonJS(array_backtracker_exports);
-var import_rxjs = require("rxjs");
-var import_set = require("../set.js");
-var import_type_guards = require("../type-guards.js");
-class ArrayBacktracker {
-  recordMap;
-  recordMapSubject;
-  currentValues;
-  get record() {
-    return this.recordMap;
-  }
-  record$;
-  constructor(array) {
-    this.recordMap = /* @__PURE__ */ new Map();
-    this.recordMapSubject = new import_rxjs.BehaviorSubject(this.recordMap);
-    this.currentValues = /* @__PURE__ */ new Set();
-    this.record$ = this.recordMapSubject.asObservable();
-    if ((0, import_type_guards.isDefined)(array)) {
-      this.track(array);
+import { BehaviorSubject } from 'rxjs';
+import { differenceSets } from '../set.js';
+import { isDefined } from '../type-guards.js';
+export class ArrayBacktracker {
+    recordMap;
+    recordMapSubject;
+    currentValues;
+    get record() {
+        return this.recordMap;
     }
-  }
-  /**
-   * gets a clone of the current record
-   */
-  getRecord() {
-    return new Map(this.recordMap);
-  }
-  track(array) {
-    const newValues = new Set(array);
-    const added = (0, import_set.differenceSets)(newValues, this.currentValues);
-    const removed = (0, import_set.differenceSets)(this.currentValues, newValues);
-    if (added.length == 0 && removed.length == 0) {
-      return;
+    record$;
+    constructor(array) {
+        this.recordMap = new Map();
+        this.recordMapSubject = new BehaviorSubject(this.recordMap);
+        this.currentValues = new Set();
+        this.record$ = this.recordMapSubject.asObservable();
+        if (isDefined(array)) {
+            this.track(array);
+        }
     }
-    for (const value of added) {
-      this.recordMap.set(value, true);
+    /**
+     * gets a clone of the current record
+     */
+    getRecord() {
+        return new Map(this.recordMap);
     }
-    for (const value of removed) {
-      this.recordMap.set(value, false);
+    track(array) {
+        const newValues = new Set(array);
+        const added = differenceSets(newValues, this.currentValues);
+        const removed = differenceSets(this.currentValues, newValues);
+        if ((added.length == 0) && (removed.length == 0)) {
+            return;
+        }
+        for (const value of added) {
+            this.recordMap.set(value, true);
+        }
+        for (const value of removed) {
+            this.recordMap.set(value, false);
+        }
+        this.currentValues = newValues;
+        this.recordMapSubject.next(this.recordMap);
+    }
+    clear() {
+        this.recordMap.clear();
+        this.recordMapSubject.next(this.recordMap);
     }
-    this.currentValues = newValues;
-    this.recordMapSubject.next(this.recordMap);
-  }
-  clear() {
-    this.recordMap.clear();
-    this.recordMapSubject.next(this.recordMap);
-  }
 }

package/utils/array/array.js

@@ -1,88 +1,85 @@
-"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 array_exports = {};
-__export(array_exports, {
-  createArray: () => createArray,
-  distinct: () => distinct,
-  extractValueOfArrayIfSingleElement: () => extractValueOfArrayIfSingleElement,
-  randomItem: () => randomItem,
-  randomItems: () => randomItems,
-  shuffle: () => shuffle,
-  toArray: () => toArray,
-  toArrayCopy: () => toArrayCopy
-});
-module.exports = __toCommonJS(array_exports);
-var import_distinct = require("../iterable-helpers/distinct.js");
-var import_math = require("../math.js");
-var import_type_guards = require("../type-guards.js");
-function toArray(value) {
-  return (0, import_type_guards.isArray)(value) ? value : [value];
+import { distinct as iterableDistinct } from '../iterable-helpers/distinct.js';
+import { randomInt } from '../math.js';
+import { isArray, isDefined } from '../type-guards.js';
+export function toArray(value) {
+    return isArray(value) ? value : [value];
 }
-function toArrayCopy(value) {
-  return (0, import_type_guards.isArray)(value) ? [...value] : [value];
+/**
+ * Return copy of value, if it is an array, otherwise puts the single value into an array.
+ */
+export function toArrayCopy(value) {
+    return isArray(value) ? [...value] : [value];
 }
-function extractValueOfArrayIfSingleElement(value) {
-  if ((0, import_type_guards.isArray)(value) && value.length == 1) {
-    return value[0];
-  }
-  return value;
+export function extractValueOfArrayIfSingleElement(value) {
+    if (isArray(value) && (value.length == 1)) {
+        return value[0];
+    }
+    return value;
 }
-function distinct(values, selector) {
-  return [...(0, import_type_guards.isDefined)(selector) ? (0, import_distinct.distinct)(values, selector) : new Set(values)];
+export function distinct(values, selector) {
+    return [...(isDefined(selector) ? iterableDistinct(values, selector) : new Set(values))];
 }
-function createArray(length, valueProvider) {
-  const arr = [];
-  arr.length = length;
-  return arr.fill(void 0).map((_, index) => valueProvider(index));
+/**
+ * creates a new array of specified length and fills it with values from the specified value provider function
+ * @param length length of the new array
+ * @param valueProvider provider function for the array values
+ * @returns created array
+ */
+export function createArray(length, valueProvider) {
+    const arr = [];
+    arr.length = length;
+    return arr.fill(undefined).map((_, index) => valueProvider(index));
 }
-function shuffle(items) {
-  const cloned = [...items];
-  for (let i = 0; i < cloned.length; i++) {
-    const j = (0, import_math.randomInt)(i, cloned.length - 1);
-    [cloned[i], cloned[j]] = [cloned[j], cloned[i]];
-  }
-  return cloned;
+/**
+ * shuffles items using "The modern version of the Fisher–Yates shuffle"
+ * @param items items to shuffle
+ * @returns shuffled items
+ */
+export function shuffle(items) {
+    const cloned = [...items];
+    for (let i = 0; i < cloned.length; i++) {
+        const j = randomInt(i, cloned.length - 1);
+        [cloned[i], cloned[j]] = [cloned[j], cloned[i]];
+    }
+    return cloned;
 }
-function randomItem(array, { min, max } = {}) {
-  const _min = (0, import_type_guards.isDefined)(min) ? Math.max(min, 0) : 0;
-  const _max = (0, import_type_guards.isDefined)(max) ? Math.min(max, array.length - 1) : array.length - 1;
-  const index = (0, import_math.randomInt)(_min, _max);
-  return array[index];
+/**
+ * picks a random item from specified array
+ * @param array array to pick random item from
+ * @param options options
+ * @returns random item
+ */
+export function randomItem(array, { min, max } = {}) {
+    const _min = isDefined(min) ? Math.max(min, 0) : 0;
+    const _max = isDefined(max) ? Math.min(max, array.length - 1) : array.length - 1;
+    const index = randomInt(_min, _max);
+    return array[index];
 }
-function randomItems(array, count, allowDuplicates = false) {
-  if (allowDuplicates) {
-    return createArray(count, () => array[(0, import_math.randomInt)(0, array.length - 1)]);
-  }
-  if (count > array.length) {
-    throw new Error("count larger than length of array without allowing duplicates");
-  }
-  if (count >= array.length / 2) {
-    return shuffle(array).slice(0, count);
-  }
-  const taken = /* @__PURE__ */ new Set();
-  return createArray(count, () => {
-    while (true) {
-      const index = (0, import_math.randomInt)(0, array.length - 1);
-      if (!taken.has(index)) {
-        taken.add(index);
-        return array[index];
-      }
+/**
+ * picks random items from specified array
+ * @param array array to pick random items from
+ * @param count count of items to pick
+ * @param allowDuplicates allow picking an item multiple times - required when count is larger than array length
+ * @returns random items
+ */
+export function randomItems(array, count, allowDuplicates = false) {
+    if (allowDuplicates) {
+        return createArray(count, () => array[randomInt(0, array.length - 1)]);
+    }
+    if (count > array.length) {
+        throw new Error('count larger than length of array without allowing duplicates');
+    }
+    if (count >= (array.length / 2)) {
+        return shuffle(array).slice(0, count);
     }
-  });
+    const taken = new Set();
+    return createArray(count, () => {
+        while (true) {
+            const index = randomInt(0, array.length - 1);
+            if (!taken.has(index)) {
+                taken.add(index);
+                return array[index];
+            }
+        }
+    });
 }

package/utils/array/index.js

@@ -1,19 +1,2 @@
-"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 array_exports = {};
-module.exports = __toCommonJS(array_exports);
-__reExport(array_exports, require("./array.js"), module.exports);
-__reExport(array_exports, require("./array-backtracker.js"), module.exports);
+export * from './array.js';
+export * from './array-backtracker.js';

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

@@ -1,53 +1,32 @@
-"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 all_exports = {};
-__export(all_exports, {
-  allAsync: () => allAsync
-});
-module.exports = __toCommonJS(all_exports);
-var import_is_async_iterable = require("./is-async-iterable.js");
-async function allAsync(iterable, predicate = () => true) {
-  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable, predicate) : sync(iterable, predicate);
+import { isAsyncIterable } from './is-async-iterable.js';
+export async function allAsync(iterable, predicate = () => true) {
+    return isAsyncIterable(iterable)
+        ? async(iterable, predicate)
+        : sync(iterable, predicate);
 }
 async function sync(iterable, predicate) {
-  let index = 0;
-  for (const item of iterable) {
-    let matches = predicate(item, index++);
-    if (matches instanceof Promise) {
-      matches = await matches;
+    let index = 0;
+    for (const item of iterable) {
+        let matches = predicate(item, index++);
+        if (matches instanceof Promise) {
+            matches = await matches;
+        }
+        if (!matches) {
+            return false;
+        }
     }
-    if (!matches) {
-      return false;
-    }
-  }
-  return true;
+    return true;
 }
 async function async(iterable, predicate) {
-  let index = 0;
-  for await (const item of iterable) {
-    let matches = predicate(item, index++);
-    if (matches instanceof Promise) {
-      matches = await matches;
-    }
-    if (!matches) {
-      return false;
+    let index = 0;
+    for await (const item of iterable) {
+        let matches = predicate(item, index++);
+        if (matches instanceof Promise) {
+            matches = await matches;
+        }
+        if (!matches) {
+            return false;
+        }
     }
-  }
-  return true;
+    return true;
 }

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

@@ -1,53 +1,32 @@
-"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 any_exports = {};
-__export(any_exports, {
-  anyAsync: () => anyAsync
-});
-module.exports = __toCommonJS(any_exports);
-var import_is_async_iterable = require("./is-async-iterable.js");
-async function anyAsync(iterable, predicate = () => true) {
-  return (0, import_is_async_iterable.isAsyncIterable)(iterable) ? async(iterable, predicate) : sync(iterable, predicate);
+import { isAsyncIterable } from './is-async-iterable.js';
+export async function anyAsync(iterable, predicate = () => true) {
+    return isAsyncIterable(iterable)
+        ? async(iterable, predicate)
+        : sync(iterable, predicate);
 }
 async function sync(iterable, predicate) {
-  let index = 0;
-  for (const item of iterable) {
-    let matches = predicate(item, index++);
-    if (matches instanceof Promise) {
-      matches = await matches;
+    let index = 0;
+    for (const item of iterable) {
+        let matches = predicate(item, index++);
+        if (matches instanceof Promise) {
+            matches = await matches;
+        }
+        if (matches) {
+            return true;
+        }
     }
-    if (matches) {
-      return true;
-    }
-  }
-  return false;
+    return false;
 }
 async function async(iterable, predicate) {
-  let index = 0;
-  for await (const item of iterable) {
-    let matches = predicate(item, index++);
-    if (matches instanceof Promise) {
-      matches = await matches;
-    }
-    if (matches) {
-      return true;
+    let index = 0;
+    for await (const item of iterable) {
+        let matches = predicate(item, index++);
+        if (matches instanceof Promise) {
+            matches = await matches;
+        }
+        if (matches) {
+            return true;
+        }
     }
-  }
-  return false;
+    return false;
 }