@duplojs/utils 1.1.15 → 1.2.16

package/dist/object/values.mjs

@@ -1,7 +1,32 @@
 import { isRuntimeKind } from '../common/kind.mjs';
+import '../common/stringToBytes.mjs';
+import '../common/stringToMillisecond.mjs';
 import { isRuntimeWrappedValueKey } from '../common/wrapValue.mjs';
 import '../common/globalStore.mjs';
 import '../common/builder.mjs';
+import '../either/bool/falsy.mjs';
+import '../either/bool/truthy.mjs';
+import '../either/bool/base.mjs';
+import '../either/left/create.mjs';
+import '../either/left/error.mjs';
+import '../either/left/fail.mjs';
+import '../either/kind.mjs';
+import '../either/right/success.mjs';
+import '../either/right/create.mjs';
+import '../either/right/ok.mjs';
+import '../either/future/success.mjs';
+import '../either/future/error.mjs';
+import '../either/future/base.mjs';
+import '../either/nullable/empty.mjs';
+import '../either/nullable/filled.mjs';
+import '../either/nullable/base.mjs';
+import '../either/nullish/empty.mjs';
+import '../either/nullish/filled.mjs';
+import '../either/nullish/base.mjs';
+import '../either/optional/empty.mjs';
+import '../either/optional/filled.mjs';
+import '../either/optional/base.mjs';
+import '../common/override.mjs';
 
 function values(object) {
     return Object.entries(object)

package/dist/pattern/exhaustive.cjs

@@ -1,8 +1,33 @@
 'use strict';
 
+require('../common/stringToBytes.cjs');
+require('../common/stringToMillisecond.cjs');
 var unwrap = require('../common/unwrap.cjs');
 require('../common/globalStore.cjs');
 require('../common/builder.cjs');
+require('../either/bool/falsy.cjs');
+require('../either/bool/truthy.cjs');
+require('../either/bool/base.cjs');
+require('../either/left/create.cjs');
+require('../either/left/error.cjs');
+require('../either/left/fail.cjs');
+require('../either/kind.cjs');
+require('../either/right/success.cjs');
+require('../either/right/create.cjs');
+require('../either/right/ok.cjs');
+require('../either/future/success.cjs');
+require('../either/future/error.cjs');
+require('../either/future/base.cjs');
+require('../either/nullable/empty.cjs');
+require('../either/nullable/filled.cjs');
+require('../either/nullable/base.cjs');
+require('../either/nullish/empty.cjs');
+require('../either/nullish/filled.cjs');
+require('../either/nullish/base.cjs');
+require('../either/optional/empty.cjs');
+require('../either/optional/filled.cjs');
+require('../either/optional/base.cjs');
+require('../common/override.cjs');
 
 function exhaustive(result) {
     return unwrap.unwrap(result);

package/dist/pattern/exhaustive.mjs

@@ -1,6 +1,31 @@
+import '../common/stringToBytes.mjs';
+import '../common/stringToMillisecond.mjs';
 import { unwrap } from '../common/unwrap.mjs';
 import '../common/globalStore.mjs';
 import '../common/builder.mjs';
+import '../either/bool/falsy.mjs';
+import '../either/bool/truthy.mjs';
+import '../either/bool/base.mjs';
+import '../either/left/create.mjs';
+import '../either/left/error.mjs';
+import '../either/left/fail.mjs';
+import '../either/kind.mjs';
+import '../either/right/success.mjs';
+import '../either/right/create.mjs';
+import '../either/right/ok.mjs';
+import '../either/future/success.mjs';
+import '../either/future/error.mjs';
+import '../either/future/base.mjs';
+import '../either/nullable/empty.mjs';
+import '../either/nullable/filled.mjs';
+import '../either/nullable/base.mjs';
+import '../either/nullish/empty.mjs';
+import '../either/nullish/filled.mjs';
+import '../either/nullish/base.mjs';
+import '../either/optional/empty.mjs';
+import '../either/optional/filled.mjs';
+import '../either/optional/base.mjs';
+import '../common/override.mjs';
 
 function exhaustive(result) {
     return unwrap(result);

package/dist/pattern/index.cjs

@@ -3,11 +3,12 @@
 var result = require('./result.cjs');
 var exhaustive = require('./exhaustive.cjs');
 var otherwise = require('./otherwise.cjs');
-var match = require('./match.cjs');
+var index = require('./match/index.cjs');
 var isMatch = require('./isMatch.cjs');
 var pattern = require('./types/pattern.cjs');
 var union = require('./union.cjs');
 var when = require('./when.cjs');
+var builder = require('./match/builder.cjs');
 
 
 
@@ -15,8 +16,10 @@ exports.isResult = result.isResult;
 exports.result = result.result;
 exports.exhaustive = exhaustive.exhaustive;
 exports.otherwise = otherwise.otherwise;
-exports.match = match.match;
+exports.match = index.match;
 exports.isMatch = isMatch.isMatch;
 exports.SymbolToolPatternFunctionLabel = pattern.SymbolToolPatternFunctionLabel;
 exports.union = union.union;
 exports.when = when.when;
+exports.InvalidExhaustivePatternError = builder.InvalidExhaustivePatternError;
+exports.matchBuilder = builder.matchBuilder;

package/dist/pattern/index.mjs

@@ -1,8 +1,9 @@
 export { isResult, result } from './result.mjs';
 export { exhaustive } from './exhaustive.mjs';
 export { otherwise } from './otherwise.mjs';
-export { match } from './match.mjs';
+export { match } from './match/index.mjs';
 export { isMatch } from './isMatch.mjs';
 export { SymbolToolPatternFunctionLabel } from './types/pattern.mjs';
 export { union } from './union.mjs';
 export { when } from './when.mjs';
+export { InvalidExhaustivePatternError, matchBuilder } from './match/builder.mjs';

package/dist/pattern/match/builder.cjs

@@ -0,0 +1,82 @@
+'use strict';
+
+var kind = require('../../common/kind.cjs');
+require('../../common/stringToBytes.cjs');
+require('../../common/stringToMillisecond.cjs');
+require('../../common/globalStore.cjs');
+var builder = require('../../common/builder.cjs');
+require('../../either/bool/falsy.cjs');
+require('../../either/bool/truthy.cjs');
+require('../../either/bool/base.cjs');
+require('../../either/left/create.cjs');
+require('../../either/left/error.cjs');
+require('../../either/left/fail.cjs');
+require('../../either/kind.cjs');
+require('../../either/right/success.cjs');
+require('../../either/right/create.cjs');
+require('../../either/right/ok.cjs');
+require('../../either/future/success.cjs');
+require('../../either/future/error.cjs');
+require('../../either/future/base.cjs');
+require('../../either/nullable/empty.cjs');
+require('../../either/nullable/filled.cjs');
+require('../../either/nullable/base.cjs');
+require('../../either/nullish/empty.cjs');
+require('../../either/nullish/filled.cjs');
+require('../../either/nullish/base.cjs');
+require('../../either/optional/empty.cjs');
+require('../../either/optional/filled.cjs');
+require('../../either/optional/base.cjs');
+require('../../common/override.cjs');
+var errorKindNamespace = require('../../common/errorKindNamespace.cjs');
+var isMatch = require('../isMatch.cjs');
+
+class InvalidExhaustivePatternError extends kind.kindHeritage("invalid-exhaustive-pattern-error", errorKindNamespace.createErrorKind("invalid-exhaustive-pattern-error"), Error) {
+    input;
+    constructor(input) {
+        super({}, ["Invalid exhaustive pattern. If typing is correct, report your situation on github."]);
+        this.input = input;
+    }
+}
+const matchBuilder = builder.createBuilder("@duplojs/utils/pattern/match");
+matchBuilder.set("with", ({ args: [pattern, theFunction], accumulator, next, }) => next({
+    ...accumulator,
+    matchers: [
+        ...accumulator.matchers,
+        {
+            isMatch: isMatch.isMatch(pattern),
+            theFunction,
+        },
+    ],
+}));
+matchBuilder.set("when", ({ args: [predicate, theFunction], accumulator, next, }) => next({
+    ...accumulator,
+    matchers: [
+        ...accumulator.matchers,
+        {
+            isMatch: predicate,
+            theFunction,
+        },
+    ],
+}));
+matchBuilder.set("exhaustive", ({ accumulator: { input, matchers, }, }) => {
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let index = 0; index < matchers.length; index++) {
+        if (matchers[index].isMatch(input)) {
+            return matchers[index].theFunction(input);
+        }
+    }
+    throw new InvalidExhaustivePatternError(input);
+});
+matchBuilder.set("otherwise", ({ args: [theFunction], accumulator: { input, matchers, }, }) => {
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let index = 0; index < matchers.length; index++) {
+        if (matchers[index].isMatch(input)) {
+            return matchers[index].theFunction(input);
+        }
+    }
+    return theFunction(input);
+});
+
+exports.InvalidExhaustivePatternError = InvalidExhaustivePatternError;
+exports.matchBuilder = matchBuilder;

package/dist/pattern/match/builder.d.ts

@@ -0,0 +1,30 @@
+import { type Builder, type FixDeepFunctionInfer, type IsEqual } from "../../common";
+import { type ComplexMatchedValue, type ComplexUnMatchedValue, type Pattern, type PatternValue } from "../types";
+export interface BuilderMatcher {
+    isMatch(value: unknown): boolean;
+    theFunction(value: unknown): unknown;
+}
+export interface MatchBuilderDefinition {
+    input: unknown;
+    matchers: BuilderMatcher[];
+}
+declare const SymbolErrorMatchExhaustive: unique symbol;
+export interface MatchBuilder<GenericValue extends unknown = never, GenericResult extends unknown = never> extends Builder<MatchBuilderDefinition> {
+    with<const GenericPattern extends Pattern<GenericValue>, GenericOutput extends unknown>(pattern: FixDeepFunctionInfer<Pattern<GenericValue>, GenericPattern>, theFunction: (value: ComplexMatchedValue<GenericValue, PatternValue<GenericPattern>>) => GenericOutput): MatchBuilder<ComplexUnMatchedValue<GenericValue, PatternValue<GenericPattern>>, GenericOutput | GenericResult>;
+    when<GenericPredicatedInput extends GenericValue, GenericOutput extends unknown>(predicate: (input: GenericValue) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): MatchBuilder<Exclude<GenericValue, GenericPredicatedInput>, GenericOutput | GenericResult>;
+    when<GenericOutput extends unknown>(predicate: (input: GenericValue) => boolean, theFunction: (predicatedInput: GenericValue) => GenericOutput): MatchBuilder<GenericValue, GenericOutput | GenericResult>;
+    exhaustive: IsEqual<GenericValue, never> extends true ? () => GenericResult : {
+        [SymbolErrorMatchExhaustive]: "Pattern are not exhaustive.";
+        restValue: GenericValue;
+    };
+    otherwise<GenericOtherwiseResult extends unknown>(theFunction: (value: GenericValue) => GenericOtherwiseResult): GenericResult | GenericOtherwiseResult;
+}
+declare const InvalidExhaustivePatternError_base: new (params: {
+    "@DuplojsUtilsError/invalid-exhaustive-pattern-error"?: unknown;
+}, parentParams: [message?: string | undefined, options?: ErrorOptions | undefined]) => Error & import("../../common").Kind<import("../../common").KindDefinition<"invalid-exhaustive-pattern-error", unknown>, unknown> & import("../../common").Kind<import("../../common").KindDefinition<"@DuplojsUtilsError/invalid-exhaustive-pattern-error", unknown>, unknown>;
+export declare class InvalidExhaustivePatternError extends InvalidExhaustivePatternError_base {
+    input: unknown;
+    constructor(input: unknown);
+}
+export declare const matchBuilder: import("../../common").BuilderHandler<MatchBuilder<unknown, unknown> & Pick<MatchBuilder<never, unknown>, "exhaustive">>;
+export {};

package/dist/pattern/match/builder.mjs

@@ -0,0 +1,79 @@
+import { kindHeritage } from '../../common/kind.mjs';
+import '../../common/stringToBytes.mjs';
+import '../../common/stringToMillisecond.mjs';
+import '../../common/globalStore.mjs';
+import { createBuilder } from '../../common/builder.mjs';
+import '../../either/bool/falsy.mjs';
+import '../../either/bool/truthy.mjs';
+import '../../either/bool/base.mjs';
+import '../../either/left/create.mjs';
+import '../../either/left/error.mjs';
+import '../../either/left/fail.mjs';
+import '../../either/kind.mjs';
+import '../../either/right/success.mjs';
+import '../../either/right/create.mjs';
+import '../../either/right/ok.mjs';
+import '../../either/future/success.mjs';
+import '../../either/future/error.mjs';
+import '../../either/future/base.mjs';
+import '../../either/nullable/empty.mjs';
+import '../../either/nullable/filled.mjs';
+import '../../either/nullable/base.mjs';
+import '../../either/nullish/empty.mjs';
+import '../../either/nullish/filled.mjs';
+import '../../either/nullish/base.mjs';
+import '../../either/optional/empty.mjs';
+import '../../either/optional/filled.mjs';
+import '../../either/optional/base.mjs';
+import '../../common/override.mjs';
+import { createErrorKind } from '../../common/errorKindNamespace.mjs';
+import { isMatch } from '../isMatch.mjs';
+
+class InvalidExhaustivePatternError extends kindHeritage("invalid-exhaustive-pattern-error", createErrorKind("invalid-exhaustive-pattern-error"), Error) {
+    input;
+    constructor(input) {
+        super({}, ["Invalid exhaustive pattern. If typing is correct, report your situation on github."]);
+        this.input = input;
+    }
+}
+const matchBuilder = createBuilder("@duplojs/utils/pattern/match");
+matchBuilder.set("with", ({ args: [pattern, theFunction], accumulator, next, }) => next({
+    ...accumulator,
+    matchers: [
+        ...accumulator.matchers,
+        {
+            isMatch: isMatch(pattern),
+            theFunction,
+        },
+    ],
+}));
+matchBuilder.set("when", ({ args: [predicate, theFunction], accumulator, next, }) => next({
+    ...accumulator,
+    matchers: [
+        ...accumulator.matchers,
+        {
+            isMatch: predicate,
+            theFunction,
+        },
+    ],
+}));
+matchBuilder.set("exhaustive", ({ accumulator: { input, matchers, }, }) => {
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let index = 0; index < matchers.length; index++) {
+        if (matchers[index].isMatch(input)) {
+            return matchers[index].theFunction(input);
+        }
+    }
+    throw new InvalidExhaustivePatternError(input);
+});
+matchBuilder.set("otherwise", ({ args: [theFunction], accumulator: { input, matchers, }, }) => {
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let index = 0; index < matchers.length; index++) {
+        if (matchers[index].isMatch(input)) {
+            return matchers[index].theFunction(input);
+        }
+    }
+    return theFunction(input);
+});
+
+export { InvalidExhaustivePatternError, matchBuilder };

package/dist/pattern/match/index.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var result = require('../result.cjs');
+var isMatch = require('../isMatch.cjs');
+var builder = require('./builder.cjs');
+
+function match(...args) {
+    if (args.length === 1) {
+        const [input] = args;
+        return builder.matchBuilder.use({
+            input,
+            matchers: [],
+        });
+    }
+    if (args.length === 2) {
+        const [pattern, theFunction] = args;
+        return (input) => match(input, pattern, theFunction);
+    }
+    const [input, pattern, theFunction] = args;
+    if (!result.isResult(input) && isMatch.isMatch(input, pattern)) {
+        return result.result(theFunction(input));
+    }
+    return input;
+}
+
+exports.InvalidExhaustivePatternError = builder.InvalidExhaustivePatternError;
+exports.matchBuilder = builder.matchBuilder;
+exports.match = match;

package/dist/pattern/{match.d.ts → match/index.d.ts}

@@ -1,6 +1,9 @@
-import { type IsEqual, type AnyValue, type EscapeVoid, type FixDeepFunctionInfer, type BreakGenericLink } from "../common";
-import { type PatternValue, type Pattern } from "./types/pattern";
-import { type PatternResult } from "./result";
-import { type ComplexMatchedValue, type ComplexUnMatchedValue } from "./types";
+import { type IsEqual, type AnyValue, type EscapeVoid, type FixDeepFunctionInfer, type BreakGenericLink } from "../../common";
+import { type PatternValue, type Pattern } from "../types/pattern";
+import { type PatternResult } from "../result";
+import { type ComplexMatchedValue, type ComplexUnMatchedValue } from "../types";
+import { type MatchBuilder } from "./builder";
+export * from "./builder";
+export declare function match<GenericInput extends AnyValue>(input: GenericInput): MatchBuilder<GenericInput>;
 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> extends infer InferredResult ? BreakGenericLink<InferredResult> : never));
 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/index.mjs

@@ -0,0 +1,25 @@
+import { isResult, result } from '../result.mjs';
+import { isMatch } from '../isMatch.mjs';
+import { matchBuilder } from './builder.mjs';
+export { InvalidExhaustivePatternError } from './builder.mjs';
+
+function match(...args) {
+    if (args.length === 1) {
+        const [input] = args;
+        return matchBuilder.use({
+            input,
+            matchers: [],
+        });
+    }
+    if (args.length === 2) {
+        const [pattern, theFunction] = args;
+        return (input) => match(input, pattern, theFunction);
+    }
+    const [input, pattern, theFunction] = args;
+    if (!isResult(input) && isMatch(input, pattern)) {
+        return result(theFunction(input));
+    }
+    return input;
+}
+
+export { match, matchBuilder };

package/dist/pattern/otherwise.cjs

@@ -1,8 +1,33 @@
 'use strict';
 
+require('../common/stringToBytes.cjs');
+require('../common/stringToMillisecond.cjs');
 var unwrap = require('../common/unwrap.cjs');
 require('../common/globalStore.cjs');
 require('../common/builder.cjs');
+require('../either/bool/falsy.cjs');
+require('../either/bool/truthy.cjs');
+require('../either/bool/base.cjs');
+require('../either/left/create.cjs');
+require('../either/left/error.cjs');
+require('../either/left/fail.cjs');
+require('../either/kind.cjs');
+require('../either/right/success.cjs');
+require('../either/right/create.cjs');
+require('../either/right/ok.cjs');
+require('../either/future/success.cjs');
+require('../either/future/error.cjs');
+require('../either/future/base.cjs');
+require('../either/nullable/empty.cjs');
+require('../either/nullable/filled.cjs');
+require('../either/nullable/base.cjs');
+require('../either/nullish/empty.cjs');
+require('../either/nullish/filled.cjs');
+require('../either/nullish/base.cjs');
+require('../either/optional/empty.cjs');
+require('../either/optional/filled.cjs');
+require('../either/optional/base.cjs');
+require('../common/override.cjs');
 var result = require('./result.cjs');
 
 function otherwise(...args) {

package/dist/pattern/otherwise.mjs

@@ -1,6 +1,31 @@
+import '../common/stringToBytes.mjs';
+import '../common/stringToMillisecond.mjs';
 import { unwrap } from '../common/unwrap.mjs';
 import '../common/globalStore.mjs';
 import '../common/builder.mjs';
+import '../either/bool/falsy.mjs';
+import '../either/bool/truthy.mjs';
+import '../either/bool/base.mjs';
+import '../either/left/create.mjs';
+import '../either/left/error.mjs';
+import '../either/left/fail.mjs';
+import '../either/kind.mjs';
+import '../either/right/success.mjs';
+import '../either/right/create.mjs';
+import '../either/right/ok.mjs';
+import '../either/future/success.mjs';
+import '../either/future/error.mjs';
+import '../either/future/base.mjs';
+import '../either/nullable/empty.mjs';
+import '../either/nullable/filled.mjs';
+import '../either/nullable/base.mjs';
+import '../either/nullish/empty.mjs';
+import '../either/nullish/filled.mjs';
+import '../either/nullish/base.mjs';
+import '../either/optional/empty.mjs';
+import '../either/optional/filled.mjs';
+import '../either/optional/base.mjs';
+import '../common/override.mjs';
 import { isResult } from './result.mjs';
 
 function otherwise(...args) {

package/dist/pattern/result.cjs

@@ -1,9 +1,34 @@
 'use strict';
 
 var kind = require('../common/kind.cjs');
+require('../common/stringToBytes.cjs');
+require('../common/stringToMillisecond.cjs');
 var wrapValue = require('../common/wrapValue.cjs');
 require('../common/globalStore.cjs');
 require('../common/builder.cjs');
+require('../either/bool/falsy.cjs');
+require('../either/bool/truthy.cjs');
+require('../either/bool/base.cjs');
+require('../either/left/create.cjs');
+require('../either/left/error.cjs');
+require('../either/left/fail.cjs');
+require('../either/kind.cjs');
+require('../either/right/success.cjs');
+require('../either/right/create.cjs');
+require('../either/right/ok.cjs');
+require('../either/future/success.cjs');
+require('../either/future/error.cjs');
+require('../either/future/base.cjs');
+require('../either/nullable/empty.cjs');
+require('../either/nullable/filled.cjs');
+require('../either/nullable/base.cjs');
+require('../either/nullish/empty.cjs');
+require('../either/nullish/filled.cjs');
+require('../either/nullish/base.cjs');
+require('../either/optional/empty.cjs');
+require('../either/optional/filled.cjs');
+require('../either/optional/base.cjs');
+require('../common/override.cjs');
 
 const patternResultKind = kind.createKind("pattern-result");
 function result(value) {

package/dist/pattern/result.mjs

@@ -1,7 +1,32 @@
 import { createKind } from '../common/kind.mjs';
+import '../common/stringToBytes.mjs';
+import '../common/stringToMillisecond.mjs';
 import { wrapValue } from '../common/wrapValue.mjs';
 import '../common/globalStore.mjs';
 import '../common/builder.mjs';
+import '../either/bool/falsy.mjs';
+import '../either/bool/truthy.mjs';
+import '../either/bool/base.mjs';
+import '../either/left/create.mjs';
+import '../either/left/error.mjs';
+import '../either/left/fail.mjs';
+import '../either/kind.mjs';
+import '../either/right/success.mjs';
+import '../either/right/create.mjs';
+import '../either/right/ok.mjs';
+import '../either/future/success.mjs';
+import '../either/future/error.mjs';
+import '../either/future/base.mjs';
+import '../either/nullable/empty.mjs';
+import '../either/nullable/filled.mjs';
+import '../either/nullable/base.mjs';
+import '../either/nullish/empty.mjs';
+import '../either/nullish/filled.mjs';
+import '../either/nullish/base.mjs';
+import '../either/optional/empty.mjs';
+import '../either/optional/filled.mjs';
+import '../either/optional/base.mjs';
+import '../common/override.mjs';
 
 const patternResultKind = createKind("pattern-result");
 function result(value) {

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

@@ -19,7 +19,7 @@ type ComplexUnMatchedTupleTuple<GenericInput extends unknown, GenericPatternValu
 ] 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 ? [
+] ? 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<InferredResultRest, never> extends true ? never : [
     IsEqual<InferredResultFirst, never> extends true ? InferredInputFirst : InferredResultFirst,
     ...Adaptor<IsEqual<InferredResultRest, never> extends true ? InferredPatternValueRest : InferredResultRest, readonly any[]>
 ] : never : never : never : never);

package/dist/string/replace.cjs

@@ -6,6 +6,21 @@ function replace(...args) {
         return (input) => replace(input, pattern, replacement);
     }
     const [input, pattern, replacement] = args;
+    if (typeof replacement === "function") {
+        return input.replace(pattern, (matchedValue, ...argsRest) => {
+            const namedGroups = typeof argsRest[argsRest.length - 1] === "object"
+                ? argsRest.pop()
+                : undefined;
+            const [offset, self] = argsRest.splice(-2, 2);
+            return replacement({
+                matchedValue,
+                namedGroups,
+                offset,
+                self,
+                groups: argsRest,
+            });
+        });
+    }
     return input.replace(pattern, replacement);
 }
 

package/dist/string/replace.d.ts

@@ -1,2 +1,10 @@
-export declare function replace<GenericInput extends string>(pattern: string | RegExp, replacement: string): (input: GenericInput) => string;
-export declare function replace<GenericInput extends string>(input: GenericInput, pattern: string | RegExp, replacement: string): string;
+export interface StringReplacerParams {
+    matchedValue: string;
+    groups: string[];
+    namedGroups?: Record<string, string>;
+    offset: number;
+    self: string;
+}
+export type StringReplacer = (params: StringReplacerParams) => string;
+export declare function replace<GenericInput extends string>(pattern: string | RegExp, replacement: string | StringReplacer): (input: GenericInput) => string;
+export declare function replace<GenericInput extends string>(input: GenericInput, pattern: string | RegExp, replacement: string | StringReplacer): string;

package/dist/string/replace.mjs

@@ -4,6 +4,21 @@ function replace(...args) {
         return (input) => replace(input, pattern, replacement);
     }
     const [input, pattern, replacement] = args;
+    if (typeof replacement === "function") {
+        return input.replace(pattern, (matchedValue, ...argsRest) => {
+            const namedGroups = typeof argsRest[argsRest.length - 1] === "object"
+                ? argsRest.pop()
+                : undefined;
+            const [offset, self] = argsRest.splice(-2, 2);
+            return replacement({
+                matchedValue,
+                namedGroups,
+                offset,
+                self,
+                groups: argsRest,
+            });
+        });
+    }
     return input.replace(pattern, replacement);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.1.15",
+  "version": "1.2.16",
   "author": "mathcovax",
   "license": "MIT",
   "type": "module",
@@ -80,6 +80,11 @@
       "import": "./dist/string/index.mjs",
       "require": "./dist/string/index.cjs",
       "types": "./dist/string/index.d.ts"
+    },
+    "./date": {
+      "import": "./dist/date/index.mjs",
+      "require": "./dist/date/index.cjs",
+      "types": "./dist/date/index.d.ts"
     }
   },
   "files": [