@cjser/ts-pattern 5.9.0-cjser.2

package/dist/types/InvertPattern.d.ts

@@ -0,0 +1,104 @@
+import { DeepExclude } from './DeepExclude.js';
+import { IsPlainObject, Primitives, IsLiteral, ValueOf, Compute, Equal, Extends, Not, All, NonLiteralPrimitive, MaybeAddReadonly, IsReadonlyArray, MapKey, MapValue, SetValue, ExtractPlainObject, GetKey, Call, Fn, ReadonlyArrayValue, WithDefault, RecordKey, RecordValue } from './helpers.js';
+import type { Matcher, Pattern, Override, AnyMatcher } from './Pattern.js';
+type OptionalKeys<p> = ValueOf<{
+    [k in keyof p]: 0 extends 1 & p[k] ? never : p[k] extends Matcher<any, any, infer matcherType> ? matcherType extends 'optional' ? k : never : never;
+}>;
+type ReduceUnion<tuple extends readonly any[], i, output = never> = tuple extends readonly [infer p, ...infer tail] ? ReduceUnion<tail, i, output | InvertPatternInternal<p, i>> : output;
+type ReduceIntersection<tuple extends readonly any[], i, output = unknown> = tuple extends readonly [infer p, ...infer tail] ? ReduceIntersection<tail, i, output & InvertPatternInternal<p, i>> : output;
+type InvertArrayPattern<p, i, startOutput extends any[] = [], endOutput extends any[] = []> = i extends readonly (infer ii)[] ? p extends readonly [] ? [...startOutput, ...endOutput] : p extends readonly [infer p1, ...infer pRest] ? i extends readonly [infer i1, ...infer iRest] ? InvertArrayPattern<pRest, iRest, [
+    ...startOutput,
+    InvertPatternInternal<p1, i1>
+], endOutput> : InvertArrayPattern<pRest, ii[], [
+    ...startOutput,
+    InvertPatternInternal<p1, ii>
+], endOutput> : p extends readonly [...infer pInit, infer p1] ? i extends readonly [...infer iInit, infer i1] ? InvertArrayPattern<pInit, iInit, startOutput, [
+    ...endOutput,
+    InvertPatternInternal<p1, i1>
+]> : InvertArrayPattern<pInit, ii[], startOutput, [
+    ...endOutput,
+    InvertPatternInternal<p1, ii>
+]> : p extends readonly [...(readonly (infer pRest & AnyMatcher)[])] ? [
+    ...startOutput,
+    ...Extract<InvertPatternInternal<pRest, i>, readonly any[]>,
+    ...endOutput
+] : [...startOutput, ...InvertPatternInternal<ValueOf<p>, ii>[], ...endOutput] : never;
+/**
+ * ### InvertPatternInternal
+ * Since patterns have special wildcard values, we need a way
+ * to transform a pattern into the type of value it represents
+ */
+export type InvertPattern<p, input> = Equal<Pattern<input>, p> extends true ? never : InvertPatternInternal<p, input>;
+type InvertPatternInternal<p, input> = 0 extends 1 & p ? never : p extends Matcher<infer _input, infer subpattern, infer matcherType, any, infer narrowedOrFn> ? {
+    not: DeepExclude<input, InvertPatternInternal<subpattern, input>>;
+    select: InvertPatternInternal<subpattern, input>;
+    array: InvertPatternInternal<subpattern, ReadonlyArrayValue<input>>[];
+    record: subpattern extends [infer pk, infer pv] ? Record<Extract<InvertPatternInternal<pk, RecordKey<input>>, PropertyKey>, InvertPatternInternal<pv, RecordValue<input>>> : never;
+    map: subpattern extends [infer pk, infer pv] ? Map<InvertPatternInternal<pk, MapKey<Extract<input, Map<any, any>>>>, InvertPatternInternal<pv, MapValue<Extract<input, Map<any, any>>>>> : never;
+    set: Set<InvertPatternInternal<subpattern, SetValue<Extract<input, Set<any>>>>>;
+    optional: InvertPatternInternal<subpattern, Exclude<input, undefined>> | undefined;
+    and: ReduceIntersection<Extract<subpattern, readonly any[]>, input>;
+    or: ReduceUnion<Extract<subpattern, readonly any[]>, input>;
+    default: [subpattern] extends [never] ? input : subpattern;
+    custom: Override<narrowedOrFn extends Fn ? Call<narrowedOrFn, input> : narrowedOrFn>;
+}[matcherType] : p extends Primitives ? p : p extends readonly any[] ? InvertArrayPattern<p, WithDefault<Extract<input, readonly any[]>, unknown[]>> : IsPlainObject<p> extends true ? OptionalKeys<p> extends infer optKeys ? [optKeys] extends [never] ? {
+    [k in Exclude<keyof p, optKeys>]: InvertPatternInternal<p[k], WithDefault<GetKey<ExtractPlainObject<input>, k>, unknown>>;
+} : Compute<{
+    [k in Exclude<keyof p, optKeys>]: InvertPatternInternal<p[k], WithDefault<GetKey<ExtractPlainObject<input>, k>, unknown>>;
+} & {
+    [k in Extract<optKeys, keyof p>]?: InvertPatternInternal<p[k], WithDefault<GetKey<ExtractPlainObject<input>, k>, unknown>>;
+}> : never : p;
+export type ReduceIntersectionForExclude<tuple extends readonly any[], i, output = unknown> = tuple extends readonly [infer p, ...infer tail] ? ReduceIntersectionForExclude<tail, i, output & InvertPatternForExcludeInternal<p, i, unknown>> : output;
+export type ReduceUnionForExclude<tuple extends readonly any[], i, output = never> = tuple extends readonly [infer p, ...infer tail] ? ReduceUnionForExclude<tail, i, output | InvertPatternForExcludeInternal<p, i, never>> : output;
+type ExcludeIfExists<a, b> = [
+    b
+] extends [never] ? never : unknown extends a ? never : All<[
+    Extends<a, NonLiteralPrimitive>,
+    Not<IsLiteral<a>>,
+    IsLiteral<b>
+]> extends true ? never : DeepExclude<a, b>;
+type InvertArrayPatternForExclude<p, i, empty, isReadonly extends boolean, startOutput extends any[] = [], endOutput extends any[] = []> = i extends readonly (infer ii)[] ? p extends readonly [] ? MaybeAddReadonly<[...startOutput, ...endOutput], isReadonly> : p extends readonly [infer p1, ...infer pRest] ? i extends readonly [infer i1, ...infer iRest] ? InvertArrayPatternForExclude<pRest, iRest, empty, isReadonly, [
+    ...startOutput,
+    InvertPatternForExcludeInternal<p1, i1, empty>
+], endOutput> : InvertArrayPatternForExclude<pRest, ii[], empty, isReadonly, [
+    ...startOutput,
+    InvertPatternForExcludeInternal<p1, ii, empty>
+], endOutput> : p extends readonly [...infer pInit, infer p1] ? i extends readonly [...infer iInit, infer i1] ? InvertArrayPatternForExclude<pInit, iInit, empty, isReadonly, startOutput, [
+    ...endOutput,
+    InvertPatternForExcludeInternal<p1, i1, empty>
+]> : InvertArrayPatternForExclude<pInit, ii[], empty, isReadonly, startOutput, [
+    ...endOutput,
+    InvertPatternForExcludeInternal<p1, ii, empty>
+]> : p extends readonly [...(readonly (infer pRest & AnyMatcher)[])] ? MaybeAddReadonly<[
+    ...startOutput,
+    ...Extract<InvertPatternForExcludeInternal<pRest, i, empty>, readonly any[]>,
+    ...endOutput
+], isReadonly> : MaybeAddReadonly<[
+    ...startOutput,
+    ...InvertPatternForExcludeInternal<ValueOf<p>, ii, empty>[],
+    ...endOutput
+], isReadonly> : empty;
+/**
+ * ### InvertPatternForExclude
+ */
+export type InvertPatternForExclude<p, i> = Equal<Pattern<i>, p> extends true ? never : InvertPatternForExcludeInternal<p, i>;
+type InvertPatternForExcludeInternal<p, i, empty = never> = unknown extends p ? i : [p] extends [Primitives] ? IsLiteral<p> extends true ? p : IsLiteral<i> extends true ? p : empty : p extends Matcher<infer matchableInput, infer subpattern, infer matcherType, any, infer excluded> ? {
+    select: InvertPatternForExcludeInternal<subpattern, i, empty>;
+    array: i extends readonly (infer ii)[] ? MaybeAddReadonly<InvertPatternForExcludeInternal<subpattern, ii, empty>[], IsReadonlyArray<i>> : empty;
+    record: subpattern extends [infer pk, infer pv] ? Record<Extract<InvertPatternForExcludeInternal<pk, RecordKey<i>, empty>, PropertyKey>, InvertPatternForExcludeInternal<pv, RecordValue<i>, empty>> : empty;
+    map: subpattern extends [infer pk, infer pv] ? i extends Map<infer ik, infer iv> ? Map<InvertPatternForExcludeInternal<pk, ik, empty>, InvertPatternForExcludeInternal<pv, iv, empty>> : empty : empty;
+    set: i extends Set<infer iv> ? Set<InvertPatternForExcludeInternal<subpattern, iv, empty>> : empty;
+    optional: InvertPatternForExcludeInternal<subpattern, i, empty> | undefined;
+    and: ReduceIntersectionForExclude<Extract<subpattern, readonly any[]>, i>;
+    or: ReduceUnionForExclude<Extract<subpattern, readonly any[]>, i>;
+    not: ExcludeIfExists<unknown extends matchableInput ? i : matchableInput, InvertPatternForExcludeInternal<subpattern, i>>;
+    default: excluded;
+    custom: excluded extends infer narrowedOrFn extends Fn ? Call<narrowedOrFn, i> : excluded;
+}[matcherType] : p extends readonly any[] ? Extract<i, readonly any[]> extends infer arrayInput ? InvertArrayPatternForExclude<p, arrayInput, empty, IsReadonlyArray<arrayInput>> : never : IsPlainObject<p> extends true ? Equal<{}, p> extends true ? {} : i extends object ? [keyof p & keyof i] extends [never] ? empty : OptionalKeys<p> extends infer optKeys ? [optKeys] extends [never] ? {
+    readonly [k in keyof p]: k extends keyof i ? InvertPatternForExcludeInternal<p[k], i[k], empty> : InvertPatternInternal<p[k], unknown>;
+} : Compute<{
+    readonly [k in Exclude<keyof p, optKeys>]: k extends keyof i ? InvertPatternForExcludeInternal<p[k], i[k], empty> : InvertPatternInternal<p[k], unknown>;
+} & {
+    readonly [k in Extract<optKeys, keyof p>]?: k extends keyof i ? InvertPatternForExcludeInternal<p[k], i[k], empty> : InvertPatternInternal<p[k], unknown>;
+}> : empty : empty : empty;
+export {};

package/dist/types/IsMatching.d.cts

@@ -0,0 +1,13 @@
+import { Primitives, IsPlainObject, IsUnion, ValueOf, Length, IsLiteral, All, Equal } from './helpers.cjs';
+type IsMatchingTuple<a extends readonly any[], b extends readonly any[]> = [
+    a,
+    b
+] extends [readonly [], readonly []] ? true : [a, b] extends [
+    readonly [infer a1, ...infer aRest],
+    readonly [infer b1, ...infer bRest]
+] ? IsMatching<a1, b1> extends true ? IsMatchingTuple<aRest, bRest> : false : false;
+type IsMatchingArray<a extends readonly any[], b extends readonly any[]> = b extends readonly [] ? true : b extends readonly [infer b1, ...infer bRest] ? a extends readonly [infer a1, ...infer aRest] ? IsMatching<a1, b1> extends true ? IsMatchingArray<aRest, bRest> : false : a extends readonly [] ? false : IsMatching<ValueOf<a>, b1> extends true ? IsMatchingArray<a, bRest> : false : b extends readonly [...infer bInit, infer b1] ? a extends readonly [...infer aInit, infer a1] ? IsMatching<a1, b1> extends true ? IsMatchingArray<aInit, bInit> : false : a extends readonly [] ? false : IsMatching<ValueOf<a>, b1> extends true ? IsMatchingArray<a, bInit> : false : IsMatching<ValueOf<a>, ValueOf<b>>;
+export type IsMatching<a, b> = true extends IsUnion<a> | IsUnion<b> ? true extends (b extends any ? (a extends any ? IsMatching<a, b> : never) : never) ? true : false : unknown extends b ? true : {} extends b ? true : b extends Primitives ? a extends b ? true : b extends a ? true : false : Equal<a, b> extends true ? true : b extends readonly any[] ? a extends readonly any[] ? All<[IsLiteral<Length<a>>, IsLiteral<Length<b>>]> extends true ? Equal<Length<a>, Length<b>> extends false ? false : IsMatchingTuple<a, b> : IsMatchingArray<a, b> : false : IsPlainObject<b> extends true ? true extends (a extends any ? [keyof b & keyof a] extends [never] ? false : {
+    [k in keyof b & keyof a]: IsMatching<a[k], b[k]>;
+}[keyof b & keyof a] extends true ? true : false : never) ? true : false : b extends a ? true : false;
+export {};

package/dist/types/IsMatching.d.ts

@@ -0,0 +1,13 @@
+import { Primitives, IsPlainObject, IsUnion, ValueOf, Length, IsLiteral, All, Equal } from './helpers.js';
+type IsMatchingTuple<a extends readonly any[], b extends readonly any[]> = [
+    a,
+    b
+] extends [readonly [], readonly []] ? true : [a, b] extends [
+    readonly [infer a1, ...infer aRest],
+    readonly [infer b1, ...infer bRest]
+] ? IsMatching<a1, b1> extends true ? IsMatchingTuple<aRest, bRest> : false : false;
+type IsMatchingArray<a extends readonly any[], b extends readonly any[]> = b extends readonly [] ? true : b extends readonly [infer b1, ...infer bRest] ? a extends readonly [infer a1, ...infer aRest] ? IsMatching<a1, b1> extends true ? IsMatchingArray<aRest, bRest> : false : a extends readonly [] ? false : IsMatching<ValueOf<a>, b1> extends true ? IsMatchingArray<a, bRest> : false : b extends readonly [...infer bInit, infer b1] ? a extends readonly [...infer aInit, infer a1] ? IsMatching<a1, b1> extends true ? IsMatchingArray<aInit, bInit> : false : a extends readonly [] ? false : IsMatching<ValueOf<a>, b1> extends true ? IsMatchingArray<a, bInit> : false : IsMatching<ValueOf<a>, ValueOf<b>>;
+export type IsMatching<a, b> = true extends IsUnion<a> | IsUnion<b> ? true extends (b extends any ? (a extends any ? IsMatching<a, b> : never) : never) ? true : false : unknown extends b ? true : {} extends b ? true : b extends Primitives ? a extends b ? true : b extends a ? true : false : Equal<a, b> extends true ? true : b extends readonly any[] ? a extends readonly any[] ? All<[IsLiteral<Length<a>>, IsLiteral<Length<b>>]> extends true ? Equal<Length<a>, Length<b>> extends false ? false : IsMatchingTuple<a, b> : IsMatchingArray<a, b> : false : IsPlainObject<b> extends true ? true extends (a extends any ? [keyof b & keyof a] extends [never] ? false : {
+    [k in keyof b & keyof a]: IsMatching<a[k], b[k]>;
+}[keyof b & keyof a] extends true ? true : false : never) ? true : false : b extends a ? true : false;
+export {};

package/dist/types/Match.d.cts

@@ -0,0 +1,171 @@
+import type * as symbols from '../internals/symbols.cjs';
+import type { Pattern, MatchedValue } from './Pattern.cjs';
+import type { InvertPatternForExclude, InvertPattern } from './InvertPattern.cjs';
+import type { DeepExclude } from './DeepExclude.cjs';
+import type { Union, GuardValue, IsNever } from './helpers.cjs';
+import type { FindSelected } from './FindSelected.cjs';
+export type PickReturnValue<a, b> = a extends symbols.unset ? b : a;
+interface NonExhaustiveError<i> {
+    __nonExhaustive: never;
+}
+interface TSPatternError<i> {
+    __nonExhaustive: never;
+}
+/**
+ * #### Match
+ * An interface to create a pattern matching clause.
+ */
+export type Match<i, o, handledCases extends any[] = [], inferredOutput = never> = {
+    /**
+     * `.with(pattern, handler)` Registers a pattern and an handler function that
+     * will be called if the pattern matches the input value.
+     *
+     * [Read the documentation for `.with()` on GitHub](https://github.com/gvergnaud/ts-pattern#with)
+     **/
+    with<const p extends Pattern<i>, c, value extends MatchedValue<i, InvertPattern<p, i>>>(pattern: IsNever<p> extends true ? Pattern<i> : p, handler: (selections: FindSelected<value, p>, value: value) => PickReturnValue<o, c>): InvertPatternForExclude<p, value> extends infer excluded ? Match<Exclude<i, excluded>, o, [
+        ...handledCases,
+        excluded
+    ], Union<inferredOutput, c>> : never;
+    with<const p1 extends Pattern<i>, const p2 extends Pattern<i>, c, p extends p1 | p2, value extends p extends any ? MatchedValue<i, InvertPattern<p, i>> : never>(p1: p1, p2: p2, handler: (value: value) => PickReturnValue<o, c>): [
+        InvertPatternForExclude<p1, value>,
+        InvertPatternForExclude<p2, value>
+    ] extends [infer excluded1, infer excluded2] ? Match<Exclude<i, excluded1 | excluded2>, o, [
+        ...handledCases,
+        excluded1,
+        excluded2
+    ], Union<inferredOutput, c>> : never;
+    with<const p1 extends Pattern<i>, const p2 extends Pattern<i>, const p3 extends Pattern<i>, const ps extends readonly Pattern<i>[], c, p extends p1 | p2 | p3 | ps[number], value extends MatchedValue<i, InvertPattern<p, i>>>(...args: [
+        p1: p1,
+        p2: p2,
+        p3: p3,
+        ...patterns: ps,
+        handler: (value: value) => PickReturnValue<o, c>
+    ]): [
+        InvertPatternForExclude<p1, value>,
+        InvertPatternForExclude<p2, value>,
+        InvertPatternForExclude<p3, value>,
+        MakeTuples<ps, value>
+    ] extends [
+        infer excluded1,
+        infer excluded2,
+        infer excluded3,
+        infer excludedRest
+    ] ? Match<Exclude<i, excluded1 | excluded2 | excluded3 | Extract<excludedRest, any[]>[number]>, o, [
+        ...handledCases,
+        excluded1,
+        excluded2,
+        excluded3,
+        ...Extract<excludedRest, any[]>
+    ], Union<inferredOutput, c>> : never;
+    with<const pat extends Pattern<i>, pred extends (value: MatchedValue<i, InvertPattern<pat, i>>) => unknown, c, value extends GuardValue<pred>>(pattern: pat, predicate: pred, handler: (selections: FindSelected<value, pat>, value: value) => PickReturnValue<o, c>): pred extends (value: any) => value is infer narrowed ? Match<Exclude<i, narrowed>, o, [
+        ...handledCases,
+        narrowed
+    ], Union<inferredOutput, c>> : Match<i, o, handledCases, Union<inferredOutput, c>>;
+    /**
+     * `.when(predicate, handler)` Registers a predicate function and an handler function.
+     * If the predicate returns true, the handler function will be called.
+     *
+     * [Read the documentation for `.when()` on GitHub](https://github.com/gvergnaud/ts-pattern#when)
+     **/
+    when<pred extends (value: i) => unknown, c, value extends GuardValue<pred>>(predicate: pred, handler: (value: value) => PickReturnValue<o, c>): pred extends (value: any) => value is infer narrowed ? Match<Exclude<i, narrowed>, o, [
+        ...handledCases,
+        narrowed
+    ], Union<inferredOutput, c>> : Match<i, o, handledCases, Union<inferredOutput, c>>;
+    /**
+     * `.otherwise()` takes a **default handler function** that will be
+     * called if no previous pattern matched your input.
+     *
+     * Equivalent to `.with(P._, () => x).exhaustive()`
+     *
+     * [Read the documentation for `.otherwise()` on GitHub](https://github.com/gvergnaud/ts-pattern#otherwise)
+     *
+     **/
+    otherwise<c>(handler: (value: i) => PickReturnValue<o, c>): PickReturnValue<o, Union<inferredOutput, c>>;
+    /**
+     * `.exhaustive()` checks that all cases are handled, and returns the result value.
+     *
+     * If you get a `NonExhaustiveError`, it means that you aren't handling
+     * all cases. You should probably add another `.with(...)` clause
+     * to match the missing case and prevent runtime errors.
+     *
+     * [Read the documentation for `.exhaustive()` on GitHub](https://github.com/gvergnaud/ts-pattern#exhaustive)
+     *
+     */
+    exhaustive: DeepExcludeAll<i, handledCases> extends infer remainingCases ? [remainingCases] extends [never] ? Exhaustive<o, inferredOutput> : NonExhaustiveError<remainingCases> : never;
+    /**
+     * `.run()` return the resulting value.
+     *
+     * ⚠️ calling this function is unsafe, and may throw if no pattern matches your input.
+     */
+    run(): PickReturnValue<o, inferredOutput>;
+    /**
+     * `.returnType<T>()` Lets you specify the return type for all of your branches.
+     *
+     * [Read the documentation for `.returnType()` on GitHub](https://github.com/gvergnaud/ts-pattern#returnType)
+     */
+    returnType: [inferredOutput] extends [never] ? <output>() => Match<i, output, handledCases> : TSPatternError<'calling `.returnType<T>()` is only allowed directly after `match(...)`.'>;
+    /**
+     * `.narrow()` narrows the input type to exclude all cases that have previously been handled.
+     *
+     * `.narrow()` is only useful if you want to excluded cases from union types or nullable
+     * properties that are deeply nested. Handled cases from top level union types are excluded
+     * by default.
+     *
+     * [Read the documentation for `.narrow() on GitHub](https://github.com/gvergnaud/ts-pattern#narrow)
+     */
+    narrow(): Match<DeepExcludeAll<i, handledCases>, o, [], inferredOutput>;
+};
+/**
+ * Potential for optimization here:
+ *
+ * Since DeepExclude distributes the union of the input type, it can
+ * generate very large union types on patterns touching several unions at once.
+ * If we were sorting patterns from those which distribute the smallest
+ * amount of union types to those which distribute the largest, we would eliminate
+ * cheap cases more quickly and have less cases in the input type for patterns
+ * that will be expensive to exclude.
+ *
+ * This pre supposes that we have a cheap way of telling if the number
+ * of union types a pattern touches and a cheap way of sorting the tuple
+ * of patterns.
+ * - For the first part, we could reuse `FindMatchingUnions` and pick the `length`
+ *   of the returned tuple.
+ * - For the second part though I'm not aware a cheap way of sorting a tuple.
+ */
+type DeepExcludeAll<a, tupleList extends any[]> = [a] extends [never] ? never : tupleList extends [infer excluded, ...infer tail] ? DeepExcludeAll<DeepExclude<a, excluded>, tail> : a;
+type MakeTuples<ps extends readonly any[], value> = {
+    -readonly [index in keyof ps]: InvertPatternForExclude<ps[index], value>;
+};
+/**
+ * The type of an overloaded function for `.exhaustive`,
+ * permitting calling it with or without a catch-all handler function.
+ *
+ * By default, TS-Pattern will throw an error if a runtime value isn't handled.
+ */
+type Exhaustive<output, inferredOutput> = {
+    /**
+     * `.exhaustive()` checks that all cases are handled, and returns the result value.
+     *
+     * If you get a `NonExhaustiveError`, it means that you aren't handling
+     * all cases. You should probably add another `.with(...)` clause
+     * to match the missing case and prevent runtime errors.
+     *
+     * [Read the documentation for `.exhaustive()` on GitHub](https://github.com/gvergnaud/ts-pattern#exhaustive)
+     *
+     */
+    (): PickReturnValue<output, inferredOutput>;
+    /**
+     * `.exhaustive(fallback)` checks that all cases are handled and returns the result value.
+     *
+     * The fallback function will be called if your input value doesn't match any pattern.
+     * This can only happen if the value you passed to `match` has an incorrect type.
+     *
+     * If you get a `NonExhaustiveError`, it means that you aren't handling
+     * all cases. You should probably add another `.with(...)` clause
+     * to match the missing case.
+     *
+     * [Read the documentation for `.exhaustive()` on GitHub](https://github.com/gvergnaud/ts-pattern#exhaustive)
+     */
+    <otherOutput>(handler: (unexpectedValue: unknown) => PickReturnValue<output, otherOutput>): PickReturnValue<output, Union<inferredOutput, otherOutput>>;
+};
+export {};

package/dist/types/Match.d.ts

@@ -0,0 +1,171 @@
+import type * as symbols from '../internals/symbols.js';
+import type { Pattern, MatchedValue } from './Pattern.js';
+import type { InvertPatternForExclude, InvertPattern } from './InvertPattern.js';
+import type { DeepExclude } from './DeepExclude.js';
+import type { Union, GuardValue, IsNever } from './helpers.js';
+import type { FindSelected } from './FindSelected.js';
+export type PickReturnValue<a, b> = a extends symbols.unset ? b : a;
+interface NonExhaustiveError<i> {
+    __nonExhaustive: never;
+}
+interface TSPatternError<i> {
+    __nonExhaustive: never;
+}
+/**
+ * #### Match
+ * An interface to create a pattern matching clause.
+ */
+export type Match<i, o, handledCases extends any[] = [], inferredOutput = never> = {
+    /**
+     * `.with(pattern, handler)` Registers a pattern and an handler function that
+     * will be called if the pattern matches the input value.
+     *
+     * [Read the documentation for `.with()` on GitHub](https://github.com/gvergnaud/ts-pattern#with)
+     **/
+    with<const p extends Pattern<i>, c, value extends MatchedValue<i, InvertPattern<p, i>>>(pattern: IsNever<p> extends true ? Pattern<i> : p, handler: (selections: FindSelected<value, p>, value: value) => PickReturnValue<o, c>): InvertPatternForExclude<p, value> extends infer excluded ? Match<Exclude<i, excluded>, o, [
+        ...handledCases,
+        excluded
+    ], Union<inferredOutput, c>> : never;
+    with<const p1 extends Pattern<i>, const p2 extends Pattern<i>, c, p extends p1 | p2, value extends p extends any ? MatchedValue<i, InvertPattern<p, i>> : never>(p1: p1, p2: p2, handler: (value: value) => PickReturnValue<o, c>): [
+        InvertPatternForExclude<p1, value>,
+        InvertPatternForExclude<p2, value>
+    ] extends [infer excluded1, infer excluded2] ? Match<Exclude<i, excluded1 | excluded2>, o, [
+        ...handledCases,
+        excluded1,
+        excluded2
+    ], Union<inferredOutput, c>> : never;
+    with<const p1 extends Pattern<i>, const p2 extends Pattern<i>, const p3 extends Pattern<i>, const ps extends readonly Pattern<i>[], c, p extends p1 | p2 | p3 | ps[number], value extends MatchedValue<i, InvertPattern<p, i>>>(...args: [
+        p1: p1,
+        p2: p2,
+        p3: p3,
+        ...patterns: ps,
+        handler: (value: value) => PickReturnValue<o, c>
+    ]): [
+        InvertPatternForExclude<p1, value>,
+        InvertPatternForExclude<p2, value>,
+        InvertPatternForExclude<p3, value>,
+        MakeTuples<ps, value>
+    ] extends [
+        infer excluded1,
+        infer excluded2,
+        infer excluded3,
+        infer excludedRest
+    ] ? Match<Exclude<i, excluded1 | excluded2 | excluded3 | Extract<excludedRest, any[]>[number]>, o, [
+        ...handledCases,
+        excluded1,
+        excluded2,
+        excluded3,
+        ...Extract<excludedRest, any[]>
+    ], Union<inferredOutput, c>> : never;
+    with<const pat extends Pattern<i>, pred extends (value: MatchedValue<i, InvertPattern<pat, i>>) => unknown, c, value extends GuardValue<pred>>(pattern: pat, predicate: pred, handler: (selections: FindSelected<value, pat>, value: value) => PickReturnValue<o, c>): pred extends (value: any) => value is infer narrowed ? Match<Exclude<i, narrowed>, o, [
+        ...handledCases,
+        narrowed
+    ], Union<inferredOutput, c>> : Match<i, o, handledCases, Union<inferredOutput, c>>;
+    /**
+     * `.when(predicate, handler)` Registers a predicate function and an handler function.
+     * If the predicate returns true, the handler function will be called.
+     *
+     * [Read the documentation for `.when()` on GitHub](https://github.com/gvergnaud/ts-pattern#when)
+     **/
+    when<pred extends (value: i) => unknown, c, value extends GuardValue<pred>>(predicate: pred, handler: (value: value) => PickReturnValue<o, c>): pred extends (value: any) => value is infer narrowed ? Match<Exclude<i, narrowed>, o, [
+        ...handledCases,
+        narrowed
+    ], Union<inferredOutput, c>> : Match<i, o, handledCases, Union<inferredOutput, c>>;
+    /**
+     * `.otherwise()` takes a **default handler function** that will be
+     * called if no previous pattern matched your input.
+     *
+     * Equivalent to `.with(P._, () => x).exhaustive()`
+     *
+     * [Read the documentation for `.otherwise()` on GitHub](https://github.com/gvergnaud/ts-pattern#otherwise)
+     *
+     **/
+    otherwise<c>(handler: (value: i) => PickReturnValue<o, c>): PickReturnValue<o, Union<inferredOutput, c>>;
+    /**
+     * `.exhaustive()` checks that all cases are handled, and returns the result value.
+     *
+     * If you get a `NonExhaustiveError`, it means that you aren't handling
+     * all cases. You should probably add another `.with(...)` clause
+     * to match the missing case and prevent runtime errors.
+     *
+     * [Read the documentation for `.exhaustive()` on GitHub](https://github.com/gvergnaud/ts-pattern#exhaustive)
+     *
+     */
+    exhaustive: DeepExcludeAll<i, handledCases> extends infer remainingCases ? [remainingCases] extends [never] ? Exhaustive<o, inferredOutput> : NonExhaustiveError<remainingCases> : never;
+    /**
+     * `.run()` return the resulting value.
+     *
+     * ⚠️ calling this function is unsafe, and may throw if no pattern matches your input.
+     */
+    run(): PickReturnValue<o, inferredOutput>;
+    /**
+     * `.returnType<T>()` Lets you specify the return type for all of your branches.
+     *
+     * [Read the documentation for `.returnType()` on GitHub](https://github.com/gvergnaud/ts-pattern#returnType)
+     */
+    returnType: [inferredOutput] extends [never] ? <output>() => Match<i, output, handledCases> : TSPatternError<'calling `.returnType<T>()` is only allowed directly after `match(...)`.'>;
+    /**
+     * `.narrow()` narrows the input type to exclude all cases that have previously been handled.
+     *
+     * `.narrow()` is only useful if you want to excluded cases from union types or nullable
+     * properties that are deeply nested. Handled cases from top level union types are excluded
+     * by default.
+     *
+     * [Read the documentation for `.narrow() on GitHub](https://github.com/gvergnaud/ts-pattern#narrow)
+     */
+    narrow(): Match<DeepExcludeAll<i, handledCases>, o, [], inferredOutput>;
+};
+/**
+ * Potential for optimization here:
+ *
+ * Since DeepExclude distributes the union of the input type, it can
+ * generate very large union types on patterns touching several unions at once.
+ * If we were sorting patterns from those which distribute the smallest
+ * amount of union types to those which distribute the largest, we would eliminate
+ * cheap cases more quickly and have less cases in the input type for patterns
+ * that will be expensive to exclude.
+ *
+ * This pre supposes that we have a cheap way of telling if the number
+ * of union types a pattern touches and a cheap way of sorting the tuple
+ * of patterns.
+ * - For the first part, we could reuse `FindMatchingUnions` and pick the `length`
+ *   of the returned tuple.
+ * - For the second part though I'm not aware a cheap way of sorting a tuple.
+ */
+type DeepExcludeAll<a, tupleList extends any[]> = [a] extends [never] ? never : tupleList extends [infer excluded, ...infer tail] ? DeepExcludeAll<DeepExclude<a, excluded>, tail> : a;
+type MakeTuples<ps extends readonly any[], value> = {
+    -readonly [index in keyof ps]: InvertPatternForExclude<ps[index], value>;
+};
+/**
+ * The type of an overloaded function for `.exhaustive`,
+ * permitting calling it with or without a catch-all handler function.
+ *
+ * By default, TS-Pattern will throw an error if a runtime value isn't handled.
+ */
+type Exhaustive<output, inferredOutput> = {
+    /**
+     * `.exhaustive()` checks that all cases are handled, and returns the result value.
+     *
+     * If you get a `NonExhaustiveError`, it means that you aren't handling
+     * all cases. You should probably add another `.with(...)` clause
+     * to match the missing case and prevent runtime errors.
+     *
+     * [Read the documentation for `.exhaustive()` on GitHub](https://github.com/gvergnaud/ts-pattern#exhaustive)
+     *
+     */
+    (): PickReturnValue<output, inferredOutput>;
+    /**
+     * `.exhaustive(fallback)` checks that all cases are handled and returns the result value.
+     *
+     * The fallback function will be called if your input value doesn't match any pattern.
+     * This can only happen if the value you passed to `match` has an incorrect type.
+     *
+     * If you get a `NonExhaustiveError`, it means that you aren't handling
+     * all cases. You should probably add another `.with(...)` clause
+     * to match the missing case.
+     *
+     * [Read the documentation for `.exhaustive()` on GitHub](https://github.com/gvergnaud/ts-pattern#exhaustive)
+     */
+    <otherOutput>(handler: (unexpectedValue: unknown) => PickReturnValue<output, otherOutput>): PickReturnValue<output, Union<inferredOutput, otherOutput>>;
+};
+export {};