@danielsimonjr/mathts-functions 0.2.2 → 0.2.4

package/dist/utils/number.d.ts

@@ -0,0 +1,314 @@
+/**
+ * Split value representation with sign, coefficients, and exponent
+ */
+export interface SplitValue {
+    sign: '+' | '-' | '';
+    coefficients: number[];
+    exponent: number;
+}
+/**
+ * Configuration for number type handling
+ */
+export interface NumberTypeConfig {
+    number: 'number' | 'BigNumber' | 'bigint' | 'Fraction';
+    numberFallback: 'number' | 'BigNumber';
+}
+/**
+ * Format options for number formatting
+ */
+export interface FormatOptions {
+    notation?: 'auto' | 'exponential' | 'fixed' | 'engineering' | 'bin' | 'oct' | 'hex';
+    precision?: number;
+    wordSize?: number;
+    lowerExp?: number;
+    upperExp?: number;
+}
+/**
+ * Normalized format options
+ */
+export interface NormalizedFormatOptions {
+    notation: 'auto' | 'exponential' | 'fixed' | 'engineering' | 'bin' | 'oct' | 'hex';
+    precision: number | undefined;
+    wordSize: number | undefined;
+}
+/**
+ * Check if a number is integer
+ * @param value The value to check
+ * @return true if value is an integer
+ */
+export declare function isInteger(value: number | boolean): boolean;
+/**
+ * Ensure the number type is compatible with the provided value.
+ * If not, return 'number' instead.
+ *
+ * For example:
+ *
+ *     safeNumberType('2.3', { number: 'bigint', numberFallback: 'number' })
+ *
+ * will return 'number' and not 'bigint' because trying to create a bigint with
+ * value 2.3 would throw an exception.
+ *
+ * @param numberStr The number as a string
+ * @param config    Configuration with number type preferences
+ * @returns The safe number type to use
+ */
+export declare function safeNumberType(numberStr: string, config: NumberTypeConfig): 'number' | 'BigNumber' | 'bigint' | 'Fraction';
+/**
+ * Calculate the sign of a number
+ * @param x The number
+ * @returns 1 for positive, -1 for negative, 0 for zero
+ */
+export declare const sign: (x: number) => number;
+/**
+ * Calculate the base-2 logarithm of a number
+ * @param x The number
+ * @returns The base-2 logarithm
+ */
+export declare const log2: (x: number) => number;
+/**
+ * Calculate the base-10 logarithm of a number
+ * @param x The number
+ * @returns The base-10 logarithm
+ */
+export declare const log10: (x: number) => number;
+/**
+ * Calculate the natural logarithm of a number + 1
+ * @param x The number
+ * @returns ln(x + 1)
+ */
+export declare const log1p: (x: number) => number;
+/**
+ * Calculate cubic root for a number
+ *
+ * Code from es6-shim.js:
+ *   https://github.com/paulmillr/es6-shim/blob/master/es6-shim.js#L1564-L1577
+ *
+ * @param x The number
+ * @returns The cubic root of x
+ */
+export declare const cbrt: (x: number) => number;
+/**
+ * Calculates exponentiation minus 1
+ * @param x The exponent
+ * @return exp(x) - 1
+ */
+export declare const expm1: (x: number) => number;
+/**
+ * Check if x^y is 0 due to infinity
+ * @param x The base
+ * @param y The exponent
+ * @returns true if x^y is 0 due to infinity
+ */
+export declare function isPowZeroAtInfinity(x: number, y: number): boolean;
+/**
+ * Convert a number 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'
+ *                         'engineering'    Always use engineering notation.
+ *                                          For example '123.4e+0' and '14.0e+6'
+ *                         'auto' (default) Regular number notation for numbers
+ *                                          having an absolute value between
+ *                                          `lowerExp` and `upperExp` 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,
+ *                                          not rounding any digits.
+ *                     {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(12.071, {notation: 'fixed'})                // '12'
+ *    format(2.3,    {notation: 'fixed', precision: 2})  // '2.30'
+ *    format(52.8,   {notation: 'exponential'})          // '5.28e+1'
+ *    format(12345678, {notation: 'engineering'})        // '12.345678e+6'
+ *
+ * @param value   The number to format
+ * @param options Optional formatting options or custom formatter function or precision
+ * @return The formatted value
+ */
+export declare function format(value: number, options?: FormatOptions | ((value: number) => string) | number): string;
+/**
+ * Normalize format options into an object:
+ *   {
+ *     notation: string,
+ *     precision: number | undefined,
+ *     wordSize: number | undefined
+ *   }
+ * @param options The input options
+ * @returns Normalized format options
+ */
+export declare function normalizeFormatOptions(options?: FormatOptions | number): NormalizedFormatOptions;
+/**
+ * Split a number into sign, coefficients, and exponent
+ * @param value The number or string to split
+ * @return Object containing sign, coefficients, and exponent
+ */
+export declare function splitNumber(value: number | string): SplitValue;
+/**
+ * Format a number in engineering notation. Like '1.23e+6', '2.3e+0', '3.500e-3'
+ * @param value     The number or string to format
+ * @param precision Optional number of significant figures to return
+ * @returns The formatted string
+ */
+export declare function toEngineering(value: number | string, precision?: number): string;
+/**
+ * Format a number with fixed notation.
+ * @param value     The number or string to format
+ * @param precision Optional number of decimals after the decimal point
+ * @returns The formatted string
+ */
+export declare function toFixed(value: number | string, precision?: number): string;
+/**
+ * Format a number in exponential notation. Like '1.23e+5', '2.3e+0', '3.500e-3'
+ * @param value     The number or string to format
+ * @param precision Number of digits in formatted output
+ * @returns The formatted string
+ */
+export declare function toExponential(value: number | string, precision?: number): string;
+/**
+ * Format a number with a certain precision
+ * @param value     The number or string to format
+ * @param precision Optional number of digits
+ * @param options   Optional formatting options (lowerExp, upperExp)
+ * @return The formatted string
+ */
+export declare function toPrecision(value: number | string, precision?: number, options?: FormatOptions): string;
+/**
+ * Round the number of digits of a number
+ * @param split     A value split with .splitNumber(value)
+ * @param precision A positive integer
+ * @return Object containing sign, coefficients, and exponent with rounded digits
+ */
+export declare function roundDigits(split: SplitValue, precision?: number): SplitValue;
+/**
+ * Count the number of significant digits of a number.
+ *
+ * For example:
+ *   2.34 returns 3
+ *   0.0034 returns 2
+ *   120.5e+30 returns 4
+ *
+ * @param value The number
+ * @return Number of significant digits
+ */
+export declare function digits(value: number): number;
+/**
+ * Compares two floating point numbers.
+ * @param a      First value to compare
+ * @param b      Second value to compare
+ * @param relTol The relative tolerance, indicating the maximum allowed difference relative to the larger absolute value. Must be greater than 0.
+ * @param absTol The minimum absolute tolerance, useful for comparisons near zero. Must be at least 0.
+ * @return 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-8);            // true
+ * nearlyEqual(1.000000002, 1.0, 0);               // false
+ * nearlyEqual(1.0, 1.009, undefined, 0.01);       // true
+ * nearlyEqual(0.000000001, 0.0, undefined, 1e-8); // true
+ */
+export declare function nearlyEqual(a: number, b: number, relTol?: number, absTol?: number): boolean;
+/**
+ * Calculate the hyperbolic arccos of a number
+ * @param x The number
+ * @return The hyperbolic arccosine
+ */
+export declare const acosh: (x: number) => number;
+/**
+ * Calculate the hyperbolic arcsine of a number
+ * @param x The number
+ * @return The hyperbolic arcsine
+ */
+export declare const asinh: (x: number) => number;
+/**
+ * Calculate the hyperbolic arctangent of a number
+ * @param x The number
+ * @return The hyperbolic arctangent
+ */
+export declare const atanh: (x: number) => number;
+/**
+ * Calculate the hyperbolic cosine of a number
+ * @param x The number
+ * @returns The hyperbolic cosine
+ */
+export declare const cosh: (x: number) => number;
+/**
+ * Calculate the hyperbolic sine of a number
+ * @param x The number
+ * @returns The hyperbolic sine
+ */
+export declare const sinh: (x: number) => number;
+/**
+ * Calculate the hyperbolic tangent of a number
+ * @param x The number
+ * @returns The hyperbolic tangent
+ */
+export declare const tanh: (x: number) => number;
+/**
+ * Returns a value with the magnitude of x and the sign of y.
+ * @param x The value providing the magnitude
+ * @param y The value providing the sign
+ * @returns Value with magnitude of x and sign of y
+ */
+export declare function copysign(x: number, y: number): number;
+//# sourceMappingURL=number.d.ts.map

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

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

package/dist/utils/numeric.d.ts

@@ -0,0 +1,10 @@
+type NumericValue = string | number | bigint | unknown;
+type NumericOutput = number | bigint | unknown;
+interface NumericDependencies {
+    number: (x: NumericValue) => number;
+    bignumber?: (x: NumericValue) => unknown;
+    fraction?: (x: NumericValue) => unknown;
+}
+export declare const createNumeric: import("../utils/factory.js").FactoryFunction<NumericDependencies, (value: NumericValue, outputType?: string, check?: unknown) => NumericOutput>;
+export {};
+//# sourceMappingURL=numeric.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"numeric.d.ts","sourceRoot":"","sources":["../../src/utils/numeric.ts"],"names":[],"mappings":"AAKA,KAAK,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AACvD,KAAK,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAE/C,UAAU,mBAAmB;IAC3B,MAAM,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,MAAM,CAAC;IACpC,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC;IACzC,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC;CACzC;AAKD,eAAO,MAAM,aAAa,6EAkDb,YAAY,eACP,MAAM,UACV,OAAO,KACd,aAAa,CAkCnB,CAAC"}

package/dist/utils/object.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Clone an object
+ *
+ *     clone(x)
+ *
+ * Can clone any primitive type, array, and object.
+ * If x has a function clone, this function will be invoked to clone the object.
+ *
+ * @param {*} x
+ * @return {*} clone
+ */
+export declare function clone<T>(x: T): T;
+/**
+ * Apply map to all properties of an object
+ * @param {Object} object
+ * @param {function} callback
+ * @return {Object} Returns a copy of the object with mapped properties
+ */
+export declare function mapObject<T, U>(object: Record<string, T>, callback: (value: T) => U): Record<string, U>;
+/**
+ * Extend object a with the properties of object b
+ * @param {Object} a
+ * @param {Object} b
+ * @return {Object} a
+ */
+export declare function extend<T extends Record<string, unknown>, U extends Record<string, unknown>>(a: T, b: U): T & U;
+/**
+ * Deep extend an object a with the properties of object b
+ * @param {Object} a
+ * @param {Object} b
+ * @returns {Object}
+ */
+export declare function deepExtend<T>(a: T, b: unknown): T;
+/**
+ * Deep test equality of all fields in two pairs of arrays or objects.
+ * Compares values and functions strictly (ie. 2 is not the same as '2').
+ * @param {Array | Object} a
+ * @param {Array | Object} b
+ * @returns {boolean}
+ */
+export declare function deepStrictEqual(a: unknown, b: unknown): boolean;
+/**
+ * Recursively flatten a nested object.
+ * @param {Object} nestedObject
+ * @return {Object} Returns the flattened object
+ */
+export declare function deepFlatten(nestedObject: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Test whether the current JavaScript engine supports Object.defineProperty
+ * @returns {boolean} returns true if supported
+ */
+export declare function canDefineProperty(): boolean;
+/**
+ * Attach a lazy loading property to a constant.
+ * The given function `fn` is called once when the property is first requested.
+ *
+ * @param {Object} object         Object where to add the property
+ * @param {string} prop           Property name
+ * @param {Function} valueResolver Function returning the property value. Called
+ *                                without arguments.
+ */
+export declare function lazy<T>(object: Record<string, unknown>, prop: string, valueResolver: () => T): void;
+/**
+ * Traverse a path into an object.
+ * When a namespace is missing, it will be created
+ * @param {Object} object
+ * @param {string | string[]} path   A dot separated string like 'name.space'
+ * @return {Object} Returns the object at the end of the path
+ */
+export declare function traverse(object: Record<string, unknown>, path: string | string[]): Record<string, unknown>;
+/**
+ * A safe hasOwnProperty
+ * @param {Object} object
+ * @param {string} property
+ */
+export declare function hasOwnProperty(object: unknown, property: string): boolean;
+/**
+ * Test whether an object is a factory. a factory has fields:
+ *
+ * - factory: function (type: Object, config: Object, load: function, typed: function [, math: Object])   (required)
+ * - name: string (optional)
+ * - path: string    A dot separated path (optional)
+ * - math: boolean   If true (false by default), the math namespace is passed
+ *                   as fifth argument of the factory function
+ *
+ * @param {*} object
+ * @returns {boolean}
+ */
+export declare function isLegacyFactory(object: unknown): boolean;
+/**
+ * Get a nested property from an object
+ * @param {Object} object
+ * @param {string | string[]} path
+ * @returns {Object}
+ */
+export declare function get(object: Record<string, unknown>, path: string | string[]): unknown;
+/**
+ * Set a nested property in an object
+ * Mutates the object itself
+ * If the path doesn't exist, it will be created
+ * @param {Object} object
+ * @param {string | string[]} path
+ * @param {*} value
+ * @returns {Object}
+ */
+export declare function set<T extends Record<string, unknown>>(object: T, path: string | string[], value: unknown): T;
+/**
+ * Create an object composed of the picked object properties
+ * @param {Object} object
+ * @param {string[]} properties
+ * @param {function} [transform] Optional value to transform a value when picking it
+ * @return {Object}
+ */
+export declare function pick(object: Record<string, unknown>, properties: string[], transform?: (value: unknown, key: string) => unknown): Record<string, unknown>;
+/**
+ * Shallow version of pick, creating an object composed of the picked object properties
+ * but not for nested properties
+ * @param {Object} object
+ * @param {string[]} properties
+ * @return {Object}
+ */
+export declare function pickShallow(object: Record<string, unknown>, properties: string[]): Record<string, unknown>;
+//# sourceMappingURL=object.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["../../src/utils/object.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAwChC;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,CAAC,EAC5B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,EACzB,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,GACxB,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAUnB;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACzF,CAAC,EAAE,CAAC,EACJ,CAAC,EAAE,CAAC,GACH,CAAC,GAAG,CAAC,CAOP;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,OAAO,GAAG,CAAC,CA8DjD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO,CA0C/D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAM1F;AAmBD;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAc3C;AAED;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,IAAI,EAAE,MAAM,EACZ,aAAa,EAAE,MAAM,CAAC,GACrB,IAAI,CAqBN;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GACtB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAkBzB;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEzE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAIxD;AAED;;;;;GAKG;AACH,wBAAgB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAiBrF;AAED;;;;;;;;GAQG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnD,MAAM,EAAE,CAAC,EACT,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EACvB,KAAK,EAAE,OAAO,GACb,CAAC,CAyBH;AAED;;;;;;GAMG;AACH,wBAAgB,IAAI,CAClB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,UAAU,EAAE,MAAM,EAAE,EACpB,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,GACnD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAYzB;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,UAAU,EAAE,MAAM,EAAE,GACnB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAYzB"}

package/dist/utils/optimizeCallback.d.ts

@@ -0,0 +1,22 @@
+interface Matrix<T = unknown> {
+    isMatrix: boolean;
+    size(): number[];
+    get(index: number[]): T;
+    dataType?: string;
+}
+interface OptimizedCallback<T = unknown, R = unknown> {
+    isUnary: boolean;
+    fn: (...args: T[]) => R;
+}
+/**
+ * Simplifies a callback function by reducing its complexity and potentially improving its performance.
+ *
+ * @param callback - The original callback function to simplify.
+ * @param array - The array that will be used with the callback function.
+ * @param name - The name of the function that is using the callback.
+ * @param isUnary - If true, the callback function is unary and will be optimized as such.
+ * @returns Returns a simplified version of the callback function.
+ */
+export declare function optimizeCallback<T, R>(callback: Function, array: T[] | Matrix<T>, name: string, isUnary?: boolean): OptimizedCallback<unknown, R>;
+export {};
+//# sourceMappingURL=optimizeCallback.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"optimizeCallback.d.ts","sourceRoot":"","sources":["../../src/utils/optimizeCallback.ts"],"names":[],"mappings":"AAKA,UAAU,MAAM,CAAC,CAAC,GAAG,OAAO;IAC1B,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,IAAI,MAAM,EAAE,CAAC;IACjB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAQD,UAAU,iBAAiB,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO;IAClD,OAAO,EAAE,OAAO,CAAC;IACjB,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;CACzB;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EACnC,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,EACtB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,GAChB,iBAAiB,CAAC,OAAO,EAAE,CAAC,CAAC,CA0E/B"}

package/dist/utils/parseNumber.d.ts

@@ -0,0 +1,2 @@
+export declare const createParseNumberWithConfig: import("./factory.js").FactoryFunction<any, (str: string) => number | any>;
+//# sourceMappingURL=parseNumber.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parseNumber.d.ts","sourceRoot":"","sources":["../../src/utils/parseNumber.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,2BAA2B,oDAyBA,MAAM,KAAG,MAAM,GAAG,GAAG,CAmD5D,CAAC"}

package/dist/utils/print.d.ts

@@ -0,0 +1,2 @@
+export declare const printTemplate: RegExp;
+//# sourceMappingURL=print.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"print.d.ts","sourceRoot":"","sources":["../../src/utils/print.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,QAAgB,CAAC"}

package/dist/utils/product.d.ts

@@ -0,0 +1,6 @@
+/** @param {number} i
+ *  @param {number} n
+ *  @returns {number} product of i to n
+ */
+export declare function product(i: any, n: any): any;
+//# sourceMappingURL=product.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"product.d.ts","sourceRoot":"","sources":["../../src/utils/product.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,GAAG,CAW3C"}

package/dist/utils/string.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Check if a text ends with a certain string.
+ * @param {string} text
+ * @param {string} search
+ */
+export declare function endsWith(text: any, search: any): boolean;
+/**
+ * Format a value of any type into a string.
+ *
+ * Usage:
+ *     math.format(value)
+ *     math.format(value, precision)
+ *     math.format(value, options)
+ *
+ * When value is a function:
+ *
+ * - When the function has a property `syntax`, it returns this
+ *   syntax description.
+ * - In other cases, a string `'function'` is returned.
+ *
+ * When `value` is an Object:
+ *
+ * - When the object contains a property `format` being a function, this
+ *   function is invoked as `value.format(options)` and the result is returned.
+ * - When the object has its own `toString` method, this method is invoked
+ *   and the result is returned.
+ * - In other cases the function will loop over all object properties and
+ *   return JSON object notation like '{"a": 2, "b": 3}'.
+ *
+ * Example usage:
+ *     math.format(2/7)                // '0.2857142857142857'
+ *     math.format(math.pi, 3)         // '3.14'
+ *     math.format(new Complex(2, 3))  // '2 + 3i'
+ *     math.format('hello')            // '"hello"'
+ *
+ * @param {*} value             Value to be stringified
+ * @param {Object | number | Function} [options]
+ *     Formatting options. See src/utils/number.js:format for a
+ *     description of the available options controlling number output.
+ *     This generic "format" also supports the option property `truncate: NN`
+ *     giving the maximum number NN of characters to return (if there would
+ *     have been more, they are deleted and replaced by an ellipsis).
+ * @return {string} str
+ */
+export declare function format(value: any, options: any): string;
+/**
+ * Stringify a value into a string enclosed in double quotes.
+ * Unescaped double quotes and backslashes inside the value are escaped.
+ * @param {*} value
+ * @return {string}
+ */
+export declare function stringify(value: any): string;
+/**
+ * Escape special HTML characters
+ * @param {*} value
+ * @return {string}
+ */
+export declare function escape(value: any): string;
+/**
+ * Compare two strings
+ * @param {string} x
+ * @param {string} y
+ * @returns {number}
+ */
+export declare function compareText(x: any, y: any): 0 | 1 | -1;
+//# sourceMappingURL=string.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/utils/string.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,WAI9C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,GAAG,MAAM,CAWvD;AAyDD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,GAAG,UAWnC;AAYD;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,GAAG,UAUhC;AA6CD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,cAoBzC"}

package/dist/utils/switch.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Transpose a matrix
+ * @param {Array} mat
+ * @returns {Array} ret
+ * @private
+ */
+export declare function _switch(mat: any): any[];
+//# sourceMappingURL=switch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"switch.d.ts","sourceRoot":"","sources":["../../src/utils/switch.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,GAAG,SAa/B"}

package/dist/utils/typeOf.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"typeOf.d.ts","sourceRoot":"","sources":["../../src/utils/typeOf.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG/D,UAAU,kBAAkB;IAC1B,KAAK,EAAE,aAAa,CAAC;CACtB;AAKD,eAAO,MAAM,YAAY,4EA6DxB,CAAC"}