@fncts/base 0.0.20 → 0.0.22

package/_src/typeclass/Semimonoidal.ts

@@ -1,6 +1,5 @@
 export interface Semimonoidal<F extends HKT, FC = HKT.None> extends HKT.Typeclass<F, FC> {
-  zip: <K1, Q1, W1, X1, I1, S1, R1, E1, A, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
-    fa: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
+  zip: <K1, Q1, W1, X1, I1, S1, R1, E1, K2, Q2, W2, X2, I2, S2, R2, E2, B>(
     fb: HKT.Kind<
       F,
       FC,
@@ -14,6 +13,8 @@ export interface Semimonoidal<F extends HKT, FC = HKT.None> extends HKT.Typeclas
       HKT.Intro<F, "E", E1, E2>,
       B
     >,
+  ) => <A>(
+    fa: HKT.Kind<F, FC, K1, Q1, W1, X1, I1, S1, R1, E1, A>,
   ) => HKT.Kind<
     F,
     FC,

package/_src/typeclass/Traversable.ts

@@ -8,12 +8,12 @@ import { identity } from "@fncts/base/data/function";
  * @tsplus type fncts.Traversable
  */
 export interface Traversable<F extends HKT, FC = HKT.None> extends Functor<F, FC>, Foldable<F, FC> {
-  traverse: <KF, QF, WF, XF, IF, SF, RF, EF, A>(
-    ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => <G extends HKT, GC = HKT.None>(
+  traverse: <G extends HKT, GC = HKT.None>(
     G: Applicative<G, GC>,
-  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(
+  ) => <A, KG, QG, WG, XG, IG, SG, RG, EG, B>(
     f: (a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>,
+  ) => <KF, QF, WF, XF, IF, SF, RF, EF>(
+    ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
   ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
 }
 
@@ -41,10 +41,10 @@ export function mkTraverse_<F extends HKT, FC = HKT.None>(): (
     R: R;
     E: E;
   }) => (
-    ta: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
-  ) => (
     G: Applicative<HKT.F<G>>,
-  ) => (f: (a: A) => HKT.FK1<G, B>) => HKT.FK1<G, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>>,
+  ) => (
+    f: (a: A) => HKT.FK1<G, B>,
+  ) => (ta: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => HKT.FK1<G, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>>,
 ) => Traversable<F, FC>["traverse"];
 export function mkTraverse_() {
   return (i: any) => i();
@@ -55,15 +55,10 @@ export function mkTraverse_() {
  */
 export function sequence<F extends HKT, FC>(
   F: Traversable<F, FC>,
-): <KF, QF, WF, XF, IF, SF, RF, EF, A>(
-  ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-) => <G extends HKT, GC = HKT.None>(
-  G: CompatibleApplicative<G, GC, A>,
-) => [A] extends [
-  HKT.Kind<G, GC, infer KG, infer QG, infer WG, infer XG, infer IG, infer SG, infer RG, infer EG, infer B>,
-]
-  ? HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XG, IF, SF, RF, EF, B>>
-  : never {
-  // @ts-expect-error
-  return (ta) => (G) => F.traverse(ta)(G)(identity);
+): <G extends HKT, GC = HKT.None>(
+  G: Applicative<G, GC>,
+) => <KF, QF, WF, XF, IF, SF, RF, EF, KG, QG, WG, XG, IG, SG, RG, EG, A>(
+  ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, A>>,
+) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>> {
+  return (G) => F.traverse(G)(identity);
 }

package/_src/typeclass/TraversableWithIndex.ts

@@ -10,12 +10,12 @@ export interface TraversableWithIndex<F extends HKT, FC = HKT.None>
   extends FunctorWithIndex<F, FC>,
     FoldableWithIndex<F, FC>,
     Traversable<F, FC> {
-  traverseWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A>(
-    ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => <G extends HKT, GC = HKT.None>(
+  traverseWithIndex: <G extends HKT, GC = HKT.None>(
     G: Applicative<G, GC>,
-  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(
+  ) => <KF, A, KG, QG, WG, XG, IG, SG, RG, EG, B>(
     f: (i: HKT.IndexFor<F, KF>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>,
+  ) => <QF, WF, XF, IF, SF, RF, EF>(
+    ta: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
   ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
 }
 
@@ -43,12 +43,10 @@ export function mkTraverseWithIndex_<F extends HKT, FC = HKT.None>(): (
     R: R;
     E: E;
   }) => (
-    ta: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>,
-  ) => (
     G: Applicative<HKT.F<G>>,
   ) => (
     f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", K>>, a: A) => HKT.FK1<G, B>,
-  ) => HKT.FK1<G, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>>,
+  ) => (ta: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => HKT.FK1<G, HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, B>>,
 ) => TraversableWithIndex<F, FC>["traverseWithIndex"];
 export function mkTraverseWithIndex_() {
   return (i: any) => i();

package/_src/typeclass/Witherable.ts

@@ -2,23 +2,25 @@ import type { Applicative } from "@fncts/base/typeclass/Applicative";
 import type { Filterable } from "@fncts/base/typeclass/Filterable";
 import type { Traversable } from "@fncts/base/typeclass/Traversable";
 
+import { pipe } from "@fncts/base/data/function";
 /**
  * @tsplus type fncts.Witherable
  */
 export interface Witherable<F extends HKT, FC = HKT.None> extends Filterable<F, FC>, Traversable<F, FC> {
-  wither: <KF, QF, WF, XF, IF, SF, RF, EF, A>(
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => <G extends HKT, GC = HKT.None>(
+  wither: <G extends HKT, GC = HKT.None>(
     G: Applicative<G, GC>,
-  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(
+  ) => <A, KG, QG, WG, XG, IG, SG, RG, EG, B>(
     f: (a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
-  ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
-  wilt: <KF, QF, WF, XF, IF, SF, RF, EF, A>(
+  ) => <KF, QF, WF, XF, IF, SF, RF, EF>(
     wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => <G extends HKT, GC = HKT.None>(
+  ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
+
+  wilt: <G extends HKT, GC = HKT.None>(
     G: Applicative<G, GC>,
-  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B, B1>(
+  ) => <A, KG, QG, WG, XG, IG, SG, RG, EG, B, B1>(
     f: (a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B1>>,
+  ) => <KF, QF, WF, XF, IF, SF, RF, EF>(
+    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
   ) => HKT.Kind<
     G,
     GC,
@@ -46,12 +48,18 @@ export const Witherable: WitherableOps = {};
  */
 export function filterA<F extends HKT, FC = HKT.None>(
   F: Witherable<F, FC>,
-): <KF, QF, WF, XF, IF, SF, RF, EF, AF>(
-  fa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, AF>,
-) => <G extends HKT, GC = HKT.None>(
+): <G extends HKT, GC = HKT.None>(
   G: Applicative<G, GC>,
-) => <KG, QG, WG, XG, IG, SG, RG, EG>(
+) => <AF, KG, QG, WG, XG, IG, SG, RG, EG>(
   p: (a: AF) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, boolean>,
+) => <KF, QF, WF, XF, IF, SF, RF, EF>(
+  fa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, AF>,
 ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, AF>> {
-  return (fa) => (G) => (p) => F.wither(fa)(G)((a) => G.map(p(a), (bb) => (bb ? Just(a) : Nothing())));
+  return (G) => (p) =>
+    F.wither(G)((a) =>
+      pipe(
+        p(a),
+        G.map((bb) => (bb ? Just(a) : Nothing())),
+      ),
+    );
 }

package/_src/typeclass/WitherableWithIndex.ts

@@ -3,6 +3,8 @@ import type { FilterableWithIndex } from "@fncts/base/typeclass/FilterableWithIn
 import type { TraversableWithIndex } from "@fncts/base/typeclass/TraversableWithIndex";
 import type { Witherable } from "@fncts/base/typeclass/Witherable";
 
+import { pipe } from "@fncts/base/data/function";
+
 /**
  * @tsplus type fncts.WitherableWithIndex
  */
@@ -10,19 +12,20 @@ export interface WitherableWithIndex<F extends HKT, FC = HKT.None>
   extends FilterableWithIndex<F, FC>,
     TraversableWithIndex<F, FC>,
     Witherable<F, FC> {
-  witherWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A>(
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => <G extends HKT, GC = HKT.None>(
+  witherWithIndex: <G extends HKT, GC = HKT.None>(
     G: Applicative<G, GC>,
-  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(
+  ) => <KF, A, KG, QG, WG, XG, IG, SG, RG, EG, B>(
     f: (k: HKT.IndexFor<F, KF>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Maybe<B>>,
-  ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
-  wiltWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A, B, B2>(
+  ) => <QF, WF, XF, IF, SF, RF, EF>(
     wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => <G extends HKT, GC = HKT.None>(
+  ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>;
+
+  wiltWithIndex: <G extends HKT, GC = HKT.None>(
     G: Applicative<G, GC>,
-  ) => <KG, QG, WG, XG, IG, SG, RG, EG, B, B2>(
+  ) => <KF, A, KG, QG, WG, XG, IG, SG, RG, EG, B, B2>(
     f: (k: HKT.IndexFor<F, KF>, a: A) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, Either<B, B2>>,
+  ) => <QF, WF, XF, IF, SF, RF, EF>(
+    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
   ) => HKT.Kind<
     G,
     GC,
@@ -62,11 +65,11 @@ export function makeWitherWithIndex<F extends HKT, FC = HKT.None>(): (
     FR: RF;
     FE: EF;
   }) => (
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => (
     G: Applicative<HKT.F<G>>,
   ) => (
     f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.FK1<G, Maybe<B>>,
+  ) => (
+    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
   ) => HKT.FK1<G, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>>,
 ) => WitherableWithIndex<F, FC>["witherWithIndex"];
 export function makeWitherWithIndex() {
@@ -91,11 +94,11 @@ export function makeWiltWithIndex<F extends HKT, FC = HKT.None>(): (
     B: B;
     B1: B1;
   }) => (
-    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
-  ) => (
     G: Applicative<HKT.F<G>>,
   ) => (
     f: (i: HKT.IndexFor<F, HKT.OrFix<FC, "K", KF>>, a: A) => HKT.FK1<G, Either<B, B1>>,
+  ) => (
+    wa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, A>,
   ) => HKT.FK1<
     G,
     readonly [HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B>, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, B1>]
@@ -107,12 +110,18 @@ export function makeWiltWithIndex() {
 
 export function filterWithIndexA<F extends HKT, FC = HKT.None>(
   F: WitherableWithIndex<F, FC>,
-): <KF, QF, WF, XF, IF, SF, RF, EF, AF>(
-  fa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, AF>,
-) => <G extends HKT, GC = HKT.None>(
+): <G extends HKT, GC = HKT.None>(
   G: Applicative<G, GC>,
-) => <KG, QG, WG, XG, IG, SG, RG, EG>(
+) => <KF, AF, KG, QG, WG, XG, IG, SG, RG, EG>(
   p: (i: HKT.IndexFor<F, KF>, a: AF) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, boolean>,
+) => <QF, WF, XF, IF, SF, RF, EF>(
+  fa: HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, AF>,
 ) => HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, HKT.Kind<F, FC, KF, QF, WF, XF, IF, SF, RF, EF, AF>> {
-  return (fa) => (G) => (p) => F.witherWithIndex(fa)(G)((i, a) => G.map(p(i, a), (bb) => (bb ? Just(a) : Nothing())));
+  return (G) => (p) =>
+    F.witherWithIndex(G)((i, a) =>
+      pipe(
+        p(i, a),
+        G.map((bb) => (bb ? Just(a) : Nothing())),
+      ),
+    );
 }

package/_src/typeclass/builtin/Symbol.ts

@@ -4,5 +4,4 @@ declare global {
    */
   export interface SymbolConstructor {}
 }
-
 export {};

package/_src/typeclass.ts

@@ -8,8 +8,6 @@ export * from "./typeclass/Apply.js";
 export * from "./typeclass/builtin.js";
 export * from "./typeclass/Chain.js";
 export * from "./typeclass/Closure.js";
-export * from "./typeclass/Eq.js";
-export * from "./typeclass/Equatable.js";
 export * from "./typeclass/Fail.js";
 export * from "./typeclass/Filterable.js";
 export * from "./typeclass/FilterableWithIndex.js";
@@ -17,17 +15,11 @@ export * from "./typeclass/Foldable.js";
 export * from "./typeclass/FoldableWithIndex.js";
 export * from "./typeclass/Functor.js";
 export * from "./typeclass/FunctorWithIndex.js";
-export * from "./typeclass/Guard.js";
 export * from "./typeclass/Has.js";
-export * from "./typeclass/Hash.js";
-export * from "./typeclass/Hashable.js";
-export * from "./typeclass/HashEq.js";
 export * from "./typeclass/Monad.js";
 export * from "./typeclass/MonadExcept.js";
 export * from "./typeclass/Monoid.js";
 export * from "./typeclass/Nil.js";
-export * from "./typeclass/Ord.js";
-export * from "./typeclass/Ordering.js";
 export * from "./typeclass/Pointed.js";
 export * from "./typeclass/Semialign.js";
 export * from "./typeclass/Semigroup.js";
@@ -37,3 +29,12 @@ export * from "./typeclass/TraversableWithIndex.js";
 export * from "./typeclass/Witherable.js";
 export * from "./typeclass/WitherableWithIndex.js";
 // codegen:end
+
+export { Eq } from "./data/Eq.js";
+export { Equatable } from "./data/Equatable.js";
+export { Guard } from "./data/Guard.js";
+export { Hash } from "./data/Hash.js";
+export { Hashable } from "./data/Hashable.js";
+export { HashEq } from "./data/HashEq.js";
+export { Ord } from "./data/Ord.js";
+export { Ordering } from "./data/Ordering.js";

package/_src/types/extractions.ts

@@ -1,8 +1,17 @@
-export type ExtractContravariantPhantom<A, P extends PropertyKey> = [A] extends [{ [K in P]: (_: infer T) => void }]
+export type ExtractContravariantPhantom<A, P extends PropertyKey> = [A] extends [
+  {
+    [K in P]: (_: infer T) => void;
+  },
+]
+  ? T
+  : never;
+export type ExtractCovariantPhantom<A, P extends PropertyKey> = [A] extends [
+  {
+    [K in P]: () => infer T;
+  },
+]
   ? T
   : never;
-export type ExtractCovariantPhantom<A, P extends PropertyKey> = [A] extends [{ [K in P]: () => infer T }] ? T : never;
-
 export type _W<A> = ExtractCovariantPhantom<A, "_W">;
 export type _S1<A> = ExtractContravariantPhantom<A, "_S1">;
 export type _S2<A> = ExtractCovariantPhantom<A, "_S2">;

package/_src/types/utility.ts

@@ -1,9 +1,7 @@
 export type Primitive = string | number | boolean | null | symbol;
-
-export type Constructor<A> = { new (...args: any[]): A };
-
+export type Constructor<A> = {
+  new (...args: any[]): A;
+};
 export type Nullable<A> = A | null | undefined;
-
 export type IsInt<N extends number> = N & (`${N}` extends `${bigint}` ? N : never);
-
 export interface Spreadable extends Record<PropertyKey, any> {}

package/_src/util/AnsiFormat.ts

@@ -62,128 +62,103 @@ export function bg_rgb(r: number, g: number, b: number): (s: string) => string {
  * Foreground color for ANSI black
  */
 export const BLACK = escape(30);
-
 /**
  * Foreground color for ANSI red
  */
 export const RED = escape(31);
-
 /**
  * Foreground color for ANSI green
  */
 export const GREEN = escape(32);
-
 /**
  * Foreground color for ANSI yellow
  */
 export const YELLOW = escape(33);
-
 /**
  * Foreground color for ANSI blue
  */
 export const BLUE = escape(34);
-
 /**
  * Foreground color for ANSI magenta
  */
 export const MAGENTA = escape(35);
-
 /**
  * Foreground color for ANSI cyan
  */
 export const CYAN = escape(36);
-
 /**
  * Foreground color for ANSI white
  */
 export const WHITE = escape(37);
-
 /**
  * Background color for ANSI black
  */
 export const BLACK_B = escape(40);
-
 /**
  * Background color for ANSI red
  */
 export const RED_B = escape(41);
-
 /**
  * Background color for ANSI green
  */
 export const GREEN_B = escape(42);
-
 /**
  * Background color for ANSI yellow
  */
 export const YELLOW_B = escape(43);
-
 /**
  * Background color for ANSI blue
  */
 export const BLUE_B = escape(44);
-
 /**
  * Background color for ANSI magenta
  */
 export const MAGENTA_B = escape(45);
-
 /**
  * Background color for ANSI cyan
  */
 export const CYAN_B = escape(46);
-
 /**
  * Background color for ANSI white
  */
 export const WHITE_B = escape(47);
-
 /**
  * Reset ANSI styles
  */
 export const RESET = escape(0);
-
 /**
  * ANSI bold
  */
 export const BOLD = escape(1);
-
 /**
  * ANSI underline
  */
 export const UNDERLINE = escape(4);
-
 /**
  * ANSI blink
  */
 export const BLINK = escape(5);
-
 /**
  * ANSI reversed
  */
 export const REVERSED = escape(7);
-
 /**
  * ANSI invisible
  */
 export const INVISIBLE = escape(8);
-
 /**
  * Reset ANSI foreground
  */
 export const RESET_FG = escape(39);
-
 /**
  * Reset ANSI background
  */
 export const RESET_BG = escape(49);
-
 /**
  * ANSI 24bit foreground
  */
 export const RGB = <r extends number, g extends number, b extends number>(r: r, g: g, b: b) =>
   `\u001b[38;2;${r};${g};${b}m` as const;
-
 /**
  * ANSI 24bit background
  */

package/_src/util/PCGRandom.ts

@@ -1,5 +1,4 @@
 /* eslint-disable no-param-reassign */
-
 /*
  * Copyright 2014 Thom Chiovoloni, released under the MIT license.
  *
@@ -14,7 +13,6 @@
 export function isNothing<T>(value: T | null | undefined) {
   return value === void 0 || value === null;
 }
-
 const defaultIncHi = 0x14057b7e;
 const defaultIncLo = 0xf767814f;
 const MUL_HI       = 0x5851f42d >>> 0;
@@ -159,9 +157,8 @@ function mul64(out: Int32Array, aHi: number, aLo: number, bHi: number, bLo: numb
 
   let lo = ((aLo & 0xffff) * (bLo & 0xffff)) >>> 0;
   let hi = ((aLo >>> 16) * (bLo >>> 16) + ((c0 >>> 16) + (c1 >>> 16))) >>> 0;
-
-  c0 = (c0 << 16) >>> 0;
-  lo = (lo + c0) >>> 0;
+  c0     = (c0 << 16) >>> 0;
+  lo     = (lo + c0) >>> 0;
   if (lo >>> 0 < c0 >>> 0) {
     hi = (hi + 1) >>> 0;
   }
@@ -171,10 +168,8 @@ function mul64(out: Int32Array, aHi: number, aLo: number, bHi: number, bLo: numb
   if (lo >>> 0 < c1 >>> 0) {
     hi = (hi + 1) >>> 0;
   }
-
-  hi = (hi + Math.imul(aLo, bHi)) >>> 0;
-  hi = (hi + Math.imul(aHi, bLo)) >>> 0;
-
+  hi     = (hi + Math.imul(aLo, bHi)) >>> 0;
+  hi     = (hi + Math.imul(aHi, bLo)) >>> 0;
   out[0] = hi;
   out[1] = lo;
 }

package/_src/util/assert.ts

@@ -3,8 +3,7 @@ export class AssertionError extends Error {
     super(`Assertion Failed: ${message}`);
   }
 }
-
-export function assert(assertion: boolean, message: string) {
+export function assert(assertion: boolean, message: string): asserts assertion {
   if (!assertion) {
     throw new AssertionError(message);
   }

package/_src/util/pattern.ts

@@ -1,15 +1,55 @@
 export const pattern_: <N extends string>(
   n: N,
 ) => {
-  <X extends { [k in N]: string }, K extends { [k in X[N]]: (_: Extract<X, { [_tag in N]: k }>) => any }>(
+  <
+    X extends {
+      [k in N]: string;
+    },
+    K extends {
+      [k in X[N]]: (
+        _: Extract<
+          X,
+          {
+            [_tag in N]: k;
+          }
+        >,
+      ) => any;
+    },
+  >(
     m: X,
     _: K,
   ): ReturnType<K[keyof K]>;
-  <X extends { [k in N]: string }, K extends { [k in X[N]]?: (_: Extract<X, { [_tag in N]: k }>) => any }, H>(
+  <
+    X extends {
+      [k in N]: string;
+    },
+    K extends {
+      [k in X[N]]?: (
+        _: Extract<
+          X,
+          {
+            [_tag in N]: k;
+          }
+        >,
+      ) => any;
+    },
+    H,
+  >(
     m: X,
     _: K,
-    __: (_: Exclude<X, { _tag: keyof K }>) => H,
-  ): { [k in keyof K]: ReturnType<NonNullable<K[k]>> }[keyof K] | H;
+    __: (
+      _: Exclude<
+        X,
+        {
+          _tag: keyof K;
+        }
+      >,
+    ) => H,
+  ):
+    | {
+        [k in keyof K]: ReturnType<NonNullable<K[k]>>;
+      }[keyof K]
+    | H;
 } = (n) =>
   ((m: any, _: any, d: any) => {
     return (_[m[n]] ? _[m[n]](m) : d(m)) as any;
@@ -18,18 +58,57 @@ export const pattern_: <N extends string>(
 export const pattern: <N extends string>(
   n: N,
 ) => {
-  <X extends { [k in N]: string }, K extends { [k in X[N]]: (_: Extract<X, { [_tag in N]: k }>) => any }>(_: K): (
-    m: X,
-  ) => ReturnType<K[keyof K]>;
-  <X extends { [k in N]: string }, K extends { [k in X[N]]?: (_: Extract<X, { [_tag in N]: k }>) => any }, H>(
+  <
+    X extends {
+      [k in N]: string;
+    },
+    K extends {
+      [k in X[N]]: (
+        _: Extract<
+          X,
+          {
+            [_tag in N]: k;
+          }
+        >,
+      ) => any;
+    },
+  >(
+    _: K,
+  ): (m: X) => ReturnType<K[keyof K]>;
+  <
+    X extends {
+      [k in N]: string;
+    },
+    K extends {
+      [k in X[N]]?: (
+        _: Extract<
+          X,
+          {
+            [_tag in N]: k;
+          }
+        >,
+      ) => any;
+    },
+    H,
+  >(
     _: K,
-    __: (_: Exclude<X, { _tag: keyof K }>) => H,
-  ): (m: X) => { [k in keyof K]: ReturnType<NonNullable<K[k]>> }[keyof K] | H;
+    __: (
+      _: Exclude<
+        X,
+        {
+          _tag: keyof K;
+        }
+      >,
+    ) => H,
+  ): (m: X) =>
+    | {
+        [k in keyof K]: ReturnType<NonNullable<K[k]>>;
+      }[keyof K]
+    | H;
 } = (n) =>
   ((_: any, d: any) => (m: any) => {
     return (_[m[n]] ? _[m[n]](m) : d(m)) as any;
   }) as any;
 
 export const matchTag_ = pattern_("_tag");
-
-export const matchTag = pattern("_tag");
+export const matchTag  = pattern("_tag");

package/_src/util/predicates.ts

@@ -44,7 +44,9 @@ export function isObject<A>(value: A | Primitive): boolean {
 export function hasTypeId<X extends symbol>(
   value: unknown,
   typeId: X,
-): value is { readonly _typeId: X } & Record<PropertyKey, unknown> {
+): value is {
+  readonly _typeId: X;
+} & Record<PropertyKey, unknown> {
   return isObject(value) && "_typeId" in value && value["_typeId"] === typeId;
 }