@duplojs/utils 0.3.0 → 1.0.0

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 {};

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

@@ -0,0 +1,66 @@
+import { type AnyTuple, type Adaptor, type IsEqual, type Or } from "../../../common";
+import { type PatternValueMaybeAll, type EligiblePrimitiveMatch } from "../pattern";
+import { type FlatObject } from "../../../object";
+import { type ExcludeTuple } from "../../../array/types/excludeTuple";
+export type GetIncompleteUnion<GenericInput extends unknown, GenericPatternValue extends unknown> = (([
+    Extract<GenericInput, EligiblePrimitiveMatch>,
+    Extract<GenericPatternValue, EligiblePrimitiveMatch>
+] extends [
+    infer InferredInput,
+    infer InferredPatternValue
+] ? IsEqual<InferredPatternValue, never> extends true ? never : IsEqual<Exclude<InferredInput, InferredPatternValue>, never> extends true ? {} : true : never) | ([
+    Exclude<Extract<GenericInput, object>, GenericPatternValue | readonly any[]>,
+    Exclude<Extract<GenericPatternValue, object>, readonly any[]>
+] extends [
+    infer InferredInput,
+    infer InferredPatternValue
+] ? IsEqual<InferredPatternValue, never> extends true ? never : IsEqual<InferredInput, Exclude<Extract<GenericInput, object>, readonly any[]>> extends true ? FlatObject<{
+    [Prop in (InferredPatternValue extends any ? keyof InferredPatternValue : never)]: GetIncompleteUnion<InferredInput[Adaptor<Prop, keyof InferredInput>], Extract<InferredPatternValue, {
+        [SubProp in Prop]: any;
+    }>[Prop]>;
+}> : IsEqual<InferredInput, never> extends true ? {} : {
+    "@duplojs/utils/{object}": true;
+} : never) | ([
+    ExcludeTuple<Extract<GenericInput, AnyTuple>, Extract<GenericPatternValue, readonly any[]>>,
+    Extract<GenericPatternValue, AnyTuple | readonly []>
+] extends [
+    infer InferredInput,
+    infer InferredPatternValue
+] ? IsEqual<InferredPatternValue, never> extends true ? never : IsEqual<InferredInput, Extract<GenericInput, AnyTuple>> extends true ? [
+    InferredInput,
+    InferredPatternValue
+] extends [
+    readonly [infer InferredInputFirst, ...infer InferredInputRest],
+    readonly [infer InferredPatternValueFirst, ...infer InferredPatternValueRest]
+] ? GetIncompleteUnion<InferredInputFirst, InferredPatternValueFirst> extends infer InferredResultFirst ? FlatObject<{
+    "@duplojs/utils/[tuple.first": InferredResultFirst;
+    "@duplojs/utils/tuple.rest]": GetIncompleteUnion<InferredInputRest, InferredPatternValueRest>;
+}> : never : never : IsEqual<InferredInput, never> extends true ? {} : {
+    "@duplojs/utils/[tuple]": true;
+} : never) | ([
+    Exclude<Extract<GenericInput, readonly any[]>, AnyTuple>,
+    Extract<GenericPatternValue, AnyTuple>
+] extends [
+    infer InferredInput extends readonly any[],
+    infer InferredPatternValue
+] ? Or<[
+    IsEqual<InferredPatternValue, never>,
+    IsEqual<InferredInput, never>
+]> extends true ? never : InferredPatternValue extends readonly [
+    infer InferredPatternValueFirst,
+    ...infer InferredPatternValueRest
+] ? GetIncompleteUnion<InferredInput[number], InferredPatternValueFirst> extends infer InferredResultFirst ? FlatObject<{
+    "@duplojs/utils/[array.first": InferredResultFirst;
+    "@duplojs/utils/array.rest]": IsEqual<InferredResultFirst, {}> extends true ? GetIncompleteUnion<InferredInput, InferredPatternValueRest> : never;
+}> : {} : {} : never) | (Extract<GenericPatternValue, PatternValueMaybeAll> extends infer InferredPatternValue ? IsEqual<InferredPatternValue, never> extends true ? never : {
+    "@duplojs/utils/{maybeAll}": true;
+} : never) | ([
+    Extract<GenericInput, readonly any[]>,
+    Extract<GenericPatternValue, readonly []>
+] extends [
+    infer InferredInput extends readonly any[],
+    infer InferredPatternValue
+] ? Or<[
+    IsEqual<InferredPatternValue, never>,
+    IsEqual<InferredInput, never>
+]> extends true ? never : {} : never));

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

@@ -0,0 +1,9 @@
+import { type UnionToTuple } from "../../../common";
+import { type GetIncompleteUnion } from "./getIncompleteUnion";
+import { type ComplexUnMatchedPrimitive } from "./primitive";
+import { type ComplexUnMatchedObject } from "./object";
+import { type ComplexUnMatchedUnionObject } from "./unionObject";
+import { type ComplexUnMatchedArray } from "./array";
+import { type PatternValueMaybeAll } from "../pattern";
+import { type ComplexUnMatchedMaybeAll } from "./maybeAll";
+export type ComplexUnMatchedValue<GenericInput extends unknown, GenericPatternValue extends unknown> = UnionToTuple<keyof GetIncompleteUnion<GenericInput, GenericPatternValue>>["length"] extends 0 | 1 ? Exclude<GenericPatternValue, PatternValueMaybeAll> extends infer InferredPatternValue ? (ComplexUnMatchedPrimitive<GenericInput, InferredPatternValue> | ComplexUnMatchedObject<GenericInput, InferredPatternValue> | ComplexUnMatchedArray<GenericInput, InferredPatternValue> | ComplexUnMatchedUnionObject<GenericInput, InferredPatternValue> | ComplexUnMatchedMaybeAll<GenericInput, GenericPatternValue>) : never : GenericInput;

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

@@ -0,0 +1,3 @@
+import { type Unwrap, type IsEqual } from "../../../common";
+import { type PatternValueMaybeAll } from "../pattern";
+export type ComplexUnMatchedMaybeAll<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/complexUnMatchedValue/object.d.ts

@@ -0,0 +1,17 @@
+import { type Adaptor, type SimplifyTopLevel, type IsEqual, type IsUnion, type NeverCoalescing, type RemoveReadonly } from "../../../common";
+import { type ComplexUnMatchedValue } from ".";
+export type ComplexUnMatchedObject<GenericInput extends unknown, GenericPatternValue extends unknown> = ([
+    Exclude<Extract<GenericInput, object>, readonly any[]>,
+    Exclude<Extract<GenericPatternValue, object>, readonly any[]>
+] extends [
+    infer InferredInput,
+    infer InferredPatternValue
+] ? IsEqual<InferredPatternValue, never> extends true ? InferredInput : IsUnion<InferredPatternValue> extends true ? never : InferredInput extends any ? InferredInput extends InferredPatternValue ? never : IsEqual<Extract<keyof InferredInput, keyof InferredPatternValue>, keyof InferredPatternValue> extends false ? InferredInput : (IsEqual<{
+    [Prop in keyof InferredPatternValue]: ComplexUnMatchedValue<InferredInput[Adaptor<Prop, keyof InferredInput>], InferredPatternValue[Prop]>;
+} extends infer InferredObjectArray extends object ? InferredObjectArray[keyof InferredObjectArray] : never, never> extends true ? never : ({
+    -readonly [Prop in keyof InferredPatternValue]: NeverCoalescing<Extract<ComplexUnMatchedValue<InferredInput[Adaptor<Prop, keyof InferredInput>], InferredPatternValue[Prop]>, any>, InferredInput[Adaptor<Prop, keyof InferredInput>]>;
+} & Omit<InferredInput, keyof InferredPatternValue>) extends infer InferredObject extends object ? ({
+    [Prop in keyof InferredObject as undefined extends InferredObject[Prop] ? Prop : never]?: InferredObject[Prop];
+} & {
+    [Prop in keyof InferredObject as undefined extends InferredObject[Prop] ? never : Prop]: InferredObject[Prop];
+}) extends infer InferredResult ? IsEqual<RemoveReadonly<InferredResult>, RemoveReadonly<InferredInput>> extends true ? InferredInput : SimplifyTopLevel<InferredResult> : never : never) : never : never);

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

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

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

@@ -0,0 +1,3 @@
+import { type RemoveDuplicateInUnion, type IsUnion } from "../../../common";
+import { type ComplexUnMatchedValue } from ".";
+export type ComplexUnMatchedUnionObject<GenericInput extends unknown, GenericPatternValue extends unknown> = (IsUnion<Extract<GenericPatternValue, object>> extends false ? never : Extract<GenericPatternValue, any> extends infer InferredPatternValue ? (InferredPatternValue extends object ? ComplexUnMatchedValue<GenericInput, InferredPatternValue> extends infer InferredResult ? ComplexUnMatchedValue<InferredResult, Exclude<GenericPatternValue, InferredPatternValue>> : never : never) extends infer InferredResult ? RemoveDuplicateInUnion<InferredResult> : never : never);

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

@@ -0,0 +1,3 @@
+export * from "./complexMatchedValue";
+export * from "./complexUnMatchedValue";
+export * from "./pattern";

package/dist/pattern/types/pattern.cjs

@@ -0,0 +1,5 @@
+'use strict';
+
+const SymbolToolPatternFunctionLabel = "SymbolToolPatternFunctionLabel";
+
+exports.SymbolToolPatternFunctionLabel = SymbolToolPatternFunctionLabel;

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

@@ -0,0 +1,37 @@
+import { type MergeUnionTuple } from "../../array/types/mergeUnionTuple";
+import { type AnyTuple, type Adaptor, type IsEqual, type ObjectKey, type WrappedValue } from "../../common";
+export type EligiblePrimitiveMatch = string | number | bigint | boolean | undefined | null;
+type PrimitivePattern<GenericInput extends unknown> = GenericInput extends EligiblePrimitiveMatch ? GenericInput : never;
+type ObjectPattern<GenericInput extends unknown> = Exclude<GenericInput, readonly any[]> extends infer InferredInput ? [
+    Extract<InferredInput, object>,
+    InferredInput extends object ? keyof InferredInput : never
+] extends [
+    infer InferredInputObject extends object,
+    infer InferredInputKeyofObject extends ObjectKey
+] ? {
+    readonly [Prop in InferredInputKeyofObject]?: Extract<InferredInputObject, Partial<Record<Prop, any>>> extends infer InferredValue extends object ? Prop extends keyof InferredValue ? Pattern<InferredValue[Prop]> : never : never;
+} extends infer InferredResult ? IsEqual<InferredResult, {}> extends true ? never : InferredResult : never : never : never;
+type ArrayPattern<GenericInput extends unknown> = ((Extract<GenericInput, AnyTuple> extends infer InferredInput extends AnyTuple ? IsEqual<InferredInput, never> extends true ? never : MergeUnionTuple<InferredInput> extends readonly [infer InferredFirst, ...infer InferredRest] ? (readonly [] | readonly [Pattern<InferredFirst>] | (InferredRest extends readonly [] ? never : readonly [
+    Pattern<InferredFirst>,
+    ...Adaptor<Pattern<InferredRest>, readonly any[]>
+])) : never : never) | (Exclude<Extract<GenericInput, readonly any[]>, AnyTuple> extends infer InferredInput extends readonly any[] ? IsEqual<InferredInput, never> extends true ? never : readonly Pattern<InferredInput[number]>[] : never));
+type PredicatePattern<GenericInput extends unknown = any> = (input: GenericInput) => boolean;
+declare const SymbolToolPattern: unique symbol;
+type SymbolToolPattern = typeof SymbolToolPattern;
+export declare const SymbolToolPatternFunctionLabel = "SymbolToolPatternFunctionLabel";
+declare const SymbolToolPatternFunction: unique symbol;
+type SymbolToolPatternFunction = typeof SymbolToolPatternFunction;
+export interface ToolPattern<GenericInput extends unknown = any, GenericPattern extends unknown = any> {
+    [SymbolToolPatternFunction](input: GenericInput): boolean;
+    [SymbolToolPattern]: GenericPattern;
+}
+export type Pattern<GenericInput extends unknown = any> = (PredicatePattern<GenericInput> | ToolPattern<GenericInput> | PrimitivePattern<GenericInput> | ObjectPattern<GenericInput> | ArrayPattern<GenericInput>);
+declare const SymbolPatternValueMaybeAll: unique symbol;
+type SymbolPatternValueMaybeAll = typeof SymbolPatternValueMaybeAll;
+export interface PatternValueMaybeAll<GenericValue extends unknown = any> extends WrappedValue<GenericValue> {
+    [SymbolPatternValueMaybeAll]: unknown;
+}
+export type PatternValue<GenericPattern extends Pattern> = GenericPattern extends EligiblePrimitiveMatch ? GenericPattern : GenericPattern extends (input: any) => input is infer InferredPredicate ? InferredPredicate : GenericPattern extends (input: infer InferredInput) => boolean ? PatternValueMaybeAll<InferredInput> : GenericPattern extends ToolPattern<any, infer InferredPattern> ? PatternValue<InferredPattern> : GenericPattern extends readonly [infer inferredFirst, ...infer inferredRest] ? IsEqual<inferredRest, readonly []> extends true ? [PatternValue<inferredFirst>] : [PatternValue<inferredFirst>, ...Adaptor<PatternValue<inferredRest>, any[]>] : GenericPattern extends readonly [] ? [] : GenericPattern extends readonly any[] ? PatternValue<GenericPattern[number]>[] : GenericPattern extends Record<ObjectKey, Pattern> ? {
+    [Prop in keyof GenericPattern]: PatternValue<GenericPattern[Prop]>;
+} : never;
+export {};

package/dist/pattern/types/pattern.mjs

@@ -0,0 +1,3 @@
+const SymbolToolPatternFunctionLabel = "SymbolToolPatternFunctionLabel";
+
+export { SymbolToolPatternFunctionLabel };

package/dist/pattern/union.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var isMatch = require('./isMatch.cjs');
+var pattern = require('./types/pattern.cjs');
+
+const SymbolToolPatternFunction = Symbol.for(pattern.SymbolToolPatternFunctionLabel);
+function union(...patterns) {
+    return {
+        [SymbolToolPatternFunction]: (input) => {
+            for (const pattern of patterns) {
+                if (isMatch.isMatch(input, pattern)) {
+                    return true;
+                }
+            }
+            return false;
+        },
+    };
+}
+
+exports.union = union;

package/dist/pattern/union.d.ts

@@ -0,0 +1,6 @@
+import { type FixDeepFunctionInfer } from "../common";
+import { type Pattern, type ToolPattern } from "./types/pattern";
+export declare function union<GenericInput extends unknown, const GenericPatterns extends readonly [
+    Pattern<GenericInput extends infer InferredInput ? InferredInput : never>,
+    ...Pattern<GenericInput extends infer InferredInput ? InferredInput : never>[]
+]>(...patterns: FixDeepFunctionInfer<readonly [Pattern<GenericInput>, ...Pattern<GenericInput>[]], GenericPatterns>): ToolPattern<GenericInput, GenericPatterns[number] extends infer InferredPattern ? InferredPattern : never>;

package/dist/pattern/union.mjs

@@ -0,0 +1,18 @@
+import { isMatch } from './isMatch.mjs';
+import { SymbolToolPatternFunctionLabel } from './types/pattern.mjs';
+
+const SymbolToolPatternFunction = Symbol.for(SymbolToolPatternFunctionLabel);
+function union(...patterns) {
+    return {
+        [SymbolToolPatternFunction]: (input) => {
+            for (const pattern of patterns) {
+                if (isMatch(input, pattern)) {
+                    return true;
+                }
+            }
+            return false;
+        },
+    };
+}
+
+export { union };

package/dist/string/at/default.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function at(...args) {
+    if (args.length === 1) {
+        const [index] = args;
+        return (input) => at(input, index);
+    }
+    const [input, index] = args;
+    return input.at(index);
+}
+
+exports.at = at;

package/dist/string/at/default.d.ts

@@ -0,0 +1,2 @@
+export declare function at<GenericString extends string, GenericIndex extends number>(index: GenericIndex): (input: GenericString) => string | undefined;
+export declare function at<GenericString extends string, GenericIndex extends number>(input: GenericString, index: GenericIndex): string | undefined;

package/dist/string/at/default.mjs

@@ -0,0 +1,10 @@
+function at(...args) {
+    if (args.length === 1) {
+        const [index] = args;
+        return (input) => at(input, index);
+    }
+    const [input, index] = args;
+    return input.at(index);
+}
+
+export { at };

package/dist/string/at/first.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function first(input) {
+    return input[0];
+}
+
+exports.first = first;