optics-ts - npm Package Compare versions

Comparing version 2.4.0 to 2.4.1

hkt.d.ts

@@ -6,3 +6,3 @@ import { ElemType, Eq, Prec } from './utils.js';
 }
-export declare type Apply<F extends HKT, A> = (F & {
+export type Apply<F extends HKT, A> = (F & {
     1: A;
@@ -18,3 +18,3 @@ })[0];
 }
-export declare type Apply2<F extends HKT2, A, B> = (F & {
+export type Apply2<F extends HKT2, A, B> = (F & {
     1: A;
@@ -52,5 +52,5 @@ 2: B;
 }
-export declare type SetTuplePath<S, K> = K extends [] ? Id : K extends [infer K, ...infer R] ? K extends keyof S ? Compose<Prop<S, K>, SetTuplePath<S[K], R>> : never : never;
-export declare type SetDottedPath<S, K> = K extends `${infer P}.${infer R}` ? P extends keyof S ? Compose<Prop<S, P>, SetDottedPath<S[P], R>> : never : K extends keyof S ? Prop<S, K> : K extends '' ? Id : never;
-declare type SetNthRec<N extends number, B, S> = N extends 0 ? S extends [any, ...infer U] ? [B, ...U] : never : S extends [infer U, ...infer V] ? [U, ...SetNthRec<Prec<N>, B, V>] : never;
+export type SetTuplePath<S, K> = K extends [] ? Id : K extends [infer K, ...infer R] ? K extends keyof S ? Compose<Prop<S, K>, SetTuplePath<S[K], R>> : never : never;
+export type SetDottedPath<S, K> = K extends `${infer P}.${infer R}` ? P extends keyof S ? Compose<Prop<S, P>, SetDottedPath<S[P], R>> : never : K extends keyof S ? Prop<S, K> : K extends '' ? Id : never;
+type SetNthRec<N extends number, B, S> = N extends 0 ? S extends [any, ...infer U] ? [B, ...U] : never : S extends [infer U, ...infer V] ? [U, ...SetNthRec<Prec<N>, B, V>] : never;
 export interface SetNth<S, N extends number> extends HKT {
@@ -57,0 +57,0 @@ 0: SetNthRec<N, this[1], S>;

index.d.ts

 import { ElemType, Eq, IfElse, Nth, DottedPath, TuplePath, RequireString, Simplify } from './utils.js';
 import { Adapt, Apply, Choice, Compose, DisallowTypeChange, ElemUnion, Elems, HKT, Id, Index, PartsOf, Plant, Prop, Optional, SetNth, SetDottedPath, SetTuplePath, Union } from './hkt.js';
 export { Apply, Compose, Eq, HKT };
-export declare type Removable = true | undefined;
+export type Removable = true | undefined;
 export interface Params<T extends HKT, R extends Removable = undefined> {
@@ -9,7 +9,7 @@ readonly _T: T;
 }
-export declare type OpticParams = Params<any, any>;
-export declare type NextParams<C extends OpticParams, T extends HKT, R extends Removable = undefined> = Params<Compose<C['_T'], T>, R>;
-export declare type NextComposeParams<C1 extends OpticParams, C2 extends OpticParams> = Params<Compose<C1['_T'], C2['_T']>, C2['_R']>;
-export declare type OpticFor<S> = Equivalence<S, Params<DisallowTypeChange<S>>, S>;
-export declare type OpticFor_<S> = Equivalence<S, Params<Id>, S>;
+export type OpticParams = Params<any, any>;
+export type NextParams<C extends OpticParams, T extends HKT, R extends Removable = undefined> = Params<Compose<C['_T'], T>, R>;
+export type NextComposeParams<C1 extends OpticParams, C2 extends OpticParams> = Params<Compose<C1['_T'], C2['_T']>, C2['_R']>;
+export type OpticFor<S> = Equivalence<S, Params<DisallowTypeChange<S>>, S>;
+export type OpticFor_<S> = Equivalence<S, Params<Id>, S>;
 export interface Equivalence<S, T extends OpticParams, A> {
@@ -16,0 +16,0 @@ readonly _tag: 'Equivalence';

internals.d.ts

 export declare const id: (x: any) => any;
-export declare type OpticType = 'Equivalence' | 'Iso' | 'Lens' | 'Prism' | 'Traversal' | 'Getter' | 'AffineFold' | 'Fold' | 'Setter';
-declare type CompositionType = {
+export type OpticType = 'Equivalence' | 'Iso' | 'Lens' | 'Prism' | 'Traversal' | 'Getter' | 'AffineFold' | 'Fold' | 'Setter';
+type CompositionType = {
     [T in OpticType]: {
@@ -9,3 +9,3 @@ [U in OpticType]: OpticType | undefined;
 export declare const compositionType: CompositionType;
-declare type Profunctor = any;
+type Profunctor = any;
 interface OpticFn {
@@ -12,0 +12,0 @@ _tag: OpticType;

interop.d.ts

@@ -7,12 +7,12 @@ import type { Optic, Try, Try2 } from './standalone/optic.js';
 export declare function get<S, A>(optic: Equivalence<S, any, A> | Iso<S, any, A> | Lens<S, any, A> | Getter<S, A>, source: S): A;
-declare type Preview<A extends HKT, S> = Apply<A, S> extends infer AU ? Try<AU, AU | undefined> : never;
+type Preview<A extends HKT, S> = Apply<A, S> extends infer AU ? Try<AU, AU | undefined> : never;
 export declare function preview<C extends 'Prism' | 'Traversal' | 'AffineFold' | 'Fold', A extends HKT, S>(optic: Optic<C, A, any, any>, source: S): Preview<A, S>;
 export declare function preview<S, A>(optic: Prism<S, any, A> | Traversal<S, any, A> | AffineFold<S, A> | Fold<S, A>, source: S): A | undefined;
-declare type Collect<A extends HKT, S> = Apply<A, S> extends infer AU ? Try<AU, AU[]> : never;
+type Collect<A extends HKT, S> = Apply<A, S> extends infer AU ? Try<AU, AU[]> : never;
 export declare function collect<C extends 'Prism' | 'Traversal' | 'Fold', A extends HKT, S>(optic: Optic<C, A, any, any>, source: S): Collect<A, S>;
 export declare function collect<S, A>(optic: Prism<S, any, A> | Traversal<S, any, A> | Fold<S, A>, source: S): A[];
-declare type Modify<A extends HKT, B, S, T extends HKT2> = Apply<A, S> extends infer AU ? Apply2<T, S, B> extends infer TU ? Try2<AU, TU, Simplify<S, TU>> : never : never;
+type Modify<A extends HKT, B, S, T extends HKT2> = Apply<A, S> extends infer AU ? Apply2<T, S, B> extends infer TU ? Try2<AU, TU, Simplify<S, TU>> : never : never;
 export declare function modify<C extends 'Equivalence' | 'Iso' | 'Lens' | 'Prism' | 'Traversal', A extends HKT, B, S, T extends HKT2>(optic: Optic<C, A, T, any>, f: (a: Apply<A, S>) => B, source: S): Modify<A, B, S, T>;
 export declare function modify<S, T extends OpticParams, A, B>(optic: Equivalence<S, T, A> | Iso<S, T, A> | Lens<S, T, A> | Prism<S, T, A> | Traversal<S, T, A>, f: (a: A) => B, source: S): Simplify<S, Apply<T['_T'], B>>;
-declare type Set<B, S, T extends HKT2> = Apply2<T, S, B> extends infer TU ? Try<TU, Simplify<S, TU>> : never;
+type Set<B, S, T extends HKT2> = Apply2<T, S, B> extends infer TU ? Try<TU, Simplify<S, TU>> : never;
 export declare function set<C extends 'Equivalence' | 'Iso' | 'Lens' | 'Prism' | 'Traversal' | 'Setter', T extends HKT2, B, S>(optic: Optic<C, any, T, any>, value: B, source: S): Set<B, S, T>;
@@ -19,0 +19,0 @@ export declare function set<S, T extends OpticParams, A, B>(optic: Equivalence<S, T, A> | Iso<S, T, A> | Lens<S, T, A> | Prism<S, T, A> | Traversal<S, T, A> | Setter<S, T, A>, value: B, source: S): Simplify<S, Apply<T['_T'], B>>;

package.json

 {
   "name": "optics-ts",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "Type-safe, ergonomic, polymorphic optics for TypeScript",
@@ -20,2 +20,3 @@ "repository": "https://github.com/akheron/optics-ts",
     ".": {
+      "types": "./index.d.ts",
       "import": "./dist/mjs/index.js",
@@ -25,2 +26,3 @@ "require": "./dist/cjs/index.js"
     "./standalone": {
+      "types": "./standalone/index.d.ts",
       "import": "./dist/mjs/standalone/index.js",
@@ -30,2 +32,3 @@ "require": "./dist/cjs/standalone/index.js"
     "./interop": {
+      "types": "./interop.d.ts",
       "import": "./dist/mjs/interop.js",
@@ -56,3 +59,3 @@ "require": "./dist/cjs/interop.js"
     "@babel/types": "^7.12.1",
-    "@types/jest": "^27.0.1",
+    "@types/jest": "^29.5.2",
     "@typescript-eslint/eslint-plugin": "^4.14.0",
@@ -63,7 +66,7 @@ "@typescript-eslint/parser": "^4.14.0",
     "eslint-plugin-prettier": "^4.0.0",
-    "jest": "^27.0.6",
+    "jest": "^29.5.0",
     "prettier": "^2.2.1",
-    "ts-jest": "^27.0.5",
+    "ts-jest": "^29.1.0",
     "typescript": "^4.1.2"
   }
 }

standalone/appendTo.d.ts

@@ -6,4 +6,4 @@ import type { Optic, TryT, B, S, T } from './optic.js';
 }
-export declare type AppendTo = Optic<'Setter', never, AppendToT>;
+export type AppendTo = Optic<'Setter', never, AppendToT>;
 export declare const appendTo: AppendTo;
 export {};

standalone/at.d.ts

@@ -10,4 +10,4 @@ import type { Optic, A, B, S, T, TryA, TryT } from './optic.js';
 }
-export declare type At = Optic<'Prism', AtA, AtT, true>;
+export type At = Optic<'Prism', AtA, AtT, true>;
 export declare const at: (i: number) => At;
 export {};

standalone/atKey.d.ts

@@ -9,4 +9,4 @@ import type { Optic, A, B, S, T, TryA, TryT } from './optic.js';
 }
-export declare type AtKey = Optic<'Prism', AtKeyA, AtKeyT, true>;
+export type AtKey = Optic<'Prism', AtKeyA, AtKeyT, true>;
 export declare const atKey: (key: string) => AtKey;
 export {};

standalone/compose.d.ts

@@ -10,3 +10,3 @@ import type { HKT, HKT2, Apply, Apply2 } from '../hkt.js';
 }
-declare type ClassTable = {
+type ClassTable = {
     Equivalence: {
@@ -112,6 +112,6 @@ Equivalence: 'Equivalence';
 };
-export declare type ComposeC<C1 extends Class, C2 extends Class> = C1 extends keyof ClassTable ? C2 extends keyof ClassTable[C1] ? ClassTable[C1][C2] : never : never;
-declare type ToOptic<O> = O extends string ? Prop<O> : O extends Optic<any, any, any, any> ? O : never;
-declare type Compose1<O1, O2> = ToOptic<O1> extends Optic<infer C1, infer A1, infer T1, any> ? ToOptic<O2> extends Optic<infer C2, infer A2, infer T2, infer R> ? Optic<ComposeC<C1, C2>, ComposeA<A1, A2>, ComposeT<T1, A1, T2>, R> : never : never;
-export declare type Compose<T extends [any, ...any]> = T extends [
+export type ComposeC<C1 extends Class, C2 extends Class> = C1 extends keyof ClassTable ? C2 extends keyof ClassTable[C1] ? ClassTable[C1][C2] : never : never;
+type ToOptic<O> = O extends string ? Prop<O> : O extends Optic<any, any, any, any> ? O : never;
+type Compose1<O1, O2> = ToOptic<O1> extends Optic<infer C1, infer A1, infer T1, any> ? ToOptic<O2> extends Optic<infer C2, infer A2, infer T2, infer R> ? Optic<ComposeC<C1, C2>, ComposeA<A1, A2>, ComposeT<T1, A1, T2>, R> : never : never;
+export type Compose<T extends [any, ...any]> = T extends [
     infer First,
@@ -121,4 +121,4 @@ infer Second,
 ] ? Compose1<First, Compose<[Second, ...Rest]>> : T extends [infer First] ? ToOptic<First> : never;
-export declare type ComposeArg = string | Optic<any, any, any, any>;
+export type ComposeArg = string | Optic<any, any, any, any>;
 export declare function compose<T extends [ComposeArg, ...ComposeArg[]]>(...args: T): Compose<T>;
 export {};

standalone/eq.d.ts

@@ -8,4 +8,4 @@ import type { Optic, TryA, TryT, A, B, S, T } from './optic.js';
 }
-export declare type Eq = Optic<'Equivalence', EqA, EqT>;
+export type Eq = Optic<'Equivalence', EqA, EqT>;
 export declare const eq: Eq;
 export {};

standalone/filter.d.ts

@@ -12,6 +12,6 @@ import type { Optic, TryA, TryT, A, B, S, T } from './optic.js';
 }
-export declare type Filter<Item> = Optic<'Lens', FilterA<Item>, FilterT<Item>>;
-export declare type FilterNarrow<Item, Narrowed extends Item> = Optic<'Lens', FilterNarrowA<Item, Narrowed>, FilterT<Item>>;
+export type Filter<Item> = Optic<'Lens', FilterA<Item>, FilterT<Item>>;
+export type FilterNarrow<Item, Narrowed extends Item> = Optic<'Lens', FilterNarrowA<Item, Narrowed>, FilterT<Item>>;
 export declare function filter<Item, Narrowed extends Item>(pred: (v: Item) => v is Narrowed): FilterNarrow<Item, Narrowed>;
 export declare function filter<Item>(pred: (v: Item) => boolean): Filter<Item>;
 export {};

standalone/indexed.d.ts

@@ -9,4 +9,4 @@ import type { Optic, TryA, TryT, A, B, S, T } from './optic.js';
 }
-export declare type Indexed = Optic<'Iso', IndexedA, IndexedT>;
+export type Indexed = Optic<'Iso', IndexedA, IndexedT>;
 export declare const indexed: Indexed;
 export {};

standalone/iso.d.ts

@@ -10,4 +10,4 @@ import type { Optic, TryA, TryT, A, B, S, T } from './optic.js';
 }
-export declare type Iso<From, To> = Optic<'Iso', IsoA<From, To>, IsoT<From, To>>;
+export type Iso<From, To> = Optic<'Iso', IsoA<From, To>, IsoT<From, To>>;
 export declare const iso: <From, To>(there: (a: From) => To, back: (a: To) => From) => Iso<From, To>;
 export {};

standalone/lens.d.ts

@@ -10,4 +10,4 @@ import type { Optic, TryA, TryT, A, B, S, T } from './optic.js';
 }
-export declare type Lens<From, To> = Optic<'Lens', LensA<From, To>, LensT<From, To>>;
+export type Lens<From, To> = Optic<'Lens', LensA<From, To>, LensT<From, To>>;
 export declare const lens: <From, To>(view: (v: From) => To, update: (v: From, u: To) => From) => Lens<From, To>;
 export {};

standalone/nth.d.ts

 import type { Optic, TryA, TryT, A, B, S, T } from './optic.js';
 import type { TupleExpected } from './errors.js';
-export declare type Prec<N> = N extends 6 ? 5 : N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : N extends 2 ? 1 : N extends 1 ? 0 : never;
-export declare type AnyTuple<N extends number, Acc extends any[] = []> = N extends 0 ? Acc : AnyTuple<Prec<N>, [...Acc, any]>;
+export type Prec<N> = N extends 6 ? 5 : N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : N extends 2 ? 1 : N extends 1 ? 0 : never;
+export type AnyTuple<N extends number, Acc extends any[] = []> = N extends 0 ? Acc : AnyTuple<Prec<N>, [...Acc, any]>;
 interface NthA<N extends number> extends A {
     0: TryA<this, S<this> extends [...AnyTuple<N>, infer Elem, ...any[]] ? Elem : TupleExpected<N, S<this>>>;
 }
-declare type SetNthRec<N extends number, B, S> = N extends 0 ? S extends [any, ...infer U] ? [B, ...U] : never : S extends [infer U, ...infer V] ? [U, ...SetNthRec<Prec<N>, B, V>] : never;
+type SetNthRec<N extends number, B, S> = N extends 0 ? S extends [any, ...infer U] ? [B, ...U] : never : S extends [infer U, ...infer V] ? [U, ...SetNthRec<Prec<N>, B, V>] : never;
 interface NthT<N extends number> extends T {
     0: TryT<this, S<this> extends [...AnyTuple<N>, any, ...any[]] ? SetNthRec<N, B<this>, S<this>> : TupleExpected<N, S<this>>>;
 }
-export declare type Nth<N extends number> = Optic<'Lens', NthA<N>, NthT<N>>;
+export type Nth<N extends number> = Optic<'Lens', NthA<N>, NthT<N>>;
 export declare const nth: <N extends number>(n: N) => Nth<N>;
 export {};

standalone/operations.d.ts

@@ -7,14 +7,14 @@ import type { Optic, Try, Try2 } from './optic.js';
 export declare function get<C extends 'Equivalence' | 'Iso' | 'Lens' | 'Getter', A extends HKT>(optic: Optic<C, A, any, any>): <S>(source: S) => Apply<A, S>;
-declare type Preview<A extends HKT, S> = Apply<A, S> extends infer AU ? Try<AU, AU | undefined> : never;
+type Preview<A extends HKT, S> = Apply<A, S> extends infer AU ? Try<AU, AU | undefined> : never;
 export declare function preview<C extends 'Prism' | 'Traversal' | 'AffineFold' | 'Fold', A extends HKT, S>(optic: Optic<C, A, any, any>, source: S): Preview<A, S>;
 export declare function preview<C extends 'Prism' | 'Traversal' | 'AffineFold' | 'Fold', A extends HKT>(optic: Optic<C, A, any, any>): <S>(source: S) => Preview<A, S>;
-declare type Collect<A extends HKT, S> = Apply<A, S> extends infer AU ? Try<AU, AU[]> : never;
+type Collect<A extends HKT, S> = Apply<A, S> extends infer AU ? Try<AU, AU[]> : never;
 export declare function collect<C extends 'Prism' | 'Traversal' | 'Fold', A extends HKT, S>(optic: Optic<C, A, any, any>, source: S): Collect<A, S>;
 export declare function collect<C extends 'Prism' | 'Traversal' | 'Fold', A extends HKT>(optic: Optic<C, A, any, any>): <S>(source: S) => Collect<A, S>;
-declare type Modify<A extends HKT, B, S, T extends HKT2> = Apply<A, S> extends infer AU ? Apply2<T, S, B> extends infer TU ? Try2<AU, TU, Simplify<S, TU>> : never : never;
-declare type ModifyPartial<A extends HKT, A2, B, S, T extends HKT2> = Apply<A, S> extends infer AU ? Apply2<T, S, B> extends infer TU ? Try2<AU, TU, Eq<AU, A2> extends true ? Simplify<S, TU> : InvalidModifyFn<AU, A2>> : never : never;
+type Modify<A extends HKT, B, S, T extends HKT2> = Apply<A, S> extends infer AU ? Apply2<T, S, B> extends infer TU ? Try2<AU, TU, Simplify<S, TU>> : never : never;
+type ModifyPartial<A extends HKT, A2, B, S, T extends HKT2> = Apply<A, S> extends infer AU ? Apply2<T, S, B> extends infer TU ? Try2<AU, TU, Eq<AU, A2> extends true ? Simplify<S, TU> : InvalidModifyFn<AU, A2>> : never : never;
 export declare function modify<C extends 'Equivalence' | 'Iso' | 'Lens' | 'Prism' | 'Traversal', A extends HKT, B, S, T extends HKT2>(optic: Optic<C, A, T, any>, f: (a: Apply<A, S>) => B, source: S): Modify<A, B, S, T>;
 export declare function modify<C extends 'Equivalence' | 'Iso' | 'Lens' | 'Prism' | 'Traversal', A extends HKT, B, T extends HKT2, Ac>(optic: Optic<C, A, T, any>, f: (a: Ac) => B): <S>(source: S) => ModifyPartial<A, Ac, B, S, T>;
 export declare function modify<C extends 'Equivalence' | 'Iso' | 'Lens' | 'Prism' | 'Traversal', A extends HKT, T extends HKT2>(optic: Optic<C, A, T, any>): <Ac, B>(f: (a: Ac) => B) => <S>(source: S) => ModifyPartial<A, Ac, B, S, T>;
-declare type Set<B, S, T extends HKT2> = Apply2<T, S, B> extends infer TU ? Try<TU, Simplify<S, TU>> : never;
+type Set<B, S, T extends HKT2> = Apply2<T, S, B> extends infer TU ? Try<TU, Simplify<S, TU>> : never;
 export declare function set<C extends 'Equivalence' | 'Iso' | 'Lens' | 'Prism' | 'Traversal' | 'Setter', T extends HKT2, B, S>(optic: Optic<C, any, T, any>, value: B, source: S): Set<B, S, T>;
@@ -21,0 +21,0 @@ export declare function set<C extends 'Equivalence' | 'Iso' | 'Lens' | 'Prism' | 'Traversal' | 'Setter', T extends HKT2, B>(optic: Optic<C, any, T, any>, value: B): <S>(source: S) => Set<B, S, T>;

standalone/optic.d.ts

 import type { HKT, HKT2 } from '../hkt.js';
 import type { OpticError } from './errors.js';
-export declare type Class = 'Equivalence' | 'Iso' | 'Lens' | 'Prism' | 'Traversal' | 'Getter' | 'AffineFold' | 'Fold' | 'Setter';
-export declare type A = HKT;
-export declare type T = HKT2;
-export declare type S<F extends HKT> = F[1];
-export declare type B<F extends HKT2> = F[2];
-export declare type Removable = true | undefined;
+export type Class = 'Equivalence' | 'Iso' | 'Lens' | 'Prism' | 'Traversal' | 'Getter' | 'AffineFold' | 'Fold' | 'Setter';
+export type A = HKT;
+export type T = HKT2;
+export type S<F extends HKT> = F[1];
+export type B<F extends HKT2> = F[2];
+export type Removable = true | undefined;
 export interface Optic<C extends Class, A extends HKT, T extends HKT2, R extends Removable = undefined> {
@@ -15,5 +15,5 @@ readonly _tag: C;
 }
-export declare type Try<P, U> = P extends OpticError ? P : U;
-export declare type Try2<P1, P2, U> = P1 extends OpticError ? P1 : P2 extends OpticError ? P2 : U;
-export declare type TryA<P extends A, U> = Try<S<P>, U>;
-export declare type TryT<P extends T, U> = Try2<S<P>, B<P>, U>;
+export type Try<P, U> = P extends OpticError ? P : U;
+export type Try2<P1, P2, U> = P1 extends OpticError ? P1 : P2 extends OpticError ? P2 : U;
+export type TryA<P extends A, U> = Try<S<P>, U>;
+export type TryT<P extends T, U> = Try2<S<P>, B<P>, U>;

standalone/prependTo.d.ts

@@ -6,4 +6,4 @@ import type { Optic, TryT, B, S, T } from './optic.js';
 }
-export declare type PrependTo = Optic<'Setter', never, PrependToT>;
+export type PrependTo = Optic<'Setter', never, PrependToT>;
 export declare const prependTo: PrependTo;
 export {};

standalone/prop.d.ts

@@ -11,4 +11,4 @@ import type { Optic, TryA, TryT, A, B, S, T } from './optic.js';
 }
-export declare type Prop<K extends string> = Optic<'Lens', PropA<K>, PropT<K>>;
+export type Prop<K extends string> = Optic<'Lens', PropA<K>, PropT<K>>;
 export declare const prop: <K extends string>(key: K) => Prop<K>;
 export {};

standalone/to.d.ts

@@ -6,4 +6,4 @@ import type { Optic, TryA, A, S } from './optic.js';
 }
-export declare type To<From, To> = Optic<'Getter', ToA<From, To>, never>;
+export type To<From, To> = Optic<'Getter', ToA<From, To>, never>;
 export declare const to: <T, U>(f: (a: T) => U) => To<T, U>;
 export {};

utils.d.ts

@@ -5,19 +5,19 @@ export interface NotAnArrayType<T> {
 }
-export declare type ElemType<A> = IfElse<IsOptional<A>, NotAnArrayType<A>, A extends (infer Item)[] ? Item : NotAnArrayType<A>>;
-export declare type Eq<A, B> = [A, B] extends [B, A] ? true : false;
-export declare type Simplify<A, B> = Eq<A, B> extends true ? A : B;
-export declare type IsOptional<A> = Or<ExtendsUndefined<A>, ExtendsNull<A>>;
-declare type ExtendsUndefined<A> = Eq<A | undefined, A>;
-declare type ExtendsNull<A> = Eq<A | null, A>;
-declare type Or<A extends true | false, B extends true | false> = A extends true ? true : B;
-export declare type IfElse<Condition extends true | false, Then, Else> = Condition extends true ? Then : Else;
-export declare type RequireString<A, B> = IfElse<Eq<A, string>, B, ExpectedStringButGot<A>>;
+export type ElemType<A> = IfElse<IsOptional<A>, NotAnArrayType<A>, A extends (infer Item)[] ? Item : NotAnArrayType<A>>;
+export type Eq<A, B> = [A, B] extends [B, A] ? true : false;
+export type Simplify<A, B> = Eq<A, B> extends true ? A : B;
+export type IsOptional<A> = Or<ExtendsUndefined<A>, ExtendsNull<A>>;
+type ExtendsUndefined<A> = Eq<A | undefined, A>;
+type ExtendsNull<A> = Eq<A | null, A>;
+type Or<A extends true | false, B extends true | false> = A extends true ? true : B;
+export type IfElse<Condition extends true | false, Then, Else> = Condition extends true ? Then : Else;
+export type RequireString<A, B> = IfElse<Eq<A, string>, B, ExpectedStringButGot<A>>;
 interface ExpectedStringButGot<_T> {
     readonly _: unique symbol;
 }
-export declare type Prec<N> = N extends 6 ? 5 : N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : N extends 2 ? 1 : N extends 1 ? 0 : never;
-export declare type TuplePath<A, K> = K extends [] ? A : K extends [infer P, ...infer R] ? P extends keyof A ? TuplePath<A[P], R> : never : never;
-export declare type DottedPath<A, K> = K extends keyof A ? A[K] : K extends `${infer P}.${infer R}` ? P extends keyof A ? DottedPath<A[P], R> : never : K extends '' ? A : never;
-export declare type AnyTuple<N extends number, Acc extends any[] = []> = N extends 0 ? Acc : AnyTuple<Prec<N>, [...Acc, any]>;
-export declare type Nth<A, N extends number> = A extends [
+export type Prec<N> = N extends 6 ? 5 : N extends 5 ? 4 : N extends 4 ? 3 : N extends 3 ? 2 : N extends 2 ? 1 : N extends 1 ? 0 : never;
+export type TuplePath<A, K> = K extends [] ? A : K extends [infer P, ...infer R] ? P extends keyof A ? TuplePath<A[P], R> : never : never;
+export type DottedPath<A, K> = K extends keyof A ? A[K] : K extends `${infer P}.${infer R}` ? P extends keyof A ? DottedPath<A[P], R> : never : K extends '' ? A : never;
+export type AnyTuple<N extends number, Acc extends any[] = []> = N extends 0 ? Acc : AnyTuple<Prec<N>, [...Acc, any]>;
+export type Nth<A, N extends number> = A extends [
     ...AnyTuple<N>,
@@ -28,3 +28,3 @@ infer U,
 /** Useful for working around distributive conditional types */
-export declare type Unnaked<T> = T extends unknown ? T : never;
+export type Unnaked<T> = T extends unknown ? T : never;
 export {};

No alert changes

Worsened metrics

Total package byte prevSize

137072

decreased by-0.33%

No dependency changes