@monstermann/set 0.0.0

package/dist/Set/mapEach.d.ts

@@ -0,0 +1,35 @@
+//#region src/Set/mapEach.d.ts
+/**
+ * ```ts
+ * function Set.mapEach(target, fn)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.mapEach(Set.create([1, 2, 3]), (x) => x * 2); // Set([2, 4, 6])
+ * Set.mapEach(Set.create(["a", "b"]), (x) => x.toUpperCase()); // Set(['A', 'B'])
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(
+ *     Set.create([1, 2, 3]),
+ *     Set.mapEach((x) => x * 2),
+ * ); // Set([2, 4, 6])
+ *
+ * pipe(
+ *     Set.create(["a", "b"]),
+ *     Set.mapEach((x) => x.toUpperCase()),
+ * ); // Set(['A', 'B'])
+ * ```
+ */
+declare const mapEach: {
+  <T, U>(fn: (value: NoInfer<T>, target: ReadonlySet<NoInfer<T>>) => U): (target: Set<T>) => Set<U>;
+  <T, U>(fn: (value: NoInfer<T>, target: ReadonlySet<NoInfer<T>>) => U): (target: ReadonlySet<T>) => ReadonlySet<U>;
+  <T, U>(target: Set<T>, fn: (value: NoInfer<T>, target: ReadonlySet<NoInfer<T>>) => U): Set<U>;
+  <T, U>(target: ReadonlySet<T>, fn: (value: NoInfer<T>, target: ReadonlySet<NoInfer<T>>) => U): ReadonlySet<U>;
+};
+//#endregion
+export { mapEach };

package/dist/Set/mapEach.js

@@ -0,0 +1,42 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Set/mapEach.ts
+/**
+* ```ts
+* function Set.mapEach(target, fn)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.mapEach(Set.create([1, 2, 3]), (x) => x * 2); // Set([2, 4, 6])
+* Set.mapEach(Set.create(["a", "b"]), (x) => x.toUpperCase()); // Set(['A', 'B'])
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(
+*     Set.create([1, 2, 3]),
+*     Set.mapEach((x) => x * 2),
+* ); // Set([2, 4, 6])
+*
+* pipe(
+*     Set.create(["a", "b"]),
+*     Set.mapEach((x) => x.toUpperCase()),
+* ); // Set(['A', 'B'])
+* ```
+*/
+const mapEach = dfdlT((target, fn) => {
+	let hasChanges = false;
+	const result = /* @__PURE__ */ new Set();
+	for (const prev of target) {
+		const next = fn(prev, target);
+		hasChanges ||= prev !== next;
+		result.add(next);
+	}
+	return hasChanges ? result : target;
+}, 2);
+
+//#endregion
+export { mapEach };

package/dist/Set/remove.d.ts

@@ -0,0 +1,28 @@
+//#region src/Set/remove.d.ts
+/**
+ * ```ts
+ * function Set.remove(target, value)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.remove(Set.create([1, 2, 3]), 2); // Set([1, 3])
+ * Set.remove(Set.create([1, 2, 3]), 4); // Set([1, 2, 3])
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(Set.create([1, 2, 3]), Set.remove(2)); // Set([1, 3])
+ * pipe(Set.create([1, 2, 3]), Set.remove(4)); // Set([1, 2, 3])
+ * ```
+ */
+declare const remove: {
+  <T>(value: NoInfer<T>): (target: Set<T>) => Set<T>;
+  <T>(value: NoInfer<T>): (target: ReadonlySet<T>) => ReadonlySet<T>;
+  <T>(target: Set<T>, value: NoInfer<T>): Set<T>;
+  <T>(target: ReadonlySet<T>, value: NoInfer<T>): ReadonlySet<T>;
+};
+//#endregion
+export { remove };

package/dist/Set/remove.js

@@ -0,0 +1,32 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneSet } from "@monstermann/remmi";
+
+//#region src/Set/remove.ts
+/**
+* ```ts
+* function Set.remove(target, value)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.remove(Set.create([1, 2, 3]), 2); // Set([1, 3])
+* Set.remove(Set.create([1, 2, 3]), 4); // Set([1, 2, 3])
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2, 3]), Set.remove(2)); // Set([1, 3])
+* pipe(Set.create([1, 2, 3]), Set.remove(4)); // Set([1, 2, 3])
+* ```
+*/
+const remove = dfdlT((target, value) => {
+	if (!target.has(value)) return target;
+	target = cloneSet(target);
+	target.delete(value);
+	return target;
+}, 2);
+
+//#endregion
+export { remove };

package/dist/Set/removeAll.d.ts

@@ -0,0 +1,28 @@
+//#region src/Set/removeAll.d.ts
+/**
+ * ```ts
+ * function Set.removeAll(target, values)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.removeAll(Set.create([1, 2, 3, 4]), [2, 3]); // Set([1, 4])
+ * Set.removeAll(Set.create([1, 2, 3]), [4, 5]); // Set([1, 2, 3])
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(Set.create([1, 2, 3, 4]), Set.removeAll([2, 3])); // Set([1, 4])
+ * pipe(Set.create([1, 2, 3]), Set.removeAll([4, 5])); // Set([1, 2, 3])
+ * ```
+ */
+declare const removeAll: {
+  <T>(values: Iterable<NoInfer<T>>): (target: Set<T>) => Set<T>;
+  <T>(values: Iterable<NoInfer<T>>): (target: ReadonlySet<T>) => ReadonlySet<T>;
+  <T>(target: Set<T>, values: Iterable<NoInfer<T>>): Set<T>;
+  <T>(target: ReadonlySet<T>, values: Iterable<NoInfer<T>>): ReadonlySet<T>;
+};
+//#endregion
+export { removeAll };

package/dist/Set/removeAll.js

@@ -0,0 +1,35 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneSet } from "@monstermann/remmi";
+
+//#region src/Set/removeAll.ts
+/**
+* ```ts
+* function Set.removeAll(target, values)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.removeAll(Set.create([1, 2, 3, 4]), [2, 3]); // Set([1, 4])
+* Set.removeAll(Set.create([1, 2, 3]), [4, 5]); // Set([1, 2, 3])
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2, 3, 4]), Set.removeAll([2, 3])); // Set([1, 4])
+* pipe(Set.create([1, 2, 3]), Set.removeAll([4, 5])); // Set([1, 2, 3])
+* ```
+*/
+const removeAll = dfdlT((target, values) => {
+	let result;
+	for (const value of values) {
+		if (!target.has(value)) continue;
+		result ??= cloneSet(target);
+		result.delete(value);
+	}
+	return result ?? target;
+}, 2);
+
+//#endregion
+export { removeAll };

package/dist/Set/removeOr.d.ts

@@ -0,0 +1,26 @@
+//#region src/Set/removeOr.d.ts
+/**
+ * ```ts
+ * function Set.removeOr(target, value, or)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.removeOr(Set.create([1, 2, 3]), 2, null); // Set([1, 3])
+ * Set.removeOr(Set.create([1, 2, 3]), 4, null); // null
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(Set.create([1, 2, 3]), Set.removeOr(2, null)); // Set([1, 3])
+ * pipe(Set.create([1, 2, 3]), Set.removeOr(4, null)); // null
+ * ```
+ */
+declare const removeOr: {
+  <T, U>(value: NoInfer<T>, or: U): (target: ReadonlySet<T>) => Set<T> | U;
+  <T, U>(target: ReadonlySet<T>, value: NoInfer<T>, or: U): Set<T> | U;
+};
+//#endregion
+export { removeOr };

package/dist/Set/removeOr.js

@@ -0,0 +1,32 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneSet } from "@monstermann/remmi";
+
+//#region src/Set/removeOr.ts
+/**
+* ```ts
+* function Set.removeOr(target, value, or)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.removeOr(Set.create([1, 2, 3]), 2, null); // Set([1, 3])
+* Set.removeOr(Set.create([1, 2, 3]), 4, null); // null
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2, 3]), Set.removeOr(2, null)); // Set([1, 3])
+* pipe(Set.create([1, 2, 3]), Set.removeOr(4, null)); // null
+* ```
+*/
+const removeOr = dfdlT((target, value, or) => {
+	if (!target.has(value)) return or;
+	const result = cloneSet(target);
+	result.delete(value);
+	return result;
+}, 3);
+
+//#endregion
+export { removeOr };

package/dist/Set/removeOrElse.d.ts

@@ -0,0 +1,33 @@
+//#region src/Set/removeOrElse.d.ts
+/**
+ * ```ts
+ * function Set.removeOrElse(target, value, orElse)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.removeOrElse(Set.create([1, 2, 3]), 2, (set) => set.size); // Set([1, 3])
+ * Set.removeOrElse(Set.create([1, 2, 3]), 4, (set) => set.size); // 3
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(
+ *     Set.create([1, 2, 3]),
+ *     Set.removeOrElse(2, (set) => set.size),
+ * ); // Set([1, 3])
+ *
+ * pipe(
+ *     Set.create([1, 2, 3]),
+ *     Set.removeOrElse(4, (set) => set.size),
+ * ); // 3
+ * ```
+ */
+declare const removeOrElse: {
+  <T, U>(value: NoInfer<T>, orElse: (target: ReadonlySet<NoInfer<T>>) => U): (target: ReadonlySet<T>) => Set<T> | U;
+  <T, U>(target: ReadonlySet<T>, value: NoInfer<T>, orElse: (target: ReadonlySet<NoInfer<T>>) => U): Set<T> | U;
+};
+//#endregion
+export { removeOrElse };

package/dist/Set/removeOrElse.js

@@ -0,0 +1,39 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneSet } from "@monstermann/remmi";
+
+//#region src/Set/removeOrElse.ts
+/**
+* ```ts
+* function Set.removeOrElse(target, value, orElse)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.removeOrElse(Set.create([1, 2, 3]), 2, (set) => set.size); // Set([1, 3])
+* Set.removeOrElse(Set.create([1, 2, 3]), 4, (set) => set.size); // 3
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(
+*     Set.create([1, 2, 3]),
+*     Set.removeOrElse(2, (set) => set.size),
+* ); // Set([1, 3])
+*
+* pipe(
+*     Set.create([1, 2, 3]),
+*     Set.removeOrElse(4, (set) => set.size),
+* ); // 3
+* ```
+*/
+const removeOrElse = dfdlT((target, value, orElse) => {
+	if (!target.has(value)) return orElse(target);
+	const result = cloneSet(target);
+	result.delete(value);
+	return result;
+}, 3);
+
+//#endregion
+export { removeOrElse };

package/dist/Set/removeOrThrow.d.ts

@@ -0,0 +1,26 @@
+//#region src/Set/removeOrThrow.d.ts
+/**
+ * ```ts
+ * function Set.removeOrThrow(target, value)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.removeOrThrow(Set.create([1, 2, 3]), 2); // Set([1, 3])
+ * Set.removeOrThrow(Set.create([1, 2, 3]), 4); // throws FnError
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(Set.create([1, 2, 3]), Set.removeOrThrow(2)); // Set([1, 3])
+ * pipe(Set.create([1, 2, 3]), Set.removeOrThrow(4)); // throws FnError
+ * ```
+ */
+declare const removeOrThrow: {
+  <T>(value: NoInfer<T>): (target: ReadonlySet<T>) => Set<T>;
+  <T>(target: ReadonlySet<T>, value: NoInfer<T>): Set<T>;
+};
+//#endregion
+export { removeOrThrow };

package/dist/Set/removeOrThrow.js

@@ -0,0 +1,32 @@
+import { dfdlT } from "@monstermann/dfdl";
+import { cloneSet } from "@monstermann/remmi";
+
+//#region src/Set/removeOrThrow.ts
+/**
+* ```ts
+* function Set.removeOrThrow(target, value)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.removeOrThrow(Set.create([1, 2, 3]), 2); // Set([1, 3])
+* Set.removeOrThrow(Set.create([1, 2, 3]), 4); // throws FnError
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2, 3]), Set.removeOrThrow(2)); // Set([1, 3])
+* pipe(Set.create([1, 2, 3]), Set.removeOrThrow(4)); // throws FnError
+* ```
+*/
+const removeOrThrow = dfdlT((target, value) => {
+	if (!target.has(value)) throw new Error("Set.removeOrThrow: Value does not exist.");
+	const result = cloneSet(target);
+	result.delete(value);
+	return result;
+}, 2);
+
+//#endregion
+export { removeOrThrow };

package/dist/Set/size.d.ts

@@ -0,0 +1,26 @@
+//#region src/Set/size.d.ts
+/**
+ * ```ts
+ * function Set.size(target)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.size(Set.create([1, 2, 3])); // 3
+ * Set.size(Set.create()); // 0
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(Set.create([1, 2, 3]), Set.size()); // 3
+ * pipe(Set.create(), Set.size()); // 0
+ * ```
+ */
+declare const size: {
+  (): <T extends ReadonlySet<unknown>>(target: T) => number;
+  <T extends ReadonlySet<unknown>>(target: T): number;
+};
+//#endregion
+export { size };

package/dist/Set/size.js

@@ -0,0 +1,28 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Set/size.ts
+/**
+* ```ts
+* function Set.size(target)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.size(Set.create([1, 2, 3])); // 3
+* Set.size(Set.create()); // 0
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2, 3]), Set.size()); // 3
+* pipe(Set.create(), Set.size()); // 0
+* ```
+*/
+const size = dfdlT((target) => {
+	return target.size;
+}, 1);
+
+//#endregion
+export { size };

package/dist/Set/symmetricDifference.d.ts

@@ -0,0 +1,26 @@
+//#region src/Set/symmetricDifference.d.ts
+/**
+ * ```ts
+ * function Set.symmetricDifference(target, source)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.symmetricDifference(Set.create([1, 2, 3]), Set.create([3, 4, 5])); // Set([1, 2, 4, 5])
+ * Set.symmetricDifference(Set.create([1, 2]), Set.create([3, 4])); // Set([1, 2, 3, 4])
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(Set.create([1, 2, 3]), Set.symmetricDifference(Set.create([3, 4, 5]))); // Set([1, 2, 4, 5])
+ * pipe(Set.create([1, 2]), Set.symmetricDifference(Set.create([3, 4]))); // Set([1, 2, 3, 4])
+ * ```
+ */
+declare const symmetricDifference: {
+  <T, U>(source: Set<U>): (target: Set<T>) => Set<T | U>;
+  <T, U>(target: Set<T>, source: Set<U>): Set<T | U>;
+};
+//#endregion
+export { symmetricDifference };

package/dist/Set/symmetricDifference.js

@@ -0,0 +1,45 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Set/symmetricDifference.ts
+/**
+* ```ts
+* function Set.symmetricDifference(target, source)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.symmetricDifference(Set.create([1, 2, 3]), Set.create([3, 4, 5])); // Set([1, 2, 4, 5])
+* Set.symmetricDifference(Set.create([1, 2]), Set.create([3, 4])); // Set([1, 2, 3, 4])
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2, 3]), Set.symmetricDifference(Set.create([3, 4, 5]))); // Set([1, 2, 4, 5])
+* pipe(Set.create([1, 2]), Set.symmetricDifference(Set.create([3, 4]))); // Set([1, 2, 3, 4])
+* ```
+*/
+const symmetricDifference = dfdlT((target, source) => {
+	if (source.size === 0) return target;
+	if (target.size === 0) return source;
+	let hasChanges = false;
+	for (const a of target) if (!source.has(a)) {
+		hasChanges = true;
+		break;
+	}
+	if (!hasChanges) {
+		for (const b of source) if (!target.has(b)) {
+			hasChanges = true;
+			break;
+		}
+	}
+	if (!hasChanges) return /* @__PURE__ */ new Set();
+	const result = /* @__PURE__ */ new Set();
+	for (const a of target) if (!source.has(a)) result.add(a);
+	for (const b of source) if (!target.has(b)) result.add(b);
+	return result;
+}, 2);
+
+//#endregion
+export { symmetricDifference };

package/dist/Set/toArray.d.ts

@@ -0,0 +1,26 @@
+//#region src/Set/toArray.d.ts
+/**
+ * ```ts
+ * function Set.toArray(target)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.toArray(Set.create([1, 2, 3])); // [1, 2, 3]
+ * Set.toArray(Set.create(["a", "b"])); // ['a', 'b']
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(Set.create([1, 2, 3]), Set.toArray()); // [1, 2, 3]
+ * pipe(Set.create(["a", "b"]), Set.toArray()); // ['a', 'b']
+ * ```
+ */
+declare const toArray: {
+  (): <T>(target: ReadonlySet<T>) => T[];
+  <T>(target: ReadonlySet<T>): T[];
+};
+//#endregion
+export { toArray };

package/dist/Set/toArray.js

@@ -0,0 +1,28 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Set/toArray.ts
+/**
+* ```ts
+* function Set.toArray(target)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.toArray(Set.create([1, 2, 3])); // [1, 2, 3]
+* Set.toArray(Set.create(["a", "b"])); // ['a', 'b']
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2, 3]), Set.toArray()); // [1, 2, 3]
+* pipe(Set.create(["a", "b"]), Set.toArray()); // ['a', 'b']
+* ```
+*/
+const toArray = dfdlT((target) => {
+	return Array.from(target);
+}, 1);
+
+//#endregion
+export { toArray };

package/dist/Set/union.d.ts

@@ -0,0 +1,26 @@
+//#region src/Set/union.d.ts
+/**
+ * ```ts
+ * function Set.union(target, source)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.union(Set.create([1, 2]), Set.create([2, 3, 4])); // Set([1, 2, 3, 4])
+ * Set.union(Set.create([1, 2]), Set.create([3, 4])); // Set([1, 2, 3, 4])
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(Set.create([1, 2]), Set.union(Set.create([2, 3, 4]))); // Set([1, 2, 3, 4])
+ * pipe(Set.create([1, 2]), Set.union(Set.create([3, 4]))); // Set([1, 2, 3, 4])
+ * ```
+ */
+declare const union: {
+  <T, U>(source: Set<U>): (target: Set<T>) => Set<T | U>;
+  <T, U>(target: Set<T>, source: Set<U>): Set<T | U>;
+};
+//#endregion
+export { union };

package/dist/Set/union.js

@@ -0,0 +1,36 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Set/union.ts
+/**
+* ```ts
+* function Set.union(target, source)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.union(Set.create([1, 2]), Set.create([2, 3, 4])); // Set([1, 2, 3, 4])
+* Set.union(Set.create([1, 2]), Set.create([3, 4])); // Set([1, 2, 3, 4])
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2]), Set.union(Set.create([2, 3, 4]))); // Set([1, 2, 3, 4])
+* pipe(Set.create([1, 2]), Set.union(Set.create([3, 4]))); // Set([1, 2, 3, 4])
+* ```
+*/
+const union = dfdlT((target, source) => {
+	if (source.size === 0) return target;
+	if (target.size === 0) return source;
+	for (const element of source) if (!target.has(element)) {
+		const result = /* @__PURE__ */ new Set();
+		for (const a of target) result.add(a);
+		for (const b of source) result.add(b);
+		return result;
+	}
+	return target;
+}, 2);
+
+//#endregion
+export { union };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { Set } from "./Set/index.js";
+export { Set };

package/dist/index.js

@@ -0,0 +1,3 @@
+import { Set } from "./Set/index.js";
+
+export { Set };