@nejs/basic-extensions 2.21.0 → 2.22.6

package/dist/cjs/json.extensions.js

@@ -1,109 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JSONExtensions = void 0;
-const extension_1 = require("@nejs/extension");
-exports.JSONExtensions = new extension_1.Patch(JSON, {
-    [extension_1.Patch.kMutablyHidden]: {
-        extractAllFrom(string) {
-            const pattern = this.JSONStartPattern;
-            const notJSON = Symbol("Value is not valid JSON");
-            const decoder = part => {
-                try {
-                    return JSON.parse(part);
-                }
-                catch (_) {
-                    return notJSON;
-                }
-            };
-            const parts = [];
-            let part = undefined;
-            while ((part = pattern.exec(string))) {
-                parts.push(decoder(part?.[0]));
-            }
-            return parts.filter(isJSON => isJSON !== notJSON);
-        },
-        /**
-         * The `extractFrom` method attempts to extract a JSON object from a string.
-         * It uses a regular expression to identify potential JSON objects in the
-         * string and attempts to parse them. If a valid JSON object is found, it is
-         * returned. If no valid JSON object is found, the method returns undefined.
-         *
-         * NOTE: This method will only find JSON from an iterated upon start spot
-         * until the end of the string. So `'JSON follows {"count": 0}'` will
-         * return `{count: 0}` but `'JSON follows {"count": 0} and more'` will
-         * fail to locate any JSON in the String. You've been warned.
-         *
-         * @param {string} string - The string from which to extract a JSON object.
-         * @returns {Object|undefined} - The first valid JSON object found in the
-         * string, or undefined if no valid JSON object is found.
-         *
-         * @example
-         * // Suppose we have a string with embedded JSON
-         * const str1 = 'Hello {"name":"John", "age":30} World'
-         * const str2 = 'Hello {"name": "John", "age": 30}'
-         *
-         * // Using `extractFrom`
-         * console.log(JSON.extractFrom(str1))  // Output: undefined
-         * console.log(JSON.extractFrom(str2))  // Output: {name: 'John', age: 30}
-         */
-        extractFrom(string) {
-            this.extractAllFrom(string)?.[0];
-        },
-        /**
-         * The `mightContain` method checks if a string might contain a JSON object.
-         * It uses the `JSONStartPattern` regular expression to search for potential
-         * JSON objects in the string. If a potential JSON object is found, the method
-         * returns true. If no potential JSON object is found, the method returns false.
-         *
-         * @param {string} string - The string to check for potential JSON objects.
-         * @returns {boolean} - Returns true if the string might contain a JSON object,
-         * false otherwise.
-         *
-         * @example
-         * // Suppose we have a string with embedded JSON
-         * const str = 'Hello {"name":"John", "age":30} World'
-         *
-         * // Using `mightContain`
-         * console.log(JSON.mightContain(str))  // Output: true
-         */
-        mightContain(string, detail = false) {
-            const results = this.JSONStartPattern.exec(string);
-            return detail ? [!!results, results?.index ?? -1, results] : !!results;
-        },
-        /**
-         * Getter method for the JSONStartPattern.
-         *
-         * This method constructs a regular expression pattern that is used to
-         * identify potential JSON objects in a string. The pattern is designed
-         * to match various JSON data types including null, boolean, number,
-         * string, object, and array.
-         *
-         * The pattern is constructed using an array of strings, each representing
-         * a part of the pattern. The array is then joined into a single string
-         * and passed to the RegExp constructor to create the pattern.
-         *
-         * @returns {RegExp} - The constructed regular expression pattern.
-         *
-         * @example
-         * // Using `JSONStartPattern`
-         * const pattern = JSONStartPattern;
-         * const str = 'Hello {"name":"John", "age":30} World';
-         * const match = pattern.exec(str);
-         * console.log(match[0]);  // Output: '{"name":"John", "age":30}'
-         */
-        get JSONStartPattern() {
-            const pattern = new RegExp([
-                '(?:', // Start with a non-capturing group and match
-                '(null)|', // ...a null
-                '(true|false)|', // ...a bool
-                '(\\d+\\.?\\d*)|', // ...a number (including floats)
-                '("[^\\"]*(?:[^:])")|', // ...a double quote (start of string)
-                '((?:\\{.*\\})+)|', // ...an open curly brace (object)
-                '((?:\\[.*\\]+))', // ...an open square bracket (array)
-                ')+', // End of the groups
-            ].join(''), 'gm');
-            return pattern;
-        },
-    }
-});
-//# sourceMappingURL=json.extensions.js.map

package/dist/cjs/json.extensions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"json.extensions.js","sourceRoot":"","sources":["../../src/json.extensions.js"],"names":[],"mappings":";;;AAAA,+CAAuC;AAE1B,QAAA,cAAc,GAAG,IAAI,iBAAK,CAAC,IAAI,EAAE;IAC5C,CAAC,iBAAK,CAAC,cAAc,CAAC,EAAE;QACtB,cAAc,CAAC,MAAM;YACnB,MAAM,OAAO,GAAG,IAAI,CAAC,gBAAgB,CAAA;YACrC,MAAM,OAAO,GAAG,MAAM,CAAC,yBAAyB,CAAC,CAAA;YACjD,MAAM,OAAO,GAAG,IAAI,CAAC,EAAE;gBACrB,IAAI,CAAC;oBAAC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;gBAAC,CAAC;gBAAC,OAAO,CAAC,EAAE,CAAC;oBAAC,OAAO,OAAO,CAAA;gBAAC,CAAC;YAC9D,CAAC,CAAA;YAED,MAAM,KAAK,GAAG,EAAE,CAAA;YAChB,IAAI,IAAI,GAAG,SAAS,CAAA;YAEpB,OAAO,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;gBACrC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;YAChC,CAAC;YAED,OAAO,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,KAAK,OAAO,CAAC,CAAA;QACnD,CAAC;QAED;;;;;;;;;;;;;;;;;;;;;;;WAuBG;QACH,WAAW,CAAC,MAAM;YAChB,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;QAClC,CAAC;QAED;;;;;;;;;;;;;;;;WAgBG;QACH,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK;YACjC,MAAM,OAAO,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;YAClD,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAA;QACxE,CAAC;QAED;;;;;;;;;;;;;;;;;;;;WAoBG;QACH,IAAI,gBAAgB;YAClB,MAAM,OAAO,GAAG,IAAI,MAAM,CAAC;gBACzB,KAAK,EAAqB,6CAA6C;gBACrE,SAAS,EAAe,YAAY;gBACpC,eAAe,EAAS,YAAY;gBACpC,iBAAiB,EAAO,iCAAiC;gBACzD,sBAAsB,EAAE,sCAAsC;gBAC9D,kBAAkB,EAAM,kCAAkC;gBAC1D,iBAAiB,EAAO,oCAAoC;gBAC9D,IAAI,EAAsB,oBAAoB;aAC/C,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,CAAA;YAEjB,OAAO,OAAO,CAAA;QAChB,CAAC;KACF;CACF,CAAC,CAAA"}

package/dist/cjs/map.extensions.d.ts

@@ -1,3 +0,0 @@
-export const MapExtensions: Patch;
-export const MapPrototypeExtensions: Patch;
-import { Patch } from '@nejs/extension';

package/dist/cjs/map.extensions.js

@@ -1,143 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MapPrototypeExtensions = exports.MapExtensions = void 0;
-const extension_1 = require("@nejs/extension");
-exports.MapExtensions = new extension_1.Patch(Map, {
-    [extension_1.Patch.kMutablyHidden]: {
-        /**
-         * Determines if the supplied `value` is a `Map` object. This check
-         * is performed by first looking for the `Symbol.toStringTag` on the
-         * `value` and checking to see if it is equal to the string "Map".
-         * If that check fails, `instanceof` is used as a fallback to check
-         * the prototype chain.
-         *
-         * @param {any} value the value that needs to be checked to determine
-         * if it is a `Map` object or not
-         * @returns {boolean} `true` if the supplied `value` is a `Map`
-         * object, `false` otherwise
-         *
-         * @example
-         * const map = new Map()
-         * isMap(map) // true
-         * isMap(new Set()) // false
-         * isMap([]) // false
-         * isMap({}) // false
-         */
-        isMap(value) {
-            return value?.[Symbol.toStringTag] === Map.name && value instanceof Map;
-        },
-        /**
-         * Conditionally returns a value based on whether the supplied
-         * `value` is a `Map` object or not. If the `value` is a `Map`
-         * object, the `thenValue` will be returned. If it is not a `Map`
-         * object, the `elseValue` will be returned instead.
-         *
-         * @param {any} value the value to check to determine if it is a
-         * `Map` object
-         * @param {any} thenValue the value to return if the supplied
-         * `value` is a `Map` object
-         * @param {any} elseValue the value to return if the supplied
-         * `value` is not a `Map` object
-         * @returns {any} either the `thenValue` or `elseValue` depending
-         * on if the supplied `value` is a `Map` object
-         *
-         * @example
-         * const map = new Map()
-         * const set = new Set()
-         * ifMap(map, 'is a map', 'not a map') // 'is a map'
-         * ifMap(set, 'is a map', 'not a map') // 'not a map'
-         */
-        ifMap(value, thenValue, elseValue) {
-            return isThenElse(this.isMap(value), thenValue, elseValue);
-        },
-    }
-});
-const { isMap: pIsMap, ifMap: pIfMap } = exports.MapExtensions.patches;
-exports.MapPrototypeExtensions = new extension_1.Patch(Map.prototype, {
-    [extension_1.Patch.kMutablyHidden]: {
-        /**
-         * Determines if the current object is a `Map` object
-         *
-         * This is a getter that uses the `isMap` function from the
-         * `MapExtensions` patch to check if the current object (`this`) is
-         * a `Map` object
-         *
-         * @type {boolean}
-         * @readonly
-         *
-         * @example
-         * const map = new Map()
-         * console.log(map.isMap) // Output: true
-         *
-         * const notMap = {}
-         * console.log(notMap.isMap) // Output: false
-         */
-        get isMap() {
-            return pIsMap(this);
-        },
-        /**
-         * Conditionally returns a value based on whether the current
-         * object is a `Map` object or not
-         *
-         * If the current object is a `Map` object, the `thenValue` will
-         * be returned. If it is not a `Map` object, the `elseValue` will
-         * be returned instead.
-         *
-         * @param {any} thenValue the value to return if the current
-         * object is a `Map` object
-         * @param {any} elseValue the value to return if the current
-         * object is not a `Map` object
-         * @returns {any} either the `thenValue` or `elseValue` depending
-         * on if the current object is a `Map` object
-         *
-         * @example
-         * const map = new Map()
-         * map.ifMap('is a map', 'not a map') // 'is a map'
-         *
-         * const notMap = {}
-         * notMap.ifMap('is a map', 'not a map') // 'not a map'
-         */
-        ifMap(thenValue, elseValue) {
-            return pIfMap(this, thenValue, elseValue);
-        },
-        /**
-         * The function `getKey` returns the key associated with a given value
-         * in a map.
-         *
-         * @param {any} value - The value parameter is the value that you want to
-         * find the corresponding key for in the map.
-         * @param [strict=true] - The "strict" parameter is a boolean value that
-         * determines whether strict equality (===) or loose equality (==) should
-         * be used when comparing the "value" parameter with the values in the
-         * entries of the object. If "strict" is set to true, strict equality will
-         * be used.
-         * @returns the key associated with the given value. If a matching key is
-         * found, it is returned. If no matching key is found, null is returned.
-         */
-        getKey(value, strict = true) {
-            for (const [key, entryValue] of this) {
-                if ((strict && value === entryValue) &&
-                    (!strict && value == entryValue)) {
-                    return key;
-                }
-                return null;
-            }
-        },
-    },
-});
-// NOTE to self; this is repeated here otherwise a circular reference from
-// Object<->Function<->Global occurs. See original source in global.this.js
-// {@see globalThis.isThenElse}
-function isThenElse(bv, tv, ev) {
-    function isFunction(value) { typeof value === 'function'; }
-    if (arguments.length > 1) {
-        var _then = isFunction(tv) ? tv(bv) : tv;
-        if (arguments.length > 2) {
-            var _else = isFunction(ev) ? tv(bv) : ev;
-            return bv ? _then : _else;
-        }
-        return bv || _then;
-    }
-    return bv;
-}
-//# sourceMappingURL=map.extensions.js.map

package/dist/cjs/map.extensions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"map.extensions.js","sourceRoot":"","sources":["../../src/map.extensions.js"],"names":[],"mappings":";;;AAAA,+CAAuC;AAE1B,QAAA,aAAa,GAAG,IAAI,iBAAK,CAAC,GAAG,EAAE;IAC1C,CAAC,iBAAK,CAAC,cAAc,CAAC,EAAE;QACtB;;;;;;;;;;;;;;;;;;WAkBG;QACH,KAAK,CAAC,KAAK;YACT,OAAO,KAAK,EAAE,CAAC,MAAM,CAAC,WAAW,CAAC,KAAK,GAAG,CAAC,IAAI,IAAI,KAAK,YAAY,GAAG,CAAA;QACzE,CAAC;QAED;;;;;;;;;;;;;;;;;;;;WAoBG;QACH,KAAK,CAAC,KAAK,EAAE,SAAS,EAAE,SAAS;YAC/B,OAAO,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,CAAA;QAC5D,CAAC;KACF;CACF,CAAC,CAAA;AAEF,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,qBAAa,CAAC,OAAO,CAAA;AAEjD,QAAA,sBAAsB,GAAG,IAAI,iBAAK,CAAC,GAAG,CAAC,SAAS,EAAE;IAC7D,CAAC,iBAAK,CAAC,cAAc,CAAC,EAAE;QACtB;;;;;;;;;;;;;;;;WAgBG;QACH,IAAI,KAAK;YACP,OAAO,MAAM,CAAC,IAAI,CAAC,CAAA;QACrB,CAAC;QAED;;;;;;;;;;;;;;;;;;;;;WAqBG;QACH,KAAK,CAAC,SAAS,EAAE,SAAS;YACxB,OAAO,MAAM,CAAC,IAAI,EAAE,SAAS,EAAE,SAAS,CAAC,CAAA;QAC3C,CAAC;QAED;;;;;;;;;;;;;WAaG;QACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;YACzB,KAAK,MAAM,CAAC,GAAG,EAAE,UAAU,CAAC,IAAI,IAAI,EAAE,CAAC;gBACrC,IACE,CAAC,MAAM,IAAI,KAAK,KAAK,UAAU,CAAC;oBAChC,CAAC,CAAC,MAAM,IAAI,KAAK,IAAI,UAAU,CAAC,EAChC,CAAC;oBACD,OAAO,GAAG,CAAA;gBACZ,CAAC;gBAED,OAAO,IAAI,CAAA;YACb,CAAC;QACH,CAAC;KACF;CACF,CAAC,CAAA;AAEF,0EAA0E;AAC1E,2EAA2E;AAC3E,+BAA+B;AAC/B,SAAS,UAAU,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE;IAC5B,SAAS,UAAU,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,UAAU,CAAA,CAAC,CAAC;IAE1D,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACzB,IAAI,KAAK,GAAG,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAAC,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACnE,IAAI,KAAK,GAAG,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAAC,OAAO,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAA;QACrE,CAAC;QAAC,OAAO,EAAE,IAAI,KAAK,CAAC;IACvB,CAAC;IAAC,OAAO,EAAE,CAAA;AACb,CAAC"}

package/dist/cjs/number.extension.d.ts

@@ -1,44 +0,0 @@
-/**
- * A patch for the JavaScript built-in `Number` class that adds utility
- * methods without modifying the global namespace directly
- *
- * This patch includes methods for checking if a value is a number and
- * conditionally returning a value based on whether the supplied value is
- * a number or not.
- *
- * @type {Patch}
- * @property {Object} [Patch.kMutablyHidden] An object containing methods
- * that are hidden from enumeration and mutation
- *
- * @example
- * import { NumberExtensions } from 'number.extension.js'
- *
- * NumberExtensions.apply()
- * // Now the `Number` class has additional methods available
- */
-export const NumberExtensions: Patch;
-/**
- * `NumberPrototypeExtensions` provides a set of utility methods that
- * are added to the `Number` prototype. This allows all number instances
- * to access new functionality directly, enhancing their capabilities
- * beyond the standard `Number` class methods.
- *
- * These extensions are applied using the `Patch` class from
- * '@nejs/extension', ensuring that they do not interfere with the
- * global namespace or existing properties.
- *
- * The extensions include methods for checking if a value is a number,
- * conditionally returning values based on whether a value is a number,
- * and more, making number-related tasks more convenient and expressive.
- *
- * @example
- * const num = 42
- * console.log(num.isNumber) // Output: true
- *
- * const notNum = "123"
- * console.log(notNum.isNumber) // Output: false
- *
- * @type {Patch}
- */
-export const NumberPrototypeExtensions: Patch;
-import { Patch } from '@nejs/extension';

package/dist/cjs/number.extension.js

@@ -1,261 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NumberPrototypeExtensions = exports.NumberExtensions = void 0;
-const extension_1 = require("@nejs/extension");
-/**
- * A patch for the JavaScript built-in `Number` class that adds utility
- * methods without modifying the global namespace directly
- *
- * This patch includes methods for checking if a value is a number and
- * conditionally returning a value based on whether the supplied value is
- * a number or not.
- *
- * @type {Patch}
- * @property {Object} [Patch.kMutablyHidden] An object containing methods
- * that are hidden from enumeration and mutation
- *
- * @example
- * import { NumberExtensions } from 'number.extension.js'
- *
- * NumberExtensions.apply()
- * // Now the `Number` class has additional methods available
- */
-exports.NumberExtensions = new extension_1.Patch(Number, {
-    [extension_1.Patch.kMutablyHidden]: {
-        /**
-         * Determines if the supplied `value` is a `Number`. This check is
-         * performed by first converting the `value` to a `Number` using the
-         * `Number()` constructor and checking to see if the result is not
-         * `NaN`. If that check passes, `typeof` is used to ensure that the
-         * original `value` is of type "number".
-         *
-         * @param {*} value The value that needs to be checked to determine if it
-         * is a `Number` or not
-         * @returns {boolean} `true` if the supplied `value` is a `Number`,
-         * `false` otherwise
-         *
-         * @example
-         * const num = 42
-         * isNumber(num) // true
-         * isNumber('42') // false
-         * isNumber(NaN) // false
-         * isNumber(Infinity) // true
-         */
-        isNumber(value) {
-            return !isNaN(value) && typeof value === 'number';
-        },
-        /**
-         * Checks if all or some of the supplied values are numbers.
-         *
-         * This method uses the `Array.prototype.every` or `Array.prototype.some`
-         * method to check if all or some of the supplied values are numbers,
-         * respectively. The method to use is determined by the `which` parameter.
-         *
-         * @param {string} [which='every'] - Determines the method to use for the
-         * check. Can be either 'every' or 'some'. Defaults to 'every'.
-         * @param {...*} values - The values to check.
-         * @returns {boolean} - Returns `true` if all or some of the values are
-         * numbers (based on the `which` parameter), `false` otherwise.
-         *
-         * @example
-         * areNumbers('every', 1, 2, 3) // true
-         * areNumbers('some', 1, '2', 3) // true
-         * areNumbers('every', 1, '2', 3) // false
-         */
-        areNumbers(which = ['every', 'some'][0], ...values) {
-            if (which !== 'every' && which !== 'some') {
-                return false;
-            }
-            return values[which](num => this.isNumber(num));
-        },
-        /**
-         * Conditionally returns a value based on whether the supplied `value` is
-         * a `Number` or not. If the `value` is a `Number`, the `thenValue` will
-         * be returned. If it is not a `Number`, the `elseValue` will be
-         * returned instead.
-         *
-         * @param {*} value The value to check to determine if it is a `Number`
-         * @param {*} thenValue The value to return if the supplied `value` is
-         * a `Number`
-         * @param {*} elseValue The value to return if the supplied `value` is
-         * not a `Number`
-         * @returns {*} Either the `thenValue` or `elseValue` depending on if the
-         * supplied `value` is a `Number`
-         *
-         * @example
-         * const num = 42
-         * const str = 'hello'
-         * ifNumber(num, 'is a number', 'not a number') // 'is a number'
-         * ifNumber(str, 'is a number', 'not a number') // 'not a number'
-         */
-        ifNumber(value, thenValue, elseValue) {
-            return isThenElse(this.isNumber(value), thenValue, elseValue);
-        },
-        /**
-         * Conditionally returns a value based on whether all or some of the
-         * supplied values are numbers.
-         *
-         * This method uses the `areNumbers` method to check if all or some of
-         * the supplied values are numbers, based on the `which` parameter.
-         * If the condition is met, the `thenValue` is returned, otherwise
-         * the `elseValue` is returned.
-         *
-         * @param {*} thenValue - The value to return if the condition is met.
-         * @param {*} elseValue - The value to return if the condition is not met.
-         * @param {string} [which='every'] - Determines the method to use for the
-         * check. Can be either 'every' or 'some'. Defaults to 'every'.
-         * @param {...*} numbers - The values to check.
-         * @returns {*} Either the `thenValue` or `elseValue` depending on if all
-         * or some of the supplied values are numbers.
-         *
-         * @example
-         * ifNumbers('All are numbers', 'Not all are numbers', 'every', 1, 2, 3)
-         * // returns 'All are numbers'
-         * ifNumbers('At least one is a number', 'None are numbers', 'some', 1, '2', 3)
-         * // returns 'At least one is a number'
-         * ifNumbers('All are numbers', 'Not all are numbers', 'every', 1, '2', 3)
-         * // returns 'Not all are numbers'
-         */
-        ifNumbers(thenValue, elseValue, which = ['every', 'some'][0], ...numbers) {
-            return isThenElse(this.areNumbers(which, ...numbers), thenValue, elseValue);
-        },
-        /**
-         * Clamps a value between a minimum and maximum value.
-         *
-         * This method checks if the provided value and the min and max bounds are
-         * numbers. If they are not, it returns the original value. If they are,
-         * it ensures that the value does not go below the minimum value or above
-         * the maximum value.
-         *
-         * @param {*} value - The value to clamp.
-         * @param {number} [minValue=-Infinity] - The minimum value. Defaults
-         * to -Infinity.
-         * @param {number} [maxValue=Infinity] - The maximum value. Defaults
-         * to Infinity.
-         * @returns {*} - Returns the clamped value if all parameters are numbers,
-         * otherwise returns the original value.
-         *
-         * @example
-         * clamp(10, 1, 5) // returns 5
-         * clamp(-10, 1, 5) // returns 1
-         * clamp(3, 1, 5) // returns 3
-         * clamp('10', 1, 5) // returns '10'
-         */
-        clamp(value, minValue = -Infinity, maxValue = Infinity) {
-            if (!this.areNumbers('every', value, minValue, maxValue)) {
-                return value;
-            }
-            return Math.max(minValue, Math.min(maxValue, value));
-        },
-    }
-});
-const { isNumber: pIsNumber, ifNumber: pIfNumber } = exports.NumberExtensions.patches;
-/**
- * `NumberPrototypeExtensions` provides a set of utility methods that
- * are added to the `Number` prototype. This allows all number instances
- * to access new functionality directly, enhancing their capabilities
- * beyond the standard `Number` class methods.
- *
- * These extensions are applied using the `Patch` class from
- * '@nejs/extension', ensuring that they do not interfere with the
- * global namespace or existing properties.
- *
- * The extensions include methods for checking if a value is a number,
- * conditionally returning values based on whether a value is a number,
- * and more, making number-related tasks more convenient and expressive.
- *
- * @example
- * const num = 42
- * console.log(num.isNumber) // Output: true
- *
- * const notNum = "123"
- * console.log(notNum.isNumber) // Output: false
- *
- * @type {Patch}
- */
-exports.NumberPrototypeExtensions = new extension_1.Patch(Number.prototype, {
-    [extension_1.Patch.kMutablyHidden]: {
-        /**
-         * Returns an object representation of the number instance.
-         *
-         * This getter method creates and returns an object that wraps the number
-         * instance, allowing it to be treated as an object. The returned object
-         * is created using the `Object()` constructor, which takes the number
-         * instance as its argument.
-         *
-         * @type {Object}
-         * @readonly
-         *
-         * @example
-         * const num = 42
-         * console.log(typeof num)           // 'number'
-         * console.log(typeof num.instance)  // 'object'
-         */
-        get instance() {
-            return Object(this);
-        },
-        /**
-         * Determines if the current object is a number
-         *
-         * This getter uses the `pIsNumber` function from the `NumberExtensions`
-         * patch to check if the current object (`this`) is a number.
-         *
-         * @type {boolean}
-         * @readonly
-         *
-         * @example
-         * const num = 42
-         * console.log(num.isNumber) // Output: true
-         *
-         * const notNum = "123"
-         * console.log(notNum.isNumber) // Output: false
-         */
-        get isNumber() {
-            return pIsNumber(this);
-        },
-        /**
-         * Checks if the current object is a number and returns the corresponding
-         * value based on the result.
-         *
-         * This method uses the `pIfNumber` function from the `NumberExtensions`
-         * patch to determine if the current object (`this`) is a number. If it is
-         * a number, the `thenValue` is returned. Otherwise, the `elseValue` is
-         * returned.
-         *
-         * @param {any} thenValue The value to return if the current object is
-         * a number
-         * @param {any} elseValue The value to return if the current object is not
-         * a number
-         * @returns {any} The `thenValue` if the current object is a number, or
-         * the `elseValue` if it is not a number
-         *
-         * @example
-         * const num = 42
-         * console.log(num.ifNumber('Is a number', 'Not a number'))
-         * // Output: 'Is a number'
-         *
-         * const notNum = '123'
-         * console.log(notNum.ifNumber('Is a number', 'Not a number'))
-         * // Output: 'Not a number'
-         */
-        ifNumber(thenValue, elseValue) {
-            return pIfNumber(this, thenValue, elseValue);
-        },
-    }
-});
-// NOTE to self; this is repeated here otherwise a circular reference from
-// Object<->Function<->Global occurs. See original source in global.this.js
-// {@see globalThis.isThenElse}
-function isThenElse(bv, tv, ev) {
-    function isFunction(value) { typeof value === 'function'; }
-    if (arguments.length > 1) {
-        var _then = isFunction(tv) ? tv(bv) : tv;
-        if (arguments.length > 2) {
-            var _else = isFunction(ev) ? tv(bv) : ev;
-            return bv ? _then : _else;
-        }
-        return bv || _then;
-    }
-    return bv;
-}
-//# sourceMappingURL=number.extension.js.map

package/dist/cjs/number.extension.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"number.extension.js","sourceRoot":"","sources":["../../src/number.extension.js"],"names":[],"mappings":"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"}

package/dist/cjs/object.extensions.d.ts

@@ -1,33 +0,0 @@
-/**
- * `ObjectExtensions` is a constant that applies a patch to the global
- * `Object` constructor. This patch extends the `Object` with additional
- * methods and properties, enhancing its functionality.
- *
- * The `Patch` function takes two arguments: the target object to be patched
- * (in this case, `Object`), and an object containing the methods and
- * properties to be added to the target object.
- *
- * @type {Patch}
- * @memberof module:object.extensions
- */
-export const ObjectExtensions: Patch;
-/**
- * `ObjectPrototypeExtensions` is a constant that applies a patch to the
- * Object prototype. This patch extends the Object prototype with additional
- * methods and properties, enhancing its functionality.
- *
- * The `Patch` function takes two arguments: the target object to be patched
- * (in this case, `Object.prototype`), and an object containing the methods
- * and properties to be added to the target object.
- *
- * @example
- * // Using a method added by ObjectPrototypeExtensions
- * const obj = {};
- * console.log(obj.isObject()); // Output: true
- *
- * @const
- * @type {Patch}
- * @memberof module:object.extensions
- */
-export const ObjectPrototypeExtensions: Patch;
-import { Patch } from '@nejs/extension';