@nejs/basic-extensions 2.21.5 → 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/math.extension.d.ts

@@ -1,14 +0,0 @@
-/**
- * `Math` extensions. Building better worlds...actually just
- * providing some parity between Number and BigInt types for
- * now, but later, better worlds.
- *
- * @type {Patch}
- * @example
- * import { MathExtensions } from 'math.extension.js'
- *
- * MathExtensions.apply()
- * // Now the `Math` class has additional methods available
- */
-export const MathExtensions: Patch;
-import { Patch } from '@nejs/extension';

package/dist/cjs/math.extension.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MathExtensions = void 0;
-const extension_1 = require("@nejs/extension");
-/**
- * `Math` extensions. Building better worlds...actually just
- * providing some parity between Number and BigInt types for
- * now, but later, better worlds.
- *
- * @type {Patch}
- * @example
- * import { MathExtensions } from 'math.extension.js'
- *
- * MathExtensions.apply()
- * // Now the `Math` class has additional methods available
- */
-exports.MathExtensions = new extension_1.Patch(Math, {
-    [extension_1.Patch.kMutablyHidden]: {
-        /**
-         * The Math.min() static method returns the smallest of the numbers given
-         * as input parameters, or Infinity if there are no parameters.
-         *
-         * @param {bigint|number} values value1, …, valueN – Zero or more numbers
-         * among which the lowest value will be selected and returned.
-         * @returns {bigint|number|NaN|Infinity} The smallest of the given numbers.
-         * Returns NaN if any of the parameters is or is converted into NaN or if
-         * the types of numbers are mismatched (i.e., bigint vs. number types).
-         * Returns Infinity if no parameters are provided.
-         */
-        min(...values) {
-            const sorter = (l, r) => l < r ? -1 : l > r ? 1 : 0;
-            if (!values.length)
-                return Infinity;
-            if (values.every(n => typeof n === 'bigint')) {
-                return values.toSorted(sorter).at(0);
-            }
-            else if (values.every(n => typeof n === 'number')) {
-                return values.toSorted(sorter).at(0);
-            }
-            else {
-                return NaN;
-            }
-        },
-        /**
-         * The Math.max() static method returns the largest of the numbers given
-         * as input parameters, or Infinity if there are no parameters.
-         *
-         * @param {bigint|number} values value1, …, valueN – Zero or more numbers
-         * among which the largest value will be selected and returned.
-         * @returns {bigint|number|NaN|Infinity} The largest of the given numbers.
-         * Returns NaN if any of the parameters is or is converted into NaN or if
-         * the types of numbers are mismatched (i.e., bigint vs. number types).
-         * Returns Infinity if no parameters are provided.
-         */
-        max(...values) {
-            const sorter = (l, r) => l < r ? -1 : l > r ? 1 : 0;
-            if (!values.length)
-                return Infinity;
-            if (values.every(n => typeof n === 'bigint')) {
-                return values.toSorted(sorter).at(-1);
-            }
-            else if (values.every(n => typeof n === 'number')) {
-                return values.toSorted(sorter).at(-1);
-            }
-            else {
-                return NaN;
-            }
-        },
-    },
-});
-//# sourceMappingURL=math.extension.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"math.extension.js","sourceRoot":"","sources":["../../src/math.extension.js"],"names":[],"mappings":";;;AAAA,+CAAuC;AAEvC;;;;;;;;;;;GAWG;AACU,QAAA,cAAc,GAAG,IAAI,iBAAK,CAAC,IAAI,EAAE;IAC5C,CAAC,iBAAK,CAAC,cAAc,CAAC,EAAE;QACtB;;;;;;;;;;WAUG;QACH,GAAG,CAAC,GAAG,MAAM;YACX,MAAM,MAAM,GAAG,CAAC,CAAC,EAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;YAElD,IAAI,CAAC,MAAM,CAAC,MAAM;gBAChB,OAAO,QAAQ,CAAA;YAEjB,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,EAAE,CAAC;gBAC7C,OAAO,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;YACtC,CAAC;iBACI,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,EAAE,CAAC;gBAClD,OAAO,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;YACtC,CAAC;iBACI,CAAC;gBACJ,OAAO,GAAG,CAAA;YACZ,CAAC;QACH,CAAC;QAED;;;;;;;;;;WAUG;QACH,GAAG,CAAC,GAAG,MAAM;YACX,MAAM,MAAM,GAAG,CAAC,CAAC,EAAC,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;YAElD,IAAI,CAAC,MAAM,CAAC,MAAM;gBAChB,OAAO,QAAQ,CAAA;YAEjB,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,EAAE,CAAC;gBAC7C,OAAO,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;YACvC,CAAC;iBACI,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,EAAE,CAAC;gBAClD,OAAO,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;YACvC,CAAC;iBACI,CAAC;gBACJ,OAAO,GAAG,CAAA;YACZ,CAAC;QACH,CAAC;KACF;CACF,CAAC,CAAA"}

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';