@danielsimonjr/mathts-functions 0.2.3 → 0.2.5

package/dist/utils/bignumber/bitwise.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Bitwise and for Bignumbers
+ *
+ * Special Cases:
+ *   N &  n =  N
+ *   n &  0 =  0
+ *   n & -1 =  n
+ *   n &  n =  n
+ *   I &  I =  I
+ *  -I & -I = -I
+ *   I & -I =  0
+ *   I &  n =  n
+ *   I & -n =  I
+ *  -I &  n =  0
+ *  -I & -n = -I
+ *
+ * @param {BigNumber} x
+ * @param {BigNumber} y
+ * @return {BigNumber} Result of `x` & `y`, is fully precise
+ * @private
+ */
+export declare function bitAndBigNumber(x: any, y: any): any;
+/**
+ * Bitwise not
+ * @param {BigNumber} x
+ * @return {BigNumber} Result of ~`x`, fully precise
+ *
+ */
+export declare function bitNotBigNumber(x: any): any;
+/**
+ * Bitwise OR for BigNumbers
+ *
+ * Special Cases:
+ *   N |  n =  N
+ *   n |  0 =  n
+ *   n | -1 = -1
+ *   n |  n =  n
+ *   I |  I =  I
+ *  -I | -I = -I
+ *   I | -n = -1
+ *   I | -I = -1
+ *   I |  n =  I
+ *  -I |  n = -I
+ *  -I | -n = -n
+ *
+ * @param {BigNumber} x
+ * @param {BigNumber} y
+ * @return {BigNumber} Result of `x` | `y`, fully precise
+ */
+export declare function bitOrBigNumber(x: any, y: any): any;
+/**
+ * Applies bitwise function to numbers
+ * @param {BigNumber} x
+ * @param {BigNumber} y
+ * @param {function (a, b)} func
+ * @return {BigNumber}
+ */
+export declare function bitwise(x: any, y: any, func: any): any;
+/**
+ * Bitwise XOR for BigNumbers
+ *
+ * Special Cases:
+ *   N ^  n =  N
+ *   n ^  0 =  n
+ *   n ^  n =  0
+ *   n ^ -1 = ~n
+ *   I ^  n =  I
+ *   I ^ -n = -I
+ *   I ^ -I = -1
+ *  -I ^  n = -I
+ *  -I ^ -n =  I
+ *
+ * @param {BigNumber} x
+ * @param {BigNumber} y
+ * @return {BigNumber} Result of `x` ^ `y`, fully precise
+ *
+ */
+export declare function bitXor(x: any, y: any): any;
+/**
+ * Bitwise left shift
+ *
+ * Special Cases:
+ *  n << -n = N
+ *  n <<  N = N
+ *  N <<  n = N
+ *  n <<  0 = n
+ *  0 <<  n = 0
+ *  I <<  I = N
+ *  I <<  n = I
+ *  n <<  I = I
+ *
+ * @param {BigNumber} x
+ * @param {BigNumber} y
+ * @return {BigNumber} Result of `x` << `y`
+ *
+ */
+export declare function leftShiftBigNumber(x: any, y: any): any;
+export declare function rightArithShiftBigNumber(x: any, y: any): any;
+//# sourceMappingURL=bitwise.d.ts.map

package/dist/utils/bignumber/bitwise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitwise.d.ts","sourceRoot":"","sources":["../../../src/utils/bignumber/bitwise.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,OA8C7C;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,OAcrC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,OAkC5C;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,OA+DhD;AA6DD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,OAqCpC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,OAqBhD;AAqBD,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,OA2BtD"}

package/dist/utils/bignumber/constants.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Calculate BigNumber e
+ * @param {function} BigNumber   BigNumber constructor
+ * @returns {BigNumber} Returns e
+ */
+export declare const createBigNumberE: import("../function.js").MemoizedFunction;
+/**
+ * Calculate BigNumber golden ratio, phi = (1+sqrt(5))/2
+ * @param {function} BigNumber   BigNumber constructor
+ * @returns {BigNumber} Returns phi
+ */
+export declare const createBigNumberPhi: import("../function.js").MemoizedFunction;
+/**
+ * Calculate BigNumber pi.
+ * @param {function} BigNumber   BigNumber constructor
+ * @returns {BigNumber} Returns pi
+ */
+export declare const createBigNumberPi: import("../function.js").MemoizedFunction;
+/**
+ * Calculate BigNumber tau, tau = 2 * pi
+ * @param {function} BigNumber   BigNumber constructor
+ * @returns {BigNumber} Returns tau
+ */
+export declare const createBigNumberTau: import("../function.js").MemoizedFunction;
+//# sourceMappingURL=constants.d.ts.map

package/dist/utils/bignumber/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/utils/bignumber/constants.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,2CAK5B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,2CAK9B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,2CAK7B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,2CAK9B,CAAC"}

package/dist/utils/bignumber/formatter.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Convert a BigNumber to a formatted string representation.
+ *
+ * Syntax:
+ *
+ *    format(value)
+ *    format(value, options)
+ *    format(value, precision)
+ *    format(value, fn)
+ *
+ * Where:
+ *
+ *    {number} value   The value to be formatted
+ *    {Object} options An object with formatting options. Available options:
+ *                     {string} notation
+ *                         Number notation. Choose from:
+ *                         'fixed'          Always use regular number notation.
+ *                                          For example '123.40' and '14000000'
+ *                         'exponential'    Always use exponential notation.
+ *                                          For example '1.234e+2' and '1.4e+7'
+ *                         'auto' (default) Regular number notation for numbers
+ *                                          having an absolute value between
+ *                                          `lower` and `upper` bounds, and uses
+ *                                          exponential notation elsewhere.
+ *                                          Lower bound is included, upper bound
+ *                                          is excluded.
+ *                                          For example '123.4' and '1.4e7'.
+ *                         'bin', 'oct, or
+ *                         'hex'            Format the number using binary, octal,
+ *                                          or hexadecimal notation.
+ *                                          For example '0b1101' and '0x10fe'.
+ *                     {number} wordSize    The word size in bits to use for formatting
+ *                                          in binary, octal, or hexadecimal notation.
+ *                                          To be used only with 'bin', 'oct', or 'hex'
+ *                                          values for 'notation' option. When this option
+ *                                          is defined the value is formatted as a signed
+ *                                          twos complement integer of the given word size
+ *                                          and the size suffix is appended to the output.
+ *                                          For example
+ *                                          format(-1, {notation: 'hex', wordSize: 8}) === '0xffi8'.
+ *                                          Default value is undefined.
+ *                     {number} precision   A number between 0 and 16 to round
+ *                                          the digits of the number.
+ *                                          In case of notations 'exponential',
+ *                                          'engineering', and 'auto',
+ *                                          `precision` defines the total
+ *                                          number of significant digits returned.
+ *                                          In case of notation 'fixed',
+ *                                          `precision` defines the number of
+ *                                          significant digits after the decimal
+ *                                          point.
+ *                                          `precision` is undefined by default.
+ *                     {number} lowerExp    Exponent determining the lower boundary
+ *                                          for formatting a value with an exponent
+ *                                          when `notation='auto`.
+ *                                          Default value is `-3`.
+ *                     {number} upperExp    Exponent determining the upper boundary
+ *                                          for formatting a value with an exponent
+ *                                          when `notation='auto`.
+ *                                          Default value is `5`.
+ *    {Function} fn    A custom formatting function. Can be used to override the
+ *                     built-in notations. Function `fn` is called with `value` as
+ *                     parameter and must return a string. Is useful for example to
+ *                     format all values inside a matrix in a particular way.
+ *
+ * Examples:
+ *
+ *    format(6.4)                                        // '6.4'
+ *    format(1240000)                                    // '1.24e6'
+ *    format(1/3)                                        // '0.3333333333333333'
+ *    format(1/3, 3)                                     // '0.333'
+ *    format(21385, 2)                                   // '21000'
+ *    format(12e8, {notation: 'fixed'})                  // returns '1200000000'
+ *    format(2.3,    {notation: 'fixed', precision: 4})  // returns '2.3000'
+ *    format(52.8,   {notation: 'exponential'})          // returns '5.28e+1'
+ *    format(12400,  {notation: 'engineering'})          // returns '12.400e+3'
+ *
+ * @param {BigNumber} value
+ * @param {Object | Function | number | BigNumber} [options]
+ * @return {string} str The formatted value
+ */
+export declare function format(value: any, options: any): any;
+/**
+ * Format a BigNumber in engineering notation. Like '1.23e+6', '2.3e+0', '3.500e-3'
+ * @param {BigNumber} value
+ * @param {number} [precision]        Optional number of significant figures to return.
+ */
+export declare function toEngineering(value: any, precision: any): string;
+/**
+ * Format a number in exponential notation. Like '1.23e+5', '2.3e+0', '3.500e-3'
+ * @param {BigNumber} value
+ * @param {number} [precision]  Number of digits in formatted output.
+ *                              If not provided, the maximum available digits
+ *                              is used.
+ * @returns {string} str
+ */
+export declare function toExponential(value: any, precision: any): any;
+/**
+ * Format a number with fixed notation.
+ * @param {BigNumber} value
+ * @param {number} [precision=undefined] Optional number of decimals after the
+ *                                       decimal point. Undefined by default.
+ */
+export declare function toFixed(value: any, precision: any): any;
+//# sourceMappingURL=formatter.d.ts.map

package/dist/utils/bignumber/formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../../src/utils/bignumber/formatter.ts"],"names":[],"mappings":"AA4CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,OAqE9C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,UAevD;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,OAMvD;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,OAEjD"}

package/dist/utils/bignumber/nearlyEqual.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Compares two BigNumbers.
+ * @param {BigNumber} a - First value to compare
+ * @param {BigNumber} b - Second value to compare
+ * @param {number} [relTol=1e-09] - The relative tolerance, indicating the maximum allowed difference relative to the larger absolute value. Must be greater than 0.
+ * @param {number} [absTol=0] - The minimum absolute tolerance, useful for comparisons near zero. Must be at least 0.
+ * @returns {boolean} whether the two numbers are nearly equal
+ * @throws {Error} If `relTol` is less than or equal to 0.
+ * @throws {Error} If `absTol` is less than 0.
+ *
+ * @example
+ * nearlyEqual(1.000000001, 1.0, 1e-9);            // true
+ * nearlyEqual(1.000000002, 1.0, 0);            // false
+ * nearlyEqual(1.0, 1.009, undefined, 0.02);       // true
+ * nearlyEqual(0.000000001, 0.0, undefined, 1e-8); // true
+ */
+export declare function nearlyEqual(a: any, b: any, relTol?: number, absTol?: number): any;
+//# sourceMappingURL=nearlyEqual.d.ts.map

package/dist/utils/bignumber/nearlyEqual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nearlyEqual.d.ts","sourceRoot":"","sources":["../../../src/utils/bignumber/nearlyEqual.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,SAAO,EAAE,MAAM,SAAI,OAyBpE"}

package/dist/utils/clone.d.ts

@@ -0,0 +1,7 @@
+import type { TypedFunction } from '../core/function/typed.js';
+interface CloneDependencies {
+    typed: TypedFunction;
+}
+export declare const createClone: import("../utils/factory.js").FactoryFunction<CloneDependencies, unknown>;
+export {};
+//# sourceMappingURL=clone.d.ts.map

package/dist/utils/clone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone.d.ts","sourceRoot":"","sources":["../../src/utils/clone.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG/D,UAAU,iBAAiB;IACzB,KAAK,EAAE,aAAa,CAAC;CACtB;AAKD,eAAO,MAAM,WAAW,2EA0BvB,CAAC"}

package/dist/utils/collection.d.ts

@@ -0,0 +1,67 @@
+interface Matrix<T = unknown> {
+    forEach(callback: (value: T) => void, skipZeros: boolean, recurse: boolean): void;
+    map<U>(callback: (value: T) => U, skipZeros: boolean, recurse: boolean): Matrix<U>;
+    size(): number[];
+    valueOf(): T[];
+    create(data: T[], datatype?: string): Matrix<T>;
+    datatype(): string | undefined;
+}
+interface SparseMatrix<T = unknown> {
+    _values: T[];
+    _index: number[];
+    _ptr: number[];
+}
+/**
+ * Test whether an array contains collections
+ * @param array - Array to test
+ * @returns Returns true when the array contains one or multiple
+ *          collections (Arrays or Matrices). Returns false otherwise.
+ */
+export declare function containsCollections(array: unknown[]): boolean;
+/**
+ * Recursively loop over all elements in a given multi dimensional array
+ * and invoke the callback on each of the elements.
+ * @param array - Array or Matrix to iterate over
+ * @param callback - The callback method is invoked with one parameter: the current element in the array
+ */
+export declare function deepForEach<T>(array: T[] | Matrix<T>, callback: (value: T) => void): void;
+/**
+ * Execute the callback function element wise for each element in array and any
+ * nested array
+ * Returns an array with the results
+ * @param array - Array or Matrix to map over
+ * @param callback - The callback is called with two parameters:
+ *                   value1 and value2, which contain the current
+ *                   element of both arrays.
+ * @param skipZeros - Invoke callback function for non-zero values only.
+ *
+ * @return Mapped result
+ */
+export declare function deepMap<T, U>(array: T[] | Matrix<T>, callback: (value: T) => U, skipZeros?: boolean): U[] | Matrix<U>;
+/**
+ * Reduce a given matrix or array to a new matrix or
+ * array with one less dimension, applying the given
+ * callback in the selected dimension.
+ * @param mat - Array or Matrix to reduce
+ * @param dim - Dimension to reduce
+ * @param callback - Callback function
+ * @return Reduced result
+ */
+export declare function reduce<T, U>(mat: T[] | Matrix<T>, dim: number, callback: (acc: U | T, val: T) => U): U[] | Matrix<U>;
+/**
+ * Scatter function for sparse matrix operations
+ * @param a - Sparse matrix
+ * @param j - Column index
+ * @param w - Work array for marking visited rows
+ * @param x - Work array for storing values
+ * @param u - Work array for marking updated rows
+ * @param mark - Current mark value
+ * @param cindex - Column index array to update
+ * @param f - Binary function to apply
+ * @param inverse - Whether to inverse the function arguments
+ * @param update - Whether to update existing values
+ * @param value - Value to use in binary function
+ */
+export declare function scatter<T>(a: SparseMatrix<T>, j: number, w: number[], x: T[] | null, u: number[], mark: number, cindex: number[], f?: (a: T, b: T) => T, inverse?: boolean, update?: boolean, value?: T): void;
+export {};
+//# sourceMappingURL=collection.d.ts.map

package/dist/utils/collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../src/utils/collection.ts"],"names":[],"mappings":"AAMA,UAAU,MAAM,CAAC,CAAC,GAAG,OAAO;IAC1B,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IAClF,GAAG,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACnF,IAAI,IAAI,MAAM,EAAE,CAAC;IACjB,OAAO,IAAI,CAAC,EAAE,CAAC;IACf,MAAM,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAChD,QAAQ,IAAI,MAAM,GAAG,SAAS,CAAC;CAChC;AAED,UAAU,YAAY,CAAC,CAAC,GAAG,OAAO;IAChC,OAAO,EAAE,CAAC,EAAE,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,OAAO,CAO7D;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,GAAG,IAAI,CAMzF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,CAAC,EAC1B,KAAK,EAAE,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,EACtB,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,EACzB,SAAS,CAAC,EAAE,OAAO,GAClB,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAcjB;AAED;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,EACzB,GAAG,EAAE,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,EACpB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,GAClC,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAgBjB;AAwCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,CAAC,EACvB,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,EAClB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EAAE,EACX,CAAC,EAAE,CAAC,EAAE,GAAG,IAAI,EACb,CAAC,EAAE,MAAM,EAAE,EACX,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EAAE,EAChB,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,EACrB,OAAO,CAAC,EAAE,OAAO,EACjB,MAAM,CAAC,EAAE,OAAO,EAChB,KAAK,CAAC,EAAE,CAAC,GACR,IAAI,CAyDN"}

package/dist/utils/complex.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Test whether two complex values are equal provided a given relTol and absTol.
+ * Does not use or change the global Complex.EPSILON setting
+ * @param {Complex} x - The first complex number for comparison.
+ * @param {Complex} y - The second complex number for comparison.
+ * @param {number} relTol - The relative tolerance for comparison.
+ * @param {number} absTol - The absolute tolerance for comparison.
+ * @returns {boolean} - Returns true if the two complex numbers are equal within the given tolerances, otherwise returns false.
+ */
+export declare function complexEquals(x: any, y: any, relTol: any, absTol: any): boolean;
+//# sourceMappingURL=complex.d.ts.map

package/dist/utils/complex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complex.d.ts","sourceRoot":"","sources":["../../src/utils/complex.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,WAErE"}

package/dist/utils/customs.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Get a property of a plain object
+ * Throws an error in case the object is not a plain object or the
+ * property is not defined on the object itself
+ * @param {Object} object
+ * @param {string} prop
+ * @return {*} Returns the property value when safe
+ */
+declare function getSafeProperty(object: any, prop: any): any;
+/**
+ * Set a property on a plain object.
+ * Throws an error in case the object is not a plain object or the
+ * property would override an inherited property like .constructor or .toString
+ * @param {Object} object
+ * @param {string} prop
+ * @param {*} value
+ * @return {*} Returns the value
+ */
+declare function setSafeProperty(object: any, prop: any, value: any): any;
+/**
+ * Test whether a property is safe to use on an object or Array.
+ * For example .toString and .constructor are not safe
+ * @param {Object | Array} object
+ * @param {string} prop
+ * @return {boolean} Returns true when safe
+ */
+declare function isSafeProperty(object: any, prop: any): boolean;
+/**
+ * Validate whether a method is safe.
+ * Throws an error when that's not the case.
+ * @param {Object} object
+ * @param {string} method
+ * @return {function} Returns the method when valid
+ */
+declare function getSafeMethod(object: any, method: any): any;
+/**
+ * Check whether a method is safe.
+ * Throws an error when that's not the case (for example for `constructor`).
+ * @param {Object} object
+ * @param {string} method
+ * @return {boolean} Returns true when safe, false otherwise
+ */
+declare function isSafeMethod(object: any, method: any): boolean;
+declare function isPlainObject(object: any): boolean;
+export { getSafeProperty };
+export { setSafeProperty };
+export { isSafeProperty };
+export { getSafeMethod };
+export { isSafeMethod };
+export { isPlainObject };
+//# sourceMappingURL=customs.d.ts.map

package/dist/utils/customs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"customs.d.ts","sourceRoot":"","sources":["../../src/utils/customs.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,iBAAS,eAAe,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,OAW9C;AAED;;;;;;;;GAQG;AAEH,iBAAS,eAAe,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,OAQ1D;AAED;;;;;;GAMG;AACH,iBAAS,cAAc,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,WA0B7C;AAED;;;;;;GAMG;AACH,iBAAS,aAAa,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,OAM9C;AAED;;;;;;GAMG;AACH,iBAAS,YAAY,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,WAoC7C;AAED,iBAAS,aAAa,CAAC,MAAM,EAAE,GAAG,WAEjC;AAaD,OAAO,EAAE,eAAe,EAAE,CAAC;AAC3B,OAAO,EAAE,eAAe,EAAE,CAAC;AAC3B,OAAO,EAAE,cAAc,EAAE,CAAC;AAC1B,OAAO,EAAE,aAAa,EAAE,CAAC;AACzB,OAAO,EAAE,YAAY,EAAE,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/utils/emitter.d.ts

@@ -0,0 +1,13 @@
+export interface EmitterMixin {
+    on: (event: string, callback: (...args: any[]) => void, context?: any) => void;
+    off: (event: string, callback?: (...args: any[]) => void) => void;
+    once: (event: string, callback: (...args: any[]) => void, context?: any) => void;
+    emit: (event: string, ...args: any[]) => void;
+}
+/**
+ * Extend given object with emitter functions `on`, `off`, `once`, `emit`
+ * @param obj - Object to extend with emitter functions
+ * @return The object with emitter methods
+ */
+export declare function mixin<T extends object>(obj: T): T & EmitterMixin;
+//# sourceMappingURL=emitter.d.ts.map

package/dist/utils/emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.d.ts","sourceRoot":"","sources":["../../src/utils/emitter.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;IAC/E,GAAG,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,KAAK,IAAI,CAAC;IAClE,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;IACjF,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;CAC/C;AAED;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,YAAY,CAYhE"}

package/dist/utils/factory.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Type for a factory function that creates instances
+ */
+export interface FactoryFunction<_TDeps = any, TResult = any> {
+    (scope: Record<string, any>): TResult;
+    isFactory: true;
+    fn: string;
+    dependencies: string[];
+    meta?: FactoryMeta;
+}
+/**
+ * Type for legacy factory objects (old-style factories)
+ */
+export interface LegacyFactory {
+    type?: string;
+    name: string;
+    factory: (...args: any[]) => any;
+    math?: boolean;
+    dependencies?: string[];
+    meta?: FactoryMeta;
+}
+/**
+ * Meta information that can be attached to a factory
+ */
+export interface FactoryMeta {
+    /**
+     * If true, the factory will be recreated when config changes
+     */
+    recreateOnConfigChange?: boolean;
+    /**
+     * If true, this is a lazy factory that should only be created when needed
+     */
+    lazy?: boolean;
+    /**
+     * Additional custom metadata
+     */
+    [key: string]: any;
+}
+/**
+ * Type for dependency names, which can be optional (prefixed with '?')
+ */
+export type DependencyName = string;
+/**
+ * Type for the create callback function
+ */
+export type CreateFunction<TDeps extends Record<string, any>, TResult> = (dependencies: TDeps) => TResult;
+/**
+ * Create a factory function, which can be used to inject dependencies.
+ *
+ * The created functions are memoized, a consecutive call of the factory
+ * with the exact same inputs will return the same function instance.
+ * The memoized cache is exposed on `factory.cache` and can be cleared
+ * if needed.
+ *
+ * Example:
+ *
+ *     const name = 'log'
+ *     const dependencies = ['config', 'typed', 'divideScalar', 'Complex']
+ *
+ *     export const createLog = factory(name, dependencies, ({ typed, config, divideScalar, Complex }) => {
+ *       // ... create the function log here and return it
+ *     }
+ *
+ * @param name           Name of the function to be created
+ * @param dependencies   The names of all required dependencies
+ * @param create         Callback function called with an object with all dependencies
+ * @param meta           Optional object with meta information that will be attached
+ *                       to the created factory function as property `meta`. For explanation
+ *                       of what meta properties can be specified and what they mean, see
+ *                       docs/core/extension.md.
+ * @returns The factory function
+ */
+export declare function factory<TDeps extends Record<string, any> = any, TResult = any>(name: string, dependencies: DependencyName[], create: CreateFunction<TDeps, TResult>, meta?: FactoryMeta): FactoryFunction<TDeps, TResult>;
+/**
+ * Sort all factories such that when loading in order, the dependencies are resolved.
+ *
+ * @param factories Array of factory functions or legacy factories
+ * @returns Returns a new array with the sorted factories
+ */
+export declare function sortFactories(factories: Array<FactoryFunction | LegacyFactory>): Array<FactoryFunction | LegacyFactory>;
+export declare function create(factories: Array<FactoryFunction | LegacyFactory>, scope?: Record<string, any>): Record<string, any>;
+/**
+ * Test whether an object is a factory. This is the case when it has
+ * properties name, dependencies, and a function create.
+ * @param obj Any value to test
+ * @returns true if obj is a factory function
+ */
+export declare function isFactory(obj: any): obj is FactoryFunction;
+/**
+ * Assert that all dependencies of a list with dependencies are available in the provided scope.
+ *
+ * Will throw an exception when there are dependencies missing.
+ *
+ * @param name         Name for the function to be created. Used to generate a useful error message
+ * @param dependencies Array of dependency names
+ * @param scope        Object containing the available dependencies
+ * @throws Error if required dependencies are missing
+ */
+export declare function assertDependencies(name: string, dependencies: DependencyName[], scope: Record<string, any>): void;
+/**
+ * Check if a dependency is optional (starts with '?')
+ * @param dependency The dependency name to check
+ * @returns true if the dependency is optional
+ */
+export declare function isOptionalDependency(dependency: DependencyName): boolean;
+/**
+ * Remove the optional notation '?' from a dependency name
+ * @param dependency The dependency name
+ * @returns The dependency name without optional notation
+ */
+export declare function stripOptionalNotation(dependency: DependencyName): string;
+//# sourceMappingURL=factory.d.ts.map

package/dist/utils/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/utils/factory.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,MAAM,GAAG,GAAG,EAAE,OAAO,GAAG,GAAG;IAC1D,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC;IACtC,SAAS,EAAE,IAAI,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;IACjC,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,IAAI,CAAC,EAAE,WAAW,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC;;OAEG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;OAEG;IACH,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC;AAEpC;;GAEG;AACH,MAAM,MAAM,cAAc,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,IAAI,CACvE,YAAY,EAAE,KAAK,KAChB,OAAO,CAAC;AAEb;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,OAAO,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,EAAE,OAAO,GAAG,GAAG,EAC5E,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,cAAc,EAAE,EAC9B,MAAM,EAAE,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,EACtC,IAAI,CAAC,EAAE,WAAW,GACjB,eAAe,CAAC,KAAK,EAAE,OAAO,CAAC,CAoBjC;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,KAAK,CAAC,eAAe,GAAG,aAAa,CAAC,GAChD,KAAK,CAAC,eAAe,GAAG,aAAa,CAAC,CAkFxC;AAGD,wBAAgB,MAAM,CACpB,SAAS,EAAE,KAAK,CAAC,eAAe,GAAG,aAAa,CAAC,EACjD,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GAC9B,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAQrB;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,eAAe,CAE1D;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,cAAc,EAAE,EAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACzB,IAAI,CAeN;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,cAAc,GAAG,OAAO,CAExE;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,cAAc,GAAG,MAAM,CAExE"}

package/dist/utils/function.d.ts

@@ -0,0 +1,44 @@
+import { lruQueue } from './lruQueue.js';
+/**
+ * Memoize a given function by caching the computed result.
+ * The cache of a memoized function can be cleared by deleting the `cache`
+ * property of the function.
+ *
+ * @param {function} fn                     The function to be memoized.
+ *                                          Must be a pure function.
+ * @param {Object} [options]
+ * @param {function(args: Array): string} [options.hasher]
+ *    A custom hash builder. Is JSON.stringify by default.
+ * @param {number | undefined} [options.limit]
+ *    Maximum number of values that may be cached. Undefined indicates
+ *    unlimited (default)
+ * @return {function}                       Returns the memoized function
+ */
+export interface MemoizeCache {
+    values: Map<string, any>;
+    lru: ReturnType<typeof lruQueue>;
+}
+export interface MemoizedFunction {
+    (...args: any[]): any;
+    cache?: MemoizeCache;
+}
+export declare function memoize(fn: any, { hasher, limit }?: {
+    hasher?: any;
+    limit?: any;
+}): MemoizedFunction;
+/**
+ * Memoize a given function by caching all results and the arguments,
+ * and comparing against the arguments of previous results before
+ * executing again.
+ * This is less performant than `memoize` which calculates a hash,
+ * which is very fast to compare. Use `memoizeCompare` only when it is
+ * not possible to create a unique serializable hash from the function
+ * arguments.
+ * The isEqual function must compare two sets of arguments
+ * and return true when equal (can be a deep equality check for example).
+ * @param {function} fn
+ * @param {function(a: *, b: *) : boolean} isEqual
+ * @returns {function}
+ */
+export declare function memoizeCompare(fn: any, isEqual: any): any;
+//# sourceMappingURL=function.d.ts.map

package/dist/utils/function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.d.ts","sourceRoot":"","sources":["../../src/utils/function.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACzB,GAAG,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,gBAAgB;IAC/B,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,CAAC;IACtB,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB;AAED,wBAAgB,OAAO,CACrB,EAAE,EAAE,GAAG,EACP,EAAE,MAAM,EAAE,KAAK,EAAE,GAAE;IAAE,MAAM,CAAC,EAAE,GAAG,CAAC;IAAC,KAAK,CAAC,EAAE,GAAG,CAAA;CAAO,GACpD,gBAAgB,CA8BlB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,GAAG,GAAG,CA0BzD"}

package/dist/utils/hasNumericValue.d.ts

@@ -0,0 +1,8 @@
+import type { TypedFunction } from '../core/function/typed.js';
+interface HasNumericValueDependencies {
+    typed: TypedFunction;
+    isNumeric: (x: unknown) => boolean;
+}
+export declare const createHasNumericValue: import("../utils/factory.js").FactoryFunction<HasNumericValueDependencies, unknown>;
+export {};
+//# sourceMappingURL=hasNumericValue.d.ts.map

package/dist/utils/hasNumericValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasNumericValue.d.ts","sourceRoot":"","sources":["../../src/utils/hasNumericValue.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG/D,UAAU,2BAA2B;IACnC,KAAK,EAAE,aAAa,CAAC;IACrB,SAAS,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC;CACpC;AAKD,eAAO,MAAM,qBAAqB,qFA8CjC,CAAC"}