@duplojs/utils 0.3.1 → 1.0.1

package/dist/object/transformProperties.d.ts

@@ -0,0 +1,10 @@
+import { type Adaptor, type FixDeepFunctionInfer, type AnyFunction, type SimplifyTopLevel } from "../common";
+type TransformObject<GenericObjectInput extends object = object> = {
+    [Prop in keyof GenericObjectInput]?: (input: GenericObjectInput[Prop]) => unknown;
+};
+type ComputesResult<GenericObjectInput extends object, GenericTransformObject extends TransformObject<GenericObjectInput>> = SimplifyTopLevel<Omit<GenericObjectInput, keyof GenericTransformObject> & {
+    [Prop in keyof GenericTransformObject]: (ReturnType<Adaptor<GenericTransformObject[Prop], AnyFunction>> | (undefined extends GenericTransformObject[Prop] ? GenericObjectInput[Adaptor<Prop, keyof GenericObjectInput>] : never));
+}>;
+export declare function transformProperties<GenericObjectInput extends object, GenericTransformObject extends TransformObject<NoInfer<GenericObjectInput>>>(transformObject: TransformObject<NoInfer<GenericObjectInput>> & GenericTransformObject): (obj: GenericObjectInput) => ComputesResult<NoInfer<GenericObjectInput>, NoInfer<GenericTransformObject>>;
+export declare function transformProperties<GenericObjectInput extends object, GenericTransformObject extends TransformObject<GenericObjectInput>>(obj: GenericObjectInput, transformObject: FixDeepFunctionInfer<TransformObject<GenericObjectInput>, GenericTransformObject>): ComputesResult<GenericObjectInput, GenericTransformObject>;
+export {};

package/dist/object/transformProperties.mjs

@@ -0,0 +1,16 @@
+function transformProperties(...args) {
+    if (args.length === 1) {
+        const [transformers] = args;
+        return (obj) => transformProperties(obj, transformers);
+    }
+    const [obj, transformObject] = args;
+    return Object.entries(transformObject)
+        .reduce((acc, [key, theFunction]) => {
+        if (theFunction) {
+            acc[key] = theFunction(acc[key]);
+        }
+        return acc;
+    }, { ...obj });
+}
+
+export { transformProperties };

package/dist/object/transformProperty.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+function transformProperty(...args) {
+    if (args.length === 2) {
+        const [key, transform] = args;
+        return (obj) => transformProperty(obj, key, transform);
+    }
+    const [obj, key, transform] = args;
+    return {
+        ...obj,
+        [key]: transform(obj[key]),
+    };
+}
+
+exports.transformProperty = transformProperty;

package/dist/object/transformProperty.d.ts

@@ -0,0 +1,7 @@
+import { type SimplifyTopLevel } from "../common";
+export declare function transformProperty<GenericObject extends object, GenericKey extends keyof GenericObject, GenericNewValue extends unknown>(key: GenericKey, transform: (value: GenericObject[GenericKey]) => GenericNewValue): (obj: GenericObject) => SimplifyTopLevel<{
+    [Prop in GenericKey]: GenericNewValue;
+} & Omit<GenericObject, GenericKey>>;
+export declare function transformProperty<GenericObject extends object, GenericKey extends keyof GenericObject, GenericNewValue extends unknown>(obj: GenericObject, key: GenericKey, transform: (value: GenericObject[GenericKey]) => GenericNewValue): SimplifyTopLevel<{
+    [Prop in GenericKey]: GenericNewValue;
+} & Omit<GenericObject, GenericKey>>;

package/dist/object/transformProperty.mjs

@@ -0,0 +1,13 @@
+function transformProperty(...args) {
+    if (args.length === 2) {
+        const [key, transform] = args;
+        return (obj) => transformProperty(obj, key, transform);
+    }
+    const [obj, key, transform] = args;
+    return {
+        ...obj,
+        [key]: transform(obj[key]),
+    };
+}
+
+export { transformProperty };

package/dist/object/types/UnionObjectToIntersection.d.ts

@@ -0,0 +1,2 @@
+import { type UnionToIntersection } from "../../common";
+export type UnionObjectToIntersection<GenericValue extends object> = UnionToIntersection<GenericValue> extends infer InferredObject extends object ? InferredObject : never;

package/dist/object/types/assignObjects.d.ts

@@ -0,0 +1,2 @@
+import { type SimplifyTopLevel } from "../../common/types/simplifyTopLevel";
+export type AssignObjects<GenericFirstObject extends object, GenericSecondObject extends object> = SimplifyTopLevel<Omit<GenericFirstObject, keyof GenericSecondObject> & GenericSecondObject>;

package/dist/object/types/flatObject.d.ts

@@ -0,0 +1,25 @@
+import { type TupleHasSpread } from "../../array";
+import { type AnyTuple, type IsEqual } from "../../common";
+export type FlatObject<GenericObject extends object, GenericPath extends string = ""> = GenericObject extends object ? ((Exclude<GenericObject, readonly any[]> extends infer InferredObject extends object ? IsEqual<InferredObject, never> extends true ? never : {
+    [Prop in Extract<keyof InferredObject, string | number>]: InferredObject[Prop] extends object ? FlatObject<InferredObject[Prop], `${GenericPath}.${Prop}`> : {
+        path: `${GenericPath}.${Prop}`;
+        value: InferredObject[Prop];
+    };
+}[Extract<keyof InferredObject, string | number>] : never) | (GenericObject extends AnyTuple ? TupleHasSpread<GenericObject> extends true ? never : GenericObject extends readonly [
+    ...infer InferredRest,
+    infer InferredLast
+] ? ((InferredLast extends object ? FlatObject<InferredLast, `${GenericPath}.[${InferredRest["length"]}]`> : {
+    path: `${GenericPath}.[${InferredRest["length"]}]`;
+    value: InferredLast;
+}) | (IsEqual<InferredRest, []> extends true ? never : FlatObject<InferredRest, GenericPath>)) : never : never) | (GenericObject extends AnyTuple ? TupleHasSpread<GenericObject> extends true ? GenericObject[number] extends infer InferredValue ? InferredValue extends object ? FlatObject<InferredValue, `${GenericPath}.[number]`> : {
+    path: `${GenericPath}.[number]`;
+    value: InferredValue;
+} : never : never : never) | (Exclude<Extract<GenericObject, readonly any[]>, AnyTuple> extends infer InferredArray extends readonly any[] ? IsEqual<InferredArray, never> extends true ? never : InferredArray[number] extends infer InferredValue ? InferredValue extends object ? FlatObject<InferredValue, `${GenericPath}.[number]`> : {
+    path: `${GenericPath}.[number]`;
+    value: InferredValue;
+} : never : never)) extends infer InferredResult extends {
+    path: string;
+    value: any;
+} ? IsEqual<GenericPath, ""> extends true ? IsEqual<InferredResult, never> extends true ? {} : {
+    [Result in InferredResult as Result["path"] extends `.${infer inferredPath}` ? inferredPath : never]: Result["value"];
+} : InferredResult : never : never;

package/dist/object/types/getPropsWithValue.d.ts

@@ -0,0 +1,4 @@
+import { type IsEqual } from "../../common";
+export type GetPropsWithValue<GenericObject extends object, GenericValue extends unknown> = {
+    [Prop in keyof GenericObject]: IsEqual<GenericObject[Prop], GenericValue> extends true ? Prop : never;
+}[keyof GenericObject];

package/dist/object/types/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./assignObjects";
+export * from "./partialKeys";
+export * from "./requiredKeys";
+export * from "./UnionObjectToIntersection";
+export * from "./getPropsWithValue";
+export * from "./flatObject";

package/dist/object/types/partialKeys.d.ts

@@ -0,0 +1,2 @@
+import { type SimplifyTopLevel } from "../../common";
+export type PartialKeys<T extends object, K extends keyof T = keyof T> = SimplifyTopLevel<Omit<T, K> & Partial<Pick<T, K>>>;

package/dist/object/types/requiredKeys.d.ts

@@ -0,0 +1,2 @@
+import { type SimplifyTopLevel } from "../../common/types/simplifyTopLevel";
+export type RequiredKeys<GenericObject extends object, GenericKeys extends keyof GenericObject = keyof GenericObject> = SimplifyTopLevel<Required<Pick<GenericObject, GenericKeys>> & GenericObject>;

package/dist/object/values.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function values(object) {
+    return Object.values(object);
+}
+
+exports.values = values;

package/dist/object/values.d.ts

@@ -0,0 +1,4 @@
+import { type AnyValue } from "../common/types/anyValue";
+export declare function values<GenericValue extends AnyValue>(object: {
+    [key: string]: GenericValue;
+} | ArrayLike<GenericValue>): GenericValue[];

package/dist/object/values.mjs

@@ -0,0 +1,5 @@
+function values(object) {
+    return Object.values(object);
+}
+
+export { values };

package/dist/pattern/exhaustive.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+var unwrap = require('../common/unwrap.cjs');
+
+function exhaustive(result) {
+    return unwrap.unwrap(result);
+}
+
+exports.exhaustive = exhaustive;

package/dist/pattern/exhaustive.d.ts

@@ -0,0 +1,3 @@
+import { type Unwrap } from "../common";
+import { type PatternResult } from "./result";
+export declare function exhaustive<const GenericValue extends unknown, GenericResult extends PatternResult<GenericValue>>(result: GenericResult): Unwrap<GenericResult>;

package/dist/pattern/exhaustive.mjs

@@ -0,0 +1,7 @@
+import { unwrap } from '../common/unwrap.mjs';
+
+function exhaustive(result) {
+    return unwrap(result);
+}
+
+export { exhaustive };

package/dist/pattern/index.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var result = require('./result.cjs');
+var exhaustive = require('./exhaustive.cjs');
+var otherwise = require('./otherwise.cjs');
+var matchPrimitive = require('./matchPrimitive.cjs');
+var match = require('./match.cjs');
+var isMatch = require('./isMatch.cjs');
+var pattern = require('./types/pattern.cjs');
+var union = require('./union.cjs');
+
+
+
+exports.isResult = result.isResult;
+exports.result = result.result;
+exports.exhaustive = exhaustive.exhaustive;
+exports.otherwise = otherwise.otherwise;
+exports.matchPrimitive = matchPrimitive.matchPrimitive;
+exports.match = match.match;
+exports.isMatch = isMatch.isMatch;
+exports.SymbolToolPatternFunctionLabel = pattern.SymbolToolPatternFunctionLabel;
+exports.union = union.union;

package/dist/pattern/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./result";
+export * from "./exhaustive";
+export * from "./otherwise";
+export * from "./matchPrimitive";
+export * from "./match";
+export * from "./isMatch";
+export * from "./types";
+export * from "./union";

package/dist/pattern/index.mjs

@@ -0,0 +1,8 @@
+export { isResult, result } from './result.mjs';
+export { exhaustive } from './exhaustive.mjs';
+export { otherwise } from './otherwise.mjs';
+export { matchPrimitive } from './matchPrimitive.mjs';
+export { match } from './match.mjs';
+export { isMatch } from './isMatch.mjs';
+export { SymbolToolPatternFunctionLabel } from './types/pattern.mjs';
+export { union } from './union.mjs';

package/dist/pattern/isMatch.cjs

@@ -0,0 +1,44 @@
+'use strict';
+
+var pattern = require('./types/pattern.cjs');
+
+const SymbolToolPatternFunction = Symbol.for(pattern.SymbolToolPatternFunctionLabel);
+function isMatch(input, pattern) {
+    if (typeof pattern === "string"
+        || typeof pattern === "number"
+        || typeof pattern === "boolean"
+        || typeof pattern === "bigint"
+        || pattern === null
+        || pattern === undefined) {
+        return input === pattern;
+    }
+    else if (typeof pattern === "function") {
+        return pattern(input);
+    }
+    else if (pattern instanceof Array && input instanceof Array) {
+        for (const key in pattern) {
+            if (!isMatch(input[key], pattern[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    else if (pattern
+        && typeof pattern === "object"
+        && SymbolToolPatternFunction in pattern) {
+        return pattern[SymbolToolPatternFunction](input);
+    }
+    else if (pattern
+        && typeof pattern === "object"
+        && input && typeof input === "object") {
+        for (const key in pattern) {
+            if (!isMatch(input[key], pattern[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+exports.isMatch = isMatch;

package/dist/pattern/isMatch.d.ts

@@ -0,0 +1,2 @@
+import { type Pattern } from "./types/pattern";
+export declare function isMatch(input: unknown, pattern: Pattern): boolean;

package/dist/pattern/isMatch.mjs

@@ -0,0 +1,42 @@
+import { SymbolToolPatternFunctionLabel } from './types/pattern.mjs';
+
+const SymbolToolPatternFunction = Symbol.for(SymbolToolPatternFunctionLabel);
+function isMatch(input, pattern) {
+    if (typeof pattern === "string"
+        || typeof pattern === "number"
+        || typeof pattern === "boolean"
+        || typeof pattern === "bigint"
+        || pattern === null
+        || pattern === undefined) {
+        return input === pattern;
+    }
+    else if (typeof pattern === "function") {
+        return pattern(input);
+    }
+    else if (pattern instanceof Array && input instanceof Array) {
+        for (const key in pattern) {
+            if (!isMatch(input[key], pattern[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    else if (pattern
+        && typeof pattern === "object"
+        && SymbolToolPatternFunction in pattern) {
+        return pattern[SymbolToolPatternFunction](input);
+    }
+    else if (pattern
+        && typeof pattern === "object"
+        && input && typeof input === "object") {
+        for (const key in pattern) {
+            if (!isMatch(input[key], pattern[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+export { isMatch };

package/dist/pattern/match.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var result = require('./result.cjs');
+var isMatch = require('./isMatch.cjs');
+
+function match(...args) {
+    if (args.length === 2) {
+        const [pattern, theFunction] = args;
+        return (input) => match(input, pattern, theFunction);
+    }
+    const [input, pattern, theFunction] = args;
+    if (isMatch.isMatch(input, pattern)) {
+        return result.result(theFunction(input));
+    }
+    return input;
+}
+
+exports.match = match;

package/dist/pattern/match.d.ts

@@ -0,0 +1,6 @@
+import { type IsEqual, type AnyValue, type EscapeVoid, type FixDeepFunctionInfer } from "../common";
+import { type PatternValue, type Pattern } from "./types/pattern";
+import { type PatternResult } from "./result";
+import { type ComplexMatchedValue, type ComplexUnMatchedValue } from "./types";
+export declare function match<GenericInput extends AnyValue, GenericInputValue extends Exclude<GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, const GenericPattern extends Pattern<GenericInputValue>, GenericPatternValue extends PatternValue<GenericPattern>, GenericOutput extends AnyValue | EscapeVoid, GenericMatchedValue extends Extract<ComplexMatchedValue<GenericInputValue, GenericPatternValue>, any>>(pattern: FixDeepFunctionInfer<Pattern<GenericInputValue>, GenericPattern>, theFunction: (value: Extract<ComplexMatchedValue<GenericInputValue, PatternValue<GenericPattern>>, any>) => GenericOutput): (input: GenericInput | GenericInputValue | GenericInputPatternResult) => ((IsEqual<GenericMatchedValue, never> extends true ? never : PatternResult<GenericOutput>) | GenericInputPatternResult | Extract<ComplexUnMatchedValue<GenericInputValue, GenericPatternValue>, any>);
+export declare function match<GenericInput extends AnyValue, GenericInputValue extends Exclude<GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, const GenericPattern extends Pattern<GenericInputValue>, GenericPatternValue extends PatternValue<GenericPattern>, GenericOutput extends AnyValue | EscapeVoid, GenericMatchedValue extends Extract<ComplexMatchedValue<GenericInputValue, GenericPatternValue>, any>>(input: GenericInput | GenericInputValue | GenericInputPatternResult, pattern: FixDeepFunctionInfer<Pattern<GenericInputValue>, GenericPattern>, theFunction: (value: Extract<ComplexMatchedValue<GenericInputValue, PatternValue<GenericPattern>>, any>) => GenericOutput): ((IsEqual<GenericMatchedValue, never> extends true ? never : PatternResult<GenericOutput>) | GenericInputPatternResult | Extract<ComplexUnMatchedValue<GenericInputValue, GenericPatternValue>, any>);

package/dist/pattern/match.mjs

@@ -0,0 +1,16 @@
+import { result } from './result.mjs';
+import { isMatch } from './isMatch.mjs';
+
+function match(...args) {
+    if (args.length === 2) {
+        const [pattern, theFunction] = args;
+        return (input) => match(input, pattern, theFunction);
+    }
+    const [input, pattern, theFunction] = args;
+    if (isMatch(input, pattern)) {
+        return result(theFunction(input));
+    }
+    return input;
+}
+
+export { match };

package/dist/pattern/matchPrimitive.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var result = require('./result.cjs');
+
+function matchPrimitive(primitive, theFunction) {
+    const formattedPrimitive = primitive instanceof Array
+        ? primitive
+        : [primitive];
+    return (input) => {
+        if (!result.isResult(input) && formattedPrimitive.includes(input)) {
+            return result.result(theFunction(input));
+        }
+        return input;
+    };
+}
+
+exports.matchPrimitive = matchPrimitive;

package/dist/pattern/matchPrimitive.d.ts

@@ -0,0 +1,3 @@
+import { type AnyValue } from "..";
+import { type PatternResult } from "./result";
+export declare function matchPrimitive<GenericInput extends AnyValue, GenericMatch extends Exclude<GenericInput, PatternResult>, GenericOutput extends AnyValue>(primitive: GenericMatch | GenericMatch[], theFunction: (predicatedInput: Extract<GenericInput, GenericMatch>) => GenericOutput): (input: GenericInput) => PatternResult<GenericOutput> | Exclude<GenericInput, GenericMatch>;

package/dist/pattern/matchPrimitive.mjs

@@ -0,0 +1,15 @@
+import { isResult, result } from './result.mjs';
+
+function matchPrimitive(primitive, theFunction) {
+    const formattedPrimitive = primitive instanceof Array
+        ? primitive
+        : [primitive];
+    return (input) => {
+        if (!isResult(input) && formattedPrimitive.includes(input)) {
+            return result(theFunction(input));
+        }
+        return input;
+    };
+}
+
+export { matchPrimitive };

package/dist/pattern/otherwise.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+var unwrap = require('../common/unwrap.cjs');
+var result = require('./result.cjs');
+
+function otherwise(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => otherwise(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    return result.isResult(input)
+        ? unwrap.unwrap(input)
+        : theFunction(input);
+}
+
+exports.otherwise = otherwise;

package/dist/pattern/otherwise.d.ts

@@ -0,0 +1,4 @@
+import { type AnyValue, type Unwrap } from "../common";
+import { type PatternResult } from "./result";
+export declare function otherwise<GenericInput extends AnyValue, GenericInputValue extends Exclude<GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericOutput extends AnyValue>(theFunction: (rest: GenericInputValue) => GenericOutput): (input: GenericInput | GenericInputPatternResult | GenericInputValue) => (GenericOutput | Unwrap<GenericInputPatternResult>);
+export declare function otherwise<GenericInput extends AnyValue, GenericInputValue extends Exclude<GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericOutput extends AnyValue>(input: GenericInput | GenericInputPatternResult | GenericInputValue, theFunction: (rest: GenericInputValue) => GenericOutput): (GenericOutput | Unwrap<GenericInputPatternResult>);

package/dist/pattern/otherwise.mjs

@@ -0,0 +1,15 @@
+import { unwrap } from '../common/unwrap.mjs';
+import { isResult } from './result.mjs';
+
+function otherwise(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (input) => otherwise(input, theFunction);
+    }
+    const [input, theFunction] = args;
+    return isResult(input)
+        ? unwrap(input)
+        : theFunction(input);
+}
+
+export { otherwise };

package/dist/pattern/result.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var kind = require('../common/kind.cjs');
+var wrapValue = require('../common/wrapValue.cjs');
+
+const patternResultKind = kind.createKind("pattern-result");
+function result(value) {
+    return patternResultKind.addTo(wrapValue.wrapValue(value), null);
+}
+const isResult = patternResultKind.has;
+
+exports.isResult = isResult;
+exports.result = result;

package/dist/pattern/result.d.ts

@@ -0,0 +1,7 @@
+import { type Kind, type WrappedValue } from "../common";
+declare const patternResultKind: import("../common").KindHandler<import("../common").KindDefinition<"pattern-result", unknown>>;
+export interface PatternResult<GenericValue extends unknown = unknown> extends Kind<typeof patternResultKind.definition>, WrappedValue<GenericValue> {
+}
+export declare function result<const GenericValue extends unknown>(value: GenericValue): PatternResult<GenericValue>;
+export declare const isResult: <GenericInput extends unknown>(input: GenericInput) => input is Extract<GenericInput, Kind<import("../common").KindDefinition<"pattern-result", unknown>, unknown>>;
+export {};

package/dist/pattern/result.mjs

@@ -0,0 +1,10 @@
+import { createKind } from '../common/kind.mjs';
+import { wrapValue } from '../common/wrapValue.mjs';
+
+const patternResultKind = createKind("pattern-result");
+function result(value) {
+    return patternResultKind.addTo(wrapValue(value), null);
+}
+const isResult = patternResultKind.has;
+
+export { isResult, result };

package/dist/pattern/types/complexMatchedValue/array.d.ts

@@ -0,0 +1,40 @@
+import { type BreakGenericLink, type Adaptor, type AnyTuple, type IsEqual } from "../../../common";
+import { type ComplexMatchedValue } from ".";
+type ComplexMatchedArrayTuple<GenericInput extends unknown, GenericPatternValue extends unknown> = ([
+    Exclude<Extract<GenericInput, any[]>, AnyTuple>,
+    Extract<GenericPatternValue, AnyTuple>
+] extends [
+    infer InferredInput,
+    infer InferredPatternValue
+] ? InferredInput extends any[] ? InferredPatternValue extends AnyTuple ? Extract<InferredInput, InferredPatternValue> extends infer InferredObviousMatchedValue ? IsEqual<InferredObviousMatchedValue, never> extends false ? InferredObviousMatchedValue : InferredPatternValue extends readonly [
+    infer InferredPatternFirst,
+    ...infer InferredPatternRest
+] ? [
+    Extract<ComplexMatchedValue<InferredInput[number], InferredPatternFirst>, any>,
+    ...(InferredPatternRest extends readonly [] ? InferredInput : Adaptor<ComplexMatchedValue<InferredInput, InferredPatternRest>, any[]>)
+] : never : never : never : never : never);
+type ComplexMatchedTupleTuple<GenericInput extends unknown, GenericPatternValue extends unknown> = ([
+    Extract<GenericInput, AnyTuple>,
+    Extract<GenericPatternValue, AnyTuple>
+] extends [
+    infer InferredInput,
+    infer InferredPatternValue
+] ? InferredInput extends any ? InferredPatternValue extends any ? Extract<InferredInput, InferredPatternValue> extends infer InferredObviousMatchedValue ? IsEqual<InferredObviousMatchedValue, never> extends false ? InferredObviousMatchedValue : [
+    InferredInput,
+    InferredPatternValue
+] extends [
+    readonly [infer InferredInputFirst, ...infer inferredInputRest],
+    readonly [infer InferredPatternValueFirst, ...infer inferredPatternValueRest]
+] ? Extract<ComplexMatchedValue<InferredInputFirst, InferredPatternValueFirst>, any> extends infer InferredResult extends InferredInputFirst ? IsEqual<InferredResult, never> extends true ? never : [
+    InferredResult,
+    ...Adaptor<(IsEqual<inferredPatternValueRest[number], never> extends true ? inferredInputRest : ComplexMatchedValue<inferredInputRest, inferredPatternValueRest>), readonly any[]>
+] : never : never : never : never : never : never);
+type ComplexMatchedArrayArray<GenericInput extends unknown, GenericPatternValue extends unknown> = ([
+    Exclude<Extract<GenericInput, readonly any[]>, AnyTuple>,
+    Exclude<Extract<GenericPatternValue, readonly any[]>, AnyTuple>
+] extends [
+    infer InferredInput extends readonly any[],
+    infer InferredPatternValue extends readonly any[]
+] ? IsEqual<InferredPatternValue, never> extends true ? never : InferredPatternValue extends InferredInput ? InferredInput : Extract<ComplexMatchedValue<InferredInput[number], InferredPatternValue[number]>, any>[] : never);
+export type ComplexMatchedArray<GenericInput extends unknown, GenericPatternValue extends unknown> = GenericPatternValue extends readonly [] ? BreakGenericLink<GenericInput> : (ComplexMatchedTupleTuple<GenericInput, GenericPatternValue> | ComplexMatchedArrayTuple<GenericInput, GenericPatternValue> | ComplexMatchedArrayArray<GenericInput, GenericPatternValue>);
+export {};

package/dist/pattern/types/complexMatchedValue/index.d.ts

@@ -0,0 +1,6 @@
+import { type ComplexMatchedPrimitive } from "./primitive";
+import { type ComplexMatchedObject } from "./object";
+import { type ComplexMatchedArray } from "./array";
+import { type PatternValueMaybeAll } from "../pattern";
+import { type ComplexMatchedMaybeAll } from "./maybeAll";
+export type ComplexMatchedValue<GenericInput extends unknown, GenericPatternValue extends unknown> = Exclude<GenericPatternValue, PatternValueMaybeAll> extends infer InferredPatternValue ? (ComplexMatchedPrimitive<GenericInput, InferredPatternValue> | ComplexMatchedObject<GenericInput, InferredPatternValue> | ComplexMatchedArray<GenericInput, InferredPatternValue> | ComplexMatchedMaybeAll<GenericInput, GenericPatternValue>) : never;

package/dist/pattern/types/complexMatchedValue/maybeAll.d.ts

@@ -0,0 +1,3 @@
+import { type Unwrap, type IsEqual } from "../../../common";
+import { type PatternValueMaybeAll } from "../pattern";
+export type ComplexMatchedMaybeAll<GenericInput extends unknown, GenericPatternValue extends unknown> = Extract<GenericPatternValue, PatternValueMaybeAll> extends infer InferredPatternValue ? IsEqual<InferredPatternValue, never> extends true ? never : Extract<Unwrap<InferredPatternValue>, GenericInput> : never;

package/dist/pattern/types/complexMatchedValue/object.d.ts

@@ -0,0 +1,11 @@
+import { type Adaptor, type SimplifyTopLevel, type IsEqual } from "../../../common";
+import { type ComplexMatchedValue } from ".";
+export type ComplexMatchedObject<GenericInput extends unknown, GenericPatternValue extends unknown> = ([
+    Exclude<Extract<GenericInput, object>, readonly any[]>,
+    Exclude<Extract<GenericPatternValue, object>, readonly any[]>
+] extends [
+    infer InferredInput,
+    infer InferredPatternValue
+] ? InferredInput extends any ? InferredPatternValue extends any ? Extract<InferredInput, InferredPatternValue> extends infer InferredObviousMatchedValue ? IsEqual<InferredObviousMatchedValue, never> extends false ? InferredObviousMatchedValue : IsEqual<Extract<keyof InferredInput, keyof InferredPatternValue>, keyof InferredPatternValue> extends false ? never : SimplifyTopLevel<Omit<InferredInput, keyof InferredPatternValue> & {
+    -readonly [Prop in keyof InferredPatternValue]: Extract<ComplexMatchedValue<InferredInput[Adaptor<Prop, keyof InferredInput>], InferredPatternValue[Prop]>, any>;
+}> extends infer InferredResult extends InferredInput ? IsEqual<InferredResult, InferredInput> extends true ? InferredInput : InferredResult : never : never : never : never : never);

package/dist/pattern/types/complexMatchedValue/primitive.d.ts

@@ -0,0 +1,9 @@
+import { type IsEqual } from "../../../common";
+import { type EligiblePrimitiveMatch } from "../pattern";
+export type ComplexMatchedPrimitive<GenericInput extends unknown, GenericPatternValue extends unknown> = ([
+    Extract<GenericInput, EligiblePrimitiveMatch>,
+    Extract<GenericPatternValue, EligiblePrimitiveMatch>
+] extends [
+    infer inferredInput extends EligiblePrimitiveMatch,
+    infer inferredPatternValue extends EligiblePrimitiveMatch
+] ? Extract<inferredInput, inferredPatternValue> extends infer inferredValue ? IsEqual<inferredValue, never> extends true ? inferredPatternValue : inferredValue : never : never);

package/dist/pattern/types/complexUnMatchedValue/array.d.ts

@@ -0,0 +1,27 @@
+import { type Adaptor, type AnyTuple, type IsEqual, type IsUnion } from "../../../common";
+import { type ComplexUnMatchedValue } from ".";
+type ComplexUnMatchedArrayTuple<GenericInput extends unknown, GenericPatternValue extends unknown> = ([
+    Exclude<Extract<GenericInput, readonly any[]>, AnyTuple>,
+    Extract<GenericPatternValue, AnyTuple>
+] extends [
+    infer InferredInput,
+    infer _InferredPatternValue
+] ? InferredInput : never);
+type ComplexUnMatchedTupleTuple<GenericInput extends unknown, GenericPatternValue extends unknown> = ([
+    Extract<GenericInput, AnyTuple>,
+    Extract<GenericPatternValue, AnyTuple>
+] extends [
+    infer InferredInput,
+    infer InferredPatternValue
+] ? IsEqual<InferredPatternValue, never> extends true ? InferredInput : IsUnion<InferredPatternValue> extends true ? never : InferredInput extends InferredPatternValue ? never : [
+    InferredInput,
+    InferredPatternValue
+] extends [
+    readonly [infer InferredInputFirst, ...infer InferredInputRest],
+    readonly [infer InferredPatternValueFirst, ...infer InferredPatternValueRest]
+] ? Extract<ComplexUnMatchedValue<InferredInputFirst, InferredPatternValueFirst>, any> extends infer InferredResultFirst ? InferredPatternValueRest extends readonly [] ? IsEqual<InferredResultFirst, never> extends true ? never : [InferredResultFirst, ...InferredInputRest] : ComplexUnMatchedValue<InferredInputRest, InferredPatternValueRest> extends infer InferredResultRest ? [
+    IsEqual<InferredResultFirst, never> extends true ? InferredInputFirst : InferredResultFirst,
+    ...Adaptor<IsEqual<InferredResultRest, never> extends true ? InferredPatternValueRest : InferredResultRest, readonly any[]>
+] : never : never : never : never);
+export type ComplexUnMatchedArray<GenericInput extends unknown, GenericPatternValue extends unknown> = Exclude<GenericPatternValue, readonly []> extends infer InferredPatternValue ? IsEqual<InferredPatternValue, never> extends true ? never : (ComplexUnMatchedTupleTuple<GenericInput, InferredPatternValue> | ComplexUnMatchedArrayTuple<GenericInput, InferredPatternValue>) : never;
+export {};