@fncts/base 0.0.13 → 0.0.14

package/_src/json.ts

@@ -0,0 +1,5 @@
+// codegen:start { preset: type-barrel, include: ./json/*.ts }
+export type {} from "./json/EitherJson.js";
+export type {} from "./json/MaybeJson.js";
+export type {} from "./json/TheseJson.js";
+// codegen:end

package/_src/optics.ts

@@ -0,0 +1,12 @@
+// codegen:start { preset: type-barrel, include: ./optics/*.ts }
+export type {} from "./optics/At.js";
+export type {} from "./optics/Fold.js";
+export type {} from "./optics/Getter.js";
+export type {} from "./optics/Index.js";
+export type {} from "./optics/Iso.js";
+export type {} from "./optics/Lens.js";
+export type {} from "./optics/Optional.js";
+export type {} from "./optics/Prism.js";
+export type {} from "./optics/Setter.js";
+export type {} from "./optics/Traversal.js";
+// codegen:end

package/_src/typeclass/Showable/show.ts

@@ -72,7 +72,7 @@ export interface ShowOptions {
 
 export class ShowContext extends CaseClass<ShowContextArgs> {}
 
-export type ShowComputationZ<A> = Z<never, ShowContext, ShowContext, unknown, never, A>;
+export type ShowComputationZ<A> = Z<never, ShowContext, ShowContext, never, never, A>;
 export type ShowComputation = ShowComputationZ<string>;
 export type ShowComputationChunk = ShowComputationZ<Conc<string>>;
 
@@ -240,7 +240,7 @@ function getInspectionInfo(context: ShowContext, value: object, typedArray?: str
 
   if (value[Symbol.iterator as keyof typeof value] || constructor === null) {
     noIterator = false;
-    if (Conc.isConc(value)) {
+    if (Conc.is(value)) {
       braces = [`Chunk (${(value as Conc<unknown>).length}) [`, "]"];
       if ((value as Conc<unknown>).length == 0) {
         return inspectionEarlyReturn(`${braces[0]}]`);

package/_src/util.ts

@@ -0,0 +1,8 @@
+// codegen:start { preset: type-barrel, include: ./util/*.ts }
+export type {} from "./util/AnsiFormat.js";
+export type {} from "./util/assert.js";
+export type {} from "./util/pattern.js";
+export type {} from "./util/PCGRandom.js";
+export type {} from "./util/predicates.js";
+export type {} from "./util/rand.js";
+// codegen:end

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

@@ -1,32 +1,32 @@
 import { ReadonlyNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import type { Eq } from "@fncts/base/typeclass";
 /**
- * @tsplus getter fncts.base.Array elem
- * @tsplus getter fncts.base.ReadonlyArray elem
+ * @tsplus getter fncts.Array elem
+ * @tsplus getter fncts.ReadonlyArray elem
  * @tsplus location "@fncts/base/collection/compat/Array/api"
  */
 export declare function elem<A>(self: ReadonlyArray<A>): (eq: Eq<A>) => (a: A) => boolean;
 /**
- * @tsplus fluent fncts.base.Array isEmpty
- * @tsplus fluent fncts.base.ReadonlyArray isEmpty
+ * @tsplus fluent fncts.Array isEmpty
+ * @tsplus fluent fncts.ReadonlyArray isEmpty
  * @tsplus location "@fncts/base/collection/compat/Array/api"
  */
 export declare function isEmpty<A>(self: ReadonlyArray<A>): boolean;
 /**
- * @tsplus fluent fncts.base.Array isNonEmpty
- * @tsplus fluent fncts.base.ReadonlyArray isNonEmpty
+ * @tsplus fluent fncts.Array isNonEmpty
+ * @tsplus fluent fncts.ReadonlyArray isNonEmpty
  * @tsplus location "@fncts/base/collection/compat/Array/api"
  */
 export declare function isNonEmpty<A>(self: ReadonlyArray<A>): self is ReadonlyNonEmptyArray<A>;
 /**
- * @tsplus fluent fncts.base.Array foldLeft
- * @tsplus fluent fncts.base.ReadonlyArray foldLeft
+ * @tsplus fluent fncts.Array foldLeft
+ * @tsplus fluent fncts.ReadonlyArray foldLeft
  * @tsplus location "@fncts/base/collection/compat/Array/api"
  */
 export declare function foldLeft<A, B>(self: ReadonlyArray<A>, b: B, f: (b: B, a: A) => B): B;
 /**
- * @tsplus fluent fncts.base.Array foldLeftWithIndex
- * @tsplus fluent fncts.base.ReadonlyArray foldLeftWithIndex
+ * @tsplus fluent fncts.Array foldLeftWithIndex
+ * @tsplus fluent fncts.ReadonlyArray foldLeftWithIndex
  * @tsplus location "@fncts/base/collection/compat/Array/api"
  */
 export declare function foldLeftWithIndex<A, B>(self: ReadonlyArray<A>, b: B, f: (i: number, b: B, a: A) => B): B;

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

@@ -1,16 +1,16 @@
 declare global {
     /**
-     * @tsplus type fncts.base.ReadonlyArray
+     * @tsplus type fncts.ReadonlyArray
      */
     export interface ReadonlyArray<T> {
     }
     /**
-     * @tsplus type fncts.base.Array
+     * @tsplus type fncts.Array
      */
     export interface Array<T> {
     }
     /**
-     * @tsplus type fncts.base.ArrayOps
+     * @tsplus type fncts.ArrayOps
      */
     export interface ArrayConstructor {
     }

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

@@ -0,0 +1,24 @@
+import { Guard } from "@fncts/base/typeclass/Guard";
+import { Decoder } from "@fncts/base/data/Decoder";
+import { These } from "@fncts/base/data/These";
+import type { Check } from "@fncts/typelevel/Check";
+/**
+ * @tsplus derive fncts.Guard[fncts.Array]<_> 10
+ * @tsplus location "@fncts/base/collection/compat/Array/derivations"
+ */
+export declare function deriveGuard<A extends Array<any>>(...[element]: [A] extends [Array<infer _A>] ? Check<Check.IsEqual<A, Array<_A>>> extends Check.True ? [element: Guard<_A>] : never : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Guard[fncts.ReadonlyArray]<_> 10
+ * @tsplus location "@fncts/base/collection/compat/Array/derivations"
+ */
+export declare const deriveReadonlyArrayGuard: <A extends ReadonlyArray<any>>(...[element]: [A] extends [ReadonlyArray<infer _A>] ? Check<Check.IsEqual<A, ReadonlyArray<_A>>> extends Check.True ? [element: Guard<_A>] : never : never) => Guard<A>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.Array]<_> 10
+ * @tsplus location "@fncts/base/collection/compat/Array/derivations"
+ */
+export declare function deriveDecoder<A extends Array<any>>(...[element]: [A] extends [Array<infer _A>] ? Check<Check.IsEqual<A, Array<_A>>> extends Check.True ? [element: Decoder<_A>] : never : never): Decoder<A>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.ReadonlyArray]<_> 10
+ * @tsplus location "@fncts/base/collection/compat/Array/derivations"
+ */
+export declare function deriveReadonlyArrayDecoder<A extends ReadonlyArray<any>>(...[element]: [A] extends [ReadonlyArray<infer _A>] ? Check<Check.IsEqual<A, ReadonlyArray<_A>>> extends Check.True ? [element: Decoder<_A>] : never : never): Decoder<A>;

package/collection/compat/Array.d.ts

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

package/collection/compat.d.ts

@@ -0,0 +1,2 @@
+export type {} from "./compat/Array.js";
+export type {} from "./compat/Record.js";

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

@@ -31,7 +31,7 @@ export interface ConcF extends HKT {
  * @tsplus companion fncts.ConcOps
  */
 export declare abstract class Conc<A> implements Iterable<A>, Hashable, Equatable {
-    readonly _A: () => A;
+    _A: () => A;
     readonly _typeId: ConcTypeId;
     abstract readonly length: number;
     abstract [Symbol.iterator](): Iterator<A>;
@@ -40,7 +40,7 @@ export declare abstract class Conc<A> implements Iterable<A>, Hashable, Equatabl
 }
 declare abstract class ConcImplementation<A> implements Iterable<A> {
     readonly _typeId: ConcTypeId;
-    readonly _A: () => A;
+    _A: () => A;
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
     abstract readonly length: number;
@@ -83,10 +83,11 @@ export declare class Empty<A> extends ConcImplementation<A> {
     arrayIterator(): Iterator<Array<A>>;
     reverseArrayIterator(): Iterator<Array<A>>;
 }
-export declare const _Empty: Empty<any>;
+export declare const _Empty: Empty<never>;
 export declare class Concat<A> extends ConcImplementation<A> {
     readonly left: ConcImplementation<A>;
     readonly right: ConcImplementation<A>;
+    _A: () => A;
     readonly _tag = ConcTag.Concat;
     length: number;
     depth: number;
@@ -107,8 +108,8 @@ declare class AppendN<A> extends ConcImplementation<A> {
     readonly _tag = ConcTag.AppendN;
     length: number;
     depth: number;
-    left: Empty<any>;
-    right: Empty<any>;
+    left: Empty<never>;
+    right: Empty<never>;
     constructor(start: ConcImplementation<A>, buffer: Array<unknown> | Uint8Array, bufferUsed: number, binary: boolean);
     [Symbol.iterator](): Iterator<A>;
     append<A1>(a: A1): ConcImplementation<A | A1>;
@@ -123,8 +124,8 @@ declare class PrependN<A> extends ConcImplementation<A> {
     readonly binary: boolean;
     readonly _tag = ConcTag.PrependN;
     length: number;
-    left: Empty<any>;
-    right: Empty<any>;
+    left: Empty<never>;
+    right: Empty<never>;
     constructor(end: ConcImplementation<A>, buffer: Array<unknown> | Uint8Array, bufferUsed: number, binary: boolean);
     [Symbol.iterator](): Iterator<A>;
     prepend<A1>(a: A1): ConcImplementation<A | A1>;
@@ -137,8 +138,8 @@ export declare class Singleton<A> extends ConcImplementation<A> {
     readonly _tag = ConcTag.Singleton;
     length: number;
     depth: number;
-    left: Empty<any>;
-    right: Empty<any>;
+    left: Empty<never>;
+    right: Empty<never>;
     binary: boolean;
     constructor(value: A);
     get(n: number): A;
@@ -156,8 +157,8 @@ export declare class Slice<A> extends ConcImplementation<A> {
     length: number;
     binary: boolean;
     depth: number;
-    left: Empty<any>;
-    right: Empty<any>;
+    left: Empty<never>;
+    right: Empty<never>;
     constructor(conc: ConcImplementation<A>, offset: number, l: number);
     get(n: number): A;
     forEach<B>(startIndex: number, f: (i: number, a: A) => B): void;
@@ -168,8 +169,8 @@ export declare class Chunk<A> extends ConcImplementation<A> {
     readonly _tag = ConcTag.Chunk;
     length: number;
     depth: number;
-    left: Empty<any>;
-    right: Empty<any>;
+    left: Empty<never>;
+    right: Empty<never>;
     binary: boolean;
     constructor(_array: ReadonlyArray<A>);
     get(n: number): A;
@@ -184,8 +185,8 @@ export declare class ByteChunk<A> extends ConcImplementation<A> {
     readonly _tag = ConcTag.ByteChunk;
     length: number;
     depth: number;
-    left: Empty<any>;
-    right: Empty<any>;
+    left: Empty<never>;
+    right: Empty<never>;
     binary: boolean;
     constructor(_array: Uint8Array);
     get(n: number): A;
@@ -205,7 +206,7 @@ export declare function concrete<A>(_: Conc<A>): asserts _ is Empty<A> | Singlet
  */
 export declare function fromArray<A>(array: ArrayLike<A>): ConcImplementation<A>;
 /**
- * @tsplus static fncts.ConcOps isConc
+ * @tsplus static fncts.ConcOps is
  * @tsplus location "@fncts/base/collection/immutable/Conc/definition"
  */
 export declare function isConc<A>(u: Iterable<A>): u is Conc<A>;

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

@@ -0,0 +1,14 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Guard } from "@fncts/base/typeclass/Guard";
+import { Decoder } from "@fncts/base/data/Decoder";
+import type { Check } from "@fncts/typelevel/Check";
+/**
+ * @tsplus derive fncts.Guard[fncts.Conc]<_> 10
+ * @tsplus location "@fncts/base/collection/immutable/Conc/derivations"
+ */
+export declare function deriveGuard<A extends Conc<any>>(...[elem]: [A] extends [Conc<infer _A>] ? [elem: Guard<_A>] : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.Conc]<_> 10
+ * @tsplus location "@fncts/base/collection/immutable/Conc/derivations"
+ */
+export declare function deriveDecoder<A extends Conc<any>>(...[array, elem]: [A] extends [Conc<infer _A>] ? Check<Check.IsEqual<A, Conc<_A>>> extends Check.True ? [array: Decoder<Array<_A>>, elem: Decoder<_A>] : never : never): Decoder<A>;

package/collection/immutable/Conc.d.ts

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

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

@@ -231,25 +231,25 @@ export declare function findLastMap_<A, B>(as: ImmutableArray<A>, f: (a: A) => M
 export declare function findLastMapWithIndex_<A, B>(as: ImmutableArray<A>, f: (i: number, a: A) => Maybe<B>): Maybe<B>;
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeftWithIndex
- * @tsplus fluent fncts.base.MutableArray foldLeftWithIndex
+ * @tsplus fluent fncts.MutableArray foldLeftWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function foldLeftWithIndex_<A, B>(self: ImmutableArray<A>, b: B, f: (i: number, b: B, a: A) => B): B;
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeft
- * @tsplus fluent fncts.base.MutableArray foldLeft
+ * @tsplus fluent fncts.MutableArray foldLeft
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function foldLeft_<A, B>(self: ImmutableArray<A>, b: B, f: (b: B, a: A) => B): B;
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeftWhile
- * @tsplus fluent fncts.base.MutableArray foldLeftWhile
+ * @tsplus fluent fncts.MutableArray foldLeftWhile
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function foldLeftWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicate<B>, f: (b: B, a: A) => B): B;
 /**
  * @tsplus fluent fncts.ImmutableArray foldLeftWithIndexWhile
- * @tsplus fluent fncts.base.MutableArray foldLeftWithIndexWhile
+ * @tsplus fluent fncts.MutableArray foldLeftWithIndexWhile
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function foldLeftWithIndexWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicate<B>, f: (i: number, b: B, a: A) => B): B;
@@ -296,7 +296,7 @@ export declare function foldRightWithIndexWhile_<A, B>(self: ImmutableArray<A>,
 export declare function forEach_<A, B>(self: ImmutableArray<A>, f: (a: A) => B): void;
 /**
  * @tsplus fluent fncts.ImmutableArray get
- * @tsplus fluent fncts.base.MutableArray get
+ * @tsplus fluent fncts.MutableArray get
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function get_<A>(self: ImmutableArray<A>, i: number): Maybe<A>;
@@ -422,7 +422,7 @@ export declare function partitionMap_<A, B, C>(self: ImmutableArray<A>, f: (a: A
 export declare function prepend_<A, B>(self: ImmutableArray<A>, head: B): ImmutableArray<A | B>;
 /**
  * @tsplus fluent fncts.ImmutableArray prependAll
- * @tsplus fluent fncts.base.MutableArray prependAll
+ * @tsplus fluent fncts.MutableArray prependAll
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function prependAll_<A>(self: ImmutableArray<A>, a: A): ImmutableArray<A>;

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

@@ -1,7 +1,7 @@
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 /**
- * @tsplus getter fncts.base.ReadonlyArray asImmutableArray
- * @tsplus getter fncts.base.Array asImmutableArray
+ * @tsplus getter fncts.ReadonlyArray asImmutableArray
+ * @tsplus getter fncts.Array asImmutableArray
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/constructors"
  */
 export declare function asImmutableArray<A>(self: ReadonlyArray<A>): ImmutableArray<A>;

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

@@ -23,4 +23,8 @@ export declare class ImmutableArray<A> implements Equatable, Hashable, Iterable<
     get [Symbol.hash](): number;
     [Symbol.iterator](): IterableIterator<A>;
 }
+/**
+ * @tsplus static fncts.ImmutableArrayOps is
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/definition"
+ */
 export declare function isImmutableArray(u: unknown): u is ImmutableArray<unknown>;

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

@@ -0,0 +1,14 @@
+import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+import { Guard } from "@fncts/base/typeclass/Guard";
+import { Decoder } from "@fncts/base/data/Decoder";
+import type { Check } from "@fncts/typelevel/Check";
+/**
+ * @tsplus derive fncts.Guard[fncts.ImmutableArray]<_> 10
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/derivations"
+ */
+export declare function deriveGuard<A extends ImmutableArray<any>>(...[element]: [A] extends [ImmutableArray<infer A>] ? [element: Guard<A>] : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.ImmutableArray]<_> 10
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/derivations"
+ */
+export declare function deriveDecoder<A extends ImmutableArray<any>>(...[array, elem]: [A] extends [ImmutableArray<infer _A>] ? Check<Check.IsEqual<A, ImmutableArray<_A>>> extends Check.True ? [array: Decoder<Array<_A>>, elem: Decoder<_A>] : never : never): Decoder<A>;

package/collection/immutable/ImmutableArray.d.ts

@@ -1,6 +1,7 @@
 export * from "./ImmutableArray/api.js";
 export * from "./ImmutableArray/constructors.js";
 export * from "./ImmutableArray/definition.js";
+export * from "./ImmutableArray/derivations.js";
 export * from "./ImmutableArray/instances.js";
 export * from "./ImmutableArray/api/chunksOf.js";
 export * from "./ImmutableArray/api/slice.js";

package/collection/immutable/ImmutableNonEmptyArray/constructors.d.ts

@@ -6,8 +6,8 @@ export declare function allocWithHead<A>(head: A, length: number): Array<A> & {
     0: A;
 };
 /**
- * @tsplus getter fncts.base.ReadonlyArray unsafeAsNonEmptyArray
- * @tsplus getter fncts.base.Array unsafeAsNonEmptyArray
+ * @tsplus getter fncts.ReadonlyArray unsafeAsNonEmptyArray
+ * @tsplus getter fncts.Array unsafeAsNonEmptyArray
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/constructors"
  */
 export declare function unsafeAsNonEmptyArray<A>(self: ReadonlyArray<A>): ImmutableNonEmptyArray<A>;

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

@@ -17,13 +17,13 @@ export declare class ImmutableNonEmptyArray<A> extends ImmutableArray<A> {
     constructor(_array: ReadonlyNonEmptyArray<A>);
 }
 /**
- * @tsplus type fncts.base.NonEmptyArray
+ * @tsplus type fncts.NonEmptyArray
  */
 export interface NonEmptyArray<T> extends Array<T> {
     0: T;
 }
 /**
- * @tsplus type fncts.base.ReadonlyNonEmptyArray
+ * @tsplus type fncts.ReadonlyNonEmptyArray
  */
 export interface ReadonlyNonEmptyArray<T> extends ReadonlyArray<T> {
     readonly 0: T;

package/collection/immutable/ImmutableNonEmptyArray/derivations.d.ts

@@ -0,0 +1,14 @@
+import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
+import { Guard } from "@fncts/base/typeclass/Guard";
+import { Decoder } from "@fncts/base/data/Decoder";
+import type { Check } from "@fncts/typelevel/Check";
+/**
+ * @tsplus derive fncts.Guard[fncts.ImmutableNonEmptyArray]<_> 10
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/derivations"
+ */
+export declare function deriveGuard<A extends ImmutableNonEmptyArray<any>>(...[elem]: [A] extends [ImmutableNonEmptyArray<infer _A>] ? [elem: Guard<_A>] : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.ImmutableNonEmptyArray]<_> 10
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/derivations"
+ */
+export declare function deriveDecoder<A extends ImmutableNonEmptyArray<any>>(...[array, elem]: [A] extends [ImmutableNonEmptyArray<infer _A>] ? Check<Check.IsEqual<A, ImmutableNonEmptyArray<_A>>> extends Check.True ? [array: Decoder<Array<_A>>, elem: Decoder<_A>] : never : never): Decoder<A>;

package/collection/immutable/ImmutableNonEmptyArray.d.ts

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

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

@@ -1,5 +1,5 @@
 /**
- * @tsplus type fncts.base.List.Cons
+ * @tsplus type fncts.List.Cons
  * @tsplus companion fncts.ConsOps
  */
 export declare class Cons<A> implements Iterable<A> {
@@ -10,7 +10,7 @@ export declare class Cons<A> implements Iterable<A> {
     [Symbol.iterator](): Iterator<A>;
 }
 /**
- * @tsplus type fncts.base.List.Nil
+ * @tsplus type fncts.List.Nil
  * @tsplus companion fncts.NilOps
  */
 export declare class Nil<A> implements Iterable<A> {

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

@@ -47,7 +47,7 @@ export declare class Vector<A> implements Iterable<A> {
     [Symbol.equals](that: unknown): boolean;
 }
 /**
- * @tsplus type fncts.base.MutableVector
+ * @tsplus type fncts.MutableVector
  */
 export interface MutableVector<A> {
     readonly _typeId: VectorTypeId;

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

@@ -106,7 +106,7 @@ export declare function incrementDepth(bits: number): number;
 export declare function decrementDepth(bits: number): number;
 /**
  * Appends the value to the Vector by _mutating_ the Vector and its content.
- * @tsplus fluent fncts.base.MutableVector push
+ * @tsplus fluent fncts.MutableVector push
  * @tsplus location "@fncts/base/collection/immutable/Vector/internal"
  */
 export declare function push<A>(l: MutableVector<A>, value: A): MutableVector<A>;

package/collection/immutable.d.ts

@@ -0,0 +1,10 @@
+export type {} from "./immutable/Conc.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";

package/collection/mutable/HashMap.d.ts

@@ -17,6 +17,7 @@ export declare class HashMap<K, V> implements Iterable<readonly [K, V]> {
     private contentSize;
     get size(): number;
     has(key: K): boolean;
+    unsafeGet(key: K): V | undefined;
     get(key: K): Maybe<V>;
     set(key: K, value: V): Maybe<V>;
     delete(key: K): Maybe<V>;

package/collection/mutable.d.ts

@@ -0,0 +1,4 @@
+export type {} from "./mutable/HashMap.js";
+export type {} from "./mutable/HashSet.js";
+export type {} from "./mutable/internal.js";
+export type {} from "./mutable/ListBuffer.js";

package/collection/weak.d.ts

@@ -0,0 +1,2 @@
+export type {} from "./weak/IterableWeakMap.js";
+export type {} from "./weak/IterableWeakSet.js";

package/collection.d.ts

@@ -0,0 +1,5 @@
+export type {} from "./collection/compat.js";
+export type {} from "./collection/immutable.js";
+export type {} from "./collection/Iterable.js";
+export type {} from "./collection/mutable.js";
+export type {} from "./collection/weak.js";