@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/utils/iterable-helpers/batch.js

@@ -1,13 +1,36 @@
-export function* batch(iterable, size) {
-    let buffer = [];
-    for (const item of iterable) {
-        buffer.push(item);
-        if (buffer.length >= size) {
-            yield buffer;
-            buffer = [];
-        }
-    }
-    if (buffer.length > 0) {
-        yield buffer;
+"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 batch_exports = {};
+__export(batch_exports, {
+  batch: () => batch
+});
+module.exports = __toCommonJS(batch_exports);
+function* batch(iterable, size) {
+  let buffer = [];
+  for (const item of iterable) {
+    buffer.push(item);
+    if (buffer.length >= size) {
+      yield buffer;
+      buffer = [];
     }
+  }
+  if (buffer.length > 0) {
+    yield buffer;
+  }
 }

package/utils/iterable-helpers/concat.js

@@ -1,5 +1,28 @@
-export function* concat(...iterables) {
-    for (const iterable of iterables) {
-        yield* iterable;
-    }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var concat_exports = {};
+__export(concat_exports, {
+  concat: () => concat
+});
+module.exports = __toCommonJS(concat_exports);
+function* concat(...iterables) {
+  for (const iterable of iterables) {
+    yield* iterable;
+  }
 }

package/utils/iterable-helpers/default-if-empty.js

@@ -1,10 +1,33 @@
-export function* defaultIfEmpty(iterable, defaultValue) {
-    let empty = true;
-    for (const item of iterable) {
-        empty = false;
-        yield item;
-    }
-    if (empty) {
-        yield defaultValue;
-    }
+"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 default_if_empty_exports = {};
+__export(default_if_empty_exports, {
+  defaultIfEmpty: () => defaultIfEmpty
+});
+module.exports = __toCommonJS(default_if_empty_exports);
+function* defaultIfEmpty(iterable, defaultValue) {
+  let empty = true;
+  for (const item of iterable) {
+    empty = false;
+    yield item;
+  }
+  if (empty) {
+    yield defaultValue;
+  }
 }

package/utils/iterable-helpers/deferred.js

@@ -1,3 +1,26 @@
-export function* deferredIterable(source) {
-    yield* source();
+"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 deferred_exports = {};
+__export(deferred_exports, {
+  deferredIterable: () => deferredIterable
+});
+module.exports = __toCommonJS(deferred_exports);
+function* deferredIterable(source) {
+  yield* source();
 }

package/utils/iterable-helpers/difference.js

@@ -1,25 +1,49 @@
-import { concat } from './concat.js';
-import { map } from './map.js';
-export function* difference(baseIterable, iterable, selector = (item) => item) {
-    const diffItems = map(iterable, selector);
-    const diffItemsSet = new Set(diffItems);
-    let index = 0;
-    for (const item of baseIterable) {
-        const selected = selector(item, index++);
-        if (!diffItemsSet.has(selected)) {
-            yield 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 difference_exports = {};
+__export(difference_exports, {
+  difference: () => difference,
+  differenceMany: () => differenceMany
+});
+module.exports = __toCommonJS(difference_exports);
+var import_concat = require("./concat.js");
+var import_map = require("./map.js");
+function* difference(baseIterable, iterable, selector = (item) => item) {
+  const diffItems = (0, import_map.map)(iterable, selector);
+  const diffItemsSet = new Set(diffItems);
+  let index = 0;
+  for (const item of baseIterable) {
+    const selected = selector(item, index++);
+    if (!diffItemsSet.has(selected)) {
+      yield item;
     }
+  }
 }
-export function* differenceMany(baseIterable, iterables, selector = (item) => item) {
-    const items = concat(...iterables);
-    const diffItems = map(items, selector);
-    const diffItemsSet = new Set(diffItems);
-    let index = 0;
-    for (const item of baseIterable) {
-        const selected = selector(item, index++);
-        if (!diffItemsSet.has(selected)) {
-            yield item;
-        }
+function* differenceMany(baseIterable, iterables, selector = (item) => item) {
+  const items = (0, import_concat.concat)(...iterables);
+  const diffItems = (0, import_map.map)(items, selector);
+  const diffItemsSet = new Set(diffItems);
+  let index = 0;
+  for (const item of baseIterable) {
+    const selected = selector(item, index++);
+    if (!diffItemsSet.has(selected)) {
+      yield item;
     }
+  }
 }

package/utils/iterable-helpers/distinct.js

@@ -1,11 +1,34 @@
-export function* distinct(iterable, selector = (item) => item) {
-    const items = new Set();
-    let index = 0;
-    for (const item of iterable) {
-        const selection = selector(item, index++);
-        if (!items.has(selection)) {
-            items.add(selection);
-            yield 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 distinct_exports = {};
+__export(distinct_exports, {
+  distinct: () => distinct
+});
+module.exports = __toCommonJS(distinct_exports);
+function* distinct(iterable, selector = (item) => item) {
+  const items = /* @__PURE__ */ new Set();
+  let index = 0;
+  for (const item of iterable) {
+    const selection = selector(item, index++);
+    if (!items.has(selection)) {
+      items.add(selection);
+      yield item;
     }
+  }
 }

package/utils/iterable-helpers/drain.js

@@ -1,5 +1,27 @@
-export function drain(iterable) {
-    for (const _ of iterable) {
-        // just drain
-    }
+"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 drain_exports = {};
+__export(drain_exports, {
+  drain: () => drain
+});
+module.exports = __toCommonJS(drain_exports);
+function drain(iterable) {
+  for (const _ of iterable) {
+  }
 }

package/utils/iterable-helpers/filter.js

@@ -1,9 +1,32 @@
-export function* filter(iterable, predicate) {
-    let index = 0;
-    for (const item of iterable) {
-        const matches = predicate(item, index++);
-        if (matches) {
-            yield 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 filter_exports = {};
+__export(filter_exports, {
+  filter: () => filter
+});
+module.exports = __toCommonJS(filter_exports);
+function* filter(iterable, predicate) {
+  let index = 0;
+  for (const item of iterable) {
+    const matches = predicate(item, index++);
+    if (matches) {
+      yield item;
     }
+  }
 }

package/utils/iterable-helpers/first-or-default.js

@@ -1,9 +1,31 @@
-import { filter } from './filter.js';
-export function firstOrDefault(iterable, defaultValue, predicate) {
-    const source = (predicate == undefined) ? iterable : filter(iterable, predicate);
-    // eslint-disable-next-line no-unreachable-loop
-    for (const item of source) {
-        return item;
-    }
-    return defaultValue;
+"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 first_or_default_exports = {};
+__export(first_or_default_exports, {
+  firstOrDefault: () => firstOrDefault
+});
+module.exports = __toCommonJS(first_or_default_exports);
+var import_filter = require("./filter.js");
+function firstOrDefault(iterable, defaultValue, predicate) {
+  const source = predicate == void 0 ? iterable : (0, import_filter.filter)(iterable, predicate);
+  for (const item of source) {
+    return item;
+  }
+  return defaultValue;
 }

package/utils/iterable-helpers/first.js

@@ -1,9 +1,31 @@
-import { filter } from './filter.js';
-export function first(iterable, predicate) {
-    const source = (predicate == undefined) ? iterable : filter(iterable, predicate);
-    // eslint-disable-next-line no-unreachable-loop
-    for (const item of source) {
-        return item;
-    }
-    throw new Error('iterable was either empty or no element matched 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 first_exports = {};
+__export(first_exports, {
+  first: () => first
+});
+module.exports = __toCommonJS(first_exports);
+var import_filter = require("./filter.js");
+function first(iterable, predicate) {
+  const source = predicate == void 0 ? iterable : (0, import_filter.filter)(iterable, predicate);
+  for (const item of source) {
+    return item;
+  }
+  throw new Error("iterable was either empty or no element matched predicate");
 }

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

@@ -1,6 +1,29 @@
-export function forEach(iterable, func) {
-    let index = 0;
-    for (const item of iterable) {
-        func(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 for_each_exports = {};
+__export(for_each_exports, {
+  forEach: () => forEach
+});
+module.exports = __toCommonJS(for_each_exports);
+function forEach(iterable, func) {
+  let index = 0;
+  for (const item of iterable) {
+    func(item, index++);
+  }
 }

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

@@ -1,4 +1,27 @@
-import { groupToSingleMap } from './group-to-single-map.js';
-export function groupSingle(iterable, selector) {
-    return groupToSingleMap(iterable, selector)[Symbol.iterator]();
+"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, {
+  groupSingle: () => groupSingle
+});
+module.exports = __toCommonJS(group_single_exports);
+var import_group_to_single_map = require("./group-to-single-map.js");
+function groupSingle(iterable, selector) {
+  return (0, import_group_to_single_map.groupToSingleMap)(iterable, selector)[Symbol.iterator]();
 }

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

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

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

@@ -1,12 +1,35 @@
-export function groupToSingleMap(iterable, selector) {
-    const map = new Map();
-    let index = 0;
-    for (const item of iterable) {
-        const groupKey = selector(item, index++);
-        if (map.has(groupKey)) {
-            throw new Error('group has more than one item');
-        }
-        map.set(groupKey, 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 group_to_single_map_exports = {};
+__export(group_to_single_map_exports, {
+  groupToSingleMap: () => groupToSingleMap
+});
+module.exports = __toCommonJS(group_to_single_map_exports);
+function groupToSingleMap(iterable, selector) {
+  const map = /* @__PURE__ */ new Map();
+  let index = 0;
+  for (const item of iterable) {
+    const groupKey = selector(item, index++);
+    if (map.has(groupKey)) {
+      throw new Error("group has more than one item");
     }
-    return map;
+    map.set(groupKey, item);
+  }
+  return map;
 }

package/utils/iterable-helpers/group.js

@@ -1,4 +1,27 @@
-import { groupToMap } from './group-to-map.js';
-export function group(iterable, selector) {
-    return groupToMap(iterable, selector)[Symbol.iterator]();
+"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, {
+  group: () => group
+});
+module.exports = __toCommonJS(group_exports);
+var import_group_to_map = require("./group-to-map.js");
+function group(iterable, selector) {
+  return (0, import_group_to_map.groupToMap)(iterable, selector)[Symbol.iterator]();
 }

package/utils/iterable-helpers/includes.js

@@ -1,4 +1,27 @@
-import { any } from './any.js';
-export function includes(iterable, value) {
-    return any(iterable, (item) => item == value);
+"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, {
+  includes: () => includes
+});
+module.exports = __toCommonJS(includes_exports);
+var import_any = require("./any.js");
+function includes(iterable, value) {
+  return (0, import_any.any)(iterable, (item) => item == value);
 }