@danielsimonjr/mathts-functions 0.41.0 → 0.43.0

package/dist/utils/collection.d.ts

@@ -1,67 +1,15 @@
-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.
+ * Cold array/Matrix-aware collection utilities (`deepMap`/`deepForEach` with
+ * Matrix-or-array dispatch, dimensional `reduce`, sparse-matrix `scatter`).
  *
- * @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 {};
+ * Consolidated onto core: the implementation lives once in
+ * `@danielsimonjr/mathts-core/internal` (see `core/src/collection.ts` and the
+ * `project-all-libraries-build-on-core` principle). Thin re-export so existing
+ * `../utils/collection.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 — the two were already functionally IDENTICAL, differing only in comments
+ * and one redundant cast) via a fast-check property harness before the redirect —
+ * see `functions/tests/dedup-bucketB-equivalence.test.ts`.
+ */
+export { containsCollections, deepForEach, deepMap, reduce, scatter, } from '@danielsimonjr/mathts-core/internal';
 //# sourceMappingURL=collection.d.ts.map

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

@@ -1 +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,CA2DN"}
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../src/utils/collection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,EACL,mBAAmB,EACnB,WAAW,EACX,OAAO,EACP,MAAM,EACN,OAAO,GACR,MAAM,qCAAqC,CAAC"}

package/dist/utils/factory.d.ts

@@ -1,3 +1,42 @@
+import { type LegacyFactory, type DependencyName, isFactory, assertDependencies, isOptionalDependency, stripOptionalNotation, sortFactories as coreSortFactories, create as coreCreate } from '@danielsimonjr/mathts-core/internal';
+/**
+ * Some of this file's helpers are consolidated onto core (see the re-exports at
+ * the bottom): `isFactory`, `assertDependencies`, `isOptionalDependency`,
+ * `stripOptionalNotation`, and the plain-data types `LegacyFactory`/`FactoryMeta`/
+ * `DependencyName` are byte-for-byte equivalent to
+ * `@danielsimonjr/mathts-core/internal`'s copies (proven via a fast-check property
+ * harness — see `functions/tests/dedup-bucketB-equivalence.test.ts`) and are
+ * re-exported from there.
+ *
+ * `factory`/`FactoryFunction`/`CreateFunction` remain DELIBERATELY KEPT LOCAL — NOT
+ * safe to redirect: `factory()`'s generic `CreateFunction<TDeps extends
+ * Record<string, unknown>, ...>` constraint (core's copy) rejects real call sites
+ * across this package (259+ activated mathjs-factory call sites in
+ * `functions/src/{arithmetic,algebra,...}`) whose destructured dependency objects
+ * are typed as plain interfaces without an index signature — confirmed
+ * empirically: redirecting it broke `tsc --noEmit` (the same failure mode
+ * reproduced first in `expression`, which has 46 call sites). This is exactly the
+ * constraint mismatch this package's own pre-existing
+ * `@typescript-eslint/no-explicit-any` comment on `CreateFunction`/`factory`
+ * documents — this package already worked around it with `any`; core's copy uses
+ * the stricter `Record<string, unknown>` and cannot be swapped in as-is.
+ *
+ * `sortFactories`/`create` are now ADOPTED from core (Bucket B, commit 2): they
+ * don't depend on `factory()`'s generic constraint (they only operate on already-
+ * constructed `FactoryFunction`/`LegacyFactory` values), so they aren't blocked by
+ * the divergence above. Core's `sortFactories` throws on ANY circular dependency —
+ * direct or indirect (see `core/tests/factory-sort.test.ts`) — which is a
+ * deliberate fix over this file's FORMER local copy, which only special-cased
+ * direct 2-cycles and otherwise silently broke longer cycles via a visited-set
+ * guard without throwing (see `functions/tests/dedup-bucketB-equivalence.test.ts`'s
+ * former "PROVEN DIVERGENCE" block, now updated to reflect the adoption). Verified
+ * this package's real `factory()` call sites (all 251 of them) are never fed
+ * through `sortFactories`/`create` in production (both are otherwise-unused mathjs
+ * legacy machinery here — every real activated factory is wired by hand via
+ * `functions/src/factories/scope.ts` + `functions/src/factories/index.ts`, not a
+ * name-sorted DAG load), so there is no live dependency graph that could hit the
+ * stricter throw.
+ */
 /**
  * Type for a factory function that creates instances
  */
@@ -8,17 +47,6 @@ export interface FactoryFunction<_TDeps = unknown, TResult = unknown> {
     dependencies: string[];
     meta?: FactoryMeta;
 }
-/**
- * Type for legacy factory objects (old-style factories)
- */
-export interface LegacyFactory {
-    type?: string;
-    name: string;
-    factory: (...args: unknown[]) => unknown;
-    math?: boolean;
-    dependencies?: string[];
-    meta?: FactoryMeta;
-}
 /**
  * Meta information that can be attached to a factory
  */
@@ -36,10 +64,6 @@ export interface FactoryMeta {
      */
     [key: string]: unknown;
 }
-/**
- * Type for dependency names, which can be optional (prefixed with '?')
- */
-export type DependencyName = string;
 /**
  * Type for the create callback function
  */
@@ -71,42 +95,7 @@ export type CreateFunction<TDeps extends Record<string, any>, TResult> = (depend
  * @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, unknown>): Record<string, unknown>;
-/**
- * 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: unknown): 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, unknown>): 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;
+export { isFactory, assertDependencies, isOptionalDependency, stripOptionalNotation };
+export { coreSortFactories as sortFactories, coreCreate as create };
+export type { LegacyFactory, DependencyName };
 //# sourceMappingURL=factory.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/utils/factory.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,MAAM,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO;IAClE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;IAC1C,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,OAAO,EAAE,KAAK,OAAO,CAAC;IACzC,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,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC;AAEpC;;GAEG;AAEH,MAAM,MAAM,cAAc,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,IAAI,CACvE,YAAY,EAAE,KAAK,KAChB,OAAO,CAAC;AAEb;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,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,OAAO,CAAM,GAClC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAQzB;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,eAAe,CAM9D;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,cAAc,EAAE,EAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,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"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/utils/factory.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,SAAS,EACT,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EACrB,aAAa,IAAI,iBAAiB,EAClC,MAAM,IAAI,UAAU,EACrB,MAAM,qCAAqC,CAAC;AAE7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH;;GAEG;AACH,MAAM,WAAW,eAAe,CAAC,MAAM,GAAG,OAAO,EAAE,OAAO,GAAG,OAAO;IAClE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC;IAC1C,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,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,OAAO,CAAC;CACxB;AAED;;GAEG;AAEH,MAAM,MAAM,cAAc,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO,IAAI,CACvE,YAAY,EAAE,KAAK,KAChB,OAAO,CAAC;AAEb;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,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;AAMD,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,CAAC;AACtF,OAAO,EAAE,iBAAiB,IAAI,aAAa,EAAE,UAAU,IAAI,MAAM,EAAE,CAAC;AACpE,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,CAAC"}

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.41.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