@sapphire/iterator-utilities 1.0.3-next.fc35dd86 → 2.0.0-next.09afdaab

package/dist/cjs/lib/greaterOrEqualThan.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/greaterOrEqualThan.ts"],"names":["compare","orderingIsLess"],"mappings":";;;;;;;AA+BO,SAAS,kBAAA,CAAsC,UAA2C,KAAiD,EAAA;AACjJ,EAAM,MAAA,MAAA,GAASA,mBAAQ,CAAA,QAAA,EAAU,KAAK,CAAA;AACtC,EAAO,OAAA,CAACC,4BAAe,MAAM,CAAA;AAC9B;AAHgB,MAAA,CAAA,kBAAA,EAAA,oBAAA,CAAA","file":"greaterOrEqualThan.cjs","sourcesContent":["import { compare } from './compare';\nimport type { IterableResolvable } from './from';\nimport { orderingIsLess, type LexicographicComparison } from './shared/_compare';\n\n/**\n * Determines if the elements of `iterable` are {@link LexicographicComparison lexicographically} greater or equal than\n * those of another.\n *\n * @param iterable The iterator to compare.\n * @param other The iterator to compare against.\n *\n * @example\n * ```typescript\n * import { greaterOrEqualThan } from '@sapphire/iterator-utilities';\n *\n * const x = [1, 2, 3, 4];\n * const y = [1, 4, 9, 16];\n * console.log(greaterOrEqualThan([1], [1]));\n * // Output: true\n * console.log(greaterOrEqualThan([1], [1, 2]));\n * // Output: false\n * console.log(greaterOrEqualThan([1, 2], [1]));\n * // Output: true\n * console.log(greaterOrEqualThan([1, 2], [1, 2]));\n * // Output: true\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function greaterOrEqualThan<const ElementType>(iterable: IterableResolvable<ElementType>, other: IterableResolvable<ElementType>): boolean {\n\tconst result = compare(iterable, other);\n\treturn !orderingIsLess(result);\n}\n\nexport { greaterOrEqualThan as ge };\n"]}

package/dist/cjs/lib/greaterOrEqualThan.d.cts

@@ -0,0 +1,32 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Determines if the elements of `iterable` are {@link LexicographicComparison lexicographically} greater or equal than
+ * those of another.
+ *
+ * @param iterable The iterator to compare.
+ * @param other The iterator to compare against.
+ *
+ * @example
+ * ```typescript
+ * import { greaterOrEqualThan } from '@sapphire/iterator-utilities';
+ *
+ * const x = [1, 2, 3, 4];
+ * const y = [1, 4, 9, 16];
+ * console.log(greaterOrEqualThan([1], [1]));
+ * // Output: true
+ * console.log(greaterOrEqualThan([1], [1, 2]));
+ * // Output: false
+ * console.log(greaterOrEqualThan([1, 2], [1]));
+ * // Output: true
+ * console.log(greaterOrEqualThan([1, 2], [1, 2]));
+ * // Output: true
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function greaterOrEqualThan<const ElementType>(iterable: IterableResolvable<ElementType>, other: IterableResolvable<ElementType>): boolean;
+
+export { greaterOrEqualThan as ge, greaterOrEqualThan };

package/dist/cjs/lib/greaterThan.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var compare_cjs = require('./compare.cjs');
+var _compare_cjs = require('./shared/_compare.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function greaterThan(iterable, other) {
+  const result = compare_cjs.compare(iterable, other);
+  return _compare_cjs.orderingIsGreater(result);
+}
+__name(greaterThan, "greaterThan");
+
+exports.greaterThan = greaterThan;
+exports.gt = greaterThan;
+//# sourceMappingURL=greaterThan.cjs.map
+//# sourceMappingURL=greaterThan.cjs.map

package/dist/cjs/lib/greaterThan.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/greaterThan.ts"],"names":["compare","orderingIsGreater"],"mappings":";;;;;;;AA+BO,SAAS,WAAA,CAA+B,UAA2C,KAAiD,EAAA;AAC1I,EAAM,MAAA,MAAA,GAASA,mBAAQ,CAAA,QAAA,EAAU,KAAK,CAAA;AACtC,EAAA,OAAOC,+BAAkB,MAAM,CAAA;AAChC;AAHgB,MAAA,CAAA,WAAA,EAAA,aAAA,CAAA","file":"greaterThan.cjs","sourcesContent":["import { compare } from './compare';\nimport type { IterableResolvable } from './from';\nimport { orderingIsGreater, type LexicographicComparison } from './shared/_compare';\n\n/**\n * Determines if the elements of `iterable` are {@link LexicographicComparison lexicographically} greater than those of\n * another.\n *\n * @param iterable The iterator to compare.\n * @param other The iterator to compare against.\n *\n * @example\n * ```typescript\n * import { greaterThan } from '@sapphire/iterator-utilities';\n *\n * const x = [1, 2, 3, 4];\n * const y = [1, 4, 9, 16];\n * console.log(greaterThan([1], [1]));\n * // Output: false\n * console.log(greaterThan([1], [1, 2]));\n * // Output: false\n * console.log(greaterThan([1, 2], [1]));\n * // Output: true\n * console.log(greaterThan([1, 2], [1, 2]));\n * // Output: false\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function greaterThan<const ElementType>(iterable: IterableResolvable<ElementType>, other: IterableResolvable<ElementType>): boolean {\n\tconst result = compare(iterable, other);\n\treturn orderingIsGreater(result);\n}\n\nexport { greaterThan as gt };\n"]}

package/dist/cjs/lib/greaterThan.d.cts

@@ -0,0 +1,32 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Determines if the elements of `iterable` are {@link LexicographicComparison lexicographically} greater than those of
+ * another.
+ *
+ * @param iterable The iterator to compare.
+ * @param other The iterator to compare against.
+ *
+ * @example
+ * ```typescript
+ * import { greaterThan } from '@sapphire/iterator-utilities';
+ *
+ * const x = [1, 2, 3, 4];
+ * const y = [1, 4, 9, 16];
+ * console.log(greaterThan([1], [1]));
+ * // Output: false
+ * console.log(greaterThan([1], [1, 2]));
+ * // Output: false
+ * console.log(greaterThan([1, 2], [1]));
+ * // Output: true
+ * console.log(greaterThan([1, 2], [1, 2]));
+ * // Output: false
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function greaterThan<const ElementType>(iterable: IterableResolvable<ElementType>, other: IterableResolvable<ElementType>): boolean;
+
+export { greaterThan, greaterThan as gt };

package/dist/cjs/lib/indexOf.cjs

@@ -17,6 +17,5 @@ function indexOf(iterable, value) {
 __name(indexOf, "indexOf");
 
 exports.indexOf = indexOf;
-exports.position = indexOf;
 //# sourceMappingURL=indexOf.cjs.map
 //# sourceMappingURL=indexOf.cjs.map

package/dist/cjs/lib/indexOf.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/indexOf.ts"],"names":["toIterableIterator"],"mappings":";;;;;;AAuBO,SAAS,OAAA,CAA2B,UAA2C,KAA4B,EAAA;AACjH,EAAA,IAAI,KAAQ,GAAA,CAAA,CAAA;AACZ,EAAW,KAAA,MAAA,OAAA,IAAWA,yCAAmB,CAAA,QAAQ,CAAG,EAAA;AACnD,IAAA,IAAI,YAAY,KAAO,EAAA;AACtB,MAAO,OAAA,KAAA,CAAA;AAAA,KACR;AAEA,IAAA,KAAA,EAAA,CAAA;AAAA,GACD;AAEA,EAAO,OAAA,CAAA,CAAA,CAAA;AACR,CAAA;AAXgB,MAAA,CAAA,OAAA,EAAA,SAAA,CAAA","file":"indexOf.cjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Advances the iterable until it finds the element, returning its index if it's found and `-1` otherwise.\n *\n * @param iterable An iterator to search for a value in.\n * @param value The value to search for.\n * @returns The index of the first occurrence of the value in the iterator, or `-1` if the value is not found.\n *\n * @example\n * ```typescript\n * import { indexOf } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log(indexOf(iterable, 3));\n * // Output: 2\n * ```\n *\n * @remarks\n *\n * This function consumes the iterator until the value is found or the iterator is exhausted.\n */\nexport function indexOf<const ElementType>(iterable: IterableResolvable<ElementType>, value: ElementType): number {\n\tlet index = 0;\n\tfor (const element of toIterableIterator(iterable)) {\n\t\tif (element === value) {\n\t\t\treturn index;\n\t\t}\n\n\t\tindex++;\n\t}\n\n\treturn -1;\n}\n\nexport { indexOf as position };\n"]}
+{"version":3,"sources":["../../../src/lib/indexOf.ts"],"names":["toIterableIterator"],"mappings":";;;;;;AAuBO,SAAS,OAAA,CAA2B,UAA2C,KAA4B,EAAA;AACjH,EAAA,IAAI,KAAQ,GAAA,CAAA;AACZ,EAAW,KAAA,MAAA,OAAA,IAAWA,yCAAmB,CAAA,QAAQ,CAAG,EAAA;AACnD,IAAA,IAAI,YAAY,KAAO,EAAA;AACtB,MAAO,OAAA,KAAA;AAAA;AAGR,IAAA,KAAA,EAAA;AAAA;AAGD,EAAO,OAAA,CAAA,CAAA;AACR;AAXgB,MAAA,CAAA,OAAA,EAAA,SAAA,CAAA","file":"indexOf.cjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Advances the iterable until it finds the element, returning its index if it's found and `-1` otherwise.\n *\n * @param iterable An iterator to search for a value in.\n * @param value The value to search for.\n * @returns The index of the first occurrence of the value in the iterator, or `-1` if the value is not found.\n *\n * @example\n * ```typescript\n * import { indexOf } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log(indexOf(iterable, 3));\n * // Output: 2\n * ```\n *\n * @remarks\n *\n * This function consumes the iterator until the value is found or the iterator is exhausted.\n */\nexport function indexOf<const ElementType>(iterable: IterableResolvable<ElementType>, value: ElementType): number {\n\tlet index = 0;\n\tfor (const element of toIterableIterator(iterable)) {\n\t\tif (element === value) {\n\t\t\treturn index;\n\t\t}\n\n\t\tindex++;\n\t}\n\n\treturn -1;\n}\n"]}

package/dist/cjs/lib/indexOf.d.cts

@@ -22,4 +22,4 @@ import { IterableResolvable } from './from.cjs';
  */
 declare function indexOf<const ElementType>(iterable: IterableResolvable<ElementType>, value: ElementType): number;
 
-export { indexOf, indexOf as position };
+export { indexOf };

package/dist/cjs/lib/inspect.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+var from_cjs = require('./from.cjs');
+var _assertFunction_cjs = require('./shared/_assertFunction.cjs');
+var _makeIterableIterator_cjs = require('./shared/_makeIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function inspect(iterable, callbackFn) {
+  callbackFn = _assertFunction_cjs.assertFunction(callbackFn);
+  let index = 0;
+  const iterator = from_cjs.from(iterable);
+  return _makeIterableIterator_cjs.makeIterableIterator(() => {
+    const result = iterator.next();
+    if (!result.done) {
+      callbackFn(result.value, index++);
+    }
+    return result;
+  });
+}
+__name(inspect, "inspect");
+
+exports.inspect = inspect;
+//# sourceMappingURL=inspect.cjs.map
+//# sourceMappingURL=inspect.cjs.map

package/dist/cjs/lib/inspect.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/inspect.ts"],"names":["assertFunction","from","makeIterableIterator"],"mappings":";;;;;;;;AAsCO,SAAS,OAAA,CACf,UACA,UACgC,EAAA;AAChC,EAAA,UAAA,GAAaA,mCAAe,UAAU,CAAA;AAEtC,EAAA,IAAI,KAAQ,GAAA,CAAA;AACZ,EAAM,MAAA,QAAA,GAAWC,cAAK,QAAQ,CAAA;AAC9B,EAAA,OAAOC,+CAAkC,MAAM;AAC9C,IAAM,MAAA,MAAA,GAAS,SAAS,IAAK,EAAA;AAC7B,IAAI,IAAA,CAAC,OAAO,IAAM,EAAA;AACjB,MAAW,UAAA,CAAA,MAAA,CAAO,OAAO,KAAO,EAAA,CAAA;AAAA;AAGjC,IAAO,OAAA,MAAA;AAAA,GACP,CAAA;AACF;AAhBgB,MAAA,CAAA,OAAA,EAAA,SAAA,CAAA","file":"inspect.cjs","sourcesContent":["import { from, type IterableResolvable } from './from';\nimport { assertFunction } from './shared/_assertFunction';\nimport { makeIterableIterator } from './shared/_makeIterableIterator';\n\n/**\n * Does something with each element of an iterator, passing the value on.\n *\n * When using iterators, you'll often chain several of them together. While working on such code, you might want to\n * check out what's happening at various parts in the pipeline. To do that, insert a call to this function.\n *\n * It's more common for this function to be used as a debugging tool than to exist in your final code, but applications\n * may find it useful in certain situations when errors need to be logged before being discarded.\n *\n * @param iterable An iterator to inspect.\n *\n * @example\n * ```typescript\n * import { inspect } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 4, 2, 3];\n *\n * let iter = inspect(iter, (value) => console.log(`about to filter: ${value}`));\n * iter = filter(iterable, (value) => value % 2 === 0);\n * iter = inspect(iter, (value) => console.log(`made it through filter: ${value}`));\n *\n * const sum = reduce(iter, (acc, value) => acc + value, 0);\n * console.log(sum);\n *\n * // Output:\n * // about to filter: 1\n * // about to filter: 4\n * // made it through filter: 4\n * // about to filter: 2\n * // made it through filter: 2\n * // about to filter: 3\n * // 6\n * ```\n */\nexport function inspect<const ElementType>(\n\titerable: IterableResolvable<ElementType>,\n\tcallbackFn: (element: ElementType, index: number) => void\n): IterableIterator<ElementType> {\n\tcallbackFn = assertFunction(callbackFn);\n\n\tlet index = 0;\n\tconst iterator = from(iterable);\n\treturn makeIterableIterator<ElementType>(() => {\n\t\tconst result = iterator.next();\n\t\tif (!result.done) {\n\t\t\tcallbackFn(result.value, index++);\n\t\t}\n\n\t\treturn result;\n\t});\n}\n"]}

package/dist/cjs/lib/inspect.d.cts

@@ -0,0 +1,39 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Does something with each element of an iterator, passing the value on.
+ *
+ * When using iterators, you'll often chain several of them together. While working on such code, you might want to
+ * check out what's happening at various parts in the pipeline. To do that, insert a call to this function.
+ *
+ * It's more common for this function to be used as a debugging tool than to exist in your final code, but applications
+ * may find it useful in certain situations when errors need to be logged before being discarded.
+ *
+ * @param iterable An iterator to inspect.
+ *
+ * @example
+ * ```typescript
+ * import { inspect } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [1, 4, 2, 3];
+ *
+ * let iter = inspect(iter, (value) => console.log(`about to filter: ${value}`));
+ * iter = filter(iterable, (value) => value % 2 === 0);
+ * iter = inspect(iter, (value) => console.log(`made it through filter: ${value}`));
+ *
+ * const sum = reduce(iter, (acc, value) => acc + value, 0);
+ * console.log(sum);
+ *
+ * // Output:
+ * // about to filter: 1
+ * // about to filter: 4
+ * // made it through filter: 4
+ * // about to filter: 2
+ * // made it through filter: 2
+ * // about to filter: 3
+ * // 6
+ * ```
+ */
+declare function inspect<const ElementType>(iterable: IterableResolvable<ElementType>, callbackFn: (element: ElementType, index: number) => void): IterableIterator<ElementType>;
+
+export { inspect };

package/dist/cjs/lib/intersect.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/intersect.ts"],"names":["toIterableIterator","filter"],"mappings":";;;;;;;AAyBO,SAAS,SAAA,CACf,OACA,MACgC,EAAA;AAChC,EAAA,MAAM,GAAM,GAAA,IAAI,GAAI,CAAAA,yCAAA,CAAmB,MAAM,CAAC,CAAA,CAAA;AAC9C,EAAA,OAAOC,kBAAO,KAAO,EAAA,CAAC,UAAU,GAAI,CAAA,GAAA,CAAI,KAAK,CAAC,CAAA,CAAA;AAC/C,CAAA;AANgB,MAAA,CAAA,SAAA,EAAA,WAAA,CAAA","file":"intersect.cjs","sourcesContent":["import { filter } from './filter';\nimport type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Creates an iterable with the elements that are in both input iterables.\n *\n * @param first An iterator to return elements from.\n * @param second An iterator that contains elements to include in the result.\n *\n * @example\n * ```typescript\n * import { intersect } from '@sapphire/iterator-utilities';\n *\n * const iterable = intersect([1, 2, 3, 4, 5], [3, 4, 5, 6, 7]);\n * console.log([...iterable]);\n * // Output: [3, 4, 5]\n * ```\n *\n * @remarks\n *\n * This function consumes the entire `second` iterator to build the set of elements to intersect with `first`.\n *\n * @seealso {@link difference} for the opposite behavior.\n */\nexport function intersect<const ElementType>(\n\tfirst: IterableResolvable<ElementType>,\n\tsecond: IterableResolvable<ElementType>\n): IterableIterator<ElementType> {\n\tconst set = new Set(toIterableIterator(second));\n\treturn filter(first, (value) => set.has(value));\n}\n"]}
+{"version":3,"sources":["../../../src/lib/intersect.ts"],"names":["toIterableIterator","filter"],"mappings":";;;;;;;AAyBO,SAAS,SAAA,CACf,OACA,MACgC,EAAA;AAChC,EAAA,MAAM,GAAM,GAAA,IAAI,GAAI,CAAAA,yCAAA,CAAmB,MAAM,CAAC,CAAA;AAC9C,EAAA,OAAOC,kBAAO,KAAO,EAAA,CAAC,UAAU,GAAI,CAAA,GAAA,CAAI,KAAK,CAAC,CAAA;AAC/C;AANgB,MAAA,CAAA,SAAA,EAAA,WAAA,CAAA","file":"intersect.cjs","sourcesContent":["import { filter } from './filter';\nimport type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Creates an iterable with the elements that are in both input iterables.\n *\n * @param first An iterator to return elements from.\n * @param second An iterator that contains elements to include in the result.\n *\n * @example\n * ```typescript\n * import { intersect } from '@sapphire/iterator-utilities';\n *\n * const iterable = intersect([1, 2, 3, 4, 5], [3, 4, 5, 6, 7]);\n * console.log([...iterable]);\n * // Output: [3, 4, 5]\n * ```\n *\n * @remarks\n *\n * This function consumes the entire `second` iterator to build the set of elements to intersect with `first`.\n *\n * @seealso {@link difference} for the opposite behavior.\n */\nexport function intersect<const ElementType>(\n\tfirst: IterableResolvable<ElementType>,\n\tsecond: IterableResolvable<ElementType>\n): IterableIterator<ElementType> {\n\tconst set = new Set(toIterableIterator(second));\n\treturn filter(first, (value) => set.has(value));\n}\n"]}

package/dist/cjs/lib/intersperse.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+var from_cjs = require('./from.cjs');
+var _makeIterableIterator_cjs = require('./shared/_makeIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function intersperse(iterable, separator) {
+  let started = false;
+  let nextItem;
+  let nextItemTaken = false;
+  const iterator = from_cjs.from(iterable);
+  return _makeIterableIterator_cjs.makeIterableIterator(() => {
+    if (started) {
+      if (nextItemTaken) {
+        nextItemTaken = false;
+        return { done: false, value: nextItem };
+      }
+      const result = iterator.next();
+      if (result.done) {
+        return { done: true, value: void 0 };
+      }
+      nextItem = result.value;
+      nextItemTaken = true;
+      return { done: false, value: separator };
+    }
+    started = true;
+    return iterator.next();
+  });
+}
+__name(intersperse, "intersperse");
+
+exports.intersperse = intersperse;
+//# sourceMappingURL=intersperse.cjs.map
+//# sourceMappingURL=intersperse.cjs.map

package/dist/cjs/lib/intersperse.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/intersperse.ts"],"names":["from","makeIterableIterator"],"mappings":";;;;;;;AA4BO,SAAS,WAAA,CAA+B,UAA2C,SAAuD,EAAA;AAChJ,EAAA,IAAI,OAAU,GAAA,KAAA;AACd,EAAI,IAAA,QAAA;AACJ,EAAA,IAAI,aAAgB,GAAA,KAAA;AAEpB,EAAM,MAAA,QAAA,GAAWA,cAAK,QAAQ,CAAA;AAC9B,EAAA,OAAOC,+CAAkC,MAAM;AAC9C,IAAA,IAAI,OAAS,EAAA;AACZ,MAAA,IAAI,aAAe,EAAA;AAClB,QAAgB,aAAA,GAAA,KAAA;AAChB,QAAA,OAAO,EAAE,IAAA,EAAM,KAAO,EAAA,KAAA,EAAO,QAAS,EAAA;AAAA;AAGvC,MAAM,MAAA,MAAA,GAAS,SAAS,IAAK,EAAA;AAC7B,MAAA,IAAI,OAAO,IAAM,EAAA;AAChB,QAAA,OAAO,EAAE,IAAA,EAAM,IAAM,EAAA,KAAA,EAAO,KAAU,CAAA,EAAA;AAAA;AAGvC,MAAA,QAAA,GAAW,MAAO,CAAA,KAAA;AAClB,MAAgB,aAAA,GAAA,IAAA;AAChB,MAAA,OAAO,EAAE,IAAA,EAAM,KAAO,EAAA,KAAA,EAAO,SAAU,EAAA;AAAA;AAGxC,IAAU,OAAA,GAAA,IAAA;AACV,IAAA,OAAO,SAAS,IAAK,EAAA;AAAA,GACrB,CAAA;AACF;AA1BgB,MAAA,CAAA,WAAA,EAAA,aAAA,CAAA","file":"intersperse.cjs","sourcesContent":["import { from, type IterableResolvable } from './from';\nimport { makeIterableIterator } from './shared/_makeIterableIterator';\n\n/**\n * Creates a new iterator which places `separator` between adjacent items of the original iterator.\n *\n * @param iterable An iterator to map over.\n * @param separator The separator to place between adjacent items.\n *\n * @example\n * ```typescript\n * import { intersperse } from '@sapphire/iterator-utilities';\n *\n * const iterable = [0, 1, 2];\n * console.log([...intersperse(iterable, 100)]);\n * // Output: [0, 100, 1, 100, 2]\n * ```\n *\n * @example\n * `intersperse` can be very useful to join an iterator's items using a common element:\n * ```typescript\n * import { intersperse } from '@sapphire/iterator-utilities';\n *\n * const iterable = ['Hello', 'World', '!'];\n * console.log([...intersperse(iterable, ', ')].join(''));\n * // Output: 'Hello, World, !'\n * ```\n */\nexport function intersperse<const ElementType>(iterable: IterableResolvable<ElementType>, separator: ElementType): IterableIterator<ElementType> {\n\tlet started = false;\n\tlet nextItem: ElementType;\n\tlet nextItemTaken = false;\n\n\tconst iterator = from(iterable);\n\treturn makeIterableIterator<ElementType>(() => {\n\t\tif (started) {\n\t\t\tif (nextItemTaken) {\n\t\t\t\tnextItemTaken = false;\n\t\t\t\treturn { done: false, value: nextItem };\n\t\t\t}\n\n\t\t\tconst result = iterator.next();\n\t\t\tif (result.done) {\n\t\t\t\treturn { done: true, value: undefined };\n\t\t\t}\n\n\t\t\tnextItem = result.value;\n\t\t\tnextItemTaken = true;\n\t\t\treturn { done: false, value: separator };\n\t\t}\n\n\t\tstarted = true;\n\t\treturn iterator.next();\n\t});\n}\n"]}

package/dist/cjs/lib/intersperse.d.cts

@@ -0,0 +1,30 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Creates a new iterator which places `separator` between adjacent items of the original iterator.
+ *
+ * @param iterable An iterator to map over.
+ * @param separator The separator to place between adjacent items.
+ *
+ * @example
+ * ```typescript
+ * import { intersperse } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = [0, 1, 2];
+ * console.log([...intersperse(iterable, 100)]);
+ * // Output: [0, 100, 1, 100, 2]
+ * ```
+ *
+ * @example
+ * `intersperse` can be very useful to join an iterator's items using a common element:
+ * ```typescript
+ * import { intersperse } from '@sapphire/iterator-utilities';
+ *
+ * const iterable = ['Hello', 'World', '!'];
+ * console.log([...intersperse(iterable, ', ')].join(''));
+ * // Output: 'Hello, World, !'
+ * ```
+ */
+declare function intersperse<const ElementType>(iterable: IterableResolvable<ElementType>, separator: ElementType): IterableIterator<ElementType>;
+
+export { intersperse };

package/dist/cjs/lib/isEmpty.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/isEmpty.ts"],"names":["from"],"mappings":";;;;;;AAuBO,SAAS,QAA2B,QAAoD,EAAA;AAC9F,EAAA,OAAOA,aAAK,CAAA,QAAQ,CAAE,CAAA,IAAA,GAAO,IAAQ,IAAA,KAAA,CAAA;AACtC,CAAA;AAFgB,MAAA,CAAA,OAAA,EAAA,SAAA,CAAA","file":"isEmpty.cjs","sourcesContent":["import { from, type IterableResolvable } from './from';\n\n/**\n * Advances the iterable once, returning `true` if it's exhausted and `false` otherwise.\n *\n * @param iterable The iterator to check for emptiness.\n * @returns `true` if the iterator is empty; otherwise, `false`.\n *\n * @example\n * ```typescript\n * import { isEmpty } from '@sapphire/iterator-utilities';\n *\n * console.log(isEmpty([]));\n * // Output: true\n *\n * console.log(isEmpty([1, 2, 3, 4, 5]));\n * // Output: false\n * ```\n *\n * @remarks\n *\n * This function consumes the first value of the iterator.\n */\nexport function isEmpty<const ElementType>(iterable: IterableResolvable<ElementType>): boolean {\n\treturn from(iterable).next().done ?? false;\n}\n"]}
+{"version":3,"sources":["../../../src/lib/isEmpty.ts"],"names":["from"],"mappings":";;;;;;AAuBO,SAAS,QAA2B,QAAoD,EAAA;AAC9F,EAAA,OAAOA,aAAK,CAAA,QAAQ,CAAE,CAAA,IAAA,GAAO,IAAQ,IAAA,KAAA;AACtC;AAFgB,MAAA,CAAA,OAAA,EAAA,SAAA,CAAA","file":"isEmpty.cjs","sourcesContent":["import { from, type IterableResolvable } from './from';\n\n/**\n * Advances the iterable once, returning `true` if it's exhausted and `false` otherwise.\n *\n * @param iterable The iterator to check for emptiness.\n * @returns `true` if the iterator is empty; otherwise, `false`.\n *\n * @example\n * ```typescript\n * import { isEmpty } from '@sapphire/iterator-utilities';\n *\n * console.log(isEmpty([]));\n * // Output: true\n *\n * console.log(isEmpty([1, 2, 3, 4, 5]));\n * // Output: false\n * ```\n *\n * @remarks\n *\n * This function consumes the first value of the iterator.\n */\nexport function isEmpty<const ElementType>(iterable: IterableResolvable<ElementType>): boolean {\n\treturn from(iterable).next().done ?? false;\n}\n"]}

package/dist/cjs/lib/isSorted.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var isSortedBy_cjs = require('./isSortedBy.cjs');
+var comparators_cjs = require('./shared/comparators.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function isSorted(iterable) {
+  return isSortedBy_cjs.isSortedBy(iterable, comparators_cjs.defaultCompare);
+}
+__name(isSorted, "isSorted");
+
+exports.isSorted = isSorted;
+//# sourceMappingURL=isSorted.cjs.map
+//# sourceMappingURL=isSorted.cjs.map

package/dist/cjs/lib/isSorted.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/isSorted.ts"],"names":["isSortedBy","defaultCompare"],"mappings":";;;;;;;AAmCO,SAAS,SAA4B,QAAoD,EAAA;AAC/F,EAAO,OAAAA,yBAAA,CAAW,UAAUC,8BAAc,CAAA;AAC3C;AAFgB,MAAA,CAAA,QAAA,EAAA,UAAA,CAAA","file":"isSorted.cjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport { isSortedBy } from './isSortedBy';\nimport type { isSortedByKey } from './isSortedByKey';\nimport { defaultCompare } from './shared/comparators';\n\n/**\n * Checks if the elements of this iterator are sorted in ascending order.\n *\n * That is, for each element `a` and its following element `b`, `a <= b` must hold. If the iterator yields exactly zero\n * or one element, `true` is returned.\n *\n * This function uses the default comparator (lexicographically), which means it will compare the elements as strings.\n * If this is undesirable, use {@link isSortedBy} instead.\n *\n * @seealso {@link isSortedBy} for a version that allows custom comparators.\n * @seealso {@link isSortedByKey} for a version that allows custom key extractors.\n *\n * @param iterable The iterator to compare.\n *\n * @example\n * ```typescript\n * import { isSorted } from '@sapphire/iterator-utilities';\n *\n * assert(isSorted([1, 2, 2, 9]);\n * assert(!isSorted([1, 3, 2, 4]);\n *\n * assert(isSorted([0]);\n * assert(isSorted([]);\n * assert(isSorted([0, 1, NaN]);\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function isSorted<const ElementType>(iterable: IterableResolvable<ElementType>): boolean {\n\treturn isSortedBy(iterable, defaultCompare);\n}\n"]}

package/dist/cjs/lib/isSorted.d.cts

@@ -0,0 +1,35 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Checks if the elements of this iterator are sorted in ascending order.
+ *
+ * That is, for each element `a` and its following element `b`, `a <= b` must hold. If the iterator yields exactly zero
+ * or one element, `true` is returned.
+ *
+ * This function uses the default comparator (lexicographically), which means it will compare the elements as strings.
+ * If this is undesirable, use {@link isSortedBy} instead.
+ *
+ * @seealso {@link isSortedBy} for a version that allows custom comparators.
+ * @seealso {@link isSortedByKey} for a version that allows custom key extractors.
+ *
+ * @param iterable The iterator to compare.
+ *
+ * @example
+ * ```typescript
+ * import { isSorted } from '@sapphire/iterator-utilities';
+ *
+ * assert(isSorted([1, 2, 2, 9]);
+ * assert(!isSorted([1, 3, 2, 4]);
+ *
+ * assert(isSorted([0]);
+ * assert(isSorted([]);
+ * assert(isSorted([0, 1, NaN]);
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function isSorted<const ElementType>(iterable: IterableResolvable<ElementType>): boolean;
+
+export { isSorted };

package/dist/cjs/lib/isSortedBy.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+var _assertFunction_cjs = require('./shared/_assertFunction.cjs');
+var _compare_cjs = require('./shared/_compare.cjs');
+var toIterableIterator_cjs = require('./toIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function isSortedBy(iterable, comparator) {
+  comparator = _assertFunction_cjs.assertFunction(comparator);
+  const iterator = toIterableIterator_cjs.toIterableIterator(iterable);
+  const result = iterator.next();
+  if (result.done) return true;
+  let previous = result.value;
+  for (const current of iterator) {
+    const comparison = _compare_cjs.compareIteratorElements(previous, current, comparator);
+    if (_compare_cjs.orderingIsGreater(comparison)) return false;
+    previous = current;
+  }
+  return true;
+}
+__name(isSortedBy, "isSortedBy");
+
+exports.isSortedBy = isSortedBy;
+//# sourceMappingURL=isSortedBy.cjs.map
+//# sourceMappingURL=isSortedBy.cjs.map

package/dist/cjs/lib/isSortedBy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/isSortedBy.ts"],"names":["assertFunction","toIterableIterator","compareIteratorElements","orderingIsGreater"],"mappings":";;;;;;;;AAiCO,SAAS,UAAA,CAA8B,UAA2C,UAAuD,EAAA;AAC/I,EAAA,UAAA,GAAaA,mCAAe,UAAU,CAAA;AAEtC,EAAM,MAAA,QAAA,GAAWC,0CAAmB,QAAQ,CAAA;AAC5C,EAAM,MAAA,MAAA,GAAS,SAAS,IAAK,EAAA;AAC7B,EAAI,IAAA,MAAA,CAAO,MAAa,OAAA,IAAA;AAExB,EAAA,IAAI,WAAW,MAAO,CAAA,KAAA;AACtB,EAAA,KAAA,MAAW,WAAW,QAAU,EAAA;AAC/B,IAAA,MAAM,UAAa,GAAAC,oCAAA,CAAqC,QAAU,EAAA,OAAA,EAAS,UAAU,CAAA;AACrF,IAAI,IAAAC,8BAAA,CAAkB,UAAU,CAAA,EAAU,OAAA,KAAA;AAE1C,IAAW,QAAA,GAAA,OAAA;AAAA;AAGZ,EAAO,OAAA,IAAA;AACR;AAhBgB,MAAA,CAAA,UAAA,EAAA,YAAA,CAAA","file":"isSortedBy.cjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport type { isSorted } from './isSorted';\nimport type { isSortedByKey } from './isSortedByKey';\nimport { assertFunction } from './shared/_assertFunction';\nimport { compareIteratorElements, orderingIsGreater, type CompareByComparator } from './shared/_compare';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Checks if the elements of this iterator are sorted using the given comparator function.\n *\n * @seealso {@link isSorted} for a version that uses the default comparator.\n * @seealso {@link isSortedByKey} for a version that allows custom key extractors.\n *\n * @param iterable The iterator to compare.\n *\n * @example\n * ```typescript\n * import { ascNumber, isSortedBy } from '@sapphire/iterator-utilities';\n *\n * assert(isSortedBy([1, 2, 2, 9], ascNumber));\n * assert(!isSortedBy([1, 2, 2, 9], ascNumber));\n *\n * assert(isSortedBy([0], () => true));\n * assert(isSortedBy([0], () => false));\n *\n * assert(isSortedBy([], () => true));\n * assert(isSortedBy([], () => false));\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function isSortedBy<const ElementType>(iterable: IterableResolvable<ElementType>, comparator: CompareByComparator<ElementType>): boolean {\n\tcomparator = assertFunction(comparator);\n\n\tconst iterator = toIterableIterator(iterable);\n\tconst result = iterator.next();\n\tif (result.done) return true;\n\n\tlet previous = result.value;\n\tfor (const current of iterator) {\n\t\tconst comparison = compareIteratorElements<ElementType>(previous, current, comparator);\n\t\tif (orderingIsGreater(comparison)) return false;\n\n\t\tprevious = current;\n\t}\n\n\treturn true;\n}\n"]}

package/dist/cjs/lib/isSortedBy.d.cts

@@ -0,0 +1,32 @@
+import { IterableResolvable } from './from.cjs';
+import { CompareByComparator } from './shared/_compare.js';
+
+/**
+ * Checks if the elements of this iterator are sorted using the given comparator function.
+ *
+ * @seealso {@link isSorted} for a version that uses the default comparator.
+ * @seealso {@link isSortedByKey} for a version that allows custom key extractors.
+ *
+ * @param iterable The iterator to compare.
+ *
+ * @example
+ * ```typescript
+ * import { ascNumber, isSortedBy } from '@sapphire/iterator-utilities';
+ *
+ * assert(isSortedBy([1, 2, 2, 9], ascNumber));
+ * assert(!isSortedBy([1, 2, 2, 9], ascNumber));
+ *
+ * assert(isSortedBy([0], () => true));
+ * assert(isSortedBy([0], () => false));
+ *
+ * assert(isSortedBy([], () => true));
+ * assert(isSortedBy([], () => false));
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function isSortedBy<const ElementType>(iterable: IterableResolvable<ElementType>, comparator: CompareByComparator<ElementType>): boolean;
+
+export { isSortedBy };

package/dist/cjs/lib/isSortedByKey.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var _assertFunction_cjs = require('./shared/_assertFunction.cjs');
+var _compare_cjs = require('./shared/_compare.cjs');
+var comparators_cjs = require('./shared/comparators.cjs');
+var toIterableIterator_cjs = require('./toIterableIterator.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function isSortedByKey(iterable, callbackFn, comparator = comparators_cjs.defaultCompare) {
+  callbackFn = _assertFunction_cjs.assertFunction(callbackFn);
+  const iterator = toIterableIterator_cjs.toIterableIterator(iterable);
+  const result = iterator.next();
+  if (result.done) return true;
+  let previousKey = callbackFn(result.value, 0);
+  let index = 1;
+  for (const current of iterator) {
+    const currentKey = callbackFn(current, index++);
+    const comparison = _compare_cjs.compareIteratorElements(previousKey, currentKey, comparator);
+    if (_compare_cjs.orderingIsGreater(comparison)) return false;
+    previousKey = currentKey;
+  }
+  return true;
+}
+__name(isSortedByKey, "isSortedByKey");
+
+exports.isSortedByKey = isSortedByKey;
+//# sourceMappingURL=isSortedByKey.cjs.map
+//# sourceMappingURL=isSortedByKey.cjs.map

package/dist/cjs/lib/isSortedByKey.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/isSortedByKey.ts"],"names":["defaultCompare","assertFunction","toIterableIterator","compareIteratorElements","orderingIsGreater"],"mappings":";;;;;;;;;AAgCO,SAAS,aACf,CAAA,QAAA,EACA,UACA,EAAA,UAAA,GAA8CA,8BACpC,EAAA;AACV,EAAA,UAAA,GAAaC,mCAAe,UAAU,CAAA;AAEtC,EAAM,MAAA,QAAA,GAAWC,0CAAmB,QAAQ,CAAA;AAC5C,EAAM,MAAA,MAAA,GAAS,SAAS,IAAK,EAAA;AAC7B,EAAI,IAAA,MAAA,CAAO,MAAa,OAAA,IAAA;AAExB,EAAA,IAAI,WAAc,GAAA,UAAA,CAAW,MAAO,CAAA,KAAA,EAAO,CAAC,CAAA;AAC5C,EAAA,IAAI,KAAQ,GAAA,CAAA;AACZ,EAAA,KAAA,MAAW,WAAW,QAAU,EAAA;AAC/B,IAAM,MAAA,UAAA,GAAa,UAAW,CAAA,OAAA,EAAS,KAAO,EAAA,CAAA;AAC9C,IAAA,MAAM,UAAa,GAAAC,oCAAA,CAAoC,WAAa,EAAA,UAAA,EAAY,UAAU,CAAA;AAC1F,IAAI,IAAAC,8BAAA,CAAkB,UAAU,CAAA,EAAU,OAAA,KAAA;AAE1C,IAAc,WAAA,GAAA,UAAA;AAAA;AAGf,EAAO,OAAA,IAAA;AACR;AAtBgB,MAAA,CAAA,aAAA,EAAA,eAAA,CAAA","file":"isSortedByKey.cjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport type { isSorted } from './isSorted';\nimport type { isSortedBy } from './isSortedBy';\nimport { assertFunction } from './shared/_assertFunction';\nimport { compareIteratorElements, orderingIsGreater, type CompareByComparator } from './shared/_compare';\nimport { defaultCompare } from './shared/comparators';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Checks if the elements of this iterator are sorted using the given key extraction function.\n *\n * Instead of comparing the iterator's elements directly, this function compares the keys of the elements, as determined\n * by `callbackFn`. Apart from that, it's equivalent to {@link isSorted}; see its documentation for more information.\n *\n * @seealso {@link isSorted} for a version that uses the default comparator.\n * @seealso {@link isSortedBy} for a version that allows custom comparators.\n *\n * @param iterable The iterator to compare.\n * @param callbackFn The function to extract the key from an element.\n *\n * @example\n * ```typescript\n * import { isSortedByKey } from '@sapphire/iterator-utilities';\n *\n * assert(isSortedByKey(['c', 'bb', 'aaa'], (s) => s.length));\n * assert(!isSortedBy([-2, -1, 0, 3], (n) => Math.abs(n)));\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function isSortedByKey<const ElementType, const MappedType>(\n\titerable: IterableResolvable<ElementType>,\n\tcallbackFn: (a: ElementType, index: number) => MappedType,\n\tcomparator: CompareByComparator<MappedType> = defaultCompare\n): boolean {\n\tcallbackFn = assertFunction(callbackFn);\n\n\tconst iterator = toIterableIterator(iterable);\n\tconst result = iterator.next();\n\tif (result.done) return true;\n\n\tlet previousKey = callbackFn(result.value, 0);\n\tlet index = 1;\n\tfor (const current of iterator) {\n\t\tconst currentKey = callbackFn(current, index++);\n\t\tconst comparison = compareIteratorElements<MappedType>(previousKey, currentKey, comparator);\n\t\tif (orderingIsGreater(comparison)) return false;\n\n\t\tpreviousKey = currentKey;\n\t}\n\n\treturn true;\n}\n"]}

package/dist/cjs/lib/isSortedByKey.d.cts

@@ -0,0 +1,30 @@
+import { IterableResolvable } from './from.cjs';
+import { CompareByComparator } from './shared/_compare.js';
+
+/**
+ * Checks if the elements of this iterator are sorted using the given key extraction function.
+ *
+ * Instead of comparing the iterator's elements directly, this function compares the keys of the elements, as determined
+ * by `callbackFn`. Apart from that, it's equivalent to {@link isSorted}; see its documentation for more information.
+ *
+ * @seealso {@link isSorted} for a version that uses the default comparator.
+ * @seealso {@link isSortedBy} for a version that allows custom comparators.
+ *
+ * @param iterable The iterator to compare.
+ * @param callbackFn The function to extract the key from an element.
+ *
+ * @example
+ * ```typescript
+ * import { isSortedByKey } from '@sapphire/iterator-utilities';
+ *
+ * assert(isSortedByKey(['c', 'bb', 'aaa'], (s) => s.length));
+ * assert(!isSortedBy([-2, -1, 0, 3], (n) => Math.abs(n)));
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function isSortedByKey<const ElementType, const MappedType>(iterable: IterableResolvable<ElementType>, callbackFn: (a: ElementType, index: number) => MappedType, comparator?: CompareByComparator<MappedType>): boolean;
+
+export { isSortedByKey };

package/dist/cjs/lib/last.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/last.ts"],"names":["last","toIterableIterator"],"mappings":";;;;;;AAsBO,SAAS,KAAwB,QAAoE,EAAA;AAC3G,EAAIA,IAAAA,KAAAA,CAAAA;AACJ,EAAW,KAAA,MAAA,KAAA,IAASC,yCAAmB,CAAA,QAAQ,CAAG,EAAA;AACjD,IAAAD,KAAO,GAAA,KAAA,CAAA;AAAA,GACR;AAEA,EAAOA,OAAAA,KAAAA,CAAAA;AACR,CAAA;AAPgB,MAAA,CAAA,IAAA,EAAA,MAAA,CAAA","file":"last.cjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Consumes the iterable until it's exhausted, returning the last element.\n *\n * @param iterable An iterator to return the last value of.\n * @returns The value at the last position in the source iterator, or `undefined` if the iterator is empty.\n *\n * @example\n * ```typescript\n * import { last } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log(last(iterable));\n * // Output: 5\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator to find the last value.\n */\nexport function last<const ElementType>(iterable: IterableResolvable<ElementType>): ElementType | undefined {\n\tlet last: ElementType | undefined;\n\tfor (const value of toIterableIterator(iterable)) {\n\t\tlast = value;\n\t}\n\n\treturn last;\n}\n"]}
+{"version":3,"sources":["../../../src/lib/last.ts"],"names":["last","toIterableIterator"],"mappings":";;;;;;AAsBO,SAAS,KAAwB,QAAoE,EAAA;AAC3G,EAAIA,IAAAA,KAAAA;AACJ,EAAW,KAAA,MAAA,KAAA,IAASC,yCAAmB,CAAA,QAAQ,CAAG,EAAA;AACjD,IAAAD,KAAO,GAAA,KAAA;AAAA;AAGR,EAAOA,OAAAA,KAAAA;AACR;AAPgB,MAAA,CAAA,IAAA,EAAA,MAAA,CAAA","file":"last.cjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Consumes the iterable until it's exhausted, returning the last element.\n *\n * @param iterable An iterator to return the last value of.\n * @returns The value at the last position in the source iterator, or `undefined` if the iterator is empty.\n *\n * @example\n * ```typescript\n * import { last } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log(last(iterable));\n * // Output: 5\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator to find the last value.\n */\nexport function last<const ElementType>(iterable: IterableResolvable<ElementType>): ElementType | undefined {\n\tlet last: ElementType | undefined;\n\tfor (const value of toIterableIterator(iterable)) {\n\t\tlast = value;\n\t}\n\n\treturn last;\n}\n"]}

package/dist/cjs/lib/lessOrEqualThan.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var compare_cjs = require('./compare.cjs');
+var _compare_cjs = require('./shared/_compare.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function lessOrEqualThan(iterable, other) {
+  const result = compare_cjs.compare(iterable, other);
+  return !_compare_cjs.orderingIsGreater(result);
+}
+__name(lessOrEqualThan, "lessOrEqualThan");
+
+exports.le = lessOrEqualThan;
+exports.lessOrEqualThan = lessOrEqualThan;
+//# sourceMappingURL=lessOrEqualThan.cjs.map
+//# sourceMappingURL=lessOrEqualThan.cjs.map

package/dist/cjs/lib/lessOrEqualThan.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/lessOrEqualThan.ts"],"names":["compare","orderingIsGreater"],"mappings":";;;;;;;AA+BO,SAAS,eAAA,CAAmC,UAA2C,KAAiD,EAAA;AAC9I,EAAM,MAAA,MAAA,GAASA,mBAAQ,CAAA,QAAA,EAAU,KAAK,CAAA;AACtC,EAAO,OAAA,CAACC,+BAAkB,MAAM,CAAA;AACjC;AAHgB,MAAA,CAAA,eAAA,EAAA,iBAAA,CAAA","file":"lessOrEqualThan.cjs","sourcesContent":["import { compare } from './compare';\nimport type { IterableResolvable } from './from';\nimport { orderingIsGreater, type LexicographicComparison } from './shared/_compare';\n\n/**\n * Determines if the elements of `iterable` are {@link LexicographicComparison lexicographically} less or equal than\n * those of another.\n *\n * @param iterable The iterator to compare.\n * @param other The iterator to compare against.\n *\n * @example\n * ```typescript\n * import { lessOrEqualThan } from '@sapphire/iterator-utilities';\n *\n * const x = [1, 2, 3, 4];\n * const y = [1, 4, 9, 16];\n * console.log(lessOrEqualThan([1], [1]));\n * // Output: false\n * console.log(lessOrEqualThan([1], [1, 2]));\n * // Output: true\n * console.log(lessOrEqualThan([1, 2], [1]));\n * // Output: false\n * console.log(lessOrEqualThan([1, 2], [1, 2]));\n * // Output: true\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function lessOrEqualThan<const ElementType>(iterable: IterableResolvable<ElementType>, other: IterableResolvable<ElementType>): boolean {\n\tconst result = compare(iterable, other);\n\treturn !orderingIsGreater(result);\n}\n\nexport { lessOrEqualThan as le };\n"]}

package/dist/cjs/lib/lessOrEqualThan.d.cts

@@ -0,0 +1,32 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Determines if the elements of `iterable` are {@link LexicographicComparison lexicographically} less or equal than
+ * those of another.
+ *
+ * @param iterable The iterator to compare.
+ * @param other The iterator to compare against.
+ *
+ * @example
+ * ```typescript
+ * import { lessOrEqualThan } from '@sapphire/iterator-utilities';
+ *
+ * const x = [1, 2, 3, 4];
+ * const y = [1, 4, 9, 16];
+ * console.log(lessOrEqualThan([1], [1]));
+ * // Output: false
+ * console.log(lessOrEqualThan([1], [1, 2]));
+ * // Output: true
+ * console.log(lessOrEqualThan([1, 2], [1]));
+ * // Output: false
+ * console.log(lessOrEqualThan([1, 2], [1, 2]));
+ * // Output: true
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function lessOrEqualThan<const ElementType>(iterable: IterableResolvable<ElementType>, other: IterableResolvable<ElementType>): boolean;
+
+export { lessOrEqualThan as le, lessOrEqualThan };

package/dist/cjs/lib/lessThan.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var compare_cjs = require('./compare.cjs');
+var _compare_cjs = require('./shared/_compare.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function lessThan(iterable, other) {
+  const result = compare_cjs.compare(iterable, other);
+  return _compare_cjs.orderingIsLess(result);
+}
+__name(lessThan, "lessThan");
+
+exports.lessThan = lessThan;
+exports.lt = lessThan;
+//# sourceMappingURL=lessThan.cjs.map
+//# sourceMappingURL=lessThan.cjs.map

package/dist/cjs/lib/lessThan.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/lessThan.ts"],"names":["compare","orderingIsLess"],"mappings":";;;;;;;AA+BO,SAAS,QAAA,CAA4B,UAA2C,KAAiD,EAAA;AACvI,EAAM,MAAA,MAAA,GAASA,mBAAQ,CAAA,QAAA,EAAU,KAAK,CAAA;AACtC,EAAA,OAAOC,4BAAe,MAAM,CAAA;AAC7B;AAHgB,MAAA,CAAA,QAAA,EAAA,UAAA,CAAA","file":"lessThan.cjs","sourcesContent":["import { compare } from './compare';\nimport type { IterableResolvable } from './from';\nimport { orderingIsLess, type LexicographicComparison } from './shared/_compare';\n\n/**\n * Determines if the elements of `iterable` are {@link LexicographicComparison lexicographically} less than those of\n * another.\n *\n * @param iterable The iterator to compare.\n * @param other The iterator to compare against.\n *\n * @example\n * ```typescript\n * import { lessThan } from '@sapphire/iterator-utilities';\n *\n * const x = [1, 2, 3, 4];\n * const y = [1, 4, 9, 16];\n * console.log(lessThan([1], [1]));\n * // Output: false\n * console.log(lessThan([1], [1, 2]));\n * // Output: true\n * console.log(lessThan([1, 2], [1]));\n * // Output: false\n * console.log(lessThan([1, 2], [1, 2]));\n * // Output: false\n * ```\n *\n * @remarks\n *\n * This function consumes the entire iterator.\n */\nexport function lessThan<const ElementType>(iterable: IterableResolvable<ElementType>, other: IterableResolvable<ElementType>): boolean {\n\tconst result = compare(iterable, other);\n\treturn orderingIsLess(result);\n}\n\nexport { lessThan as lt };\n"]}

package/dist/cjs/lib/lessThan.d.cts

@@ -0,0 +1,32 @@
+import { IterableResolvable } from './from.cjs';
+
+/**
+ * Determines if the elements of `iterable` are {@link LexicographicComparison lexicographically} less than those of
+ * another.
+ *
+ * @param iterable The iterator to compare.
+ * @param other The iterator to compare against.
+ *
+ * @example
+ * ```typescript
+ * import { lessThan } from '@sapphire/iterator-utilities';
+ *
+ * const x = [1, 2, 3, 4];
+ * const y = [1, 4, 9, 16];
+ * console.log(lessThan([1], [1]));
+ * // Output: false
+ * console.log(lessThan([1], [1, 2]));
+ * // Output: true
+ * console.log(lessThan([1, 2], [1]));
+ * // Output: false
+ * console.log(lessThan([1, 2], [1, 2]));
+ * // Output: false
+ * ```
+ *
+ * @remarks
+ *
+ * This function consumes the entire iterator.
+ */
+declare function lessThan<const ElementType>(iterable: IterableResolvable<ElementType>, other: IterableResolvable<ElementType>): boolean;
+
+export { lessThan, lessThan as lt };

package/dist/cjs/lib/map.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/map.ts"],"names":["assertFunction","toIterableIterator"],"mappings":";;;;;;;AAmBO,UAAU,GAAA,CAChB,UACA,UAC+B,EAAA;AAC/B,EAAA,UAAA,GAAaA,mCAAe,UAAU,CAAA,CAAA;AAEtC,EAAA,IAAI,KAAQ,GAAA,CAAA,CAAA;AACZ,EAAW,KAAA,MAAA,OAAA,IAAWC,yCAAmB,CAAA,QAAQ,CAAG,EAAA;AACnD,IAAM,MAAA,UAAA,CAAW,SAAS,KAAO,EAAA,CAAA,CAAA;AAAA,GAClC;AACD,CAAA;AAViB,MAAA,CAAA,GAAA,EAAA,KAAA,CAAA","file":"map.cjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport { assertFunction } from './shared/_assertFunction';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Creates an iterable with the results of calling a provided function on each element.\n *\n * @param iterable An iterator to map over.\n * @param callbackFn A function to execute for each element produced by the iterator. Its return value is yielded by the iterator helper.\n *\n * @example\n * ```typescript\n * import { map } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log([...map(iterable, (value) => value * 2)]);\n * // Output: [2, 4, 6, 8, 10]\n * ```\n */\nexport function* map<const ElementType, const MappedType>(\n\titerable: IterableResolvable<ElementType>,\n\tcallbackFn: (element: ElementType, index: number) => MappedType\n): IterableIterator<MappedType> {\n\tcallbackFn = assertFunction(callbackFn);\n\n\tlet index = 0;\n\tfor (const element of toIterableIterator(iterable)) {\n\t\tyield callbackFn(element, index++);\n\t}\n}\n"]}
+{"version":3,"sources":["../../../src/lib/map.ts"],"names":["assertFunction","toIterableIterator"],"mappings":";;;;;;;AAmBO,UAAU,GAAA,CAChB,UACA,UAC+B,EAAA;AAC/B,EAAA,UAAA,GAAaA,mCAAe,UAAU,CAAA;AAEtC,EAAA,IAAI,KAAQ,GAAA,CAAA;AACZ,EAAW,KAAA,MAAA,OAAA,IAAWC,yCAAmB,CAAA,QAAQ,CAAG,EAAA;AACnD,IAAM,MAAA,UAAA,CAAW,SAAS,KAAO,EAAA,CAAA;AAAA;AAEnC;AAViB,MAAA,CAAA,GAAA,EAAA,KAAA,CAAA","file":"map.cjs","sourcesContent":["import type { IterableResolvable } from './from';\nimport { assertFunction } from './shared/_assertFunction';\nimport { toIterableIterator } from './toIterableIterator';\n\n/**\n * Creates an iterable with the results of calling a provided function on each element.\n *\n * @param iterable An iterator to map over.\n * @param callbackFn A function to execute for each element produced by the iterator. Its return value is yielded by the iterator helper.\n *\n * @example\n * ```typescript\n * import { map } from '@sapphire/iterator-utilities';\n *\n * const iterable = [1, 2, 3, 4, 5];\n * console.log([...map(iterable, (value) => value * 2)]);\n * // Output: [2, 4, 6, 8, 10]\n * ```\n */\nexport function* map<const ElementType, const MappedType>(\n\titerable: IterableResolvable<ElementType>,\n\tcallbackFn: (element: ElementType, index: number) => MappedType\n): IterableIterator<MappedType> {\n\tcallbackFn = assertFunction(callbackFn);\n\n\tlet index = 0;\n\tfor (const element of toIterableIterator(iterable)) {\n\t\tyield callbackFn(element, index++);\n\t}\n}\n"]}