@fncts/base 0.0.36 → 0.0.38

package/_src/types.ts

@@ -1,5 +1,4 @@
-/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: types/*.ts }
-export * from "./types/utility.js";
 export * from "./types/extractions.js";
+export * from "./types/utility.js";
 // codegen:end

package/_src/util/PCGRandom.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-param-reassign */
 /*
  * Copyright 2014 Thom Chiovoloni, released under the MIT license.
  *

package/_src/util/predicates.ts

@@ -146,8 +146,10 @@ export function isRegExp(u: unknown): u is RegExp {
   return isObject(u) && (getTag(u) === "[object RegExp]" || u instanceof RegExp);
 }
 
+const hasSharedArrayBuffer = "SharedArrayBuffer" in globalThis;
+
 export function isAnyArrayBuffer(u: unknown): u is ArrayBuffer | SharedArrayBuffer {
-  return u instanceof ArrayBuffer || u instanceof SharedArrayBuffer;
+  return u instanceof ArrayBuffer || (hasSharedArrayBuffer && u instanceof SharedArrayBuffer);
 }
 
 export function isArrayBuffer(u: unknown): u is ArrayBuffer {

package/_src/util/rand/distribution/UniformBigIntDistribution.ts

@@ -12,7 +12,7 @@ function uniformBigIntInternal(from: bigint, diff: bigint, rng: RandomGenerator)
     ++NumIterations;
   }
   const MaxAcceptedRandom = FinalNumValues - (FinalNumValues % diff);
-  // eslint-disable-next-line no-constant-condition
+
   while (true) {
     // Aggregate mutiple calls to next() into a single random value
     let value = BigInt(0);

package/_src/util/rand/distribution/internals/ArrayInt.ts

@@ -111,7 +111,7 @@ export function substractArrayIntToNew(arrayIntA: ArrayInt, arrayIntB: ArrayInt)
 export function trimArrayIntInplace(arrayInt: ArrayInt) {
   const data       = arrayInt.data;
   let firstNonZero = 0;
-  // eslint-disable-next-line no-empty
+
   for (; firstNonZero !== data.length && data[firstNonZero] === 0; ++firstNonZero) {}
   if (firstNonZero === data.length) {
     // only zeros

package/_src/util/rand/distribution/internals/UniformArrayIntDistributionInternal.ts

@@ -18,7 +18,7 @@ export function uniformArrayIntDistributionInternal(
 ): ArrayInt["data"] {
   const rangeLength = rangeSize.length;
   // We iterate until we find a valid value for arrayInt
-  // eslint-disable-next-line no-constant-condition
+
   while (true) {
     // We compute a new value for arrayInt
     for (let index = 0; index !== rangeLength; ++index) {

package/_src/util/rand/distribution/internals/UniformIntDistributionInternal.ts

@@ -9,7 +9,7 @@ export function uniformIntDistributionInternal(rangeSize: number, rng: RandomGen
   // Range provided by the RandomGenerator is large enough
   if (rangeSize <= NumValues) {
     const MaxAllowed = NumValues - (NumValues % rangeSize);
-    // eslint-disable-next-line no-constant-condition
+
     while (true) {
       const out    = rng.next();
       const deltaV = out - MinRng;
@@ -27,7 +27,7 @@ export function uniformIntDistributionInternal(rangeSize: number, rng: RandomGen
     ++NumIterations;
   }
   const MaxAcceptedRandom = rangeSize * Math.floor((1 * FinalNumValues) / rangeSize);
-  // eslint-disable-next-line no-constant-condition
+
   while (true) {
     // Aggregate mutiple calls to next() into a single random value
     let value = 0;

package/collection/Iterable/api/traverseConc.d.ts

@@ -5,7 +5,7 @@ import type * as P from "@fncts/base/typeclass";
  * @tsplus getter fncts.Iterable traverseToConcWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api/traverseConc"
  */
-export declare function _traverseToConcWithIndex<A>(ta: Iterable<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (i: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("../../immutable/Conc").Conc<B>>;
+export declare function _traverseToConcWithIndex<A>(ta: Iterable<A>): <G extends HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (i: number, a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Conc<B>>;
 /**
  * @tsplus getter fncts.Iterable traverseToConc
  * @tsplus location "@fncts/base/collection/Iterable/api/traverseConc"

package/collection/Iterable/api.d.ts

@@ -4,7 +4,6 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Eval } from "@fncts/base/control/Eval/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import type * as P from "@fncts/base/typeclass";
-import { Iterable } from "@fncts/base/collection/Iterable/definition";
 /**
  * @tsplus pipeable fncts.Iterable ap
  * @tsplus location "@fncts/base/collection/Iterable/api"

package/collection/Iterable.d.ts

@@ -1,3 +1,3 @@
-export * from "./Iterable/definition.js";
-export * from "./Iterable/constructors.js";
 export * from "./Iterable/api.js";
+export * from "./Iterable/constructors.js";
+export * from "./Iterable/definition.js";

package/collection/compat/Array/api.d.ts

@@ -1,6 +1,11 @@
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { ReadonlyNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import type { Eq } from "@fncts/base/typeclass";
+/**
+ * @tsplus static fncts.ArrayOps fromValue
+ * @tsplus location "@fncts/base/collection/compat/Array/api"
+ */
+export declare function fromValue<A>(value: A): A extends Array<any> ? A : A extends ReadonlyArray<any> ? A : ReadonlyArray<A>;
 /**
  * @tsplus getter fncts.Array elem
  * @tsplus getter fncts.ReadonlyArray elem
@@ -49,3 +54,9 @@ export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A)
  * @tsplus location "@fncts/base/collection/compat/Array/api"
  */
 export declare function updateAt<A>(i: number, a: A): (self: ReadonlyArray<A>) => ReadonlyArray<A>;
+/**
+ * @tsplus pipeable fncts.Array groupBy
+ * @tsplus pipeable fncts.ReadonlyArray groupBy
+ * @tsplus location "@fncts/base/collection/compat/Array/api"
+ */
+export declare function groupBy<A, K extends PropertyKey>(f: (a: A) => K): (self: ReadonlyArray<A>) => Record<K, ReadonlyArray<A>>;

package/collection/compat/Array.d.ts

@@ -1,2 +1,2 @@
-export * from "./Array/definition.js";
 export * from "./Array/api.js";
+export * from "./Array/definition.js";

package/collection/immutable/Conc/definition.d.ts

@@ -147,9 +147,9 @@ export declare class Singleton<A> extends ConcImplementation<A> {
     get(n: number): A;
     forEach<B>(startIndex: number, f: (i: number, a: A) => B): void;
     copyToArray(n: number, dest: Array<A> | Uint8Array): void;
-    [Symbol.iterator](): Iterator<A, any, undefined>;
-    arrayIterator(): Iterator<A[], any, undefined>;
-    reverseArrayIterator: () => Iterator<A[], any, undefined>;
+    [Symbol.iterator](): Iterator<A, any, any>;
+    arrayIterator(): Iterator<A[], any, any>;
+    reverseArrayIterator: () => Iterator<A[], any, any>;
 }
 export declare class Slice<A> extends ConcImplementation<A> {
     readonly conc: ConcImplementation<A>;
@@ -179,8 +179,8 @@ export declare class Chunk<A> extends ConcImplementation<A> {
     forEach<B>(startIndex: number, f: (i: number, a: A) => B): void;
     copyToArray(n: number, dest: Array<A> | Uint8Array): void;
     [Symbol.iterator](): Iterator<A>;
-    arrayIterator(): Iterator<readonly A[], any, undefined>;
-    reverseArrayIterator: () => Iterator<readonly A[], any, undefined>;
+    arrayIterator(): Iterator<readonly A[], any, any>;
+    reverseArrayIterator: () => Iterator<readonly A[], any, any>;
 }
 export declare class ByteChunk<A> extends ConcImplementation<A> {
     readonly _array: Uint8Array;

package/collection/immutable/Conc.d.ts

@@ -1,6 +1,6 @@
-export * from "./Conc/definition.js";
-export * from "./Conc/constructors.js";
 export * from "./Conc/api.js";
-export * from "./Conc/api/replicate.js";
-export * from "./Conc/api/makeBy.js";
+export * from "./Conc/constructors.js";
+export * from "./Conc/definition.js";
 export * from "./Conc/api/empty.js";
+export * from "./Conc/api/makeBy.js";
+export * from "./Conc/api/replicate.js";

package/collection/immutable/Dictionary.d.ts

@@ -1,2 +1,2 @@
-export * from "./Dictionary/definition.js";
 export * from "./Dictionary/api.js";
+export * from "./Dictionary/definition.js";

package/collection/immutable/HashMap.d.ts

@@ -1,2 +1,2 @@
-export * from "./HashMap/definition.js";
 export * from "./HashMap/api.js";
+export * from "./HashMap/definition.js";

package/collection/immutable/HashSet.d.ts

@@ -1,2 +1,2 @@
-export * from "./HashSet/definition.js";
 export * from "./HashSet/api.js";
+export * from "./HashSet/definition.js";

package/collection/immutable/ImmutableArray/api.d.ts

@@ -31,7 +31,7 @@ export declare function alt<B>(that: Lazy<ImmutableArray<B>>): <A>(self: Immutab
  * @tsplus pipeable fncts.ImmutableArray ap
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function ap<A>(fa: ImmutableArray<A>): <B>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<(a: A) => B>) => ImmutableArray<B>;
+export declare function ap<A>(fa: ImmutableArray<A>): <B>(self: ImmutableArray<(a: A) => B>) => ImmutableArray<B>;
 /**
  * @tsplus pipeable fncts.ImmutableArray append
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -153,7 +153,7 @@ export declare function everyWithIndex<A>(p: PredicateWithIndex<number, A>): (se
  * @tsplus pipeable fncts.ImmutableArray some
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function some<A>(p: Predicate<A>): (self: ImmutableArray<A>) => self is import("../ImmutableNonEmptyArray").ImmutableNonEmptyArray<A>;
+export declare function some<A>(p: Predicate<A>): (self: ImmutableArray<A>) => self is ImmutableNonEmptyArray<A>;
 /**
  * @tsplus pipeable fncts.ImmutableArray filter
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -570,22 +570,22 @@ export declare function updateAt<A>(i: number, a: A): (as: ImmutableArray<A>) =>
  * @tsplus getter fncts.ImmutableArray wiltWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function _wiltWithIndex<A>(self: ImmutableArray<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B, B2>(f: (i: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("@fncts/base/data/Either").Either<B, B2>>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, readonly [import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B2>]>;
+export declare function _wiltWithIndex<A>(self: ImmutableArray<A>): <G extends HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B, B2>(f: (i: number, a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Either<B, B2>>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, readonly [ImmutableArray<B>, ImmutableArray<B2>]>;
 /**
  * @tsplus getter fncts.ImmutableArray wilt
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function _wilt<A>(self: ImmutableArray<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B, B2>(f: (a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("@fncts/base/data/Either").Either<B, B2>>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, readonly [import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B2>]>;
+export declare function _wilt<A>(self: ImmutableArray<A>): <G extends HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B, B2>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Either<B, B2>>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, readonly [ImmutableArray<B>, ImmutableArray<B2>]>;
 /**
  * @tsplus getter fncts.ImmutableArray witherWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function _witherWithIndex<A>(self: ImmutableArray<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (i: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("../../../data/Maybe").Maybe<B>>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>>;
+export declare function _witherWithIndex<A>(self: ImmutableArray<A>): <G extends HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (i: number, a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Maybe<B>>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, ImmutableArray<B>>;
 /**
  * @tsplus getter fncts.ImmutableArray wither
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function _wither<A>(self: ImmutableArray<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("../../../data/Maybe").Maybe<B>>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>>;
+export declare function _wither<A>(self: ImmutableArray<A>): <G extends HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Maybe<B>>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, ImmutableArray<B>>;
 export declare const wiltWithIndex: P.WitherableWithIndex<ImmutableArrayF>["wiltWithIndex"];
 export declare const wilt: P.WitherableWithIndex<ImmutableArrayF>["wilt"];
 export declare const witherWithIndex: P.WitherableWithIndex<ImmutableArrayF>["witherWithIndex"];

package/collection/immutable/ImmutableArray/definition.d.ts

@@ -25,7 +25,7 @@ export declare class ImmutableArray<A> implements Equatable, Hashable, Iterable<
     constructor(_array: ReadonlyArray<A>);
     [Symbol.equals](that: unknown): boolean;
     get [Symbol.hash](): number;
-    [Symbol.iterator](): IterableIterator<A>;
+    [Symbol.iterator](): ArrayIterator<A>;
 }
 /**
  * @tsplus static fncts.ImmutableArrayOps is

package/collection/immutable/ImmutableArray.d.ts

@@ -1,8 +1,8 @@
-export * from "./ImmutableArray/instances.js";
-export * from "./ImmutableArray/definition.js";
-export * from "./ImmutableArray/constructors.js";
 export * from "./ImmutableArray/api.js";
-export * from "./ImmutableArray/api/splitWhere.js";
-export * from "./ImmutableArray/api/splitAt.js";
-export * from "./ImmutableArray/api/slice.js";
+export * from "./ImmutableArray/constructors.js";
+export * from "./ImmutableArray/definition.js";
+export * from "./ImmutableArray/instances.js";
 export * from "./ImmutableArray/api/chunksOf.js";
+export * from "./ImmutableArray/api/slice.js";
+export * from "./ImmutableArray/api/splitAt.js";
+export * from "./ImmutableArray/api/splitWhere.js";

package/collection/immutable/ImmutableNonEmptyArray.d.ts

@@ -1,5 +1,5 @@
-export * from "./ImmutableNonEmptyArray/instances.js";
-export * from "./ImmutableNonEmptyArray/destructors.js";
-export * from "./ImmutableNonEmptyArray/definition.js";
-export * from "./ImmutableNonEmptyArray/constructors.js";
 export * from "./ImmutableNonEmptyArray/api.js";
+export * from "./ImmutableNonEmptyArray/constructors.js";
+export * from "./ImmutableNonEmptyArray/definition.js";
+export * from "./ImmutableNonEmptyArray/destructors.js";
+export * from "./ImmutableNonEmptyArray/instances.js";

package/collection/immutable/List.d.ts

@@ -1,5 +1,5 @@
-export * from "./List/definition.js";
-export * from "./List/constructors.js";
 export * from "./List/api.js";
-export * from "./List/api/unsafeTail.js";
+export * from "./List/constructors.js";
+export * from "./List/definition.js";
 export * from "./List/api/foldLeft.js";
+export * from "./List/api/unsafeTail.js";

package/collection/immutable/Queue/definition.d.ts

@@ -7,6 +7,6 @@ export declare class Queue<A> implements Iterable<A> {
     _in: List<A>;
     _out: List<A>;
     constructor(_in: List<A>, _out: List<A>);
-    [Symbol.iterator](): Iterator<A, any, undefined>;
+    [Symbol.iterator](): Iterator<A, any, any>;
 }
 export declare const EmptyQueue: Queue<never>;

package/collection/immutable/Queue.d.ts

@@ -1,4 +1,4 @@
-export * from "./Queue/guards.js";
-export * from "./Queue/definition.js";
-export * from "./Queue/constructors.js";
 export * from "./Queue/api.js";
+export * from "./Queue/constructors.js";
+export * from "./Queue/definition.js";
+export * from "./Queue/guards.js";

package/collection/immutable/RoseTree.d.ts

@@ -1,2 +1,2 @@
-export * from "./RoseTree/definition.js";
 export * from "./RoseTree/api.js";
+export * from "./RoseTree/definition.js";

package/collection/immutable/SortedMap.d.ts

@@ -1,5 +1,5 @@
-export * from "./SortedMap/node.js";
-export * from "./SortedMap/iterator.js";
-export * from "./SortedMap/internal.js";
-export * from "./SortedMap/definition.js";
 export * from "./SortedMap/api.js";
+export * from "./SortedMap/definition.js";
+export * from "./SortedMap/internal.js";
+export * from "./SortedMap/iterator.js";
+export * from "./SortedMap/node.js";

package/collection/immutable/Vector/api.d.ts

@@ -577,7 +577,7 @@ export declare function _traverseWithIndex<A>(self: Vector<A>): <G extends HKT,
  * @tsplus getter fncts.Vector traverse
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function _traverse<A>(self: Vector<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("@fncts/base/collection/immutable/Vector/definition").Vector<B>>;
+export declare function _traverse<A>(self: Vector<A>): <G extends HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Vector<B>>;
 export declare const traverseWithIndex: P.TraversableWithIndex<VectorF>["traverseWithIndex"];
 export declare const traverse: Traversable<VectorF>["traverse"];
 /**

package/collection/immutable/Vector.d.ts

@@ -1,2 +1,2 @@
-export * from "./Vector/definition.js";
 export * from "./Vector/api.js";
+export * from "./Vector/definition.js";

package/control/Eval/api.d.ts

@@ -35,7 +35,7 @@ export declare function zip<B>(fb: Eval<B>): <A>(self: Eval<A>) => Eval<Zipped.M
  * @tsplus pipeable fncts.control.Eval ap
  * @tsplus location "@fncts/base/control/Eval/api"
  */
-export declare function ap<A>(fa: Eval<A>): <B>(self: import("@fncts/base/control/Eval/definition").Eval<(a: A) => B>) => Eval<B>;
+export declare function ap<A>(fa: Eval<A>): <B>(self: Eval<(a: A) => B>) => Eval<B>;
 /**
  * @tsplus static fncts.control.EvalOps sequenceT
  * @tsplus location "@fncts/base/control/Eval/api"

package/control/Eval/definition.d.ts

@@ -40,7 +40,7 @@ export declare const Eval: EvalOps;
 export declare const enum EvalTag {
     Value = 0,
     Defer = 1,
-    Chain = 2
+    FlatMap = 2
 }
 export interface Value extends EvalOp<EvalTag.Value, {
     readonly i0: any;
@@ -50,14 +50,14 @@ export interface Defer extends EvalOp<EvalTag.Defer, {
     readonly i0: () => Primitive;
 }> {
 }
-export interface FlatMap extends EvalOp<EvalTag.Chain, {
+export interface FlatMap extends EvalOp<EvalTag.FlatMap, {
     readonly i0: Primitive;
     readonly i1: (a: any) => Primitive;
 }> {
 }
 type Primitive = Value | Defer | FlatMap;
 /**
- * @tsplus smart:remove
+ * @tsplus optimize remove
  */
 export declare function concrete(_: Eval<any>): asserts _ is Primitive;
 /**

package/control/Eval.d.ts

@@ -1,5 +1,5 @@
-export * from "./Eval/run.js";
-export * from "./Eval/instance.js";
-export * from "./Eval/definition.js";
-export * from "./Eval/constructors.js";
 export * from "./Eval/api.js";
+export * from "./Eval/constructors.js";
+export * from "./Eval/definition.js";
+export * from "./Eval/instance.js";
+export * from "./Eval/run.js";

package/control/Pure/api.d.ts

@@ -16,7 +16,7 @@ export declare function absolve<W, S1, S2, R, E, E1, A>(fa: Pure<W, S1, S2, R, E
  * @tsplus pipeable fncts.control.Pure ap
  * @tsplus location "@fncts/base/control/Pure/api"
  */
-export declare function ap<W, S, A, R1, E1>(fb: Pure<W, S, S, R1, E1, A>): <R, E, B>(self: import("@fncts/base/control/Pure/definition").Pure<W, S, S, R, E, (a: A) => B>) => Pure<W, S, S, R & R1, E | E1, B>;
+export declare function ap<W, S, A, R1, E1>(fb: Pure<W, S, S, R1, E1, A>): <R, E, B>(self: Pure<W, S, S, R, E, (a: A) => B>) => Pure<W, S, S, R & R1, E | E1, B>;
 /**
  * @tsplus pipeable fncts.control.Pure zipLeft
  * @tsplus location "@fncts/base/control/Pure/api"

package/control/Pure.d.ts

@@ -1,4 +1,4 @@
-export * from "./Pure/runtime.js";
-export * from "./Pure/instances.js";
-export * from "./Pure/definition.js";
 export * from "./Pure/api.js";
+export * from "./Pure/definition.js";
+export * from "./Pure/instances.js";
+export * from "./Pure/runtime.js";

package/data/Cause.d.ts

@@ -1,7 +1,7 @@
-export * from "./Cause/definition.js";
 export * from "./Cause/api.js";
-export * from "./Cause/api/unified.js";
-export * from "./Cause/api/prettyPrint.js";
-export * from "./Cause/api/linearize.js";
-export * from "./Cause/api/isEmpty.js";
+export * from "./Cause/definition.js";
 export * from "./Cause/api/fold.js";
+export * from "./Cause/api/isEmpty.js";
+export * from "./Cause/api/linearize.js";
+export * from "./Cause/api/prettyPrint.js";
+export * from "./Cause/api/unified.js";

package/data/Const.d.ts

@@ -1,3 +1,3 @@
-export * from "./Const/instances.js";
-export * from "./Const/definition.js";
 export * from "./Const/api.js";
+export * from "./Const/definition.js";
+export * from "./Const/instances.js";

package/data/Datum/api.d.ts

@@ -175,7 +175,7 @@ export declare function toReplete<A>(self: Datum<A>): Datum<A>;
  * @tsplus getter fncts.Datum traverse
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function _traverse<A>(self: Datum<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E1, B>(f: (a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, import("@fncts/base/data/Datum/definition").Datum<B>>;
+export declare function _traverse<A>(self: Datum<A>): <G extends HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E1, B>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, Datum<B>>;
 export declare const traverse: P.Traversable<DatumF>["traverse"];
 /**
  * @tsplus pipeable fncts.Datum zip

package/data/DatumEither/api.d.ts

@@ -157,7 +157,7 @@ export declare const toReplete: <E, A>(self: DatumEither<E, A>) => DatumEither<E
  * @tsplus getter fncts.DatumEither traverse
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function _traverse<E, A>(self: DatumEither<E, A>): <G extends import("@fncts/typelevel/HKT.js").HKT, GC = import("@fncts/typelevel/HKT.js").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E1, B>(f: (a: A) => import("@fncts/typelevel/HKT.js").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => import("@fncts/typelevel/HKT.js").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, import("@fncts/base/data/DatumEither/definition").DatumEither<E, B>>;
+export declare function _traverse<E, A>(self: DatumEither<E, A>): <G extends HKT, GC = import("@fncts/typelevel/HKT.js").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E1, B>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, DatumEither<E, B>>;
 export declare const traverse: P.Traversable<DatumEitherF>["traverse"];
 /**
  * @tsplus pipeable fncts.DatumEither zipWith

package/data/DatumEither.d.ts

@@ -1,2 +1,2 @@
-export * from "./DatumEither/definition.js";
 export * from "./DatumEither/api.js";
+export * from "./DatumEither/definition.js";

package/data/Duration.d.ts

@@ -1,2 +1,2 @@
-export * from "./Duration/definition.js";
 export * from "./Duration/api.js";
+export * from "./Duration/definition.js";

package/data/Either/api.d.ts

@@ -11,7 +11,7 @@ import { Left, Right } from "./definition.js";
  * @tsplus pipeable fncts.Either ap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function ap<A, E2>(fa: Either<E2, A>): <E1, B>(self: import("./definition.js").Either<E1, (a: A) => B>) => Either<E1 | E2, B>;
+export declare function ap<A, E2>(fa: Either<E2, A>): <E1, B>(self: Either<E1, (a: A) => B>) => Either<E1 | E2, B>;
 /**
  * @tsplus pipeable fncts.Either bimap
  * @tsplus location "@fncts/base/data/Either/api"
@@ -114,7 +114,7 @@ export declare function swap<E, A>(self: Either<E, A>): Either<A, E>;
  * @tsplus getter fncts.Either traverse
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function _traverse<E, A>(self: Either<E, A>): <G extends import("@fncts/typelevel/HKT.js").HKT, GC = import("@fncts/typelevel/HKT.js").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E1, B>(f: (a: A) => import("@fncts/typelevel/HKT.js").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => import("@fncts/typelevel/HKT.js").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, import("./definition.js").Either<E, B>>;
+export declare function _traverse<E, A>(self: Either<E, A>): <G extends HKT, GC = import("@fncts/typelevel/HKT.js").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E1, B>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, Either<E, B>>;
 export declare const traverse_: P.Traversable<EitherF>["traverse"];
 /**
  * @tsplus pipeable fncts.Either zipWith
@@ -151,5 +151,5 @@ export declare function partition<E, A>(p: Predicate<A>, /** @tsplus auto */ M:
  * @tsplus location "@fncts/base/data/Either/api"
  */
 export declare function toMaybe<E, A>(self: Either<E, A>): Maybe<A>;
-export * from "./api/alignWith.js";
 export * from "./api/align.js";
+export * from "./api/alignWith.js";

package/data/Either.d.ts

@@ -1,5 +1,5 @@
-export * from "./Either/instances.js";
-export * from "./Either/destructors.js";
-export * from "./Either/definition.js";
-export * from "./Either/constructors.js";
 export * from "./Either/api.js";
+export * from "./Either/constructors.js";
+export * from "./Either/definition.js";
+export * from "./Either/destructors.js";
+export * from "./Either/instances.js";

package/data/EitherT/api.d.ts

@@ -32,22 +32,22 @@ export declare function leftF<F extends HKT, FC>(F: P.Functor<F, FC>): <K, Q, W,
  * @tsplus static fncts.EitherTOps map
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function map<F extends HKT, FC>(F: P.Functor<F, FC>): <A, B>(f: (a: A) => B) => <K, Q, W, X, I, S, R, FE, E>(self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, B>;
+export declare function map<F extends HKT, FC>(F: P.Functor<F, FC>): <A, B>(f: (a: A) => B) => (<K, Q, W, X, I, S, R, FE, E>(self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, B>);
 /**
  * @tsplus static fncts.EitherTOps mapLeft
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function mapLeft<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>): <E, E1>(f: (e: E) => E1) => <K, Q, W, X, I, S, R, FE, A>(self: import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E, A>>) => import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E1, A>>;
+export declare function mapLeft<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>): <E, E1>(f: (e: E) => E1) => (<K, Q, W, X, I, S, R, FE, A>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E1, A>>);
 /**
  * @tsplus static fncts.EitherTOps bimap
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function bimap<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>): <E, A, E1, B>(f: (e: E) => E1, g: (a: A) => B) => <K, Q, W, X, I, S, R, FE>(self: import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E, A>>) => import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E1, B>>;
+export declare function bimap<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>): <E, A, E1, B>(f: (e: E) => E1, g: (a: A) => B) => (<K, Q, W, X, I, S, R, FE>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E1, B>>);
 /**
  * @tsplus static fncts.EitherTOps flatMap
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>): <K, Q, W, X, I, S, R, FE, A, K1, Q1, W1, X1, I1, S1, R1, FE1, E1, B>(f: (a: A) => HKT.Kind<F, FC, HKT.Intro<F, "K", K, K1>, HKT.Intro<F, "Q", Q, Q1>, HKT.Intro<F, "W", W, W1>, HKT.Intro<F, "X", X, X1>, HKT.Intro<F, "I", I, I1>, HKT.Intro<F, "S", S, S1>, HKT.Intro<F, "R", R, R1>, HKT.Intro<F, "E", FE, FE1>, Either<E1, B>>) => <E>(self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>) => EitherT<F, FC, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "K", [K, K1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "Q", [Q, Q1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "W", [W, W1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "X", [X, X1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "I", [I, I1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "S", [S, S1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "R", [R, R1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "E", [FE, FE1]>, E1 | E, B>;
+export declare function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>): <K, Q, W, X, I, S, R, FE, A, K1, Q1, W1, X1, I1, S1, R1, FE1, E1, B>(f: (a: A) => HKT.Kind<F, FC, HKT.Intro<F, "K", K, K1>, HKT.Intro<F, "Q", Q, Q1>, HKT.Intro<F, "W", W, W1>, HKT.Intro<F, "X", X, X1>, HKT.Intro<F, "I", I, I1>, HKT.Intro<F, "S", S, S1>, HKT.Intro<F, "R", R, R1>, HKT.Intro<F, "E", FE, FE1>, Either<E1, B>>) => (<E>(self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>) => EitherT<F, FC, HKT.Mix<F, "K", [K, K1]>, HKT.Mix<F, "Q", [Q, Q1]>, HKT.Mix<F, "W", [W, W1]>, HKT.Mix<F, "X", [X, X1]>, HKT.Mix<F, "I", [I, I1]>, HKT.Mix<F, "S", [S, S1]>, HKT.Mix<F, "R", [R, R1]>, HKT.Mix<F, "E", [FE, FE1]>, E | E1, B>);
 /**
  * @tsplus static fncts.EitherTOps zipWith
  * @tsplus location "@fncts/base/data/EitherT/api"

package/data/Environment.d.ts

@@ -1,3 +1,3 @@
-export * from "./Environment/definition.js";
 export * from "./Environment/api.js";
+export * from "./Environment/definition.js";
 export * from "./Environment/ServiceNotFoundError.js";

package/data/Equatable.d.ts

@@ -1,3 +1,3 @@
-export * from "./Equatable/fast-equals.js";
-export * from "./Equatable/definition.js";
 export * from "./Equatable/api.js";
+export * from "./Equatable/definition.js";
+export * from "./Equatable/fast-equals.js";

package/data/Exit/api.d.ts

@@ -6,7 +6,7 @@ import { Cause } from "@fncts/base/data/Cause/definition";
  * @tsplus pipeable fncts.Exit ap
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function ap<E, A>(that: Exit<E, A>): <G, B>(self: import("./definition.js").Exit<G, (a: A) => B>) => Exit<E | G, B>;
+export declare function ap<E, A>(that: Exit<E, A>): <G, B>(self: Exit<G, (a: A) => B>) => Exit<E | G, B>;
 /**
  * @tsplus pipeable fncts.Exit zipLeft
  * @tsplus location "@fncts/base/data/Exit/api"

package/data/Exit.d.ts

@@ -1,3 +1,3 @@
-export * from "./Exit/definition.js";
-export * from "./Exit/constructors.js";
 export * from "./Exit/api.js";
+export * from "./Exit/constructors.js";
+export * from "./Exit/definition.js";

package/data/FiberId/definition.d.ts

@@ -6,7 +6,7 @@ export type FiberIdTypeId = typeof FiberIdTypeId;
 export declare class None implements Hashable, Equatable {
     readonly [FiberIdTypeId]: FiberIdTypeId;
     readonly _tag = "None";
-    [Symbol.equals](that: unknown): boolean;
+    [Symbol.equals](that: unknown): that is None;
     get [Symbol.hash](): number;
 }
 export declare class Runtime implements Hashable, Equatable {

package/data/FiberId.d.ts

@@ -1,3 +1,3 @@
-export * from "./FiberId/definition.js";
-export * from "./FiberId/constructors.js";
 export * from "./FiberId/api.js";
+export * from "./FiberId/constructors.js";
+export * from "./FiberId/definition.js";

package/data/Guard/api.d.ts

@@ -224,7 +224,7 @@ export declare function deriveValidation<A extends Brand.Valid<any, any>>(...[ba
  * @tsplus static fncts.GuardOps validation
  * @tsplus location "@fncts/base/data/Guard/api"
  */
-export declare function validation<A, B extends ReadonlyArray<Validation<A, any>>>(...validations: B): (base: Guard<A>) => Guard<A & { [K in keyof B]: B[K] extends Validation<any, infer S extends string> ? Brand.Valid<A, S> : never; }[number]>;
+export declare function validation<A, B extends ReadonlyArray<Validation<A, any>>>(...validations: B): (base: Guard<A>) => Guard<A & { [K in keyof B]: B[K] extends Validation<any, infer S> ? Brand.Valid<A, S> : never; }[number]>;
 /**
  * @tsplus derive fncts.Guard<_> 10
  * @tsplus location "@fncts/base/data/Guard/api"

package/data/Guard.d.ts

@@ -1,2 +1,2 @@
-export * from "./Guard/definition.js";
 export * from "./Guard/api.js";
+export * from "./Guard/definition.js";

package/data/Hashable.d.ts

@@ -1,2 +1,2 @@
-export * from "./Hashable/hash.js";
 export * from "./Hashable/definition.js";
+export * from "./Hashable/hash.js";