venerate 0.0.3 → 0.0.5

package/LICENSE

@@ -0,0 +1,5 @@
+Mozilla Public License Version 2.0
+
+This Source Code Form is subject to the terms of the Mozilla Public
+License, v. 2.0. If a copy of the MPL was not distributed with this
+file, You can obtain one at https://mozilla.org/MPL/2.0/.

package/README.md

@@ -1,14 +1,30 @@
 # venerate
 
 <a aria-label="NPM version" href="https://www.npmjs.com/package/venerate">
-  <img alt="NPM Version" src="https://img.shields.io/npm/v/treetrunks?style=for-the-badge">
+	<img
+		alt="NPM Version"
+		src="https://img.shields.io/npm/v/treetrunks?style=for-the-badge"
+	>
 </a>
 <a aria-label="Dependencies 0" href="https://www.npmjs.com/package/treetrunks">
-  <img alt="Dependencies 0" src="https://img.shields.io/badge/dependencies-0-0?style=for-the-badge">
-</a>
-<a href="https://bundlephobia.com/result?p=venerate">
-  <img alt="Bundlephobia" src="https://img.shields.io/bundlephobia/minzip/venerate?style=for-the-badge">
+	<img
+		alt="Dependencies 0"
+		src="https://img.shields.io/badge/dependencies-0-0?style=for-the-badge"
+	>
 </a>
+<!-- tonnage:default:start -->
+
+## Bundle size
+
+Public-module rows retain complete runtime export surfaces. Recipe rows bundle their reviewable entry files and tree-shake unused exports. Both report exact minified and level-9 gzip JavaScript byte counts; declarations, source maps, CSS, and other assets are excluded. Peer dependencies stay external, and shared modules are counted once per bundle.
+
+### Public modules (whole export surface)
+
+| Import                | Minified JS | Gzip JS |
+| --------------------- | ----------: | ------: |
+| <code>venerate</code> |     1,318 B |   572 B |
+
+<!-- tonnage:default:end -->
 
 ```sh
 npm i venerate
@@ -19,15 +35,15 @@ venerate is a small, pure library implementing venn diagram logic for iterables.
 ## usage
 
 ```ts
-import * as V from "venerate";
+import * as V from "venerate"
 
-const a = [1, 2, 3];
-const b = new Set([2, 3, 4]);
+const a = [1, 2, 3]
+const b = new Set([2, 3, 4])
 const c = (function* () {
-  yield 3;
-  yield 4;
-  yield 5;
-})();
+	yield 3
+	yield 4
+	yield 5
+})()
 
-const union = [...V.union(a, b, c)]; // [1, 2, 3, 4, 5]
+const union = [...V.union(a, b, c)] // [1, 2, 3, 4, 5]
 ```

package/dist/venerate.d.ts

@@ -1,48 +1,47 @@
 //#region src/venerate.d.ts
 /**
-* Cross-realm-safe check for anything that extends Set.
-*/
-declare function isSet(value: unknown): value is Set<any>;
-/**
-* Materializes an unknown iterable as a Set, without providing for mutation.
-* Does not copy the input if it is already a Set.
-*/
-declare const toSet: <T>(it: Iterable<T>) => ReadonlySet<T>;
-/**
-* Lazily yield the union of A, B, C, ... preserving first-seen order.
-* Only a small "seen" Set is maintained; inputs are streamed.
-*/
-declare function union<T>(...iterables: Iterable<T>[]): Iterable<T>;
-/**
-* Lazily yield A \ (B ∪ C ∪ ...), streaming A and pre-materializing removals.
-*/
-declare function difference<T>(base: Iterable<T>, ...rest: Iterable<T>[]): Iterable<T>;
-/**
-* Lazily yield A ∩ B ∩ C ∩ ...
-* Streams only the FIRST iterable; others are materialized as Sets for O(1) lookups.
-* If no others are provided, yields a shallow copy of A.
-*/
-declare function intersection<T>(base: Iterable<T>, ...rest: Iterable<T>[]): Iterable<T>;
-/**
-* Lazily yield A △ B (pairwise symmetric difference).
-* Streams A and B once; materializes the opposite side for membership checks.
-* - First yields items unique to A (preserving A's order)
-* - Then yields items unique to B (preserving B's order)
-*/
-declare function symmetricDifference<T>(a: Iterable<T>, b: Iterable<T>): Iterable<T>;
-/**
-* Variadic symmetric difference via left fold of the pairwise version.
-* Still lazy in the sense that we only materialize small per-step Sets;
-* each fold pass consumes its input generator.
-*/
-declare function symmetricDifferenceVariadic<T>(acc: Iterable<T>, ...rest: Iterable<T>[]): Iterable<T>;
-/**
-* Predicates (not lazy outputs, but efficient w/ early exits)
-*/
-declare function isSubset<T>(a: Iterable<T>, b: Iterable<T>): boolean;
-declare function isSuperset<T>(a: Iterable<T>, b: Iterable<T>): boolean;
-declare function isDisjoint<T>(a: Iterable<T>, b: Iterable<T>): boolean;
-declare function equals<T>(a: Iterable<T>, b: Iterable<T>): boolean;
+ * Cross-realm-safe check for anything that extends Set.
+ */
+export declare function isSet(value: unknown): value is Set<any>;
+/**
+ * Materializes an unknown iterable as a Set, without providing for mutation.
+ * Does not copy the input if it is already a Set.
+ */
+export declare const toSet: <T>(it: Iterable<T>) => ReadonlySet<T>;
+/**
+ * Lazily yield the union of A, B, C, ... preserving first-seen order.
+ * Only a small "seen" Set is maintained; inputs are streamed.
+ */
+export declare function union<T>(...iterables: Iterable<T>[]): Iterable<T>;
+/**
+ * Lazily yield A \ (B ∪ C ∪ ...), streaming A and pre-materializing removals.
+ */
+export declare function difference<T>(base: Iterable<T>, ...rest: Iterable<T>[]): Iterable<T>;
+/**
+ * Lazily yield A ∩ B ∩ C ∩ ...
+ * Streams only the FIRST iterable; others are materialized as Sets for O(1) lookups.
+ * If no others are provided, yields a shallow copy of A.
+ */
+export declare function intersection<T>(base: Iterable<T>, ...rest: Iterable<T>[]): Iterable<T>;
+/**
+ * Lazily yield A △ B (pairwise symmetric difference).
+ * Streams A and B once; materializes the opposite side for membership checks.
+ * - First yields items unique to A (preserving A's order)
+ * - Then yields items unique to B (preserving B's order)
+ */
+export declare function symmetricDifference<T>(a: Iterable<T>, b: Iterable<T>): Iterable<T>;
+/**
+ * Variadic symmetric difference via left fold of the pairwise version.
+ * Still lazy in the sense that we only materialize small per-step Sets;
+ * each fold pass consumes its input generator.
+ */
+export declare function symmetricDifferenceVariadic<T>(acc: Iterable<T>, ...rest: Iterable<T>[]): Iterable<T>;
+/**
+ * Predicates (not lazy outputs, but efficient w/ early exits)
+ */
+export declare function isSubset<T>(a: Iterable<T>, b: Iterable<T>): boolean;
+export declare function isSuperset<T>(a: Iterable<T>, b: Iterable<T>): boolean;
+export declare function isDisjoint<T>(a: Iterable<T>, b: Iterable<T>): boolean;
+export declare function equals<T>(a: Iterable<T>, b: Iterable<T>): boolean;
 //#endregion
-export { difference, equals, intersection, isDisjoint, isSet, isSubset, isSuperset, symmetricDifference, symmetricDifferenceVariadic, toSet, union };
 //# sourceMappingURL=venerate.d.ts.map

package/dist/venerate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"venerate.d.ts","names":[],"sources":["../src/venerate.ts"],"sourcesContent":[],"mappings":";;AAGA;AAeA;AAAuD,iBAfvC,KAAA,CAeuC,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,IAfP,GAeO,CAAA,GAAA,CAAA;;;;;AAAZ,cAA9B,KAA8B,EAAA,CAAA,CAAA,CAAA,CAAA,EAAA,EAAd,QAAc,CAAL,CAAK,CAAA,EAAA,GAAA,WAAA,CAAY,CAAZ,CAAA;AAO3C;;;;AAAiE,iBAAhD,KAAgD,CAAA,CAAA,CAAA,CAAA,GAAA,SAAA,EAAzB,QAAyB,CAAhB,CAAgB,CAAA,EAAA,CAAA,EAAT,QAAS,CAAA,CAAA,CAAA;;;AAejE;AAAiB,iBAAA,UAAA,CAAA,CAAA,CAAA,CAAA,IAAA,EACV,QADU,CACD,CADC,CAAA,EAAA,GAAA,IAAA,EAEP,QAFO,CAEE,CAFF,CAAA,EAAA,CAAA,EAGd,QAHc,CAGL,CAHK,CAAA;;;;;;AAGd,iBAec,YAfd,CAAA,CAAA,CAAA,CAAA,IAAA,EAgBI,QAhBJ,CAgBa,CAhBb,CAAA,EAAA,GAAA,IAAA,EAiBO,QAjBP,CAiBgB,CAjBhB,CAAA,EAAA,CAAA,EAkBA,QAlBA,CAkBS,CAlBT,CAAA;;AAeH;;;;;AAEU,iBAkBO,mBAlBP,CAAA,CAAA,CAAA,CAAA,CAAA,EAmBN,QAnBM,CAmBG,CAnBH,CAAA,EAAA,CAAA,EAoBN,QApBM,CAoBG,CApBH,CAAA,CAAA,EAqBP,QArBO,CAqBE,CArBF,CAAA;;;;AAkBV;;AACa,iBAiBI,2BAjBJ,CAAA,CAAA,CAAA,CAAA,GAAA,EAkBP,QAlBO,CAkBE,CAlBF,CAAA,EAAA,GAAA,IAAA,EAmBH,QAnBG,CAmBM,CAnBN,CAAA,EAAA,CAAA,EAoBV,QApBU,CAoBD,CApBC,CAAA;;;;AAED,iBA0BI,QA1BJ,CAAA,CAAA,CAAA,CAAA,CAAA,EA0BmB,QA1BnB,CA0B4B,CA1B5B,CAAA,EAAA,CAAA,EA0BmC,QA1BnC,CA0B4C,CA1B5C,CAAA,CAAA,EAAA,OAAA;AAAT,iBAkCa,UAlCb,CAAA,CAAA,CAAA,CAAA,CAAA,EAkC8B,QAlC9B,CAkCuC,CAlCvC,CAAA,EAAA,CAAA,EAkC8C,QAlC9C,CAkCuD,CAlCvD,CAAA,CAAA,EAAA,OAAA;AAAA,iBAsCa,UAtCb,CAAA,CAAA,CAAA,CAAA,CAAA,EAsC8B,QAtC9B,CAsCuC,CAtCvC,CAAA,EAAA,CAAA,EAsC8C,QAtC9C,CAsCuD,CAtCvD,CAAA,CAAA,EAAA,OAAA;AAec,iBAiCD,MAjCC,CAAA,CAAA,CAAA,CAAA,CAAA,EAiCY,QAjCZ,CAiCqB,CAjCrB,CAAA,EAAA,CAAA,EAiC4B,QAjC5B,CAiCqC,CAjCrC,CAAA,CAAA,EAAA,OAAA"}
+{"version":3,"file":"venerate.d.ts","names":[],"sources":["../src/venerate.ts"],"mappings":";;;;wBAGgB,MAAM,iBAAiB,SAAS;;;;;qBAenC,QAAS,GAAG,IAAI,SAAS,OAAK,YAAY;;;;;wBAOtC,MAAM,MAAM,WAAW,SAAS,OAAO,SAAS;;;;wBAehD,WAAW,GAC3B,MAAM,SAAS,OACZ,MAAM,SAAS,OAChB,SAAS;;;;;;wBAeK,aAAa,GAC7B,MAAM,SAAS,OACZ,MAAM,SAAS,OAChB,SAAS;;;;;;;wBAiBK,oBAAoB,GACpC,GAAG,SAAS,IACZ,GAAG,SAAS,KACV,SAAS;;;;;;wBAeK,4BAA4B,GAC5C,KAAK,SAAS,OACX,MAAM,SAAS,OAChB,SAAS;;;;wBAQI,SAAS,GAAG,GAAG,SAAS,IAAI,GAAG,SAAS;wBAQxC,WAAW,GAAG,GAAG,SAAS,IAAI,GAAG,SAAS;wBAI1C,WAAW,GAAG,GAAG,SAAS,IAAI,GAAG,SAAS;wBAU1C,OAAO,GAAG,GAAG,SAAS,IAAI,GAAG,SAAS"}

package/dist/venerate.js

@@ -102,7 +102,7 @@ function equals(a, b) {
 	for (const v of A) if (!B.has(v)) return false;
 	return true;
 }
-
 //#endregion
 export { difference, equals, intersection, isDisjoint, isSet, isSubset, isSuperset, symmetricDifference, symmetricDifferenceVariadic, toSet, union };
+
 //# sourceMappingURL=venerate.js.map

package/dist/venerate.js.map

@@ -1 +1 @@
-{"version":3,"file":"venerate.js","names":[],"sources":["../src/venerate.ts"],"sourcesContent":["/**\n * Cross-realm-safe check for anything that extends Set.\n */\nexport function isSet(value: unknown): value is Set<any> {\n\tif (value == null) return false\n\ttry {\n\t\t// brand check: throws TypeError unless `value` has [[SetData]]\n\t\tSet.prototype.has.call(value, Symbol.for(`@@brandCheck`))\n\t\treturn true\n\t} catch {\n\t\treturn false\n\t}\n}\n\n/**\n * Materializes an unknown iterable as a Set, without providing for mutation.\n * Does not copy the input if it is already a Set.\n */\nexport const toSet = <T>(it: Iterable<T>): ReadonlySet<T> =>\n\tisSet(it) ? it : new Set(it)\n\n/**\n * Lazily yield the union of A, B, C, ... preserving first-seen order.\n * Only a small \"seen\" Set is maintained; inputs are streamed.\n */\nexport function* union<T>(...iterables: Iterable<T>[]): Iterable<T> {\n\tconst seen = new Set<T>()\n\tfor (const it of iterables) {\n\t\tfor (const v of it) {\n\t\t\tif (!seen.has(v)) {\n\t\t\t\tseen.add(v)\n\t\t\t\tyield v\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Lazily yield A \\ (B ∪ C ∪ ...), streaming A and pre-materializing removals.\n */\nexport function* difference<T>(\n\tbase: Iterable<T>,\n\t...rest: Iterable<T>[]\n): Iterable<T> {\n\tif (rest.length === 0) {\n\t\tyield* base\n\t\treturn\n\t}\n\tconst remove = new Set<T>()\n\tfor (const it of rest) for (const v of it) remove.add(v)\n\tfor (const v of base) if (!remove.has(v)) yield v\n}\n\n/**\n * Lazily yield A ∩ B ∩ C ∩ ...\n * Streams only the FIRST iterable; others are materialized as Sets for O(1) lookups.\n * If no others are provided, yields a shallow copy of A.\n */\nexport function* intersection<T>(\n\tbase: Iterable<T>,\n\t...rest: Iterable<T>[]\n): Iterable<T> {\n\tif (rest.length === 0) {\n\t\tyield* base\n\t\treturn\n\t}\n\tconst sets = rest.map(toSet)\n\tfor (const v of base) {\n\t\tif (sets.every((s) => s.has(v))) yield v\n\t}\n}\n\n/**\n * Lazily yield A △ B (pairwise symmetric difference).\n * Streams A and B once; materializes the opposite side for membership checks.\n * - First yields items unique to A (preserving A's order)\n * - Then yields items unique to B (preserving B's order)\n */\nexport function* symmetricDifference<T>(\n\ta: Iterable<T>,\n\tb: Iterable<T>,\n): Iterable<T> {\n\tconst A = toSet(a)\n\tconst B = toSet(b)\n\n\t// Items unique to A\n\tfor (const v of A) if (!B.has(v)) yield v\n\t// Items unique to B\n\tfor (const v of B) if (!A.has(v)) yield v\n}\n\n/**\n * Variadic symmetric difference via left fold of the pairwise version.\n * Still lazy in the sense that we only materialize small per-step Sets;\n * each fold pass consumes its input generator.\n */\nexport function* symmetricDifferenceVariadic<T>(\n\tacc: Iterable<T>,\n\t...rest: Iterable<T>[]\n): Iterable<T> {\n\tfor (const it of rest) acc = symmetricDifference(acc, it)\n\tyield* acc\n}\n\n/**\n * Predicates (not lazy outputs, but efficient w/ early exits)\n */\nexport function isSubset<T>(a: Iterable<T>, b: Iterable<T>): boolean {\n\tconst A = toSet(a)\n\tconst B = toSet(b)\n\tif (A.size > B.size) return false\n\tfor (const v of A) if (!B.has(v)) return false\n\treturn true\n}\n\nexport function isSuperset<T>(a: Iterable<T>, b: Iterable<T>): boolean {\n\treturn isSubset(b, a)\n}\n\nexport function isDisjoint<T>(a: Iterable<T>, b: Iterable<T>): boolean {\n\tconst A = toSet(a)\n\tconst B = toSet(b)\n\tconst aIsSmall = A.size <= B.size\n\tconst small = aIsSmall ? A : B\n\tconst big = aIsSmall ? B : A\n\tfor (const v of small) if (big.has(v)) return false\n\treturn true\n}\n\nexport function equals<T>(a: Iterable<T>, b: Iterable<T>): boolean {\n\tconst A = toSet(a)\n\tconst B = toSet(b)\n\tif (A.size !== B.size) return false\n\tfor (const v of A) if (!B.has(v)) return false\n\treturn true\n}\n"],"mappings":";;;;AAGA,SAAgB,MAAM,OAAmC;AACxD,KAAI,SAAS,KAAM,QAAO;AAC1B,KAAI;AAEH,MAAI,UAAU,IAAI,KAAK,OAAO,OAAO,IAAI,eAAe,CAAC;AACzD,SAAO;SACA;AACP,SAAO;;;;;;;AAQT,MAAa,SAAY,OACxB,MAAM,GAAG,GAAG,KAAK,IAAI,IAAI,GAAG;;;;;AAM7B,UAAiB,MAAS,GAAG,WAAuC;CACnE,MAAM,uBAAO,IAAI,KAAQ;AACzB,MAAK,MAAM,MAAM,UAChB,MAAK,MAAM,KAAK,GACf,KAAI,CAAC,KAAK,IAAI,EAAE,EAAE;AACjB,OAAK,IAAI,EAAE;AACX,QAAM;;;;;;AASV,UAAiB,WAChB,MACA,GAAG,MACW;AACd,KAAI,KAAK,WAAW,GAAG;AACtB,SAAO;AACP;;CAED,MAAM,yBAAS,IAAI,KAAQ;AAC3B,MAAK,MAAM,MAAM,KAAM,MAAK,MAAM,KAAK,GAAI,QAAO,IAAI,EAAE;AACxD,MAAK,MAAM,KAAK,KAAM,KAAI,CAAC,OAAO,IAAI,EAAE,CAAE,OAAM;;;;;;;AAQjD,UAAiB,aAChB,MACA,GAAG,MACW;AACd,KAAI,KAAK,WAAW,GAAG;AACtB,SAAO;AACP;;CAED,MAAM,OAAO,KAAK,IAAI,MAAM;AAC5B,MAAK,MAAM,KAAK,KACf,KAAI,KAAK,OAAO,MAAM,EAAE,IAAI,EAAE,CAAC,CAAE,OAAM;;;;;;;;AAUzC,UAAiB,oBAChB,GACA,GACc;CACd,MAAM,IAAI,MAAM,EAAE;CAClB,MAAM,IAAI,MAAM,EAAE;AAGlB,MAAK,MAAM,KAAK,EAAG,KAAI,CAAC,EAAE,IAAI,EAAE,CAAE,OAAM;AAExC,MAAK,MAAM,KAAK,EAAG,KAAI,CAAC,EAAE,IAAI,EAAE,CAAE,OAAM;;;;;;;AAQzC,UAAiB,4BAChB,KACA,GAAG,MACW;AACd,MAAK,MAAM,MAAM,KAAM,OAAM,oBAAoB,KAAK,GAAG;AACzD,QAAO;;;;;AAMR,SAAgB,SAAY,GAAgB,GAAyB;CACpE,MAAM,IAAI,MAAM,EAAE;CAClB,MAAM,IAAI,MAAM,EAAE;AAClB,KAAI,EAAE,OAAO,EAAE,KAAM,QAAO;AAC5B,MAAK,MAAM,KAAK,EAAG,KAAI,CAAC,EAAE,IAAI,EAAE,CAAE,QAAO;AACzC,QAAO;;AAGR,SAAgB,WAAc,GAAgB,GAAyB;AACtE,QAAO,SAAS,GAAG,EAAE;;AAGtB,SAAgB,WAAc,GAAgB,GAAyB;CACtE,MAAM,IAAI,MAAM,EAAE;CAClB,MAAM,IAAI,MAAM,EAAE;CAClB,MAAM,WAAW,EAAE,QAAQ,EAAE;CAC7B,MAAM,QAAQ,WAAW,IAAI;CAC7B,MAAM,MAAM,WAAW,IAAI;AAC3B,MAAK,MAAM,KAAK,MAAO,KAAI,IAAI,IAAI,EAAE,CAAE,QAAO;AAC9C,QAAO;;AAGR,SAAgB,OAAU,GAAgB,GAAyB;CAClE,MAAM,IAAI,MAAM,EAAE;CAClB,MAAM,IAAI,MAAM,EAAE;AAClB,KAAI,EAAE,SAAS,EAAE,KAAM,QAAO;AAC9B,MAAK,MAAM,KAAK,EAAG,KAAI,CAAC,EAAE,IAAI,EAAE,CAAE,QAAO;AACzC,QAAO"}
+{"version":3,"file":"venerate.js","names":[],"sources":["../src/venerate.ts"],"sourcesContent":["/**\n * Cross-realm-safe check for anything that extends Set.\n */\nexport function isSet(value: unknown): value is Set<any> {\n\tif (value == null) return false\n\ttry {\n\t\t// brand check: throws TypeError unless `value` has [[SetData]]\n\t\tSet.prototype.has.call(value, Symbol.for(`@@brandCheck`))\n\t\treturn true\n\t} catch {\n\t\treturn false\n\t}\n}\n\n/**\n * Materializes an unknown iterable as a Set, without providing for mutation.\n * Does not copy the input if it is already a Set.\n */\nexport const toSet = <T>(it: Iterable<T>): ReadonlySet<T> =>\n\tisSet(it) ? it : new Set(it)\n\n/**\n * Lazily yield the union of A, B, C, ... preserving first-seen order.\n * Only a small \"seen\" Set is maintained; inputs are streamed.\n */\nexport function* union<T>(...iterables: Iterable<T>[]): Iterable<T> {\n\tconst seen = new Set<T>()\n\tfor (const it of iterables) {\n\t\tfor (const v of it) {\n\t\t\tif (!seen.has(v)) {\n\t\t\t\tseen.add(v)\n\t\t\t\tyield v\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Lazily yield A \\ (B ∪ C ∪ ...), streaming A and pre-materializing removals.\n */\nexport function* difference<T>(\n\tbase: Iterable<T>,\n\t...rest: Iterable<T>[]\n): Iterable<T> {\n\tif (rest.length === 0) {\n\t\tyield* base\n\t\treturn\n\t}\n\tconst remove = new Set<T>()\n\tfor (const it of rest) for (const v of it) remove.add(v)\n\tfor (const v of base) if (!remove.has(v)) yield v\n}\n\n/**\n * Lazily yield A ∩ B ∩ C ∩ ...\n * Streams only the FIRST iterable; others are materialized as Sets for O(1) lookups.\n * If no others are provided, yields a shallow copy of A.\n */\nexport function* intersection<T>(\n\tbase: Iterable<T>,\n\t...rest: Iterable<T>[]\n): Iterable<T> {\n\tif (rest.length === 0) {\n\t\tyield* base\n\t\treturn\n\t}\n\tconst sets = rest.map(toSet)\n\tfor (const v of base) {\n\t\tif (sets.every((s) => s.has(v))) yield v\n\t}\n}\n\n/**\n * Lazily yield A △ B (pairwise symmetric difference).\n * Streams A and B once; materializes the opposite side for membership checks.\n * - First yields items unique to A (preserving A's order)\n * - Then yields items unique to B (preserving B's order)\n */\nexport function* symmetricDifference<T>(\n\ta: Iterable<T>,\n\tb: Iterable<T>,\n): Iterable<T> {\n\tconst A = toSet(a)\n\tconst B = toSet(b)\n\n\t// Items unique to A\n\tfor (const v of A) if (!B.has(v)) yield v\n\t// Items unique to B\n\tfor (const v of B) if (!A.has(v)) yield v\n}\n\n/**\n * Variadic symmetric difference via left fold of the pairwise version.\n * Still lazy in the sense that we only materialize small per-step Sets;\n * each fold pass consumes its input generator.\n */\nexport function* symmetricDifferenceVariadic<T>(\n\tacc: Iterable<T>,\n\t...rest: Iterable<T>[]\n): Iterable<T> {\n\tfor (const it of rest) acc = symmetricDifference(acc, it)\n\tyield* acc\n}\n\n/**\n * Predicates (not lazy outputs, but efficient w/ early exits)\n */\nexport function isSubset<T>(a: Iterable<T>, b: Iterable<T>): boolean {\n\tconst A = toSet(a)\n\tconst B = toSet(b)\n\tif (A.size > B.size) return false\n\tfor (const v of A) if (!B.has(v)) return false\n\treturn true\n}\n\nexport function isSuperset<T>(a: Iterable<T>, b: Iterable<T>): boolean {\n\treturn isSubset(b, a)\n}\n\nexport function isDisjoint<T>(a: Iterable<T>, b: Iterable<T>): boolean {\n\tconst A = toSet(a)\n\tconst B = toSet(b)\n\tconst aIsSmall = A.size <= B.size\n\tconst small = aIsSmall ? A : B\n\tconst big = aIsSmall ? B : A\n\tfor (const v of small) if (big.has(v)) return false\n\treturn true\n}\n\nexport function equals<T>(a: Iterable<T>, b: Iterable<T>): boolean {\n\tconst A = toSet(a)\n\tconst B = toSet(b)\n\tif (A.size !== B.size) return false\n\tfor (const v of A) if (!B.has(v)) return false\n\treturn true\n}\n"],"mappings":";;;;AAGA,SAAgB,MAAM,OAAmC;CACxD,IAAI,SAAS,MAAM,OAAO;CAC1B,IAAI;EAEH,IAAI,UAAU,IAAI,KAAK,OAAO,OAAO,IAAI,cAAc,CAAC;EACxD,OAAO;CACR,QAAQ;EACP,OAAO;CACR;AACD;;;;;AAMA,MAAa,SAAY,OACxB,MAAM,EAAE,IAAI,KAAK,IAAI,IAAI,EAAE;;;;;AAM5B,UAAiB,MAAS,GAAG,WAAuC;CACnE,MAAM,uBAAO,IAAI,IAAO;CACxB,KAAK,MAAM,MAAM,WAChB,KAAK,MAAM,KAAK,IACf,IAAI,CAAC,KAAK,IAAI,CAAC,GAAG;EACjB,KAAK,IAAI,CAAC;EACV,MAAM;CACP;AAGH;;;;AAKA,UAAiB,WAChB,MACA,GAAG,MACW;CACd,IAAI,KAAK,WAAW,GAAG;EACtB,OAAO;EACP;CACD;CACA,MAAM,yBAAS,IAAI,IAAO;CAC1B,KAAK,MAAM,MAAM,MAAM,KAAK,MAAM,KAAK,IAAI,OAAO,IAAI,CAAC;CACvD,KAAK,MAAM,KAAK,MAAM,IAAI,CAAC,OAAO,IAAI,CAAC,GAAG,MAAM;AACjD;;;;;;AAOA,UAAiB,aAChB,MACA,GAAG,MACW;CACd,IAAI,KAAK,WAAW,GAAG;EACtB,OAAO;EACP;CACD;CACA,MAAM,OAAO,KAAK,IAAI,KAAK;CAC3B,KAAK,MAAM,KAAK,MACf,IAAI,KAAK,OAAO,MAAM,EAAE,IAAI,CAAC,CAAC,GAAG,MAAM;AAEzC;;;;;;;AAQA,UAAiB,oBAChB,GACA,GACc;CACd,MAAM,IAAI,MAAM,CAAC;CACjB,MAAM,IAAI,MAAM,CAAC;CAGjB,KAAK,MAAM,KAAK,GAAG,IAAI,CAAC,EAAE,IAAI,CAAC,GAAG,MAAM;CAExC,KAAK,MAAM,KAAK,GAAG,IAAI,CAAC,EAAE,IAAI,CAAC,GAAG,MAAM;AACzC;;;;;;AAOA,UAAiB,4BAChB,KACA,GAAG,MACW;CACd,KAAK,MAAM,MAAM,MAAM,MAAM,oBAAoB,KAAK,EAAE;CACxD,OAAO;AACR;;;;AAKA,SAAgB,SAAY,GAAgB,GAAyB;CACpE,MAAM,IAAI,MAAM,CAAC;CACjB,MAAM,IAAI,MAAM,CAAC;CACjB,IAAI,EAAE,OAAO,EAAE,MAAM,OAAO;CAC5B,KAAK,MAAM,KAAK,GAAG,IAAI,CAAC,EAAE,IAAI,CAAC,GAAG,OAAO;CACzC,OAAO;AACR;AAEA,SAAgB,WAAc,GAAgB,GAAyB;CACtE,OAAO,SAAS,GAAG,CAAC;AACrB;AAEA,SAAgB,WAAc,GAAgB,GAAyB;CACtE,MAAM,IAAI,MAAM,CAAC;CACjB,MAAM,IAAI,MAAM,CAAC;CACjB,MAAM,WAAW,EAAE,QAAQ,EAAE;CAC7B,MAAM,QAAQ,WAAW,IAAI;CAC7B,MAAM,MAAM,WAAW,IAAI;CAC3B,KAAK,MAAM,KAAK,OAAO,IAAI,IAAI,IAAI,CAAC,GAAG,OAAO;CAC9C,OAAO;AACR;AAEA,SAAgB,OAAU,GAAgB,GAAyB;CAClE,MAAM,IAAI,MAAM,CAAC;CACjB,MAAM,IAAI,MAAM,CAAC;CACjB,IAAI,EAAE,SAAS,EAAE,MAAM,OAAO;CAC9B,KAAK,MAAM,KAAK,GAAG,IAAI,CAAC,EAAE,IAAI,CAAC,GAAG,OAAO;CACzC,OAAO;AACR"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "venerate",
-  "version": "0.0.3",
-  "license": "MIT",
+  "version": "0.0.5",
+  "license": "MPL-2.0",
   "author": {
     "name": "Jeremy Banka",
     "email": "hello@jeremybanka.com"
@@ -21,25 +21,26 @@
   ],
   "main": "dist/venerate.js",
   "devDependencies": {
-    "@types/node": "24.3.1",
-    "@vitest/coverage-v8": "3.2.4",
-    "concurrently": "9.2.1",
-    "eslint": "9.35.0",
-    "recoverage": "0.1.11",
-    "tsdown": "0.14.2",
-    "vite": "7.1.5",
-    "vitest": "3.2.4"
+    "@types/node": "25.9.5",
+    "typescript": "7.0.2",
+    "@vitest/coverage-v8": "4.1.11",
+    "concurrently": "10.0.5",
+    "eslint": "10.9.1",
+    "recoverage": "0.1.16",
+    "tsdown": "0.22.14",
+    "vite": "8.2.2",
+    "vitest": "4.1.11"
   },
   "scripts": {
     "build": "tsdown",
-    "lint:biome": "biome check -- .",
     "lint:eslint": "eslint -- .",
-    "lint:types": "tsgo --noEmit",
-    "watch:types": "tsgo --watch --noEmit",
+    "lint:oxlint": "oxlint --type-aware -c ../../.oxlintrc.jsonc .",
+    "lint:types": "tsc --noEmit",
+    "watch:types": "tsc --watch --noEmit",
     "lint": "concurrently \"bun:lint:*\"",
     "test": "vitest",
     "test:coverage": "vitest run --coverage",
     "test:once": "vitest run",
-    "postversion": "biome format --write package.json"
+    "postversion": "dprint fmt package.json"
   }
 }