@danielsimonjr/mathts-functions 0.42.0 → 0.43.0

package/dist/utils/map.d.ts

@@ -1,106 +1,33 @@
 /**
- * A map facade on a bare object.
- *
- * The small number of methods needed to implement a scope,
- * forwarding on to the SafeProperty functions. Over time, the codebase
- * will stop using this method, as all objects will be Maps, rather than
- * more security prone objects.
- */
-/**
- * The iterator type `Map` itself declares, derived from the installed TS lib
- * rather than hard-coded: older libs say `IterableIterator<[K, V]>`, TS >= 5.6
- * says `MapIterator<[K, V]>` (which additionally requires `[Symbol.dispose]`).
- * Deriving it keeps `implements Map<K, V>` honest on every TS version.
- */
-type MapEntryIterator<K, V> = ReturnType<Map<K, V>[typeof Symbol.iterator]>;
-export declare class ObjectWrappingMap<K = string, V = unknown> implements Map<K, V> {
-    wrappedObject: Record<string, V>;
-    readonly [Symbol.toStringTag]: string;
-    constructor(object: Record<string, V>);
-    /**
-     * Declared as a real method rather than assigned in the constructor through a
-     * cast. The old form satisfied the runtime but never appeared in the emitted
-     * type, so `implements Map<K, V>` was a lie that only surfaced downstream:
-     * consumers compiling with `skipLibCheck: false` got TS2420 ("incorrectly
-     * implements interface 'Map'... '[Symbol.iterator]' is missing").
-     */
-    [Symbol.iterator](): MapEntryIterator<K, V>;
-    keys(): IterableIterator<K>;
-    get(key: K): V | undefined;
-    set(key: K, value: V): this;
-    has(key: K): boolean;
-    entries(): IterableIterator<[K, V]>;
-    values(): IterableIterator<V>;
-    forEach(callback: (value: V, key: K, map: Map<K, V>) => void): void;
-    delete(key: K): boolean;
-    clear(): void;
-    get size(): number;
-}
-/**
- * Create a map with two partitions: a and b.
- * The set with bKeys determines which keys/values are read/written to map b,
- * all other values are read/written to map a
- *
- * For example:
- *
- *   const a = new Map()
- *   const b = new Map()
- *   const p = new PartitionedMap(a, b, new Set(['x', 'y']))
- *
- * In this case, values `x` and `y` are read/written to map `b`,
- * all other values are read/written to map `a`.
- */
-export declare class PartitionedMap<K = unknown, V = unknown> implements Map<K, V> {
-    a: Map<K, V>;
-    b: Map<K, V>;
-    bKeys: Set<K>;
-    readonly [Symbol.toStringTag]: string;
-    /**
-     * @param a - Primary map
-     * @param b - Secondary map
-     * @param bKeys - Set of keys that should be read/written to map b
-     */
-    constructor(a: Map<K, V>, b: Map<K, V>, bKeys: Set<K>);
-    /** See the note on `ObjectWrappingMap[Symbol.iterator]` — same fix. */
-    [Symbol.iterator](): MapEntryIterator<K, V>;
-    get(key: K): V | undefined;
-    set(key: K, value: V): this;
-    has(key: K): boolean;
-    keys(): IterableIterator<K>;
-    values(): IterableIterator<V>;
-    entries(): IterableIterator<[K, V]>;
-    forEach(callback: (value: V, key: K, map: Map<K, V>) => void): void;
-    delete(key: K): boolean;
-    clear(): void;
-    get size(): number;
-}
-/**
- * Creates an empty map, or whatever your platform's polyfill is.
- *
- * @returns an empty Map or Map like object.
- */
-export declare function createEmptyMap<K = unknown, V = unknown>(): Map<K, V>;
-/**
- * Creates a Map from the given object.
- *
- * @param mapOrObject - Map or object to convert
- * @returns Map instance
- */
-export declare function createMap<K = unknown, V = unknown>(mapOrObject?: Map<K, V> | Record<string, V> | null): Map<K, V>;
-/**
- * Copies the contents of key-value pairs from each `objects` in to `map`.
- *
- * Object is `objects` can be a `Map` or object.
- *
- * This is the `Map` analog to `Object.assign`.
- */
-export declare function assign<K = unknown, V = unknown>(map: Map<K, V>, ...objects: (Map<K, V> | Record<string, V> | null | undefined)[]): Map<K, V>;
-/**
- * Returns `true` if `object` is an {@link ObjectWrappingMap}.
- *
- * Defined here, next to the class it guards, so `is.ts` need not import
- * `map.ts` — that import was the sole edge closing the `is`/`map` cycle.
+ * A `Map`-facade over a bare object (`ObjectWrappingMap`), a two-partition
+ * `Map` (`PartitionedMap`), and small `Map`/object interop helpers
+ * (`createMap`/`createEmptyMap`/`assign`).
+ *
+ * Consolidated onto core: the implementation lives once in
+ * `@danielsimonjr/mathts-core/internal` (see `core/src/map.ts` and the
+ * `project-all-libraries-build-on-core` principle). Thin re-export so existing
+ * `../utils/map.js` imports keep working while the single source of truth lives
+ * in core. Proven equivalent to the prior local copy (and to `expression`'s copy)
+ * via a fast-check property harness before the redirect — see
+ * `functions/tests/dedup-bucketB-equivalence.test.ts`.
+ *
+ * TWO divergences were found and reconciled onto core (see `core/src/map.ts`'s
+ * header for the full writeup):
+ *  1. `[Symbol.iterator]` — THIS package's prior copy already declared it as a
+ *     real, correctly-typed class method (the fix `expression`'s copy was
+ *     missing); core's canonical adopts this package's version unchanged.
+ *  2. `createEmptyMap`/`createMap`'s generic default (`K = unknown` here vs.
+ *     `K = string` in `expression`) — a compile-time-only inference default with
+ *     no behavioral difference; reconciled to core's `K = string` (matching
+ *     `ObjectWrappingMap`/`PartitionedMap`'s own `K = string` default already
+ *     shared by both packages). No call site in this package relies on the
+ *     `K = unknown` default (checked: `functions/src/algebra/simplify.ts`'s
+ *     `createEmptyMap()` call is assigned to an explicitly `Map<string, unknown>`-
+ *     typed parameter default, which `Map<string, unknown>` satisfies directly).
+ *
+ * This package never had `toObject` (unlike `expression`'s prior copy, consumed
+ * by its `Parser.ts`), so it is intentionally not re-exported here — this shim
+ * preserves exactly the original export surface.
  */
-export declare function isObjectWrappingMap(object: unknown): object is ObjectWrappingMap;
-export {};
+export { ObjectWrappingMap, PartitionedMap, createEmptyMap, createMap, assignMap as assign, isObjectWrappingMap, } from '@danielsimonjr/mathts-core/internal';
 //# sourceMappingURL=map.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/utils/map.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/utils/map.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,cAAc,EACd,SAAS,EACT,SAAS,IAAI,MAAM,EACnB,mBAAmB,GACpB,MAAM,qCAAqC,CAAC"}

package/dist/utils/string.d.ts

@@ -1,64 +1,20 @@
-import { type FormatOptions } from './number.js';
 /**
- * Formatting options accepted by the generic `format` helper. Extends the
- * numeric {@link FormatOptions} with the string-level `truncate` and the
- * fraction rendering mode, or is a precision number, or a custom formatter.
- */
-export type GeneralFormatOptions = number | ((value: unknown) => string) | (FormatOptions & {
-    truncate?: number;
-    fraction?: 'ratio' | 'decimal';
-});
-/**
- * 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:
+ * Generic-value string formatting (`format`, `stringify`, `compareText`).
  *
- * - 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}'.
+ * Consolidated onto core: the implementations live once in
+ * `@danielsimonjr/mathts-core/internal` (see `number.ts`/`object.ts` and the
+ * `project-all-libraries-build-on-core` principle). Thin re-export so existing
+ * `../utils/string.js` imports keep working while the single source of truth
+ * lives in core. Proven equivalent to the prior local copy (and to `expression`'s
+ * copy) via a fast-check property harness before the redirect — see
+ * `functions/tests/dedup-bucketB-equivalence.test.ts`.
  *
- * 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: unknown, options?: unknown): 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: unknown): string;
-/**
- * Compare two strings
- * @param {string} x
- * @param {string} y
- * @returns {number}
+ * NOTE: core exports the generic `format` here as `formatGeneric` (its `number.ts`
+ * already exports a `format` for plain numbers from the same `internal.ts` barrel,
+ * so an unaliased re-export would collide); re-exported here under the original
+ * local name `format`. This package never had `escape`/`endsWith` in this file
+ * (unlike `expression`'s prior copy), so they are intentionally not re-exported
+ * here — this shim preserves exactly the original export surface.
  */
-export declare function compareText(x: unknown, y: unknown): number;
+export { formatGeneric as format, stringify, compareText, type GeneralFormatOptions, } from '@danielsimonjr/mathts-core/internal';
 //# sourceMappingURL=string.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/utils/string.ts"],"names":[],"mappings":"AACA,OAAO,EAA0B,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAGzE;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAC5B,MAAM,GACN,CAAC,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC,GAC5B,CAAC,aAAa,GAAG;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAChC,CAAC,CAAC;AASP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,CAShE;AA2DD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAWhD;AAwDD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAoB1D"}
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/utils/string.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EACL,aAAa,IAAI,MAAM,EACvB,SAAS,EACT,WAAW,EACX,KAAK,oBAAoB,GAC1B,MAAM,qCAAqC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielsimonjr/mathts-functions",
-  "version": "0.42.0",
+  "version": "0.43.0",
   "description": "Mathematical functions for MathTS - arithmetic, algebra, trigonometry, statistics, and more",
   "author": "Daniel Simon Jr.",
   "license": "MIT",
@@ -34,11 +34,11 @@
     "build:prod": "tsup src/index.ts --format esm --clean --minify --treeshake"
   },
   "dependencies": {
-    "@danielsimonjr/mathts-core": "^0.10.0",
-    "@danielsimonjr/mathts-expression": "^0.6.4",
+    "@danielsimonjr/mathts-core": "^0.11.0",
+    "@danielsimonjr/mathts-expression": "^0.6.5",
     "@danielsimonjr/mathts-gpu": "^0.2.0",
-    "@danielsimonjr/mathts-matrix": "^0.6.0",
-    "@danielsimonjr/mathts-parallel": "^0.6.0",
+    "@danielsimonjr/mathts-matrix": "^0.6.1",
+    "@danielsimonjr/mathts-parallel": "^0.6.1",
     "bignumber.js": "^9.1.2",
     "complex.js": "^2.2.5",
     "decimal.js": "^10.4.3",

package/dist/error/MathjsError.d.ts

@@ -1,13 +0,0 @@
-/**
- * Custom error type for Mathjs errors
- * @extends Error
- */
-export declare class MathjsError extends Error {
-    isMathjsError: true;
-    /**
-     * Create a MathjsError
-     * @param message  Error message
-     */
-    constructor(message: string);
-}
-//# sourceMappingURL=MathjsError.d.ts.map

package/dist/error/MathjsError.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MathjsError.d.ts","sourceRoot":"","sources":["../../src/error/MathjsError.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,WAAY,SAAQ,KAAK;IACpC,aAAa,EAAG,IAAI,CAAU;IAE9B;;;OAGG;gBACS,OAAO,EAAE,MAAM;CAY5B"}

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

@@ -1,136 +0,0 @@
-/**
- * Structural contract for the BigNumber values handled by this formatter.
- * Captures exactly the methods/properties used here. The configured BigNumber
- * implementation (e.g. decimal.js) provides these; the project's `BigNumber`
- * type alias points at a minimal local Decimal that does not declare them all,
- * so we model the runtime contract explicitly.
- */
-interface BigNumberValue {
-    e: number;
-    constructor: new (value: number | string) => BigNumberValue;
-    isFinite(): boolean;
-    isNaN(): boolean;
-    isZero(): boolean;
-    isInteger(): boolean;
-    gt(other: number | BigNumberValue): boolean;
-    greaterThan(other: number | BigNumberValue): boolean;
-    lessThan(other: number | BigNumberValue): boolean;
-    add(other: number | BigNumberValue): BigNumberValue;
-    sub(other: number | BigNumberValue): BigNumberValue;
-    mul(other: number | BigNumberValue): BigNumberValue;
-    pow(exp: number | BigNumberValue): BigNumberValue;
-    toNumber(): number;
-    toFixed(places?: number): string;
-    toExponential(places?: number): string;
-    toPrecision(sd?: number): string;
-    toSignificantDigits(sd?: number): BigNumberValue;
-    toBinary(): string;
-    toOctal(): string;
-    toHexadecimal(): string;
-}
-/**
- * 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: unknown, options?: unknown): string;
-/**
- * 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: BigNumberValue, precision?: number): 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: BigNumberValue, precision?: number): string;
-/**
- * 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: BigNumberValue, precision?: number): string;
-export {};
-//# sourceMappingURL=formatter.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../../src/utils/bignumber/formatter.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,UAAU,cAAc;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,KAAK,KAAK,EAAE,MAAM,GAAG,MAAM,KAAK,cAAc,CAAC;IAC5D,QAAQ,IAAI,OAAO,CAAC;IACpB,KAAK,IAAI,OAAO,CAAC;IACjB,MAAM,IAAI,OAAO,CAAC;IAClB,SAAS,IAAI,OAAO,CAAC;IACrB,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,OAAO,CAAC;IAC5C,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,OAAO,CAAC;IACrD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,OAAO,CAAC;IAClD,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,cAAc,CAAC;IACpD,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,cAAc,CAAC;IACpD,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,cAAc,CAAC;IACpD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,cAAc,CAAC;IAClD,QAAQ,IAAI,MAAM,CAAC;IACnB,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACjC,aAAa,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvC,WAAW,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACjC,mBAAmB,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,cAAc,CAAC;IACjD,QAAQ,IAAI,MAAM,CAAC;IACnB,OAAO,IAAI,MAAM,CAAC;IAClB,aAAa,IAAI,MAAM,CAAC;CACzB;AA2CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,CA0EhE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAe/E;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAM/E;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAEzE"}