@danielsimonjr/mathts-functions 0.69.2 → 0.70.1

package/dist/numeric-equivalence.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Sampling comparison of two scalar trees.
+ *
+ * Samples random points in a caller-supplied domain, evaluates both trees with
+ * {@link compileScalar}, and compares with {@link nearlyEqual} from core.
+ * **Numerical agreement alone never proves symbolic equivalence.** A
+ * `consistent` verdict is evidence, not proof.
+ *
+ * @packageDocumentation
+ */
+import type { ScalarNode } from '@danielsimonjr/mathts-expression';
+import type { SeededRng } from '@danielsimonjr/mathts-core';
+/**
+ * Thrown for invalid options (bad domain, tolerances, RNG, samples, and so on).
+ * Does not wrap {@link ScalarEvalError} from bad trees.
+ *
+ * @example
+ * ```ts
+ * import { numericallyEquivalent, NumericEquivalenceError, scalar } from '@danielsimonjr/mathts-functions';
+ * import { createSeededRng } from '@danielsimonjr/mathts-core';
+ * try {
+ *   numericallyEquivalent(scalar.symbol('x'), scalar.symbol('x'), {
+ *     domain: {},
+ *     rng: createSeededRng(0),
+ *   });
+ * } catch (e) {
+ *   e instanceof NumericEquivalenceError; // true — missing domain for x
+ * }
+ * ```
+ */
+export declare class NumericEquivalenceError extends Error {
+    constructor(message: string);
+}
+/**
+ * Options for {@link numericallyEquivalent}.
+ *
+ * @example
+ * ```ts
+ * import type { NumericEquivalenceOptions } from '@danielsimonjr/mathts-functions';
+ * import { createSeededRng } from '@danielsimonjr/mathts-core';
+ * const opts: NumericEquivalenceOptions = {
+ *   domain: { x: [0, 1] },
+ *   rng: createSeededRng(42),
+ * };
+ * ```
+ */
+export interface NumericEquivalenceOptions {
+    /** Per-symbol sampling box `[lo, hi)` (half-open unless `lo === hi`). */
+    readonly domain: Readonly<Record<string, readonly [number, number]>>;
+    /** Sample count when there is at least one free symbol (default 64). */
+    readonly samples?: number;
+    /** Required stream; the implementation calls `next()` only. */
+    readonly rng: SeededRng;
+    /** Relative tolerance (default `1e-9`). */
+    readonly relTol?: number;
+    /** Absolute tolerance (default `1e-12`). */
+    readonly absTol?: number;
+    /** When true, test whether `a` and `b` agree up to a single scale factor. */
+    readonly upToConstant?: boolean;
+    /** Symbol names to sample log-uniformly on a strictly positive box. */
+    readonly logUniform?: readonly string[];
+}
+/**
+ * Result of {@link numericallyEquivalent}.
+ *
+ * @example
+ * ```ts
+ * import { numericallyEquivalent, scalar } from '@danielsimonjr/mathts-functions';
+ * import { createSeededRng } from '@danielsimonjr/mathts-core';
+ * const r = numericallyEquivalent(scalar.number(1), scalar.number(1), {
+ *   domain: {},
+ *   rng: createSeededRng(0),
+ * });
+ * r.verdict; // 'consistent'
+ * ```
+ */
+export type NumericEquivalence = {
+    readonly verdict: 'consistent';
+    readonly samplesUsed: number;
+    readonly constant?: number;
+} | {
+    readonly verdict: 'counterexample';
+    readonly at: Readonly<Record<string, number>>;
+    readonly a: number;
+    readonly b: number;
+} | {
+    readonly verdict: 'inconclusive';
+    readonly reason: 'too-few-valid-samples';
+};
+/**
+ * Compare two scalar trees by random sampling in a domain.
+ *
+ * **Numerical agreement alone never proves symbolic equivalence.** A
+ * `consistent` verdict is evidence, not proof.
+ *
+ * @example
+ * ```ts
+ * import { numericallyEquivalent, scalar } from '@danielsimonjr/mathts-functions';
+ * import { createSeededRng } from '@danielsimonjr/mathts-core';
+ * const rng = createSeededRng(1);
+ * const lhs = scalar.op('+', [
+ *   scalar.op('^', [scalar.call('sin', scalar.symbol('x')), scalar.number(2)]),
+ *   scalar.op('^', [scalar.call('cos', scalar.symbol('x')), scalar.number(2)]),
+ * ]);
+ * const r = numericallyEquivalent(lhs, scalar.number(1), { domain: { x: [0, 1] }, rng });
+ * r.verdict === 'consistent'; // evidence only — not a proof of identity
+ * ```
+ */
+export declare function numericallyEquivalent(a: ScalarNode, b: ScalarNode, options: NumericEquivalenceOptions): NumericEquivalence;
+//# sourceMappingURL=numeric-equivalence.d.ts.map

package/dist/numeric-equivalence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeric-equivalence.d.ts","sourceRoot":"","sources":["../src/numeric-equivalence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AAEnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAO5D;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,yBAAyB;IACxC,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IACrE,wEAAwE;IACxE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,+DAA+D;IAC/D,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,2CAA2C;IAC3C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,4CAA4C;IAC5C,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,6EAA6E;IAC7E,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC,uEAAuE;IACvE,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACzC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,kBAAkB,GAC1B;IAAE,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5F;IACE,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IACnC,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC9C,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;CACpB,GACD;IAAE,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,uBAAuB,CAAA;CAAE,CAAC;AAmLnF;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CACnC,CAAC,EAAE,UAAU,EACb,CAAC,EAAE,UAAU,EACb,OAAO,EAAE,yBAAyB,GACjC,kBAAkB,CAuHpB"}

package/dist/numeric-extra.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"numeric-extra.d.ts","sourceRoot":"","sources":["../src/numeric-extra.ts"],"names":[],"mappings":"AAUA,KAAK,GAAG,GAAG,SAAS,MAAM,EAAE,GAAG,YAAY,CAAC;AAe5C,oEAAoE;AACpE,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;AACjE,wBAAgB,KAAK,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AAU9E,gFAAgF;AAChF,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;AAC3C,wBAAgB,OAAO,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;AAUxD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,GAAG,MAAM,CAQxC;AAED,+EAA+E;AAC/E,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,CAOxC;AAED,+EAA+E;AAC/E,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,CASxC;AAED,wCAAwC;AACxC,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,CASvC;AAED,wCAAwC;AACxC,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,CASvC;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,GAAG,MAAM,GAAG,MAAM,EAAE,CAsB3D"}
+{"version":3,"file":"numeric-extra.d.ts","sourceRoot":"","sources":["../src/numeric-extra.ts"],"names":[],"mappings":"AAUA,KAAK,GAAG,GAAG,SAAS,MAAM,EAAE,GAAG,YAAY,CAAC;AAe5C,oEAAoE;AACpE,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;AACjE,wBAAgB,KAAK,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AAU9E,gFAAgF;AAChF,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;AAC3C,wBAAgB,OAAO,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC;AAUxD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,GAAG,MAAM,CAQxC;AAED,+EAA+E;AAC/E,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,CAOxC;AAED,+EAA+E;AAC/E,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,CASxC;AAuBD,wCAAwC;AACxC,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,CAEvC;AAED,wCAAwC;AACxC,wBAAgB,MAAM,CAAC,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,CAEvC;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,GAAG,MAAM,GAAG,MAAM,EAAE,CAsB3D"}

package/dist/optimization-extra.d.ts

@@ -9,17 +9,32 @@ export interface OptimizeResult {
     converged: boolean;
 }
 /**
- * Nelder–Mead downhill-simplex minimization of `f: ℝⁿ → ℝ` from `x0`. Derivative-free.
- * Matches `scipy.optimize.minimize(method='Nelder-Mead')` to the requested tolerance.
+ * Options for {@link nelderMead}. Defaults use a relative simplex step and relative
+ * convergence test (SciPy-style); set `stepRule` / `tolRule` to `'absolute'` for the
+ * contract used by {@link minimize}.
  */
-export declare function nelderMead(f: (x: number[]) => number, x0: readonly number[], opts?: {
+export interface NelderMeadOptions {
     maxIter?: number;
     tol?: number;
     step?: number;
-}): OptimizeResult;
+    /** `'relative'` (default): perturb each coordinate by `step * x_j` (or `step` at zero). */
+    stepRule?: 'relative' | 'absolute';
+    /** `'relative'` (default): `|f_worst−f_best| ≤ tol·(|f_best|+tol)`. `'absolute'`: max vertex spread `< tol`. */
+    tolRule?: 'relative' | 'absolute';
+}
+/**
+ * Nelder–Mead downhill-simplex minimization of `f: ℝⁿ → ℝ` from `x0`. Derivative-free.
+ * Matches `scipy.optimize.minimize(method='Nelder-Mead')` to the requested tolerance.
+ *
+ * @example
+ * nelderMead((x) => (x[0] - 1) ** 2, [2]) // => { x: ~[1], … }; relative step 0.05 by default
+ */
+export declare function nelderMead(f: (x: number[]) => number, x0: readonly number[], opts?: NelderMeadOptions): OptimizeResult;
 /**
  * Gradient-descent minimization with optional backtracking line search. `grad` may
- * be supplied; otherwise a central-difference gradient is used.
+ * be supplied; otherwise a central-difference gradient with constant step `1e-6`
+ * is used ({@link centralDifferenceGradient}). That step is not the
+ * `max(1, |x_i|) · cbrt(eps)` step `bfgs` uses.
  */
 export declare function gradientDescent(f: (x: number[]) => number, x0: readonly number[], opts?: {
     grad?: (x: number[]) => number[];
@@ -37,13 +52,21 @@ export interface LMResult {
     iterations: number;
     converged: boolean;
 }
+/** Options for {@link levenbergMarquardt}. */
+export interface LMOptions {
+    maxIter?: number;
+    tol?: number;
+    /**
+     * Analytic Jacobian `J` with `J[i][j] = ∂r_i/∂x_j`. When omitted, a forward
+     * difference via {@link numericJacobian} is used (`h = 1e-7`).
+     */
+    jacobian?: (x: number[]) => number[][];
+}
 /**
  * Levenberg–Marquardt nonlinear least squares: minimize ½‖r(x)‖² for a vector
- * residual `r`. Numeric Jacobian; damped normal equations `(JᵀJ + λI)δ = Jᵀr`
+ * residual `r`. Uses `opts.jacobian` when provided, otherwise a forward-difference
+ * {@link numericJacobian} (`h = 1e-7`). Damped normal equations `(JᵀJ + λI)δ = Jᵀr`
  * solved via the matrix `inv`. Mirrors `scipy.optimize.least_squares(method='lm')`.
  */
-export declare function levenbergMarquardt(residual: (x: number[]) => number[], x0: readonly number[], opts?: {
-    maxIter?: number;
-    tol?: number;
-}): LMResult;
+export declare function levenbergMarquardt(residual: (x: number[]) => number[], x0: readonly number[], opts?: LMOptions): LMResult;
 //# sourceMappingURL=optimization-extra.d.ts.map

package/dist/optimization-extra.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"optimization-extra.d.ts","sourceRoot":"","sources":["../src/optimization-extra.ts"],"names":[],"mappings":"AAUA;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAC1B,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GAC3D,cAAc,CA8DhB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAC1B,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,IAAI,GAAE;IAAE,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GAC7F,cAAc,CA6BhB;AAED;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACvB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,EACnC,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GAC5C,QAAQ,CAwEV"}
+{"version":3,"file":"optimization-extra.d.ts","sourceRoot":"","sources":["../src/optimization-extra.ts"],"names":[],"mappings":"AAYA;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2FAA2F;IAC3F,QAAQ,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;IACnC,gHAAgH;IAChH,OAAO,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;CACnC;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAC1B,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,IAAI,GAAE,iBAAsB,GAC3B,cAAc,CA8EhB;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAC1B,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,IAAI,GAAE;IAAE,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GAC7F,cAAc,CAiBhB;AAED;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACvB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,8CAA8C;AAC9C,MAAM,WAAW,SAAS;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,EAAE,CAAC;CACxC;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,EACnC,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,IAAI,GAAE,SAAc,GACnB,QAAQ,CA4EV"}

package/dist/pareto-front.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Pareto hall of fame, log-loss scores, and model selection.
+ *
+ * `scoreFront` on the log scale walks the array in the order given. It does not sort
+ * and it does not drop rows. The first row scores `0`. Each later row with `loss > 0`
+ * scores `-Math.log(loss / previousLoss) / (complexity - previousComplexity)`.
+ * `loss <= 0` scores `+Infinity`. A zero complexity gap is IEEE division (`NaN` or an
+ * infinity); there is no special case. On the linear scale every score is `null`, and a
+ * zero loss does not become `+Infinity`. Any other `lossScale` throws `ParetoFrontError`.
+ *
+ * `selectFrontModel` defaults to `best` with factor `1.5`. `accuracy` is the minimum
+ * loss. `score` is the maximum score. `best` keeps rows with `loss <= 1.5 * min(loss)`
+ * and then takes the maximum score. If every score is `null`, `score` and `best` both
+ * fall back to `accuracy`. A mix of `null` and numeric scores throws. Ties: lower
+ * complexity, then the earlier input index. `NaN` is worse than every other score,
+ * including `-Infinity`. The return value is the same object as the chosen row.
+ *
+ * @packageDocumentation
+ */
+/**
+ * One hall-of-fame row. `item` is opaque and is not inspected.
+ *
+ * @example
+ * ```ts
+ * import { paretoFront } from '@danielsimonjr/mathts-functions';
+ * const front = paretoFront([
+ *   { loss: 0.5, complexity: 1, item: 'A' },
+ *   { loss: 0.1, complexity: 3, item: 'D-front' },
+ * ]);
+ * front.map((r) => r.item).join(','); // 'A,D-front'
+ * ```
+ */
+export interface FrontCandidate<T = unknown> {
+    readonly loss: number;
+    readonly complexity: number;
+    readonly item: T;
+}
+/**
+ * A {@link FrontCandidate} plus a log-scale score.
+ * `null` means the linear loss scale, where no score column is stored.
+ * A numeric score may be `+Infinity`, `-Infinity`, or `NaN` (a zero complexity gap).
+ *
+ * @example
+ * ```ts
+ * import { paretoFront, scoreFront } from '@danielsimonjr/mathts-functions';
+ * const front = paretoFront([{ loss: 0.5, complexity: 1, item: 'A' }]);
+ * scoreFront(front)[0]!.score; // 0 (log scale)
+ * scoreFront(front, { lossScale: 'linear' })[0]!.score; // null
+ * ```
+ */
+export interface ScoredCandidate<T = unknown> extends FrontCandidate<T> {
+    readonly score: number | null;
+}
+/**
+ * Thrown by {@link scoreFront} and {@link selectFrontModel} for an empty
+ * selection, a bad mode, a bad loss scale, or a mixed score column.
+ * `paretoFront` does not throw.
+ *
+ * @example
+ * ```ts
+ * import { selectFrontModel, ParetoFrontError } from '@danielsimonjr/mathts-functions';
+ * try {
+ *   selectFrontModel([]);
+ * } catch (e) {
+ *   e instanceof ParetoFrontError && e.message; // 'selectFrontModel: empty front'
+ * }
+ * ```
+ */
+export declare class ParetoFrontError extends Error {
+    constructor(message: string);
+}
+/**
+ * Hall of fame: one survivor per complexity, sorted by complexity ascending.
+ *
+ * A candidate whose `loss` or `complexity` is not finite (`NaN`, `+Infinity`,
+ * `-Infinity`) is dropped. That is a documented choice; callers are assumed
+ * to supply finite losses before scoring.
+ *
+ * Among finite candidates with `===` complexity (`-0` and `0` are the same),
+ * keep the strictly smallest loss. If two losses are equal, keep the earlier
+ * input. The survivor is then kept only when its loss is **strictly** smaller
+ * than the loss of every survivor of lower complexity. The lowest complexity
+ * is always kept. A simpler row is never removed because a more complex row
+ * is better.
+ *
+ * Returns a new array of new wrapper objects. `item` is the input reference.
+ * The input array and objects are not mutated.
+ *
+ * @example
+ * ```ts
+ * import { paretoFront } from '@danielsimonjr/mathts-functions';
+ * const front = paretoFront([
+ *   { loss: 0.5, complexity: 1, item: 'A' },
+ *   { loss: 0.5, complexity: 2, item: 'B-tie' },
+ *   { loss: 0.2, complexity: 4, item: 'C-dominated' },
+ *   { loss: 0.1, complexity: 3, item: 'D-front' },
+ *   { loss: Number.NaN, complexity: 1, item: 'drop' },
+ * ]);
+ * front.length; // 2 — non-finite row dropped; paretoFront never throws
+ * paretoFront([]).length; // 0
+ * ```
+ */
+export declare function paretoFront<T>(candidates: readonly FrontCandidate<T>[]): FrontCandidate<T>[];
+/**
+ * Log-loss scores, in array order. Does not sort and does not drop rows.
+ *
+ * `lossScale` defaults to `'log'`. On `'log'`, the first row scores `0`.
+ * Each later row scores `-Math.log(loss / previousLoss) / (complexity - previousComplexity)`
+ * when `loss > 0`. When `loss <= 0` (zero **or** negative), the score is `+Infinity`.
+ * A zero complexity gap is left to IEEE division (`NaN`, `+Infinity`, or `-Infinity`);
+ * there is no special case. On `'linear'`, every score is `null` and a zero loss
+ * does **not** become `+Infinity`.
+ *
+ * Any other `lossScale` throws `ParetoFrontError`
+ * (`scoreFront: lossScale must be 'log' or 'linear'`).
+ *
+ * @example
+ * ```ts
+ * import { paretoFront, scoreFront } from '@danielsimonjr/mathts-functions';
+ * const front = paretoFront([
+ *   { loss: 0.5, complexity: 1, item: 'A' },
+ *   { loss: 0.1, complexity: 3, item: 'D-front' },
+ * ]);
+ * scoreFront(front)[0]!.score; // 0
+ * scoreFront(front, { lossScale: 'linear' })[0]!.score; // null
+ * ```
+ */
+export declare function scoreFront<T>(front: readonly FrontCandidate<T>[], options?: {
+    lossScale?: 'log' | 'linear';
+}): ScoredCandidate<T>[];
+/**
+ * Pick a champion row from a scored front. `mode` defaults to `'best'`.
+ *
+ * `'accuracy'` is the minimum loss. `'score'` is the maximum score.
+ * `'best'` keeps rows with `loss <= bestLossFactor * min(loss)` (`bestLossFactor`
+ * defaults to `1.5`) and then takes the maximum score among them.
+ * If every `score` is `null`, `'score'` and `'best'` both fall back to `'accuracy'`
+ * (as when the score column is absent on the linear scale).
+ *
+ * Ties on the chosen metric: lower complexity wins, then the earlier input index.
+ * Score order treats `NaN` as worse than every other score, including `-Infinity`.
+ * Two `+Infinity` scores, or two `NaN` scores, tie and use complexity, then input order.
+ *
+ * Returns the **same object reference** as the chosen element of `scored`.
+ * Throws `ParetoFrontError` on an empty list, a non-finite loss or complexity,
+ * a non-finite `bestLossFactor`, a mode other than the three names, a mix of
+ * `null` and numeric scores, or a `'best'` filter that keeps no row.
+ *
+ * @example
+ * ```ts
+ * import { paretoFront, scoreFront, selectFrontModel } from '@danielsimonjr/mathts-functions';
+ * const front = paretoFront([
+ *   { loss: 0.5, complexity: 1, item: 'A' },
+ *   { loss: 0.1, complexity: 3, item: 'D-front' },
+ * ]);
+ * const scored = scoreFront(front);
+ * selectFrontModel(scored, 'accuracy').item; // 'D-front'
+ * selectFrontModel(scored, 'best').item; // 'D-front'
+ * selectFrontModel(scoreFront(front, { lossScale: 'linear' }), 'score').item; // null-score → accuracy fallback
+ * ```
+ */
+export declare function selectFrontModel<T>(scored: readonly ScoredCandidate<T>[], mode?: 'accuracy' | 'score' | 'best', options?: {
+    bestLossFactor?: number;
+}): ScoredCandidate<T>;
+//# sourceMappingURL=pareto-front.d.ts.map

package/dist/pareto-front.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pareto-front.d.ts","sourceRoot":"","sources":["../src/pareto-front.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC,GAAG,OAAO;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;CAClB;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IACrE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED;;;;;;;;;;;;;;GAcG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,UAAU,EAAE,SAAS,cAAc,CAAC,CAAC,CAAC,EAAE,GAAG,cAAc,CAAC,CAAC,CAAC,EAAE,CAqC5F;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAC1B,KAAK,EAAE,SAAS,cAAc,CAAC,CAAC,CAAC,EAAE,EACnC,OAAO,CAAC,EAAE;IAAE,SAAS,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAA;CAAE,GACzC,eAAe,CAAC,CAAC,CAAC,EAAE,CA0CtB;AA4DD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,MAAM,EAAE,SAAS,eAAe,CAAC,CAAC,CAAC,EAAE,EACrC,IAAI,CAAC,EAAE,UAAU,GAAG,OAAO,GAAG,MAAM,EACpC,OAAO,CAAC,EAAE;IAAE,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,GACpC,eAAe,CAAC,CAAC,CAAC,CA8CpB"}

package/dist/plain/number/probability.d.ts

@@ -17,10 +17,16 @@ export declare const lgammaG: number;
 export declare const lgammaN: number;
 export declare const lgammaSeries: number[];
 /**
- * Return the natural logarithm of the gamma function of `n`.
+ * Return the natural logarithm of the gamma function of `n` (mathjs real-only contract).
  *
- * A negative `n` gives NaN, and 0 gives Infinity. A non-finite `n` is returned unchanged.
- * Values below 0.5 use the reflection formula. Other values use the Lanczos method.
+ * Every negative `n` returns `NaN` (including non-positive integers — not `+Infinity`).
+ * `0` returns `Infinity`. Non-finite `n` is returned unchanged. Values in `(0, 0.5)` use
+ * Euler's reflection with bare `sin(πn)` (positive on that interval). Lanczos `g = 5`
+ * applies for `n ≥ 0.5`. This is **not** `log|Γ(n)|`.
+ *
+ * For `log|Γ(x)|` with `+Infinity` at non-positive integer poles and finite values at
+ * negative non-integers (e.g. `lgamma(-0.5) = ln(2√π)`), use the typed `lgamma` export
+ * (`_lgamma` in `wasm/special/scalars.ts`).
  */
 export declare function lgammaNumber(n: number): number;
 export declare namespace lgammaNumber {

package/dist/plain/number/probability.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probability.d.ts","sourceRoot":"","sources":["../../../src/plain/number/probability.ts"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAkD7C;yBAlDe,WAAW;;;AAuD3B,eAAO,MAAM,MAAM,EAAE,MAAkB,CAAC;AAExC,eAAO,MAAM,MAAM,EAAE,MAAM,EAM1B,CAAC;AAKF,eAAO,MAAM,SAAS,EAAE,MAA+B,CAAC;AAExD,eAAO,MAAM,OAAO,EAAE,MAAU,CAAC;AACjC,eAAO,MAAM,OAAO,EAAE,MAAU,CAAC;AAEjC,eAAO,MAAM,YAAY,EAAE,MAAM,EAGhC,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAuB9C;yBAvBe,YAAY"}
+{"version":3,"file":"probability.d.ts","sourceRoot":"","sources":["../../../src/plain/number/probability.ts"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAkD7C;yBAlDe,WAAW;;;AAuD3B,eAAO,MAAM,MAAM,EAAE,MAAkB,CAAC;AAExC,eAAO,MAAM,MAAM,EAAE,MAAM,EAM1B,CAAC;AAKF,eAAO,MAAM,SAAS,EAAE,MAA+B,CAAC;AAExD,eAAO,MAAM,OAAO,EAAE,MAAU,CAAC;AACjC,eAAO,MAAM,OAAO,EAAE,MAAU,CAAC;AAEjC,eAAO,MAAM,YAAY,EAAE,MAAM,EAGhC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAuB9C;yBAvBe,YAAY"}

package/dist/probability/bigint-binomial.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared BigNumber binomial product `C(total, choose)` via the short multiplicative
+ * loop (per-step `times` then `dividedBy` for exact integer arithmetic).
+ *
+ * Not exported from the package barrel; factory handlers keep their own validation.
+ */
+/** Structural BigNumber shape used by legacy mathjs factory handlers. */
+export interface BigNumberBinomialType {
+    constructor: BigNumberBinomialConstructor;
+    minus(n: BigNumberBinomialType | number): BigNumberBinomialType;
+    plus(n: BigNumberBinomialType | number): BigNumberBinomialType;
+    times(n: BigNumberBinomialType | number): BigNumberBinomialType;
+    dividedBy(n: BigNumberBinomialType | number): BigNumberBinomialType;
+    lt(n: BigNumberBinomialType | number): boolean;
+    gt(n: BigNumberBinomialType | number): boolean;
+    lte(n: BigNumberBinomialType | number): boolean;
+    gte(n: BigNumberBinomialType | number): boolean;
+    isInteger(): boolean;
+}
+interface BigNumberBinomialConstructor {
+    new (value: number): BigNumberBinomialType;
+}
+/** True when `n` is a non-negative integer BigNumber. */
+export declare function isPositiveInteger(n: BigNumberBinomialType): boolean;
+/**
+ * Binomial coefficient `C(total, choose)`. Same branch as the former factory
+ * loops: if `choose < total - choose`, iterate `i = 1 .. total - choose`
+ * multiplying `(choose + i) / i`; otherwise iterate `i = 1 .. choose`
+ * multiplying `(total - choose + i) / i`. Per-step order is
+ * `result.times(...).dividedBy(i)` so integer BigNumbers stay exact.
+ */
+export declare function binomialProductBigNumber<T extends BigNumberBinomialType>(total: T, choose: T): T;
+export {};
+//# sourceMappingURL=bigint-binomial.d.ts.map

package/dist/probability/bigint-binomial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigint-binomial.d.ts","sourceRoot":"","sources":["../../src/probability/bigint-binomial.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,yEAAyE;AACzE,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,4BAA4B,CAAC;IAC1C,KAAK,CAAC,CAAC,EAAE,qBAAqB,GAAG,MAAM,GAAG,qBAAqB,CAAC;IAChE,IAAI,CAAC,CAAC,EAAE,qBAAqB,GAAG,MAAM,GAAG,qBAAqB,CAAC;IAC/D,KAAK,CAAC,CAAC,EAAE,qBAAqB,GAAG,MAAM,GAAG,qBAAqB,CAAC;IAChE,SAAS,CAAC,CAAC,EAAE,qBAAqB,GAAG,MAAM,GAAG,qBAAqB,CAAC;IACpE,EAAE,CAAC,CAAC,EAAE,qBAAqB,GAAG,MAAM,GAAG,OAAO,CAAC;IAC/C,EAAE,CAAC,CAAC,EAAE,qBAAqB,GAAG,MAAM,GAAG,OAAO,CAAC;IAC/C,GAAG,CAAC,CAAC,EAAE,qBAAqB,GAAG,MAAM,GAAG,OAAO,CAAC;IAChD,GAAG,CAAC,CAAC,EAAE,qBAAqB,GAAG,MAAM,GAAG,OAAO,CAAC;IAChD,SAAS,IAAI,OAAO,CAAC;CACtB;AAED,UAAU,4BAA4B;IACpC,KAAK,KAAK,EAAE,MAAM,GAAG,qBAAqB,CAAC;CAC5C;AAED,yDAAyD;AACzD,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAEnE;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,qBAAqB,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAehG"}

package/dist/probability/combinations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"combinations.d.ts","sourceRoot":"","sources":["../../src/probability/combinations.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAoB/D,UAAU,wBAAwB;IAChC,KAAK,EAAE,aAAa,CAAC;CACtB;AAKD,eAAO,MAAM,kBAAkB,wFA6D9B,CAAC"}
+{"version":3,"file":"combinations.d.ts","sourceRoot":"","sources":["../../src/probability/combinations.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAO/D,UAAU,wBAAwB;IAChC,KAAK,EAAE,aAAa,CAAC;CACtB;AAKD,eAAO,MAAM,kBAAkB,wFA2C9B,CAAC"}

package/dist/probability/combinationsWithRep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"combinationsWithRep.d.ts","sourceRoot":"","sources":["../../src/probability/combinationsWithRep.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAmB/D,UAAU,+BAA+B;IACvC,KAAK,EAAE,aAAa,CAAC;CACtB;AAKD,eAAO,MAAM,yBAAyB,+FA8ErC,CAAC"}
+{"version":3,"file":"combinationsWithRep.d.ts","sourceRoot":"","sources":["../../src/probability/combinationsWithRep.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAO/D,UAAU,+BAA+B;IACvC,KAAK,EAAE,aAAa,CAAC;CACtB;AAKD,eAAO,MAAM,yBAAyB,+FAgErC,CAAC"}

package/dist/scalar-batch-parallel.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Evaluates many scalar trees over shared columns, on worker threads when asked to (M14).
+ *
+ * The caller opts in with `parallel`; without it every tree runs through
+ * {@link compileScalar} on the caller thread. With it, populations over at least
+ * {@link SCALAR_PARALLEL_MIN_ROWS} rows are compiled to tapes here and the tapes are
+ * evaluated by `scalar-batch.worker.js` through {@link WorkerPool.execute}, with a
+ * timeout that always applies. Both paths run the same `evaluateScalarTape`, so the values
+ * agree bit for bit.
+ *
+ * @packageDocumentation
+ */
+import type { ScalarNode } from '@danielsimonjr/mathts-expression';
+import { WorkerPool } from '@danielsimonjr/mathts-parallel';
+import { type CompileScalarOptions, type ScalarBatchResult } from './scalar-compile.js';
+/**
+ * Smallest row count that is sent to workers. 100 is the `n` from which the M3 tape beats
+ * the per-row interpreter in every run of the `scalar` benchmark (`docs/BENCHMARK_RESULTS.md`,
+ * section "`evaluateScalar` vs `compileScalar` (M3 batch evaluator) - 2026-10-25"). That
+ * table compares the two evaluators on the caller thread; it did not time a worker round
+ * trip, so this is the plan's floor for using the pool and not a measured break-even. The
+ * pool is opt-in, and nothing here claims a speed-up.
+ */
+export declare const SCALAR_PARALLEL_MIN_ROWS = 100;
+/** Timeout applied to every worker call when the caller does not choose one. */
+export declare const DEFAULT_SCALAR_PARALLEL_TIMEOUT_MS = 30000;
+/** URL of the built worker, a sibling of the module that contains this code. */
+export declare function resolveScalarBatchWorkerScript(): string;
+/** Starts the pool that {@link evaluateScalarPopulation} uses when it is not given one. */
+export declare function createScalarBatchPool(): WorkerPool;
+/** How to run a population on workers. */
+export interface ScalarPopulationParallelOptions {
+    /**
+     * Milliseconds a worker call may take, queueing included, before it is cancelled, the
+     * worker replaced and the evaluation rejected. Must be positive: `0` would switch the
+     * pool's timeout off. Default 30000.
+     */
+    readonly timeoutMs?: number;
+    /** A pool to use, which the caller owns and terminates. Default: one for the call. */
+    readonly pool?: Pick<WorkerPool, 'execute'>;
+}
+export interface ScalarPopulationEvalItem {
+    /** Returned unchanged with the result. */
+    readonly index: number;
+    readonly node: ScalarNode;
+    readonly params?: ArrayLike<number>;
+}
+export interface EvaluateScalarPopulationOptions extends CompileScalarOptions {
+    readonly columns: readonly Float64Array[];
+    readonly items: readonly ScalarPopulationEvalItem[];
+    readonly parallel?: ScalarPopulationParallelOptions;
+}
+export interface ScalarPopulationEvalResult {
+    readonly index: number;
+    readonly batch: ScalarBatchResult;
+}
+/** Positive, finite timeout, or a `RangeError`: a zero would silently disable the guard. */
+export declare function resolveParallelTimeout(timeoutMs: number | undefined): number;
+/**
+ * Evaluates every item over `columns`, in the order given.
+ *
+ * Without `parallel`, or with fewer than {@link SCALAR_PARALLEL_MIN_ROWS} rows, each tree
+ * runs on the caller thread and no pool is touched. Otherwise the trees are compiled here,
+ * split into consecutive chunks, evaluated by the workers, and put back in item order by
+ * position. A pool that was not passed in is created for the call and terminated after it.
+ *
+ * @throws {RangeError} `parallel.timeoutMs` is not a positive finite number.
+ * @throws A worker error, a timeout, or a tree that cannot be compiled.
+ */
+export declare function evaluateScalarPopulation(options: EvaluateScalarPopulationOptions): Promise<ScalarPopulationEvalResult[]>;
+//# sourceMappingURL=scalar-batch-parallel.d.ts.map

package/dist/scalar-batch-parallel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalar-batch-parallel.d.ts","sourceRoot":"","sources":["../src/scalar-batch-parallel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAC5D,OAAO,EAGL,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EACvB,MAAM,qBAAqB,CAAC;AAQ7B;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAE5C,gFAAgF;AAChF,eAAO,MAAM,kCAAkC,QAAS,CAAC;AAEzD,gFAAgF;AAChF,wBAAgB,8BAA8B,IAAI,MAAM,CAEvD;AAED,2FAA2F;AAC3F,wBAAgB,qBAAqB,IAAI,UAAU,CAElD;AAED,0CAA0C;AAC1C,MAAM,WAAW,+BAA+B;IAC9C;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,sFAAsF;IACtF,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;CAC7C;AAED,MAAM,WAAW,wBAAwB;IACvC,0CAA0C;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;CACrC;AAED,MAAM,WAAW,+BAAgC,SAAQ,oBAAoB;IAC3E,QAAQ,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,SAAS,wBAAwB,EAAE,CAAC;IACpD,QAAQ,CAAC,QAAQ,CAAC,EAAE,+BAA+B,CAAC;CACrD;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;CACnC;AAED,4FAA4F;AAC5F,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAM5E;AAqGD;;;;;;;;;;GAUG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,+BAA+B,GACvC,OAAO,CAAC,0BAA0B,EAAE,CAAC,CAsBvC"}