@duplojs/utils 0.3.0 → 1.0.0

package/dist/generator/map.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+function map(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (iterator) => map(iterator, theFunction);
+    }
+    const [iterator, theFunction] = args;
+    let index = 0;
+    return (function* () {
+        for (const element of iterator) {
+            yield theFunction(element, { index });
+            index++;
+        }
+    })();
+}
+
+exports.map = map;

package/dist/generator/map.d.ts

@@ -0,0 +1,6 @@
+interface GeneratorMapParams {
+    index: number;
+}
+export declare function map<const GenericInput extends unknown, const GenericOutput extends unknown>(theFunction: (arg: GenericInput, params: GeneratorMapParams) => GenericOutput): (iterator: Iterable<GenericInput>) => Generator<GenericOutput, unknown, unknown>;
+export declare function map<const GenericInput extends unknown, const GenericOutput extends unknown>(iterator: Iterable<GenericInput>, theFunction: (arg: GenericInput, params: GeneratorMapParams) => GenericOutput): Generator<GenericOutput, unknown, unknown>;
+export {};

package/dist/generator/map.mjs

@@ -0,0 +1,16 @@
+function map(...args) {
+    if (args.length === 1) {
+        const [theFunction] = args;
+        return (iterator) => map(iterator, theFunction);
+    }
+    const [iterator, theFunction] = args;
+    let index = 0;
+    return (function* () {
+        for (const element of iterator) {
+            yield theFunction(element, { index });
+            index++;
+        }
+    })();
+}
+
+export { map };

package/dist/generator/reduce.cjs

@@ -0,0 +1,42 @@
+'use strict';
+
+var kind = require('../common/kind.cjs');
+var wrapValue = require('../common/wrapValue.cjs');
+var unwrap = require('../common/unwrap.cjs');
+var override = require('../object/override.cjs');
+
+const generatorReduceFromKind = kind.createKind("generator-reduce-from");
+const getStartValueParams = {
+    from: (value) => generatorReduceFromKind.addTo(wrapValue.wrapValue(value), null),
+};
+function reduce(...args) {
+    if (args.length === 2) {
+        const [getStartValue, theFunction] = args;
+        return (iterator) => reduce(iterator, getStartValue, theFunction);
+    }
+    const [iterator, getStartValue, theFunction] = args;
+    let lastValue = unwrap.unwrap(typeof getStartValue === "function"
+        ? getStartValue(getStartValueParams)
+        : getStartValue);
+    let index = 0;
+    for (const element of iterator) {
+        const result = theFunction({
+            element,
+            index,
+            lastValue,
+            nextWithObject: ((object1, object2) => ({
+                "-next": override.override(object1, object2),
+            })),
+            exit: (output) => ({ "-exit": output }),
+            next: (output) => ({ "-next": output }),
+        });
+        if ("-exit" in result) {
+            return result["-exit"];
+        }
+        lastValue = result["-next"];
+        index++;
+    }
+    return lastValue;
+}
+
+exports.reduce = reduce;

package/dist/generator/reduce.d.ts

@@ -0,0 +1,30 @@
+import { type Kind } from "../common/kind";
+import { type WrappedValue } from "../common/wrapValue";
+import { type Unwrap } from "../common/unwrap";
+import { type ToLargeEnsemble } from "../common";
+interface GeneratorReduceNext<GenericOutput extends unknown> {
+    "-next": GenericOutput;
+}
+interface ArrayReduceExit<GenericOutput extends unknown> {
+    "-exit": GenericOutput;
+}
+type ExitOrNext<GenericOutput extends unknown = unknown> = ArrayReduceExit<GenericOutput> | GeneratorReduceNext<GenericOutput>;
+export interface GeneratorReduceFunctionParams<GenericElement extends unknown = unknown, GenericOutput extends unknown = unknown> {
+    element: GenericElement;
+    index: number;
+    lastValue: GenericOutput;
+    nextWithObject: GenericOutput extends object ? (object1: GenericOutput, object2: Partial<GenericOutput>) => GeneratorReduceNext<GenericOutput> : undefined;
+    next(output: GenericOutput): GeneratorReduceNext<GenericOutput>;
+    exit(output: GenericOutput): ArrayReduceExit<GenericOutput>;
+}
+declare const generatorReduceFromKind: import("../common").KindHandler<import("../common").KindDefinition<"generator-reduce-from", unknown>>;
+export interface GeneratorReduceFromResult<GenericValue extends unknown = unknown> extends Kind<typeof generatorReduceFromKind.definition>, WrappedValue<GenericValue> {
+}
+interface GetStartValueParams {
+    from<GenericValue extends unknown>(value: GenericValue): GeneratorReduceFromResult<GenericValue>;
+}
+export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean>(startValue: GenericReduceFrom, theFunction: (params: GeneratorReduceFunctionParams<GenericElement, ToLargeEnsemble<GenericReduceFrom>>) => ExitOrNext<ToLargeEnsemble<GenericReduceFrom>>): (iterator: Iterable<GenericElement>) => ToLargeEnsemble<GenericReduceFrom>;
+export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends GeneratorReduceFromResult>(getStartValue: (params: GetStartValueParams) => GenericReduceFrom, theFunction: (params: GeneratorReduceFunctionParams<GenericElement, Unwrap<GenericReduceFrom>>) => ExitOrNext<Unwrap<GenericReduceFrom>>): (iterator: Iterable<GenericElement>) => Unwrap<GenericReduceFrom>;
+export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends number | string | bigint | boolean>(iterator: Iterable<GenericElement>, startValue: GenericReduceFrom, theFunction: (params: GeneratorReduceFunctionParams<GenericElement, ToLargeEnsemble<GenericReduceFrom>>) => ExitOrNext<ToLargeEnsemble<GenericReduceFrom>>): ToLargeEnsemble<GenericReduceFrom>;
+export declare function reduce<GenericElement extends unknown, GenericReduceFrom extends GeneratorReduceFromResult>(iterator: Iterable<GenericElement>, getStartValue: (params: GetStartValueParams) => GenericReduceFrom, theFunction: (params: GeneratorReduceFunctionParams<GenericElement, Unwrap<GenericReduceFrom>>) => ExitOrNext<Unwrap<GenericReduceFrom>>): Unwrap<GenericReduceFrom>;
+export {};

package/dist/generator/reduce.mjs

@@ -0,0 +1,40 @@
+import { createKind } from '../common/kind.mjs';
+import { wrapValue } from '../common/wrapValue.mjs';
+import { unwrap } from '../common/unwrap.mjs';
+import { override } from '../object/override.mjs';
+
+const generatorReduceFromKind = createKind("generator-reduce-from");
+const getStartValueParams = {
+    from: (value) => generatorReduceFromKind.addTo(wrapValue(value), null),
+};
+function reduce(...args) {
+    if (args.length === 2) {
+        const [getStartValue, theFunction] = args;
+        return (iterator) => reduce(iterator, getStartValue, theFunction);
+    }
+    const [iterator, getStartValue, theFunction] = args;
+    let lastValue = unwrap(typeof getStartValue === "function"
+        ? getStartValue(getStartValueParams)
+        : getStartValue);
+    let index = 0;
+    for (const element of iterator) {
+        const result = theFunction({
+            element,
+            index,
+            lastValue,
+            nextWithObject: ((object1, object2) => ({
+                "-next": override(object1, object2),
+            })),
+            exit: (output) => ({ "-exit": output }),
+            next: (output) => ({ "-next": output }),
+        });
+        if ("-exit" in result) {
+            return result["-exit"];
+        }
+        lastValue = result["-next"];
+        index++;
+    }
+    return lastValue;
+}
+
+export { reduce };

package/dist/index.cjs

@@ -1,138 +1,84 @@
 'use strict';
 
-function getTypedEntries(object) {
-    return Object.entries(object);
-}
+var addWrappedProperties = require('./common/addWrappedProperties.cjs');
+var asyncPipe = require('./common/asyncPipe.cjs');
+var clone = require('./common/clone.cjs');
+var _enum = require('./common/enum.cjs');
+var escapeRegExp = require('./common/escapeRegExp.cjs');
+var externalPromise = require('./common/externalPromise.cjs');
+var interpolation = require('./common/interpolation.cjs');
+var kind = require('./common/kind.cjs');
+var pipe = require('./common/pipe.cjs');
+var promiseObject = require('./common/promiseObject.cjs');
+var simpleClone = require('./common/simpleClone.cjs');
+var sleep = require('./common/sleep.cjs');
+var stringToBytes = require('./common/stringToBytes.cjs');
+var stringToMillisecond = require('./common/stringToMillisecond.cjs');
+var toJson = require('./common/toJson.cjs');
+var toTransform = require('./common/toTransform.cjs');
+var toWrappedValue = require('./common/toWrappedValue.cjs');
+var unwrap = require('./common/unwrap.cjs');
+var asyncLoop = require('./common/asyncLoop.cjs');
+var asyncRetry = require('./common/asyncRetry.cjs');
+var wrapValue = require('./common/wrapValue.cjs');
+var toString = require('./common/toString.cjs');
+var innerPipe = require('./common/innerPipe.cjs');
+var asyncInnerPipe = require('./common/asyncInnerPipe.cjs');
+var loop = require('./common/loop.cjs');
+var forward = require('./common/forward.cjs');
+var index = require('./array/index.cjs');
+var index$1 = require('./number/index.cjs');
+var index$2 = require('./either/index.cjs');
+var index$3 = require('./object/index.cjs');
+var index$4 = require('./string/index.cjs');
+var index$5 = require('./generator/index.cjs');
+var index$6 = require('./pattern/index.cjs');
 
-function clone(unknownValue) {
-    if (!unknownValue) {
-        return unknownValue;
-    }
-    else if (typeof unknownValue !== "object") {
-        return unknownValue;
-    }
-    else if (unknownValue instanceof Array) {
-        return unknownValue.map(clone);
-    }
-    else {
-        return getTypedEntries(unknownValue).reduce((pv, [key, value]) => {
-            pv[key] = clone(value);
-            return pv;
-        }, {});
-    }
-}
 
-function entryUseMapper([key, value], mapper) {
-    const ReTypedMapper = mapper;
-    return ReTypedMapper[key](value);
-}
 
-function escapeRegExp(text) {
-    return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
-}
-
-function getTypedKeys(object) {
-    return Object.keys(object);
-}
-
-function hasKey(obj, key) {
-    return key in obj;
-}
-
-function createInterpolation(value, _strict) {
-    return (interpolationValues) => (interpolationValues
-        ? value.replace(/\{([^}]*)\}/g, (match, interpolationId) => interpolationValues[interpolationId])
-        : value);
-}
-
-function simpleClone(unknownValue) {
-    if (!unknownValue) {
-        return unknownValue;
-    }
-    else if (typeof unknownValue !== "object") {
-        return unknownValue;
-    }
-    else if (unknownValue.constructor?.name === "Object"
-        || unknownValue.constructor === undefined) {
-        return getTypedEntries(unknownValue).reduce((pv, [key, value]) => {
-            pv[key] = simpleClone(value);
-            return pv;
-        }, {});
-    }
-    else if (unknownValue instanceof Array && unknownValue.constructor.name === "Array") {
-        return unknownValue.map(simpleClone);
-    }
-    else {
-        return unknownValue;
-    }
-}
-
-function sleep(milliseconde) {
-    return new Promise((resolve) => void setTimeout(resolve, milliseconde));
-}
-
-/* eslint-disable id-length */
-class InvalidBytesInStringError extends Error {
-    input;
-    constructor(input) {
-        super("Invalid Input");
-        this.input = input;
-    }
-}
-const parseRegExp = /^((-|\+)?(\d+(?:\.\d+)?)) *(kb|mb|gb|tb|pb)$/i;
-const unitMapper = {
-    b: 1,
-    kb: 1 << 10,
-    mb: 1 << 20,
-    gb: 1 << 30,
-    tb: Math.pow(1024, 4),
-    pb: Math.pow(1024, 5),
-};
-function stringToBytes(bytesInString) {
-    if (typeof bytesInString === "number") {
-        return bytesInString;
-    }
-    const regExpResults = parseRegExp.exec(bytesInString);
-    const floatValue = regExpResults
-        ? parseFloat(regExpResults[1])
-        : parseInt(bytesInString, 10);
-    const unit = regExpResults
-        ? regExpResults[4].toLowerCase()
-        : "b";
-    if (!hasKey(unitMapper, unit) || isNaN(floatValue)) {
-        throw new InvalidBytesInStringError(bytesInString);
-    }
-    return Math.floor(unitMapper[unit] * floatValue);
-}
-
-class UnPartialError extends Error {
-    key;
-    partialObject;
-    constructor(key, partialObject) {
-        super(`The key "${key.toString()}" is missing in partial object.`);
-        this.key = key;
-        this.partialObject = partialObject;
-    }
-}
-function unPartial(partialObject, keys) {
-    keys.forEach((key) => {
-        if (partialObject[key] === undefined) {
-            throw new UnPartialError(key, partialObject);
-        }
-    });
-    return partialObject;
-}
-
-exports.InvalidBytesInStringError = InvalidBytesInStringError;
-exports.UnPartialError = UnPartialError;
-exports.clone = clone;
-exports.createInterpolation = createInterpolation;
-exports.entryUseMapper = entryUseMapper;
-exports.escapeRegExp = escapeRegExp;
-exports.getTypedEntries = getTypedEntries;
-exports.getTypedKeys = getTypedKeys;
-exports.hasKey = hasKey;
-exports.simpleClone = simpleClone;
-exports.sleep = sleep;
-exports.stringToBytes = stringToBytes;
-exports.unPartial = unPartial;
+exports.addWrappedProperties = addWrappedProperties.addWrappedProperties;
+exports.asyncPipe = asyncPipe.asyncPipe;
+exports.clone = clone.clone;
+exports.createEnum = _enum.createEnum;
+exports.escapeRegExp = escapeRegExp.escapeRegExp;
+exports.createExternalPromise = externalPromise.createExternalPromise;
+exports.createInterpolation = interpolation.createInterpolation;
+exports.createKind = kind.createKind;
+exports.keyKindPrefix = kind.keyKindPrefix;
+exports.pipe = pipe.pipe;
+exports.promiseObject = promiseObject.promiseObject;
+exports.simpleClone = simpleClone.simpleClone;
+exports.sleep = sleep.sleep;
+exports.InvalidBytesInStringError = stringToBytes.InvalidBytesInStringError;
+exports.stringToBytes = stringToBytes.stringToBytes;
+exports.InvalidMillisecondInStringError = stringToMillisecond.InvalidMillisecondInStringError;
+exports.stringToMillisecond = stringToMillisecond.stringToMillisecond;
+exports.toJSON = toJson.toJSON;
+exports.toTransform = toTransform.toTransform;
+exports.toWrappedValue = toWrappedValue.toWrappedValue;
+exports.unwrap = unwrap.unwrap;
+exports.asyncLoop = asyncLoop.asyncLoop;
+exports.createAsyncRetry = asyncRetry.createAsyncRetry;
+exports.useAsyncRetry = asyncRetry.useAsyncRetry;
+exports.isWrappedValue = wrapValue.isWrappedValue;
+exports.keyWrappedValue = wrapValue.keyWrappedValue;
+exports.wrapValue = wrapValue.wrapValue;
+exports.toString = toString.toString;
+exports.innerPipe = innerPipe.innerPipe;
+exports.asyncInnerPipe = asyncInnerPipe.asyncInnerPipe;
+exports.loop = loop.loop;
+exports.forward = forward.forward;
+exports.A = index;
+exports.DArray = index;
+exports.DNumber = index$1;
+exports.N = index$1;
+exports.DEither = index$2;
+exports.E = index$2;
+exports.DObject = index$3;
+exports.O = index$3;
+exports.DString = index$4;
+exports.S = index$4;
+exports.DGenerator = index$5;
+exports.G = index$5;
+exports.DPattern = index$6;
+exports.P = index$6;

package/dist/index.d.ts

@@ -1,25 +1,15 @@
-export * from "./addThis";
-export * from "./clone";
-export * from "./entryUseMapper";
-export * from "./escapeRegExp";
-export * from "./expectType";
-export * from "./getLastOfUnion";
-export * from "./getPropsWithTrueValue";
-export * from "./getTypedEntries";
-export * from "./getTypedKeys";
-export * from "./hasKey";
-export * from "./incremente";
-export * from "./interpolation";
-export * from "./isEqual";
-export * from "./overrideInterface";
-export * from "./partialKeys";
-export * from "./requiredKeys";
-export * from "./simpleClone";
-export * from "./simplifyType";
-export * from "./sleep";
-export * from "./stringToBytes";
-export * from "./types";
-export * from "./unionToIntersection";
-export * from "./unionToTuple";
-export * from "./uniqueGeneric";
-export * from "./unPartial";
+export * from "./common";
+export * as A from "./array";
+export * as DArray from "./array";
+export * as N from "./number";
+export * as DNumber from "./number";
+export * as E from "./either";
+export * as DEither from "./either";
+export * as O from "./object";
+export * as DObject from "./object";
+export * as S from "./string";
+export * as DString from "./string";
+export * as G from "./generator";
+export * as DGenerator from "./generator";
+export * as P from "./pattern";
+export * as DPattern from "./pattern";

package/dist/index.mjs

@@ -1,124 +1,47 @@
-function getTypedEntries(object) {
-    return Object.entries(object);
-}
-
-function clone(unknownValue) {
-    if (!unknownValue) {
-        return unknownValue;
-    }
-    else if (typeof unknownValue !== "object") {
-        return unknownValue;
-    }
-    else if (unknownValue instanceof Array) {
-        return unknownValue.map(clone);
-    }
-    else {
-        return getTypedEntries(unknownValue).reduce((pv, [key, value]) => {
-            pv[key] = clone(value);
-            return pv;
-        }, {});
-    }
-}
-
-function entryUseMapper([key, value], mapper) {
-    const ReTypedMapper = mapper;
-    return ReTypedMapper[key](value);
-}
-
-function escapeRegExp(text) {
-    return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
-}
-
-function getTypedKeys(object) {
-    return Object.keys(object);
-}
-
-function hasKey(obj, key) {
-    return key in obj;
-}
-
-function createInterpolation(value, _strict) {
-    return (interpolationValues) => (interpolationValues
-        ? value.replace(/\{([^}]*)\}/g, (match, interpolationId) => interpolationValues[interpolationId])
-        : value);
-}
-
-function simpleClone(unknownValue) {
-    if (!unknownValue) {
-        return unknownValue;
-    }
-    else if (typeof unknownValue !== "object") {
-        return unknownValue;
-    }
-    else if (unknownValue.constructor?.name === "Object"
-        || unknownValue.constructor === undefined) {
-        return getTypedEntries(unknownValue).reduce((pv, [key, value]) => {
-            pv[key] = simpleClone(value);
-            return pv;
-        }, {});
-    }
-    else if (unknownValue instanceof Array && unknownValue.constructor.name === "Array") {
-        return unknownValue.map(simpleClone);
-    }
-    else {
-        return unknownValue;
-    }
-}
-
-function sleep(milliseconde) {
-    return new Promise((resolve) => void setTimeout(resolve, milliseconde));
-}
-
-/* eslint-disable id-length */
-class InvalidBytesInStringError extends Error {
-    input;
-    constructor(input) {
-        super("Invalid Input");
-        this.input = input;
-    }
-}
-const parseRegExp = /^((-|\+)?(\d+(?:\.\d+)?)) *(kb|mb|gb|tb|pb)$/i;
-const unitMapper = {
-    b: 1,
-    kb: 1 << 10,
-    mb: 1 << 20,
-    gb: 1 << 30,
-    tb: Math.pow(1024, 4),
-    pb: Math.pow(1024, 5),
-};
-function stringToBytes(bytesInString) {
-    if (typeof bytesInString === "number") {
-        return bytesInString;
-    }
-    const regExpResults = parseRegExp.exec(bytesInString);
-    const floatValue = regExpResults
-        ? parseFloat(regExpResults[1])
-        : parseInt(bytesInString, 10);
-    const unit = regExpResults
-        ? regExpResults[4].toLowerCase()
-        : "b";
-    if (!hasKey(unitMapper, unit) || isNaN(floatValue)) {
-        throw new InvalidBytesInStringError(bytesInString);
-    }
-    return Math.floor(unitMapper[unit] * floatValue);
-}
-
-class UnPartialError extends Error {
-    key;
-    partialObject;
-    constructor(key, partialObject) {
-        super(`The key "${key.toString()}" is missing in partial object.`);
-        this.key = key;
-        this.partialObject = partialObject;
-    }
-}
-function unPartial(partialObject, keys) {
-    keys.forEach((key) => {
-        if (partialObject[key] === undefined) {
-            throw new UnPartialError(key, partialObject);
-        }
-    });
-    return partialObject;
-}
-
-export { InvalidBytesInStringError, UnPartialError, clone, createInterpolation, entryUseMapper, escapeRegExp, getTypedEntries, getTypedKeys, hasKey, simpleClone, sleep, stringToBytes, unPartial };
+export { addWrappedProperties } from './common/addWrappedProperties.mjs';
+export { asyncPipe } from './common/asyncPipe.mjs';
+export { clone } from './common/clone.mjs';
+export { createEnum } from './common/enum.mjs';
+export { escapeRegExp } from './common/escapeRegExp.mjs';
+export { createExternalPromise } from './common/externalPromise.mjs';
+export { createInterpolation } from './common/interpolation.mjs';
+export { createKind, keyKindPrefix } from './common/kind.mjs';
+export { pipe } from './common/pipe.mjs';
+export { promiseObject } from './common/promiseObject.mjs';
+export { simpleClone } from './common/simpleClone.mjs';
+export { sleep } from './common/sleep.mjs';
+export { InvalidBytesInStringError, stringToBytes } from './common/stringToBytes.mjs';
+export { InvalidMillisecondInStringError, stringToMillisecond } from './common/stringToMillisecond.mjs';
+export { toJSON } from './common/toJson.mjs';
+export { toTransform } from './common/toTransform.mjs';
+export { toWrappedValue } from './common/toWrappedValue.mjs';
+export { unwrap } from './common/unwrap.mjs';
+export { asyncLoop } from './common/asyncLoop.mjs';
+export { createAsyncRetry, useAsyncRetry } from './common/asyncRetry.mjs';
+export { isWrappedValue, keyWrappedValue, wrapValue } from './common/wrapValue.mjs';
+export { toString } from './common/toString.mjs';
+export { innerPipe } from './common/innerPipe.mjs';
+export { asyncInnerPipe } from './common/asyncInnerPipe.mjs';
+export { loop } from './common/loop.mjs';
+export { forward } from './common/forward.mjs';
+import * as index from './array/index.mjs';
+export { index as A };
+export { index as DArray };
+import * as index$1 from './number/index.mjs';
+export { index$1 as DNumber };
+export { index$1 as N };
+import * as index$2 from './either/index.mjs';
+export { index$2 as DEither };
+export { index$2 as E };
+import * as index$3 from './object/index.mjs';
+export { index$3 as DObject };
+export { index$3 as O };
+import * as index$4 from './string/index.mjs';
+export { index$4 as DString };
+export { index$4 as S };
+import * as index$5 from './generator/index.mjs';
+export { index$5 as DGenerator };
+export { index$5 as G };
+import * as index$6 from './pattern/index.mjs';
+export { index$6 as DPattern };
+export { index$6 as P };

package/dist/number/abs.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function abs(value) {
+    return Math.abs(value);
+}
+
+exports.abs = abs;

package/dist/number/abs.d.ts

@@ -0,0 +1 @@
+export declare function abs<GenericValue extends number>(value: GenericValue): number;

package/dist/number/abs.mjs

@@ -0,0 +1,5 @@
+function abs(value) {
+    return Math.abs(value);
+}
+
+export { abs };

package/dist/number/acos.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function acos(value) {
+    return Math.acos(value);
+}
+
+exports.acos = acos;

package/dist/number/acos.d.ts

@@ -0,0 +1 @@
+export declare function acos<GenericValue extends number>(value: GenericValue): number;

package/dist/number/acos.mjs

@@ -0,0 +1,5 @@
+function acos(value) {
+    return Math.acos(value);
+}
+
+export { acos };

package/dist/number/add.cjs

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

package/dist/number/add.d.ts

@@ -0,0 +1,2 @@
+export declare function add<GenericValue extends number>(operand: number): (value: GenericValue) => number;
+export declare function add<GenericValue extends number>(value: GenericValue, operand: number): number;