@monstermann/set 0.0.0

package/dist/Set/hasAll.js

@@ -0,0 +1,29 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Set/hasAll.ts
+/**
+* ```ts
+* function Set.hasAll(target, values)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.hasAll(Set.create([1, 2, 3]), [1, 2]); // true
+* Set.hasAll(Set.create([1, 2, 3]), [1, 4]); // false
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2, 3]), Set.hasAll([1, 2])); // true
+* pipe(Set.create([1, 2, 3]), Set.hasAll([1, 4])); // false
+* ```
+*/
+const hasAll = dfdlT((target, values) => {
+	for (const value of values) if (!target.has(value)) return false;
+	return true;
+}, 2);
+
+//#endregion
+export { hasAll };

package/dist/Set/hasAny.d.ts

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

package/dist/Set/hasAny.js

@@ -0,0 +1,29 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Set/hasAny.ts
+/**
+* ```ts
+* function Set.hasAny(target, values)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.hasAny(Set.create([1, 2, 3]), [3, 4]); // true
+* Set.hasAny(Set.create([1, 2, 3]), [4, 5]); // false
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2, 3]), Set.hasAny([3, 4])); // true
+* pipe(Set.create([1, 2, 3]), Set.hasAny([4, 5])); // false
+* ```
+*/
+const hasAny = dfdlT((target, values) => {
+	for (const value of values) if (target.has(value)) return true;
+	return false;
+}, 2);
+
+//#endregion
+export { hasAny };

package/dist/Set/hasNone.d.ts

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

package/dist/Set/hasNone.js

@@ -0,0 +1,29 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Set/hasNone.ts
+/**
+* ```ts
+* function Set.hasNone(target, values)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.hasNone(Set.create([1, 2, 3]), [4, 5]); // true
+* Set.hasNone(Set.create([1, 2, 3]), [3, 4]); // false
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2, 3]), Set.hasNone([4, 5])); // true
+* pipe(Set.create([1, 2, 3]), Set.hasNone([3, 4])); // false
+* ```
+*/
+const hasNone = dfdlT((target, values) => {
+	for (const value of values) if (target.has(value)) return false;
+	return true;
+}, 2);
+
+//#endregion
+export { hasNone };

package/dist/Set/index.d.ts

@@ -0,0 +1,38 @@
+import { add } from "./add.js";
+import { addAll } from "./addAll.js";
+import { addOr } from "./addOr.js";
+import { addOrElse } from "./addOrElse.js";
+import { addOrThrow } from "./addOrThrow.js";
+import { clone } from "./clone.js";
+import { compact } from "./compact.js";
+import { difference } from "./difference.js";
+import { forEach } from "./forEach.js";
+import { has } from "./has.js";
+import { hasAll } from "./hasAll.js";
+import { hasAny } from "./hasAny.js";
+import { hasNone } from "./hasNone.js";
+import { intersection } from "./intersection.js";
+import { isDisjointFrom } from "./isDisjointFrom.js";
+import { isEmpty } from "./isEmpty.js";
+import { isSet } from "./isSet.js";
+import { isShallowEqual } from "./isShallowEqual.js";
+import { isSubsetOf } from "./isSubsetOf.js";
+import { isSupersetOf } from "./isSupersetOf.js";
+import { mapEach } from "./mapEach.js";
+import { remove } from "./remove.js";
+import { removeAll } from "./removeAll.js";
+import { removeOr } from "./removeOr.js";
+import { removeOrElse } from "./removeOrElse.js";
+import { removeOrThrow } from "./removeOrThrow.js";
+import { size } from "./size.js";
+import { symmetricDifference } from "./symmetricDifference.js";
+import { toArray } from "./toArray.js";
+import { union } from "./union.js";
+
+//#region src/Set/index.d.ts
+
+declare namespace Set {
+  export { add, addAll, addOr, addOrElse, addOrThrow, clone, compact, difference, forEach, has, hasAll, hasAny, hasNone, intersection, isDisjointFrom, isEmpty, isSet, isShallowEqual, isSubsetOf, isSupersetOf, mapEach, remove, removeAll, removeOr, removeOrElse, removeOrThrow, size, symmetricDifference, toArray, union };
+}
+//#endregion
+export { Set };

package/dist/Set/index.js

@@ -0,0 +1,67 @@
+import { add } from "./add.js";
+import { addAll } from "./addAll.js";
+import { addOr } from "./addOr.js";
+import { addOrElse } from "./addOrElse.js";
+import { addOrThrow } from "./addOrThrow.js";
+import { clone } from "./clone.js";
+import { compact } from "./compact.js";
+import { difference } from "./difference.js";
+import { forEach } from "./forEach.js";
+import { has } from "./has.js";
+import { hasAll } from "./hasAll.js";
+import { hasAny } from "./hasAny.js";
+import { hasNone } from "./hasNone.js";
+import { intersection } from "./intersection.js";
+import { isDisjointFrom } from "./isDisjointFrom.js";
+import { isEmpty } from "./isEmpty.js";
+import { isSet } from "./isSet.js";
+import { isShallowEqual } from "./isShallowEqual.js";
+import { isSubsetOf } from "./isSubsetOf.js";
+import { isSupersetOf } from "./isSupersetOf.js";
+import { mapEach } from "./mapEach.js";
+import { remove } from "./remove.js";
+import { removeAll } from "./removeAll.js";
+import { removeOr } from "./removeOr.js";
+import { removeOrElse } from "./removeOrElse.js";
+import { removeOrThrow } from "./removeOrThrow.js";
+import { size } from "./size.js";
+import { symmetricDifference } from "./symmetricDifference.js";
+import { toArray } from "./toArray.js";
+import { union } from "./union.js";
+
+//#region src/Set/index.js
+const Set = {
+	add,
+	addAll,
+	addOr,
+	addOrElse,
+	addOrThrow,
+	clone,
+	compact,
+	difference,
+	forEach,
+	has,
+	hasAll,
+	hasAny,
+	hasNone,
+	intersection,
+	isDisjointFrom,
+	isEmpty,
+	isSet,
+	isShallowEqual,
+	isSubsetOf,
+	isSupersetOf,
+	mapEach,
+	remove,
+	removeAll,
+	removeOr,
+	removeOrElse,
+	removeOrThrow,
+	size,
+	symmetricDifference,
+	toArray,
+	union
+};
+
+//#endregion
+export { Set };

package/dist/Set/internals/types.d.ts

@@ -0,0 +1,4 @@
+//#region src/Set/internals/types.d.ts
+type NonNil<T> = Exclude<T, null | undefined>;
+//#endregion
+export { NonNil };

package/dist/Set/intersection.d.ts

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

package/dist/Set/intersection.js

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

package/dist/Set/isDisjointFrom.d.ts

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

package/dist/Set/isDisjointFrom.js

@@ -0,0 +1,29 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Set/isDisjointFrom.ts
+/**
+* ```ts
+* function Set.isDisjointFrom(target, source)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.isDisjointFrom(Set.create([1, 2]), Set.create([3, 4])); // true
+* Set.isDisjointFrom(Set.create([1, 2]), Set.create([2, 3])); // false
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2]), Set.isDisjointFrom(Set.create([3, 4]))); // true
+* pipe(Set.create([1, 2]), Set.isDisjointFrom(Set.create([2, 3]))); // false
+* ```
+*/
+const isDisjointFrom = dfdlT((target, source) => {
+	for (const value of target) if (source.has(value)) return false;
+	return true;
+}, 2);
+
+//#endregion
+export { isDisjointFrom };

package/dist/Set/isEmpty.d.ts

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

package/dist/Set/isEmpty.js

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

package/dist/Set/isSet.d.ts

@@ -0,0 +1,28 @@
+//#region src/Set/isSet.d.ts
+/**
+ * ```ts
+ * function Set.isSet(target)
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * Set.isSet(Set.create([1, 2, 3])); // true
+ * Set.isSet([1, 2, 3]); // false
+ * Set.isSet({}); // false
+ * ```
+ *
+ * ```ts
+ * import { Set } from "@monstermann/set";
+ *
+ * pipe(Set.create([1, 2, 3]), Set.isSet()); // true
+ * pipe([1, 2, 3], Set.isSet()); // false
+ * pipe({}, Set.isSet()); // false
+ * ```
+ */
+declare const isSet: {
+  (): (target: unknown) => target is Set<unknown>;
+  (target: unknown): target is Set<unknown>;
+};
+//#endregion
+export { isSet };

package/dist/Set/isSet.js

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

package/dist/Set/isShallowEqual.d.ts

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

package/dist/Set/isShallowEqual.js

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

package/dist/Set/isSubsetOf.d.ts

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

package/dist/Set/isSubsetOf.js

@@ -0,0 +1,30 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Set/isSubsetOf.ts
+/**
+* ```ts
+* function Set.isSubsetOf(target, source)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.isSubsetOf(Set.create([1, 2]), Set.create([1, 2, 3])); // true
+* Set.isSubsetOf(Set.create([1, 4]), Set.create([1, 2, 3])); // false
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2]), Set.isSubsetOf(Set.create([1, 2, 3]))); // true
+* pipe(Set.create([1, 4]), Set.isSubsetOf(Set.create([1, 2, 3]))); // false
+* ```
+*/
+const isSubsetOf = dfdlT((target, source) => {
+	if (target.size > source.size) return false;
+	for (const value of target) if (!source.has(value)) return false;
+	return true;
+}, 2);
+
+//#endregion
+export { isSubsetOf };

package/dist/Set/isSupersetOf.d.ts

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

package/dist/Set/isSupersetOf.js

@@ -0,0 +1,30 @@
+import { dfdlT } from "@monstermann/dfdl";
+
+//#region src/Set/isSupersetOf.ts
+/**
+* ```ts
+* function Set.isSupersetOf(target, source)
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* Set.isSupersetOf(Set.create([1, 2, 3]), Set.create([1, 2])); // true
+* Set.isSupersetOf(Set.create([1, 2, 3]), Set.create([1, 4])); // false
+* ```
+*
+* ```ts
+* import { Set } from "@monstermann/set";
+*
+* pipe(Set.create([1, 2, 3]), Set.isSupersetOf(Set.create([1, 2]))); // true
+* pipe(Set.create([1, 2, 3]), Set.isSupersetOf(Set.create([1, 4]))); // false
+* ```
+*/
+const isSupersetOf = dfdlT((target, source) => {
+	if (target.size < source.size) return false;
+	for (const value of source) if (!target.has(value)) return false;
+	return true;
+}, 2);
+
+//#endregion
+export { isSupersetOf };