@fncts/base 0.0.9 → 0.0.12

package/_src/collection/weak/IterableWeakSet.ts

@@ -0,0 +1,56 @@
+/**
+ * @tsplus type fncts.IterableWeakSet
+ */
+export class IterableWeakSet<A extends object> implements Iterable<A> {
+  private weakMap           = new WeakMap<A, { ref: WeakRef<A> }>();
+  private refSet            = new Set<WeakRef<A>>();
+  private finalizationGroup = new FinalizationRegistry<{ ref: WeakRef<A>; set: Set<WeakRef<A>> }>(
+    IterableWeakSet.cleanup,
+  );
+
+  private static cleanup<A extends object>({ ref, set }: { ref: WeakRef<A>; set: Set<WeakRef<A>> }) {
+    set.delete(ref);
+  }
+
+  constructor(iterable: Iterable<A>) {
+    for (const value of iterable) {
+      this.add(value);
+    }
+  }
+
+  add(this: this, value: A): this {
+    const ref = new WeakRef(value);
+
+    this.weakMap.set(value, { ref });
+    this.refSet.add(ref);
+    this.finalizationGroup.register(value, { set: this.refSet, ref }, ref);
+    return this;
+  }
+
+  delete(this: this, value: A): boolean {
+    const entry = this.weakMap.get(value);
+    if (!entry) {
+      return false;
+    }
+
+    this.weakMap.delete(value);
+    this.refSet.delete(entry.ref);
+    return true;
+  }
+
+  [Symbol.iterator](this: this): IterableIterator<A> {
+    return this.entries();
+  }
+
+  *entries(this: this): IterableIterator<A> {
+    for (const ref of this.refSet) {
+      const key = ref.deref();
+      if (!key) continue;
+      yield key;
+    }
+  }
+
+  has(this: this, value: A): boolean {
+    return this.weakMap.has(value);
+  }
+}

package/_src/data/Branded/definition.ts

@@ -17,18 +17,22 @@ export declare namespace Branded {
   export type Validated<A, K extends string> = A & Brand<A, K>;
 
   export type IsValidated<P extends Brand<any, any>> = {
-    [K in keyof P[Branded.Symbol]]: P extends P[Branded.Symbol][K] ? 0 : 1
-  }[keyof P[Branded.Symbol]] extends 0 ? unknown : never;
+    [K in keyof P[Branded.Symbol]]: P extends P[Branded.Symbol][K] ? 0 : 1;
+  }[keyof P[Branded.Symbol]] extends 0
+    ? unknown
+    : never;
 
   export type Unbrand<P extends Brand<any, any>> = P extends infer Q & Brands<P> ? Q : P;
 
-  export type Brands<P extends Brand<any, any>> = Union.IntersectionOf<{
-    [K in keyof P[Branded.Symbol]]: P extends P[Branded.Symbol][K]
-      ? K extends string
-        ? Brand<P[Branded.Symbol][K], K>
-        : never
-      : never;
-  }[keyof P[Branded.Symbol]]>;
+  export type Brands<P extends Brand<any, any>> = Union.IntersectionOf<
+    {
+      [K in keyof P[Branded.Symbol]]: P extends P[Branded.Symbol][K]
+        ? K extends string
+          ? Brand<P[Branded.Symbol][K], K>
+          : never
+        : never;
+    }[keyof P[Branded.Symbol]]
+  >;
 }
 
 /**

package/_src/data/Branded/derivations.ts

@@ -10,11 +10,11 @@ import { Decoder } from "@fncts/base/data/Decoder/definition";
 export function deriveGuard<A extends Branded.Brand<any, any>>(
   ...[base, brands]: Check<Branded.IsValidated<A>> extends Check.True
     ? [
-      base: Guard<Branded.Unbrand<A>>,
-      brands: {
-        [K in keyof A[Branded.Symbol] & string]: Brand<A[Branded.Symbol][K], K>;
-      }
-    ]
+        base: Guard<Branded.Unbrand<A>>,
+        brands: {
+          [K in keyof A[Branded.Symbol] & string]: Brand<A[Branded.Symbol][K], K>;
+        },
+      ]
     : never
 ): Guard<A> {
   const validations = Object.values(brands) as ReadonlyArray<Brand<A, any>>;
@@ -35,23 +35,24 @@ export function deriveDecoder<A extends Branded.Brand<any, any>>(
     : never
 ): Decoder<A> {
   const label = "Brand<" + Object.keys(brands).join(" & ") + ">";
-  return Decoder((u) => base.decode(u).match2(
-    These.left,
-    (warning, value) => {
-      const failedBrands: Array<string> = [];
-      for (const brand in brands) {
-        if (!brands[brand]!.validate(value as any)) {
-          failedBrands.push(brand);
+  return Decoder(
+    (u) =>
+      base.decode(u).match2(These.left, (warning, value) => {
+        const failedBrands: Array<string> = [];
+        for (const brand in brands) {
+          if (!brands[brand]!.validate(value as any)) {
+            failedBrands.push(brand);
+          }
+        }
+        if (failedBrands.length > 0) {
+          const error = new BrandedError(label, Vector.from(failedBrands));
+          return warning.match(
+            () => These.left(error),
+            (warning) => These.left(new CompoundError(label, Vector(warning, error))),
+          );
         }
-      }
-      if (failedBrands.length > 0) {
-        const error = new BrandedError(label, Vector.from(failedBrands));
-        return warning.match(
-          () => These.left(error),
-          (warning) => These.left(new CompoundError(label, Vector(warning, error)))
-        );
-      }
-      return These.rightOrBoth(warning, value);
-    }
-  ), label);
+        return These.rightOrBoth(warning, value);
+      }),
+    label,
+  );
 }

package/_src/data/Branded.ts

@@ -1,4 +1,4 @@
 // codegen:start { preset: barrel, include: ./Branded/*.ts }
 export * from "./Branded/definition.js";
 export * from "./Branded/derivations.js";
-// codegen:end
+// codegen:end

package/_src/data/CaseClass.ts

@@ -66,8 +66,7 @@ export const CaseClass: CaseConstructor = class<T extends Record<PropertyKey, an
 
       while (result && i < len) {
         result =
-          this[keysSymbol][i] === thatKeys[i] &&
-          (this[this[keysSymbol]![i]!] as {}) == (that as T)[thatKeys[i]!];
+          this[keysSymbol][i] === thatKeys[i] && (this[this[keysSymbol]![i]!] as {}) == (that as T)[thatKeys[i]!];
         i++;
       }
 

package/_src/data/Cause/api.ts

@@ -1017,11 +1017,3 @@ export function traced<E>(cause: Cause<E>, trace: Trace): Cause<E> {
 export function untraced<E>(self: Cause<E>): Cause<E> {
   return self.mapTrace(() => Trace.none);
 }
-
-// codegen:start { preset: barrel, include: api/*.ts }
-export * from "./api/fold.js";
-export * from "./api/isEmpty.js";
-export * from "./api/linearize.js";
-export * from "./api/prettyPrint.js";
-export * from "./api/unified.js";
-// codegen:end

package/_src/data/Cause.ts

@@ -2,3 +2,11 @@
 export * from "./Cause/api.js";
 export * from "./Cause/definition.js";
 // codegen:end
+
+// codegen:start { preset: barrel, include: Cause/api/*.ts }
+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";
+// codegen:end

package/_src/data/Const/definition.ts

@@ -25,4 +25,4 @@ export interface Const1<E, A> {
   readonly [HKT.E]: () => E;
   readonly [HKT.A]: () => A;
   readonly [HKT.T]: Const<E, HKT._A<this>>;
-}
+}

package/_src/data/DecodeError.ts

@@ -1,3 +1,3 @@
 // codegen:start { preset: barrel, include: ./DecodeError/*.ts }
 export * from "./DecodeError/definition.js";
-// codegen:end
+// codegen:end

package/_src/data/Decoder/api.ts

@@ -41,6 +41,7 @@ export const number: Decoder<number> = fromGuard(Number.Guard, (u) => new Primit
 export const boolean: Decoder<boolean> = fromGuard(Boolean.Guard, (u) => new PrimitiveError(u, "boolean"), "boolean");
 
 /**
+ * @tsplus static fncts.DecoderOps record
  * @tsplus implicit
  */
 export const record: Decoder<{}> = fromGuard(Object.Guard, (u) => new PrimitiveError(u, "{}"), "{}");
@@ -95,7 +96,7 @@ export function deriveUnion<A extends ReadonlyArray<unknown>>(
 }
 
 /**
- * @tsplus derive fncts.Decoder<_> 10
+ * @tsplus derive fncts.Decoder<_> 20
  */
 export function deriveStruct<A extends Record<string, any>>(
   ...[requiredFields, optionalFields]: Check<Check.IsStruct<A>> extends Check.True

package/_src/data/Duration/api.ts

@@ -73,4 +73,4 @@ export function difference(self: Duration, that: Duration): Duration {
  */
 export function fromInterval(start: number, end: number): Duration {
   return Duration.milliseconds(Math.round(end) - Math.round(start));
-}
+}

package/_src/data/Identity/api.ts

@@ -40,4 +40,4 @@ export function zip_<A, B>(fa: Identity<A>, fb: Identity<B>): Identity<readonly
  */
 export function getIdentity<A>(self: Identity<A>): A {
   return Identity.reverseGet(self);
-}
+}

package/_src/data/Identity/definition.ts

@@ -1,5 +1,5 @@
 export interface IdentityN {
-  readonly [HKT.T]: Identity<HKT._A<this>>
+  readonly [HKT.T]: Identity<HKT._A<this>>;
 }
 
 /**

package/_src/data/These/api.ts

@@ -177,7 +177,7 @@ export function condemn<E, A>(self: These<E, A>): These<E, A> {
  * @tsplus fluent fncts.These condemnWhen
  */
 export function condemnWhen<E, A>(self: These<E, A>, p: Predicate<E>): These<E, A> {
-  if(self._tag === TheseTag.Both && p(self.left)) {
+  if (self._tag === TheseTag.Both && p(self.left)) {
     return These.left(self.left);
   }
   return self;

package/_src/data/These/constructors.ts

@@ -30,6 +30,6 @@ export function both<E = never, A = never>(e: E, a: A): These<E, A> {
 export function rightOrBoth<E = never, A = never>(e: Maybe<E>, a: A): These<E, A> {
   return e.match(
     () => These.right(a),
-    (e) => These.both(e, a)
+    (e) => These.both(e, a),
   );
 }

package/_src/data/These/definition.ts

@@ -51,4 +51,4 @@ export const These: TheseOps = {};
  */
 export function isThese(u: unknown): u is These<unknown, unknown> {
   return hasTypeId(u, TheseTypeId);
-}
+}

package/_src/data/These/destructors.ts

@@ -50,16 +50,12 @@ export function match_<E, A, B, C, D>(
 /**
  * @tsplus fluent fncts.These match2
  */
-export function match2<E, A, B, C>(
-  self: These<E, A>,
-  left: (e: E) => B,
-  right: (e: Maybe<E>, a: A) => C
-): B | C {
-  switch(self._tag) {
+export function match2<E, A, B, C>(self: These<E, A>, left: (e: E) => B, right: (e: Maybe<E>, a: A) => C): B | C {
+  switch (self._tag) {
     case TheseTag.Left:
       return left(self.left);
     case TheseTag.Right:
     case TheseTag.Both:
       return right(self.leftMaybe, self.right);
   }
-}
+}

package/_src/data/These.ts

@@ -3,4 +3,5 @@ export * from "./These/api.js";
 export * from "./These/constructors.js";
 export * from "./These/definition.js";
 export * from "./These/destructors.js";
+export * from "./These/instances.js";
 // codegen:end

package/_src/data/bigint/definition.ts

@@ -10,4 +10,4 @@ declare global {
   interface BigIntConstructor {}
 }
 
-export {};
+export {};

package/_src/data/bigint.ts

@@ -1,4 +1,4 @@
 // codegen:start { preset: barrel, include: ./bigint/*.ts }
 export * from "./bigint/definition.js";
 export * from "./bigint/instances.js";
-// codegen:end
+// codegen:end

package/_src/data/boolean/instances.ts

@@ -5,4 +5,4 @@ import { isBoolean } from "@fncts/base/util/predicates";
  * @tsplus static fncts.BooleanOps Guard
  * @tsplus implicit
  */
-export const Guard: P.Guard<boolean> = P.Guard(isBoolean);
+export const Guard: P.Guard<boolean> = P.Guard(isBoolean);

package/_src/data/boolean.ts

@@ -1,4 +1,4 @@
 // codegen:start { preset: barrel, include: ./boolean/*.ts }
 export * from "./boolean/definition.js";
 export * from "./boolean/instances.js";
-// codegen:end
+// codegen:end

package/_src/data/exceptions.ts

@@ -6,4 +6,5 @@ export * from "./exceptions/IndexOutOfBoundsError.js";
 export * from "./exceptions/InterruptedException.js";
 export * from "./exceptions/InvalidCapacityError.js";
 export * from "./exceptions/NoSuchElementError.js";
+export * from "./exceptions/RuntimeError.js";
 // codegen:end

package/_src/data/number/instances.ts

@@ -22,4 +22,4 @@ export const Ord: P.Ord<number> = P.Ord({
  * @tsplus static fncts.NumberOps Guard
  * @tsplus implicit
  */
-export const Guard: P.Guard<number> = P.Guard(isNumber);
+export const Guard: P.Guard<number> = P.Guard(isNumber);

package/_src/data/object.ts

@@ -1,3 +1,4 @@
 // codegen:start { preset: barrel, include: ./object/*.ts }
 export * from "./object/definition.js";
+export * from "./object/instances.js";
 // codegen:end

package/_src/data/string/instances.ts

@@ -33,4 +33,4 @@ export const Ord: P.Ord<string> = P.Ord({
  * @tsplus static fncts.StringOps Guard
  * @tsplus implicit
  */
-export const Guard: P.Guard<string> = P.Guard(isString);
+export const Guard: P.Guard<string> = P.Guard(isString);

package/_src/json/MaybeJson.ts

@@ -1,10 +1,10 @@
 export interface NothingJson {
-  readonly _tag: "Nothing"
+  readonly _tag: "Nothing";
 }
 
 export interface JustJson<A> {
-  readonly _tag: "Just"
-  readonly value: A
+  readonly _tag: "Just";
+  readonly value: A;
 }
 
 /**
@@ -24,4 +24,4 @@ export const MaybeJson: MaybeJsonOps = {};
  */
 export function getDecoder<A>(value: Decoder<A>): Decoder<MaybeJson<A>> {
   return Derive();
-}
+}

package/_src/typeclass/Align.ts

@@ -11,4 +11,4 @@ export interface Align<F extends HKT> extends Semialign<F>, Nil<F> {}
  */
 export interface AlignOps {}
 
-export const Align: AlignOps = {};
+export const Align: AlignOps = {};

package/_src/typeclass/Closure.ts

@@ -17,4 +17,4 @@ export const Closure: ClosureOps = {};
  */
 export function mkClosure<A>(F: Closure<A>): Closure<A> {
   return F;
-}
+}

package/_src/typeclass/Eq/definition.ts

@@ -2,7 +2,7 @@
  * @tsplus type fncts.Eq
  */
 export interface Eq<A> {
-  readonly equals: (x: A, y: A) => boolean
+  readonly equals: (x: A, y: A) => boolean;
 }
 
 /**
@@ -17,4 +17,4 @@ export const Eq: EqOps = {};
  */
 export function mkEq<A>(E: Eq<A>): Eq<A> {
   return E;
-}
+}

package/_src/typeclass/Guard/api.ts

@@ -29,4 +29,4 @@ export function assert<A>(self: Guard<A>, u: unknown): asserts u is A {
   if (!self.is(u)) {
     throw new AssertionError("Guard failed check failed");
   }
-}
+}

package/_src/typeclass/Guard/definition.ts

@@ -20,4 +20,4 @@ export class Guard<A> {
  */
 export function makeGuard<A>(refinement: Refinement<unknown, A>): Guard<A> {
   return new Guard(refinement);
-}
+}

package/_src/typeclass/Guard/derivations.ts

@@ -4,9 +4,7 @@ import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
 /**
  * @tsplus derive fncts.Guard lazy
  */
-export function deriveLazy<A>(
-  f: (_: Guard<A>) => Guard<A>
-): Guard<A> {
+export function deriveLazy<A>(f: (_: Guard<A>) => Guard<A>): Guard<A> {
   let cached: Guard<A> | undefined;
   const guard: Guard<A> = Guard((u: unknown): u is A => {
     if (!cached) {
@@ -30,18 +28,21 @@ export function deriveLiteral<A extends string | number | boolean>(
  * @tsplus derive fncts.Guard<_> 20
  */
 export function deriveStruct<A extends Record<string, any>>(
-  ...[requiredFields, optionalFields]: Check<Check.IsStruct<A>> extends Check.True ? [
-    ...[
-      requiredFields: {
-        [k in RequiredKeys<A>]: Guard<A[k]>;
-      }
-    ],
-    ...([OptionalKeys<A>] extends [never] ? [] : [
-      optionalFields: {
-        [k in OptionalKeys<A>]: Guard<NonNullable<A[k]>>;
-      }
-    ])
-  ]
+  ...[requiredFields, optionalFields]: Check<Check.IsStruct<A>> extends Check.True
+    ? [
+        ...[
+          requiredFields: {
+            [k in RequiredKeys<A>]: Guard<A[k]>;
+          },
+        ],
+        ...([OptionalKeys<A>] extends [never]
+          ? []
+          : [
+              optionalFields: {
+                [k in OptionalKeys<A>]: Guard<NonNullable<A[k]>>;
+              },
+            ]),
+      ]
     : never
 ): Guard<A> {
   return Guard((u): u is A => {
@@ -71,7 +72,7 @@ export function deriveStruct<A extends Record<string, any>>(
 export function deriveUnion<A extends unknown[]>(...members: { [K in keyof A]: Guard<A[K]> }): Guard<A[number]> {
   return Guard((u): u is A[number] => {
     for (const member of members) {
-      if(member.is(u)) {
+      if (member.is(u)) {
         return true;
       }
     }

package/_src/typeclass/Guard.ts

@@ -2,4 +2,3 @@
 export * from "./Guard/api.js";
 export * from "./Guard/definition.js";
 // codegen:end
-

package/_src/typeclass/Monoid.ts

@@ -48,7 +48,7 @@ export function deriveLazy<A>(fn: (_: Monoid<A>) => Monoid<A>): Monoid<A> {
         cached = fn(M);
       }
       return cached.nat;
-    }
+    },
   });
   return M;
 }
@@ -74,8 +74,8 @@ export function deriveStruct<A extends Record<string, any>>(
       ]
     : never
 ): Monoid<A> {
-  const [ requiredFields, optionalFields ] = args;
-  const nat: Record<string, unknown>       = {};
+  const [requiredFields, optionalFields] = args;
+  const nat: Record<string, unknown>     = {};
   for (const field in requiredFields) {
     nat[field] = (requiredFields[field] as Monoid<any>).nat;
   }
@@ -84,6 +84,6 @@ export function deriveStruct<A extends Record<string, any>>(
   }
   return Monoid({
     ...Semigroup.deriveStruct<A>(...args),
-    nat: nat as A
+    nat: nat as A,
   });
 }

package/_src/typeclass/Semialign.ts

@@ -204,7 +204,6 @@ export function alignCombine<F extends HKT, K, Q, W, X, I, S, R, E, A, K1, Q1, W
   HKT.Mix<"E", [E, E1]>,
   A
 > {
-
   return self.alignWith(that, (th) => th.match(identity, identity, S.combine));
 }
 
@@ -331,14 +330,12 @@ export function padZipWith<F extends HKT, K, Q, W, X, I, S, R, E, A, K1, Q1, W1,
   HKT.Mix<"E", [E, E1]>,
   D
 > {
-  return fa.alignWith(
-    fb,
-    (th) =>
-      th.match(
-        (a) => f([Just(a), Nothing()]),
-        (b) => f([Nothing(), Just(b)]),
-        (a, b) => f([Just(a), Just(b)]),
-      ),
+  return fa.alignWith(fb, (th) =>
+    th.match(
+      (a) => f([Just(a), Nothing()]),
+      (b) => f([Nothing(), Just(b)]),
+      (a, b) => f([Just(a), Just(b)]),
+    ),
   );
 }
 

package/_src/typeclass/Semigroup/derivations.ts

@@ -61,4 +61,4 @@ export function deriveStruct<A extends Record<string, any>>(
       return out as A;
     },
   });
-}
+}

package/_src/typeclass/Showable/show.ts

@@ -544,9 +544,9 @@ function showSet(value: Set<unknown>): ShowComputationChunk {
 function showMap(value: Map<unknown, unknown>): ShowComputationChunk {
   return Z.update((_: ShowContext) => _.copy({ indentationLevel: _.indentationLevel + 2 }))
     .apSecond(
-      (value as Iterable<[unknown, unknown]>).traverseToConc(([k, v]) =>
-        _show(k).crossWith(_show(v), (k, v) => `${k} => ${v}`),
-        Z.Applicative
+      (value as Iterable<[unknown, unknown]>).traverseToConc(
+        ([k, v]) => _show(k).crossWith(_show(v), (k, v) => `${k} => ${v}`),
+        Z.Applicative,
       ),
     )
     .apFirst(
@@ -578,7 +578,10 @@ function showTypedArray(value: TypedArray): ShowComputationChunk {
           .apSecond(
             Z.succeedNow(output).flatMap((output) =>
               Conc("BYTES_PER_ELEMENT", "length", "byteLength", "byteOffset", "buffer")
-                .traverse((key) => _show(value[key as keyof TypedArray]).map((shown) => `[${key}]: ${shown}`), Z.Applicative)
+                .traverse(
+                  (key) => _show(value[key as keyof TypedArray]).map((shown) => `[${key}]: ${shown}`),
+                  Z.Applicative,
+                )
                 .map((shownKeys) => output.concat(shownKeys)),
             ),
           )
@@ -888,7 +891,7 @@ function _showString(context: ShowContext, value: string): string {
   ) {
     return (
       result
-        .split(/(?<=\n)/)
+        .split(/(?!\n)/)
         .map((line) => context.stylize(strEscape(line), "string"))
         .join(` +\n${" ".repeat(context.indentationLevel + 2)}`) + trailer
     );

package/_src/typeclass.ts

@@ -37,4 +37,3 @@ export * from "./typeclass/TraversableWithIndex.js";
 export * from "./typeclass/Witherable.js";
 export * from "./typeclass/WitherableWithIndex.js";
 // codegen:end
-

package/collection/Iterable/api.d.ts

@@ -79,6 +79,11 @@ export declare function filterWithIndex_<A>(self: Iterable<A>, p: PredicateWithI
  */
 export declare function find_<A, B extends A>(ia: Iterable<A>, refinement: Refinement<A, B>): Maybe<B>;
 export declare function find_<A>(ia: Iterable<A>, predicate: Predicate<A>): Maybe<A>;
+/**
+ * @tsplus fluent fncts.Iterable findIndex
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function findIndex<A>(self: Iterable<A>, p: Predicate<A>): number;
 /**
  * @tsplus fluent fncts.Iterable foldLeftWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
@@ -147,6 +152,11 @@ export declare function partitionWithIndex_<A>(self: Iterable<A>, p: PredicateWi
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
 export declare function size<A>(self: Iterable<A>): number;
+/**
+ * @tsplus getter fncts.Iterable sum
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function sum(self: Iterable<number>): number;
 /**
  * @tsplus fluent fncts.Iterable take
  * @tsplus location "@fncts/base/collection/Iterable/api"

package/collection/compat/Record/instances.d.ts

@@ -0,0 +1,10 @@
+import { Guard } from "@fncts/base/typeclass/Guard";
+import { Decoder } from "@fncts/base/data/Decoder";
+import type { Check } from "@fncts/typelevel/Check";
+/**
+ * @tsplus derive fncts.Decoder<_> 15
+ * @tsplus location "@fncts/base/collection/compat/Record/instances"
+ */
+export declare function deriveDecoder<A extends Record<string, any>>(...[keyGuard, valueDecoder, requiredKeysRecord]: [A] extends [Record<infer X, infer Y>] ? Check<Check.Not<Check.IsUnion<A>> & Check.IsEqual<A, Record<X, Y>>> extends Check.True ? [keyGuard: Guard<X>, valueDecoder: Decoder<Y>, requiredKeysRecord: {
+    [k in X]: 0;
+}] : never : never): Decoder<A>;

package/collection/compat/Record.d.ts

@@ -0,0 +1 @@
+export * from "./Record/instances.js";