@fncts/base 0.0.32 → 0.0.33

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

@@ -271,7 +271,10 @@ export class Concat<A> extends ConcImplementation<A> {
   length        = this.left.length + this.right.length;
   depth         = 1 + Math.max(this.left.depth, this.right.depth);
   binary        = this.left.binary && this.right.binary;
-  constructor(readonly left: ConcImplementation<A>, readonly right: ConcImplementation<A>) {
+  constructor(
+    readonly left: ConcImplementation<A>,
+    readonly right: ConcImplementation<A>,
+  ) {
     super();
   }
   get(n: number): A {
@@ -588,7 +591,11 @@ export class Slice<A> extends ConcImplementation<A> {
   left  = _Empty;
   right = _Empty;
 
-  constructor(readonly conc: ConcImplementation<A>, readonly offset: number, readonly l: number) {
+  constructor(
+    readonly conc: ConcImplementation<A>,
+    readonly offset: number,
+    readonly l: number,
+  ) {
     super();
     if (this.conc.depth >= MAX_CONC_DEPTH) {
       this.conc = this.conc.materialize();

package/_src/collection/immutable/Conc.ts

@@ -1,11 +1,13 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Conc/*.ts }
-export * from "./Conc/api.js";
-export * from "./Conc/constructors.js";
 export * from "./Conc/definition.js";
+export * from "./Conc/constructors.js";
+export * from "./Conc/api.js";
 // codegen:end
 
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Conc/api/*.ts }
-export * from "./Conc/api/empty.js";
-export * from "./Conc/api/makeBy.js";
 export * from "./Conc/api/replicate.js";
+export * from "./Conc/api/makeBy.js";
+export * from "./Conc/api/empty.js";
 // codegen:end

package/_src/collection/immutable/Dictionary.ts

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

package/_src/collection/immutable/HashMap/api.ts

@@ -537,6 +537,43 @@ export function partition<V>(predicate: Predicate<V>) {
   };
 }
 
+/**
+ * Reduce a state over the map entries
+ *
+ * @tsplus pipeable fncts.HashMap foldLeftWithIndexWhile
+ */
+export function foldLeftWithIndexWhile<K, V, Z>(z: Z, f: (k: K, z: Z, v: V) => Z, p: Predicate<Z>) {
+  return (self: HashMap<K, V>): Z => {
+    const root = self.root;
+    if (root._tag === "LeafNode") return root.value.isJust() ? f(root.key, z, root.value.value) : z;
+    if (root._tag === "EmptyNode") {
+      return z;
+    }
+    const toVisit = [root.children];
+    let children;
+    let acc       = z;
+    loop: while ((children = toVisit.pop())) {
+      for (let i = 0, len = children.length; i < len; ) {
+        const child = children[i++];
+        if (child && !isEmptyNode(child)) {
+          if (child._tag === "LeafNode") {
+            if (child.value.isJust()) {
+              // eslint-disable-next-line no-param-reassign
+              acc = f(child.key, acc, child.value.value);
+              if (p(acc)) {
+                break loop;
+              }
+            }
+          } else {
+            toVisit.push(child.children);
+          }
+        }
+      }
+    }
+    return acc;
+  };
+}
+
 /**
  * Reduce a state over the map entries
  *
@@ -571,6 +608,17 @@ export function foldLeftWithIndex<K, V, Z>(z: Z, f: (k: K, z: Z, v: V) => Z) {
   };
 }
 
+/**
+ * Reduce a state over the map entries
+ *
+ * @tsplus pipeable fncts.HashMap foldLeftWhile
+ */
+export function foldLeftWhile<V, Z>(z: Z, f: (z: Z, v: V) => Z, p: Predicate<Z>) {
+  return <K>(self: HashMap<K, V>): Z => {
+    return self.foldLeftWithIndexWhile(z, (_, z, v) => f(z, v), p);
+  };
+}
+
 /**
  * Reduce a state over the map entries
  *
@@ -582,6 +630,34 @@ export function foldLeft<V, Z>(z: Z, f: (z: Z, v: V) => Z) {
   };
 }
 
+/**
+ * @tsplus pipeable fncts.HashMap findWithIndex
+ */
+export function findWithIndex<K, V, B extends V>(p: RefinementWithIndex<K, V, B>): (self: HashMap<K, V>) => Maybe<B>;
+export function findWithIndex<K, V>(p: PredicateWithIndex<K, V>): (self: HashMap<K, V>) => Maybe<V>;
+export function findWithIndex<K, V>(p: PredicateWithIndex<K, V>) {
+  return (self: HashMap<K, V>): Maybe<V> =>
+    self.foldLeftWithIndexWhile(
+      Nothing(),
+      (k, _, v) => (p(k, v) ? Just(v) : Nothing()),
+      (v) => v.isNothing(),
+    );
+}
+
+/**
+ * @tsplus pipeable fncts.HashMap find
+ */
+export function find<V, B extends V>(p: Refinement<V, B>): <K>(self: HashMap<K, V>) => Maybe<B>;
+export function find<V>(p: Predicate<V>): <K>(self: HashMap<K, V>) => Maybe<V>;
+export function find<V>(p: Predicate<V>) {
+  return <K>(self: HashMap<K, V>): Maybe<V> =>
+    self.foldLeftWhile(
+      Nothing(),
+      (_, v) => (p(v) ? Just(v) : Nothing()),
+      (v) => v.isNothing(),
+    );
+}
+
 /**
  * @tsplus getter fncts.HashMap traverseWithIndex
  */

package/_src/collection/immutable/HashMap/definition.ts

@@ -70,7 +70,10 @@ export function isHashMap(u: unknown): u is HashMap<unknown, unknown> {
 export class HashMapIterator<K, V, T> implements IterableIterator<T> {
   v: Maybe<VisitResult<K, V, T>>;
 
-  constructor(readonly map: HashMap<K, V>, readonly f: (node: readonly [K, V]) => T) {
+  constructor(
+    readonly map: HashMap<K, V>,
+    readonly f: (node: readonly [K, V]) => T,
+  ) {
     this.v = visitLazy(this.map.root, this.f, undefined);
   }
 

package/_src/collection/immutable/HashMap/internal.ts

@@ -135,7 +135,12 @@ export type UpdateFn<V> = (v: Maybe<V>) => Maybe<V>;
 
 export class LeafNode<K, V> {
   readonly _tag = "LeafNode";
-  constructor(readonly edit: number, readonly hash: number, readonly key: K, public value: Maybe<V>) {}
+  constructor(
+    readonly edit: number,
+    readonly hash: number,
+    readonly key: K,
+    public value: Maybe<V>,
+  ) {}
 
   modify(
     edit: number,
@@ -169,7 +174,11 @@ export class LeafNode<K, V> {
 
 export class CollisionNode<K, V> {
   readonly _tag = "CollisionNode";
-  constructor(public edit: number, public hash: number, public children: Array<Node<K, V>>) {}
+  constructor(
+    public edit: number,
+    public hash: number,
+    public children: Array<Node<K, V>>,
+  ) {}
 
   modify(
     edit: number,
@@ -227,7 +236,11 @@ function updateCollisionList<K, V>(
 
 export class IndexedNode<K, V> {
   readonly _tag = "IndexedNode";
-  constructor(public edit: number, public mask: number, public children: Array<Node<K, V>>) {}
+  constructor(
+    public edit: number,
+    public mask: number,
+    public children: Array<Node<K, V>>,
+  ) {}
 
   modify(
     edit: number,
@@ -281,7 +294,11 @@ export class IndexedNode<K, V> {
 
 export class ArrayNode<K, V> {
   readonly _tag = "ArrayNode";
-  constructor(public edit: number, public size: number, public children: Array<Node<K, V>>) {}
+  constructor(
+    public edit: number,
+    public size: number,
+    public children: Array<Node<K, V>>,
+  ) {}
 
   modify(
     edit: number,

package/_src/collection/immutable/HashMap.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: HashMap/*.ts, exclude: HashMap/internal.ts }
-export * from "./HashMap/api.js";
 export * from "./HashMap/definition.js";
+export * from "./HashMap/api.js";
 // codegen:end

package/_src/collection/immutable/HashSet/definition.ts

@@ -84,7 +84,10 @@ export function isHashSet(u: unknown): u is HashSet<unknown> {
 class HashSetIterator<A, T> implements IterableIterator<T> {
   v: VisitResult<A, T> | undefined;
 
-  constructor(readonly set: HashSet<A>, readonly f: (node: A) => T) {
+  constructor(
+    readonly set: HashSet<A>,
+    readonly f: (node: A) => T,
+  ) {
     this.v = visitLazy(this.set._root, this.f, undefined);
   }
 
@@ -144,7 +147,11 @@ export function isEmptyNode<A>(n: Node<A>): n is EmptyNode<A> {
 
 export class LeafNode<A> {
   readonly _tag = "LeafNode";
-  constructor(public edit: number, public hash: number, public value: A) {}
+  constructor(
+    public edit: number,
+    public hash: number,
+    public value: A,
+  ) {}
 
   modify(
     remove: boolean,
@@ -179,7 +186,11 @@ export class LeafNode<A> {
 
 export class CollisionNode<A> {
   readonly _tag = "CollisionNode";
-  constructor(public edit: number, public hash: number, public children: Array<Node<A>>) {}
+  constructor(
+    public edit: number,
+    public hash: number,
+    public children: Array<Node<A>>,
+  ) {}
   modify(
     remove: boolean,
     edit: number,
@@ -234,7 +245,11 @@ export function isLeaf<A>(node: Node<A>): node is EmptyNode<A> | LeafNode<A> | C
 
 export class IndexedNode<A> {
   readonly _tag = "IndexedNode";
-  constructor(public edit: number, public mask: number, public children: Array<Node<A>>) {}
+  constructor(
+    public edit: number,
+    public mask: number,
+    public children: Array<Node<A>>,
+  ) {}
 
   modify(
     remove: boolean,
@@ -283,7 +298,11 @@ export class IndexedNode<A> {
 
 export class ArrayNode<A> {
   readonly _tag = "ArrayNode";
-  constructor(public edit: number, public size: number, public children: Array<Node<A>>) {}
+  constructor(
+    public edit: number,
+    public size: number,
+    public children: Array<Node<A>>,
+  ) {}
   modify(
     remove: boolean,
     edit: number,

package/_src/collection/immutable/HashSet.ts

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

package/_src/collection/immutable/ImmutableArray.ts

@@ -1,13 +1,15 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./ImmutableArray/*.ts }
-export * from "./ImmutableArray/api.js";
-export * from "./ImmutableArray/constructors.js";
-export * from "./ImmutableArray/definition.js";
 export * from "./ImmutableArray/instances.js";
+export * from "./ImmutableArray/definition.js";
+export * from "./ImmutableArray/constructors.js";
+export * from "./ImmutableArray/api.js";
 // codegen:end
 
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./ImmutableArray/api/*.ts }
-export * from "./ImmutableArray/api/chunksOf.js";
-export * from "./ImmutableArray/api/slice.js";
-export * from "./ImmutableArray/api/splitAt.js";
 export * from "./ImmutableArray/api/splitWhere.js";
+export * from "./ImmutableArray/api/splitAt.js";
+export * from "./ImmutableArray/api/slice.js";
+export * from "./ImmutableArray/api/chunksOf.js";
 // codegen:end

package/_src/collection/immutable/ImmutableNonEmptyArray.ts

@@ -1,7 +1,8 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ImmutableNonEmptyArray/*.ts }
-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";
+export * from "./ImmutableNonEmptyArray/destructors.js";
+export * from "./ImmutableNonEmptyArray/definition.js";
+export * from "./ImmutableNonEmptyArray/constructors.js";
+export * from "./ImmutableNonEmptyArray/api.js";
 // codegen:end

package/_src/collection/immutable/List/definition.ts

@@ -22,7 +22,10 @@ export type ListTypeId = typeof ListTypeId;
 export class Cons<A> implements Iterable<A> {
   readonly _tag                     = "Cons";
   readonly [ListTypeId]: ListTypeId = ListTypeId;
-  constructor(readonly head: A, public tail: List<A> = _Nil) {}
+  constructor(
+    readonly head: A,
+    public tail: List<A> = _Nil,
+  ) {}
 
   [Symbol.iterator](): Iterator<A> {
     let done = false;

package/_src/collection/immutable/List.ts

@@ -1,9 +1,11 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: List/*.ts }
-export * from "./List/api.js";
-export * from "./List/constructors.js";
 export * from "./List/definition.js";
+export * from "./List/constructors.js";
+export * from "./List/api.js";
 // codegen:end
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: "./List/api/*.ts" }
-export * from "./List/api/foldLeft.js";
 export * from "./List/api/unsafeTail.js";
+export * from "./List/api/foldLeft.js";
 // codegen:end

package/_src/collection/immutable/Queue.ts

@@ -1,6 +1,7 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Queue/*.ts }
-export * from "./Queue/api.js";
-export * from "./Queue/constructors.js";
-export * from "./Queue/definition.js";
 export * from "./Queue/guards.js";
+export * from "./Queue/definition.js";
+export * from "./Queue/constructors.js";
+export * from "./Queue/api.js";
 // codegen:end

package/_src/collection/immutable/RoseTree/definition.ts

@@ -20,7 +20,10 @@ export class RoseTree<A> implements Hashable, Equatable {
   declare [RoseTreeVariance]: {
     readonly _A: (_: never) => A;
   };
-  constructor(readonly value: A, readonly forest: Vector<RoseTree<A>>) {}
+  constructor(
+    readonly value: A,
+    readonly forest: Vector<RoseTree<A>>,
+  ) {}
 
   [Symbol.equals](that: unknown): boolean {
     return isRoseTree(that) ? Equatable.strictEquals(this.value, that.value) && this.forest == that.forest : false;

package/_src/collection/immutable/RoseTree.ts

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

package/_src/collection/immutable/SortedMap/definition.ts

@@ -14,7 +14,10 @@ export type TypeId = typeof TypeId;
 export class SortedMap<K, V> implements SortedMapIterable<K, V> {
   readonly [TypeId]: TypeId = TypeId;
 
-  constructor(readonly ord: Ord<K>, readonly root: RBNode<K, V>) {}
+  constructor(
+    readonly ord: Ord<K>,
+    readonly root: RBNode<K, V>,
+  ) {}
 
   [Symbol.iterator](): SortedMapIterator<K, V> {
     return forward(this)[Symbol.iterator]();

package/_src/collection/immutable/SortedMap/iterator.ts

@@ -41,7 +41,11 @@ export function backward<K, V>(self: SortedMap<K, V>): SortedMapIterable<K, V> {
 
 export class SortedMapIterator<K, V> implements Iterator<readonly [K, V]> {
   private count = 0;
-  constructor(readonly m: SortedMap<K, V>, readonly stack: Array<Node<K, V>>, readonly direction: 0 | 1) {}
+  constructor(
+    readonly m: SortedMap<K, V>,
+    readonly stack: Array<Node<K, V>>,
+    readonly direction: 0 | 1,
+  ) {}
 
   next(): IteratorResult<readonly [K, V]> {
     if (this.isEmpty) {

package/_src/collection/immutable/SortedMap.ts

@@ -1,7 +1,8 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./SortedMap/*.ts }
-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";
+export * from "./SortedMap/iterator.js";
+export * from "./SortedMap/internal.js";
+export * from "./SortedMap/definition.js";
+export * from "./SortedMap/api.js";
 // codegen:end

package/_src/collection/immutable/Vector/internal.ts

@@ -18,7 +18,10 @@ export abstract class VectorIterator<A> implements Iterator<A> {
   prefixSize: number;
   middleSize: number;
   result: IteratorResult<A> = { done: false, value: undefined as any };
-  constructor(protected l: Vector<A>, direction: 1 | -1) {
+  constructor(
+    protected l: Vector<A>,
+    direction: 1 | -1,
+  ) {
     this.idx        = direction === 1 ? -1 : l.length;
     this.prefixSize = getPrefixSize(l);
     this.middleSize = l.length - getSuffixSize(l);
@@ -130,7 +133,10 @@ type Sizes = number[] | undefined;
 
 /** @internal */
 export class Node {
-  constructor(public sizes: Sizes, public array: any[]) {}
+  constructor(
+    public sizes: Sizes,
+    public array: any[],
+  ) {}
 }
 
 /**

package/_src/collection/immutable/Vector.ts

@@ -1,4 +1,5 @@
-// codegen:start { preset: barrel, include: ./Vector/*.ts, exclude: ./Vector/internal.ts }
-export * from "./Vector/api.js";
+/* eslint-disable simple-import-sort/exports */
+// codegen:start { preset: barrel, include: ./Vector/*.ts, exclude: Vector/internal.ts }
 export * from "./Vector/definition.js";
+export * from "./Vector/api.js";
 // codegen:end

package/_src/collection/immutable.ts

@@ -1,13 +1,14 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: type-barrel, include: ./immutable/*.ts }
-export type {} from "./immutable/Conc.js";
-export type {} from "./immutable/Dictionary.js";
-export type {} from "./immutable/HashMap.js";
-export type {} from "./immutable/HashSet.js";
-export type {} from "./immutable/ImmutableArray.js";
-export type {} from "./immutable/ImmutableNonEmptyArray.js";
-export type {} from "./immutable/List.js";
-export type {} from "./immutable/Queue.js";
-export type {} from "./immutable/RoseTree.js";
-export type {} from "./immutable/SortedMap.js";
 export type {} from "./immutable/Vector.js";
+export type {} from "./immutable/SortedMap.js";
+export type {} from "./immutable/RoseTree.js";
+export type {} from "./immutable/Queue.js";
+export type {} from "./immutable/List.js";
+export type {} from "./immutable/ImmutableNonEmptyArray.js";
+export type {} from "./immutable/ImmutableArray.js";
+export type {} from "./immutable/HashSet.js";
+export type {} from "./immutable/HashMap.js";
+export type {} from "./immutable/Dictionary.js";
+export type {} from "./immutable/Conc.js";
 // codegen:end

package/_src/collection/mutable/ArrayDeque.ts

@@ -6,7 +6,11 @@ const DEFAULT_INITIAL_SIZE = 16;
  * @tsplus companion fncts.MutableArrayDeque
  */
 export class ArrayDeque<A> {
-  constructor(protected array: Array<A>, private start: number, private end: number) {}
+  constructor(
+    protected array: Array<A>,
+    private start: number,
+    private end: number,
+  ) {}
 
   static empty<A>(initialSize = DEFAULT_INITIAL_SIZE): ArrayDeque<A> {
     return new ArrayDeque(new Array(initialSize), 0, 0);

package/_src/collection/mutable/HashMap.ts

@@ -281,7 +281,12 @@ export class HashMap<K, V> implements Iterable<readonly [K, V]> {
 }
 
 class Node<K, V> {
-  constructor(public key: K, public hash: number, public value: V, public next: Node<K, V> | undefined) {}
+  constructor(
+    public key: K,
+    public hash: number,
+    public value: V,
+    public next: Node<K, V> | undefined,
+  ) {}
 
   findNode(k: K, h: number, equals: (y: K) => (x: K) => boolean): Node<K, V> | undefined {
     let n: Node<K, V> | undefined = this;
@@ -309,7 +314,10 @@ export class HashMapIterator<K, V, A> implements Iterator<A> {
   private i = 0;
   private len: number;
   private done = false;
-  constructor(private table: Array<Node<K, V> | undefined>, private extract: (nd: Node<K, V>) => A) {
+  constructor(
+    private table: Array<Node<K, V> | undefined>,
+    private extract: (nd: Node<K, V>) => A,
+  ) {
     this.len = table.length;
   }
 

package/_src/collection/mutable/HashSet.ts

@@ -188,7 +188,11 @@ export class HashSet<A> implements Iterable<A> {
 }
 
 class Node<K> {
-  constructor(public key: K, public hash: number, public next: Node<K> | undefined) {}
+  constructor(
+    public key: K,
+    public hash: number,
+    public next: Node<K> | undefined,
+  ) {}
 
   findNode(k: K, h: number, equals: (y: K) => (x: K) => boolean): Node<K> | undefined {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
@@ -218,7 +222,10 @@ export class HashSetIterator<V, A> implements Iterator<A> {
   private len: number;
   private i    = 0;
   private done = false;
-  constructor(private table: Array<Node<V> | undefined>, private extract: (nd: Node<V>) => A) {
+  constructor(
+    private table: Array<Node<V> | undefined>,
+    private extract: (nd: Node<V>) => A,
+  ) {
     this.len = table.length;
   }
 

package/_src/collection/mutable.ts

@@ -1,8 +1,9 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: type-barrel, include: ./mutable/*.ts }
-export type {} from "./mutable/ArrayDeque.js";
-export type {} from "./mutable/HashMap.js";
-export type {} from "./mutable/HashSet.js";
 export type {} from "./mutable/internal.js";
-export type {} from "./mutable/ListBuffer.js";
 export type {} from "./mutable/Queue.js";
+export type {} from "./mutable/ListBuffer.js";
+export type {} from "./mutable/HashSet.js";
+export type {} from "./mutable/HashMap.js";
+export type {} from "./mutable/ArrayDeque.js";
 // codegen:end

package/_src/collection/weak.ts

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

package/_src/collection.ts

@@ -1,7 +1,8 @@
-// codegen:start { preset: type-barrel, include: ./collection/*.ts }
-export type {} from "./collection/compat.js";
+/* eslint-disable simple-import-sort/exports */
+// codegen:start { preset: type-barrel, include: ./collection/*.ts, exclude: collection/internal.ts }
+export type {} from "./collection/weak.js";
+export type {} from "./collection/mutable.js";
 export type {} from "./collection/immutable.js";
+export type {} from "./collection/compat.js";
 export type {} from "./collection/Iterable.js";
-export type {} from "./collection/mutable.js";
-export type {} from "./collection/weak.js";
 // codegen:end

package/_src/control/Eval/api.ts

@@ -114,6 +114,7 @@ export function gen<T extends GenEval<any>, A>(
   });
 }
 
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: api/*.ts }
 export * from "./api/sequenceArray.js";
 // codegen:end

package/_src/control/Eval.ts

@@ -1,7 +1,8 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Eval/*.ts }
-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";
+export * from "./Eval/instance.js";
+export * from "./Eval/definition.js";
+export * from "./Eval/constructors.js";
+export * from "./Eval/api.js";
 // codegen:end

package/_src/control/Pure.ts

@@ -1,6 +1,7 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Pure/*.ts }
-export * from "./Pure/api.js";
-export * from "./Pure/definition.js";
-export * from "./Pure/instances.js";
 export * from "./Pure/runtime.js";
+export * from "./Pure/instances.js";
+export * from "./Pure/definition.js";
+export * from "./Pure/api.js";
 // codegen:end

package/_src/control.ts

@@ -1,6 +1,8 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: type-barrel, include: ./control/*.ts }
-export type {} from "./control/CompletablePromise.js";
-export type {} from "./control/Eval.js";
-export type {} from "./control/LazyValue.js";
 export type {} from "./control/Pure.js";
+export type {} from "./control/LazyValue.js";
+export type {} from "./control/InterruptiblePromise.js";
+export type {} from "./control/Eval.js";
+export type {} from "./control/CompletablePromise.js";
 // codegen:end